Looking for:
Clr profiler.exe download |
- Clr profiler.exe download
- Clr profiler.exe download
When you notice memory issues cropping up in your. It allows you to take a peek under the hood of. NET applications and monitor the garbage collector heap. In the. NET Framework, memory management is supposed to be handled automatically by the system.
This allows you to concentrate on the important issues of application design and development. Unfortunately, this utopia has not been completely realized as memory issues still appear in.
NET-based applications. NET platform adopted the garbage collection approach used in Java. That is, the. NET system tracks all memory blocks allocated in an application. It knows when memory is allocated and what monitors it uses. The system also knows when it is no longer used and frees it up. The garbage collector handles these tasks, but it does not totally divorce you from understanding memory allocation.
Objects in. NET are allocated from an area of memory called the managed heap. The heap is described as managed because, after you ask it for memory, the garbage collector takes care of its cleanup. Garbage collection begins by assuming all objects are unnecessary until proven otherwise. An object proves that it is necessary essentially by its references, or who it is referenced by. If the object is necessary, it is not part of the garbage collection cycle.
On the other hand, if the object is not necessary, the object is flagged to be discarded. While garbage collection is an automatic process, you should still be aware of how memory is utilized in an application.
This allows you to decide if the application is properly using its memory and how the garbage collector is being utilized. This involves knowing the life of objects used to determine how often garbage collection is called in order for you to determine if the garbage collector is taxed.
Code profilers can help with this process by providing a peek at the inner workings of an application, allowing you to gain a better understanding of memory usage. There are plenty of commercial profiler tools available, but Microsoft provides a free one called the CLR Profiler. The download is comprised of a single installation program that places the tool on your system. In addition, extensive documentation is included. The CLR Profiler allows you to take a peek under the hood of a.
NET application and see what is happening as it runs. It also lets you monitor what is happening with the garbage collector heap. By installing the CLR Profiler, you can access the following information about an application:. The data used by the CLR Profiler is stored in self-contained log files. To illustrate how the two interfaces work together, suppose that a profiler is active and a notification for a managed to unmanaged code transition is received via the callback ICorProfilerCallback::ManagedToUnmanagedTransition.
In addition, suppose you want to find out on which managed thread the transition is occurring. The parameters of the callback don't provide that information.
Profiling under the CLR is enabled on a per-process basis. Here's an example of how to use these variables:. It is possible to have more than one profiler registered at the same time. Every profiler has to be previously registered and must provide a unique GUID. Also notice that it is possible to have different profilers enabled in different environments simultaneously. For more details on how to do this, see the Help section in recent releases of the.
The profiler must be implemented as an inproc COM server, which is basically a DLL mapped into the same address space as the process that is being profiled. This is why the profiler DLL needs to be previously registered. Subsequently, the CLR sends the very first notification to the newly created server, which is nothing but an ICorProfilerCallback::Initialize callback.
This is the point where the profiler has to specify which events it wants to monitor and get an ICorProfilerInfo interface pointer that it can use during the program's execution to acquire additional information, if needed. Limiting the number of events I want the profiler to monitor means I can build a simpler, specialized profiler and at the same time reduce the amount of CPU time that the CLR spends in sending notifications that I am not really interested in.
These fine points will become clearer in the following sections. At this point, you should have a clearer idea about what the. In the next section I'll present some interesting, real-life scenarios where CLR profiling would be a valuable asset in a developer's arsenal. There are numerous things that a CLR profiler can provide information about, as described in Figure 1. Depending on the type of the application and which aspect of the CLR operation you are interested in, a tool based on the.
In this case, the profiler needs to receive the enter-leave function events and transition events from the CLR and then organize them on a per-thread basis. This information can be used at the end of the execution for different purposes. For example, the profiler can produce a call graph or print information about managed exceptions or code transitions. The key to remember is that the profiler has to ensure thread safety when accessing its data members and its internal data structures, since the profiling API does not offer any guarantees.
You can use. One of the most powerful capabilities of the profiling API is the ability to modify the IL code of a managed method before the just-in-time JIT compiler compiles it. This scenario can be used for instrumentation of a managed application if the profiler inserts the appropriate hooks into every method.
The inserted code can be something as simple as increasing a counter or making a call to a native or even a managed function. In fact, this is the only point where a profiler is allowed to make calls into managed code.
In case you make a function call, you should pay attention to the calling convention because if there is stack corruption the JIT compiler can crash. A direct call into managed code from any other profiler callback, or when using any other mechanism, could result in a hang or crash of the execution engine, and therefore should be avoided.
One of the most interesting mechanisms of the CLR is the automatic disposal of dead object references, known as garbage collection GC. The profiler receives a notification not only when an object gets allocated, but also when a GC takes place. An interesting scenario would be to track how many objects get allocated per class and which objects are surviving every GC. In this way, the profiler is able to build an object graph during the program's execution. Managed exception handling is one of the most complicated mechanisms of the CLR, and.
Exceptions during the execution of a program are always time-consuming, and a profiler should be able to report them when they occur. The profiling API offers an extensive set of callbacks that depict in detail the search, unwind, and finally phases of the exception handling cycle. An interesting profiling scenario would monitor managed exceptions and provide additional information such as the Win32 thread that threw the exception, the function that was on the top of the stack, the arguments of that function, and the locals that were in scope at the point where the exception occurred.
Additional information could include the functions involved in the search, unwind, and finally phases. For more details on their usage, you should check the.
Remoting calls are time-consuming and sometimes it is very important to know when they are taking place while running an application. Important parameters to monitor in remoting include:. NET CLR Profiling Services can also be used to identify hot spots in your application—namely, where most of the execution time is spent.
As mentioned before, improving application performance is a key reason to use profiling. The first step of that process is to identify which part of the application is performing poorly and investigate how things can be done more efficiently.
An interesting profiling scenario would be to keep track of the execution time spent in every function and persist that information for later analysis. This task is not trivial since you need to consider the overhead caused by the profiling process, the time spent in the callees of a method, the time that the CLR has suspended a thread, and so on.
I'll discuss this scenario in the following sections of this article. Now let's go through a step-by-step tutorial on how to design a CLR profiler. Although I will use the example of the "Hotspots Profiler Tracker" that I've just described, there are some common design steps you need to consider regardless of the nature and functionality of the profiling tool you want to design. The design of a profiler could be broken into two steps. As I walk you through these design steps, I'll point out the pitfalls you may run across when building a profiler from scratch.
All the source code for my sample profiler is available at the link at the top of this article. With some minor modifications you can use my example to build your own special-purpose profiler.
My server is always in-process and I do not need to implement any logic for the LockServer method. The declaration for my class factory is shown in Figure 3 , and the implementation can be found in the classfactory.
The implementation of DllMain is shown in Figure 4. There are certain cases when the CLR is terminating and shutting down in a peculiar way and the profiler never receives the shutdown event. This situation can result in major leaking of the profiler resources that have been allocated during the execution of the managed application.
To avoid that pitfall, I detect the boundary conditions and send a pseudo-shutdown event to the profiler. In this way, the profiler can release the memory that was allocated and also flush its data to the output stream. The above mentioned condition can occur when an unmanaged client is making calls to a managed server. The CLR has no knowledge of the state in the unmanaged program and this causes an abrupt shutdown at the end of the execution. Another scenario of abnormal shutdown is when an application throws an unhandled exception that causes the CLR to terminate.
The full implementation of the above functions can be found in dllmain. The components I've discussed can be reused no matter what your profiler needs to monitor. The only thing you need to do is assign a new GUID to your profiler by redefining the following:. As I mentioned, each profiler has to fully implement the ICorProfilerCallback interface even if it is not using all the events. Therefore, I can further divide this step in two parts: the implementation of the callbacks that I don't need, and the implementation of the callbacks that contain the logic for the tool.
The first step is easy. All you need to do is provide a default handler for all the possible events that the profiler can receive. A good technique is to keep your ICorProfilerCallback implementation relatively simple and use a helper class as a placeholder for your profiler logic.
I have followed this technique here, so you will find all the logic associated with the profiler in ProfilerInfo. Remember that your ICorProfilerCallback has to implement the pseudo-shutdown method; you should also define and initialize a global pointer to your ICorProfilerCallback.
The implementation details are found in ProfilerCallback. The second step is the most interesting part of the design phase, and it includes the actual implementation of the tool. First, I decided how to accomplish my objective and which callbacks I needed to monitor. The fewer callbacks I monitor, the less overhead there is for the CLR, so an important part of the design is to choose the optimum set of callbacks.
In my case, the objective of the tool is to report execution times for every thread and for every managed function that was executed on that thread. During the execution of a managed application, I chose to monitor and calculate running time, profiler time, and suspended time per thread, while watching inclusive time, callee time, profiler time, and suspended time for each function executed on a thread.
The profiler time represents the amount of time that was added to the execution of the application because of the profiler. To find the pure execution time, you have to subtract it from the running time.
For every function, the profiler and suspended times are calculated when the function is on the top of the call stack for the specific thread. In brief, the tool needs to be able to keep track of the existing threads, the status of the threads suspended or running , and the current call-stack on a per-thread basis. The first objective can be accomplished easily by monitoring thread-related events. The second one is less self-explanatory and it requires monitoring suspend and resume events.
Finally, the third one is the most difficult to achieve. In order to successfully keep a call stack you need to disable inlining. As a result, you will get an accurate result of the time you are spending in each function without any "noise" from the inline functions that may be contained in the specific method. The next step is to enable enter-leave function events.
The profiler API allows you to specify the function pointers that will be invoked every time a method is entered or left. The enter-leave handlers are simply function pointers for increased speed and simplicity. Implementing the hooks for the enter-leave and tail-leave events is shown in Figure 5.
The actual functions used by the function hooks have to be static. Unfortunately, I am not finished yet. That was the self-evident part. The CLR notifies the profiler when a managed function starts and ends its execution. What about the time spent executing unmanaged code? The enter-leave notifications don't provide any information about unmanaged code. In order to properly update the call stack, I have to correctly identify enter and leave events for unmanaged functions.
My resources for that task are the transition callbacks that allow simulation of the desired events.
Comments
Post a Comment