To study (something, such as a competitor's product or business practices) in order to improve the performance of one's own company

A point of reference from which measurements may be made

A standardized problem or test that serves as a basis for evaluation or comparison (as of computer system performance)

What is this micro thing and why is it micro?

A simplified benchmark that tests com­po­nents in isolation.

It simplifies the process by abstracting the problem, removing complexity, and improving debuggability.

Components are usually quite small. Compare that to the unit test idea!

public static void main(String[] args)
{
    var length = 255;
    var src = new byte[length];
    var dest = new byte[length];

    var s1 = System.nanoTime();
    System.arraycopy(src, 0, dest, 0, length);
    var e1 = System.nanoTime();

    var s2 = System.nanoTime();
    for (int i = 0; i < length; i++)
    {
        dest[i] = src[i];
    }
    var e2 = System.nanoTime();

    System.out.printf("System Copy: %d ns%n", e1 - s1);
    System.out.printf("Manual Copy: %d ns%n", e2 - s2);
}

public static void main(String[] args) {
    final String a = "This is a test";
    final String b = "More fun with a string";
    final long c = System.currentTimeMillis(); // e.g. 1684581249117
    var l = a.length() + b.length() + 13;

    var s1 = System.nanoTime();
    {
        var sb = new StringBuilder();
        sb.append(a); sb.append(b); sb.append(c);
        var r = sb.toString();
    }
    var e1 = System.nanoTime();

    var s2 = System.nanoTime();
    {
        var sb = new StringBuilder(l);
        sb.append(a); sb.append(b); sb.append(c);
        var r = sb.toString();
    }
    var e2 = System.nanoTime();

    var s3 = System.nanoTime();
    {
        var r = a + b + c;
    }
    var e3 = System.nanoTime();

    System.out.printf("Pure String usage  : %d ns%n", e3 - s3);
    System.out.printf("StringBuilder      : %d ns%n", e1 - s1);
    System.out.printf("Sized StringBuilder: %d ns%n", e2 - s2);
}

public static void main(String[] args) {
    var data = new long[10000];
    for (int i = 0; i < data.length; i++) {
        data[i] = i;
    }

    // manual
    var s1 = System.nanoTime(); {
        var total = 0.0d;
        for (int i = 0; i < data.length; i++) {
            total += calc(data[i]);
        }
        var r = total / data.length;
    }
    var e1 = System.nanoTime();

    // stream
    var s2 = System.nanoTime(); {
        var r = Arrays.stream(data).map(i -> calc(i)).average();
    }
    var e2 = System.nanoTime();

    // stream parallel
    var s3 = System.nanoTime(); {
        var r = Arrays.stream(data).parallel().map(i -> calc(i)).average();
    }
    var e3 = System.nanoTime();
    ...
    }

    private static long calc(long c) {
        var t = c;
        for (long i = 100; i > 0; i--) {
            t += (t * 0x5DEECE66DL + 0xBL + i) & (0xFFFFFFFFFFFFL);
        }
        return t;
    }
}

@Warmup(iterations = 5, time = 2,
        timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 10, time = 1,
        timeUnit = TimeUnit.SECONDS)
@Fork(1)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
public class A01 {
    long time;

    @Setup
    public void setup() {
        time = System.currentTimeMillis();
    }

    @Benchmark
	public void add() {
		var x =
            (time * 0x5DEECE66DL + 0xBL + time) /
            (time * time * 0.42d);
 	}
}

Not every clock is created equal

• RTC Real Time Clock
• PIT Programmable Interval Timer
• HPET High Performance Event Timer
• ACPI PM ACPI Power Management Timer
• APIC Advanced Programmable Interrupt Controller
• TSC Time Stamp Counter

x86 Time Stamp Counter (TSC), a low-latency monotonically increasing clock, to measure event duration

public class A03b {
    long time;
	Long lTime;

	@Setup
	public void setup() {
		time = System.currentTimeMillis();
		lTime = Long.valueOf(time);
	}

	@Benchmark
	public void addCheap1()	{
		var x = 1 + 1727610292048L;
	}

    @Benchmark
	public void addCheap2()	{
		var x = 1 + time;
	}

	@Benchmark
	public void addCheap3() {
		var x = 1 + lTime.longValue();
	}

	@Benchmark
	public void addExpensive() {
		var x =
            (time * 0x5DEECE66DL + 0xBL + time) /
            (time * time * 0.42d);
	}
}

[Entry Point]
  # {method} {0x00007f89d0475488} 'addCheap2' '()V' in 'org/xc/jmh/A03b'
  #           [sp+0x20]  (sp of caller)
  0x00007f8a24476f80:   mov    0x8(%rsi),%r10d
  0x00007f8a24476f84:   movabs $0x7f89db000000,%r11
  0x00007f8a24476f8e:   add    %r11,%r10
  0x00007f8a24476f91:   cmp    %r10,%rax
  0x00007f8a24476f94:   jne    0x00007f8a23d53d80           ;   {runtime_call ic_miss_stub}
  0x00007f8a24476f9a:   xchg   %ax,%ax
  0x00007f8a24476f9c:   nopl   0x0(%rax)
[Verified Entry Point]
  0x00007f8a24476fa0:   sub    $0x18,%rsp
  0x00007f8a24476fa7:   mov    %rbp,0x10(%rsp)
  0x00007f8a24476fac:   cmpl   $0x0,0x20(%r15)
  0x00007f8a24476fb4:   jne    0x00007f8a24476fe3
  0x00007f8a24476fba:   add    $0x10,%rsp
  0x00007f8a24476fbe:   pop    %rbp
  0x00007f8a24476fbf:   cmp    0x450(%r15),%rsp     ;   {poll_return}
  0x00007f8a24476fc6:   ja     0x00007f8a24476fcd
  0x00007f8a24476fcc:   ret
  0x00007f8a24476fcd:   movabs $0x7f8a24476fbf,%r10 ; {internal_word}
  0x00007f8a24476fd7:   mov    %r10,0x468(%r15)
  0x00007f8a24476fde:   jmp    0x00007f8a23d5a400   ; {runtime_call SafepointBlob}
  0x00007f8a24476fe3:   call   Stub::nmethod_entry_barrier ; {runtime_call StubRoutines (final stubs)}
  0x00007f8a24476fe8:   jmp    0x00007f8a24476fba
  0x00007f8a24476fed:   hlt
  0x00007f8a24476fee:   hlt
  0x00007f8a24476fef:   hlt
[Exception Handler]
  0x00007f8a24476ff0:   jmp    0x00007f8a23e0a600 ; {no_reloc}
[Deopt Handler Code]
  0x00007f8a24476ff5:   call   0x00007f8a24476ffa
  0x00007f8a24476ffa:   subq   $0x5,(%rsp)
  0x00007f8a24476fff:   jmp    0x00007f8a23d596a0 ; {runtime_call DeoptimizationBlob}
  0x00007f8a24477004:   hlt
  0x00007f8a24477005:   hlt
  0x00007f8a24477006:   hlt
  0x00007f8a24477007:   hlt

public class A04a {
    ...
    @Benchmark
	public long addCheap1()	{
		return 1 + 1727610292048L;
	}

    @Benchmark
	public long addCheap2()	{
		return 1 + time;
	}

	@Benchmark
	public long addCheap3()	{
		return 1 + lTime.longValue();
	}

	@Benchmark
	public double addExpensive() {
		return
            (time * 0x5DEECE66DL + 0xBL + time) /
            (time * time * 0.42d);
	}
    ...
}

[Entry Point]
  # {method} {0x00007f5c2c4754c0} 'addCheap2' '()J' in 'org/xc/jmh/A04a'
  #           [sp+0x20]  (sp of caller)
  0x00007f5c80475a80:   mov    0x8(%rsi),%r10d
  0x00007f5c80475a84:   movabs $0x7f5c37000000,%r11
  0x00007f5c80475a8e:   add    %r11,%r10
  0x00007f5c80475a91:   cmp    %r10,%rax
  0x00007f5c80475a94:   jne    0x00007f5c7fd53d80           ;   {runtime_call ic_miss_stub}
  0x00007f5c80475a9a:   xchg   %ax,%ax
  0x00007f5c80475a9c:   nopl   0x0(%rax)
