Class BenchmarkGenerator

java.lang.Object

org.openjdk.jmh.generators.core.BenchmarkGenerator

public class BenchmarkGenerator
extends Object

Benchmark generator.

Benchmark generator is the agnostic piece of code which generates synthetic Java code for JMH benchmarks. GeneratorSource is used to feed the generator with the required metadata.

Field Summary

Fields

Modifier and Type	Field	Description
private final Set<BenchmarkInfo>	benchmarkInfos
private final CompilerControlPlugin	compilerControl
(package private) static String[]	INDENTS
(package private) static final Object	INDENTS_LOCK
protected static final String	JMH_GENERATED_SUBPACKAGE
private static final String	JMH_STUB_SUFFIX
private static final String	JMH_TESTCLASS_SUFFIX
private final Set<String>	processedBenchmarks
private final BenchmarkGeneratorSession	session

Constructor Summary

Constructors

Constructor	Description
BenchmarkGenerator()

Method Summary

Modifier and Type	Method	Description
private void	addAuxCounters(PrintWriter writer, String resName, StateObjectHandler states, MethodInfo method)
private Multimap<ClassInfo, MethodInfo>	buildAnnotatedSet(GeneratorSource source)	Build a set of Classes which has annotated methods in them
void	complete(GeneratorSource source, GeneratorDestination destination)	Finish generating the benchmarks.
private String	emitCall(MethodInfo method, StateObjectHandler states)
void	generate(GeneratorSource source, GeneratorDestination destination)	Execute the next phase of benchmark generation.
private void	generateAverageTime(PrintWriter writer, Mode benchmarkKind, MethodGroup methodGroup, StateObjectHandler states)
private void	generateClass(GeneratorDestination destination, ClassInfo classInfo, BenchmarkInfo info)	Create and generate Java code for a class and it's methods
private void	generateImport(PrintWriter writer)
private void	generateMethod(Mode benchmarkKind, PrintWriter writer, MethodGroup methodGroup, StateObjectHandler states)	Generate the method for a specific benchmark method
private void	generateSampleTime(PrintWriter writer, Mode benchmarkKind, MethodGroup methodGroup, StateObjectHandler states)
private void	generateSingleShotTime(PrintWriter writer, Mode benchmarkKind, MethodGroup methodGroup, StateObjectHandler states)
private void	generateThroughput(PrintWriter writer, Mode benchmarkKind, MethodGroup methodGroup, StateObjectHandler states)
private String	getStubArgs()
private String	getStubTypeArgs()
(package private) static String	ident(int tabs)
private void	invocationEpilog(PrintWriter writer, int prefix, MethodInfo method, StateObjectHandler states, boolean pauseMeasurement)
private void	invocationProlog(PrintWriter writer, int prefix, MethodInfo method, StateObjectHandler states, boolean pauseMeasurement)
private void	iterationEpilog(PrintWriter writer, int prefix, MethodInfo method, StateObjectHandler states)
private void	iterationProlog(PrintWriter writer, int prefix, MethodInfo method, StateObjectHandler states)
private Collection<BenchmarkInfo>	makeBenchmarkInfo(ClassInfo clazz, Collection<MethodInfo> methods)	Generate BenchmarkInfo for given class.
private void	methodEpilog(PrintWriter writer)
private void	methodProlog(PrintWriter writer)
private String	prefix(String argList)
private void	validateBenchmark(ClassInfo clazz, Collection<MethodInfo> methods)	Do basic benchmark validation.
private void	validateBenchmarkInfo(BenchmarkInfo info)	validate benchmark info

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

JMH_STUB_SUFFIX

private static final String JMH_STUB_SUFFIX

See Also:

• Constant Field Values

JMH_TESTCLASS_SUFFIX

private static final String JMH_TESTCLASS_SUFFIX

See Also:

• Constant Field Values

JMH_GENERATED_SUBPACKAGE

protected static final String JMH_GENERATED_SUBPACKAGE

See Also:

• Constant Field Values

benchmarkInfos

private final Set<BenchmarkInfo> benchmarkInfos

