brendangregg/FlameGraph

Features

• Flame Graph Generators - Transforms folded stack trace data into interactive diagrams for analyzing software execution frequency.
• CPU Profilers - Samples active code paths and stack traces at specific frequencies to identify which functions consume the most processor time.
• Kernel Execution Profilers - Samples processor usage at the function or module level to identify hot code paths and quantify time spent in kernel versus user space.
• Performance Profiling Tools - Provides a suite of scripts for converting stack trace samples into interactive hierarchical visualizations to identify performance bottlenecks.
• Stack Trace Aggregators - Renders aggregated execution frequency data as interactive, nested rectangles to reveal performance bottlenecks in software call paths.
• Flame Graph Generators - Converts raw stack trace data into interactive flame graphs to identify frequent code paths.
• Kernel Event Tracers - Captures system-wide activity via stable, hard-coded kernel tracepoints for system calls, scheduler events, and file system operations.
• Dynamic Kernel Probes - Attaches probes to live kernel and user-space functions by dynamically patching binary code without requiring system restarts.
• Monitoring and Observability - Provides a collection of diagnostic scripts and visualization tools for analyzing kernel and user-space performance metrics.
• Performance Profiling - Analyzes sampled stack traces to identify hot code paths and quantify resource consumption within complex software applications.
• Differential Profilers - Performs differential profile analysis to highlight performance regressions or improvements by comparing two datasets side-by-side.
• Performance Regression Analyzers - Compares two performance profiles to highlight code path changes and identify regressions or improvements between software versions.
• Off-CPU Latency Analyzers - Profiles thread execution states to visualize time spent waiting for locks or input-output operations to resolve application blocking issues.
• Kernel Observability Programs - Runs custom code within a secure kernel sandbox to enable advanced observability without modifying kernel source.
• Off-CPU Latency Visualizers - Maps time spent by threads waiting off-processor to their corresponding stack traces.
• Dynamic Binary Instrumentation - Instruments arbitrary kernel or user-space functions at runtime by dynamically patching code.
• Observability Tracing - Records user and library function usage, including elapsed and on-processor time, to debug application behavior and performance.
• System Performance Analyzers - Measures software stack behavior under controlled workloads to identify bottlenecks by correlating execution frequency with system operations.
• Code Quality and Utilities - Visualization tool for analyzing stack traces and performance.
• Debugging And Tracing - Visualizes profiled code performance.
• System Performance Tools - Visualization tool for analyzing performance profiles.
• Hierarchical Performance Visualizers - Generates interactive diagrams from stack trace data to represent code execution frequency.
• Memory Profiling - Samples memory usage across time intervals to visualize how a process's working set size grows.
• I/O Latency Tracers - Captures stack traces and latency for disk or system input-output operations to determine if synchronous operations are impacting application performance.
• Application Observability - Attaches probes to statically defined tracepoints in user-space applications to monitor behavior.
• Event Monitoring Systems - Captures kernel and user-level events like system calls and hardware counters to monitor system behavior in real-time.
• Metric and Performance Monitors - Aggregates event data into histograms, counts, or statistical distributions to identify latency bottlenecks and resource usage patterns.
• Performance Visualization - Generates interactive diagrams from stack traces to represent code execution frequency and identify performance bottlenecks.
• Time-Based Performance Visualizers - Maps performance samples into a heat map grid to identify execution variance and temporal perturbations.
• Sample Quantifiers - Highlights specific code paths or functions within a visualization and calculates the percentage of total samples matching the search term to quantify performance impact.
• Trace Visualization - Generates interactive hierarchical visualizations from sampled stack trace data to identify frequent code paths.
• Stack Trace Hierarchy Visualizers - Generates interactive visualizations of code execution paths to identify frequent call sequences.
• Execution Path Comparison Tools - Generates separate visualizations for different thread states and aligns them to allow direct visual comparison of code path durations.
• Code Execution Sandboxes - Executes diagnostic programs within a secure, verified kernel environment to prevent system instability.
• Heat Map Generators - Creates interactive graphical representations of trace data to visualize distribution patterns and identify outliers.
• Full-Stack Execution Visualizers - Maps hierarchical call stacks into interactive diagrams to reveal structural performance patterns across interpreted and compiled code layers.
• Graphics Execution Profilers - Captures and correlates processor and graphics execution stacks to identify cross-processor stalls and performance-intensive shader operations.
• Memory Access Profilers - Examines memory allocation patterns and cache-line sharing to detect performance issues related to memory usage.
• Stack Trace Formatters - Formats hierarchical stack trace data into a single-line, delimited string structure for flame graph generation.
• Symbol Resolution Engines - Translates memory addresses from virtual machine environments into human-readable function names using symbol mapping files.
• Anomaly Detection - Highlights outliers in complex datasets to visually distinguish irregular behavior from standard activity.
• Full-Stack Execution Tracers - Maps graphics kernel execution back to high-level source code for a complete performance view.
• Thread Execution State Visualizers - Combines on-processor and off-processor stack traces into a single interactive visualization.
• Virtual Memory Growth Trackers - Tracks system calls that expand the process heap or memory segments to identify application growth patterns and memory usage trends.
• Memory Usage Analyzers - Calculates the amount of memory a process actively references over a specific duration to help determine cache and main memory requirements.
• Performance Distribution Analyzers - Aligns and overlays multiple frequency trails in a single image to compare latency patterns or data distributions across different time intervals or sources.
• Blocking Data Integrators - Merges blocking call stacks with processor execution profiles to highlight performance bottlenecks.
• Scheduler Latency Analyzers - Records and reports kernel scheduler events to quantify task migration, context switching, and scheduling delays.
• Execution Path Visualizers - Maps complex execution paths through hierarchical diagrams to identify bottlenecks and improve software stack performance.
• Data Filtering - Processes specific subsets of execution paths by applying text-based filtering to input data.
• Thread Wakeup Analyzers - Records the stack traces of threads that wake up blocked processes to reveal the root cause of lock contention.
• Memory Allocation Tracers - Provides tools to capture and analyze memory allocation calls for identifying performance bottlenecks and leaks.
• Wakeup Chain Mappers - Links sequences of thread wakeups to visualize complex dependencies and event chains across the system.
• Stack Metric Analyzers - Maps trace paths to quantitative values to visualize stack-based data like memory allocation or system call counts.
• Hardware Performance Monitoring - Collects low-level processor statistics like cache misses and cycles to identify hardware-level performance bottlenecks.
• Metric Decorators - Adds secondary dimensions like cycles-per-instruction to highlight specific performance characteristics.
• System Activity Monitoring - Monitors live system events including process execution, file access, and network activity to troubleshoot performance.
• System Diagnostics - Provides automated diagnostic scripts to collect system state data into compressed archives for performance analysis.
• System Statistic Visualizers - Generates graphical representations of system performance metrics by processing output from standard monitoring utilities.
• System Workload Characterizers - Identifies the sources and types of system load by correlating performance metrics with specific code paths and process identifiers.
• Differential Visualization Inverters - Reverses the color-coding logic of a differential visualization to highlight code paths that have vanished or decreased in frequency between profiles.
• Profile Normalizers - Adjusts stack counts between datasets to ensure accurate comparisons when profiles are captured under different system loads or timeframes.

Star history