COMMAND: ./gradlew --offline --no-daemon --console=plain clean test loopbackTest packageTest distZip 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 :clean
> Task :domain:clean
> 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:///home/admin/workspace/my-blogs/examples/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: 50.608 us/op
# Warmup Iteration   2: 16.006 us/op
# Warmup Iteration   3: 13.646 us/op
Iteration   1: 12.327 us/op
                 gc.alloc.rate:      1579.684 MB/sec
                 gc.alloc.rate.norm: 20520.341 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   2: 11.673 us/op
                 gc.alloc.rate:      1673.270 MB/sec
                 gc.alloc.rate.norm: 20520.322 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   3: 12.763 us/op
                 gc.alloc.rate:      1530.655 MB/sec
                 gc.alloc.rate.norm: 20520.354 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   4: 12.954 us/op
                 gc.alloc.rate:      1508.102 MB/sec
                 gc.alloc.rate.norm: 20520.365 B/op
                 gc.count:           3.000 counts
                 gc.time:            3.000 ms


# Run progress: 8.33% complete, ETA 00:00:42
# Fork: 2 of 2
# Warmup Iteration   1: 35.272 us/op
# Warmup Iteration   2: 13.387 us/op
# Warmup Iteration   3: 18.704 us/op
Iteration   1: 15.330 us/op
                 gc.alloc.rate:      1274.424 MB/sec
                 gc.alloc.rate.norm: 20520.425 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   2: 12.196 us/op
                 gc.alloc.rate:      1601.911 MB/sec
                 gc.alloc.rate.norm: 20520.337 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

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

Iteration   4: 12.399 us/op
                 gc.alloc.rate:      1575.605 MB/sec
                 gc.alloc.rate.norm: 20520.349 B/op
                 gc.count:           3.000 counts
                 gc.time:            3.000 ms



Result "example.tasks.TaskCostBenchmark.boxedIds":
  12.638 ±(99.9%) 2.287 us/op [Average]
  (min, avg, max) = (11.466, 12.638, 15.330), stdev = 1.196
  CI (99.9%): [10.351, 14.926] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.boxedIds:gc.alloc.rate":
  1555.901 ±(99.9%) 251.170 MB/sec [Average]
  (min, avg, max) = (1274.424, 1555.901, 1703.560), stdev = 131.367
  CI (99.9%): [1304.731, 1807.072] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.boxedIds:gc.alloc.rate.norm":
  20520.352 ±(99.9%) 0.064 B/op [Average]
  (min, avg, max) = (20520.318, 20520.352, 20520.425), stdev = 0.034
  CI (99.9%): [20520.287, 20520.416] (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, 3.000), stdev = 0.354
  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:36
# Fork: 1 of 2
# Warmup Iteration   1: 0.053 us/op
# Warmup Iteration   2: 0.025 us/op
# Warmup Iteration   3: 0.026 us/op
Iteration   1: 0.018 us/op
                 gc.alloc.rate:      4120.260 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           4.000 counts
                 gc.time:            6.000 ms

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

Iteration   3: 0.017 us/op
                 gc.alloc.rate:      4470.351 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:      4460.313 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:32
# Fork: 2 of 2
# Warmup Iteration   1: 0.053 us/op
# Warmup Iteration   2: 0.027 us/op
# Warmup Iteration   3: 0.025 us/op
Iteration   1: 0.017 us/op
                 gc.alloc.rate:      4403.332 MB/sec
                 gc.alloc.rate.norm: 80.000 B/op
                 gc.count:           4.000 counts
                 gc.time:            6.000 ms

Iteration   2: 0.018 us/op
                 gc.alloc.rate:      4331.077 MB/sec
                 gc.alloc.rate.norm: 80.000 B/op
                 gc.count:           4.000 counts
                 gc.time:            7.000 ms

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

Iteration   4: 0.018 us/op
                 gc.alloc.rate:      4266.547 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.017 ±(99.9%) 0.001 us/op [Average]
  (min, avg, max) = (0.017, 0.017, 0.018), stdev = 0.001
  CI (99.9%): [0.016, 0.018] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.direct:gc.alloc.rate":
  4367.746 ±(99.9%) 250.315 MB/sec [Average]
  (min, avg, max) = (4120.260, 4367.746, 4531.159), stdev = 130.920
  CI (99.9%): [4117.431, 4618.060] (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.001), stdev = 0.001
  CI (99.9%): [80.000, 80.001] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.direct:gc.count":
  34.000 ±(99.9%) 0.001 counts [Sum]
  (min, avg, max) = (4.000, 4.250, 5.000), stdev = 0.463
  CI (99.9%): [34.000, 34.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, 8.000), stdev = 0.886
  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:27
