The procedure is pretty convenient with Visual Studio 2010, since all you have to do is:

1. Log into the machine you wish to debug on (you can use TS). In my case let's use msl-1440087.
2. Make sure you can navigate to a share on the machine with the debugger installed (galaxy-dev for example).
3. Run the right version of msvsmon.exe from the share, for example, the 32 bit version, as follows:
   > "\\galaxy-dev\c$\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\Remote Debugger\x86\msvsmon.exe"
   
4. Go back to the machine that the debugger is installed on (galaxy-dev) and choose 'Tools -> Attach To Process...'
   
5. Enter the machine name where you started msvsmon.exe in the Qualifier section.
6. Select the process you wish to debug,
7. Choose the type of debugging - Native or Managed etc.
8. Select 'Attach'.

Debug as you usually would. Thanks to Gregg for writing a blog post reminding me how to do this. You might also be interested in his post about Remote Debugging without domain accounts.

Example Program

Here’s a very simple program I’ll use in this post.

using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Foo();
        }

        private static void Foo()
        {
            double d = 0;
            for (int i = 0; i < 100000000; ++i)
            {
                d += Math.Sqrt(i);
            }
            Console.WriteLine(d);
        }
    }
}

Why ‘Just My Code’?

Typically when profiling you are most interested in optimizing code that you either wrote or you have control over. Sure, sometimes there will be issues in the frameworks that you are using or in other binaries, but even then you often control the calls into those frameworks.  Just My Code or JMC is intended to filter the data that is displayed in profiler reports so that more of the code you control shows up in the reports and the reports are more manageable.

For example, the Call Tree after collecting sampling data for the simple program above, with JMC off, is shown below:

With the default JMC options, this reduces down to:

What is ‘My Code’?

There are two conditions for code being considered ‘My Code’ by the profiler and they are both at the Module level (Module Name column in the screenshots above). In the example above, this means the checks are made against the clr.dll, mscoreee.dll, mscoreei.dll and ConsoleApplication1.exe binaries.

Modules considered ‘My Code’:

1. the copyright string for the module does not contain ‘Microsoft’, OR:
2. the module name is the same as the module name generated by building any project in the currently open Solution in Visual Studio.
   

How do I turn JMC on or off?

You can temporarily toggle JMC on or off on the profiler Summary Page in the Notifications area using ‘Show All Code’ or ‘Hide All Code’ (shown in red below):

The default setting may be configured as discussed in the following section.

How do I configure JMC?

Use Tools –> Options –> Performance Tools –> General and set options in the ‘Just My Code’ section:

The default has JMC on, showing one level of non-user callee functions. In the example above with JMC on, this is why we see the call to COMDouble::Sqrt(dobule) showing up in the call tree.

It is also possible to show one-level of non-user code calling user code, which in the example above would add one level of the non-user code that calls main, as shown below:

Why is ‘Just My Code’ only available for sampling?

When you instrument binaries for profiling, you have already performed some level of JMC. Only binaries that you instrument and first-level calls into other binaries will show up in the instrumentation report, so JMC is not really necessary.

> VSPerfASPNetCmd.exe https://localhost
Microsoft (R) VSPerf ASP.NET Command, Version 10.0.0.0
Copyright (C) Microsoft Corporation. All rights reserved.

Error
VSP 7008: ASP.net exception: "The website metabase contains unexpected information or you do not have permission to access the metabase.  You must be a member of the Administrators group on the local computer to access the IIS metabase. Therefore, you cannot create or open a local IIS Web site.  If you have Read, Write, and Modify Permissions for the folder where the files are located, you can create a file system web site that points to the folder in order to proceed."

The information in the error is correct and it is worth checking to make sure that you are running from an elevated command prompt, but it does miss a common configuration issue. In order to query for information from the IIS metabase, certain IIS components need to be installed.

To check this in Windows 7:

1. Open ‘Control Panel\Programs\Programs and Features’ (or run ‘appwiz.cpl’).
2. Choose ‘Turn Windows features on or off’.
3. In the ‘Internet Information Services’ section, make sure that the following options are selected.

The non-default options include:

• IIS 6 Scripting Tools
• IIS 6 WMI Compatibility
• IIS Metabase and IIS 6 configuration compatibility
• ASP.NET,
• Windows Authentication

