Perfinity .NET Runtime Analyzer Funktionen

Debug, analyze and fix performance issues.
Performance Analyzer
Resolve memory and resource leaks.
Memory Profiler / Resource Tracker
Analyze Slow Database Queries and Other Issues.
System/Application Event-Tracker
Exceptions can affect the performance of your app and also its functionality.
Line-Level Exception-Tracker
Identify and eliminate the root causes of slow application startups.
Optimize Startup Performance
Debug, analyze and fix performance issues.

Debug, analyze and fix performance issues.

The powerful line level sampling profiler and the ultra-fast, low-overhead instrumentation profiler provide functionality to quickly pinpoint performance bottlenecks within the app.

The integrated focus feature simplifies the analysis of complex applications to a minimum.

In addition, the tool supports event tracing to maximize the user experience. File I/O activity, network activity and debug events can be captured. That way interesting app insights can be correlated with the timeline. Data context information can be added to investigate internals of apps beyond code level.

The built-in timeline functionality empowers the user to process interesting time ranges.

Resolve memory and resource leaks.

Resolve memory and resource leaks.

The integrated .NET memory profiler empowers the user to identify the root causes for memory issues and resource leaks. The memory profiler is fast with minimal overhead in regards to memory consumption and execution times.
Features:

  • Memory overview (Managed Heap, Win32 Heap, Modules, Mapped Files, Stacks, etc.) to get the big picture.
  • Tracking of memory and resource issues triggered from native code including the .NET runtime.
  • Capture of Win32 allocations from any 3rd party code to investigate memory leaks from native code.
  • GDI Resource Tracking to identity resource leaks (bitmaps, fonts etc.).
  • Tracking of file mapping events which can contribute multiple gigabytes of memory usage for a single process with can cause sluggish performance.
  • Analysis of crash (memory) dump files.
Analyze Slow Database Queries and Other Issues.

Analyze Slow Database Queries and Other Issues.

The built-in application event tracker captures interesting system and application event topics. For each traced event, the profiler provides timestamps and thread stacks information. For this purpose, the profiler can record both managed and native event triggers.
The tool can capture event activity with data context and error information, for instance:

  • Network activity tracing: View WCF calls, Database queries, Web access with source and target endpoints, View SSL encrypted info.
  • File I/O activity including named pipes: View .NET Remoting / WCF calls. View performed read/write operations with actual data read/written.
  • Startup-Performance optimizer: Analyze root causes of JIT compilations, module relocations.
  • Concurrency analyzer (threading events with trigger stacks) to pinpoint threading usage.
Exceptions can affect the performance of your app and also its functionality.

Exceptions can affect the performance of your app and also its functionality.

Unexpected exceptions can be another interesting source of problems that may not only affect the performance of your application but also its functionality.

.NET Runtime Analyzer highlights all exceptions which occur during the application execution. For each exception, it shows thread stacks on a line-level base to indicate the source line from which the problem was raised.

Furthermore, the built-in exception profiler allows the analysis of specific exception types or exception creation stacks to display frequencies and their distribution within the timeline.

Identify and eliminate the root causes of slow application startups.

Identify and eliminate the root causes of slow application startups.

Sluggish application startup performance can be induced by poor software algorithms. We need to identify the root cause of these issues and fix the software.

Besides, we need to also provide the best infrastructure for our software to run. The key task then is to provide proper software deployment.

Before .NET software can run on the CPU, .NET assemblies must be translated from IL to native code. So we should deploy native images for assemblies which cause high time losses in order to minimize annoying runtime overheads.