[Verified Entry Point]
  0x00007f5c80475aa0:   sub    $0x18,%rsp
  0x00007f5c80475aa7:   mov    %rbp,0x10(%rsp)
  0x00007f5c80475aac:   cmpl   $0x1,0x20(%r15)
  0x00007f5c80475ab4:   jne    0x00007f5c80475aec
  0x00007f5c80475aba:   mov    $0x1,%eax
  0x00007f5c80475abf:   add    0x10(%rsi),%rax
  0x00007f5c80475ac3:   add    $0x10,%rsp
  0x00007f5c80475ac7:   pop    %rbp
  0x00007f5c80475ac8:   cmp    0x450(%r15),%rsp             ;   {poll_return}
  0x00007f5c80475acf:   ja     0x00007f5c80475ad6
  0x00007f5c80475ad5:   ret
  0x00007f5c80475ad6:   movabs $0x7f5c80475ac8,%r10         ;   {internal_word}
  0x00007f5c80475ae0:   mov    %r10,0x468(%r15)
  0x00007f5c80475ae7:   jmp    0x00007f5c7fd5a400           ;   {runtime_call SafepointBlob}
  0x00007f5c80475aec:   call   Stub::nmethod_entry_barrier  ;   {runtime_call StubRoutines (final stubs)}
  0x00007f5c80475af1:   jmp    0x00007f5c80475aba
  0x00007f5c80475af6:   hlt
  0x00007f5c80475af7:   hlt
[Exception Handler]
  0x00007f5c80475af8:   jmp    0x00007f5c7fe08200           ;   {no_reloc}
[Deopt Handler Code]
  0x00007f5c80475afd:   call   0x00007f5c80475b02
  0x00007f5c80475b02:   subq   $0x5,(%rsp)
  0x00007f5c80475b07:   jmp    0x00007f5c7fd596a0           ;   {runtime_call DeoptimizationBlob}
  0x00007f5c80475b0c:   hlt
  0x00007f5c80475b0d:   hlt
  0x00007f5c80475b0e:   hlt
  0x00007f5c80475b0f:   hlt

public class A04d {
    ...
    @Benchmark
	public void addCheap1(Blackhole b)
	{
		b.consume(1 + 1727610292048L);
	}

	@Benchmark
	public void addCheap2(Blackhole b)
	{
		b.consume(1 + time);
	}

	@Benchmark
	public void addCheap3(Blackhole b)
	{
		b.consume( 1 + lTime.longValue());
	}

	@Benchmark
	public void addExpensive(Blackhole b)
	{
		b.consume((time * 0x5DEECE66DL + 0xBL + time) / (time * time * 0.42d));
	}
    ...
}

@Benchmark
public double addExpensive() {
	return
        (time * 0x5DEECE66DL + 0xBL + time) /
        (time * time * 0.42d);
}

# C1-Compiler
0x00007f8b009a5122:   mov    0x10(%rsi),%rdi
0x00007f8b009a5126:   movabs $0x5deece66d,%rax
0x00007f8b009a5130:   mov    %rax,%rsi
0x00007f8b009a5133:   mov    %rdi,%rax
0x00007f8b009a5136:   imul   %rsi,%rax
0x00007f8b009a513a:   movabs $0xb,%r10
0x00007f8b009a5144:   add    %r10,%rax
0x00007f8b009a5147:   add    %rdi,%rax
0x00007f8b009a514a:   vcvtsi2sd %rax,%xmm0,%xmm0
0x00007f8b009a514f:   mov    %rdi,%rsi
0x00007f8b009a5152:   mov    %rdi,%rax
0x00007f8b009a5155:   imul   %rsi,%rax
0x00007f8b009a5159:   vcvtsi2sd %rax,%xmm1,%xmm1
0x00007f8b009a515e:   vmulsd -0xc6(%rip),%xmm1,%xmm1
0x00007f8b009a5166:   vdivsd %xmm1,%xmm0,%xmm0

public class A11 {
	double x1, x2;

	@Setup
	public void setup() {
		x1 = System.currentTimeMillis() / 42.1801;
		x2 = System.currentTimeMillis() / 42.1802;
	}

	private double compute(double d) {
		for (int c = 0; c < 10; c++) {
			d = d * d / Math.PI;
		}
		return d;
	}

	public double baseline() {
		return compute(x2);
	}

	public double measureWrong() {
		compute(x1);
		return compute(x2);
	}

	public void measureRight_Blackholes(Blackhole bh) {
		bh.consume(compute(x1));
		bh.consume(compute(x2));
	}

    public void measureWrong_Blackholes(Blackhole bh) {
		compute(x1);
		bh.consume(compute(x2));
	}
}

// make is warm longer
@Warmup(iterations = 5, time = 2, timeUnit = TimeUnit.SECONDS)
// measure longer and more often
@Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
public class A04b {
    ...
    The same here!
    ...
}

# Benchmark: org.xc.jmh.A04b.addCheap2

# Warmup Iteration   1: 0.372 ns/op
# Warmup Iteration   2: 0.373 ns/op
# Warmup Iteration   3: 0.549 ns/op
# Warmup Iteration   4: 0.549 ns/op
# Warmup Iteration   5: 0.553 ns/op
Iteration   1: 0.549 ns/op
Iteration   2: 0.548 ns/op
Iteration   3: 0.548 ns/op
Iteration   4: 0.569 ns/op
Iteration   5: 0.548 ns/op
Iteration   6: 0.549 ns/op
Iteration   7: 0.547 ns/op
Iteration   8: 0.547 ns/op
Iteration   9: 0.548 ns/op
Iteration  10: 0.547 ns/op

/*
 * Each method warms and runs differently
 */
@Fork(1)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
public class A04c {
    ...
    @Warmup(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
    @Measurement(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
    @Benchmark
    public long addShort() {
    	return 1 + time;
    }

    @Warmup(iterations = 5, time = 2, timeUnit = TimeUnit.SECONDS)
    @Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS)
    @Benchmark
    public long addLong() {
    	return 1 + time;
    }
    ...
}

# Run it normally
# java -jar target/benchmarks.jar "A04c"




# Benchmark: org.xc.jmh.A04c.addLong
# Warmup Iteration   1: 0.381 ns/op
# Warmup Iteration   2: 0.378 ns/op
# Warmup Iteration   3: 0.547 ns/op
# Warmup Iteration   4: 0.547 ns/op
# Warmup Iteration   5: 0.547 ns/op
Iteration   1: 0.547 ns/op
Iteration   2: 0.550 ns/op
Iteration   3: 0.547 ns/op
Iteration   4: 0.547 ns/op
Iteration   5: 0.547 ns/op
Iteration   6: 0.548 ns/op
Iteration   7: 0.547 ns/op
Iteration   8: 0.547 ns/op
Iteration   9: 0.549 ns/op
Iteration  10: 0.548 ns/op

public class A05 {
    ...
    @Benchmark
	@CompilerControl(CompilerControl.Mode.DONT_INLINE)
	public long addCheap1() {
		return 1 + 1727610292048L;
	}

	@Benchmark
	@CompilerControl(CompilerControl.Mode.DONT_INLINE)
	public long addCheap2()	{
		return 1 + time;
	}

	@Benchmark
	@CompilerControl(CompilerControl.Mode.DONT_INLINE)
	public long addCheap3()	{
		return 1 + lTime.longValue();
	}

	@Benchmark
	@CompilerControl(CompilerControl.Mode.DONT_INLINE)
	public double addExpensive() {
		return
            (time * 0x5DEECE66DL + 0xBL + time) /
            (time * time * 0.42d);
	}
    ...
}

public class B01
{
	final int SIZE = 1000;
	int[] data;

	@Setup(Level.Iteration)
	public void setup()
	{
		var r = new Random(42L);
		data = new int[SIZE];
		for (int i = 0; i < SIZE; i++)
		{
			data[i] = r.nextInt();
		}
	}

