UTC_DATE=2026-10-10T06:37:29+0000
STAGING=/tmp/kotlin-38-stage-rRqZ6q
REPLAY=/tmp/kotlin-38-replay-FVFs7o
COMMAND: package cumulative code, 00-38 research and raw verification
SOURCE_COPY_EXIT_CODE=0
EVIDENCE_COPY_EXIT_CODE=0
ARCHIVE_EXIT_CODE=0
kotlin-language-38.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 :serverStartScripts
> Task :startScripts
> Task :installDist
> Task :distZip

> Task :compileTestKotlin
w: file:///tmp/kotlin-38-replay-FVFs7o/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 :packageTest

> 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: 19.123 us/op
# Warmup Iteration   2: 10.606 us/op
# Warmup Iteration   3: 11.131 us/op
Iteration   1: 10.709 us/op
                 gc.alloc.rate:      1817.711 MB/sec
                 gc.alloc.rate.norm: 20520.297 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   2: 10.230 us/op
                 gc.alloc.rate:      1910.004 MB/sec
                 gc.alloc.rate.norm: 20520.281 B/op
                 gc.count:           4.000 counts
                 gc.time:            7.000 ms

Iteration   3: 11.994 us/op
                 gc.alloc.rate:      1628.869 MB/sec
                 gc.alloc.rate.norm: 20520.331 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   4: 10.232 us/op
                 gc.alloc.rate:      1900.297 MB/sec
                 gc.alloc.rate.norm: 20520.280 B/op
                 gc.count:           3.000 counts
                 gc.time:            3.000 ms


# Run progress: 8.33% complete, ETA 00:00:25
# Fork: 2 of 2
# Warmup Iteration   1: 15.936 us/op
# Warmup Iteration   2: 12.046 us/op
# Warmup Iteration   3: 11.168 us/op
Iteration   1: 11.584 us/op
                 gc.alloc.rate:      1687.002 MB/sec
                 gc.alloc.rate.norm: 20520.320 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   2: 10.461 us/op
                 gc.alloc.rate:      1867.519 MB/sec
                 gc.alloc.rate.norm: 20520.295 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   3: 11.701 us/op
                 gc.alloc.rate:      1670.032 MB/sec
                 gc.alloc.rate.norm: 20520.325 B/op
                 gc.count:           3.000 counts
                 gc.time:            3.000 ms

Iteration   4: 10.413 us/op
                 gc.alloc.rate:      1876.515 MB/sec
                 gc.alloc.rate.norm: 20520.289 B/op
                 gc.count:           4.000 counts
                 gc.time:            4.000 ms



Result "example.tasks.TaskCostBenchmark.boxedIds":
  10.916 ±(99.9%) 1.384 us/op [Average]
  (min, avg, max) = (10.230, 10.916, 11.994), stdev = 0.724
  CI (99.9%): [9.532, 12.300] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.boxedIds:gc.alloc.rate":
  1794.744 ±(99.9%) 218.731 MB/sec [Average]
  (min, avg, max) = (1628.869, 1794.744, 1910.004), stdev = 114.400
  CI (99.9%): [1576.013, 2013.475] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.boxedIds:gc.alloc.rate.norm":
  20520.302 ±(99.9%) 0.039 B/op [Average]
  (min, avg, max) = (20520.280, 20520.302, 20520.331), stdev = 0.020
  CI (99.9%): [20520.264, 20520.341] (assumes normal distribution)

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

