Java Microbenchmark Harness (JMH)

import org.openjdk.jmh.annotations.*;

import java.util.concurrent.TimeUnit;

/**
 * A simple JMH benchmark to compare the performance of summing an array using a loop vs. using streams.
 */
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Thread)
public class SimpleBenchmark {

    private static final int ARRAY_SIZE = 1_000_000;
    private int[] data;

    /**
     * Setup method to initialize data for the benchmark.
     */
    @Setup(Level.Trial)
    public void setup() {
        data = new int[ARRAY_SIZE];
        for (int i = 0; i < ARRAY_SIZE; i++) {
            data[i] = i;
        }
    }

    /**
     * Benchmark method to sum the array using a loop.
     *
     * @return The sum of the array elements
     */
    @Benchmark
    public long sumUsingLoop() {
        long sum = 0;
        for (int value : data) {
            sum += value;
        }
        return sum;
    }

    /**
     * Benchmark method to sum the array using streams.
     *
     * @return The sum of the array elements
     */
    @Benchmark
    public long sumUsingStreams() {
        return java.util.Arrays.stream(data).sum();
    }

    /**
     * Main method to run the benchmark.
     *
     * @param args Command line arguments
     * @throws Exception If an error occurs during benchmark execution
     */
    public static void main(String[] args) throws Exception {
        org.openjdk.jmh.Main.main(args);
    }
}

import org.openjdk.jmh.annotations.*;

@State(Scope.Benchmark)
// This class represents a stateful object for benchmarking.
public class InitializationBenchmark {

    @Benchmark
    // @Benchmark annotation marks the method as a benchmark to be executed by JMH.
    @BenchmarkMode(Mode.AverageTime)
    // @BenchmarkMode specifies the benchmark mode as AverageTime, measuring the average time taken per operation.
    public void init() {
        // This benchmark method is used to measure the average time taken for an initialization operation.
        // In this case, the method does nothing (no operation is performed for the sake of benchmarking).
        // The goal is to measure the baseline performance of the benchmarking infrastructure.
        // You might replace the comment "// Do nothing" with the actual initialization code you want to benchmark.
    }

}

import org.openjdk.jmh.annotations.*;

import com.google.common.hash.Hasher;
import com.google.common.hash.Hashing;

@State(Scope.Benchmark)
// This class represents the state for benchmarking purposes.
public class ExecutionPlan {

    @Param({ "10", "20", "30", "50", "100" })
    // This annotation specifies the parameters for the benchmark iterations.
    // The 'iterations' variable will take on the values 10, 20, 30, 50, and 100 during benchmarking.
    public int iterations;

    // This variable holds a Hasher instance for the Murmur3 hash function.
    public Hasher murmur3;

    // A sample password string for hashing.
    public String password = "5vnr5yui3yui2i";

    @Setup(Level.Invocation)
    // This setup method is executed before each benchmark invocation.
    public void setUp() {
        // Initialize the Murmur3 Hasher before each benchmark iteration.
        murmur3 = Hashing.murmur3_128().newHasher();
    }
}

@Benchmark
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
public void doNothing() {
    // This benchmark method represents doing nothing.
    // It is used to measure the baseline performance overhead of the benchmarking infrastructure.
    // The annotations specify that the time unit is in nanoseconds and the benchmark mode is average time.
    // The method itself doesn't perform any meaningful computation, serving as a reference for minimal overhead.
}

@Benchmark
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
public void objectCreation() {
    // This benchmark method measures the time taken for creating a new Object.
    // It is useful for assessing the performance impact of object instantiation in the benchmarked environment.
    // The annotations specify that the time unit is in nanoseconds and the benchmark mode is average time.
    // The method creates a new Object, and the benchmarking infrastructure measures the time it takes.
}

@State(Scope.Benchmark)
public static class Log {
    // This class represents a stateful object for benchmarking.
    // It has a public field 'x' initialized to 10.
    public int x = 10;
}

@Benchmark
// This annotation marks the method as a benchmark to be executed by JMH.
public double log(Log input) {
    // This benchmark method calculates the natural logarithm (base e) of the 'x' field
    // in the provided Log object and returns the result.
    return Math.log(input.x);
}