COMMAND: ./gradlew --offline --no-daemon --console=plain jmh
To honour the JVM settings for this build a single-use Daemon process will be forked. For more on this, please refer to https://docs.gradle.org/8.14/userguide/gradle_daemon.html#sec:disabling_the_daemon in the Gradle documentation.
Daemon will be stopped at the end of the build 
> Task :checkKotlinGradlePluginConfigurationErrors SKIPPED
> Task :domain:checkKotlinGradlePluginConfigurationErrors SKIPPED
> Task :domain:compileKotlin UP-TO-DATE
> Task :domain:compileJava NO-SOURCE
> Task :domain:processResources NO-SOURCE
> Task :domain:classes UP-TO-DATE
> Task :domain:jar UP-TO-DATE
> Task :compileKotlin UP-TO-DATE
> Task :compileJava UP-TO-DATE
> Task :processResources NO-SOURCE
> Task :classes UP-TO-DATE
> Task :jar UP-TO-DATE
> Task :compileTestKotlin UP-TO-DATE
> Task :compileTestJava UP-TO-DATE
> Task :processTestResources NO-SOURCE
> Task :testClasses UP-TO-DATE

> Task :jmh
# JMH version: 1.37
# VM version: JDK 21.0.12.1, OpenJDK 64-Bit Server VM, 21.0.12.1+1-1-24.04.4-Ubuntu
# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java
# VM options: -Dfile.encoding=UTF-8 -Duser.country=US -Duser.language=en -Duser.variant
# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable)
# Warmup: 3 iterations, 250 ms each
# Measurement: 4 iterations, 250 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: example.tasks.TaskCostBenchmark.boxedIds

# Run progress: 0.00% complete, ETA 00:00:21
# Fork: 1 of 2
# Warmup Iteration   1: 30.171 us/op
# Warmup Iteration   2: 12.341 us/op
# Warmup Iteration   3: 11.042 us/op
Iteration   1: 12.905 us/op
                 gc.alloc.rate:      1514.069 MB/sec
                 gc.alloc.rate.norm: 20520.357 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   2: 9.896 us/op
                 gc.alloc.rate:      1974.847 MB/sec
                 gc.alloc.rate.norm: 20520.274 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   3: 10.768 us/op
                 gc.alloc.rate:      1815.035 MB/sec
                 gc.alloc.rate.norm: 20520.303 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   4: 10.568 us/op
                 gc.alloc.rate:      1849.196 MB/sec
                 gc.alloc.rate.norm: 20520.293 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms


# Run progress: 8.33% complete, ETA 00:00:33
# Fork: 2 of 2
# Warmup Iteration   1: 24.515 us/op
# Warmup Iteration   2: 11.615 us/op
# Warmup Iteration   3: 10.937 us/op
Iteration   1: 11.087 us/op
                 gc.alloc.rate:      1762.386 MB/sec
                 gc.alloc.rate.norm: 20520.308 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   2: 10.342 us/op
                 gc.alloc.rate:      1889.627 MB/sec
                 gc.alloc.rate.norm: 20520.291 B/op
                 gc.count:           4.000 counts
                 gc.time:            6.000 ms

Iteration   3: 11.196 us/op
                 gc.alloc.rate:      1745.274 MB/sec
                 gc.alloc.rate.norm: 20520.311 B/op
                 gc.count:           2.000 counts
                 gc.time:            2.000 ms

Iteration   4: 10.797 us/op
                 gc.alloc.rate:      1809.954 MB/sec
                 gc.alloc.rate.norm: 20520.300 B/op
                 gc.count:           3.000 counts
                 gc.time:            6.000 ms