# Fork: 1 of 2
# Warmup Iteration   1: 591.154 us/op
# Warmup Iteration   2: 71.281 us/op
# Warmup Iteration   3: 63.037 us/op
Iteration   1: 60.049 us/op
                 gc.alloc.rate:      1885.988 MB/sec
                 gc.alloc.rate.norm: 118929.666 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms

Iteration   2: 61.841 us/op
                 gc.alloc.rate:      1830.449 MB/sec
                 gc.alloc.rate.norm: 118929.708 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   3: 54.247 us/op
                 gc.alloc.rate:      2088.132 MB/sec
                 gc.alloc.rate.norm: 118929.499 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms

Iteration   4: 54.820 us/op
                 gc.alloc.rate:      2065.750 MB/sec
                 gc.alloc.rate.norm: 118929.512 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms


# Run progress: 41.67% complete, ETA 00:00:24
# Fork: 2 of 2
# Warmup Iteration   1: 722.504 us/op
# Warmup Iteration   2: 105.066 us/op
# Warmup Iteration   3: 103.499 us/op
Iteration   1: 103.560 us/op
                 gc.alloc.rate:      1093.639 MB/sec
                 gc.alloc.rate.norm: 118931.659 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   2: 72.069 us/op
                 gc.alloc.rate:      1571.945 MB/sec
                 gc.alloc.rate.norm: 118929.923 B/op
                 gc.count:           4.000 counts
                 gc.time:            8.000 ms

Iteration   3: 74.508 us/op
                 gc.alloc.rate:      1520.054 MB/sec
                 gc.alloc.rate.norm: 118930.024 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   4: 65.423 us/op
                 gc.alloc.rate:      1731.324 MB/sec
                 gc.alloc.rate.norm: 118929.755 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms



Result "example.tasks.TaskCostBenchmark.eager":
  68.314 ±(99.9%) 30.602 us/op [Average]
  (min, avg, max) = (54.247, 68.314, 103.560), stdev = 16.006
  CI (99.9%): [37.712, 98.917] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.alloc.rate":
  1723.410 ±(99.9%) 625.456 MB/sec [Average]
  (min, avg, max) = (1093.639, 1723.410, 2088.132), stdev = 327.126
  CI (99.9%): [1097.954, 2348.866] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.alloc.rate.norm":
  118929.968 ±(99.9%) 1.351 B/op [Average]
  (min, avg, max) = (118929.499, 118929.968, 118931.659), stdev = 0.707
  CI (99.9%): [118928.617, 118931.320] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.count":
  26.000 ±(99.9%) 0.001 counts [Sum]
  (min, avg, max) = (2.000, 3.250, 4.000), stdev = 0.707
  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, 8.000), stdev = 1.488
  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:20
# Fork: 1 of 2
# Warmup Iteration   1: 5123.835 us/op
# Warmup Iteration   2: 117.976 us/op
# Warmup Iteration   3: 82.181 us/op
Iteration   1: 79.955 us/op
                 gc.alloc.rate:      1367.105 MB/sec
                 gc.alloc.rate.norm: 114868.006 B/op
                 gc.count:           4.000 counts
                 gc.time:            6.000 ms

Iteration   2: 76.480 us/op
                 gc.alloc.rate:      1427.971 MB/sec
                 gc.alloc.rate.norm: 114826.123 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   3: 71.026 us/op
                 gc.alloc.rate:      1520.684 MB/sec
                 gc.alloc.rate.norm: 114825.971 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   4: 64.857 us/op
                 gc.alloc.rate:      1651.410 MB/sec
                 gc.alloc.rate.norm: 114825.800 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms


# Run progress: 58.33% complete, ETA 00:00:17
# Fork: 2 of 2
# Warmup Iteration   1: 8025.314 us/op
# Warmup Iteration   2: 93.175 us/op
# Warmup Iteration   3: 71.774 us/op
Iteration   1: 64.045 us/op
                 gc.alloc.rate:      1701.613 MB/sec
                 gc.alloc.rate.norm: 114828.270 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   2: 69.351 us/op
                 gc.alloc.rate:      1575.536 MB/sec
                 gc.alloc.rate.norm: 114825.925 B/op
                 gc.count:           3.000 counts
                 gc.time:            6.000 ms

Iteration   3: 56.505 us/op
                 gc.alloc.rate:      1934.688 MB/sec
                 gc.alloc.rate.norm: 114825.566 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms

Iteration   4: 63.814 us/op
                 gc.alloc.rate:      1706.329 MB/sec
                 gc.alloc.rate.norm: 114825.762 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms



