UTC_DATE=2026-10-10T06:14:30+0000
STAGING=/tmp/kotlin-37-stage-abwkCk
REPLAY=/tmp/kotlin-37-replay-skJOSM
COMMAND: package cumulative code, 00-37 research and raw verification
SOURCE_COPY_EXIT_CODE=0
EVIDENCE_COPY_EXIT_CODE=0
ARCHIVE_EXIT_CODE=0
kotlin-language-37.tar.gz: OK
SHA_EXIT_CODE=0
EXTRACT_EXIT_CODE=0
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 :clean UP-TO-DATE
> Task :domain:clean UP-TO-DATE
> Task :checkKotlinGradlePluginConfigurationErrors SKIPPED
> Task :domain:checkKotlinGradlePluginConfigurationErrors SKIPPED
> Task :domain:processResources NO-SOURCE
> Task :processResources NO-SOURCE
> Task :processTestResources NO-SOURCE
> Task :domain:processTestResources NO-SOURCE
> Task :domain:compileKotlin
> Task :domain:compileJava NO-SOURCE
> Task :domain:classes UP-TO-DATE
> Task :domain:jar
> Task :domain:compileTestKotlin NO-SOURCE
> Task :domain:compileTestJava NO-SOURCE
> Task :domain:testClasses UP-TO-DATE
> Task :domain:test NO-SOURCE
> Task :compileKotlin
> Task :compileJava
> Task :classes
> Task :jar

> Task :compileTestKotlin
w: file:///tmp/kotlin-37-replay-skJOSM/kotlin-language/src/test/kotlin/example/tasks/TaskFormattingTest.kt:19:20 This extension is shadowed by a member: 'fun label(): String'.

> Task :compileTestJava
> Task :testClasses
> Task :test
> Task :loopbackTest

> 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: 18.866 us/op
# Warmup Iteration   2: 12.858 us/op
# Warmup Iteration   3: 13.258 us/op
Iteration   1: 13.724 us/op
                 gc.alloc.rate:      1423.308 MB/sec
                 gc.alloc.rate.norm: 20520.381 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   2: 10.855 us/op
                 gc.alloc.rate:      1799.980 MB/sec
                 gc.alloc.rate.norm: 20520.300 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms

Iteration   3: 11.450 us/op
                 gc.alloc.rate:      1703.176 MB/sec
                 gc.alloc.rate.norm: 20520.322 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   4: 11.656 us/op
                 gc.alloc.rate:      1658.312 MB/sec
                 gc.alloc.rate.norm: 20520.324 B/op
                 gc.count:           3.000 counts
                 gc.time:            3.000 ms


# Run progress: 8.33% complete, ETA 00:00:26
# Fork: 2 of 2
# Warmup Iteration   1: 22.036 us/op
# Warmup Iteration   2: 15.174 us/op
# Warmup Iteration   3: 13.830 us/op
Iteration   1: 13.564 us/op
                 gc.alloc.rate:      1436.136 MB/sec
                 gc.alloc.rate.norm: 20520.376 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   2: 11.686 us/op
                 gc.alloc.rate:      1671.365 MB/sec
                 gc.alloc.rate.norm: 20520.325 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   3: 11.358 us/op
                 gc.alloc.rate:      1720.357 MB/sec
                 gc.alloc.rate.norm: 20520.318 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   4: 13.865 us/op
                 gc.alloc.rate:      1409.353 MB/sec
                 gc.alloc.rate.norm: 20520.383 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms



Result "example.tasks.TaskCostBenchmark.boxedIds":
  12.270 ±(99.9%) 2.348 us/op [Average]
  (min, avg, max) = (10.855, 12.270, 13.865), stdev = 1.228
  CI (99.9%): [9.922, 14.618] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.boxedIds:gc.alloc.rate":
  1602.748 ±(99.9%) 296.179 MB/sec [Average]
  (min, avg, max) = (1409.353, 1602.748, 1799.980), stdev = 154.907
  CI (99.9%): [1306.570, 1898.927] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.boxedIds:gc.alloc.rate.norm":
  20520.341 ±(99.9%) 0.063 B/op [Average]
  (min, avg, max) = (20520.300, 20520.341, 20520.383), stdev = 0.033
  CI (99.9%): [20520.278, 20520.405] (assumes normal distribution)

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