Result "example.tasks.TaskCostBenchmark.boxedIds":
  10.945 ±(99.9%) 1.708 us/op [Average]
  (min, avg, max) = (9.896, 10.945, 12.905), stdev = 0.893
  CI (99.9%): [9.237, 12.652] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.boxedIds:gc.alloc.rate":
  1795.049 ±(99.9%) 257.858 MB/sec [Average]
  (min, avg, max) = (1514.069, 1795.049, 1974.847), stdev = 134.865
  CI (99.9%): [1537.190, 2052.907] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.boxedIds:gc.alloc.rate.norm":
  20520.305 ±(99.9%) 0.046 B/op [Average]
  (min, avg, max) = (20520.274, 20520.305, 20520.357), stdev = 0.024
  CI (99.9%): [20520.259, 20520.350] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.boxedIds:gc.count":
  24.000 ±(99.9%) 0.001 counts [Sum]
  (min, avg, max) = (2.000, 3.000, 4.000), stdev = 0.535
  CI (99.9%): [24.000, 24.000] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.boxedIds:gc.time":
  35.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (2.000, 4.375, 6.000), stdev = 1.302
  CI (99.9%): [35.000, 35.000] (assumes normal distribution)


# JMH version: 1.37
# VM version: JDK 21.0.12.1, OpenJDK 64-Bit Server VM, 21.0.12.1+1-1-24.04.4-Ubuntu
# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java
# VM options: -Dfile.encoding=UTF-8 -Duser.country=US -Duser.language=en -Duser.variant
# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable)
# Warmup: 3 iterations, 250 ms each
# Measurement: 4 iterations, 250 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: example.tasks.TaskCostBenchmark.direct

# Run progress: 16.67% complete, ETA 00:00:30
# Fork: 1 of 2
# Warmup Iteration   1: 0.070 us/op
# Warmup Iteration   2: 0.069 us/op
# Warmup Iteration   3: 0.026 us/op
Iteration   1: 0.017 us/op
                 gc.alloc.rate:      4402.809 MB/sec
                 gc.alloc.rate.norm: 80.000 B/op
                 gc.count:           2.000 counts
                 gc.time:            5.000 ms

Iteration   2: 0.017 us/op
                 gc.alloc.rate:      4518.310 MB/sec
                 gc.alloc.rate.norm: 80.000 B/op
                 gc.count:           2.000 counts
                 gc.time:            5.000 ms

Iteration   3: 0.017 us/op
                 gc.alloc.rate:      4426.017 MB/sec
                 gc.alloc.rate.norm: 80.000 B/op
                 gc.count:           2.000 counts
                 gc.time:            4.000 ms

Iteration   4: 0.017 us/op
                 gc.alloc.rate:      4414.908 MB/sec
                 gc.alloc.rate.norm: 80.000 B/op
                 gc.count:           2.000 counts
                 gc.time:            5.000 ms


# Run progress: 25.00% complete, ETA 00:00:28
# Fork: 2 of 2
# Warmup Iteration   1: 0.076 us/op
# Warmup Iteration   2: 0.051 us/op
# Warmup Iteration   3: 0.049 us/op
Iteration   1: 0.017 us/op
                 gc.alloc.rate:      4482.295 MB/sec
                 gc.alloc.rate.norm: 80.000 B/op
                 gc.count:           2.000 counts
                 gc.time:            4.000 ms

Iteration   2: 0.017 us/op
                 gc.alloc.rate:      4460.641 MB/sec
                 gc.alloc.rate.norm: 80.000 B/op
                 gc.count:           2.000 counts
                 gc.time:            4.000 ms

Iteration   3: 0.017 us/op
                 gc.alloc.rate:      4544.176 MB/sec
                 gc.alloc.rate.norm: 80.000 B/op
                 gc.count:           2.000 counts
                 gc.time:            4.000 ms

Iteration   4: 0.017 us/op
                 gc.alloc.rate:      4456.716 MB/sec
                 gc.alloc.rate.norm: 80.000 B/op
                 gc.count:           2.000 counts
                 gc.time:            4.000 ms



