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: 36.284 us/op
# Warmup Iteration   2: 13.055 us/op
# Warmup Iteration   3: 13.046 us/op
Iteration   1: 14.055 us/op
                 gc.alloc.rate:      1390.000 MB/sec
                 gc.alloc.rate.norm: 20520.390 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   2: 14.301 us/op
                 gc.alloc.rate:      1357.567 MB/sec
                 gc.alloc.rate.norm: 20520.397 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   3: 11.101 us/op
                 gc.alloc.rate:      1760.250 MB/sec
                 gc.alloc.rate.norm: 20520.313 B/op
                 gc.count:           3.000 counts
                 gc.time:            3.000 ms

Iteration   4: 11.391 us/op
                 gc.alloc.rate:      1715.272 MB/sec
                 gc.alloc.rate.norm: 20520.315 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms


# Run progress: 8.33% complete, ETA 00:00:36
# Fork: 2 of 2
# Warmup Iteration   1: 38.390 us/op
# Warmup Iteration   2: 11.718 us/op
# Warmup Iteration   3: 14.012 us/op
Iteration   1: 11.545 us/op
                 gc.alloc.rate:      1692.428 MB/sec
                 gc.alloc.rate.norm: 20520.320 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   2: 12.379 us/op
                 gc.alloc.rate:      1578.260 MB/sec
                 gc.alloc.rate.norm: 20520.341 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   3: 11.325 us/op
                 gc.alloc.rate:      1725.437 MB/sec
                 gc.alloc.rate.norm: 20520.317 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms

Iteration   4: 12.755 us/op
                 gc.alloc.rate:      1531.567 MB/sec
                 gc.alloc.rate.norm: 20520.354 B/op
                 gc.count:           2.000 counts
                 gc.time:            2.000 ms



