Traditional Tools Used in Profiling a .NET Application
The tools that existed pre-.NET still can be used to profile some of the characteristics of a .NET application. A .NET application still needs memory and it still needs the services of the CPU on which it is running. These tools provide information about the usage of generic resources such as these. Before you look at the specific tools (such as .NET performance counters and a custom profiler API) that are available for .NET applications, you need to review what is and has been available for any application.
Obtaining a Snapshot of Memory Usage with memsnap
This tool provides a snapshot of memory (and some resource) usage. It comes as part of Visual Studio .NET in Microsoft Visual Studio .NETCommon7ToolsBinWinNT. If this utility is not in the directory specified, then you probably failed to install the Platform SDK (which is not installed by default). It is a command-line utility and it writes the snapshot to memsnap.log unless you specify a specific log file. Invoking memsnap with no arguments or -? gives this usage help output, as in Listing 20.1.
Listing 20.1. memsnap Usage
memsnap [-t] [-g] [-?] [<logfile>] memsnap logs system memory usage to <logfile> <logfile> = memsnap.log by default -t Add tagging information (time (GMT), date, machinename) -g Add GDI and USER resource counts -? Gets this message memsnap – Creates a memsnap.log file that contains a snap-shot of the memory usage. Each subsequent usage appends to the memsnap.log file. |
If you have a managed application running like ThreadPoolTest.exe of Chapter 14, “Delegates and Events,” the log file looks like Listing 20.2.
Listing 20.2. memsnap Output
If you start an instance of the DiningPhilosophers.exe application, look at memsnap:
Process ID Proc.Name Wrkng.Set PagedPool NonPgdPl Pagefile Commit HandlesThreads 0000B09C ThreadPoolTest. 14708736 46736 12232 6963200 6963200 443
If you start three instances of the DiningPhilosophers.exe applications, you see the following:
Process ID Proc.Name Wrkng.Set PagedPool NonPgdPl Pagefile Commit Handles
Because 20 threads should exist per application, this just confirms the limit that the ThreadPool places on the number of threads that it allocates, as discussed in Chapter 11, “Threading.” If you stop all of the applications and return back to just the small ThreadPoolTest.exe form, you see the following:
Process ID Proc.Name Wrkng.Set PagedPool NonPgdPl Pagefile Commit Handles
As you can see from the output, most of the threads have been returned to the pool, some of the memory has been reclaimed from the Pagefile, and the Working Set is somewhat smaller.
Obtaining Processor Usage Information with pstat
This function provides much of the same information as memsnap except that it also provides a dump of process-specific information including memory on standard output. This tool is located in the same place as memsnap (Microsoft Visual Studio.NETCommon7ToolsBinWinNT). The output is substantial, so you might want to invoke pstat like this:
pstat |more
or
pstat >pstat.log
The first bit of information that this utility prints is basic system information, as shown in Listing 20.3.
Listing 20.3. pstat Usage
Pstat version 0.3: memory: 261424 kb uptime: 0 1:10:09.603
PageFile: ??D:pagefile.sys
Current Size: 393216 kb Total Used: 34464 kb Peak Used 35384 kb
Memory: 261424K Avail: 48256K TotalWs: 245064K InRam Kernel: 3464K P:70456K
Commit: 217564K/ 103000K Limit: 632712K Peak: 251296K Pool N:10816K P:89728K
|
This shows how much RAM is available, how long the computer has been up, basic information about the PageFile that you have for your system, and system-wide memory information. In addition, a section is available where process-specific information is printed.
User Time Kernel Time Ws Faults Commit Pri Hnd Thd Pid Name . . . 0:00:06.489 0:00:00.500 14860 9201 8948 8 282 6 45212 ThreadPoolTest.
This is the same information as memsnap, with the exception that here you can see how much time was spent in kernel and user mode. A more detailed output is available for each of the processes. For the ThreadPoolTest.exe process, the output looks like Listing 20.4.
Listing 20.4. pstat Report of Thread Status for a Process
Detailed information is available about each of the six threads that is running in the process. You can see a thread ID, a priority, the number of context switches, the start address of the thread, how much time the thread has spent in user mode and kernel mode, and what the current state of the thread is. If you were to start the DiningPhilosophers application, you would see detail on more threads. At the end of the output from pstat is a detailed table of the drivers and system services that are loaded and running on the system.
Profiling Memory Usage with vadump
Also located in Microsoft Visual Studio .NETCommon7ToolsBinWinNT, vadump reports memory usage information about a particular process. To use this tool, you first must obtain the process ID of the process. You might not know that process ID, so you will have to use pview or the Task Manager to get the hex ID of each process. You can activate the Task Manager from the Start Toolbar by right-clicking on the toolbar and selecting Task Manager. After the Task Manager comes up, you can select the Processes tab to view the processes and the associated IDs. pview is a program found in Microsoft Visual Studio .NETCommon7ToolsBinWinNT. Start pview from a command line (assuming that you have the preceding path in your PATH environment variable). pview lists each process with its ID in parentheses. You then need to convert this hex version of the process ID to decimal. (You can use the calculator in Accessories to do this conversion.) Notice that Task Manager displays process IDs as decimal, so conversion is not necessary. The usage report for vadump is shown in Listing 20.5.
Listing 20.5. vadump Usage
If you invoke vadump with all of the defaults, you get output that is split into three sections. The first section is an address map for the process. It looks like Listing 20.6.
Listing 20.6. vadump Address Map
The next section describes how to obtain the memory that is associated with each DLL. Listing 20.7 shows a partial output of the vadump utility. Because you are using this tool to profile a .NET application, you can see how much memory each of the DLLs is responsible for. If the section under mscoree.dll includes some huge numbers, then you cannot fix this problem because the problem is with the CLR. Large memory usage in the main portion of the code (ThreadPoolTest) is something that you have a better chance of affecting.
Listing 20.7. vadump DLL Memory Usage
A summary report, as shown in Listing 20.8, offers important information about an application. Specifically, for this .NET application, you can see how much of a memory resource hog this application will be.
Listing 20.8. vadump Summary
If you add a flag to turn on verbose mode, you get an address map of where each of the DLLs associated with the process were loaded, as in Listing 20.9.
Listing 20.9. vadump Verbose
Listing 20.9 shows the output of vadump for the same ThreadPoolTest application. Notice that from the output of this tool, you can see not only what DLLs are loaded, but also where they are placed. You can immediately see that this is a managed (.NET) application. You can see DLLs such as mscoree.dll and system.windows.forms.dll loaded into the address space.
Like most other traditional tools, vadump mainly provides information about the process memory and how it is allocated and used.
Detailed Execution Profile of a .NET Application Using profile
profile is also located in Microsoft Visual Studio .NETCommon7ToolsBinWinNT. From the output of profile, you can obtain a count of the number of functions called in each DLL that is loaded as part of the process. The output of profile is somewhat cryptic, but it can be useful for low-level analysis of a running process.
Invoking profile like this
profile DiningPhilosophers.exe
leads to output like Listing 20.10.
Listing 20.10. profile Output
As you can see, the output is difficult to understand. The first number is the number of times that the function in the specified DLL was called. The second field gives the name of the DLL. The third field is either the total number of calls associated with this DLL (in which case it is “Total”), or it is the name of the function within the DLL that was called. The last field is the address of the function in the DLL. The problem with this output is that it does not list managed method calls.
Monitoring Page Faults with pfmon
This tool is also located in Microsoft Visual Studio .NETCommon7ToolsBinWinNT. Pfmon outputs information about the number of page faults that your process or application generates. One possible way to invoke this tool is as follows:
pfmon –n traceswitch.exe
With the -n switch, the tool outputs all of its information to a file pfmon.log. When this tool is used to monitor the page faults for a .NET application, traceswitch.exe (introduced in the last chapter), the log file looks like Listing 20.11.
Listing 20.11. pfmon Output
A page fault occurs when a thread addresses memory that is not in the main working-set. The page that contains the address is brought into the current working-set, and some pages might be removed from the current working set. The presence of many page faults indicates that the process is accessing a wide range of addresses that are probably not contiguous. If your process has many page faults, it is probably thrashing, a term indicating that a large portion of the time allocated to your application is spent paging memory to and from disk. When this occurs, performance decreases. A simple fix is to change your program to access memory in a more linear fashion.
Monitoring Process Timing, Memory, and Thread Count with pview
pview is located in Microsoft Visual Studio .NETCommon7ToolsBinWinNT. pview presents a graphical display of processes on your system. It provides all of the information available from the previous command-line tools, but in a dialog-type user interface. When you invoke pview.exe, you get a dialog box that looks like Figure 20.1. Notice that this figure highlights information about a .NET application, ThreadPoolTest.exe.
Figure 20.1. pview process view.
You can highlight each of the threads listed for each process and get the start address of the thread, the current address location of the thread, the number of context switches, and the priority. If you highlight a process and select the Memory Detail button, you will get a dialog box that looks like Figure 20.2.
Figure 20.2. pview memory detail.
This dialog box contains much information, but notice that the DLLs that would have specific interest for a managed process are shown in the drop-down list. pview incorporates much of the same information that is obtained from vadump and pstat into a compact graphical form.
Task Manager
The Task Manager is always available by right-clicking on the toolbar. On Windows 2000 machines, three tabs exist: Applications, Processes, and Performance. With Windows XP, a fourth tab titled Networking has been added. If you need to monitor network activity, the Networking tab can be useful. It shows a graphical view of network utilization. If your application uses the network heavily, the Network tab offers a quick check to see if the bottleneck in your program is the network. Figure 20.3 shows what the Task Manager looks like.
Figure 20.3. Monitoring a .NET application with Task Manager.
The Processes tab shows information about each process running on your system. By default, the process identifier, CPU usage, CPU time, memory usage, and thread count are displayed. However, as can be seen in Figure 20.4, other types of information can also be displayed. Depending on the information you need to gather about your application, you might be interested in some of this information. For example, if you are concerned that thread pooling is not working, you can turn on the option to list the number of threads in a process and see if the thread count goes too high.
Monitoring System-Wide Information with perfmtr
perfmtr is located in Microsoft Visual Studio .NETCommon7ToolsBinWinNT. perfmtr provides a console view of the processes running on your system. By default, invoking perfmtr like this:
perfmtr
The output is similar to Figure 20.5, which monitors the CPU usage for the system.
Figure 20.5. Monitoring system-wide CPU usage with perfmtr.
Other system-wide status information is available by entering the appropriate letter as indicated when the tool is first invoked. For example, “C” causes permtr to do a continuous dump of CPU usage, “V” provides a dump of virtual memory, and “H” causes file cache information to be monitored. See Figure 20.5 for all of the options, or invoke the tool on your own. Permtr provides system information, and it would only be useful in profiling an application if this information was used as a baseline.
Profiling the Profiler with exctrlst
This last tool leads us into the next section. exctrlst shows the performance counters that have been installed. This tool shows the tools that are available through the Performance Monitor. When you run this tool, you get a dialog box that looks like Figure 20.6.
Figure 20.6. Performance counter information.
With this tool, you can see which DLL is associated with each of the performance categories. You can use this information along with some of the tools outlined earlier to determine whether a significant bottleneck exists due to the profile process. If the performance counter caused the application to crash, you could either debug it (if it was your performance counter) or send the information to those responsible for the performance counter to help them diagnose the problem.
Although Exctrlst does not indicate the exact counters that are available, it does indicate that the Performance Monitor has been extended and additional counters are available. It also shows the counter range that is used.