Result "example.tasks.TaskCostBenchmark.direct":
  0.017 ±(99.9%) 0.001 us/op [Average]
  (min, avg, max) = (0.017, 0.017, 0.017), stdev = 0.001
  CI (99.9%): [0.017, 0.017] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.direct:gc.alloc.rate":
  4463.234 ±(99.9%) 95.241 MB/sec [Average]
  (min, avg, max) = (4402.809, 4463.234, 4544.176), stdev = 49.813
  CI (99.9%): [4367.993, 4558.474] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.direct:gc.alloc.rate.norm":
  80.000 ±(99.9%) 0.001 B/op [Average]
  (min, avg, max) = (80.000, 80.000, 80.000), stdev = 0.001
  CI (99.9%): [80.000, 80.000] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.direct:gc.count":
  16.000 ±(99.9%) 0.001 counts [Sum]
  (min, avg, max) = (2.000, 2.000, 2.000), stdev = 0.001
  CI (99.9%): [16.000, 16.000] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.direct:gc.time":
  35.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (4.000, 4.375, 5.000), stdev = 0.518
  CI (99.9%): [35.000, 35.000] (assumes normal distribution)


# JMH version: 1.37
# VM version: JDK 21.0.12.1, OpenJDK 64-Bit Server VM, 21.0.12.1+1-1-24.04.4-Ubuntu
# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java
# VM options: -Dfile.encoding=UTF-8 -Duser.country=US -Duser.language=en -Duser.variant
# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable)
# Warmup: 3 iterations, 250 ms each
# Measurement: 4 iterations, 250 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: example.tasks.TaskCostBenchmark.eager

# Run progress: 33.33% complete, ETA 00:00:24
# Fork: 1 of 2
# Warmup Iteration   1: 541.151 us/op
# Warmup Iteration   2: 75.998 us/op
# Warmup Iteration   3: 67.037 us/op
Iteration   1: 69.574 us/op
                 gc.alloc.rate:      1627.819 MB/sec
                 gc.alloc.rate.norm: 118929.931 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms

Iteration   2: 54.291 us/op
                 gc.alloc.rate:      2086.172 MB/sec
                 gc.alloc.rate.norm: 118929.507 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms

Iteration   3: 63.410 us/op
                 gc.alloc.rate:      1786.094 MB/sec
                 gc.alloc.rate.norm: 118929.760 B/op
                 gc.count:           3.000 counts
                 gc.time:            3.000 ms

Iteration   4: 55.519 us/op
                 gc.alloc.rate:      2039.945 MB/sec
                 gc.alloc.rate.norm: 118929.541 B/op
                 gc.count:           4.000 counts
                 gc.time:            4.000 ms


# Run progress: 41.67% complete, ETA 00:00:21
# Fork: 2 of 2
# Warmup Iteration   1: 567.656 us/op
# Warmup Iteration   2: 66.872 us/op
# Warmup Iteration   3: 59.893 us/op
Iteration   1: 70.388 us/op
                 gc.alloc.rate:      1609.043 MB/sec
                 gc.alloc.rate.norm: 118929.953 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms

Iteration   2: 54.876 us/op
                 gc.alloc.rate:      2063.178 MB/sec
                 gc.alloc.rate.norm: 118929.523 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   3: 52.766 us/op
                 gc.alloc.rate:      2146.156 MB/sec
                 gc.alloc.rate.norm: 118929.458 B/op
                 gc.count:           4.000 counts
                 gc.time:            4.000 ms

Iteration   4: 63.036 us/op
                 gc.alloc.rate:      1796.476 MB/sec
                 gc.alloc.rate.norm: 118929.750 B/op
                 gc.count:           4.000 counts
                 gc.time:            4.000 ms



Result "example.tasks.TaskCostBenchmark.eager":
  60.482 ±(99.9%) 13.516 us/op [Average]
  (min, avg, max) = (52.766, 60.482, 70.388), stdev = 7.069
  CI (99.9%): [46.966, 73.999] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.alloc.rate":
  1894.360 ±(99.9%) 411.116 MB/sec [Average]
  (min, avg, max) = (1609.043, 1894.360, 2146.156), stdev = 215.022
  CI (99.9%): [1483.244, 2305.477] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.alloc.rate.norm":
  118929.678 ±(99.9%) 0.377 B/op [Average]
  (min, avg, max) = (118929.458, 118929.678, 118929.953), stdev = 0.197
  CI (99.9%): [118929.301, 118930.055] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.count":
  30.000 ±(99.9%) 0.001 counts [Sum]
  (min, avg, max) = (3.000, 3.750, 4.000), stdev = 0.463
  CI (99.9%): [30.000, 30.000] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.time":
  34.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (3.000, 4.250, 5.000), stdev = 0.707
  CI (99.9%): [34.000, 34.000] (assumes normal distribution)