Result "example.tasks.TaskCostBenchmark.boxedIds":
  12.356 ±(99.9%) 2.402 us/op [Average]
  (min, avg, max) = (11.101, 12.356, 14.301), stdev = 1.256
  CI (99.9%): [9.954, 14.759] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.boxedIds:gc.alloc.rate":
  1593.848 ±(99.9%) 298.810 MB/sec [Average]
  (min, avg, max) = (1357.567, 1593.848, 1760.250), stdev = 156.284
  CI (99.9%): [1295.037, 1892.658] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.boxedIds:gc.alloc.rate.norm":
  20520.343 ±(99.9%) 0.065 B/op [Average]
  (min, avg, max) = (20520.313, 20520.343, 20520.397), stdev = 0.034
  CI (99.9%): [20520.278, 20520.409] (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":
  31.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (2.000, 3.875, 5.000), stdev = 0.991
  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:33
# Fork: 1 of 2
# Warmup Iteration   1: 0.053 us/op
# Warmup Iteration   2: 0.026 us/op
# Warmup Iteration   3: 0.021 us/op
Iteration   1: 0.021 us/op
                 gc.alloc.rate:      3552.945 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           5.000 counts
                 gc.time:            9.000 ms

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

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

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


# Run progress: 25.00% complete, ETA 00:00:30
# Fork: 2 of 2
# Warmup Iteration   1: 0.052 us/op
# Warmup Iteration   2: 0.026 us/op
# Warmup Iteration   3: 0.021 us/op
Iteration   1: 0.021 us/op
                 gc.alloc.rate:      3652.395 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           5.000 counts
                 gc.time:            8.000 ms

Iteration   2: 0.019 us/op
                 gc.alloc.rate:      3934.971 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms

Iteration   3: 0.019 us/op
                 gc.alloc.rate:      3933.305 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           5.000 counts
                 gc.time:            6.000 ms

Iteration   4: 0.019 us/op
                 gc.alloc.rate:      4005.070 MB/sec
                 gc.alloc.rate.norm: 80.001 B/op
                 gc.count:           5.000 counts
                 gc.time:            8.000 ms



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

Secondary result "example.tasks.TaskCostBenchmark.direct:gc.alloc.rate":
  4001.579 ±(99.9%) 584.894 MB/sec [Average]
  (min, avg, max) = (3552.945, 4001.579, 4393.969), stdev = 305.911
  CI (99.9%): [3416.685, 4586.472] (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":
  37.000 ±(99.9%) 0.001 counts [Sum]
  (min, avg, max) = (4.000, 4.625, 5.000), stdev = 0.518
  CI (99.9%): [37.000, 37.000] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.direct:gc.time":
  55.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (5.000, 6.875, 9.000), stdev = 1.356
  CI (99.9%): [55.000, 55.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: 678.840 us/op
# Warmup Iteration   2: 83.965 us/op
# Warmup Iteration   3: 63.886 us/op
Iteration   1: 60.081 us/op
                 gc.alloc.rate:      1884.729 MB/sec
                 gc.alloc.rate.norm: 118929.666 B/op
                 gc.count:           4.000 counts
                 gc.time:            6.000 ms

Iteration   2: 65.511 us/op
                 gc.alloc.rate:      1720.853 MB/sec
                 gc.alloc.rate.norm: 118929.809 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   3: 62.115 us/op
                 gc.alloc.rate:      1822.701 MB/sec
                 gc.alloc.rate.norm: 118929.716 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   4: 58.775 us/op
                 gc.alloc.rate:      1926.562 MB/sec
                 gc.alloc.rate.norm: 118929.631 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms


# Run progress: 41.67% complete, ETA 00:00:23
# Fork: 2 of 2
# Warmup Iteration   1: 1003.036 us/op
# Warmup Iteration   2: 69.591 us/op
# Warmup Iteration   3: 59.615 us/op
Iteration   1: 60.513 us/op
                 gc.alloc.rate:      1869.306 MB/sec
                 gc.alloc.rate.norm: 118929.679 B/op
                 gc.count:           4.000 counts
                 gc.time:            6.000 ms

Iteration   2: 56.993 us/op
                 gc.alloc.rate:      1986.566 MB/sec
                 gc.alloc.rate.norm: 118929.582 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   3: 67.785 us/op
                 gc.alloc.rate:      1670.847 MB/sec
                 gc.alloc.rate.norm: 118929.881 B/op
                 gc.count:           3.000 counts
                 gc.time:            4.000 ms

Iteration   4: 57.723 us/op
                 gc.alloc.rate:      1961.791 MB/sec
                 gc.alloc.rate.norm: 118929.602 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms



Result "example.tasks.TaskCostBenchmark.eager":
  61.187 ±(99.9%) 7.233 us/op [Average]
  (min, avg, max) = (56.993, 61.187, 67.785), stdev = 3.783
  CI (99.9%): [53.954, 68.420] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.alloc.rate":
  1855.419 ±(99.9%) 214.220 MB/sec [Average]
  (min, avg, max) = (1670.847, 1855.419, 1986.566), stdev = 112.041
  CI (99.9%): [1641.199, 2069.640] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager:gc.alloc.rate.norm":
  118929.696 ±(99.9%) 0.198 B/op [Average]
  (min, avg, max) = (118929.582, 118929.696, 118929.881), stdev = 0.103
  CI (99.9%): [118929.498, 118929.894] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.eager: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.eager:gc.time":
  37.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (3.000, 4.625, 6.000), stdev = 1.061
  CI (99.9%): [37.000, 37.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:19
# Fork: 1 of 2
# Warmup Iteration   1: 639.304 us/op
# Warmup Iteration   2: 70.318 us/op
# Warmup Iteration   3: 61.053 us/op
Iteration   1: 59.865 us/op
                 gc.alloc.rate:      1826.305 MB/sec
                 gc.alloc.rate.norm: 114825.661 B/op
                 gc.count:           4.000 counts
                 gc.time:            6.000 ms

Iteration   2: 52.164 us/op
                 gc.alloc.rate:      2095.953 MB/sec
                 gc.alloc.rate.norm: 114825.448 B/op
                 gc.count:           4.000 counts
                 gc.time:            4.000 ms

Iteration   3: 75.944 us/op
                 gc.alloc.rate:      1439.947 MB/sec
                 gc.alloc.rate.norm: 114826.107 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   4: 55.630 us/op
                 gc.alloc.rate:      1965.482 MB/sec
                 gc.alloc.rate.norm: 114825.544 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms


# Run progress: 58.33% complete, ETA 00:00:16
# Fork: 2 of 2
# Warmup Iteration   1: 2215.749 us/op
# Warmup Iteration   2: 97.552 us/op
# Warmup Iteration   3: 90.811 us/op
Iteration   1: 62.529 us/op
                 gc.alloc.rate:      1749.184 MB/sec
                 gc.alloc.rate.norm: 114857.810 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   2: 58.333 us/op
                 gc.alloc.rate:      1874.282 MB/sec
                 gc.alloc.rate.norm: 114825.606 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   3: 55.591 us/op
                 gc.alloc.rate:      1966.512 MB/sec
                 gc.alloc.rate.norm: 114825.543 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   4: 51.359 us/op
                 gc.alloc.rate:      2128.744 MB/sec
                 gc.alloc.rate.norm: 114825.425 B/op
                 gc.count:           4.000 counts
                 gc.time:            5.000 ms



Result "example.tasks.TaskCostBenchmark.lazy":
  58.927 ±(99.9%) 14.965 us/op [Average]
  (min, avg, max) = (51.359, 58.927, 75.944), stdev = 7.827
  CI (99.9%): [43.962, 73.891] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.alloc.rate":
  1880.801 ±(99.9%) 419.497 MB/sec [Average]
  (min, avg, max) = (1439.947, 1880.801, 2128.744), stdev = 219.405
  CI (99.9%): [1461.304, 2300.299] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.alloc.rate.norm":
  114829.643 ±(99.9%) 21.764 B/op [Average]
  (min, avg, max) = (114825.425, 114829.643, 114857.810), stdev = 11.383
  CI (99.9%): [114807.879, 114851.407] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.lazy:gc.count":
  27.000 ±(99.9%) 0.001 counts [Sum]
  (min, avg, max) = (2.000, 3.375, 4.000), stdev = 0.744
  CI (99.9%): [27.000, 27.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 = 0.886
  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:13
# Fork: 1 of 2
# Warmup Iteration   1: 10.115 us/op
# Warmup Iteration   2: 7.535 us/op
# Warmup Iteration   3: 7.400 us/op
Iteration   1: 8.580 us/op
                 gc.alloc.rate:      458.336 MB/sec
                 gc.alloc.rate.norm: 4136.242 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

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

Iteration   3: 6.118 us/op
                 gc.alloc.rate:      643.104 MB/sec
                 gc.alloc.rate.norm: 4136.170 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   4: 5.960 us/op
                 gc.alloc.rate:      651.837 MB/sec
                 gc.alloc.rate.norm: 4136.165 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms


# Run progress: 75.00% complete, ETA 00:00:09
# Fork: 2 of 2
# Warmup Iteration   1: 9.679 us/op
# Warmup Iteration   2: 7.537 us/op
# Warmup Iteration   3: 7.374 us/op
Iteration   1: 8.044 us/op
                 gc.alloc.rate:      489.602 MB/sec
                 gc.alloc.rate.norm: 4136.226 B/op
                 gc.count:           2.000 counts
                 gc.time:            2.000 ms

Iteration   2: 6.897 us/op
                 gc.alloc.rate:      570.827 MB/sec
                 gc.alloc.rate.norm: 4136.191 B/op
                 gc.count:           2.000 counts
                 gc.time:            2.000 ms

Iteration   3: 6.167 us/op
                 gc.alloc.rate:      637.037 MB/sec
                 gc.alloc.rate.norm: 4136.171 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms

Iteration   4: 6.996 us/op
                 gc.alloc.rate:      560.975 MB/sec
                 gc.alloc.rate.norm: 4136.193 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms



Result "example.tasks.TaskCostBenchmark.rawIds":
  6.861 ±(99.9%) 1.878 us/op [Average]
  (min, avg, max) = (5.960, 6.861, 8.580), stdev = 0.982
  CI (99.9%): [4.983, 8.740] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.alloc.rate":
  581.781 ±(99.9%) 143.989 MB/sec [Average]
  (min, avg, max) = (458.336, 581.781, 651.837), stdev = 75.309
  CI (99.9%): [437.792, 725.771] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.rawIds:gc.alloc.rate.norm":
  4136.191 ±(99.9%) 0.055 B/op [Average]
  (min, avg, max) = (4136.165, 4136.191, 4136.242), stdev = 0.029
  CI (99.9%): [4136.136, 4136.246] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.rawIds: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.rawIds:gc.time":
  21.000 ±(99.9%) 0.001 ms [Sum]
  (min, avg, max) = (2.000, 2.625, 3.000), stdev = 0.518
  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: 737887.486 us/op
# Warmup Iteration   2: 3.004 us/op
# Warmup Iteration   3: 0.267 us/op
Iteration   1: 0.242 us/op
                 gc.alloc.rate:      1226.974 MB/sec
                 gc.alloc.rate.norm: 312.007 B/op
                 gc.count:           3.000 counts
                 gc.time:            5.000 ms

Iteration   2: 0.244 us/op
                 gc.alloc.rate:      1219.588 MB/sec
                 gc.alloc.rate.norm: 312.007 B/op
                 gc.count:           3.000 counts
                 gc.time:            6.000 ms

Iteration   3: 0.246 us/op
                 gc.alloc.rate:      1206.064 MB/sec
                 gc.alloc.rate.norm: 312.007 B/op
                 gc.count:           2.000 counts
                 gc.time:            5.000 ms

Iteration   4: 0.255 us/op
                 gc.alloc.rate:      1165.028 MB/sec
                 gc.alloc.rate.norm: 312.007 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: 713091.701 us/op
# Warmup Iteration   2: 3.630 us/op
# Warmup Iteration   3: 0.362 us/op
Iteration   1: 0.249 us/op
                 gc.alloc.rate:      1038.291 MB/sec
                 gc.alloc.rate.norm: 272.007 B/op
                 gc.count:           4.000 counts
                 gc.time:            6.000 ms

Iteration   2: 0.248 us/op
                 gc.alloc.rate:      1044.358 MB/sec
                 gc.alloc.rate.norm: 272.007 B/op
                 gc.count:           2.000 counts
                 gc.time:            4.000 ms

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

Iteration   4: 0.259 us/op
                 gc.alloc.rate:      999.271 MB/sec
                 gc.alloc.rate.norm: 272.007 B/op
                 gc.count:           2.000 counts
                 gc.time:            3.000 ms



Result "example.tasks.TaskCostBenchmark.suspended":
  0.251 ±(99.9%) 0.017 us/op [Average]
  (min, avg, max) = (0.242, 0.251, 0.269), stdev = 0.009
  CI (99.9%): [0.234, 0.269] (assumes normal distribution)

Secondary result "example.tasks.TaskCostBenchmark.suspended:gc.alloc.rate":
  1107.313 ±(99.9%) 207.473 MB/sec [Average]
  (min, avg, max) = (958.933, 1107.313, 1226.974), stdev = 108.512
  CI (99.9%): [899.841, 1314.786] (assumes normal distribution)

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

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

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


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

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.356 ±   2.402   us/op
TaskCostBenchmark.boxedIds:gc.alloc.rate        avgt    8    1593.848 ± 298.810  MB/sec
TaskCostBenchmark.boxedIds:gc.alloc.rate.norm   avgt    8   20520.343 ±   0.065    B/op
TaskCostBenchmark.boxedIds:gc.count             avgt    8      24.000            counts
TaskCostBenchmark.boxedIds:gc.time              avgt    8      31.000                ms
TaskCostBenchmark.direct                        avgt    8       0.019 ±   0.003   us/op
TaskCostBenchmark.direct:gc.alloc.rate          avgt    8    4001.579 ± 584.894  MB/sec
TaskCostBenchmark.direct:gc.alloc.rate.norm     avgt    8      80.001 ±   0.001    B/op
TaskCostBenchmark.direct:gc.count               avgt    8      37.000            counts
TaskCostBenchmark.direct:gc.time                avgt    8      55.000                ms
TaskCostBenchmark.eager                         avgt    8      61.187 ±   7.233   us/op
TaskCostBenchmark.eager:gc.alloc.rate           avgt    8    1855.419 ± 214.220  MB/sec
TaskCostBenchmark.eager:gc.alloc.rate.norm      avgt    8  118929.696 ±   0.198    B/op
TaskCostBenchmark.eager:gc.count                avgt    8      25.000            counts
TaskCostBenchmark.eager:gc.time                 avgt    8      37.000                ms
TaskCostBenchmark.lazy                          avgt    8      58.927 ±  14.965   us/op
TaskCostBenchmark.lazy:gc.alloc.rate            avgt    8    1880.801 ± 419.497  MB/sec
TaskCostBenchmark.lazy:gc.alloc.rate.norm       avgt    8  114829.643 ±  21.764    B/op
TaskCostBenchmark.lazy:gc.count                 avgt    8      27.000            counts
TaskCostBenchmark.lazy:gc.time                  avgt    8      38.000                ms
TaskCostBenchmark.rawIds                        avgt    8       6.861 ±   1.878   us/op
TaskCostBenchmark.rawIds:gc.alloc.rate          avgt    8     581.781 ± 143.989  MB/sec
TaskCostBenchmark.rawIds:gc.alloc.rate.norm     avgt    8    4136.191 ±   0.055    B/op
TaskCostBenchmark.rawIds:gc.count               avgt    8      16.000            counts
TaskCostBenchmark.rawIds:gc.time                avgt    8      21.000                ms
TaskCostBenchmark.suspended                     avgt    8       0.251 ±   0.017   us/op
TaskCostBenchmark.suspended:gc.alloc.rate       avgt    8    1107.313 ± 207.473  MB/sec
TaskCostBenchmark.suspended:gc.alloc.rate.norm  avgt    8     292.007 ±  40.880    B/op
TaskCostBenchmark.suspended:gc.count            avgt    8      22.000            counts
TaskCostBenchmark.suspended:gc.time             avgt    8      40.000                ms

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

BUILD SUCCESSFUL in 2m 43s
17 actionable tasks: 17 executed
EXIT_CODE=0