Secondary result "example.tasks.TaskCostBenchmark.boxedIds:gc.time":
  31.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (3.000, 3.875, 5.000), stdev = 0.835
  CI (99.9%): [31.000, 31.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:23
# Fork: 1 of 2
# Warmup Iteration   1: 0.060 us/op
# Warmup Iteration   2: 0.028 us/op
# Warmup Iteration   3: 0.023 us/op
Iteration   1: 0.018 us/op
                 gc.alloc.rate:      4141.454 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           5.000 counts
                 gc.time:            8.000 ms

Iteration   2: 0.021 us/op
                 gc.alloc.rate:      3662.437 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           4.000 counts
                 gc.time:            6.000 ms

Iteration   3: 0.019 us/op
                 gc.alloc.rate:      3925.104 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   4: 0.019 us/op
                 gc.alloc.rate:      4009.509 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           4.000 counts
                 gc.time:            7.000 ms


# Run progress: 25.00% complete, ETA 00:00:21
# Fork: 2 of 2
# Warmup Iteration   1: 0.268 us/op
# Warmup Iteration   2: 0.059 us/op
# Warmup Iteration   3: 0.043 us/op
Iteration   1: 0.036 us/op
                 gc.alloc.rate:      2050.258 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           4.000 counts
                 gc.time:            7.000 ms

Iteration   2: 0.029 us/op
                 gc.alloc.rate:      2591.185 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           3.000 counts
                 gc.time:            6.000 ms

Iteration   3: 0.036 us/op
                 gc.alloc.rate:      2058.458 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           3.000 counts
                 gc.time:            7.000 ms

Iteration   4: 0.026 us/op
                 gc.alloc.rate:      2969.574 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms



Result "example.tasks.TaskCostBenchmark.direct":
  0.026 ±(99.9%) 0.014 us/op [Average]
  (min, avg, max) = (0.018, 0.026, 0.036), stdev = 0.007
  CI (99.9%): [0.011, 0.040] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.direct:gc.alloc.rate":
  3175.997 ±(99.9%) 1667.672 MB/sec [Average]
  (min, avg, max) = (2050.258, 3175.997, 4141.454), stdev = 872.225
  CI (99.9%): [1508.326, 4843.669] (assumes normal distribution)

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

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

Secondary result "example.tasks.TaskCostBenchmark.direct:gc.time":
  50.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (4.000, 6.250, 8.000), stdev = 1.282
  CI (99.9%): [50.000, 50.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:20
# Fork: 1 of 2
# Warmup Iteration   1: 859.872 us/op
# Warmup Iteration   2: 874.588 us/op
# Warmup Iteration   3: 163.076 us/op
Iteration   1: 270.322 us/op
                 gc.alloc.rate:      415.234 MB/sec
                 gc.alloc.rate.norm: 118935.464 B/op
                 gc.count:           1.000 counts
                 gc.time:            2.000 ms

Iteration   2: 132.871 us/op
                 gc.alloc.rate:      836.946 MB/sec
                 gc.alloc.rate.norm: 118931.372 B/op
                 gc.count:           3.000 counts
                 gc.time:            6.000 ms

Iteration   3: 128.440 us/op
                 gc.alloc.rate:      852.089 MB/sec
                 gc.alloc.rate.norm: 118932.522 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   4: 92.498 us/op
                 gc.alloc.rate:      1205.605 MB/sec
                 gc.alloc.rate.norm: 118930.555 B/op
                 gc.count:           3.000 counts
                 gc.time:            3.000 ms


# Run progress: 41.67% complete, ETA 00:00:18
# Fork: 2 of 2
# Warmup Iteration   1: 895.451 us/op
# Warmup Iteration   2: 147.005 us/op
# Warmup Iteration   3: 101.589 us/op
Iteration   1: 135.961 us/op
                 gc.alloc.rate:      827.118 MB/sec
                 gc.alloc.rate.norm: 118932.782 B/op
                 gc.count:           2.000 counts
                 gc.time:            8.000 ms

Iteration   2: 123.882 us/op
                 gc.alloc.rate:      896.183 MB/sec
                 gc.alloc.rate.norm: 118931.423 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   3: 254.760 us/op
                 gc.alloc.rate:      438.601 MB/sec
                 gc.alloc.rate.norm: 118934.967 B/op
                 gc.count:           ≈ 0 counts

Iteration   4: 57.152 us/op
                 gc.alloc.rate:      1963.389 MB/sec
                 gc.alloc.rate.norm: 118929.579 B/op
                 gc.count:           4.000 counts
                 gc.time:            6.000 ms



Result "example.tasks.TaskCostBenchmark.eager":
  149.486 ±(99.9%) 142.740 us/op [Average]
  (min, avg, max) = (57.152, 149.486, 270.322), stdev = 74.656
  CI (99.9%): [6.745, 292.226] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.alloc.rate":
  929.395 ±(99.9%) 935.769 MB/sec [Average]
  (min, avg, max) = (415.234, 929.395, 1963.389), stdev = 489.426
  CI (99.9%): [≈ 0, 1865.165] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.alloc.rate.norm":
  118932.333 ±(99.9%) 3.924 B/op [Average]
  (min, avg, max) = (118929.579, 118932.333, 118935.464), stdev = 2.052
  CI (99.9%): [118928.410, 118936.257] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.count":
  18.000 ±(99.9%) 0.001 counts [Sum]
  (min, avg, max) = (≈ 0, 2.250, 4.000), stdev = 1.282
  CI (99.9%): [18.000, 18.000] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.time":
  33.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (≈ 0, 4.125, 8.000), stdev = 2.588
  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.lazy

# Run progress: 50.00% complete, ETA 00:00:16
# Fork: 1 of 2
# Warmup Iteration   1: 601.696 us/op
# Warmup Iteration   2: 92.335 us/op
# Warmup Iteration   3: 73.553 us/op
Iteration   1: 64.910 us/op
                 gc.alloc.rate:      1677.081 MB/sec
                 gc.alloc.rate.norm: 114889.831 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   2: 99.426 us/op
                 gc.alloc.rate:      1094.760 MB/sec
                 gc.alloc.rate.norm: 114890.746 B/op
                 gc.count:           2.000 counts
                 gc.time:            26.000 ms

Iteration   3: 59.522 us/op
                 gc.alloc.rate:      1758.392 MB/sec
                 gc.alloc.rate.norm: 114889.645 B/op
                 gc.count:           3.000 counts
                 gc.time:            10.000 ms

Iteration   4: 61.240 us/op
                 gc.alloc.rate:      1746.150 MB/sec
                 gc.alloc.rate.norm: 114889.692 B/op
                 gc.count:           2.000 counts
                 gc.time:            2.000 ms


# Run progress: 58.33% complete, ETA 00:00:13
# Fork: 2 of 2
# Warmup Iteration   1: 254.028 us/op
# Warmup Iteration   2: 71.075 us/op
# Warmup Iteration   3: 72.571 us/op
Iteration   1: 56.019 us/op
                 gc.alloc.rate:      1946.867 MB/sec
                 gc.alloc.rate.norm: 114825.555 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms

Iteration   2: 61.930 us/op
                 gc.alloc.rate:      1740.068 MB/sec
                 gc.alloc.rate.norm: 114825.719 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   3: 56.460 us/op
                 gc.alloc.rate:      1936.828 MB/sec
                 gc.alloc.rate.norm: 114825.567 B/op
                 gc.count:           3.000 counts
                 gc.time:            9.000 ms

Iteration   4: 56.049 us/op
                 gc.alloc.rate:      1943.530 MB/sec
                 gc.alloc.rate.norm: 114825.549 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms



Result "example.tasks.TaskCostBenchmark.lazy":
  64.444 ±(99.9%) 27.707 us/op [Average]
  (min, avg, max) = (56.019, 64.444, 99.426), stdev = 14.491
  CI (99.9%): [36.737, 92.151] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.alloc.rate":
  1730.459 ±(99.9%) 532.468 MB/sec [Average]
  (min, avg, max) = (1094.760, 1730.459, 1946.867), stdev = 278.491
  CI (99.9%): [1197.991, 2262.928] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.alloc.rate.norm":
  114857.788 ±(99.9%) 65.800 B/op [Average]
  (min, avg, max) = (114825.549, 114857.788, 114890.746), stdev = 34.415
  CI (99.9%): [114791.988, 114923.588] (assumes normal distribution)

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

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.time":
  66.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (2.000, 8.250, 26.000), stdev = 7.630
  CI (99.9%): [66.000, 66.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:10
# Fork: 1 of 2
# Warmup Iteration   1: 16.171 us/op
# Warmup Iteration   2: 7.385 us/op
# Warmup Iteration   3: 7.146 us/op
Iteration   1: 9.534 us/op
                 gc.alloc.rate:      411.696 MB/sec
                 gc.alloc.rate.norm: 4136.269 B/op
                 gc.count:           1.000 counts
                 gc.time:            2.000 ms

Iteration   2: 6.156 us/op
                 gc.alloc.rate:      639.102 MB/sec
                 gc.alloc.rate.norm: 4136.170 B/op
                 gc.count:           2.000 counts
                 gc.time:            2.000 ms

Iteration   3: 6.844 us/op
                 gc.alloc.rate:      572.975 MB/sec
                 gc.alloc.rate.norm: 4136.189 B/op
                 gc.count:           2.000 counts
                 gc.time:            1.000 ms

Iteration   4: 6.339 us/op
                 gc.alloc.rate:      606.693 MB/sec
                 gc.alloc.rate.norm: 4136.175 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: 16.744 us/op
# Warmup Iteration   2: 11.634 us/op
# Warmup Iteration   3: 40.338 us/op
Iteration   1: 10.290 us/op
                 gc.alloc.rate:      380.553 MB/sec
                 gc.alloc.rate.norm: 4136.284 B/op
                 gc.count:           1.000 counts
                 gc.time:            1.000 ms

Iteration   2: 9.713 us/op
                 gc.alloc.rate:      400.583 MB/sec
                 gc.alloc.rate.norm: 4136.268 B/op
                 gc.count:           1.000 counts
                 gc.time:            2.000 ms

Iteration   3: 10.971 us/op
                 gc.alloc.rate:      358.329 MB/sec
                 gc.alloc.rate.norm: 4136.308 B/op
                 gc.count:           1.000 counts
                 gc.time:            1.000 ms

Iteration   4: 7.034 us/op
                 gc.alloc.rate:      545.515 MB/sec
                 gc.alloc.rate.norm: 4136.194 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms



Result "example.tasks.TaskCostBenchmark.rawIds":
  8.360 ±(99.9%) 3.738 us/op [Average]
  (min, avg, max) = (6.156, 8.360, 10.971), stdev = 1.955
  CI (99.9%): [4.622, 12.098] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.alloc.rate":
  489.431 ±(99.9%) 215.899 MB/sec [Average]
  (min, avg, max) = (358.329, 489.431, 639.102), stdev = 112.919
  CI (99.9%): [273.532, 705.330] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.alloc.rate.norm":
  4136.232 ±(99.9%) 0.106 B/op [Average]
  (min, avg, max) = (4136.170, 4136.232, 4136.308), stdev = 0.055
  CI (99.9%): [4136.126, 4136.338] (assumes normal distribution)

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

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.time":
  14.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (1.000, 1.750, 3.000), stdev = 0.707
  CI (99.9%): [14.000, 14.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: 195.128 us/op
# Warmup Iteration   2: 6.519 us/op
# Warmup Iteration   3: 1.093 us/op
Iteration   1: 0.329 us/op
                 gc.alloc.rate:      893.080 MB/sec
                 gc.alloc.rate.norm: 312.009 B/op
                 gc.count:           3.000 counts
                 gc.time:            9.000 ms

Iteration   2: 0.398 us/op
                 gc.alloc.rate:      744.304 MB/sec
                 gc.alloc.rate.norm: 312.011 B/op
                 gc.count:           2.000 counts
                 gc.time:            4.000 ms

Iteration   3: 0.283 us/op
                 gc.alloc.rate:      1030.390 MB/sec
                 gc.alloc.rate.norm: 312.008 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   4: 0.311 us/op
                 gc.alloc.rate:      932.132 MB/sec
                 gc.alloc.rate.norm: 312.009 B/op
                 gc.count:           2.000 counts
                 gc.time:            4.000 ms


# Run progress: 91.67% complete, ETA 00:00:02
# Fork: 2 of 2
# Warmup Iteration   1: 16.134 us/op
# Warmup Iteration   2: 0.540 us/op
# Warmup Iteration   3: 0.274 us/op
Iteration   1: 0.250 us/op
                 gc.alloc.rate:      1032.237 MB/sec
                 gc.alloc.rate.norm: 272.007 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   2: 0.284 us/op
                 gc.alloc.rate:      913.069 MB/sec
                 gc.alloc.rate.norm: 272.008 B/op
                 gc.count:           2.000 counts
                 gc.time:            5.000 ms

Iteration   3: 0.256 us/op
                 gc.alloc.rate:      1008.868 MB/sec
                 gc.alloc.rate.norm: 272.007 B/op
                 gc.count:           2.000 counts
                 gc.time:            4.000 ms

Iteration   4: 0.402 us/op
                 gc.alloc.rate:      644.717 MB/sec
                 gc.alloc.rate.norm: 272.011 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms



Result "example.tasks.TaskCostBenchmark.suspended":
  0.314 ±(99.9%) 0.113 us/op [Average]
  (min, avg, max) = (0.250, 0.314, 0.402), stdev = 0.059
  CI (99.9%): [0.201, 0.427] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.suspended:gc.alloc.rate":
  899.850 ±(99.9%) 267.483 MB/sec [Average]
  (min, avg, max) = (644.717, 899.850, 1032.237), stdev = 139.899
  CI (99.9%): [632.366, 1167.333] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.suspended:gc.alloc.rate.norm":
  292.009 ±(99.9%) 40.881 B/op [Average]
  (min, avg, max) = (272.007, 292.009, 312.011), stdev = 21.381
  CI (99.9%): [251.128, 332.889] (assumes normal distribution)

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

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


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

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      12.270 ±    2.348   us/op
TaskCostBenchmark.boxedIds:gc.alloc.rate        avgt    8    1602.748 ±  296.179  MB/sec
TaskCostBenchmark.boxedIds:gc.alloc.rate.norm   avgt    8   20520.341 ±    0.063    B/op
TaskCostBenchmark.boxedIds:gc.count             avgt    8      23.000             counts
TaskCostBenchmark.boxedIds:gc.time              avgt    8      31.000                 ms
TaskCostBenchmark.direct                        avgt    8       0.026 ±    0.014   us/op
TaskCostBenchmark.direct:gc.alloc.rate          avgt    8    3175.997 ± 1667.672  MB/sec
TaskCostBenchmark.direct:gc.alloc.rate.norm     avgt    8      80.001 ±    0.001    B/op
TaskCostBenchmark.direct:gc.count               avgt    8      30.000             counts
TaskCostBenchmark.direct:gc.time                avgt    8      50.000                 ms
TaskCostBenchmark.eager                         avgt    8     149.486 ±  142.740   us/op
TaskCostBenchmark.eager:gc.alloc.rate           avgt    8     929.395 ±  935.769  MB/sec
TaskCostBenchmark.eager:gc.alloc.rate.norm      avgt    8  118932.333 ±    3.924    B/op
TaskCostBenchmark.eager:gc.count                avgt    8      18.000             counts
TaskCostBenchmark.eager:gc.time                 avgt    8      33.000                 ms
TaskCostBenchmark.lazy                          avgt    8      64.444 ±   27.707   us/op
TaskCostBenchmark.lazy:gc.alloc.rate            avgt    8    1730.459 ±  532.468  MB/sec
TaskCostBenchmark.lazy:gc.alloc.rate.norm       avgt    8  114857.788 ±   65.800    B/op
TaskCostBenchmark.lazy:gc.count                 avgt    8      24.000             counts
TaskCostBenchmark.lazy:gc.time                  avgt    8      66.000                 ms
TaskCostBenchmark.rawIds                        avgt    8       8.360 ±    3.738   us/op
TaskCostBenchmark.rawIds:gc.alloc.rate          avgt    8     489.431 ±  215.899  MB/sec
TaskCostBenchmark.rawIds:gc.alloc.rate.norm     avgt    8    4136.232 ±    0.106    B/op
TaskCostBenchmark.rawIds:gc.count               avgt    8      12.000             counts
TaskCostBenchmark.rawIds:gc.time                avgt    8      14.000                 ms
TaskCostBenchmark.suspended                     avgt    8       0.314 ±    0.113   us/op
TaskCostBenchmark.suspended:gc.alloc.rate       avgt    8     899.850 ±  267.483  MB/sec
TaskCostBenchmark.suspended:gc.alloc.rate.norm  avgt    8     292.009 ±   40.881    B/op
TaskCostBenchmark.suspended:gc.count            avgt    8      18.000             counts
TaskCostBenchmark.suspended:gc.time             avgt    8      37.000                 ms

Benchmark result is saved to /tmp/kotlin-37-replay-skJOSM/kotlin-language/build/reports/jmh/results.json

BUILD SUCCESSFUL in 1m 30s
12 actionable tasks: 10 executed, 2 up-to-date
CLEAN_TEST_LOOPBACK_JMH_EXIT_CODE=0
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 :run
TASK input accepted (not persisted): alpha

BUILD SUCCESSFUL in 20s
5 actionable tasks: 1 executed, 4 up-to-date
VALID_EXIT_CODE=0
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 :run FAILED
Exception in thread "main" java.lang.IllegalArgumentException: Usage: submit <task text>
	at example.tasks.MainKt.submitTask(Main.kt:4)
	at example.tasks.CommandParserKt.parseCommand(CommandParser.kt:5)
	at example.tasks.MainKt.main(Main.kt:11)

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':run'.
> Process 'command '/usr/lib/jvm/java-21-openjdk-amd64/bin/java'' finished with non-zero exit value 1

* Try:
> Run with --stacktrace option to get the stack trace.
> Run with --info or --debug option to get more log output.
> Run with --scan to get full insights.
> Get more help at https://help.gradle.org.

BUILD FAILED in 15s
5 actionable tasks: 1 executed, 4 up-to-date
INVALID_EXIT_CODE=1
FINAL_EXIT_CODE=0