	@Benchmark
	public long sumClassic()
	{
		long result = 0;
		for (int i = 0; i < data.length; i++)
		{
			result += data[i];
		}

		return result;
	}
}

# Trial - Per Benchmark
$ java -jar target/benchmarks.jar "B02"

# Warmup Iteration   1: 75.102 ns/op
# Warmup Iteration   2: 73.226 ns/op
Iteration   1: 72.837 ns/op
Iteration   2: 76.176 ns/op
Iteration   3: 77.893 ns/op
Iteration   4: 74.138 ns/op
Iteration   5: 74.346 ns/op

Benchmark       Mode  Cnt   Score   Error  Units
B02.sumClassic  avgt    5  75.078 ± 7.598  ns/op

# Iteration - Per Warmup and Measurement Round
$ java -jar target/benchmarks.jar "B01"

# Warmup Iteration   1: 75.288 ns/op
# Warmup Iteration   2: 73.892 ns/op
Iteration   1: 76.258 ns/op
Iteration   2: 73.315 ns/op
Iteration   3: 77.246 ns/op
Iteration   4: 76.957 ns/op
Iteration   5: 72.868 ns/op

Benchmark       Mode  Cnt   Score   Error  Units
B01.sumClassic  avgt    5  75.329 ± 8.008  ns/op

• Now we measure EACH invocation
• Remember our clock issue!
• Need enough work to suppress overhead
• Expensive setup might skew the result
• More warnings in the JavaDoc!

@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 2, timeUnit = TimeUnit.SECONDS)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
@Fork(value = 1, jvmArgsAppend = {"-Xms4g", "-Xmx4g", "-XX:+AlwaysPreTouch"})
public class B04a {
	@Param({"1", "10", "100", "1000", "10000", "100000",
		"1000000", "10000000", "100000000", "1000000000"})
	int SIZE;
	int[] data;

	@Setup
	public void setup()	{
		var r = new Random(42L);
		data = new int[SIZE];
		for (int i = 0; i < SIZE; i++) {
			data[i] = r.nextInt();
		}
	}

	@Benchmark
	public long sumClassic() {
		long result = 0;
		for (int i = 0; i < data.length; i++) {
			result += data[i];
		}

		return result;
	}

	@Benchmark
	public long sumStream()	{
		return Arrays.stream(data).sum();
	}
}