Probably the best way to introduce this feature is via an example. Let’s assume you have written a simple application as follows:

   1: using System;

   2: namespace TestApplication

   3: {

   4:     class Program

   5:     {

   6:         static void Main(string[] args)

   7:         {

   8:             BadStringConcat();

   9:         }

  10:  

  11:         private static void BadStringConcat()

  12:         {

  13:             string s = "Base ";

  14:             for (int i = 0; i < 10000; ++i)

  15:             {

  16:                 s += i.ToString();

  17:             }

  18:         }

  19:     }

  20: }

If you profile this application in Sampling Mode you’ll see an Action Link called ‘View Guidance’ on the Summary Page:

Clicking on this link brings up the Error List, which is where you would also see things like compiler errors and static code analysis warnings:

DA0001: System.String.Concat(.*) = 96.00; Consider using StringBuilder for string concatenations.

As you can see there is a 1 warning, which is DA0001, warning about excessive usage of String.Concat. The number 96.00 is the percentage of inclusive samples in this function.

Double-clicking on the warning in the Error List switches to the Function Details View. Navigating up one level of callers, we see that BadStringConcat is calling Concat (96% of Inclusive Samples) and doing some work itself (4%). The String.Concat call is not a direct call, but looking at the Function Code View you can see a ‘+=’ call on a string triggers the call.
 

The DA0001 rule suggests fixing the problem by changing the string concatenation to use a StringBuilder but I’ll leave that up to the reader. Instead, I’ll cover some of the other aspects of rules.

One of the more important questions is what to do if you wish to turn off a given rule (or even all rules)? The answer is to open up the ‘Tools/Options’ dialog and in the Performance section, navigate to the new ‘Rules’ subsection:

Here you can see that I’ve started searching by typing ‘st’ in the search box at the top. This dialog can be used to turn off rules (by clicking on the checkboxes on the left), or to change rule categories to ‘Warning’, ‘Information’ or ‘Error’. The only affect is to change how the rule is displayed in the Error List.

If you have a situation where you are sharing a profiler report (VSP file) with team members, sometimes it might be useful to let them know that a warning is not important or has already been considered. In this case you can right-click on the Error List and choose ‘Suppress Message’.

The rule warning is crossed out and you can choose to save the VSP file so that the next time it is opened, the suppression is shown:

That’s it for now. I plan on covering a little more about rules in a future post, including more details about the rules themselves, how you can tweak thresholds and even write your own rules.

Our goal was to show something simple and lightweight while profiling and to make a few simple operations possible. PIP in VS2010 is shown below:

Currently profiling. Pause profiling. Stop profiling or exit the application to generate a report.

The progress/spin control indicates that the UI is responding and there are two links:

• Pause profiling, which changes to ‘Resume profiling’ when clicked. This has the same effect as clicking on the ‘Pause profiling’ button in the Performance Explorer.
• Stop profiling, which kills the application and finishes profiling.

After profiling completes, PIP changes to show that we are about to open the report.

Preparing to open report… This might take a while if your symbol server is slow or not responding.

I’m going to use PeopleTrax application again, which you can download from CodeBox. I have a report which I collected earlier using the Sampling method of profiling, since the application appears to be CPU bound (at least on a single core).

In this report I take a look at the Hot Path and see that People.GetNames is calling two hot functions ‘StringReader.ReadLine()’ and ‘String.Trim()’.

I’d like to see where these expensive calls are in my code so I click on GetNames (shown in purple above) to bring up the new Function Details view.

There are a few things to note about this new view.

• The title at the top is for People.GetNames().
• There is a dropdown to switch between ‘Inclusive Samples %’ and ‘Inclusive Samples’
• There are some blue boxes showing callers and callees (I’ll cover this more later).
• The code is shown with hot lines and an annotated margin.

In the default view we would need to drag the splitter (shown in purple) to see all of the boxes. Instead, we can use the toolbar option to ‘Split Screen Vertically’, also highlighted in purple.

Now we can clearly see where the calls to ReadLine() and Trim() are in the code on the right-hand side. There is also a metrics table in the ‘Function Performance Details’ section and there are some related links.

