Product - ProfileSharp

Key Features

On-demand, plug-n-play profiling
ProfileSharp can be turned on and off without the need to restart the target process repeatedly. It’s virtually like attaching and detaching the profiler. The Plug-n-Play kind! How this can help is that you can profile only the problematic part of your .NET code. This produces results in almost no time and you can focus on the key areas of your code. It also gives you the possibility to profile and analyze applications which need to have very less down-time like your web or application server.

No need for code recompilation/modification
The profile does not require you to recompile or re-write your .NET code. This not only brings down the performance and memory analysis time in your application considerably but you can also analyze what is happening inside the .NET applications/components that you may not have the code for e.g. 3rd party .NET components. Problem segregation is quick and effortless. The message is simple. Compile once, profile anywhere.

On site profiling
Normally profilers are so complicated to use and heavy on the systems, that the task of performance analysis is left to the performance team alone. You can’t imagine of doing performance or memory analysis in a post-deployment scenario; and so you find your Performance and Stability team to be quickly sent in to save the day. ProfileSharp is so simple yet so much result-oriented that within minutes of downloading it, you will start getting results. It is one of the few software products that run off-the-shelf. All in all it’s a tool for everyone and so the Performance team alone is not crunched when an application underperforms or leaks memory. It simulates a real-time environment for your .NET application and takes out the risk of frequent crashes which may occur during profiling.

Line level profiling
It does not get finer than this! As ProfileSharp works directly at the MSIL level, its produces results at the source code line level. This also makes the profiler automatically compatible with any .NET compliant language be it C#, VB.NET, MC++ or J# etc. You get to delve into the finest of performance details in no time and all this is without re-compilation or code-modification at any stage. You can discover which lines of code were executed how many times and what was the time consumed by each corresponding line. This obviously is for those parts of the application that you have the source-code for. Otherwise Method-Level profiling is performed anyway.

ProfileSharp is an exhaustive memory profiler and analyzer too. It lets you know about the memory usage patterns of your .NET applications and its quick memory comparison feature lets you take on-demand snapshots/fingerprints of .NET heap and compare the results so that you can know which objects are leaking, why and how. Its exception-tracing mechanism continuously monitors your application for caught/uncaught exceptions to produce details like the stack-trace when the exception occurred. Researches show that excessive exception occurrences can bring your .NET application to a grinding halt. All this too is without recompilation required and applies to any .NET application whether you have its source-code or not.

Information Oriented
Profilers can flood you with heaps of data collected during profiling, much of it turns out to be unnecessary and the right information is lost somewhere in between. Your performance-testing team will tell you that. ProfileSharp brings to you pin-point information and no unnecessary junk. Every piece of profiling information collected by ProfileSharp is accurate and exhaustive, no more no less. 

Superior information filtering functionality; Support for standard formats: - Ability to export the Line-Level performance data to RTF format , dynamic source-code document retrieval and charting & diagram conversion for the collected information are some of the add-on features in the profiler that help you convert and display the .NET performance statistics into industry-standard formats and prepare you for the all-important meetings and presentations. The information can also be viewed in web and print view to be put up on-site.

Supports all .NET framework
With ProfileSharp, you can now profile applications built using .NET 1.0, 1.1 and 2.0.

IS PROFILE SHARP FOR YOU ?
Designed specifically for the complex and ever-demanding environment of enterprise solutions, ProfileSharp is fully loaded with features and capabilities to profile .NET desktop applications, .NET windows services, Enterprise .NET packages (COM+) and ASP.NET web-services and web-applications etc. of any strength and complexity.

So, if you are