@Warmup(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
public class B08
{
	@Param({"1", "10", "100", "1000"})
	int SIZE;
	List<String> data = new ArrayList<>(SIZE);

	@Setup
	public void setup()
	{
		var r = new Random(42);
		for (int i = 0; i < SIZE; i++)
		{
			data.add(String.valueOf(r.nextInt()));
		}
	}

	@Benchmark
    public List<String> sort()
	{
		Collections.sort(data);
		return data;
	}
}

public class Example1ArrayCopying {
    @Param({"1000"}) int SIZE;
    byte[] src;

    @Setup
    public void setup() {
        src = new byte[SIZE];
        final Random r = new Random(7L);
        r.nextBytes(src);
    }

    @Benchmark
    public byte[] systemCopy() {
        var dest = new byte[src.length];
        System.arraycopy(src, 0, dest, 0, src.length);

        return dest;
    }

    @Benchmark
    public byte[] arrayCopy() {
        return Arrays.copyOf(src, src.length);
    }

    @Benchmark
    public byte[] manualCopy() {
        var dest = new byte[src.length];
        for (int i = 0; i < src.length; i++) {
            dest[i] = src[i];
        }

        return dest;
    }
}

public class Example1ArrayCopying {
    @Param({"1000"}) int SIZE;
    byte[] src;

    @Setup
    public void setup() {
        src = new byte[SIZE];
        final Random r = new Random(7L);
        r.nextBytes(src);
    }

    @Benchmark
    public byte[] systemCopy() {
        var dest = new byte[src.length];
        System.arraycopy(src, 0, dest, 0, src.length);

        return dest;
    }

    @Benchmark
    public byte[] arrayCopy() {
        return Arrays.copyOf(src, src.length);
    }

    @Benchmark
    public byte[] manualCopy() {
        var dest = new byte[src.length];
        for (int i = 0; i < src.length; i++) {
            dest[i] = src[i];
        }

        return dest;
    }
}

@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(3)
public class Example2ArrayCopying {
    ...

    @Benchmark
    public byte[] systemCopy() {
        var dest = new byte[src.length];
        System.arraycopy(src, 0, dest, 0, src.length);

        return dest;
    }

    @Benchmark
    public byte[] arrayCopy() {
        return Arrays.copyOf(src, src.length);
    }

    @Benchmark
    public byte[] manualCopy() {
        var dest = new byte[src.length];
        for (int i = 0; i < src.length; i++) {
            dest[i] = src[i];
        }

        return dest;
    }
}

@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
public class Example3ArrayCopying {
    @Param({"10", "1000", "100000"})
    int SIZE;
    ...
}

@State(Scope.Thread)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
public class Example4ArrayCopying {
    @Param({"10", "1000", "100000"})
    int SIZE;
    long[] src;

    @Setup
    public void setup()
    {
        src = new long[SIZE];
        final Random r = new Random(7L);
        for (int i = 0; i < src.length; i++)
        {
            src[i] = r.nextLong();
        }
    }
    ...
}

public class Example6ArrayCopying {
    @Param({"1000"})
    int SIZE;
    long[] src, dest;

    @Setup
    public void setup() {
        src = new long[SIZE];
        dest = new long[SIZE];

        final Random r = new Random(7L);
        for (int i = 0; i < src.length; i++) {
        	src[i] = r.nextLong();
        }
    }

    @Benchmark
    public long[] systemCopy() {
        System.arraycopy(src, 0, dest, 0, src.length);
        return dest;
    }

    @Benchmark
    public long[] manualCopy() {
        for (int i = 0; i < src.length; i++) {
            dest[i] = src[i];
        }

        return dest;
    }
}

public class Example7ArrayCopying {
    @Param({"1000"})
    int SIZE;
    int pos;
    long[] src;

    public void setup() {
        ...
        pos = SIZE / 2;
        ...
    }

    public long[] manualCopy1() {
        for (int i = 0; i < src.length - pos; i++) {
            src[i] = src[pos + i];
        }
        return src;
    }

    public long[] manualCopy2() {
    	var to = src.length - pos;
        for (int i = 0; i < to; i++) {
            src[i] = src[pos + i];
        }
        return src;
    }

    public long[] manualCopy3() {
    	var p = pos;
    	var to = src.length - p;
        for (int i = 0; i < to; i++, p++) {
            src[i] = src[p];
        }
        return src;
    }
}

public class Example8ArrayCopying {
    @Setup
    public void setup() {
        ...
        final Random r = new Random(7L);
        increment = r.nextInt(1) + 1;
    }

    @Benchmark
    public long[] manualCopyAntiUnroll1() {
        for (long l = 0; l < src.length; l++) {
        	final var i = (int)l;
            dest[i] = src[i];
        }
        return src;
    }

    @Benchmark
    public long[] manualCopyAntiUnroll2() {
        for (int i = 0; i < src.length; i = i + increment) {
            dest[i] = src[i];
        }
        return src;
    }

    @Benchmark
    public long[] manualCopyAntiUnroll3() {
        final var inc = increment;
        for (int i = 0; i < src.length; i = i + inc) {
            dest[i] = src[i];
        }
        return src;
    }
}

public class Example9ArrayCopying {
    @Benchmark
    public long[] manualCopyAntiUnroll() {
        for (int i = 0; i < src.length; i = i + increment) {
            dest[i] = src[i];
        }

        return dest;
    }

    @Benchmark
    public long[] manualCopyUnroll() {
    	var inc = increment * 4;
    	var i = 0;
        for (; i < src.length; i = i + inc) {
            dest[i] = src[i];
            dest[i + 1] = src[i + 1];
            dest[i + 2] = src[i + 2];
            dest[i + 3] = src[i + 3];
        }
        for (; i < src.length; i++) {
            dest[i] = src[i];
        }

        return dest;
    }
}

java -jar target/benchmarks.jar "Example8ArrayCopying"

# JDK 21 - Hetzner AMD EPYC - W5-1/M10-1/F1 - Default Mem
Benchmark                                   (SIZE)  Mode  Cnt     Score    Error  Units
Example8ArrayCopying.manualCopy1              1000  avgt   10    68.692 ±  0.066  ns/op
Example8ArrayCopying.manualCopy2              1000  avgt   10    70.277 ±  1.390  ns/op
Example8ArrayCopying.manualCopyAntiUnroll1    1000  avgt   10   385.301 ±  3.335  ns/op
Example8ArrayCopying.manualCopyAntiUnroll2    1000  avgt   10   617.899 ± 28.190  ns/op
Example8ArrayCopying.manualCopyAntiUnroll3    1000  avgt   10  1640.345 ±  0.966  ns/op
Example8ArrayCopying.systemCopy               1000  avgt   10   100.947 ±  1.753  ns/op
---
Benchmark                                   (SIZE)  Mode  Cnt     Score    Error  Units
Example8ArrayCopying.manualCopy1              1000  avgt   10    68.818 ±  0.893  ns/op
Example8ArrayCopying.manualCopy2              1000  avgt   10    70.744 ±  0.439  ns/op
Example8ArrayCopying.manualCopyAntiUnroll1    1000  avgt   10   385.096 ±  4.509  ns/op
Example8ArrayCopying.manualCopyAntiUnroll2    1000  avgt   10   655.082 ±  1.224  ns/op
Example8ArrayCopying.manualCopyAntiUnroll3    1000  avgt   10  1645.394 ± 24.600  ns/op
Example8ArrayCopying.systemCopy               1000  avgt   10    74.698 ±  1.357  ns/op
--
# Benchmark: org.xc.jmh.Example8ArrayCopying.manualCopyAntiUnroll3
# Warmup Iteration   1: 579.444 ns/op
# Warmup Iteration   2: 421.095 ns/op
# Warmup Iteration   3: 1640.320 ns/op
# Warmup Iteration   4: 1639.955 ns/op
# Warmup Iteration   5: 1639.914 ns/op
Iteration   1: 1640.164 ns/op
...
Iteration  10: 1641.931 ns/op

public class Cache03 {
    final int SIZE = 100_000;
    final int[] src = new int[SIZE];

    @Benchmark
    public int step1() {
        int sum = 0;
        for (int i = 0; i < SIZE; i++) {
            sum += src[i];
        }
        return sum;
    }

    @Benchmark
    public int step20() {
        int sum = 0;
        for (int i = 0; i < SIZE; i = i + 20) {
            sum += src[i];
        }
        return sum;
    }

    int step(int strideSize) {
        int sum = 0;
        for (int i = 0; i < SIZE; i = i + strideSize) {
            sum += src[i];
        }
        return sum;
    }

    @Benchmark
    public int stepUnrolled1() {return step(1);}

    @Benchmark
    public int stepUnrolled20() {return step(2o);}
}

# java -jar target/benchmarks.jar "Cache03.step(1|20)" -prof perfnorm

Benchmark                             Mode Cnt      Score      Units
Cache03.step1                         avgt   3  31676.192      ns/op

Cache03.step1:IPC                     avgt          1.227  insns/clk

Cache03.step1:L1-dcache-load-misses   avgt       5337.646       #/op
Cache03.step1:L1-dcache-loads         avgt      83939.072       #/op
Cache03.step1:L1-icache-load-misses   avgt          4.004       #/op
Cache03.step1:L1-icache-loads         avgt        165.415       #/op

Cache03.step1:branch-misses           avgt         13.406       #/op
Cache03.step1:branches                avgt       5143.071       #/op
Cache03.step1:cycles                  avgt      81345.466       #/op
Cache03.step1:instructions            avgt      99844.986       #/op

Cache03.step1:dTLB-load-misses        avgt          0.194       #/op
Cache03.step1:dTLB-loads              avgt         90.337       #/op
Cache03.step1:iTLB-load-misses        avgt          0.112       #/op
Cache03.step1:iTLB-loads              avgt          0.534       #/op

Cache03.step1:stalled-cycles-frontend avgt        534.119       #/op

public class Example10ArrayCopying {
    @Param({"1000"})
    int SIZE;
    @Param({"1", "10", "1000", "10000"})
    int COUNT;

    final List srcArrays = new ArrayList<>();
    final List destArrays = new ArrayList<>();
    final Random r = new Random(7L);

    @Setup
    public void setup() {
    	srcArrays.clear();
    	destArrays.clear();
    	var a = new long[SIZE];

        for (int i = 0; i < a.length; i++) {
        	a[i] = r.nextLong();
        }

        // get us enough arrays
        for (int i = 0; i < COUNT; i++) {
        	srcArrays.add(Arrays.copyOf(a, a.length));
        	destArrays.add(Arrays.copyOf(a, a.length));
        }
    }

    @Benchmark
    public long[] systemCopy() {
    	var src = srcArrays.get(r.nextInt(srcArrays.size()));
    	var dest = destArrays.get(r.nextInt(destArrays.size()));

        System.arraycopy(src, 0, dest, 0, src.length);
        return dest;
    }
    ...
}

public class Cache01 {
    @Param({"10", "1000", "10000"}) int SIZE = 1000;

    @Param({"true", "false"}) boolean RANDOM = false;
    @Param({"true", "false"}) boolean MOREGARBAGE = false;

    final List<String> data = new ArrayList<>(SIZE);
    final List<byte[]> garbage = new ArrayList<>(SIZE);

    String[] CITIES = {"Berlin;", "Hannover;", "Prag;", "Rio;", "Hamburg;", "Paris;", "Rotterdam;"};
    String[] TEMPERATURES = {"-99.9", "99.9", "3.4", "-12.2", "22.2", "26.8", "31.1", "11.0", "-5.6"};

    @Setup(Level.Trial)
    public void setup() {
    	data.clear();
    	garbage.clear();
        final var r = new Random(7L);

        for (int i = 0; i < SIZE; i++) {
        	if (MOREGARBAGE) {
        		garbage.add(new byte[r.nextInt(5000)]);
        	}

        	data.add(
                CITIES[r.nextInt(CITIES.length)] +
                TEMPERATURES[r.nextInt(TEMPERATURES.length)]);
        }

        if (RANDOM) {
        	Collections.shuffle(data, r);
        }
    }

    @Benchmark
    public double parse() {
    	var total = 0d;
    	for (int i = 0; i < data.size(); i++) {
    		var s = data.get(i);
    		var pos = s.indexOf(';');
    		total += pos + s.length(); // .parseDouble(s.substring(pos + 1));
        }

        return total;
    }
}

# Parameters: (MOREGARBAGE = false, RANDOM = false, SIZE = 1000)
# Warmup Iteration   1: 4741.602 ns/op
# Warmup Iteration   2: 4620.027 ns/op
# Warmup Iteration   3: 4616.325 ns/op
# Warmup Iteration   4: 4573.271 ns/op
# Warmup Iteration   5: 4446.747 ns/op
Iteration   1: 4574.989 ns/op
Iteration   2: 4517.727 ns/op
Iteration   3: 4575.883 ns/op
Iteration   4: 4576.167 ns/op
Iteration   5: 4574.460 ns/op
Iteration   6: 4573.074 ns/op
Iteration   7: 4387.671 ns/op
Iteration   8: 4492.154 ns/op
Iteration   9: 4557.968 ns/op
Iteration  10: 4560.888 ns/op

# Parameters: (MOREGARBAGE = false, RANDOM = false, SIZE = 10000)
# Warmup Iteration   1: 45189.567 ns/op
# Warmup Iteration   2: 43549.135 ns/op
# Warmup Iteration   3: 43981.266 ns/op
# Warmup Iteration   4: 44022.431 ns/op
# Warmup Iteration   5: 43775.808 ns/op
Iteration   1: 57472.806 ns/op
Iteration   2: 57244.411 ns/op
Iteration   3: 55563.821 ns/op
Iteration   4: 61645.149 ns/op
Iteration   5: 56521.307 ns/op
Iteration   6: 56301.759 ns/op
Iteration   7: 56916.481 ns/op
Iteration   8: 55442.452 ns/op
Iteration   9: 66088.367 ns/op
Iteration  10: 72888.761 ns/op

public class Cache02
{
	@Param({"10", "1000", "10000"}) int SIZE;

	int totalData = 10_000;
	int baseSize = 10_000;
	int counter = 0;

	final List<List<String>> data = new ArrayList<>(SIZE);

	String[] CITIES = {"Berlin;", "Hannover;", "Prag;", "Rio;", "Hamburg;", "Paris;", "Rotterdam;"};
	String[] TEMPERATURES = {"-99.9", "99.9", "3.4", "-12.2", "22.2", "26.8", "31.1", "11.0", "-5.6"};

	@Setup(Level.Trial)
	public void setupTrial()
	{
		data.clear();
		final var r = new Random(7L);

		for (int j = 0; j < totalData; j++)
		{
            final List<String> d = new ArrayList<>(SIZE);
			for (int i = 0; i < baseSize; i++)
			{
				d.add(CITIES[r.nextInt(CITIES.length)] + TEMPERATURES[r.nextInt(TEMPERATURES.length)]);
			}
			data.add(d);
		}
	}

	@Setup(Level.Iteration)
	public void setupIteration()
	{
		counter = 0;
	}

Benchmark          (SIZE)  Mode  Cnt       Score       Error  Units
Cache02.cacheHit       10  avgt   10      43.010 ±     0.184  ns/op
Cache02.cacheHit     1000  avgt   10    4778.031 ±    60.261  ns/op
Cache02.cacheHit    10000  avgt   10   64683.226 ± 14788.267  ns/op
Cache02.cacheMiss      10  avgt   10     336.260 ±    45.515  ns/op
Cache02.cacheMiss    1000  avgt   10   17669.625 ±    41.837  ns/op
Cache02.cacheMiss   10000  avgt   10  174635.237 ±  2976.802  ns/op

# Benchmark: org.xc.jmh.Cache02.cacheMiss
# Parameters: (SIZE = 10000)
# Warmup Iteration   1: 177439.666 ns/op
# Warmup Iteration   2: 174301.683 ns/op
# Warmup Iteration   3: 174319.358 ns/op
# Warmup Iteration   4: 175194.210 ns/op
# Warmup Iteration   5: 193149.452 ns/op
Iteration   1: 176797.338 ns/op
Iteration   2: 179366.082 ns/op
Iteration   3: 174686.931 ns/op
Iteration   4: 173912.824 ns/op
Iteration   5: 174186.462 ns/op
Iteration   6: 173900.033 ns/op
Iteration   7: 173583.888 ns/op
Iteration   8: 173610.283 ns/op
Iteration   9: 173037.852 ns/op
Iteration  10: 173270.673 ns/op

# Perf - requires Linux kernel tooling
java -jar target/benchmarks.jar "Cache02.cacheMiss" -prof perfnorm

cacheMiss                         10000 avgt 202,126.64     ns/op
cacheMiss:IPC                     10000 avgt       1.22 insns/clk
cacheMiss:L1-dcache-load-misses   10000 avgt   7,949.14      #/op
cacheMiss:L1-dcache-loads         10000 avgt 125,343.85      #/op

cacheMiss:branch-misses           10000 avgt   7,672.78      #/op
cacheMiss:branches                10000 avgt 211,824.84      #/op
cacheMiss:cycles                  10000 avgt 516,010.56      #/op
cacheMiss:dTLB-load-misses        10000 avgt     124.12      #/op
cacheMiss:dTLB-loads              10000 avgt     152.94      #/op

cacheMiss:instructions            10000 avgt 634,205.58      #/op
cacheMiss:stalled-cycles-frontend 10000 avgt  54,376.13      #/op

# Benchmark: org.xc.jmh.Cache02.cacheMiss
# Parameters: (SIZE = 10000)
# Warmup Iteration   1: 177439.666 ns/op
# Warmup Iteration   2: 174301.683 ns/op
# Warmup Iteration   3: 174319.358 ns/op
# Warmup Iteration   4: 175194.210 ns/op
# Warmup Iteration   5: 193149.452 ns/op
Iteration   1: 176797.338 ns/op
Iteration   2: 179366.082 ns/op
Iteration   6: 173900.033 ns/op
Iteration   7: 173583.888 ns/op
Iteration   9: 173037.852 ns/op

@Measurement(iterations = 1, time=10, timeUnit = TimeUnit.MILLISECONDS)
...
public class C02
{
    @Benchmark
    @Warmup(iterations = 0)
	public byte[] systemCopyCold()

	@Benchmark
    @Warmup(iterations = 1, time=10, timeUnit = TimeUnit.MILLISECONDS)
	public byte[] systemCopyWarm()

	@Benchmark
    @Warmup(iterations = 1, time=1000, timeUnit = TimeUnit.MILLISECONDS)
	public byte[] systemCopyHot()

	@Benchmark
    @Warmup(iterations = 0)
	public byte[] manualCopyCold()

	@Benchmark
    @Warmup(iterations = 1, time=10, timeUnit = TimeUnit.MILLISECONDS)
	public byte[] manualCopyWarm()

	@Benchmark
    @Warmup(iterations = 1, time=1000, timeUnit = TimeUnit.MILLISECONDS)
	public byte[] manualCopyHot()
}

java -jar target/benchmarks.jar "C02" -jvmArgs "-XX:+PrintCompilation"
# Benchmark: org.xc.jmh.C02.systemCopyHot
# Fork: 1 of 1
...
# Warmup Iteration   1:
...
  175  506     3  org.xc.jmh.C02::systemCopyHot (23 bytes)
  175  507     3  org.openjdk.jmh.infra.Blackhole::consume (19 bytes)
  175  508     3  org.openjdk.jmh.infra.Blackhole::consumeCompiler (1 bytes)
  185  509     4  org.xc.jmh.C02::systemCopyHot (23 bytes)
# 186  506     3  org.xc.jmh.C02::systemCopyHot (23 bytes)   made not entrant
  186  510     4  org.openjdk.jmh.infra.Blackhole::consume (19 bytes)
# 186  507     3  org.openjdk.jmh.infra.Blackhole::consume (19 bytes)   made not entrant
  287  511 %   3  org.xc...jmhTest::systemCopyHot_avgt_jmhStub @ 13 (57 bytes)
  289  512     3  org.xc...jmhTest::systemCopyHot_avgt_jmhStub (57 bytes)
  361  513 %   4  org.xc...jmhTest::systemCopyHot_avgt_jmhStub @ 13 (57 bytes)
# 368  511 %   3  org.xc...jmhTest::systemCopyHot_avgt_jmhStub @ 13 (57 bytes)   made not entrant
#1175  513 %   4  org.xc...jmhTest::systemCopyHot_avgt_jmhStub @ 13 (57 bytes)   made not entrant

1820.859 ns/op
Iteration   1: 4797.916 ns/op

# Only compile quick and easy, never leave that again
java -jar target/benchmarks.jar "C02" -jvmArgs "-XX:TieredStopAtLevel=1"


Benchmark           Mode  Cnt       Score   Error  Units
C02.manualCopyCold  avgt       197266.887          ns/op
C02.manualCopyHot   avgt       146286.457          ns/op
C02.manualCopyWarm  avgt       147154.377          ns/op
C02.systemCopyCold  avgt         1943.922          ns/op
C02.systemCopyHot   avgt         1775.785          ns/op
C02.systemCopyWarm  avgt         3744.589          ns/op
--
C02.manualCopyCold  avgt       144304.352          ns/op
C02.manualCopyHot   avgt        57894.731          ns/op
C02.manualCopyWarm  avgt       115281.330          ns/op
C02.systemCopyCold  avgt         1940.215          ns/op
C02.systemCopyHot   avgt         1878.354          ns/op
C02.systemCopyWarm  avgt         4590.958          ns/op
--
C02.manualCopyCold  avgt       295074.343          ns/op
C02.manualCopyHot   avgt        58333.523          ns/op
C02.manualCopyWarm  avgt        57356.597          ns/op
C02.systemCopyCold  avgt         1943.131          ns/op
C02.systemCopyHot   avgt         1856.031          ns/op
C02.systemCopyWarm  avgt         4736.612          ns/op

public class Streams {
    final int SIZE = 1024;
    final int[] integers = new int[SIZE];
    ...

    @Benchmark
    @Warmup(iterations = 0, batchSize = 1)
    public int lambdaArrayCold() {
        return Arrays.stream(integers).filter(i -> i % 2 == 0).sum();
    }
    @Benchmark
    @Warmup(iterations = 1, time = 1, timeUnit = TimeUnit.SECONDS)
    public int lambdaArrayWarm() {...}

    @Benchmark
    @Warmup(iterations = 3, time = 5, timeUnit = TimeUnit.SECONDS)
    public int lambdaArrayHot() {...}

    @Benchmark
    @Warmup(iterations = 0, batchSize = 1)
    public int loopCold() {
        int sum = 0;
        for (int i = 0; i < integers.length; i++) {
            var v = integers[i];
            if (v % 2 == 0) {
                sum += v;
            }
        }
        return sum;
    }

    @Benchmark
    @Warmup(iterations = 1, time = 1, timeUnit = TimeUnit.SECONDS)
    public int loopWarm() {...}

    @Benchmark
    @Warmup(iterations = 3, time = 5, timeUnit = TimeUnit.SECONDS)
    public int loopHot() {...}
}

public class HeavyStreams {
    // as seen before

    @Benchmark
    @Warmup(iterations = 0, batchSize = 1)
    public int lambdaArrayCold() {
        return Arrays.stream(integers)
            .filter(i -> i.mod(BigInteger.TWO).equals(BigInteger.ZERO))
            .map(i -> i.sqrt())
            .mapToInt(BigInteger::intValue)
            .sum();
    }

    ...

    @Benchmark
    @Warmup(iterations = 0, batchSize = 1)
    public int loopCold() {
        int sum = 0;
        for (int i = 0; i < integers.length; i++) {
            var v = integers[i];

            if (v.mod(BigInteger.TWO).equals(BigInteger.ZERO)) {
                sum += v.sqrt().intValue();
            }
        }

        return sum;
    }
}

@State(Scope.Benchmark)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Measurement(iterations = 5, batchSize = 1, time=1, timeUnit = TimeUnit.NANOSECONDS)
@Fork(1)
public class HeavyStreamsConsume {
    final int SIZE = 1024;
    final int[] integers = new int[SIZE];

    static int calcAndBurn(int a) {
    	Blackhole.consumeCPU(10011);
    	return a % 2;
    }

    @Benchmark
    @Warmup(iterations = 0, batchSize = 1)
    public int lambdaArrayCold() {
        return Arrays
        		.stream(integers)
        		.filter(i -> calcAndBurn(i) == 0).sum();
    }

    @Benchmark
    @Warmup(iterations = 0, batchSize = 1)
    public int loopCold() {
        int sum = 0;
        for (int i = 0; i < integers.length; i++) {
            var v = integers[i];
            if (calcAndBurn(v) == 0) {
                sum += v;
            }
        }

        return sum;
    }
}

@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
@State(Scope.Thread)
public class M01
{
    ...
	@Benchmark
	@BenchmarkMode(Mode.AverageTime)
	@OutputTimeUnit(TimeUnit.NANOSECONDS)
	public long sum_AverageTime()
    {
		long result = 0;
		for (int i = 0; i < data.length; i++)
        {
			result += data[i];
			Blackhole.consumeCPU(10);
		}

		return result;
	}

	@Benchmark
	@BenchmarkMode(Mode.Throughput)
	@OutputTimeUnit(TimeUnit.MILLISECONDS)
	public long sum_Throughput() { ... }

	@Benchmark
	@BenchmarkMode(Mode.SingleShotTime)
	@OutputTimeUnit(TimeUnit.NANOSECONDS)
	public long sum_SingleShotTime() { ... }

	@Benchmark
	@BenchmarkMode(Mode.SampleTime)
	@OutputTimeUnit(TimeUnit.NANOSECONDS)
	public long sum_SampleTime() { ... }
}

@Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
public class Error01 {
	int iterationCount = 0;
    final String[] integers = new String[1000];

    @Setup(Level.Iteration)
    public void setup(BenchmarkParams params)
    {
    	iterationCount++;

        for (int i = 0; i < integers.length; i++) {
            integers[i] = new String(String.valueOf(i));
        }
        // when we are beyond warmup the third time, inject failure
        if (iterationCount == params.getWarmup().getCount() + 6) {
            integers[integers.length / 2] = "any";
        }
        else {
            integers[integers.length / 2] = "42";
        }
    }

    @Benchmark
    public long parse() {
        long total = 0;
        for (int i = 0; i < integers.length; i++) {
            try {
                total += Integer.valueOf(integers[i]);
            }
            catch(NumberFormatException e) {
                total = 0;
            }
        }

        return total;
    }
}

@Warmup(iterations = 3, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 10, time = 500, timeUnit = TimeUnit.MILLISECONDS)
@Fork(value = 1, jvmArgsAppend = {"-Xms4g", "-Xmx4g", "-XX:+AlwaysPreTouch"})
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
public class Error02 {
	int iterationCount = 0;
    final String[] integers = new String[1000];

    @Setup(Level.Iteration)
    public void setup(BenchmarkParams params) {
    	iterationCount++;

        for (int i = 0; i < integers.length; i++) {
            integers[i] = new String(String.valueOf(i));
        }
        // when we are beyond warmup the third time, inject failure
        if (iterationCount == params.getWarmup().getCount() + 6) {
        	integers[integers.length / 2] = "any";
        }
        else {
            integers[integers.length / 2] = "yas";
        }
    }

    @Benchmark
    public long parse() {
    	long total = 0;
    	for (int i = 0; i < integers.length; i++) {
    		try {
    			total += Integer.valueOf(integers[i]);
    		}
    		catch(NumberFormatException e) {
    			total = 0;
    		}
    	}

    	return total;
    }
}

public class BranchPrediction {
    private static final int COUNT = 10000;

    // sorted ints
    private int[] sorted = new int[COUNT];
    // fully unsorted
    private int[] unsorted = new int[COUNT];
    // alternating branch usage
    private int[] pattern2 = new int[COUNT];
    // 80/20 branch usage
    private int[] pattern5 = new int[COUNT];
    // data from pattern2, but shuffled
    private int[] shuffledPattern = new int[COUNT];

    @Setup
    public void setup() {
        final Random r = new Random(13241L);

        for (int i = 0; i < COUNT; i++) {
        	final int d = r.nextInt(100_000_000) + 1;
            sorted[i] = d;
            unsorted[i] = d;
            pattern2[i] = i % 2 == 0 ? 100_000_000 : r.nextInt(50_000_000);
            pattern5[i] = i % 5 == 0 ? 100_000_000 : r.nextInt(50_000_000);
            shuffledPattern[i] = pattern2[i];
        }
        Arrays.sort(sorted);

        // make it noisy to break the branch predictor
        for (int i = 0; i < shuffledPattern.length; i++) {
            int j = r.nextInt(shuffledPattern.length);
            var t = shuffledPattern[j];
            shuffledPattern[j] = shuffledPattern[i];
            shuffledPattern[i] = t;
        }
    }

    public long doIt(int[] array) {
        long sum = 2;
        for (int v : array) {
            if (v > 50_000_000) {
                sum += (v >> 2);
            }
            else {
                sum += (v << 2);
            }
        }
        return sum;
    }


    @Benchmark
    public long sorted() {
    	return doIt(sorted);
    }
    ...
}

Branch01.pattern2                          avgt    5   4763.210 ±  12.230      ns/op
Branch01.pattern2:IPC                      avgt           4.740            insns/clk
Branch01.pattern2:L1-dcache-load-misses    avgt         535.867                 #/op
Branch01.pattern2:L1-dcache-loads          avgt        8442.117                 #/op
Branch01.pattern2:branch-misses            avgt           4.468                 #/op
Branch01.pattern2:branches                 avgt       14288.724                 #/op
Branch01.pattern2:cycles                   avgt       12237.059                 #/op
Branch01.pattern2:dTLB-load-misses         avgt           0.023                 #/op
Branch01.pattern2:dTLB-loads               avgt           0.318                 #/op
Branch01.pattern2:instructions             avgt       58002.780                 #/op
Branch01.pattern2:stalled-cycles-frontend  avgt         100.277                 #/op

Branch01.pattern5                          avgt    5   4192.828 ± 359.636      ns/op
Branch01.pattern5:IPC                      avgt           5.220            insns/clk
Branch01.pattern5:L1-dcache-load-misses    avgt         535.540                 #/op
Branch01.pattern5:L1-dcache-loads          avgt        8428.333                 #/op
Branch01.pattern5:branch-misses            avgt           3.536                 #/op
Branch01.pattern5:branches                 avgt       11897.675                 #/op
Branch01.pattern5:cycles                   avgt       10714.181                 #/op
Branch01.pattern5:dTLB-load-misses         avgt           0.021                 #/op
Branch01.pattern5:dTLB-loads               avgt           0.296                 #/op
Branch01.pattern5:instructions             avgt       55924.576                 #/op
Branch01.pattern5:stalled-cycles-frontend  avgt         129.842                 #/op

Branch01.random                            avgt    5   7763.375 ± 483.591      ns/op
Branch01.random:IPC                        avgt           2.935            insns/clk
Branch01.random:L1-dcache-load-misses      avgt         534.159                 #/op
Branch01.random:L1-dcache-loads            avgt        8454.813                 #/op
Branch01.random:branch-misses              avgt           2.361                 #/op
Branch01.random:branches                   avgt       14225.074                 #/op
Branch01.random:cycles                     avgt       19737.984                 #/op
Branch01.random:dTLB-load-misses           avgt           0.029                 #/op
Branch01.random:dTLB-loads                 avgt           0.528                 #/op
Branch01.random:instructions               avgt       57938.467                 #/op
Branch01.random:stalled-cycles-frontend    avgt        6542.892                 #/op

Branch01.pattern2                          avgt    5  12644.421 ±    32.790      ns/op
Branch01.pattern2:IPC                      avgt           4.101              insns/clk
Branch01.pattern2:L1-dcache-load-misses    avgt         635.322                   #/op
Branch01.pattern2:L1-dcache-loads          avgt       10065.464                   #/op
Branch01.pattern2:branch-misses            avgt           5.700                   #/op
Branch01.pattern2:branches                 avgt       17610.050                   #/op
Branch01.pattern2:cycles                   avgt       17783.624                   #/op
Branch01.pattern2:instructions             avgt       72937.027                   #/op
Branch01.pattern2:stalled-cycles-backend   avgt        2556.326                   #/op
Branch01.pattern2:stalled-cycles-frontend  avgt          14.046                   #/op

Branch01.pattern5                          avgt    5  11561.519 ±    91.598      ns/op
Branch01.pattern5:IPC                      avgt           4.301              insns/clk
Branch01.pattern5:L1-dcache-load-misses    avgt         634.284                   #/op
Branch01.pattern5:L1-dcache-loads          avgt       10058.859                   #/op
Branch01.pattern5:branch-misses            avgt           4.610                   #/op
Branch01.pattern5:branches                 avgt       14569.519                   #/op
Branch01.pattern5:cycles                   avgt       16247.216                   #/op
Branch01.pattern5:instructions             avgt       69877.428                   #/op
Branch01.pattern5:stalled-cycles-backend   avgt        3526.451                   #/op
Branch01.pattern5:stalled-cycles-frontend  avgt          19.762                   #/op

Branch01.random                            avgt    5  39071.484 ± 11327.252      ns/op
Branch01.random:IPC                        avgt           1.285              insns/clk
Branch01.random:L1-dcache-load-misses      avgt         650.766                   #/op
Branch01.random:L1-dcache-loads            avgt       11321.971                   #/op
Branch01.random:branch-misses              avgt         975.152                   #/op
Branch01.random:branches                   avgt       17595.904                   #/op
Branch01.random:cycles                     avgt       56724.714                   #/op
Branch01.random:instructions               avgt       72887.307                   #/op
Branch01.random:stalled-cycles-backend     avgt         270.540                   #/op
Branch01.random:stalled-cycles-frontend    avgt        1286.695                   #/op

public class E01
{
    final int[] integers = new int[1000];

    @Setup
    public void setup() {
        for (int i = 0; i < integers.length; i++) {
            integers[i] = i;
        }
    }

    @Benchmark
    public int lambda() {
        return Arrays.stream(integers).filter(i -> i % 2 == 0).sum();
    }

    @Benchmark
    public int loop() {
        int sum = 0;
        for (int i = 0; i < integers.length; i++) {
            var v = integers[i];
            if (v % 2 == 0) {
                sum += v;
            }
        }

        return sum;
    }
}

public class E02
{
    ...
    private static int calc(final int a) {
        // consume time and cpu, but don't waste memory
        // trick the compiler too and avoid optimization
        // by creating a side-effect
    	Blackhole.consumeCPU(100);

    	return a;
    }

    @Benchmark
    public int lambda() {
        return Arrays.stream(integers)
            .filter(i -> calc(i) % 2 == 0)
            .sum();
    }

    @Benchmark
    public int loop() {
        int sum = 0;
        for (int i = 0; i < integers.length; i++) {
            var v = calc(integers[i]);
            if (v % 2 == 0) {
                sum += v;
            }
        }

        return sum;
    }
}

...
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@State(Scope.Benchmark)
public class T01
{
    final int SIZE = 10000;
    List<String> csv = new ArrayList<>(SIZE);

    @Setup(Level.Trial)
    public void setup()	{
    	var r = new FastRandom(41L);
    	for (int i = 0; i < SIZE; i++) {
    		var sb = new StringJoiner(",");
    		for (int j = 0; j < 5; j++) {
    			sb.add(RandomUtils.randomString(r, 15));
    		}
    		csv.add(sb.toString());
    	}
    }

    @Benchmark
    @Threads(1)
    public long split_1() {
    	long count = 0;
    	for (var s : csv) {
    		count += s.split(",").length;
    	}
    	return count;
    }

    @Benchmark
    @Threads(2)
    public long split_2() { ... }
}

# T14s Gen 1, AMD 8+8 Core, 32 GB memory
# Mode powersave (battery)
Benchmark    Mode  Cnt     Score     Error  Units
T01.split_1  avgt    3  1111.237 ±  76.534  us/op
T01.split_2  avgt    3  1247.724 ± 149.086  us/op
T01.split_4  avgt    3  1387.988 ± 255.601  us/op
T01.split_6  avgt    3  1659.864 ± 226.979  us/op
T01.split_8  avgt    3  2243.382 ± 207.846  us/op

# T14s Gen 1, AMD 8+8 Core, 32 GB memory
# Mode performance (plugged in)
Benchmark    Mode  Cnt     Score      Error  Units
T01.split_1  avgt    3  1035.574 ±  139.435  us/op
T01.split_2  avgt    3  1167.293 ±  102.166  us/op
T01.split_4  avgt    3  1480.129 ±  563.533  us/op
T01.split_6  avgt    3  1933.609 ± 1095.241  us/op
T01.split_8  avgt    3  2291.194 ±  321.369  us/op

• It does not scale!
• Why?
• We only share read-only data

# -prof gc, mode performance
Benchmark                       Mode  Cnt        Score      Error   Units
T01.split_1                     avgt    3     1318.253 ±  670.168   us/op
T01.split_1:gc.alloc.rate       avgt    3     2894.884 ± 1494.720  MB/sec
T01.split_1:gc.alloc.rate.norm  avgt    3  4000000.389 ±    0.874    B/op
T01.split_1:gc.count            avgt    3        7.000             counts
T01.split_1:gc.time             avgt    3       19.000                 ms
T01.split_2                     avgt    3     1177.087 ±  293.667   us/op
T01.split_2:gc.alloc.rate       avgt    3     6479.263 ± 1621.990  MB/sec
T01.split_2:gc.alloc.rate.norm  avgt    3  4000000.350 ±    0.558    B/op
T01.split_2:gc.count            avgt    3       16.000             counts
T01.split_2:gc.time             avgt    3       27.000                 ms
T01.split_4                     avgt    3     1483.509 ±  553.779   us/op
T01.split_4:gc.alloc.rate       avgt    3    10279.160 ± 3869.941  MB/sec
T01.split_4:gc.alloc.rate.norm  avgt    3  4000001.102 ±   21.109    B/op
T01.split_4:gc.count            avgt    3       26.000             counts
T01.split_4:gc.time             avgt    3       35.000                 ms
T01.split_6                     avgt    3     1992.545 ±  327.078   us/op
T01.split_6:gc.alloc.rate       avgt    3    11473.173 ± 1753.518  MB/sec
T01.split_6:gc.alloc.rate.norm  avgt    3  4000001.164 ±   18.958    B/op
T01.split_6:gc.count            avgt    3       28.000             counts
T01.split_6:gc.time             avgt    3       34.000                 ms
T01.split_8                     avgt    3     2314.763 ±  646.143   us/op
T01.split_8:gc.alloc.rate       avgt    3    13216.420 ± 3163.362  MB/sec
T01.split_8:gc.alloc.rate.norm  avgt    3  4000000.627 ±    0.149    B/op
T01.split_8:gc.count            avgt    3       32.000             counts
T01.split_8:gc.time             avgt    3       36.000                 ms

• It does not scale!

# -prof gc, no SMT and turbo, mode performance, -XX:+UseG1GC
Benchmark                       Mode  Cnt        Score     Error   Units
T01.split_1                     avgt    3     2841.890 ± 219.913   us/op
T01.split_1:gc.alloc.rate       avgt    3     1342.067 ± 104.672  MB/sec
T01.split_1:gc.alloc.rate.norm  avgt    3  4000000.803 ±   0.460    B/op
T01.split_1:gc.count            avgt    3        3.000            counts
T01.split_1:gc.time             avgt    3       10.000                ms
T01.split_2                     avgt    3     2506.612 ±  42.312   us/op
T01.split_2:gc.alloc.rate       avgt    3     3041.421 ±  50.525  MB/sec
T01.split_2:gc.alloc.rate.norm  avgt    3  4000000.746 ±   0.949    B/op
T01.split_2:gc.count            avgt    3        7.000            counts
T01.split_2:gc.time             avgt    3       22.000                ms
T01.split_4                     avgt    3     2519.438 ± 251.261   us/op
T01.split_4:gc.alloc.rate       avgt    3     6049.532 ± 620.042  MB/sec
T01.split_4:gc.alloc.rate.norm  avgt    3  4000001.828 ±  34.873    B/op
T01.split_4:gc.count            avgt    3       15.000            counts
T01.split_4:gc.time             avgt    3       38.000                ms
T01.split_6                     avgt    3     2567.769 ± 106.240   us/op
T01.split_6:gc.alloc.rate       avgt    3     8889.642 ± 340.287  MB/sec
T01.split_6:gc.alloc.rate.norm  avgt    3  4000000.707 ±   0.080    B/op
T01.split_6:gc.count            avgt    3       22.000            counts
T01.split_6:gc.time             avgt    3       44.000                ms
T01.split_8                     avgt    3     2682.544 ± 246.422   us/op
T01.split_8:gc.alloc.rate       avgt    3    11352.457 ± 942.768  MB/sec
T01.split_8:gc.alloc.rate.norm  avgt    3  4000000.746 ±   0.277    B/op
T01.split_8:gc.count            avgt    3       28.000            counts
T01.split_8:gc.time             avgt    3       51.000                ms

# -prof gc, no SMT and turbo, mode performance, -XX:+UseG1GC
Benchmark                       Mode  Cnt        Score     Error   Units
T01.split_1                     avgt    3     2841.890 ± 219.913   us/op
T01.split_1:gc.alloc.rate       avgt    3     1342.067 ± 104.672  MB/sec
T01.split_1:gc.alloc.rate.norm  avgt    3  4000000.803 ±   0.460    B/op
T01.split_1:gc.count            avgt    3        3.000            counts
T01.split_1:gc.time             avgt    3       10.000                ms
T01.split_2                     avgt    3     2506.612 ±  42.312   us/op
T01.split_2:gc.alloc.rate       avgt    3     3041.421 ±  50.525  MB/sec
T01.split_2:gc.alloc.rate.norm  avgt    3  4000000.746 ±   0.949    B/op
T01.split_2:gc.count            avgt    3        7.000            counts
T01.split_2:gc.time             avgt    3       22.000                ms
T01.split_4                     avgt    3     2519.438 ± 251.261   us/op
T01.split_4:gc.alloc.rate       avgt    3     6049.532 ± 620.042  MB/sec
T01.split_4:gc.alloc.rate.norm  avgt    3  4000001.828 ±  34.873    B/op
T01.split_4:gc.count            avgt    3       15.000            counts
T01.split_4:gc.time             avgt    3       38.000                ms
T01.split_6                     avgt    3     2567.769 ± 106.240   us/op
T01.split_6:gc.alloc.rate       avgt    3     8889.642 ± 340.287  MB/sec
T01.split_6:gc.alloc.rate.norm  avgt    3  4000000.707 ±   0.080    B/op
T01.split_6:gc.count            avgt    3       22.000            counts
T01.split_6:gc.time             avgt    3       44.000                ms
T01.split_8                     avgt    3     2682.544 ± 246.422   us/op
T01.split_8:gc.alloc.rate       avgt    3    11352.457 ± 942.768  MB/sec
T01.split_8:gc.alloc.rate.norm  avgt    3  4000000.746 ±   0.277    B/op
T01.split_8:gc.count            avgt    3       28.000            counts
T01.split_8:gc.time             avgt    3       51.000                ms

# -prof gc, no SMT and turbo, mode performance, -XX:+UseG1GC
Benchmark                       Mode  Cnt        Score     Error   Units
T01.split_1                     avgt    3     2841.890 ± 219.913   us/op
T01.split_1:gc.alloc.rate       avgt    3     1342.067 ± 104.672  MB/sec
T01.split_1:gc.alloc.rate.norm  avgt    3  4000000.803 ±   0.460    B/op
T01.split_1:gc.count            avgt    3        3.000            counts
T01.split_1:gc.time             avgt    3       10.000                ms
T01.split_2                     avgt    3     2506.612 ±  42.312   us/op
T01.split_2:gc.alloc.rate       avgt    3     3041.421 ±  50.525  MB/sec
T01.split_2:gc.alloc.rate.norm  avgt    3  4000000.746 ±   0.949    B/op
T01.split_2:gc.count            avgt    3        7.000            counts
T01.split_2:gc.time             avgt    3       22.000                ms
T01.split_4                     avgt    3     2519.438 ± 251.261   us/op
T01.split_4:gc.alloc.rate       avgt    3     6049.532 ± 620.042  MB/sec
T01.split_4:gc.alloc.rate.norm  avgt    3  4000001.828 ±  34.873    B/op
T01.split_4:gc.count            avgt    3       15.000            counts
T01.split_4:gc.time             avgt    3       38.000                ms
T01.split_6                     avgt    3     2567.769 ± 106.240   us/op
T01.split_6:gc.alloc.rate       avgt    3     8889.642 ± 340.287  MB/sec
T01.split_6:gc.alloc.rate.norm  avgt    3  4000000.707 ±   0.080    B/op
T01.split_6:gc.count            avgt    3       22.000            counts
T01.split_6:gc.time             avgt    3       44.000                ms
T01.split_8                     avgt    3     2682.544 ± 246.422   us/op
T01.split_8:gc.alloc.rate       avgt    3    11352.457 ± 942.768  MB/sec
T01.split_8:gc.alloc.rate.norm  avgt    3  4000000.746 ±   0.277    B/op
T01.split_8:gc.count            avgt    3       28.000            counts
T01.split_8:gc.time             avgt    3       51.000                ms

public class Strings1 {
    private static final String PREFIX = "a";
    private String foo = null;
    private int LENGTH;

    @Setup
    public void setup() {
        //                        13 chars                  18 chars
        foo = String.valueOf(System.currentTimeMillis()) + "ashdfhgas dfhsa df";
        LENGTH = plain().length();
    }

    @Benchmark
    public String plain() {
        return PREFIX + foo;
    }

    @Benchmark
    public String concat() {
        return PREFIX.concat(foo);
    }

    @Benchmark
    public String builder() {
        return new StringBuilder().append(PREFIX).append(foo).toString();
    }

    @Benchmark
    public String builderSized() {
        return new StringBuilder(LENGTH).append(PREFIX).append(foo).toString();
    }

    @Benchmark
    public String builderNonFluid() {
        final StringBuilder sb = new StringBuilder();
        sb.append(PREFIX);
        sb.append(foo);
        return sb.toString();
    }

    @Benchmark
    public String builderNonFluidSized() {
        final StringBuilder sb = new StringBuilder(LENGTH);
        sb.append(PREFIX);
        sb.append(foo);
        return sb.toString();
    }
}

public class Strings2 {
    private String[] foo = new String[5];
    private Random r = new Random(1L);

    @Setup
    public void setup() {
        foo[0] = String.valueOf(r.nextInt()) + "ashdfhgas dfhsa df";
        foo[1] = String.valueOf(r.nextInt()) + "hsa df";
        foo[2] = String.valueOf(r.nextInt()) + "fhsa df";
        foo[3] = String.valueOf(r.nextInt()) + "as dfhsa df";
        foo[4] = String.valueOf(r.nextInt())
                        + "ashdfhgas dfhsa hsajdhf kjahskjdh fkjhsa dhfkjskhj hdf"
                        + "ashdfhgas dfhsa hsajdhf kjahs as87837 837 987kjskhj hdf";
    }

    public String foo() {
        return foo[r.nextInt(5)];
    }

    @Benchmark
    public String plain() {
        return "a" + foo();
    }

    @Benchmark
    public String concat() {
        return "a".concat(foo());
    }

    @Benchmark
    public String builder() {
        return new StringBuilder().append("a").append(foo()).toString();
    }
    ...
}