# JMH version: 1.37
# VM version: JDK 21.0.12.1, OpenJDK 64-Bit Server VM, 21.0.12.1+1-1-24.04.4-Ubuntu
# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java
# VM options: -Dfile.encoding=UTF-8 -Duser.country=US -Duser.language=en -Duser.variant
# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable)
# Warmup: 3 iterations, 250 ms each
# Measurement: 4 iterations, 250 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: example.tasks.TaskCostBenchmark.lazy

# Run progress: 50.00% complete, ETA 00:00:18
# Fork: 1 of 2
# Warmup Iteration   1: 429.099 us/op
# Warmup Iteration   2: 63.632 us/op
# Warmup Iteration   3: 54.208 us/op
Iteration   1: 53.044 us/op
                 gc.alloc.rate:      2061.638 MB/sec
                 gc.alloc.rate.norm: 114825.470 B/op
                 gc.count:           4.000 counts
                 gc.time:            4.000 ms

Iteration   2: 49.415 us/op
                 gc.alloc.rate:      2213.005 MB/sec
                 gc.alloc.rate.norm: 114825.366 B/op
                 gc.count:           5.000 counts
                 gc.time:            6.000 ms

Iteration   3: 48.911 us/op
                 gc.alloc.rate:      2235.925 MB/sec
                 gc.alloc.rate.norm: 114825.351 B/op
                 gc.count:           4.000 counts
                 gc.time:            3.000 ms

Iteration   4: 51.916 us/op
                 gc.alloc.rate:      2106.190 MB/sec
                 gc.alloc.rate.norm: 114825.426 B/op
                 gc.count:           4.000 counts
                 gc.time:            4.000 ms


# Run progress: 58.33% complete, ETA 00:00:15
# Fork: 2 of 2
# Warmup Iteration   1: 327.168 us/op
# Warmup Iteration   2: 57.426 us/op
# Warmup Iteration   3: 54.798 us/op
Iteration   1: 55.677 us/op
                 gc.alloc.rate:      1959.807 MB/sec
                 gc.alloc.rate.norm: 114825.545 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms

Iteration   2: 48.185 us/op
                 gc.alloc.rate:      2269.049 MB/sec
                 gc.alloc.rate.norm: 114825.337 B/op
                 gc.count:           4.000 counts
                 gc.time:            3.000 ms

Iteration   3: 50.127 us/op
                 gc.alloc.rate:      2181.629 MB/sec
                 gc.alloc.rate.norm: 114825.391 B/op
                 gc.count:           4.000 counts
                 gc.time:            4.000 ms

Iteration   4: 46.909 us/op
                 gc.alloc.rate:      2331.307 MB/sec
                 gc.alloc.rate.norm: 114825.302 B/op
                 gc.count:           4.000 counts
                 gc.time:            4.000 ms



Result "example.tasks.TaskCostBenchmark.lazy":
  50.523 ±(99.9%) 5.474 us/op [Average]
  (min, avg, max) = (46.909, 50.523, 55.677), stdev = 2.863
  CI (99.9%): [45.049, 55.997] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.alloc.rate":
  2169.819 ±(99.9%) 230.976 MB/sec [Average]
  (min, avg, max) = (1959.807, 2169.819, 2331.307), stdev = 120.805
  CI (99.9%): [1938.843, 2400.794] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.alloc.rate.norm":
  114825.399 ±(99.9%) 0.151 B/op [Average]
  (min, avg, max) = (114825.302, 114825.399, 114825.545), stdev = 0.079
  CI (99.9%): [114825.247, 114825.550] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.count":
  33.000 ±(99.9%) 0.001 counts [Sum]
  (min, avg, max) = (4.000, 4.125, 5.000), stdev = 0.354
  CI (99.9%): [33.000, 33.000] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.time":
  33.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (3.000, 4.125, 6.000), stdev = 0.991
  CI (99.9%): [33.000, 33.000] (assumes normal distribution)


