All Classes and Interfaces
Class
Description
Aggregator composes multiple results into one.
This implements a simple String armoring scheme that resembles Base64.
A profiler based on async-profiler.
AuxCounters annotation can be used to mark State objects
as the bearers of auxiliary secondary results.Result class that stores average operation time.
Abstract runner, the base class for Runner and ForkedRunner.
Benchmark annotates the benchmark method.Internal exception in JMH.
Benchmark generator.
Base class for all benchmarks handlers.
Handles thread-local data for each worker that should not change
between the iterations.
Helper class for listing micro benchmarks.
Benchmark mode declares the default modes in which this benchmark
would run.
Benchmark parameters.
Benchmark result.
Accepts the binary data from the forked VM and pushes it to parent VM
as appropriate.
Black Hole.
Bounded variant of
PriorityQueue.Class metadata.
A utility class for loading classes in various ways.
Class that handles all the command line options.
Compiler control annotation may be used to affect the compilation of
particular methods in the benchmarks.
Compilation mode.
Control object, used to communicate significant information from JMH to the benchmark.
JMH global defaults: these are used when no other values are available.
Mac OS X perfasm profiler based on DTrace "profile-n" provider which samples program counter by timer interrupt.
External profiler: profilers to be run outside of JVM.
Thrown by worker threads when they detect other threads have failed.
Field metadata info.
A utility class for File creation and manipulation.
Fork annotation allows to set the default forking parameters for the benchmark.
Main program entry point for forked JVM instance
Hangup thread will detach us from the host VM properly, in three cases:
- normal shutdown
- shutdown with benchmark exception
- any System.exit call
The need to intercept System.exit calls is the reason to register ourselves
as the shutdown hook.
Shutdown timeout thread will forcefully exit the VM in two cases:
- stray non-daemon thread prevents the VM from exiting
- all user threads have finished, but we are stuck in some shutdown hook or finalizer
In all other "normal" cases, VM will exit before the timeout expires.
Runner frontend class.
This class encapsulates any platform-specific functionality.
Generator destination.
Generator source.
Execution group.
GroupThreads defines how many threads are participating in running
a particular
Benchmark method in the group.The InfraControl logic class.
Will drain the output stream.
Internal profiler.
Iteration parameters.
Class contains all info returned by benchmark iteration or/and collected during benchmark iteration.
A profiler based on Java Flight Recorder.
Fixtures have different Levels to control when they are about to run.
Chromosome: encodes solution.
Population.
Sometimes you need the black hole not in @Benchmark method, but in
helper methods, because you want to pass it through to the concrete
implementation which is instantiated in helper methods.
There are weird cases when the benchmark state is more cleanly described
by the set of @States, and those @States reference each other.
Our own crippled classloader, that can only load a simple class over and over again.
Control when to run the fixture methods.
Calculate statistics over a list of doubles.
Main program entry point
Measurement annotations allows to set the default measurement parameters for
the benchmark.
Super-interface for all metadata elements.
Method info.
Benchmark mode.
Basic Multimap.
Basic Multiset.
OperationsPerInvocation annotations allows to communicate the benchmark does more than
one operation, and let JMH to adjust the scores appropriately.
Option class
Internal interface for OutputFormat.
Encapsulates the OutputFormat call
- method name
- arguments (assumed to be serializable)
OutputTimeUnit provides the default time unit to report the results in.
Marks the configurable parameter in the benchmark.
Method parameter metadata.
Always add up all the samples into final result.
Main program entry point for exporting the system properties, used for detecting the VM version.
Root profiler interface.
Base class for all types of results that can be returned by a benchmark.
Runner executes JMH benchmarks.
Complete run result.
Always add up all the samples into final result.
Sampling buffer accepts samples.
Result class that samples operation time.
Always add up all the samples into final result.
State scope.Setup marks the fixture method to be run before the benchmark.
Silent format, does nothing.
Result class that stores once operation execution time.
Averages the time on all levels.
Calculate statistics with just a single value.
Very basic and naive stack profiler.
Marks the state object.
JMH VM support tester
TearDown marks the fixture method to be run after the benchmark.
TextReportFormat implementation of OutputFormat.
Thread parameters.
Threads annotation provides the default number of threads to run.
Result class that counts the number of operations performed during a specified unit of time.
Timeout annotation allows to set the default timeout parameters for the benchmark.
A generic time scalar.
Main program entry point detecting the VM version.
Warmup annotation allows to set the default warmup parameters for the benchmark.
Warmup Mode enum
Windows performance profiler based on "xperf" utility.