Result "example.tasks.TaskCostBenchmark.lazy":
  68.254 ±(99.9%) 14.462 us/op [Average]
  (min, avg, max) = (56.505, 68.254, 79.955), stdev = 7.564
  CI (99.9%): [53.792, 82.716] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.alloc.rate":
  1610.667 ±(99.9%) 343.627 MB/sec [Average]
  (min, avg, max) = (1367.105, 1610.667, 1934.688), stdev = 179.723
  CI (99.9%): [1267.040, 1954.294] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.alloc.rate.norm":
  114831.428 ±(99.9%) 28.307 B/op [Average]
  (min, avg, max) = (114825.566, 114831.428, 114868.006), stdev = 14.805
  CI (99.9%): [114803.122, 114859.735] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.lazy: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.lazy:gc.time":
  40.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (4.000, 5.000, 6.000), stdev = 0.756
  CI (99.9%): [40.000, 40.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:13
# Fork: 1 of 2
# Warmup Iteration   1: 12.104 us/op
# Warmup Iteration   2: 8.487 us/op
# Warmup Iteration   3: 7.915 us/op
Iteration   1: 7.797 us/op
                 gc.alloc.rate:      504.549 MB/sec
                 gc.alloc.rate.norm: 4136.219 B/op
                 gc.count:           1.000 counts
                 gc.time:            1.000 ms

Iteration   2: 6.115 us/op
                 gc.alloc.rate:      643.884 MB/sec
                 gc.alloc.rate.norm: 4136.170 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   3: 6.315 us/op
                 gc.alloc.rate:      623.616 MB/sec
                 gc.alloc.rate.norm: 4136.175 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   4: 6.100 us/op
                 gc.alloc.rate:      645.523 MB/sec
                 gc.alloc.rate.norm: 4136.167 B/op
                 gc.count:           2.000 counts
                 gc.time:            2.000 ms


# Run progress: 75.00% complete, ETA 00:00:10
# Fork: 2 of 2
# Warmup Iteration   1: 9.702 us/op
# Warmup Iteration   2: 7.192 us/op
# Warmup Iteration   3: 6.960 us/op
Iteration   1: 7.674 us/op
                 gc.alloc.rate:      513.131 MB/sec
                 gc.alloc.rate.norm: 4136.215 B/op
                 gc.count:           2.000 counts
                 gc.time:            2.000 ms

Iteration   2: 6.233 us/op
                 gc.alloc.rate:      631.875 MB/sec
                 gc.alloc.rate.norm: 4136.172 B/op
                 gc.count:           2.000 counts
                 gc.time:            2.000 ms

Iteration   3: 6.256 us/op
                 gc.alloc.rate:      629.337 MB/sec
                 gc.alloc.rate.norm: 4136.173 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   4: 6.148 us/op
                 gc.alloc.rate:      640.679 MB/sec
                 gc.alloc.rate.norm: 4136.170 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms



Result "example.tasks.TaskCostBenchmark.rawIds":
  6.580 ±(99.9%) 1.372 us/op [Average]
  (min, avg, max) = (6.100, 6.580, 7.797), stdev = 0.718
  CI (99.9%): [5.208, 7.952] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.alloc.rate":
  604.074 ±(99.9%) 113.372 MB/sec [Average]
  (min, avg, max) = (504.549, 604.074, 645.523), stdev = 59.296
  CI (99.9%): [490.702, 717.446] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.alloc.rate.norm":
  4136.183 ±(99.9%) 0.041 B/op [Average]
  (min, avg, max) = (4136.167, 4136.183, 4136.219), stdev = 0.021
  CI (99.9%): [4136.142, 4136.223] (assumes normal distribution)

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

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.time":
  21.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (1.000, 2.625, 4.000), stdev = 1.061
  CI (99.9%): [21.000, 21.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:06
# Fork: 1 of 2
# Warmup Iteration   1: 735994.425 us/op
# Warmup Iteration   2: 4.447 us/op
# Warmup Iteration   3: 0.460 us/op
Iteration   1: 0.284 us/op
                 gc.alloc.rate:      909.432 MB/sec
                 gc.alloc.rate.norm: 272.008 B/op
                 gc.count:           3.000 counts
                 gc.time:            6.000 ms

Iteration   2: 0.442 us/op
                 gc.alloc.rate:      579.815 MB/sec
                 gc.alloc.rate.norm: 272.012 B/op
                 gc.count:           1.000 counts
                 gc.time:            2.000 ms

Iteration   3: 0.319 us/op
                 gc.alloc.rate:      809.830 MB/sec
                 gc.alloc.rate.norm: 272.009 B/op
                 gc.count:           3.000 counts
                 gc.time:            7.000 ms

Iteration   4: 0.353 us/op
                 gc.alloc.rate:      729.886 MB/sec
                 gc.alloc.rate.norm: 272.010 B/op
                 gc.count:           2.000 counts
                 gc.time:            10.000 ms


# Run progress: 91.67% complete, ETA 00:00:03
# Fork: 2 of 2
# Warmup Iteration   1: 757252.931 us/op
# Warmup Iteration   2: 5.649 us/op
# Warmup Iteration   3: 0.789 us/op
Iteration   1: 0.273 us/op
                 gc.alloc.rate:      948.758 MB/sec
                 gc.alloc.rate.norm: 272.008 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   2: 0.302 us/op
                 gc.alloc.rate:      856.059 MB/sec
                 gc.alloc.rate.norm: 272.008 B/op
                 gc.count:           3.000 counts
                 gc.time:            6.000 ms

Iteration   3: 0.292 us/op
                 gc.alloc.rate:      884.801 MB/sec
                 gc.alloc.rate.norm: 272.008 B/op
                 gc.count:           2.000 counts
                 gc.time:            4.000 ms

Iteration   4: 0.295 us/op
                 gc.alloc.rate:      876.413 MB/sec
                 gc.alloc.rate.norm: 272.008 B/op
                 gc.count:           2.000 counts
                 gc.time:            5.000 ms



Result "example.tasks.TaskCostBenchmark.suspended":
  0.320 ±(99.9%) 0.105 us/op [Average]
  (min, avg, max) = (0.273, 0.320, 0.442), stdev = 0.055
  CI (99.9%): [0.215, 0.426] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.suspended:gc.alloc.rate":
  824.374 ±(99.9%) 227.400 MB/sec [Average]
  (min, avg, max) = (579.815, 824.374, 948.758), stdev = 118.935
  CI (99.9%): [596.974, 1051.775] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.suspended:gc.alloc.rate.norm":
  272.009 ±(99.9%) 0.003 B/op [Average]
  (min, avg, max) = (272.008, 272.009, 272.012), stdev = 0.002
  CI (99.9%): [272.006, 272.012] (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":
  45.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (2.000, 5.625, 10.000), stdev = 2.326
  CI (99.9%): [45.000, 45.000] (assumes normal distribution)


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

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.638 ±   2.287   us/op
TaskCostBenchmark.boxedIds:gc.alloc.rate        avgt    8    1555.901 ± 251.170  MB/sec
TaskCostBenchmark.boxedIds:gc.alloc.rate.norm   avgt    8   20520.352 ±   0.064    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.017 ±   0.001   us/op
TaskCostBenchmark.direct:gc.alloc.rate          avgt    8    4367.746 ± 250.315  MB/sec
TaskCostBenchmark.direct:gc.alloc.rate.norm     avgt    8      80.000 ±   0.001    B/op
TaskCostBenchmark.direct:gc.count               avgt    8      34.000            counts
TaskCostBenchmark.direct:gc.time                avgt    8      50.000                ms
TaskCostBenchmark.eager                         avgt    8      68.314 ±  30.602   us/op
TaskCostBenchmark.eager:gc.alloc.rate           avgt    8    1723.410 ± 625.456  MB/sec
TaskCostBenchmark.eager:gc.alloc.rate.norm      avgt    8  118929.968 ±   1.351    B/op
TaskCostBenchmark.eager:gc.count                avgt    8      26.000            counts
TaskCostBenchmark.eager:gc.time                 avgt    8      38.000                ms
TaskCostBenchmark.lazy                          avgt    8      68.254 ±  14.462   us/op
TaskCostBenchmark.lazy:gc.alloc.rate            avgt    8    1610.667 ± 343.627  MB/sec
TaskCostBenchmark.lazy:gc.alloc.rate.norm       avgt    8  114831.428 ±  28.307    B/op
TaskCostBenchmark.lazy:gc.count                 avgt    8      26.000            counts
TaskCostBenchmark.lazy:gc.time                  avgt    8      40.000                ms
TaskCostBenchmark.rawIds                        avgt    8       6.580 ±   1.372   us/op
TaskCostBenchmark.rawIds:gc.alloc.rate          avgt    8     604.074 ± 113.372  MB/sec
TaskCostBenchmark.rawIds:gc.alloc.rate.norm     avgt    8    4136.183 ±   0.041    B/op
TaskCostBenchmark.rawIds:gc.count               avgt    8      17.000            counts
TaskCostBenchmark.rawIds:gc.time                avgt    8      21.000                ms
TaskCostBenchmark.suspended                     avgt    8       0.320 ±   0.105   us/op
TaskCostBenchmark.suspended:gc.alloc.rate       avgt    8     824.374 ± 227.400  MB/sec
TaskCostBenchmark.suspended:gc.alloc.rate.norm  avgt    8     272.009 ±   0.003    B/op
TaskCostBenchmark.suspended:gc.count            avgt    8      19.000            counts
TaskCostBenchmark.suspended:gc.time             avgt    8      45.000                ms

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

BUILD SUCCESSFUL in 3m 7s
17 actionable tasks: 17 executed
EXIT_CODE=0