At this point, let’s look at the blue boxes. The left-hand box shows the callers of this function. The height of the box represents the relative cost for the metric that is currently chosen (in this case Inclusive Samples). Since we have a single caller, it takes up the entire box.

On the right we have another blue box that contains several sections:

• Function Body (87 samples). The height of this box represents the relative number of samples in the body itself (Exclusive Samples).
• ReadLine (727 samples). This is the function with the most Inclusive Samples. Again, the height is proportional so it is also the biggest box.
• Trim (642 samples). The function with the second most Inclusive Samples. Slightly smaller height.
• Other functions with smaller sample counts.

Each of these boxes (aside from Function Body) is clickable, allowing navigation of the Caller/Callees.

Looking at the code I can’t see an easy way to simplify it and I don’t control either Trim() or ReadLine(), so now let’s navigate one level up in the callers by clicking on GetPeople.

Clicking causes us to navigate to the GetPeople Function Details view:

From the code on the right-hand side we can see that in the two highlighted calls to GetNames 89.2% of the samples are occurring. From the loop structure it seems like it would be a good idea to avoid making these GetNames calls inside the for loop. Followers of the PeopleTrax application will notice that this is the first optimization suggestion for this application – cache the GetNames calls in the constructor. The next step in this investigation would be to change the code, collect another profile and compare the reports, but I’ll leave that up to you.

NOTE: line-level information is only available for sample-profiling. Since this information is not available in Instrumentation mode, highlighting and margin annotation is also not available for Instrumentation mode.

I’ll describe a few features of the new summary page using the PeopleTrax application, which you can download from CodeBox. I won’t describe collecting the profiling data since this is already covered on MSDN. The summary page for a sample profiling run is shown below.

I’ll describe the individual pieces of the report below:

• The header shows the type of data collected (Sample, Instrumentation, etc.) and also how many samples were collected.
  
  
• The hot path is shown right on the front page.
   
  We can see straight away that the ReadLine() function is an interesting function to look at. Clicking on the hyperlink will take you directly to the Function Details page. There are also related views links to navigate directly to the ‘Call Tree’ and ‘Functions’ views.
  
• Functions that are doing the most individual work (have the highest Exclusive Samples) are listed with visual ‘sparklines’ (bar charts) to indicate relative importance.
  
  Clicking on the hyperlink for a function takes you directly to the Function Details page for that function.
  
• Notifications that change based on the state of the report are shown in a new ‘Notifications’ area. In the example below, clicking Show All Code will reanalyze the report with Just My Code turned off. ‘View Guidance’ will bring up the Error List to display guidance from the new Rules and Guidance profiler feature.
   
  
• Action links are shown in the ‘Report’ area and they do not depend on the state of the report. One useful link we added is ‘Toggle Full Screen’ which shows the report in full-screen mode.
  
  
• A chart of CPU usage (for sampling, although we also show contention data in Concurrency mode) enables filtering of the report data. Highlight a region on the chart and choose ‘Filter by selection’ to show data from only that period of time. For example, with the chart below it may be useful to filter between 16 and 24 seconds.
  
  
• At the top of the report above the header, we still have the profiler toolbar which is useful for navigating (see the left and right arrows and also the dropdown for jumping between views) and for executing some of the actions that are also listed on the Summary Page.
   

Hopefully these new features on the front page will make it quicker and easier than ever to diagnose your performance issues.

• You must have a Visual Studio Solution open in order to enable it.
• If you have a solution open, but do not have a launchable current performance session, Start Performance Analysis launches the Performance Wizard.
• If you have a solution open and have a launchable current performance session, Start Performance Analysis starts profiling.

Let’s use this new functionality to profile an application that I prepared earlier.

1. Open the solution with ‘Alt-F, J, Enter’:
    
2. Start Performance Analysis with ‘Alt-F2’, which brings up the wizard:
   
3.   Press ‘Enter’ to choose the default ‘CPU Sampling’ profiling method and move to the target selection page:
    
4. Press ‘Enter’ to select the only launchable project in the solution and move to final wizard page:
   
5. Press ‘Enter’ to finish the wizard and start profiling:
   
6. The report will open when profiling finishes:
    

If you wish to profile again, selecting Alt-F2 will start profiling with the Performance Session that was created after step #4.