# JMH version: 1.37
# VM version: JDK 21.0.12.1, OpenJDK 64-Bit Server VM, 21.0.12.1+1-1-24.04.4-Ubuntu
# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java
# VM options: -Dfile.encoding=UTF-8 -Duser.country=US -Duser.language=en -Duser.variant
# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable)
# Warmup: 3 iterations, 250 ms each
# Measurement: 4 iterations, 250 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: example.tasks.TaskCostBenchmark.rawIds

# Run progress: 66.67% complete, ETA 00:00:12
# Fork: 1 of 2
# Warmup Iteration   1: 7.995 us/op
# Warmup Iteration   2: 7.108 us/op
# Warmup Iteration   3: 6.395 us/op
Iteration   1: 7.613 us/op
                 gc.alloc.rate:      514.393 MB/sec
                 gc.alloc.rate.norm: 4136.211 B/op
                 gc.count:           1.000 counts
                 gc.time:            1.000 ms

Iteration   2: 5.995 us/op
                 gc.alloc.rate:      656.905 MB/sec
                 gc.alloc.rate.norm: 4136.166 B/op
                 gc.count:           3.000 counts
                 gc.time:            3.000 ms

Iteration   3: 5.752 us/op
                 gc.alloc.rate:      684.811 MB/sec
                 gc.alloc.rate.norm: 4136.159 B/op
                 gc.count:           2.000 counts
                 gc.time:            2.000 ms

Iteration   4: 5.905 us/op
                 gc.alloc.rate:      666.976 MB/sec
                 gc.alloc.rate.norm: 4136.163 B/op
                 gc.count:           2.000 counts
                 gc.time:            2.000 ms


# Run progress: 75.00% complete, ETA 00:00:08
# Fork: 2 of 2
# Warmup Iteration   1: 8.381 us/op
# Warmup Iteration   2: 8.946 us/op
# Warmup Iteration   3: 8.438 us/op
Iteration   1: 7.253 us/op
                 gc.alloc.rate:      543.112 MB/sec
                 gc.alloc.rate.norm: 4136.202 B/op
                 gc.count:           ≈ 0 counts

Iteration   2: 5.816 us/op
                 gc.alloc.rate:      677.233 MB/sec
                 gc.alloc.rate.norm: 4136.161 B/op
                 gc.count:           1.000 counts
                 gc.time:            1.000 ms

Iteration   3: 5.704 us/op
                 gc.alloc.rate:      690.634 MB/sec
                 gc.alloc.rate.norm: 4136.158 B/op
                 gc.count:           1.000 counts
                 gc.time:            1.000 ms

Iteration   4: 5.765 us/op
                 gc.alloc.rate:      681.406 MB/sec
                 gc.alloc.rate.norm: 4136.159 B/op
                 gc.count:           1.000 counts
                 gc.time:            1.000 ms



Result "example.tasks.TaskCostBenchmark.rawIds":
  6.225 ±(99.9%) 1.448 us/op [Average]
  (min, avg, max) = (5.704, 6.225, 7.613), stdev = 0.757
  CI (99.9%): [4.778, 7.673] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.alloc.rate":
  639.434 ±(99.9%) 132.953 MB/sec [Average]
  (min, avg, max) = (514.393, 639.434, 690.634), stdev = 69.537
  CI (99.9%): [506.481, 772.387] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.alloc.rate.norm":
  4136.173 ±(99.9%) 0.041 B/op [Average]
  (min, avg, max) = (4136.158, 4136.173, 4136.211), stdev = 0.021
  CI (99.9%): [4136.131, 4136.214] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.count":
  11.000 ±(99.9%) 0.001 counts [Sum]
  (min, avg, max) = (≈ 0, 1.375, 3.000), stdev = 0.916
  CI (99.9%): [11.000, 11.000] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.time":
  11.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (≈ 0, 1.375, 3.000), stdev = 0.916
  CI (99.9%): [11.000, 11.000] (assumes normal distribution)