• Looking for a solution to identify and troubleshoot performance bottlenecks in your .NET code/application. This also includes 3rd Party .NET components.
• Looking for a solution to analyze and optimize memory and resource consumption in your .NET application
• Looking for application scalability and stability without spending more on hardware costs or newer computers
• Looking to make qualitative as well as quantitative application performance reports/presentations for your .NET software in real-time
• Interested in analyzing your .NET program control flow and lines of code executed 
• Interested in making fool-proof test cases for your .NET program and/or verify that all test-cases are actually executed.
• Seeking a solution to make your .NET code robust and free from exceptions or simulate 'What-If' scenarios for your applications
• Trying to implement custom error-logging in your .NET code. With ProfileSharp's expert 'runtime exception-tracing' mechanism that works for 'Release' builds too, you could actually do away with the headache of custom error-logging.
• Or, just seeking to learn the internals of .NET and/or improve your .NET programming skills and willing to contribute (with thanks in advance!) to the ProfileSharp's community.

Technical details about ProfileSharp

Performance and Code Profiling

• Profile methods have been called, optionally collect module or assembly name information containing the method. 
• Profile how many times a particular method is called. 
• Profile the time consumed by each method (in nanoseconds, milliseconds or CPU cycles). 
• Find out methods executing on a thread with a particular thread-Id. 
• Profile purely managed functions or optionally also profile unmanaged function calls made by your application ( COM-Interop and PInvoke ) with the same level of detail.  
• Filter out or optionally select, only the functions that you want to profile [ Based on namespace,class or module / assembly ] (Say, "I want to profile'MyDotNetLibrary.dll' only or I do not want to profile System.Web.dll and System.Security.dll." AND "I want to profile 'MyDotNetNamespace' namespace only or I do not want to profile 'System.Runtime'
• Profile more than one application simultaneously even if they target different .NET frameworks. Switch between applications on will.
• Profile only part of your application ,you are interested in [In case of performance profiling, it means a particular use-case or program flow. Optionally profile exhaustively.
• Profile applications right from the first .NET method called in the application [This is done by suspending the process just before the CLR is loaded into the process, so you can initialize the profiling first and then resume the process. Profiling that way ensures none of your .NET code is missed.
• Discover which lines of code in each method profiled were executed, how many times and what was the %time consumption by each line of code (requires source code for the application being profiled along with the debug symbol or PDB files (i.e. 'DEBUG' build). For assemblies with source code and PDBs not available (i.e. 'RELEASE' build) , function level profiling is performed, nevertheless.
• Find out parent and child functions for each function called [i.e. all the functions that called into a particular function and all the functions called by a particular function]. Also identify the time consumed by parent and children functions as a % of original function and build a call-tree.
• An array of views to analyze the profiling data collected.

Exception Tracing

Find out exceptions raised in your profile application, along with number of exceptions, type of each exception and a detailed stack-trace when the exception occurred. Also identify the .NET thread which raised the exception.

Memory Profiling

• Capture the information about objects lying in memory [The .NET heap] at a particular instance in your application. This includes number of each type of object and its size in bytes, including the size of blob (large) objects and also whether an object is a 'root' object or not.
• Find out the Generation (Gen1, Gen2, Gen3) as well as object lifetime for each object.(number of garbage collections it has survived since inception)
• Find out parent and child objects for each object alive in memory [ a parent object is one that holds a reference to an object, a child is one that is being held or referenced by an object ]. Also discover the reference count.
• Capture the complete allocation stack for each live object for a .NET thread. An 'Allocation-stack' is a stack of method calls that eventually led to the creation of an object on the .NET heap by a .NET thread.
• Compare 2 or more memory profiling snapshots to locate the heap status differences and identify lingering objects. Hence crack down on memory leaks.

Extensibility
The collected performance statistics have to be represented in a way that makes it easier for you to quickly pinpoint flaws in .NET code. Equally important is that it is displayed in a manner that is easy for the intended audience to comprehend. 

To achieve this goal ,ProfileSharp features a very flexible and extensible custom DataGrid, that helps you quickly drill down to the exact piece of information that you so desire to view. Also featuring is the tool's ability to convert the compiled performance statistics to standards like XML, CSV,HTML and RTF so that you are never short of well-groomed performance metrics for any .NET application that you wish to deliver impressive presentations for. Also the tool features an integrated graphics package for presentations in-vitrio