google/benchmark

Features

• C++ Microbenchmarking Libraries - Provides a high-performance C++ library for measuring the execution time of small code fragments.
• C++ Microbenchmarking - Provides a high-performance framework for measuring small code fragments in C++ using high-resolution timers.
• Multithreaded Benchmarking Tools - Provides a framework for measuring the performance of code executed across multiple threads with synchronized execution.
• Benchmark Thread Synchronization - Coordinates multiple worker threads to start and stop simultaneously using barriers to measure parallel throughput.
• Compiler Optimization Validation - Prevents the compiler from optimizing away benchmarked code to ensure measurements reflect actual execution costs.
• Optimization Barriers - Implements volatile memory writes and compiler barriers to prevent the optimizer from removing benchmarked code.
• Thread-Synchronized Execution - Coordinates multiple worker threads to start and stop simultaneously using barriers to measure parallel throughput.
• Python Bindings - Provides native Python bindings to the C++ core for high-performance timing in scripted environments.
• Parametric Benchmark Generation - Supports complex parameterization via Cartesian products to test functions across all possible input combinations.
• Complexity Analysis - Calculates algorithmic Big O complexity by fitting execution times against varying input sizes using linear regression.
• Monotonic Time Measurement - Utilizes high-resolution CPU and wall-clock timers to measure the duration of small code fragments.
• Benchmark Parameterization - Allows a single benchmark function to run across multiple input values using ranges or Cartesian products.
• Code Block Timing - A timing mechanism that tracks the execution of a specific code block within a loop.
• Compiler Optimization Prevention - Employs volatile memory writes and compiler barriers to prevent the optimizer from removing benchmarked code.
• Iterative Timing Loops - Runs target code repeatedly in a loop to average out noise and reach a stable measurement.
• Parallel Test Execution - Executes benchmarks across multiple concurrent threads to measure performance in parallel environments.
• Parameterized Benchmarks - Provides a system to run benchmarks across multiple input ranges and combinations via Cartesian products.
• Performance Analysis - Includes tools for comparing benchmark results and testing statistical significance to evaluate algorithmic efficiency.
• Asymptotic Complexity Models - Computes the Big O asymptotic complexity of benchmarks by analyzing the high-order term coefficients.
• Performance Measurement - Implements a comprehensive toolset for high-resolution timing, statistical aggregates, and asymptotic complexity analysis.
• Multithreaded Throughput Measurement - Provides specialized capabilities for measuring parallel throughput and scaling behavior across multiple CPU threads.
• Statistical Iteration Aggregation - Executes benchmarks multiple times to calculate mean, median, and standard deviation to reduce measurement noise.
• Statistical Performance Reporting - Calculates and reports the mean, median, and standard deviation for benchmarks executed across multiple repetitions.
• Statistical Sampling Benchmarks - Executes benchmarks repeatedly to gather statistical distributions of execution times and determine statistical significance.
• Custom Performance Counters - Provides a per-benchmark storage map for user-defined metrics that are reported alongside timing data.
• Benchmark Execution Control - Provides mechanisms to filter benchmarks via regular expressions or limit execution time.
• Statistical Significance Testing - Implements p-value calculations via U-tests to validate the statistical significance of performance changes.
• User-Defined Statistical Metrics - Allows the calculation of user-defined metrics for repeated benchmark runs using custom lambda functions.
• Metric Collection - Allows tracking of user-defined counters and integration with memory managers to report additional performance metrics.
• Lifecycle Management - Implements global or per-benchmark setup and teardown callbacks to manage the test environment.
• User-Defined Performance Counters - Provides a per-benchmark storage map for user-defined metrics that are aggregated and reported.
• Benchmark Result Comparison - Provides utilities to analyze and compare differences between two sets of benchmark results.
• Language-Specific Benchmarking Bindings - Extends the C++ benchmarking core to Python through native bindings for high-performance timing.
• Parameterized Performance Tuning - Supports complex parameterization via Cartesian products to test functions across various input ranges.
• Fixture Definitions - Provides a mechanism to set up reusable environments for groups of benchmarks via fixture classes.
• Test Execution Filtering - Enables the execution of a specific subset of benchmarks that match a provided regular expression.
• Benchmarking Tools - Support library for micro-benchmarking C++ code.
• Performance Analysis Tools - Microbenchmark support library for tracking C++ performance.
• Testing and Benchmarking - Micro-benchmarking support library.
• Testing and Debugging - Library for microbenchmarking C++ code.

Star history