Browse by Tags

Tagged Content List
  • Blog Post: The Garbage Collector Manages my Memory

    Profiling a .NET application with the Concurrency Visualizer in Visual Studio 11 Developer Preview has a less noisy Synchronization profile report than in Visual Studio 2010. The reason is because synchronizing with the thread driving garbage collection is now categorized as Memory Management. Without...
  • Blog Post: Performance Improvements for the Concurrency Visualizer

    Downloading Symbols As mentioned in http://blogs.msdn.com/b/visualizeparallel/archive/2011/09/19/how-can-visual-studio-11-developer-preview-visualize-the-behavior-of-a-multithreaded-application.aspx there are noticeable performance improvements to the Concurrency Visualizer in Visual Studio 11 Developer...
  • Blog Post: Profiling DirectX Activity

    In Visual Studio 11 Developer Preview the Concurrency Visualizer highlights the way the traced process makes use of DirectX. To see how Internet Explorer 9 makes use of the GPU give the HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\Main\TabProcGrowth registry key a value of 0. Internet Explorer...
  • Blog Post: I know I’m doing more File I/O than this

    One of the changes made to the Concurrency Visualizer in Visual Studio 11 Developer Preview is that it no longers shows all of the disk I/O activity for the System process in the disk I/O swim lanes. In Visual Studio 2010 the disk I/O swim lanes had I/O segments for all of the disk I/O for the process...
  • Blog Post: How Can Visual Studio 11 Developer Preview Visualize the Behavior of a Multithreaded Application

    Now that you’ve had a day or two to work with the latest build of Visual Studio 11 Developer Preview and the .Net Framework 4.5 Developer Preview, I’m positive that you’re at the point where you would like to visualize the behavior of your multithreaded application. Remembering how...
  • Blog Post: Processor Cache Misses are Reported as Execution

    When refactoring a serial application into a parallel application the minimum bar of acceptable performance is that the parallel application must run from beginning to end in less wall clock time than the serial application. If it doesn’t run faster, there’s no point in doing the refactoring...
  • Blog Post: Visualizing Concurrency on Production Systems

    As interesting as profiling applications on your development computer is, I’m sure you’ve wanted to see the behavior of applications when running in production systems. The ability to view remote traces with the Concurrency Visualizer first requires installing the Visual Studio 2010 profiler...
  • Blog Post: Using the Concurrency Visualizer to Pick the Best Way to Parallelize a Data Set

    In the application I am working on, there is a small array of objects (10 - 100 items) and a large array of objects (10,000 - 100,000). I want to know how close each object in the small array is to each object in the large array. Since calculating the value for each candidate item from the small array...
  • Blog Post: A TaskScheduler that Limits the Number of Threads

    I created an application which uses a Parallel.For loop to create some data and another Parallel.For loop to make comparisons in the data set. This process is repeated a hundred times, with each iteration having a slightly bigger data set. The data is small enough that it is contained in memory and each...
  • Blog Post: Concurrency Visualizer as a Microscope for Execution Dynamics

    This is the picture that Concurrency Visualizer team used on the title page of internal specs. It actually reveals how most of us think about our product: not as a profiler (though you can get decent sample profile from it by clicking the green “Execution” category in the legend), and not even as a performance...
  • Blog Post: Where is my stack?

    In an earlier post I explained why you may get stacks that do not look like what you were expecting when you have FPO optimizations, but even without FPO enabled there are some other scenarios that can cause your application stacks to look somehow “unexpected” in the Concurrency Visualizer...
  • Blog Post: Case Study: Parallelism and Memory Usage, VS2010 Tools to the Rescue!

    Hazim Shafi has written a very relevant case study illustrating how significantly memory usage patterns can affect speedups of parallel applications.  Have you ever parallelized an application only to find marginal (or no) speedup?  Perhaps this entry will explain why. 
  • Blog Post: Where is the Concurrency Visualizer?

    I noticed several instances of folks struggling to find the Concurrency Visualizer in Visual Studio 2010, only to find that the problem was system requirements.   I’ll shed some light on this here: The Concurrency Visualizer is only available in Visual Studio 2010 Premium and Ultimate The Concurrency...
  • Blog Post: Concurrency Visualizer Feature Grab Bag

    In this entry, I’ll dive deep into the following features of the Threads View in the Concurrency Visualizer : Thread Sorting Thread Hiding Visible Timeline Profile Interactivity Jumping to Code Thread Ready Connector Thread Sorting By default, threads are sorted by start time.  However, you can...
  • Blog Post: Using the Concurrency Visualizer to Understand and Optimize UI Responsiveness

    In UI programming, it’s easy to unwittingly make inefficient use of computing resources by blocking or executing long running tasks on the main thread rather than dispatching work to worker threads when advantageous.   It is good practice to dispatch any non-trivial, non-UI task to a thread pool...
  • Blog Post: Concurrency Visualizer High Speed Tour

    Whether you’re not very familiar with The Concurrency Visualizer, you’re bored and have 75 seconds to burn, or you’re interested to see me nervous in front of a camera, this 75 second video is a great use of your time (if I don’t say so myself).  It provides the fastest possible introduction to...
  • Blog Post: The Concurrency Visualizer Debuts with the Launch of VS2010!

    Visual Studio 2010 is finally here and those of us who worked on the Concurrency Visualizer are thrilled about its debut (in VS2010 Premium and Ultimate)! We truly hope that our hard work pays off for you, enabling you to solve your toughest parallel performance problems. I’d like to thank everyone who...
  • Blog Post: Mid-execution Profiling of a Multithreaded Process

    In this entry, I will describe how to capture a trace in the middle of a process’ execution for the Concurrency Visualizer, allowing you to visualize the multithreaded behavior of your application during that period of time.  This is accomplished by attaching to and detaching from the running process...
  • Blog Post: Technical Article: Optimizing Parallel Applications Using the Concurrency Visualizer

    Ever wonder how a spellchecker works? How about a parallel spellchecker implemented in PLINQ? Boby George and Pooja Nagpal from the Parallel Computing Platform team wrote this article , which outlines the steps to convert a LINQ implementation of a spellchecker to PLINQ.  It details numerous optimizations...
  • Blog Post: General-Purpose Computation on Graphics Hardware

    Those of you following the various parallel computing blogs from our team or who have played with Visual Studio 2010 have probably noticed a heavy focus on single box parallelism (and mostly on client machines). For a future version of Visual Studio we are exploring stronger investment for the...
  • Blog Post: Call stack gymnastics: Why is function Foo missing from my call stack?

    Sometimes you expect to see a specific function on the stacks collected by the Concurrency Visualizer but to your surprise it is not there. To understand why this can sometimes happen, we have to start with some basic information: Event Tracing for Windows (ETW) is the system wide tracing mechanism shipped...
  • Blog Post: Instantly Expanding Long Callstacks in the Concurrency Visualizer Reports

    Did you notice that reports frequently show pretty long stacks? E.g. in the picture below it is 12 frames deep, but sometimes it can be a hundred… and very frequently you need the deepest one to see what is going on. Are you supposed to click on “+” hundred times? Happily, there is a shortcut – asterisk...
  • Blog Post: Using the Concurrency Visualizer to Analyze MPI Communication Overheads

    The Message Passing Interface (MPI) is a popular API for developing message-passing based parallel applications on clusters. Microsoft has a Windows HPC Server product that includes an implementation of MPI, among other things (visit http://www.microsoft.com/hpc) . In this post, I’d like to demonstrate...
  • Blog Post: Tuning a Parallel LINQ File Search Application

    This post explores the performance issues that arise when using PLINQ to parallelize queries, and illustrates how the Concurrency Visualizer in Visual Studio 2010 can be a valuable tool in identifying performance bottlenecks and making efficient and profitable parallelization choices. The subject of...
  • Blog Post: Tuning a Parallel Ray Tracer in F#

    One of the samples that is included with the Parallel Programming Samples for .NET 4 is a simple Ray Tracer.  This ray tracer provides a nice visual way of seeing the benefits of .NET 4 parallelism features, as well as giving insights into the way work stealing happens under the hood.  The...
Page 1 of 2 (38 items) 12