# JMH version: 1.37
# VM version: JDK 21.0.12.1, OpenJDK 64-Bit Server VM, 21.0.12.1+1-1-24.04.4-Ubuntu
# VM invoker: /usr/lib/jvm/java-21-openjdk-amd64/bin/java
# VM options: -Dfile.encoding=UTF-8 -Duser.country=US -Duser.language=en -Duser.variant
# Blackhole mode: compiler (auto-detected, use -Djmh.blackhole.autoDetect=false to disable)
# Warmup: 3 iterations, 250 ms each
# Measurement: 4 iterations, 250 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: example.tasks.TaskCostBenchmark.suspended

# Run progress: 83.33% complete, ETA 00:00:05
# Fork: 1 of 2
# Warmup Iteration   1: 583586.563 us/op
# Warmup Iteration   2: 1.445 us/op
# Warmup Iteration   3: 0.288 us/op
Iteration   1: 0.232 us/op
                 gc.alloc.rate:      1280.698 MB/sec
                 gc.alloc.rate.norm: 312.006 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   2: 0.241 us/op
                 gc.alloc.rate:      1234.628 MB/sec
                 gc.alloc.rate.norm: 312.007 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   3: 0.243 us/op
                 gc.alloc.rate:      1223.691 MB/sec
                 gc.alloc.rate.norm: 312.007 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   4: 0.233 us/op
                 gc.alloc.rate:      1269.536 MB/sec
                 gc.alloc.rate.norm: 312.006 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms


# Run progress: 91.67% complete, ETA 00:00:03
# Fork: 2 of 2
# Warmup Iteration   1: 586471.241 us/op
# Warmup Iteration   2: 2.024 us/op
# Warmup Iteration   3: 0.275 us/op
Iteration   1: 0.261 us/op
                 gc.alloc.rate:      988.224 MB/sec
                 gc.alloc.rate.norm: 272.007 B/op
                 gc.count:           3.000 counts
                 gc.time:            6.000 ms

Iteration   2: 0.254 us/op
                 gc.alloc.rate:      1019.173 MB/sec
                 gc.alloc.rate.norm: 272.007 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   3: 0.234 us/op
                 gc.alloc.rate:      1108.485 MB/sec
                 gc.alloc.rate.norm: 272.006 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   4: 0.268 us/op
                 gc.alloc.rate:      964.025 MB/sec
                 gc.alloc.rate.norm: 272.007 B/op
                 gc.count:           2.000 counts
                 gc.time:            4.000 ms



Result "example.tasks.TaskCostBenchmark.suspended":
  0.246 ±(99.9%) 0.027 us/op [Average]
  (min, avg, max) = (0.232, 0.246, 0.268), stdev = 0.014
  CI (99.9%): [0.219, 0.272] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.suspended:gc.alloc.rate":
  1136.057 ±(99.9%) 252.419 MB/sec [Average]
  (min, avg, max) = (964.025, 1136.057, 1280.698), stdev = 132.020
  CI (99.9%): [883.638, 1388.477] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.suspended:gc.alloc.rate.norm":
  292.007 ±(99.9%) 40.879 B/op [Average]
  (min, avg, max) = (272.006, 292.007, 312.007), stdev = 21.381
  CI (99.9%): [251.128, 332.886] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.suspended:gc.count":
  21.000 ±(99.9%) 0.001 counts [Sum]
  (min, avg, max) = (2.000, 2.625, 3.000), stdev = 0.518
  CI (99.9%): [21.000, 21.000] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.suspended:gc.time":
  35.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (3.000, 4.375, 6.000), stdev = 1.061
  CI (99.9%): [35.000, 35.000] (assumes normal distribution)