compilerControl

private final CompilerControlPlugin compilerControl

processedBenchmarks

private final Set<String> processedBenchmarks

session

private final BenchmarkGeneratorSession session

INDENTS

static volatile String[] INDENTS

INDENTS_LOCK

static final Object INDENTS_LOCK

Constructor Details

BenchmarkGenerator

public BenchmarkGenerator()

Method Details

generate

public void generate(GeneratorSource source,
 GeneratorDestination destination)

Execute the next phase of benchmark generation. Multiple calls to this method are acceptable, even with the difference sources

Parameters:

source - generator source to get the metadata from

destination - generator destination to write the results to

complete

public void complete(GeneratorSource source,
 GeneratorDestination destination)

Finish generating the benchmarks. Must be called at the end of generation.

Parameters:

source - source generator to use

destination - generator destination to write the results to

buildAnnotatedSet

private Multimap<ClassInfo, MethodInfo> buildAnnotatedSet(GeneratorSource source)

Build a set of Classes which has annotated methods in them

Returns:

for all methods annotated with $annotation, returns Mapinvalid input: '<'holder-class, Set>

validateBenchmark

private void validateBenchmark(ClassInfo clazz,
 Collection<MethodInfo> methods)

Do basic benchmark validation.

validateBenchmarkInfo

private void validateBenchmarkInfo(BenchmarkInfo info)

validate benchmark info

Parameters:

info - benchmark info to validate

makeBenchmarkInfo

private Collection<BenchmarkInfo> makeBenchmarkInfo(ClassInfo clazz,
 Collection<MethodInfo> methods)

Generate BenchmarkInfo for given class. We will figure out method groups at this point.

Parameters:

clazz - holder class

methods - annotated methods

Returns:

BenchmarkInfo

generateClass

private void generateClass(GeneratorDestination destination,
 ClassInfo classInfo,
 BenchmarkInfo info)
                    throws IOException

Create and generate Java code for a class and it's methods

Throws:

IOException

generateImport

private void generateImport(PrintWriter writer)

generateMethod

private void generateMethod(Mode benchmarkKind,
 PrintWriter writer,
 MethodGroup methodGroup,
 StateObjectHandler states)

Generate the method for a specific benchmark method

generateThroughput

private void generateThroughput(PrintWriter writer,
 Mode benchmarkKind,
 MethodGroup methodGroup,
 StateObjectHandler states)

addAuxCounters

private void addAuxCounters(PrintWriter writer,
 String resName,
 StateObjectHandler states,
 MethodInfo method)

generateAverageTime

private void generateAverageTime(PrintWriter writer,
 Mode benchmarkKind,
 MethodGroup methodGroup,
 StateObjectHandler states)

getStubArgs

private String getStubArgs()

getStubTypeArgs

private String getStubTypeArgs()

methodProlog

private void methodProlog(PrintWriter writer)

methodEpilog

private void methodEpilog(PrintWriter writer)

prefix

private String prefix(String argList)

generateSampleTime

private void generateSampleTime(PrintWriter writer,
 Mode benchmarkKind,
 MethodGroup methodGroup,
 StateObjectHandler states)

generateSingleShotTime

private void generateSingleShotTime(PrintWriter writer,
 Mode benchmarkKind,
 MethodGroup methodGroup,
 StateObjectHandler states)

invocationProlog

private void invocationProlog(PrintWriter writer,
 int prefix,
 MethodInfo method,
 StateObjectHandler states,
 boolean pauseMeasurement)

invocationEpilog

private void invocationEpilog(PrintWriter writer,
 int prefix,
 MethodInfo method,
 StateObjectHandler states,
 boolean pauseMeasurement)

iterationProlog

private void iterationProlog(PrintWriter writer,
 int prefix,
 MethodInfo method,
 StateObjectHandler states)

iterationEpilog

private void iterationEpilog(PrintWriter writer,
 int prefix,
 MethodInfo method,
 StateObjectHandler states)

emitCall

private String emitCall(MethodInfo method,
 StateObjectHandler states)

ident

static String ident(int tabs)