- System requirements
- Profiler architecture
- Profiler installation
- Uninstall profiler
- Running the profiler
- Profiler activation
- Welcome screen
- Start profiling
- Profiling overhead
- Snapshots
- Solving performance problems
- CPU profiling
- Thread profiling
- Virtual threads support
- Object allocation profiling
- Memory profiling
- Monitor profiling
- Exception profiling
- Telemetry
- Probes: monitor events of various kinds
- Inspections: automatic recognition of typical problems
- Automatically trigger actions on event
- Automatic deobfuscation
- Summary
- Filters
- Profiler command line
- Export of profiling results to external formats
- Profiler Java API
- Profiler HTTP API
- Settings
- Troubleshooting and FAQ
Performance snapshot
- What is a performance snapshot?
- Information contained in a performance snapshot
- Comparing performance snapshots
What is a performance snapshot?
A performance snapshot is a detailed report that provides insights into the behavior of your application at a specific point in time or over a designated period. This snapshot can help you understand how system resources are being utilized, where bottlenecks may exist, and what potential improvements can be made to enhance performance.
Information contained in a performance snapshot
CPU usage
It gives a breakdown of how much CPU time is being consumed by different parts of the application. This helps you identify which methods or operations are CPU-intensive.
Thread activity
Get an overview of all active threads, their statuses, and how they are interacting. This can help identify issues like deadlocks or thread contention.
Object allocations
Information about the locations where Java objects were created, their quantity, and their size will be recorded in the performance snapshot if you profiled object allocations.
Synchronization and Java monitor usage
Performance snapshots include valuable information about synchronization mechanisms used within the application, such as locks and Java monitors. Metrics around lock contention, waiting times, and monitor ownership can be critical for identifying bottlenecks related to multi-threading issues. Analyzing these metrics can help you understand if your application's threads are spending excessive time waiting for locks, which can severely degrade performance.
Thrown exceptions
Exceptions in Java can be performance killers, especially when thrown and caught frequently. Performance snapshots capture data on exceptions that have been thrown and may provide stack traces or other contextual information. This data allows you to identify exception-related bottlenecks, which can be especially useful for debugging or optimizing error-prone areas of your application.
Various performance metrics
Beyond CPU metrics, performance snapshots capture a range of other performance indicators, including: GC activity, memory consumption, I/O activity, etc. Start your analysis by examining the telemetry charts for an immediate visual sense of how your application is performing. Look for noticeable spikes, dips, or patterns.
Comparing performance snapshots
Lear more how to compare performance snapshots.