# Run complete. Total time: 00:00:36

REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on
why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial
experiments, perform baseline and negative tests that provide experimental control, make sure
the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts.
Do not assume the numbers tell you what you want them to tell.

NOTE: Current JVM experimentally supports Compiler Blackholes, and they are in use. Please exercise
extra caution when trusting the results, look into the generated code to check the benchmark still
works, and factor in a small probability of new VM bugs. Additionally, while comparisons between
different JVMs are already problematic, the performance difference caused by different Blackhole
modes can be very significant. Please make sure you use the consistent Blackhole mode for comparisons.

Benchmark                                       Mode  Cnt       Score     Error   Units
TaskCostBenchmark.boxedIds                      avgt    8      10.945 ±   1.708   us/op
TaskCostBenchmark.boxedIds:gc.alloc.rate        avgt    8    1795.049 ± 257.858  MB/sec
TaskCostBenchmark.boxedIds:gc.alloc.rate.norm   avgt    8   20520.305 ±   0.046    B/op
TaskCostBenchmark.boxedIds:gc.count             avgt    8      24.000            counts
TaskCostBenchmark.boxedIds:gc.time              avgt    8      35.000                ms
TaskCostBenchmark.direct                        avgt    8       0.017 ±   0.001   us/op
TaskCostBenchmark.direct:gc.alloc.rate          avgt    8    4463.234 ±  95.241  MB/sec
TaskCostBenchmark.direct:gc.alloc.rate.norm     avgt    8      80.000 ±   0.001    B/op
TaskCostBenchmark.direct:gc.count               avgt    8      16.000            counts
TaskCostBenchmark.direct:gc.time                avgt    8      35.000                ms
TaskCostBenchmark.eager                         avgt    8      60.482 ±  13.516   us/op
TaskCostBenchmark.eager:gc.alloc.rate           avgt    8    1894.360 ± 411.116  MB/sec
TaskCostBenchmark.eager:gc.alloc.rate.norm      avgt    8  118929.678 ±   0.377    B/op
TaskCostBenchmark.eager:gc.count                avgt    8      30.000            counts
TaskCostBenchmark.eager:gc.time                 avgt    8      34.000                ms
TaskCostBenchmark.lazy                          avgt    8      50.523 ±   5.474   us/op
TaskCostBenchmark.lazy:gc.alloc.rate            avgt    8    2169.819 ± 230.976  MB/sec
TaskCostBenchmark.lazy:gc.alloc.rate.norm       avgt    8  114825.399 ±   0.151    B/op
TaskCostBenchmark.lazy:gc.count                 avgt    8      33.000            counts
TaskCostBenchmark.lazy:gc.time                  avgt    8      33.000                ms
TaskCostBenchmark.rawIds                        avgt    8       6.225 ±   1.448   us/op
TaskCostBenchmark.rawIds:gc.alloc.rate          avgt    8     639.434 ± 132.953  MB/sec
TaskCostBenchmark.rawIds:gc.alloc.rate.norm     avgt    8    4136.173 ±   0.041    B/op
TaskCostBenchmark.rawIds:gc.count               avgt    8      11.000            counts
TaskCostBenchmark.rawIds:gc.time                avgt    8      11.000                ms
TaskCostBenchmark.suspended                     avgt    8       0.246 ±   0.027   us/op
TaskCostBenchmark.suspended:gc.alloc.rate       avgt    8    1136.057 ± 252.419  MB/sec
TaskCostBenchmark.suspended:gc.alloc.rate.norm  avgt    8     292.007 ±  40.879    B/op
TaskCostBenchmark.suspended:gc.count            avgt    8      21.000            counts
TaskCostBenchmark.suspended:gc.time             avgt    8      35.000                ms

Benchmark result is saved to /home/admin/workspace/my-blogs/examples/kotlin-language/build/reports/jmh/results.json

BUILD SUCCESSFUL in 49s
8 actionable tasks: 1 executed, 7 up-to-date
EXIT_CODE=0