Secondary result "example.tasks.TaskCostBenchmark.boxedIds:gc.time":
  32.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (3.000, 4.000, 7.000), stdev = 1.309
  CI (99.9%): [32.000, 32.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.037 us/op
# Warmup Iteration   2: 0.025 us/op
# Warmup Iteration   3: 0.022 us/op
Iteration   1: 0.018 us/op
                 gc.alloc.rate:      4224.261 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           5.000 counts
                 gc.time:            7.000 ms

Iteration   2: 0.020 us/op
                 gc.alloc.rate:      3802.488 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           5.000 counts
                 gc.time:            7.000 ms

Iteration   3: 0.017 us/op
                 gc.alloc.rate:      4405.886 MB/sec
                 gc.alloc.rate.norm: 80.000 B/op
                 gc.count:           5.000 counts
                 gc.time:            6.000 ms

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


# Run progress: 25.00% complete, ETA 00:00:20
# Fork: 2 of 2
# Warmup Iteration   1: 0.042 us/op
# Warmup Iteration   2: 0.026 us/op
# Warmup Iteration   3: 0.020 us/op
Iteration   1: 0.018 us/op
                 gc.alloc.rate:      4274.393 MB/sec
                 gc.alloc.rate.norm: 80.000 B/op
                 gc.count:           4.000 counts
                 gc.time:            6.000 ms

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

Iteration   3: 0.022 us/op
                 gc.alloc.rate:      3493.885 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

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



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

Secondary result "example.tasks.TaskCostBenchmark.direct:gc.alloc.rate":
  4171.519 ±(99.9%) 649.709 MB/sec [Average]
  (min, avg, max) = (3493.885, 4171.519, 4405.886), stdev = 339.810
  CI (99.9%): [3521.809, 4821.228] (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.000, 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":
  35.000 ±(99.9%) 0.001 counts [Sum]
  (min, avg, max) = (3.000, 4.375, 5.000), stdev = 0.744
  CI (99.9%): [35.000, 35.000] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.direct:gc.time":
  50.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (5.000, 6.250, 7.000), stdev = 0.707
  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:18
# Fork: 1 of 2
# Warmup Iteration   1: 281.972 us/op
# Warmup Iteration   2: 59.621 us/op
# Warmup Iteration   3: 55.073 us/op
Iteration   1: 62.468 us/op
                 gc.alloc.rate:      1787.301 MB/sec
                 gc.alloc.rate.norm: 118929.734 B/op
                 gc.count:           4.000 counts
                 gc.time:            7.000 ms

Iteration   2: 53.523 us/op
                 gc.alloc.rate:      2102.357 MB/sec
                 gc.alloc.rate.norm: 118929.486 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   3: 60.373 us/op
                 gc.alloc.rate:      1875.858 MB/sec
                 gc.alloc.rate.norm: 118929.676 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   4: 52.959 us/op
                 gc.alloc.rate:      2106.886 MB/sec
                 gc.alloc.rate.norm: 118929.470 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms


# Run progress: 41.67% complete, ETA 00:00:15
# Fork: 2 of 2
# Warmup Iteration   1: 603.090 us/op
# Warmup Iteration   2: 68.028 us/op
# Warmup Iteration   3: 59.487 us/op
Iteration   1: 62.685 us/op
                 gc.alloc.rate:      1803.752 MB/sec
                 gc.alloc.rate.norm: 118929.731 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   2: 59.431 us/op
                 gc.alloc.rate:      1864.820 MB/sec
                 gc.alloc.rate.norm: 118929.642 B/op
                 gc.count:           4.000 counts
                 gc.time:            6.000 ms

Iteration   3: 52.917 us/op
                 gc.alloc.rate:      2131.742 MB/sec
                 gc.alloc.rate.norm: 118929.461 B/op
                 gc.count:           3.000 counts
                 gc.time:            3.000 ms

Iteration   4: 52.966 us/op
                 gc.alloc.rate:      2138.112 MB/sec
                 gc.alloc.rate.norm: 118929.463 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms



Result "example.tasks.TaskCostBenchmark.eager":
  57.165 ±(99.9%) 8.571 us/op [Average]
  (min, avg, max) = (52.917, 57.165, 62.685), stdev = 4.483
  CI (99.9%): [48.595, 65.736] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.alloc.rate":
  1976.354 ±(99.9%) 299.095 MB/sec [Average]
  (min, avg, max) = (1787.301, 1976.354, 2138.112), stdev = 156.433
  CI (99.9%): [1677.258, 2275.449] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.alloc.rate.norm":
  118929.583 ±(99.9%) 0.238 B/op [Average]
  (min, avg, max) = (118929.461, 118929.583, 118929.734), stdev = 0.124
  CI (99.9%): [118929.345, 118929.821] (assumes normal distribution)

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

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.time":
  38.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (3.000, 4.750, 7.000), stdev = 1.282
  CI (99.9%): [38.000, 38.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:13
# Fork: 1 of 2
# Warmup Iteration   1: 131.780 us/op
# Warmup Iteration   2: 57.643 us/op
# Warmup Iteration   3: 55.183 us/op
Iteration   1: 57.318 us/op
                 gc.alloc.rate:      1907.835 MB/sec
                 gc.alloc.rate.norm: 114825.591 B/op
                 gc.count:           4.000 counts
                 gc.time:            6.000 ms

Iteration   2: 48.445 us/op
                 gc.alloc.rate:      2257.287 MB/sec
                 gc.alloc.rate.norm: 114825.338 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   3: 47.284 us/op
                 gc.alloc.rate:      2312.532 MB/sec
                 gc.alloc.rate.norm: 114825.312 B/op
                 gc.count:           4.000 counts
                 gc.time:            4.000 ms

Iteration   4: 53.067 us/op
                 gc.alloc.rate:      2060.679 MB/sec
                 gc.alloc.rate.norm: 114825.433 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms


# Run progress: 58.33% complete, ETA 00:00:11
# Fork: 2 of 2
# Warmup Iteration   1: 116.890 us/op
# Warmup Iteration   2: 69.955 us/op
# Warmup Iteration   3: 63.361 us/op
Iteration   1: 64.720 us/op
                 gc.alloc.rate:      1686.637 MB/sec
                 gc.alloc.rate.norm: 114825.788 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   2: 49.925 us/op
                 gc.alloc.rate:      2177.748 MB/sec
                 gc.alloc.rate.norm: 114825.386 B/op
                 gc.count:           4.000 counts
                 gc.time:            6.000 ms

Iteration   3: 49.748 us/op
                 gc.alloc.rate:      2195.170 MB/sec
                 gc.alloc.rate.norm: 114825.370 B/op
                 gc.count:           3.000 counts
                 gc.time:            3.000 ms

Iteration   4: 50.513 us/op
                 gc.alloc.rate:      2157.761 MB/sec
                 gc.alloc.rate.norm: 114825.402 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms



Result "example.tasks.TaskCostBenchmark.lazy":
  52.628 ±(99.9%) 11.067 us/op [Average]
  (min, avg, max) = (47.284, 52.628, 64.720), stdev = 5.788
  CI (99.9%): [41.560, 63.695] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.alloc.rate":
  2094.456 ±(99.9%) 394.127 MB/sec [Average]
  (min, avg, max) = (1686.637, 2094.456, 2312.532), stdev = 206.136
  CI (99.9%): [1700.330, 2488.583] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.alloc.rate.norm":
  114825.453 ±(99.9%) 0.305 B/op [Average]
  (min, avg, max) = (114825.312, 114825.453, 114825.788), stdev = 0.160
  CI (99.9%): [114825.147, 114825.758] (assumes normal distribution)

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

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.time":
  38.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (3.000, 4.750, 6.000), stdev = 1.035
  CI (99.9%): [38.000, 38.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:09
# Fork: 1 of 2
# Warmup Iteration   1: 11.202 us/op
# Warmup Iteration   2: 8.676 us/op
# Warmup Iteration   3: 7.204 us/op
Iteration   1: 7.374 us/op
                 gc.alloc.rate:      532.714 MB/sec
                 gc.alloc.rate.norm: 4136.205 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   2: 5.974 us/op
                 gc.alloc.rate:      656.304 MB/sec
                 gc.alloc.rate.norm: 4136.165 B/op
                 gc.count:           2.000 counts
                 gc.time:            2.000 ms

Iteration   3: 5.936 us/op
                 gc.alloc.rate:      663.609 MB/sec
                 gc.alloc.rate.norm: 4136.164 B/op
                 gc.count:           2.000 counts
                 gc.time:            2.000 ms

Iteration   4: 6.168 us/op
                 gc.alloc.rate:      617.867 MB/sec
                 gc.alloc.rate.norm: 4136.171 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms


# Run progress: 75.00% complete, ETA 00:00:06
# Fork: 2 of 2
# Warmup Iteration   1: 9.747 us/op
# Warmup Iteration   2: 6.929 us/op
# Warmup Iteration   3: 6.877 us/op
Iteration   1: 7.427 us/op
                 gc.alloc.rate:      528.146 MB/sec
                 gc.alloc.rate.norm: 4136.208 B/op
                 gc.count:           1.000 counts
                 gc.time:            1.000 ms

Iteration   2: 5.877 us/op
                 gc.alloc.rate:      667.965 MB/sec
                 gc.alloc.rate.norm: 4136.162 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   3: 6.010 us/op
                 gc.alloc.rate:      655.344 MB/sec
                 gc.alloc.rate.norm: 4136.167 B/op
                 gc.count:           1.000 counts
                 gc.time:            1.000 ms

Iteration   4: 5.896 us/op
                 gc.alloc.rate:      667.901 MB/sec
                 gc.alloc.rate.norm: 4136.164 B/op
                 gc.count:           2.000 counts
                 gc.time:            2.000 ms



Result "example.tasks.TaskCostBenchmark.rawIds":
  6.333 ±(99.9%) 1.272 us/op [Average]
  (min, avg, max) = (5.877, 6.333, 7.427), stdev = 0.665
  CI (99.9%): [5.061, 7.605] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.alloc.rate":
  623.731 ±(99.9%) 114.293 MB/sec [Average]
  (min, avg, max) = (528.146, 623.731, 667.965), stdev = 59.777
  CI (99.9%): [509.439, 738.024] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.alloc.rate.norm":
  4136.176 ±(99.9%) 0.037 B/op [Average]
  (min, avg, max) = (4136.162, 4136.176, 4136.208), stdev = 0.019
  CI (99.9%): [4136.139, 4136.213] (assumes normal distribution)

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

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.time":
  19.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (1.000, 2.375, 5.000), stdev = 1.302
  CI (99.9%): [19.000, 19.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:04
# Fork: 1 of 2
# Warmup Iteration   1: 6.556 us/op
# Warmup Iteration   2: 0.405 us/op
# Warmup Iteration   3: 0.248 us/op
Iteration   1: 0.243 us/op
                 gc.alloc.rate:      1065.838 MB/sec
                 gc.alloc.rate.norm: 272.007 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   2: 0.235 us/op
                 gc.alloc.rate:      1103.505 MB/sec
                 gc.alloc.rate.norm: 272.006 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   3: 0.242 us/op
                 gc.alloc.rate:      1071.333 MB/sec
                 gc.alloc.rate.norm: 272.007 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   4: 0.256 us/op
                 gc.alloc.rate:      1001.012 MB/sec
                 gc.alloc.rate.norm: 272.007 B/op
                 gc.count:           1.000 counts
                 gc.time:            2.000 ms


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

Iteration   2: 0.223 us/op
                 gc.alloc.rate:      1161.527 MB/sec
                 gc.alloc.rate.norm: 272.006 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   3: 0.268 us/op
                 gc.alloc.rate:      968.307 MB/sec
                 gc.alloc.rate.norm: 272.007 B/op
                 gc.count:           3.000 counts
                 gc.time:            6.000 ms

Iteration   4: 0.237 us/op
                 gc.alloc.rate:      1091.918 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.245 ±(99.9%) 0.027 us/op [Average]
  (min, avg, max) = (0.223, 0.245, 0.268), stdev = 0.014
  CI (99.9%): [0.218, 0.271] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.suspended:gc.alloc.rate":
  1060.434 ±(99.9%) 118.448 MB/sec [Average]
  (min, avg, max) = (968.307, 1060.434, 1161.527), stdev = 61.950
  CI (99.9%): [941.986, 1178.882] (assumes normal distribution)

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

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

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


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

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.916 ±   1.384   us/op
TaskCostBenchmark.boxedIds:gc.alloc.rate        avgt    8    1794.744 ± 218.731  MB/sec
TaskCostBenchmark.boxedIds:gc.alloc.rate.norm   avgt    8   20520.302 ±   0.039    B/op
TaskCostBenchmark.boxedIds:gc.count             avgt    8      25.000            counts
TaskCostBenchmark.boxedIds:gc.time              avgt    8      32.000                ms
TaskCostBenchmark.direct                        avgt    8       0.018 ±   0.003   us/op
TaskCostBenchmark.direct:gc.alloc.rate          avgt    8    4171.519 ± 649.709  MB/sec
TaskCostBenchmark.direct:gc.alloc.rate.norm     avgt    8      80.001 ±   0.001    B/op
TaskCostBenchmark.direct:gc.count               avgt    8      35.000            counts
TaskCostBenchmark.direct:gc.time                avgt    8      50.000                ms
TaskCostBenchmark.eager                         avgt    8      57.165 ±   8.571   us/op
TaskCostBenchmark.eager:gc.alloc.rate           avgt    8    1976.354 ± 299.095  MB/sec
TaskCostBenchmark.eager:gc.alloc.rate.norm      avgt    8  118929.583 ±   0.238    B/op
TaskCostBenchmark.eager:gc.count                avgt    8      26.000            counts
TaskCostBenchmark.eager:gc.time                 avgt    8      38.000                ms
TaskCostBenchmark.lazy                          avgt    8      52.628 ±  11.067   us/op
TaskCostBenchmark.lazy:gc.alloc.rate            avgt    8    2094.456 ± 394.127  MB/sec
TaskCostBenchmark.lazy:gc.alloc.rate.norm       avgt    8  114825.453 ±   0.305    B/op
TaskCostBenchmark.lazy:gc.count                 avgt    8      29.000            counts
TaskCostBenchmark.lazy:gc.time                  avgt    8      38.000                ms
TaskCostBenchmark.rawIds                        avgt    8       6.333 ±   1.272   us/op
TaskCostBenchmark.rawIds:gc.alloc.rate          avgt    8     623.731 ± 114.293  MB/sec
TaskCostBenchmark.rawIds:gc.alloc.rate.norm     avgt    8    4136.176 ±   0.037    B/op
TaskCostBenchmark.rawIds:gc.count               avgt    8      15.000            counts
TaskCostBenchmark.rawIds:gc.time                avgt    8      19.000                ms
TaskCostBenchmark.suspended                     avgt    8       0.245 ±   0.027   us/op
TaskCostBenchmark.suspended:gc.alloc.rate       avgt    8    1060.434 ± 118.448  MB/sec
TaskCostBenchmark.suspended:gc.alloc.rate.norm  avgt    8     272.007 ±   0.001    B/op
TaskCostBenchmark.suspended:gc.count            avgt    8      19.000            counts
TaskCostBenchmark.suspended:gc.time             avgt    8      33.000                ms

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

BUILD SUCCESSFUL in 1m 55s
17 actionable tasks: 15 executed, 2 up-to-date
CLEAN_TEST_LOOPBACK_PACKAGE_ZIP_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 17s
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 14s
5 actionable tasks: 1 executed, 4 up-to-date
INVALID_EXIT_CODE=1
FINAL_EXIT_CODE=0
