diff --git a/lexers/regex/verifiedlexer/benchmark_wi5_i5_regex_zipper_laraquad3.txt b/lexers/regex/verifiedlexer/benchmark_wi5_i5_regex_zipper_laraquad3.txt new file mode 100644 index 00000000..63ef5f4c --- /dev/null +++ b/lexers/regex/verifiedlexer/benchmark_wi5_i5_regex_zipper_laraquad3.txt @@ -0,0 +1,4856 @@ +[info] welcome to sbt 1.9.8 (Eclipse Adoptium Java 17.0.11) +[info] loading settings for project verifiedlexer-build-build-build from metals.sbt ... +[info] loading project definition from /localhome/chassot/bolts/lexers/regex/verifiedlexer/project/project/project +[info] loading settings for project verifiedlexer-build-build from metals.sbt ... +[info] loading project definition from /localhome/chassot/bolts/lexers/regex/verifiedlexer/project/project +[success] Generated .bloop/verifiedlexer-build-build.json +[success] Total time: 3 s, completed Nov 28, 2024, 1:10:17 PM +[info] loading settings for project verifiedlexer-build from metals.sbt,plugins.sbt ... +[info] loading project definition from /localhome/chassot/bolts/lexers/regex/verifiedlexer/project +[success] Generated .bloop/verifiedlexer-build.json +[success] Total time: 2 s, completed Nov 28, 2024, 1:10:19 PM +[info] loading settings for project verifiedlexer from build.sbt ... +[info] set current project to VerifiedLexer (in build file:/localhome/chassot/bolts/lexers/regex/verifiedlexer/) +[info] compiling 58 Scala sources to /localhome/chassot/bolts/lexers/regex/verifiedlexer/target/scala-3.5.2/classes ... +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/lexer/Utils.scala:522:23 +[warn] 522 | val res: List[B] = l match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Nil() +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/lexer/Utils.scala:550:4 +[warn] 550 | l match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Cons(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/lexer/Utils.scala:1035:4 +[warn] 1035 | newList match { +[warn] | ^^^^^^^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Cons(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/lexer/VerifiedLexer.scala:223:10 +[warn] 223 | maxPrefWithoutSep match { +[warn] | ^^^^^^^^^^^^^^^^^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.lang.Some(_) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/lexer/VerifiedLexer.scala:257:10 +[warn] 257 | (currentRulePref, othersPrefix) match { +[warn] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +[warn] |match may not be exhaustive. +[warn] | +[warn] |It would fail on pattern case: (stainless.lang.Some(_), stainless.lang.Some(_)) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/lexer/VerifiedLexer.scala:252:45 +[warn] 252 | val ret: Option[(Token[C], List[C])] = rulesArg match { +[warn] | ^^^^^^^^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Nil() +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/lexer/VerifiedLexer.scala:611:6 +[warn] 611 | rules match { +[warn] | ^^^^^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Cons(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/lexer/VerifiedRegex.scala:332:4 +[warn] 332 | r match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: Concat(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/ListLongMap.scala:157:4 +[warn] 157 | l match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Cons(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/ListLongMap.scala:191:4 +[warn] 191 | l match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Cons(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/ListLongMap.scala:206:4 +[warn] 206 | l match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Cons(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/ListLongMap.scala:222:4 +[warn] 222 | l match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Cons(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/ListLongMap.scala:243:4 +[warn] 243 | l match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Cons(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/ListLongMap.scala:274:4 +[warn] 274 | l match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Cons(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/ListMap.scala:195:4 +[warn] 195 | l match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Cons(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/ListMap.scala:229:4 +[warn] 229 | l match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Cons(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/ListMap.scala:256:4 +[warn] 256 | l match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Cons(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/ListMap.scala:308:4 +[warn] 308 | l match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Cons(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/ListMap.scala:380:4 +[warn] 380 | l match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: stainless.collection.Cons(_, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/MutableLongMap.scala:347:4 +[warn] 347 | c match { +[warn] | ^ +[warn] | match may not be exhaustive. +[warn] | +[warn] | It would fail on pattern case: EmptyCell() +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/MutableLongMap.scala:596:8 +[warn] 596 | seekEntryRes match { +[warn] | ^^^^^^^^^^^^ +[warn] |match may not be exhaustive. +[warn] | +[warn] |It would fail on pattern case: ch.epfl.map.MutableLongMap.Intermediate(_, _, _) +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/MutableLongMap.scala:1106:6 +[warn] 1106 | intermediate match { +[warn] | ^^^^^^^^^^^^ +[warn] |match may not be exhaustive. +[warn] | +[warn] |It would fail on pattern case: _: ch.epfl.map.MutableLongMap.SeekEntryResult +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] -- [E029] Pattern Match Exhaustivity Warning: /localhome/chassot/bolts/lexers/regex/verifiedlexer/src/main/scala/ch/epfl/map/MutableLongMap.scala:1156:6 +[warn] 1156 | intermediate match { +[warn] | ^^^^^^^^^^^^ +[warn] |match may not be exhaustive. +[warn] | +[warn] |It would fail on pattern case: _: ch.epfl.map.MutableLongMap.SeekEntryResult +[warn] | +[warn] | longer explanation available when compiling with `-explain` +[warn] 23 warnings found +[info] done compiling +[info] compiling 44 Scala sources to /localhome/chassot/bolts/lexers/regex/verifiedlexer/target/scala-3.5.2/test-classes ... +[info] running org.openjdk.jmh.generators.bytecode.JmhBytecodeGenerator /localhome/chassot/bolts/lexers/regex/verifiedlexer/target/scala-3.5.2/classes /localhome/chassot/bolts/lexers/regex/verifiedlexer/target/scala-3.5.2/src_managed/jmh /localhome/chassot/bolts/lexers/regex/verifiedlexer/target/scala-3.5.2/resource_managed/jmh default +Processing 847 classes from /localhome/chassot/bolts/lexers/regex/verifiedlexer/target/scala-3.5.2/classes with "reflection" generator +Writing out Java source to /localhome/chassot/bolts/lexers/regex/verifiedlexer/target/scala-3.5.2/src_managed/jmh and resources to /localhome/chassot/bolts/lexers/regex/verifiedlexer/target/scala-3.5.2/resource_managed/jmh +[info] compiling 12 Java sources to /localhome/chassot/bolts/lexers/regex/verifiedlexer/target/scala-3.5.2/classes ... +[info] done compiling +[info] done compiling +[info] running (fork) org.openjdk.jmh.Main -i 5 -wi 5 -f1 -t1 +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 5) +[info] # Run progress: 0.00% complete, ETA 04:26:40 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 1.893 us/op +[info] # Warmup Iteration 2: 1.746 us/op +[info] # Warmup Iteration 3: 1.692 us/op +[info] # Warmup Iteration 4: 1.704 us/op +[info] # Warmup Iteration 5: 1.692 us/op +[info] Iteration 1: 1.697 us/op +[info] Iteration 2: 1.743 us/op +[info] Iteration 3: 1.790 us/op +[info] Iteration 4: 1.673 us/op +[info] Iteration 5: 1.689 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 1.718 ±(99.9%) 0.185 us/op [Average] +[info] (min, avg, max) = (1.673, 1.718, 1.790), stdev = 0.048 +[info] CI (99.9%): [1.534, 1.903] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 10) +[info] # Run progress: 0.63% complete, ETA 04:26:15 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 10.807 us/op +[info] # Warmup Iteration 2: 10.209 us/op +[info] # Warmup Iteration 3: 10.220 us/op +[info] # Warmup Iteration 4: 10.218 us/op +[info] # Warmup Iteration 5: 10.229 us/op +[info] Iteration 1: 10.054 us/op +[info] Iteration 2: 10.062 us/op +[info] Iteration 3: 10.186 us/op +[info] Iteration 4: 10.071 us/op +[info] Iteration 5: 10.204 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 10.116 ±(99.9%) 0.283 us/op [Average] +[info] (min, avg, max) = (10.054, 10.116, 10.204), stdev = 0.073 +[info] CI (99.9%): [9.833, 10.398] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 15) +[info] # Run progress: 1.25% complete, ETA 04:24:31 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 34.100 us/op +[info] # Warmup Iteration 2: 31.979 us/op +[info] # Warmup Iteration 3: 32.033 us/op +[info] # Warmup Iteration 4: 31.788 us/op +[info] # Warmup Iteration 5: 31.933 us/op +[info] Iteration 1: 31.570 us/op +[info] Iteration 2: 31.822 us/op +[info] Iteration 3: 31.868 us/op +[info] Iteration 4: 32.109 us/op +[info] Iteration 5: 31.561 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 31.786 ±(99.9%) 0.882 us/op [Average] +[info] (min, avg, max) = (31.561, 31.786, 32.109), stdev = 0.229 +[info] CI (99.9%): [30.904, 32.668] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 20) +[info] # Run progress: 1.88% complete, ETA 04:22:48 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 79.834 us/op +[info] # Warmup Iteration 2: 75.056 us/op +[info] # Warmup Iteration 3: 74.888 us/op +[info] # Warmup Iteration 4: 74.625 us/op +[info] # Warmup Iteration 5: 74.751 us/op +[info] Iteration 1: 73.821 us/op +[info] Iteration 2: 74.809 us/op +[info] Iteration 3: 73.726 us/op +[info] Iteration 4: 75.158 us/op +[info] Iteration 5: 73.807 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 74.264 ±(99.9%) 2.577 us/op [Average] +[info] (min, avg, max) = (73.726, 74.264, 75.158), stdev = 0.669 +[info] CI (99.9%): [71.687, 76.841] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 25) +[info] # Run progress: 2.50% complete, ETA 04:21:06 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 156.665 us/op +[info] # Warmup Iteration 2: 148.576 us/op +[info] # Warmup Iteration 3: 147.658 us/op +[info] # Warmup Iteration 4: 147.439 us/op +[info] # Warmup Iteration 5: 147.855 us/op +[info] Iteration 1: 145.484 us/op +[info] Iteration 2: 147.155 us/op +[info] Iteration 3: 144.918 us/op +[info] Iteration 4: 146.754 us/op +[info] Iteration 5: 146.137 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 146.090 ±(99.9%) 3.507 us/op [Average] +[info] (min, avg, max) = (144.918, 146.090, 147.155), stdev = 0.911 +[info] CI (99.9%): [142.582, 149.597] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 30) +[info] # Run progress: 3.13% complete, ETA 04:19:25 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 271.811 us/op +[info] # Warmup Iteration 2: 257.193 us/op +[info] # Warmup Iteration 3: 256.897 us/op +[info] # Warmup Iteration 4: 256.498 us/op +[info] # Warmup Iteration 5: 254.767 us/op +[info] Iteration 1: 254.039 us/op +[info] Iteration 2: 258.260 us/op +[info] Iteration 3: 256.664 us/op +[info] Iteration 4: 258.534 us/op +[info] Iteration 5: 252.884 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 256.076 ±(99.9%) 9.722 us/op [Average] +[info] (min, avg, max) = (252.884, 256.076, 258.534), stdev = 2.525 +[info] CI (99.9%): [246.355, 265.798] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 35) +[info] # Run progress: 3.75% complete, ETA 04:17:44 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 436.947 us/op +[info] # Warmup Iteration 2: 414.890 us/op +[info] # Warmup Iteration 3: 414.595 us/op +[info] # Warmup Iteration 4: 415.311 us/op +[info] # Warmup Iteration 5: 408.053 us/op +[info] Iteration 1: 412.597 us/op +[info] Iteration 2: 411.373 us/op +[info] Iteration 3: 409.924 us/op +[info] Iteration 4: 410.601 us/op +[info] Iteration 5: 409.639 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 410.827 ±(99.9%) 4.600 us/op [Average] +[info] (min, avg, max) = (409.639, 410.827, 412.597), stdev = 1.195 +[info] CI (99.9%): [406.226, 415.427] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 40) +[info] # Run progress: 4.38% complete, ETA 04:16:03 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 663.111 us/op +[info] # Warmup Iteration 2: 625.955 us/op +[info] # Warmup Iteration 3: 627.828 us/op +[info] # Warmup Iteration 4: 626.643 us/op +[info] # Warmup Iteration 5: 619.212 us/op +[info] Iteration 1: 617.324 us/op +[info] Iteration 2: 618.400 us/op +[info] Iteration 3: 617.164 us/op +[info] Iteration 4: 614.740 us/op +[info] Iteration 5: 622.594 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 618.044 ±(99.9%) 11.066 us/op [Average] +[info] (min, avg, max) = (614.740, 618.044, 622.594), stdev = 2.874 +[info] CI (99.9%): [606.978, 629.110] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 45) +[info] # Run progress: 5.00% complete, ETA 04:14:22 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 951.215 us/op +[info] # Warmup Iteration 2: 895.022 us/op +[info] # Warmup Iteration 3: 895.570 us/op +[info] # Warmup Iteration 4: 897.134 us/op +[info] # Warmup Iteration 5: 883.724 us/op +[info] Iteration 1: 900.422 us/op +[info] Iteration 2: 886.968 us/op +[info] Iteration 3: 901.261 us/op +[info] Iteration 4: 895.335 us/op +[info] Iteration 5: 894.478 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 895.693 ±(99.9%) 22.044 us/op [Average] +[info] (min, avg, max) = (886.968, 895.693, 901.261), stdev = 5.725 +[info] CI (99.9%): [873.649, 917.737] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 50) +[info] # Run progress: 5.63% complete, ETA 04:12:42 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 1321.473 us/op +[info] # Warmup Iteration 2: 1244.650 us/op +[info] # Warmup Iteration 3: 1252.287 us/op +[info] # Warmup Iteration 4: 1242.204 us/op +[info] # Warmup Iteration 5: 1242.275 us/op +[info] Iteration 1: 1247.789 us/op +[info] Iteration 2: 1250.646 us/op +[info] Iteration 3: 1230.086 us/op +[info] Iteration 4: 1244.640 us/op +[info] Iteration 5: 1223.130 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 1239.258 ±(99.9%) 46.194 us/op [Average] +[info] (min, avg, max) = (1223.130, 1239.258, 1250.646), stdev = 11.996 +[info] CI (99.9%): [1193.064, 1285.452] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 55) +[info] # Run progress: 6.25% complete, ETA 04:11:01 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 1783.678 us/op +[info] # Warmup Iteration 2: 1684.516 us/op +[info] # Warmup Iteration 3: 1681.852 us/op +[info] # Warmup Iteration 4: 1674.600 us/op +[info] # Warmup Iteration 5: 1677.731 us/op +[info] Iteration 1: 1654.021 us/op +[info] Iteration 2: 1674.448 us/op +[info] Iteration 3: 1654.551 us/op +[info] Iteration 4: 1663.738 us/op +[info] Iteration 5: 1658.206 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 1660.993 ±(99.9%) 32.586 us/op [Average] +[info] (min, avg, max) = (1654.021, 1660.993, 1674.448), stdev = 8.462 +[info] CI (99.9%): [1628.407, 1693.579] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 60) +[info] # Run progress: 6.88% complete, ETA 04:09:20 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 2338.491 us/op +[info] # Warmup Iteration 2: 2211.306 us/op +[info] # Warmup Iteration 3: 2200.110 us/op +[info] # Warmup Iteration 4: 2226.046 us/op +[info] # Warmup Iteration 5: 2194.647 us/op +[info] Iteration 1: 2190.000 us/op +[info] Iteration 2: 2211.766 us/op +[info] Iteration 3: 2235.557 us/op +[info] Iteration 4: 2182.800 us/op +[info] Iteration 5: 2206.895 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 2205.404 ±(99.9%) 79.386 us/op [Average] +[info] (min, avg, max) = (2182.800, 2205.404, 2235.557), stdev = 20.616 +[info] CI (99.9%): [2126.017, 2284.790] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 65) +[info] # Run progress: 7.50% complete, ETA 04:07:40 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 3018.482 us/op +[info] # Warmup Iteration 2: 2832.532 us/op +[info] # Warmup Iteration 3: 2837.197 us/op +[info] # Warmup Iteration 4: 2807.911 us/op +[info] # Warmup Iteration 5: 2812.827 us/op +[info] Iteration 1: 2824.355 us/op +[info] Iteration 2: 2784.257 us/op +[info] Iteration 3: 2819.723 us/op +[info] Iteration 4: 2784.265 us/op +[info] Iteration 5: 2809.912 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 2804.502 ±(99.9%) 73.930 us/op [Average] +[info] (min, avg, max) = (2784.257, 2804.502, 2824.355), stdev = 19.199 +[info] CI (99.9%): [2730.572, 2878.433] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 70) +[info] # Run progress: 8.13% complete, ETA 04:06:00 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 3788.844 us/op +[info] # Warmup Iteration 2: 3545.434 us/op +[info] # Warmup Iteration 3: 3499.799 us/op +[info] # Warmup Iteration 4: 3539.087 us/op +[info] # Warmup Iteration 5: 3482.376 us/op +[info] Iteration 1: 3554.703 us/op +[info] Iteration 2: 3505.661 us/op +[info] Iteration 3: 3548.476 us/op +[info] Iteration 4: 3509.635 us/op +[info] Iteration 5: 3548.219 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 3533.339 ±(99.9%) 91.019 us/op [Average] +[info] (min, avg, max) = (3505.661, 3533.339, 3554.703), stdev = 23.637 +[info] CI (99.9%): [3442.320, 3624.358] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 75) +[info] # Run progress: 8.75% complete, ETA 04:04:19 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 4724.984 us/op +[info] # Warmup Iteration 2: 4414.747 us/op +[info] # Warmup Iteration 3: 4385.753 us/op +[info] # Warmup Iteration 4: 4421.577 us/op +[info] # Warmup Iteration 5: 4515.994 us/op +[info] Iteration 1: 4435.122 us/op +[info] Iteration 2: 4469.446 us/op +[info] Iteration 3: 4415.493 us/op +[info] Iteration 4: 4395.342 us/op +[info] Iteration 5: 4342.924 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 4411.665 ±(99.9%) 181.586 us/op [Average] +[info] (min, avg, max) = (4342.924, 4411.665, 4469.446), stdev = 47.157 +[info] CI (99.9%): [4230.079, 4593.251] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 80) +[info] # Run progress: 9.38% complete, ETA 04:02:39 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 5727.227 us/op +[info] # Warmup Iteration 2: 5350.702 us/op +[info] # Warmup Iteration 3: 5288.866 us/op +[info] # Warmup Iteration 4: 5369.704 us/op +[info] # Warmup Iteration 5: 5281.919 us/op +[info] Iteration 1: 5355.887 us/op +[info] Iteration 2: 5336.874 us/op +[info] Iteration 3: 5293.648 us/op +[info] Iteration 4: 5261.380 us/op +[info] Iteration 5: 5338.653 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 5317.288 ±(99.9%) 149.315 us/op [Average] +[info] (min, avg, max) = (5261.380, 5317.288, 5355.887), stdev = 38.777 +[info] CI (99.9%): [5167.973, 5466.604] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 85) +[info] # Run progress: 10.00% complete, ETA 04:00:59 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 6902.766 us/op +[info] # Warmup Iteration 2: 6444.748 us/op +[info] # Warmup Iteration 3: 6428.795 us/op +[info] # Warmup Iteration 4: 6393.420 us/op +[info] # Warmup Iteration 5: 6472.554 us/op +[info] Iteration 1: 6370.088 us/op +[info] Iteration 2: 6457.461 us/op +[info] Iteration 3: 6346.935 us/op +[info] Iteration 4: 6373.305 us/op +[info] Iteration 5: 6382.865 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 6386.131 ±(99.9%) 161.737 us/op [Average] +[info] (min, avg, max) = (6346.935, 6386.131, 6457.461), stdev = 42.003 +[info] CI (99.9%): [6224.394, 6547.868] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 90) +[info] # Run progress: 10.63% complete, ETA 03:59:18 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 8214.794 us/op +[info] # Warmup Iteration 2: 7603.918 us/op +[info] # Warmup Iteration 3: 7676.171 us/op +[info] # Warmup Iteration 4: 7697.759 us/op +[info] # Warmup Iteration 5: 7760.668 us/op +[info] Iteration 1: 7820.583 us/op +[info] Iteration 2: 7801.222 us/op +[info] Iteration 3: 7815.937 us/op +[info] Iteration 4: 7727.704 us/op +[info] Iteration 5: 7667.320 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 7766.553 ±(99.9%) 257.710 us/op [Average] +[info] (min, avg, max) = (7667.320, 7766.553, 7820.583), stdev = 66.926 +[info] CI (99.9%): [7508.843, 8024.263] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 95) +[info] # Run progress: 11.25% complete, ETA 03:57:38 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 9716.770 us/op +[info] # Warmup Iteration 2: 9091.213 us/op +[info] # Warmup Iteration 3: 9123.615 us/op +[info] # Warmup Iteration 4: 9083.732 us/op +[info] # Warmup Iteration 5: 9136.628 us/op +[info] Iteration 1: 8988.651 us/op +[info] Iteration 2: 9096.242 us/op +[info] Iteration 3: 8979.067 us/op +[info] Iteration 4: 9190.976 us/op +[info] Iteration 5: 8973.142 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 9045.615 ±(99.9%) 368.430 us/op [Average] +[info] (min, avg, max) = (8973.142, 9045.615, 9190.976), stdev = 95.680 +[info] CI (99.9%): [8677.185, 9414.046] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex +[info] # Parameters: (size = 100) +[info] # Run progress: 11.88% complete, ETA 03:55:58 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 11266.731 us/op +[info] # Warmup Iteration 2: 10759.143 us/op +[info] # Warmup Iteration 3: 10698.762 us/op +[info] # Warmup Iteration 4: 10664.237 us/op +[info] # Warmup Iteration 5: 10670.718 us/op +[info] Iteration 1: 10489.075 us/op +[info] Iteration 2: 10615.258 us/op +[info] Iteration 3: 10470.663 us/op +[info] Iteration 4: 10618.366 us/op +[info] Iteration 5: 10463.976 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex": +[info] 10531.468 ±(99.9%) 302.107 us/op [Average] +[info] (min, avg, max) = (10463.976, 10531.468, 10618.366), stdev = 78.456 +[info] CI (99.9%): [10229.360, 10833.575] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 5) +[info] # Run progress: 12.50% complete, ETA 03:54:20 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 10.667 us/op +[info] # Warmup Iteration 2: 10.390 us/op +[info] # Warmup Iteration 3: 10.325 us/op +[info] # Warmup Iteration 4: 10.325 us/op +[info] # Warmup Iteration 5: 10.333 us/op +[info] Iteration 1: 10.272 us/op +[info] Iteration 2: 10.234 us/op +[info] Iteration 3: 10.275 us/op +[info] Iteration 4: 10.224 us/op +[info] Iteration 5: 10.279 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 10.257 ±(99.9%) 0.099 us/op [Average] +[info] (min, avg, max) = (10.224, 10.257, 10.279), stdev = 0.026 +[info] CI (99.9%): [10.158, 10.356] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 10) +[info] # Run progress: 13.13% complete, ETA 03:52:39 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 60.737 us/op +[info] # Warmup Iteration 2: 59.223 us/op +[info] # Warmup Iteration 3: 59.497 us/op +[info] # Warmup Iteration 4: 59.506 us/op +[info] # Warmup Iteration 5: 59.421 us/op +[info] Iteration 1: 59.478 us/op +[info] Iteration 2: 59.452 us/op +[info] Iteration 3: 59.436 us/op +[info] Iteration 4: 59.465 us/op +[info] Iteration 5: 59.225 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 59.411 ±(99.9%) 0.405 us/op [Average] +[info] (min, avg, max) = (59.225, 59.411, 59.478), stdev = 0.105 +[info] CI (99.9%): [59.007, 59.816] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 15) +[info] # Run progress: 13.75% complete, ETA 03:50:59 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 171.161 us/op +[info] # Warmup Iteration 2: 165.900 us/op +[info] # Warmup Iteration 3: 166.145 us/op +[info] # Warmup Iteration 4: 165.315 us/op +[info] # Warmup Iteration 5: 165.604 us/op +[info] Iteration 1: 165.331 us/op +[info] Iteration 2: 165.273 us/op +[info] Iteration 3: 165.223 us/op +[info] Iteration 4: 165.710 us/op +[info] Iteration 5: 165.329 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 165.373 ±(99.9%) 0.745 us/op [Average] +[info] (min, avg, max) = (165.223, 165.373, 165.710), stdev = 0.193 +[info] CI (99.9%): [164.629, 166.118] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 20) +[info] # Run progress: 14.37% complete, ETA 03:49:18 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 355.889 us/op +[info] # Warmup Iteration 2: 345.349 us/op +[info] # Warmup Iteration 3: 345.577 us/op +[info] # Warmup Iteration 4: 345.672 us/op +[info] # Warmup Iteration 5: 345.871 us/op +[info] Iteration 1: 345.955 us/op +[info] Iteration 2: 347.683 us/op +[info] Iteration 3: 351.085 us/op +[info] Iteration 4: 346.863 us/op +[info] Iteration 5: 346.165 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 347.550 ±(99.9%) 8.042 us/op [Average] +[info] (min, avg, max) = (345.955, 347.550, 351.085), stdev = 2.088 +[info] CI (99.9%): [339.508, 355.592] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 25) +[info] # Run progress: 15.00% complete, ETA 03:47:37 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 631.425 us/op +[info] # Warmup Iteration 2: 608.935 us/op +[info] # Warmup Iteration 3: 608.618 us/op +[info] # Warmup Iteration 4: 608.791 us/op +[info] # Warmup Iteration 5: 609.563 us/op +[info] Iteration 1: 609.253 us/op +[info] Iteration 2: 608.358 us/op +[info] Iteration 3: 607.146 us/op +[info] Iteration 4: 608.633 us/op +[info] Iteration 5: 607.699 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 608.218 ±(99.9%) 3.153 us/op [Average] +[info] (min, avg, max) = (607.146, 608.218, 609.253), stdev = 0.819 +[info] CI (99.9%): [605.065, 611.370] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 30) +[info] # Run progress: 15.63% complete, ETA 03:45:57 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 1028.862 us/op +[info] # Warmup Iteration 2: 984.301 us/op +[info] # Warmup Iteration 3: 984.540 us/op +[info] # Warmup Iteration 4: 985.349 us/op +[info] # Warmup Iteration 5: 984.133 us/op +[info] Iteration 1: 982.540 us/op +[info] Iteration 2: 982.887 us/op +[info] Iteration 3: 979.242 us/op +[info] Iteration 4: 980.467 us/op +[info] Iteration 5: 982.661 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 981.560 ±(99.9%) 6.240 us/op [Average] +[info] (min, avg, max) = (979.242, 981.560, 982.887), stdev = 1.620 +[info] CI (99.9%): [975.320, 987.799] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 35) +[info] # Run progress: 16.25% complete, ETA 03:44:16 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 1600.484 us/op +[info] # Warmup Iteration 2: 1536.376 us/op +[info] # Warmup Iteration 3: 1535.827 us/op +[info] # Warmup Iteration 4: 1539.493 us/op +[info] # Warmup Iteration 5: 1569.976 us/op +[info] Iteration 1: 1571.627 us/op +[info] Iteration 2: 1567.371 us/op +[info] Iteration 3: 1565.188 us/op +[info] Iteration 4: 1542.337 us/op +[info] Iteration 5: 1535.467 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 1556.398 ±(99.9%) 62.844 us/op [Average] +[info] (min, avg, max) = (1535.467, 1556.398, 1571.627), stdev = 16.320 +[info] CI (99.9%): [1493.554, 1619.242] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 40) +[info] # Run progress: 16.88% complete, ETA 03:42:35 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 2275.232 us/op +[info] # Warmup Iteration 2: 2182.105 us/op +[info] # Warmup Iteration 3: 2163.058 us/op +[info] # Warmup Iteration 4: 2158.304 us/op +[info] # Warmup Iteration 5: 2145.278 us/op +[info] Iteration 1: 2145.590 us/op +[info] Iteration 2: 2148.637 us/op +[info] Iteration 3: 2147.300 us/op +[info] Iteration 4: 2150.169 us/op +[info] Iteration 5: 2149.944 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 2148.328 ±(99.9%) 7.370 us/op [Average] +[info] (min, avg, max) = (2145.590, 2148.328, 2150.169), stdev = 1.914 +[info] CI (99.9%): [2140.958, 2155.698] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 45) +[info] # Run progress: 17.50% complete, ETA 03:40:55 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 3131.547 us/op +[info] # Warmup Iteration 2: 3035.408 us/op +[info] # Warmup Iteration 3: 2982.451 us/op +[info] # Warmup Iteration 4: 2976.431 us/op +[info] # Warmup Iteration 5: 2973.928 us/op +[info] Iteration 1: 2975.436 us/op +[info] Iteration 2: 2977.676 us/op +[info] Iteration 3: 2969.007 us/op +[info] Iteration 4: 2971.172 us/op +[info] Iteration 5: 2971.366 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 2972.931 ±(99.9%) 13.578 us/op [Average] +[info] (min, avg, max) = (2969.007, 2972.931, 2977.676), stdev = 3.526 +[info] CI (99.9%): [2959.354, 2986.509] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 50) +[info] # Run progress: 18.13% complete, ETA 03:39:14 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 4198.168 us/op +[info] # Warmup Iteration 2: 4084.518 us/op +[info] # Warmup Iteration 3: 3987.449 us/op +[info] # Warmup Iteration 4: 3989.937 us/op +[info] # Warmup Iteration 5: 4049.938 us/op +[info] Iteration 1: 4082.779 us/op +[info] Iteration 2: 4057.805 us/op +[info] Iteration 3: 4046.948 us/op +[info] Iteration 4: 4042.255 us/op +[info] Iteration 5: 3971.852 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 4040.328 ±(99.9%) 159.279 us/op [Average] +[info] (min, avg, max) = (3971.852, 4040.328, 4082.779), stdev = 41.364 +[info] CI (99.9%): [3881.048, 4199.607] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 55) +[info] # Run progress: 18.75% complete, ETA 03:37:33 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 5398.971 us/op +[info] # Warmup Iteration 2: 5224.216 us/op +[info] # Warmup Iteration 3: 5098.822 us/op +[info] # Warmup Iteration 4: 5061.053 us/op +[info] # Warmup Iteration 5: 5055.937 us/op +[info] Iteration 1: 5066.927 us/op +[info] Iteration 2: 5065.037 us/op +[info] Iteration 3: 5058.024 us/op +[info] Iteration 4: 5060.597 us/op +[info] Iteration 5: 5050.158 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 5060.148 ±(99.9%) 25.422 us/op [Average] +[info] (min, avg, max) = (5050.158, 5060.148, 5066.927), stdev = 6.602 +[info] CI (99.9%): [5034.726, 5085.571] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 60) +[info] # Run progress: 19.38% complete, ETA 03:35:53 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 7221.293 us/op +[info] # Warmup Iteration 2: 7019.297 us/op +[info] # Warmup Iteration 3: 6997.384 us/op +[info] # Warmup Iteration 4: 6717.553 us/op +[info] # Warmup Iteration 5: 6724.414 us/op +[info] Iteration 1: 6730.023 us/op +[info] Iteration 2: 6740.835 us/op +[info] Iteration 3: 6730.897 us/op +[info] Iteration 4: 6715.019 us/op +[info] Iteration 5: 6706.971 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 6724.749 ±(99.9%) 52.200 us/op [Average] +[info] (min, avg, max) = (6706.971, 6724.749, 6740.835), stdev = 13.556 +[info] CI (99.9%): [6672.549, 6776.949] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 65) +[info] # Run progress: 20.00% complete, ETA 03:34:12 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 8910.599 us/op +[info] # Warmup Iteration 2: 8620.643 us/op +[info] # Warmup Iteration 3: 8626.055 us/op +[info] # Warmup Iteration 4: 8263.495 us/op +[info] # Warmup Iteration 5: 8316.588 us/op +[info] Iteration 1: 8437.705 us/op +[info] Iteration 2: 8403.233 us/op +[info] Iteration 3: 8399.945 us/op +[info] Iteration 4: 8307.588 us/op +[info] Iteration 5: 8268.302 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 8363.355 ±(99.9%) 276.350 us/op [Average] +[info] (min, avg, max) = (8268.302, 8363.355, 8437.705), stdev = 71.767 +[info] CI (99.9%): [8087.005, 8639.704] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 70) +[info] # Run progress: 20.63% complete, ETA 03:32:32 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 11240.312 us/op +[info] # Warmup Iteration 2: 10895.878 us/op +[info] # Warmup Iteration 3: 10893.084 us/op +[info] # Warmup Iteration 4: 10664.743 us/op +[info] # Warmup Iteration 5: 10300.694 us/op +[info] Iteration 1: 10323.206 us/op +[info] Iteration 2: 10329.788 us/op +[info] Iteration 3: 10316.453 us/op +[info] Iteration 4: 10320.956 us/op +[info] Iteration 5: 10318.997 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 10321.880 ±(99.9%) 19.532 us/op [Average] +[info] (min, avg, max) = (10316.453, 10321.880, 10329.788), stdev = 5.072 +[info] CI (99.9%): [10302.348, 10341.412] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 75) +[info] # Run progress: 21.25% complete, ETA 03:30:52 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 13535.347 us/op +[info] # Warmup Iteration 2: 13077.899 us/op +[info] # Warmup Iteration 3: 13068.392 us/op +[info] # Warmup Iteration 4: 12941.220 us/op +[info] # Warmup Iteration 5: 12321.522 us/op +[info] Iteration 1: 12322.787 us/op +[info] Iteration 2: 12326.612 us/op +[info] Iteration 3: 12311.573 us/op +[info] Iteration 4: 12286.670 us/op +[info] Iteration 5: 12269.942 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 12303.517 ±(99.9%) 93.941 us/op [Average] +[info] (min, avg, max) = (12269.942, 12303.517, 12326.612), stdev = 24.396 +[info] CI (99.9%): [12209.576, 12397.457] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 80) +[info] # Run progress: 21.88% complete, ETA 03:29:11 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 16457.726 us/op +[info] # Warmup Iteration 2: 15853.245 us/op +[info] # Warmup Iteration 3: 15883.293 us/op +[info] # Warmup Iteration 4: 15897.341 us/op +[info] # Warmup Iteration 5: 15429.948 us/op +[info] Iteration 1: 15288.583 us/op +[info] Iteration 2: 15298.622 us/op +[info] Iteration 3: 15290.565 us/op +[info] Iteration 4: 14939.219 us/op +[info] Iteration 5: 14895.260 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 15142.450 ±(99.9%) 794.036 us/op [Average] +[info] (min, avg, max) = (14895.260, 15142.450, 15298.622), stdev = 206.209 +[info] CI (99.9%): [14348.414, 15936.486] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 85) +[info] # Run progress: 22.50% complete, ETA 03:27:31 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 19822.674 us/op +[info] # Warmup Iteration 2: 19093.638 us/op +[info] # Warmup Iteration 3: 19103.663 us/op +[info] # Warmup Iteration 4: 19121.169 us/op +[info] # Warmup Iteration 5: 18874.789 us/op +[info] Iteration 1: 17859.632 us/op +[info] Iteration 2: 17802.157 us/op +[info] Iteration 3: 17750.810 us/op +[info] Iteration 4: 17788.071 us/op +[info] Iteration 5: 17793.401 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 17798.814 ±(99.9%) 151.100 us/op [Average] +[info] (min, avg, max) = (17750.810, 17798.814, 17859.632), stdev = 39.240 +[info] CI (99.9%): [17647.715, 17949.914] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 90) +[info] # Run progress: 23.13% complete, ETA 03:25:51 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 23200.695 us/op +[info] # Warmup Iteration 2: 22316.740 us/op +[info] # Warmup Iteration 3: 22302.344 us/op +[info] # Warmup Iteration 4: 22312.888 us/op +[info] # Warmup Iteration 5: 22337.557 us/op +[info] Iteration 1: 21467.180 us/op +[info] Iteration 2: 20761.996 us/op +[info] Iteration 3: 20808.484 us/op +[info] Iteration 4: 20763.084 us/op +[info] Iteration 5: 20703.560 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 20900.861 ±(99.9%) 1227.450 us/op [Average] +[info] (min, avg, max) = (20703.560, 20900.861, 21467.180), stdev = 318.765 +[info] CI (99.9%): [19673.410, 22128.311] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 95) +[info] # Run progress: 23.75% complete, ETA 03:24:10 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 27179.291 us/op +[info] # Warmup Iteration 2: 25993.547 us/op +[info] # Warmup Iteration 3: 26333.724 us/op +[info] # Warmup Iteration 4: 26819.910 us/op +[info] # Warmup Iteration 5: 26617.269 us/op +[info] Iteration 1: 26212.894 us/op +[info] Iteration 2: 24304.420 us/op +[info] Iteration 3: 24323.173 us/op +[info] Iteration 4: 24297.885 us/op +[info] Iteration 5: 24322.680 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 24692.210 ±(99.9%) 3273.667 us/op [Average] +[info] (min, avg, max) = (24297.885, 24692.210, 26212.894), stdev = 850.161 +[info] CI (99.9%): [21418.543, 27965.878] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_regex_mem +[info] # Parameters: (size = 100) +[info] # Run progress: 24.38% complete, ETA 03:22:30 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 31713.365 us/op +[info] # Warmup Iteration 2: 30169.910 us/op +[info] # Warmup Iteration 3: 30153.767 us/op +[info] # Warmup Iteration 4: 30153.784 us/op +[info] # Warmup Iteration 5: 30261.883 us/op +[info] Iteration 1: 30257.357 us/op +[info] Iteration 2: 28608.962 us/op +[info] Iteration 3: 28202.618 us/op +[info] Iteration 4: 28114.364 us/op +[info] Iteration 5: 28118.413 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_regex_mem": +[info] 28660.343 ±(99.9%) 3526.225 us/op [Average] +[info] (min, avg, max) = (28114.364, 28660.343, 30257.357), stdev = 915.749 +[info] CI (99.9%): [25134.118, 32186.568] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 5) +[info] # Run progress: 25.00% complete, ETA 03:20:50 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 1.177 us/op +[info] # Warmup Iteration 2: 1.080 us/op +[info] # Warmup Iteration 3: 1.081 us/op +[info] # Warmup Iteration 4: 1.067 us/op +[info] # Warmup Iteration 5: 1.069 us/op +[info] Iteration 1: 1.079 us/op +[info] Iteration 2: 1.058 us/op +[info] Iteration 3: 1.080 us/op +[info] Iteration 4: 1.057 us/op +[info] Iteration 5: 1.073 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 1.069 ±(99.9%) 0.043 us/op [Average] +[info] (min, avg, max) = (1.057, 1.069, 1.080), stdev = 0.011 +[info] CI (99.9%): [1.026, 1.113] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 10) +[info] # Run progress: 25.62% complete, ETA 03:19:09 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 2.354 us/op +[info] # Warmup Iteration 2: 2.167 us/op +[info] # Warmup Iteration 3: 2.190 us/op +[info] # Warmup Iteration 4: 2.205 us/op +[info] # Warmup Iteration 5: 2.180 us/op +[info] Iteration 1: 2.168 us/op +[info] Iteration 2: 2.122 us/op +[info] Iteration 3: 2.172 us/op +[info] Iteration 4: 2.122 us/op +[info] Iteration 5: 2.156 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 2.148 ±(99.9%) 0.094 us/op [Average] +[info] (min, avg, max) = (2.122, 2.148, 2.172), stdev = 0.024 +[info] CI (99.9%): [2.054, 2.242] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 15) +[info] # Run progress: 26.25% complete, ETA 03:17:29 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 3.697 us/op +[info] # Warmup Iteration 2: 3.432 us/op +[info] # Warmup Iteration 3: 3.450 us/op +[info] # Warmup Iteration 4: 3.440 us/op +[info] # Warmup Iteration 5: 3.391 us/op +[info] Iteration 1: 3.410 us/op +[info] Iteration 2: 3.419 us/op +[info] Iteration 3: 3.387 us/op +[info] Iteration 4: 3.417 us/op +[info] Iteration 5: 3.382 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 3.403 ±(99.9%) 0.067 us/op [Average] +[info] (min, avg, max) = (3.382, 3.403, 3.419), stdev = 0.017 +[info] CI (99.9%): [3.336, 3.469] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 20) +[info] # Run progress: 26.88% complete, ETA 03:15:49 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 4.614 us/op +[info] # Warmup Iteration 2: 4.300 us/op +[info] # Warmup Iteration 3: 4.318 us/op +[info] # Warmup Iteration 4: 4.311 us/op +[info] # Warmup Iteration 5: 4.332 us/op +[info] Iteration 1: 4.258 us/op +[info] Iteration 2: 4.315 us/op +[info] Iteration 3: 4.247 us/op +[info] Iteration 4: 4.285 us/op +[info] Iteration 5: 4.284 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 4.278 ±(99.9%) 0.103 us/op [Average] +[info] (min, avg, max) = (4.247, 4.278, 4.315), stdev = 0.027 +[info] CI (99.9%): [4.175, 4.381] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 25) +[info] # Run progress: 27.50% complete, ETA 03:14:08 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 6.157 us/op +[info] # Warmup Iteration 2: 5.603 us/op +[info] # Warmup Iteration 3: 5.653 us/op +[info] # Warmup Iteration 4: 5.577 us/op +[info] # Warmup Iteration 5: 5.615 us/op +[info] Iteration 1: 5.691 us/op +[info] Iteration 2: 5.625 us/op +[info] Iteration 3: 5.595 us/op +[info] Iteration 4: 5.618 us/op +[info] Iteration 5: 5.586 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 5.623 ±(99.9%) 0.159 us/op [Average] +[info] (min, avg, max) = (5.586, 5.623, 5.691), stdev = 0.041 +[info] CI (99.9%): [5.464, 5.782] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 30) +[info] # Run progress: 28.13% complete, ETA 03:12:28 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 7.079 us/op +[info] # Warmup Iteration 2: 6.680 us/op +[info] # Warmup Iteration 3: 6.720 us/op +[info] # Warmup Iteration 4: 6.688 us/op +[info] # Warmup Iteration 5: 6.713 us/op +[info] Iteration 1: 6.603 us/op +[info] Iteration 2: 6.679 us/op +[info] Iteration 3: 6.561 us/op +[info] Iteration 4: 6.626 us/op +[info] Iteration 5: 6.605 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 6.615 ±(99.9%) 0.165 us/op [Average] +[info] (min, avg, max) = (6.561, 6.615, 6.679), stdev = 0.043 +[info] CI (99.9%): [6.449, 6.780] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 35) +[info] # Run progress: 28.75% complete, ETA 03:10:47 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 8.415 us/op +[info] # Warmup Iteration 2: 7.773 us/op +[info] # Warmup Iteration 3: 7.868 us/op +[info] # Warmup Iteration 4: 7.833 us/op +[info] # Warmup Iteration 5: 7.771 us/op +[info] Iteration 1: 7.896 us/op +[info] Iteration 2: 7.723 us/op +[info] Iteration 3: 7.814 us/op +[info] Iteration 4: 7.862 us/op +[info] Iteration 5: 7.772 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 7.813 ±(99.9%) 0.265 us/op [Average] +[info] (min, avg, max) = (7.723, 7.813, 7.896), stdev = 0.069 +[info] CI (99.9%): [7.548, 8.079] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 40) +[info] # Run progress: 29.38% complete, ETA 03:09:07 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 9.668 us/op +[info] # Warmup Iteration 2: 8.933 us/op +[info] # Warmup Iteration 3: 9.135 us/op +[info] # Warmup Iteration 4: 9.036 us/op +[info] # Warmup Iteration 5: 8.914 us/op +[info] Iteration 1: 9.053 us/op +[info] Iteration 2: 8.858 us/op +[info] Iteration 3: 9.049 us/op +[info] Iteration 4: 8.856 us/op +[info] Iteration 5: 9.014 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 8.966 ±(99.9%) 0.387 us/op [Average] +[info] (min, avg, max) = (8.856, 8.966, 9.053), stdev = 0.101 +[info] CI (99.9%): [8.579, 9.353] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 45) +[info] # Run progress: 30.00% complete, ETA 03:07:26 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 11.092 us/op +[info] # Warmup Iteration 2: 10.293 us/op +[info] # Warmup Iteration 3: 10.244 us/op +[info] # Warmup Iteration 4: 10.113 us/op +[info] # Warmup Iteration 5: 10.161 us/op +[info] Iteration 1: 10.266 us/op +[info] Iteration 2: 10.003 us/op +[info] Iteration 3: 10.125 us/op +[info] Iteration 4: 10.227 us/op +[info] Iteration 5: 10.040 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 10.132 ±(99.9%) 0.440 us/op [Average] +[info] (min, avg, max) = (10.003, 10.132, 10.266), stdev = 0.114 +[info] CI (99.9%): [9.693, 10.572] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 50) +[info] # Run progress: 30.63% complete, ETA 03:05:46 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 12.312 us/op +[info] # Warmup Iteration 2: 11.536 us/op +[info] # Warmup Iteration 3: 11.432 us/op +[info] # Warmup Iteration 4: 11.478 us/op +[info] # Warmup Iteration 5: 11.237 us/op +[info] Iteration 1: 11.280 us/op +[info] Iteration 2: 11.498 us/op +[info] Iteration 3: 11.321 us/op +[info] Iteration 4: 11.272 us/op +[info] Iteration 5: 11.296 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 11.333 ±(99.9%) 0.361 us/op [Average] +[info] (min, avg, max) = (11.272, 11.333, 11.498), stdev = 0.094 +[info] CI (99.9%): [10.972, 11.695] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 55) +[info] # Run progress: 31.25% complete, ETA 03:04:05 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 13.952 us/op +[info] # Warmup Iteration 2: 12.775 us/op +[info] # Warmup Iteration 3: 12.810 us/op +[info] # Warmup Iteration 4: 12.771 us/op +[info] # Warmup Iteration 5: 12.831 us/op +[info] Iteration 1: 13.037 us/op +[info] Iteration 2: 12.852 us/op +[info] Iteration 3: 12.877 us/op +[info] Iteration 4: 12.773 us/op +[info] Iteration 5: 12.563 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 12.820 ±(99.9%) 0.667 us/op [Average] +[info] (min, avg, max) = (12.563, 12.820, 13.037), stdev = 0.173 +[info] CI (99.9%): [12.154, 13.487] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 60) +[info] # Run progress: 31.87% complete, ETA 03:02:25 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 14.849 us/op +[info] # Warmup Iteration 2: 13.703 us/op +[info] # Warmup Iteration 3: 13.618 us/op +[info] # Warmup Iteration 4: 13.566 us/op +[info] # Warmup Iteration 5: 13.646 us/op +[info] Iteration 1: 13.712 us/op +[info] Iteration 2: 13.446 us/op +[info] Iteration 3: 13.686 us/op +[info] Iteration 4: 13.551 us/op +[info] Iteration 5: 13.581 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 13.595 ±(99.9%) 0.414 us/op [Average] +[info] (min, avg, max) = (13.446, 13.595, 13.712), stdev = 0.108 +[info] CI (99.9%): [13.181, 14.009] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 65) +[info] # Run progress: 32.50% complete, ETA 03:00:44 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 13.174 us/op +[info] # Warmup Iteration 2: 12.178 us/op +[info] # Warmup Iteration 3: 12.192 us/op +[info] # Warmup Iteration 4: 12.111 us/op +[info] # Warmup Iteration 5: 11.979 us/op +[info] Iteration 1: 12.157 us/op +[info] Iteration 2: 11.917 us/op +[info] Iteration 3: 12.171 us/op +[info] Iteration 4: 12.016 us/op +[info] Iteration 5: 12.072 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 12.067 ±(99.9%) 0.404 us/op [Average] +[info] (min, avg, max) = (11.917, 12.067, 12.171), stdev = 0.105 +[info] CI (99.9%): [11.663, 12.470] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 70) +[info] # Run progress: 33.13% complete, ETA 02:59:04 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 14.463 us/op +[info] # Warmup Iteration 2: 13.369 us/op +[info] # Warmup Iteration 3: 13.566 us/op +[info] # Warmup Iteration 4: 13.224 us/op +[info] # Warmup Iteration 5: 13.225 us/op +[info] Iteration 1: 13.407 us/op +[info] Iteration 2: 13.104 us/op +[info] Iteration 3: 13.155 us/op +[info] Iteration 4: 13.241 us/op +[info] Iteration 5: 13.074 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 13.196 ±(99.9%) 0.515 us/op [Average] +[info] (min, avg, max) = (13.074, 13.196, 13.407), stdev = 0.134 +[info] CI (99.9%): [12.682, 13.711] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 75) +[info] # Run progress: 33.75% complete, ETA 02:57:24 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 15.466 us/op +[info] # Warmup Iteration 2: 13.992 us/op +[info] # Warmup Iteration 3: 13.976 us/op +[info] # Warmup Iteration 4: 13.883 us/op +[info] # Warmup Iteration 5: 13.753 us/op +[info] Iteration 1: 13.931 us/op +[info] Iteration 2: 13.685 us/op +[info] Iteration 3: 13.878 us/op +[info] Iteration 4: 13.656 us/op +[info] Iteration 5: 13.865 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 13.803 ±(99.9%) 0.478 us/op [Average] +[info] (min, avg, max) = (13.656, 13.803, 13.931), stdev = 0.124 +[info] CI (99.9%): [13.326, 14.281] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 80) +[info] # Run progress: 34.38% complete, ETA 02:55:43 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 16.496 us/op +[info] # Warmup Iteration 2: 15.224 us/op +[info] # Warmup Iteration 3: 14.826 us/op +[info] # Warmup Iteration 4: 15.079 us/op +[info] # Warmup Iteration 5: 15.005 us/op +[info] Iteration 1: 15.087 us/op +[info] Iteration 2: 14.726 us/op +[info] Iteration 3: 15.074 us/op +[info] Iteration 4: 14.733 us/op +[info] Iteration 5: 14.972 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 14.918 ±(99.9%) 0.685 us/op [Average] +[info] (min, avg, max) = (14.726, 14.918, 15.087), stdev = 0.178 +[info] CI (99.9%): [14.233, 15.604] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 85) +[info] # Run progress: 35.00% complete, ETA 02:54:03 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 17.602 us/op +[info] # Warmup Iteration 2: 16.177 us/op +[info] # Warmup Iteration 3: 16.379 us/op +[info] # Warmup Iteration 4: 16.487 us/op +[info] # Warmup Iteration 5: 16.197 us/op +[info] Iteration 1: 16.565 us/op +[info] Iteration 2: 16.265 us/op +[info] Iteration 3: 16.155 us/op +[info] Iteration 4: 16.019 us/op +[info] Iteration 5: 16.078 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 16.216 ±(99.9%) 0.831 us/op [Average] +[info] (min, avg, max) = (16.019, 16.216, 16.565), stdev = 0.216 +[info] CI (99.9%): [15.386, 17.047] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 90) +[info] # Run progress: 35.63% complete, ETA 02:52:22 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 18.352 us/op +[info] # Warmup Iteration 2: 16.545 us/op +[info] # Warmup Iteration 3: 16.478 us/op +[info] # Warmup Iteration 4: 16.475 us/op +[info] # Warmup Iteration 5: 16.532 us/op +[info] Iteration 1: 16.637 us/op +[info] Iteration 2: 16.297 us/op +[info] Iteration 3: 16.584 us/op +[info] Iteration 4: 16.316 us/op +[info] Iteration 5: 16.512 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 16.469 ±(99.9%) 0.596 us/op [Average] +[info] (min, avg, max) = (16.297, 16.469, 16.637), stdev = 0.155 +[info] CI (99.9%): [15.873, 17.066] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 95) +[info] # Run progress: 36.25% complete, ETA 02:50:42 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 19.060 us/op +[info] # Warmup Iteration 2: 17.468 us/op +[info] # Warmup Iteration 3: 17.473 us/op +[info] # Warmup Iteration 4: 17.370 us/op +[info] # Warmup Iteration 5: 17.200 us/op +[info] Iteration 1: 17.455 us/op +[info] Iteration 2: 17.120 us/op +[info] Iteration 3: 17.407 us/op +[info] Iteration 4: 17.197 us/op +[info] Iteration 5: 17.270 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 17.290 ±(99.9%) 0.540 us/op [Average] +[info] (min, avg, max) = (17.120, 17.290, 17.455), stdev = 0.140 +[info] CI (99.9%): [16.750, 17.830] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper +[info] # Parameters: (size = 100) +[info] # Run progress: 36.88% complete, ETA 02:49:02 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 20.744 us/op +[info] # Warmup Iteration 2: 19.390 us/op +[info] # Warmup Iteration 3: 19.504 us/op +[info] # Warmup Iteration 4: 19.182 us/op +[info] # Warmup Iteration 5: 18.900 us/op +[info] Iteration 1: 19.258 us/op +[info] Iteration 2: 18.836 us/op +[info] Iteration 3: 19.159 us/op +[info] Iteration 4: 18.730 us/op +[info] Iteration 5: 18.906 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper": +[info] 18.978 ±(99.9%) 0.857 us/op [Average] +[info] (min, avg, max) = (18.730, 18.978, 19.258), stdev = 0.222 +[info] CI (99.9%): [18.121, 19.835] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 5) +[info] # Run progress: 37.50% complete, ETA 02:47:21 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 2.878 us/op +[info] # Warmup Iteration 2: 2.706 us/op +[info] # Warmup Iteration 3: 2.683 us/op +[info] # Warmup Iteration 4: 2.667 us/op +[info] # Warmup Iteration 5: 2.697 us/op +[info] Iteration 1: 2.683 us/op +[info] Iteration 2: 2.669 us/op +[info] Iteration 3: 2.652 us/op +[info] Iteration 4: 2.690 us/op +[info] Iteration 5: 2.653 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 2.669 ±(99.9%) 0.066 us/op [Average] +[info] (min, avg, max) = (2.652, 2.669, 2.690), stdev = 0.017 +[info] CI (99.9%): [2.604, 2.735] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 10) +[info] # Run progress: 38.13% complete, ETA 02:45:41 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 5.884 us/op +[info] # Warmup Iteration 2: 5.584 us/op +[info] # Warmup Iteration 3: 5.511 us/op +[info] # Warmup Iteration 4: 5.478 us/op +[info] # Warmup Iteration 5: 5.478 us/op +[info] Iteration 1: 5.482 us/op +[info] Iteration 2: 5.473 us/op +[info] Iteration 3: 5.472 us/op +[info] Iteration 4: 5.483 us/op +[info] Iteration 5: 5.446 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 5.471 ±(99.9%) 0.057 us/op [Average] +[info] (min, avg, max) = (5.446, 5.471, 5.483), stdev = 0.015 +[info] CI (99.9%): [5.414, 5.528] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 15) +[info] # Run progress: 38.75% complete, ETA 02:44:00 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 8.894 us/op +[info] # Warmup Iteration 2: 8.323 us/op +[info] # Warmup Iteration 3: 8.265 us/op +[info] # Warmup Iteration 4: 8.270 us/op +[info] # Warmup Iteration 5: 8.208 us/op +[info] Iteration 1: 8.299 us/op +[info] Iteration 2: 8.204 us/op +[info] Iteration 3: 8.289 us/op +[info] Iteration 4: 8.158 us/op +[info] Iteration 5: 8.287 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 8.247 ±(99.9%) 0.241 us/op [Average] +[info] (min, avg, max) = (8.158, 8.247, 8.299), stdev = 0.063 +[info] CI (99.9%): [8.006, 8.489] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 20) +[info] # Run progress: 39.38% complete, ETA 02:42:20 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 11.352 us/op +[info] # Warmup Iteration 2: 10.664 us/op +[info] # Warmup Iteration 3: 10.552 us/op +[info] # Warmup Iteration 4: 10.675 us/op +[info] # Warmup Iteration 5: 10.516 us/op +[info] Iteration 1: 10.548 us/op +[info] Iteration 2: 10.661 us/op +[info] Iteration 3: 10.500 us/op +[info] Iteration 4: 10.560 us/op +[info] Iteration 5: 10.598 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 10.573 ±(99.9%) 0.231 us/op [Average] +[info] (min, avg, max) = (10.500, 10.573, 10.661), stdev = 0.060 +[info] CI (99.9%): [10.342, 10.804] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 25) +[info] # Run progress: 40.00% complete, ETA 02:40:40 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 15.246 us/op +[info] # Warmup Iteration 2: 14.395 us/op +[info] # Warmup Iteration 3: 14.433 us/op +[info] # Warmup Iteration 4: 14.447 us/op +[info] # Warmup Iteration 5: 14.139 us/op +[info] Iteration 1: 14.364 us/op +[info] Iteration 2: 14.186 us/op +[info] Iteration 3: 14.176 us/op +[info] Iteration 4: 14.179 us/op +[info] Iteration 5: 14.186 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 14.218 ±(99.9%) 0.314 us/op [Average] +[info] (min, avg, max) = (14.176, 14.218, 14.364), stdev = 0.081 +[info] CI (99.9%): [13.905, 14.532] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 30) +[info] # Run progress: 40.63% complete, ETA 02:39:00 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 21.454 us/op +[info] # Warmup Iteration 2: 19.809 us/op +[info] # Warmup Iteration 3: 19.750 us/op +[info] # Warmup Iteration 4: 19.933 us/op +[info] # Warmup Iteration 5: 19.958 us/op +[info] Iteration 1: 19.800 us/op +[info] Iteration 2: 19.748 us/op +[info] Iteration 3: 19.613 us/op +[info] Iteration 4: 19.656 us/op +[info] Iteration 5: 19.607 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 19.685 ±(99.9%) 0.329 us/op [Average] +[info] (min, avg, max) = (19.607, 19.685, 19.800), stdev = 0.085 +[info] CI (99.9%): [19.356, 20.013] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 35) +[info] # Run progress: 41.25% complete, ETA 02:37:19 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 24.878 us/op +[info] # Warmup Iteration 2: 23.401 us/op +[info] # Warmup Iteration 3: 23.474 us/op +[info] # Warmup Iteration 4: 23.344 us/op +[info] # Warmup Iteration 5: 23.460 us/op +[info] Iteration 1: 23.031 us/op +[info] Iteration 2: 23.372 us/op +[info] Iteration 3: 22.998 us/op +[info] Iteration 4: 23.008 us/op +[info] Iteration 5: 23.001 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 23.082 ±(99.9%) 0.626 us/op [Average] +[info] (min, avg, max) = (22.998, 23.082, 23.372), stdev = 0.162 +[info] CI (99.9%): [22.456, 23.708] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 40) +[info] # Run progress: 41.88% complete, ETA 02:35:39 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 28.040 us/op +[info] # Warmup Iteration 2: 26.019 us/op +[info] # Warmup Iteration 3: 26.120 us/op +[info] # Warmup Iteration 4: 26.105 us/op +[info] # Warmup Iteration 5: 25.717 us/op +[info] Iteration 1: 25.777 us/op +[info] Iteration 2: 26.050 us/op +[info] Iteration 3: 25.916 us/op +[info] Iteration 4: 25.763 us/op +[info] Iteration 5: 25.784 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 25.858 ±(99.9%) 0.477 us/op [Average] +[info] (min, avg, max) = (25.763, 25.858, 26.050), stdev = 0.124 +[info] CI (99.9%): [25.381, 26.335] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 45) +[info] # Run progress: 42.50% complete, ETA 02:33:59 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 32.550 us/op +[info] # Warmup Iteration 2: 29.880 us/op +[info] # Warmup Iteration 3: 30.563 us/op +[info] # Warmup Iteration 4: 30.099 us/op +[info] # Warmup Iteration 5: 30.448 us/op +[info] Iteration 1: 29.841 us/op +[info] Iteration 2: 30.182 us/op +[info] Iteration 3: 29.689 us/op +[info] Iteration 4: 29.685 us/op +[info] Iteration 5: 29.626 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 29.805 ±(99.9%) 0.868 us/op [Average] +[info] (min, avg, max) = (29.626, 29.805, 30.182), stdev = 0.225 +[info] CI (99.9%): [28.937, 30.673] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 50) +[info] # Run progress: 43.13% complete, ETA 02:32:18 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 35.695 us/op +[info] # Warmup Iteration 2: 32.850 us/op +[info] # Warmup Iteration 3: 32.799 us/op +[info] # Warmup Iteration 4: 32.801 us/op +[info] # Warmup Iteration 5: 32.957 us/op +[info] Iteration 1: 32.468 us/op +[info] Iteration 2: 32.902 us/op +[info] Iteration 3: 32.336 us/op +[info] Iteration 4: 32.448 us/op +[info] Iteration 5: 32.927 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 32.617 ±(99.9%) 1.067 us/op [Average] +[info] (min, avg, max) = (32.336, 32.617, 32.927), stdev = 0.277 +[info] CI (99.9%): [31.550, 33.683] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 55) +[info] # Run progress: 43.75% complete, ETA 02:30:38 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 34.298 us/op +[info] # Warmup Iteration 2: 31.780 us/op +[info] # Warmup Iteration 3: 31.549 us/op +[info] # Warmup Iteration 4: 30.991 us/op +[info] # Warmup Iteration 5: 30.951 us/op +[info] Iteration 1: 31.248 us/op +[info] Iteration 2: 30.974 us/op +[info] Iteration 3: 31.066 us/op +[info] Iteration 4: 30.882 us/op +[info] Iteration 5: 30.956 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 31.025 ±(99.9%) 0.543 us/op [Average] +[info] (min, avg, max) = (30.882, 31.025, 31.248), stdev = 0.141 +[info] CI (99.9%): [30.483, 31.568] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 60) +[info] # Run progress: 44.38% complete, ETA 02:28:57 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 41.959 us/op +[info] # Warmup Iteration 2: 39.268 us/op +[info] # Warmup Iteration 3: 39.853 us/op +[info] # Warmup Iteration 4: 39.953 us/op +[info] # Warmup Iteration 5: 40.042 us/op +[info] Iteration 1: 40.050 us/op +[info] Iteration 2: 39.375 us/op +[info] Iteration 3: 39.283 us/op +[info] Iteration 4: 39.226 us/op +[info] Iteration 5: 39.053 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 39.397 ±(99.9%) 1.475 us/op [Average] +[info] (min, avg, max) = (39.053, 39.397, 40.050), stdev = 0.383 +[info] CI (99.9%): [37.922, 40.872] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 65) +[info] # Run progress: 45.00% complete, ETA 02:27:17 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 53.996 us/op +[info] # Warmup Iteration 2: 50.120 us/op +[info] # Warmup Iteration 3: 49.075 us/op +[info] # Warmup Iteration 4: 50.240 us/op +[info] # Warmup Iteration 5: 50.197 us/op +[info] Iteration 1: 49.329 us/op +[info] Iteration 2: 49.727 us/op +[info] Iteration 3: 49.673 us/op +[info] Iteration 4: 49.128 us/op +[info] Iteration 5: 49.100 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 49.392 ±(99.9%) 1.140 us/op [Average] +[info] (min, avg, max) = (49.100, 49.392, 49.727), stdev = 0.296 +[info] CI (99.9%): [48.252, 50.531] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 70) +[info] # Run progress: 45.63% complete, ETA 02:25:37 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 48.546 us/op +[info] # Warmup Iteration 2: 45.227 us/op +[info] # Warmup Iteration 3: 45.983 us/op +[info] # Warmup Iteration 4: 45.867 us/op +[info] # Warmup Iteration 5: 46.073 us/op +[info] Iteration 1: 45.364 us/op +[info] Iteration 2: 45.853 us/op +[info] Iteration 3: 45.605 us/op +[info] Iteration 4: 45.315 us/op +[info] Iteration 5: 45.278 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 45.483 ±(99.9%) 0.936 us/op [Average] +[info] (min, avg, max) = (45.278, 45.483, 45.853), stdev = 0.243 +[info] CI (99.9%): [44.547, 46.419] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 75) +[info] # Run progress: 46.25% complete, ETA 02:23:56 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 52.914 us/op +[info] # Warmup Iteration 2: 49.310 us/op +[info] # Warmup Iteration 3: 49.351 us/op +[info] # Warmup Iteration 4: 48.173 us/op +[info] # Warmup Iteration 5: 49.260 us/op +[info] Iteration 1: 48.993 us/op +[info] Iteration 2: 48.951 us/op +[info] Iteration 3: 48.223 us/op +[info] Iteration 4: 48.470 us/op +[info] Iteration 5: 48.474 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 48.622 ±(99.9%) 1.293 us/op [Average] +[info] (min, avg, max) = (48.223, 48.622, 48.993), stdev = 0.336 +[info] CI (99.9%): [47.329, 49.915] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 80) +[info] # Run progress: 46.88% complete, ETA 02:22:16 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 57.075 us/op +[info] # Warmup Iteration 2: 53.808 us/op +[info] # Warmup Iteration 3: 54.410 us/op +[info] # Warmup Iteration 4: 53.797 us/op +[info] # Warmup Iteration 5: 53.579 us/op +[info] Iteration 1: 53.846 us/op +[info] Iteration 2: 52.992 us/op +[info] Iteration 3: 52.960 us/op +[info] Iteration 4: 53.104 us/op +[info] Iteration 5: 53.337 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 53.248 ±(99.9%) 1.408 us/op [Average] +[info] (min, avg, max) = (52.960, 53.248, 53.846), stdev = 0.366 +[info] CI (99.9%): [51.840, 54.656] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 85) +[info] # Run progress: 47.50% complete, ETA 02:20:35 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 58.827 us/op +[info] # Warmup Iteration 2: 55.377 us/op +[info] # Warmup Iteration 3: 55.081 us/op +[info] # Warmup Iteration 4: 54.751 us/op +[info] # Warmup Iteration 5: 54.767 us/op +[info] Iteration 1: 54.174 us/op +[info] Iteration 2: 54.871 us/op +[info] Iteration 3: 54.804 us/op +[info] Iteration 4: 54.473 us/op +[info] Iteration 5: 54.348 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 54.534 ±(99.9%) 1.146 us/op [Average] +[info] (min, avg, max) = (54.174, 54.534, 54.871), stdev = 0.297 +[info] CI (99.9%): [53.389, 55.680] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 90) +[info] # Run progress: 48.13% complete, ETA 02:18:55 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 62.305 us/op +[info] # Warmup Iteration 2: 59.547 us/op +[info] # Warmup Iteration 3: 61.038 us/op +[info] # Warmup Iteration 4: 59.663 us/op +[info] # Warmup Iteration 5: 59.248 us/op +[info] Iteration 1: 59.780 us/op +[info] Iteration 2: 58.483 us/op +[info] Iteration 3: 58.518 us/op +[info] Iteration 4: 57.981 us/op +[info] Iteration 5: 57.887 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 58.530 ±(99.9%) 2.906 us/op [Average] +[info] (min, avg, max) = (57.887, 58.530, 59.780), stdev = 0.755 +[info] CI (99.9%): [55.624, 61.436] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 95) +[info] # Run progress: 48.75% complete, ETA 02:17:14 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 67.026 us/op +[info] # Warmup Iteration 2: 63.482 us/op +[info] # Warmup Iteration 3: 63.308 us/op +[info] # Warmup Iteration 4: 62.855 us/op +[info] # Warmup Iteration 5: 62.700 us/op +[info] Iteration 1: 62.199 us/op +[info] Iteration 2: 62.993 us/op +[info] Iteration 3: 62.975 us/op +[info] Iteration 4: 62.537 us/op +[info] Iteration 5: 62.672 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 62.675 ±(99.9%) 1.273 us/op [Average] +[info] (min, avg, max) = (62.199, 62.675, 62.993), stdev = 0.331 +[info] CI (99.9%): [61.402, 63.948] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.abStar_accepting_zipper_mem +[info] # Parameters: (size = 100) +[info] # Run progress: 49.38% complete, ETA 02:15:34 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 72.762 us/op +[info] # Warmup Iteration 2: 66.547 us/op +[info] # Warmup Iteration 3: 66.994 us/op +[info] # Warmup Iteration 4: 65.436 us/op +[info] # Warmup Iteration 5: 65.281 us/op +[info] Iteration 1: 66.284 us/op +[info] Iteration 2: 65.649 us/op +[info] Iteration 3: 65.768 us/op +[info] Iteration 4: 65.369 us/op +[info] Iteration 5: 65.231 us/op +[info] Result "benchmark.RegexBenchmark.abStar_accepting_zipper_mem": +[info] 65.660 ±(99.9%) 1.576 us/op [Average] +[info] (min, avg, max) = (65.231, 65.660, 66.284), stdev = 0.409 +[info] CI (99.9%): [64.084, 67.236] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 5) +[info] # Run progress: 50.00% complete, ETA 02:13:54 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 15.767 us/op +[info] # Warmup Iteration 2: 14.933 us/op +[info] # Warmup Iteration 3: 15.011 us/op +[info] # Warmup Iteration 4: 14.966 us/op +[info] # Warmup Iteration 5: 14.679 us/op +[info] Iteration 1: 14.725 us/op +[info] Iteration 2: 14.514 us/op +[info] Iteration 3: 14.427 us/op +[info] Iteration 4: 14.347 us/op +[info] Iteration 5: 14.381 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 14.479 ±(99.9%) 0.582 us/op [Average] +[info] (min, avg, max) = (14.347, 14.479, 14.725), stdev = 0.151 +[info] CI (99.9%): [13.897, 15.060] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 10) +[info] # Run progress: 50.63% complete, ETA 02:12:13 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 68.551 us/op +[info] # Warmup Iteration 2: 63.418 us/op +[info] # Warmup Iteration 3: 63.599 us/op +[info] # Warmup Iteration 4: 63.747 us/op +[info] # Warmup Iteration 5: 62.467 us/op +[info] Iteration 1: 63.823 us/op +[info] Iteration 2: 63.188 us/op +[info] Iteration 3: 63.135 us/op +[info] Iteration 4: 62.702 us/op +[info] Iteration 5: 62.690 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 63.107 ±(99.9%) 1.784 us/op [Average] +[info] (min, avg, max) = (62.690, 63.107, 63.823), stdev = 0.463 +[info] CI (99.9%): [61.324, 64.891] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 15) +[info] # Run progress: 51.25% complete, ETA 02:10:33 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 150.426 us/op +[info] # Warmup Iteration 2: 142.334 us/op +[info] # Warmup Iteration 3: 142.205 us/op +[info] # Warmup Iteration 4: 142.129 us/op +[info] # Warmup Iteration 5: 139.512 us/op +[info] Iteration 1: 142.121 us/op +[info] Iteration 2: 139.666 us/op +[info] Iteration 3: 141.540 us/op +[info] Iteration 4: 139.590 us/op +[info] Iteration 5: 139.478 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 140.479 ±(99.9%) 4.823 us/op [Average] +[info] (min, avg, max) = (139.478, 140.479, 142.121), stdev = 1.252 +[info] CI (99.9%): [135.656, 145.302] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 20) +[info] # Run progress: 51.88% complete, ETA 02:08:52 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 297.653 us/op +[info] # Warmup Iteration 2: 273.726 us/op +[info] # Warmup Iteration 3: 281.561 us/op +[info] # Warmup Iteration 4: 276.422 us/op +[info] # Warmup Iteration 5: 280.318 us/op +[info] Iteration 1: 270.196 us/op +[info] Iteration 2: 272.672 us/op +[info] Iteration 3: 272.198 us/op +[info] Iteration 4: 270.368 us/op +[info] Iteration 5: 270.852 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 271.257 ±(99.9%) 4.290 us/op [Average] +[info] (min, avg, max) = (270.196, 271.257, 272.672), stdev = 1.114 +[info] CI (99.9%): [266.967, 275.548] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 25) +[info] # Run progress: 52.50% complete, ETA 02:07:12 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 450.852 us/op +[info] # Warmup Iteration 2: 424.203 us/op +[info] # Warmup Iteration 3: 423.430 us/op +[info] # Warmup Iteration 4: 424.419 us/op +[info] # Warmup Iteration 5: 415.305 us/op +[info] Iteration 1: 423.145 us/op +[info] Iteration 2: 419.750 us/op +[info] Iteration 3: 417.931 us/op +[info] Iteration 4: 414.884 us/op +[info] Iteration 5: 415.396 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 418.221 ±(99.9%) 13.027 us/op [Average] +[info] (min, avg, max) = (414.884, 418.221, 423.145), stdev = 3.383 +[info] CI (99.9%): [405.195, 431.248] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 30) +[info] # Run progress: 53.13% complete, ETA 02:05:32 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 806.193 us/op +[info] # Warmup Iteration 2: 759.024 us/op +[info] # Warmup Iteration 3: 764.188 us/op +[info] # Warmup Iteration 4: 757.943 us/op +[info] # Warmup Iteration 5: 747.072 us/op +[info] Iteration 1: 759.313 us/op +[info] Iteration 2: 754.395 us/op +[info] Iteration 3: 750.781 us/op +[info] Iteration 4: 745.668 us/op +[info] Iteration 5: 744.802 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 750.992 ±(99.9%) 23.385 us/op [Average] +[info] (min, avg, max) = (744.802, 750.992, 759.313), stdev = 6.073 +[info] CI (99.9%): [727.607, 774.377] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 35) +[info] # Run progress: 53.75% complete, ETA 02:03:51 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 1100.522 us/op +[info] # Warmup Iteration 2: 1037.535 us/op +[info] # Warmup Iteration 3: 1050.014 us/op +[info] # Warmup Iteration 4: 1041.095 us/op +[info] # Warmup Iteration 5: 1024.572 us/op +[info] Iteration 1: 1038.150 us/op +[info] Iteration 2: 1026.275 us/op +[info] Iteration 3: 1032.371 us/op +[info] Iteration 4: 1016.903 us/op +[info] Iteration 5: 1013.334 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 1025.407 ±(99.9%) 39.910 us/op [Average] +[info] (min, avg, max) = (1013.334, 1025.407, 1038.150), stdev = 10.365 +[info] CI (99.9%): [985.496, 1065.317] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 40) +[info] # Run progress: 54.37% complete, ETA 02:02:11 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 1812.686 us/op +[info] # Warmup Iteration 2: 1701.102 us/op +[info] # Warmup Iteration 3: 1703.948 us/op +[info] # Warmup Iteration 4: 1706.109 us/op +[info] # Warmup Iteration 5: 1674.899 us/op +[info] Iteration 1: 1692.061 us/op +[info] Iteration 2: 1689.882 us/op +[info] Iteration 3: 1707.192 us/op +[info] Iteration 4: 1683.237 us/op +[info] Iteration 5: 1682.154 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 1690.905 ±(99.9%) 38.652 us/op [Average] +[info] (min, avg, max) = (1682.154, 1690.905, 1707.192), stdev = 10.038 +[info] CI (99.9%): [1652.253, 1729.557] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 45) +[info] # Run progress: 55.00% complete, ETA 02:00:30 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 2281.149 us/op +[info] # Warmup Iteration 2: 2131.715 us/op +[info] # Warmup Iteration 3: 2142.010 us/op +[info] # Warmup Iteration 4: 2135.391 us/op +[info] # Warmup Iteration 5: 2122.801 us/op +[info] Iteration 1: 2144.013 us/op +[info] Iteration 2: 2105.133 us/op +[info] Iteration 3: 2100.777 us/op +[info] Iteration 4: 2127.302 us/op +[info] Iteration 5: 2118.891 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 2119.223 ±(99.9%) 67.212 us/op [Average] +[info] (min, avg, max) = (2100.777, 2119.223, 2144.013), stdev = 17.455 +[info] CI (99.9%): [2052.011, 2186.435] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 50) +[info] # Run progress: 55.63% complete, ETA 01:58:50 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 3246.413 us/op +[info] # Warmup Iteration 2: 3080.286 us/op +[info] # Warmup Iteration 3: 3084.870 us/op +[info] # Warmup Iteration 4: 3090.836 us/op +[info] # Warmup Iteration 5: 3039.394 us/op +[info] Iteration 1: 3051.697 us/op +[info] Iteration 2: 3014.486 us/op +[info] Iteration 3: 2984.224 us/op +[info] Iteration 4: 3034.426 us/op +[info] Iteration 5: 2982.877 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 3013.542 ±(99.9%) 116.997 us/op [Average] +[info] (min, avg, max) = (2982.877, 3013.542, 3051.697), stdev = 30.384 +[info] CI (99.9%): [2896.545, 3130.539] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 55) +[info] # Run progress: 56.25% complete, ETA 01:57:09 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 3803.446 us/op +[info] # Warmup Iteration 2: 3527.405 us/op +[info] # Warmup Iteration 3: 3569.036 us/op +[info] # Warmup Iteration 4: 3571.279 us/op +[info] # Warmup Iteration 5: 3504.520 us/op +[info] Iteration 1: 3567.597 us/op +[info] Iteration 2: 3537.244 us/op +[info] Iteration 3: 3534.956 us/op +[info] Iteration 4: 3509.922 us/op +[info] Iteration 5: 3523.045 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 3534.553 ±(99.9%) 82.552 us/op [Average] +[info] (min, avg, max) = (3509.922, 3534.553, 3567.597), stdev = 21.438 +[info] CI (99.9%): [3452.001, 3617.105] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 60) +[info] # Run progress: 56.88% complete, ETA 01:55:29 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 4519.099 us/op +[info] # Warmup Iteration 2: 4234.664 us/op +[info] # Warmup Iteration 3: 4246.635 us/op +[info] # Warmup Iteration 4: 4235.680 us/op +[info] # Warmup Iteration 5: 4239.196 us/op +[info] Iteration 1: 4162.927 us/op +[info] Iteration 2: 4171.752 us/op +[info] Iteration 3: 4219.836 us/op +[info] Iteration 4: 4164.173 us/op +[info] Iteration 5: 4165.526 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 4176.843 ±(99.9%) 93.465 us/op [Average] +[info] (min, avg, max) = (4162.927, 4176.843, 4219.836), stdev = 24.272 +[info] CI (99.9%): [4083.378, 4270.307] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 65) +[info] # Run progress: 57.50% complete, ETA 01:53:49 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 6031.758 us/op +[info] # Warmup Iteration 2: 5687.405 us/op +[info] # Warmup Iteration 3: 5604.169 us/op +[info] # Warmup Iteration 4: 5675.077 us/op +[info] # Warmup Iteration 5: 5579.744 us/op +[info] Iteration 1: 5694.549 us/op +[info] Iteration 2: 5543.194 us/op +[info] Iteration 3: 5541.836 us/op +[info] Iteration 4: 5632.084 us/op +[info] Iteration 5: 5526.451 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 5587.623 ±(99.9%) 280.479 us/op [Average] +[info] (min, avg, max) = (5526.451, 5587.623, 5694.549), stdev = 72.839 +[info] CI (99.9%): [5307.144, 5868.102] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 70) +[info] # Run progress: 58.13% complete, ETA 01:52:08 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 7339.159 us/op +[info] # Warmup Iteration 2: 6942.061 us/op +[info] # Warmup Iteration 3: 6947.970 us/op +[info] # Warmup Iteration 4: 6932.373 us/op +[info] # Warmup Iteration 5: 6818.457 us/op +[info] Iteration 1: 6856.230 us/op +[info] Iteration 2: 6936.095 us/op +[info] Iteration 3: 6830.617 us/op +[info] Iteration 4: 6819.419 us/op +[info] Iteration 5: 6872.533 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 6862.979 ±(99.9%) 176.748 us/op [Average] +[info] (min, avg, max) = (6819.419, 6862.979, 6936.095), stdev = 45.901 +[info] CI (99.9%): [6686.231, 7039.727] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 75) +[info] # Run progress: 58.75% complete, ETA 01:50:28 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 9219.093 us/op +[info] # Warmup Iteration 2: 8750.682 us/op +[info] # Warmup Iteration 3: 8734.988 us/op +[info] # Warmup Iteration 4: 8718.179 us/op +[info] # Warmup Iteration 5: 8671.876 us/op +[info] Iteration 1: 8645.887 us/op +[info] Iteration 2: 8700.887 us/op +[info] Iteration 3: 8674.581 us/op +[info] Iteration 4: 8619.847 us/op +[info] Iteration 5: 8613.064 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 8650.853 ±(99.9%) 142.532 us/op [Average] +[info] (min, avg, max) = (8613.064, 8650.853, 8700.887), stdev = 37.015 +[info] CI (99.9%): [8508.321, 8793.385] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 80) +[info] # Run progress: 59.38% complete, ETA 01:48:47 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 10050.804 us/op +[info] # Warmup Iteration 2: 9447.013 us/op +[info] # Warmup Iteration 3: 9389.744 us/op +[info] # Warmup Iteration 4: 9337.514 us/op +[info] # Warmup Iteration 5: 9200.877 us/op +[info] Iteration 1: 9257.820 us/op +[info] Iteration 2: 9092.141 us/op +[info] Iteration 3: 9091.937 us/op +[info] Iteration 4: 9155.140 us/op +[info] Iteration 5: 9143.925 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 9148.193 ±(99.9%) 261.101 us/op [Average] +[info] (min, avg, max) = (9091.937, 9148.193, 9257.820), stdev = 67.807 +[info] CI (99.9%): [8887.092, 9409.294] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 85) +[info] # Run progress: 60.00% complete, ETA 01:47:07 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 12178.962 us/op +[info] # Warmup Iteration 2: 11444.864 us/op +[info] # Warmup Iteration 3: 11416.167 us/op +[info] # Warmup Iteration 4: 11379.580 us/op +[info] # Warmup Iteration 5: 11295.787 us/op +[info] Iteration 1: 11351.947 us/op +[info] Iteration 2: 11448.398 us/op +[info] Iteration 3: 11451.889 us/op +[info] Iteration 4: 11366.263 us/op +[info] Iteration 5: 11366.907 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 11397.081 ±(99.9%) 187.999 us/op [Average] +[info] (min, avg, max) = (11351.947, 11397.081, 11451.889), stdev = 48.823 +[info] CI (99.9%): [11209.082, 11585.080] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 90) +[info] # Run progress: 60.62% complete, ETA 01:45:27 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 14613.387 us/op +[info] # Warmup Iteration 2: 13852.344 us/op +[info] # Warmup Iteration 3: 13834.350 us/op +[info] # Warmup Iteration 4: 13584.187 us/op +[info] # Warmup Iteration 5: 13619.888 us/op +[info] Iteration 1: 13593.530 us/op +[info] Iteration 2: 13528.767 us/op +[info] Iteration 3: 13643.525 us/op +[info] Iteration 4: 13444.408 us/op +[info] Iteration 5: 13696.685 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 13581.383 ±(99.9%) 379.412 us/op [Average] +[info] (min, avg, max) = (13444.408, 13581.383, 13696.685), stdev = 98.532 +[info] CI (99.9%): [13201.971, 13960.795] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 95) +[info] # Run progress: 61.25% complete, ETA 01:43:46 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 17306.191 us/op +[info] # Warmup Iteration 2: 16182.188 us/op +[info] # Warmup Iteration 3: 16508.593 us/op +[info] # Warmup Iteration 4: 16295.805 us/op +[info] # Warmup Iteration 5: 16034.989 us/op +[info] Iteration 1: 15768.108 us/op +[info] Iteration 2: 15839.584 us/op +[info] Iteration 3: 16049.614 us/op +[info] Iteration 4: 15810.976 us/op +[info] Iteration 5: 15789.707 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 15851.598 ±(99.9%) 438.220 us/op [Average] +[info] (min, avg, max) = (15768.108, 15851.598, 16049.614), stdev = 113.804 +[info] CI (99.9%): [15413.378, 16289.818] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex +[info] # Parameters: (size = 100) +[info] # Run progress: 61.88% complete, ETA 01:42:06 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 18923.516 us/op +[info] # Warmup Iteration 2: 17539.810 us/op +[info] # Warmup Iteration 3: 17622.653 us/op +[info] # Warmup Iteration 4: 17340.056 us/op +[info] # Warmup Iteration 5: 17645.175 us/op +[info] Iteration 1: 17410.213 us/op +[info] Iteration 2: 17594.211 us/op +[info] Iteration 3: 17479.591 us/op +[info] Iteration 4: 17317.897 us/op +[info] Iteration 5: 17320.808 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex": +[info] 17424.544 ±(99.9%) 448.055 us/op [Average] +[info] (min, avg, max) = (17317.897, 17424.544, 17594.211), stdev = 116.359 +[info] CI (99.9%): [16976.489, 17872.599] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 5) +[info] # Run progress: 62.50% complete, ETA 01:40:26 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 100.477 us/op +[info] # Warmup Iteration 2: 97.554 us/op +[info] # Warmup Iteration 3: 97.723 us/op +[info] # Warmup Iteration 4: 97.688 us/op +[info] # Warmup Iteration 5: 97.657 us/op +[info] Iteration 1: 97.751 us/op +[info] Iteration 2: 97.974 us/op +[info] Iteration 3: 97.872 us/op +[info] Iteration 4: 98.078 us/op +[info] Iteration 5: 97.954 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 97.926 ±(99.9%) 0.471 us/op [Average] +[info] (min, avg, max) = (97.751, 97.926, 98.078), stdev = 0.122 +[info] CI (99.9%): [97.455, 98.397] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 10) +[info] # Run progress: 63.13% complete, ETA 01:38:45 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 351.585 us/op +[info] # Warmup Iteration 2: 343.477 us/op +[info] # Warmup Iteration 3: 342.347 us/op +[info] # Warmup Iteration 4: 337.541 us/op +[info] # Warmup Iteration 5: 335.959 us/op +[info] Iteration 1: 336.903 us/op +[info] Iteration 2: 337.657 us/op +[info] Iteration 3: 335.683 us/op +[info] Iteration 4: 335.716 us/op +[info] Iteration 5: 336.305 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 336.453 ±(99.9%) 3.227 us/op [Average] +[info] (min, avg, max) = (335.683, 336.453, 337.657), stdev = 0.838 +[info] CI (99.9%): [333.225, 339.680] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 15) +[info] # Run progress: 63.75% complete, ETA 01:37:05 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 704.729 us/op +[info] # Warmup Iteration 2: 676.631 us/op +[info] # Warmup Iteration 3: 672.354 us/op +[info] # Warmup Iteration 4: 675.244 us/op +[info] # Warmup Iteration 5: 674.854 us/op +[info] Iteration 1: 674.795 us/op +[info] Iteration 2: 674.396 us/op +[info] Iteration 3: 673.297 us/op +[info] Iteration 4: 672.836 us/op +[info] Iteration 5: 672.388 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 673.542 ±(99.9%) 3.941 us/op [Average] +[info] (min, avg, max) = (672.388, 673.542, 674.795), stdev = 1.023 +[info] CI (99.9%): [669.601, 677.483] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 20) +[info] # Run progress: 64.38% complete, ETA 01:35:24 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 1199.939 us/op +[info] # Warmup Iteration 2: 1153.249 us/op +[info] # Warmup Iteration 3: 1142.679 us/op +[info] # Warmup Iteration 4: 1150.173 us/op +[info] # Warmup Iteration 5: 1154.849 us/op +[info] Iteration 1: 1152.845 us/op +[info] Iteration 2: 1155.650 us/op +[info] Iteration 3: 1158.450 us/op +[info] Iteration 4: 1156.631 us/op +[info] Iteration 5: 1158.342 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 1156.384 ±(99.9%) 8.869 us/op [Average] +[info] (min, avg, max) = (1152.845, 1156.384, 1158.450), stdev = 2.303 +[info] CI (99.9%): [1147.514, 1165.253] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 25) +[info] # Run progress: 65.00% complete, ETA 01:33:44 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 1940.983 us/op +[info] # Warmup Iteration 2: 1864.592 us/op +[info] # Warmup Iteration 3: 1852.188 us/op +[info] # Warmup Iteration 4: 1863.763 us/op +[info] # Warmup Iteration 5: 1875.955 us/op +[info] Iteration 1: 1841.304 us/op +[info] Iteration 2: 1836.644 us/op +[info] Iteration 3: 1838.558 us/op +[info] Iteration 4: 1837.548 us/op +[info] Iteration 5: 1831.557 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 1837.122 ±(99.9%) 13.741 us/op [Average] +[info] (min, avg, max) = (1831.557, 1837.122, 1841.304), stdev = 3.568 +[info] CI (99.9%): [1823.381, 1850.863] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 30) +[info] # Run progress: 65.63% complete, ETA 01:32:03 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 3133.521 us/op +[info] # Warmup Iteration 2: 2990.577 us/op +[info] # Warmup Iteration 3: 2974.111 us/op +[info] # Warmup Iteration 4: 2959.848 us/op +[info] # Warmup Iteration 5: 2962.865 us/op +[info] Iteration 1: 2966.282 us/op +[info] Iteration 2: 2976.415 us/op +[info] Iteration 3: 2964.309 us/op +[info] Iteration 4: 2969.627 us/op +[info] Iteration 5: 2962.069 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 2967.740 ±(99.9%) 21.515 us/op [Average] +[info] (min, avg, max) = (2962.069, 2967.740, 2976.415), stdev = 5.588 +[info] CI (99.9%): [2946.225, 2989.256] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 35) +[info] # Run progress: 66.25% complete, ETA 01:30:23 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 3966.414 us/op +[info] # Warmup Iteration 2: 3747.557 us/op +[info] # Warmup Iteration 3: 3719.132 us/op +[info] # Warmup Iteration 4: 3688.067 us/op +[info] # Warmup Iteration 5: 3691.605 us/op +[info] Iteration 1: 3693.461 us/op +[info] Iteration 2: 3692.166 us/op +[info] Iteration 3: 3713.677 us/op +[info] Iteration 4: 3701.310 us/op +[info] Iteration 5: 3705.610 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 3701.245 ±(99.9%) 34.258 us/op [Average] +[info] (min, avg, max) = (3692.166, 3701.245, 3713.677), stdev = 8.897 +[info] CI (99.9%): [3666.987, 3735.503] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 40) +[info] # Run progress: 66.88% complete, ETA 01:28:42 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 8549.842 us/op +[info] # Warmup Iteration 2: 7998.262 us/op +[info] # Warmup Iteration 3: 8022.403 us/op +[info] # Warmup Iteration 4: 7949.163 us/op +[info] # Warmup Iteration 5: 7874.702 us/op +[info] Iteration 1: 7786.443 us/op +[info] Iteration 2: 7815.501 us/op +[info] Iteration 3: 7795.589 us/op +[info] Iteration 4: 7799.746 us/op +[info] Iteration 5: 7824.877 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 7804.431 ±(99.9%) 59.788 us/op [Average] +[info] (min, avg, max) = (7786.443, 7804.431, 7824.877), stdev = 15.527 +[info] CI (99.9%): [7744.644, 7864.219] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 45) +[info] # Run progress: 67.50% complete, ETA 01:27:02 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 7470.799 us/op +[info] # Warmup Iteration 2: 6687.043 us/op +[info] # Warmup Iteration 3: 6705.346 us/op +[info] # Warmup Iteration 4: 6653.787 us/op +[info] # Warmup Iteration 5: 6644.840 us/op +[info] Iteration 1: 6635.838 us/op +[info] Iteration 2: 6643.638 us/op +[info] Iteration 3: 6639.177 us/op +[info] Iteration 4: 6629.124 us/op +[info] Iteration 5: 6651.111 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 6639.778 ±(99.9%) 31.797 us/op [Average] +[info] (min, avg, max) = (6629.124, 6639.778, 6651.111), stdev = 8.257 +[info] CI (99.9%): [6607.981, 6671.574] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 50) +[info] # Run progress: 68.13% complete, ETA 01:25:22 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 13364.694 us/op +[info] # Warmup Iteration 2: 11707.379 us/op +[info] # Warmup Iteration 3: 11721.477 us/op +[info] # Warmup Iteration 4: 11704.387 us/op +[info] # Warmup Iteration 5: 11721.742 us/op +[info] Iteration 1: 11604.850 us/op +[info] Iteration 2: 11641.419 us/op +[info] Iteration 3: 11615.536 us/op +[info] Iteration 4: 11589.444 us/op +[info] Iteration 5: 11574.476 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 11605.145 ±(99.9%) 98.380 us/op [Average] +[info] (min, avg, max) = (11574.476, 11605.145, 11641.419), stdev = 25.549 +[info] CI (99.9%): [11506.765, 11703.525] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 55) +[info] # Run progress: 68.75% complete, ETA 01:23:41 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 14540.779 us/op +[info] # Warmup Iteration 2: 12323.876 us/op +[info] # Warmup Iteration 3: 12443.109 us/op +[info] # Warmup Iteration 4: 12331.735 us/op +[info] # Warmup Iteration 5: 12265.287 us/op +[info] Iteration 1: 12216.385 us/op +[info] Iteration 2: 12210.939 us/op +[info] Iteration 3: 12195.536 us/op +[info] Iteration 4: 12218.500 us/op +[info] Iteration 5: 12232.808 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 12214.834 ±(99.9%) 51.894 us/op [Average] +[info] (min, avg, max) = (12195.536, 12214.834, 12232.808), stdev = 13.477 +[info] CI (99.9%): [12162.940, 12266.728] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 60) +[info] # Run progress: 69.38% complete, ETA 01:22:01 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 15138.494 us/op +[info] # Warmup Iteration 2: 12166.785 us/op +[info] # Warmup Iteration 3: 12158.514 us/op +[info] # Warmup Iteration 4: 12168.363 us/op +[info] # Warmup Iteration 5: 12066.135 us/op +[info] Iteration 1: 12024.675 us/op +[info] Iteration 2: 12016.989 us/op +[info] Iteration 3: 12011.403 us/op +[info] Iteration 4: 12016.091 us/op +[info] Iteration 5: 12012.448 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 12016.321 ±(99.9%) 20.146 us/op [Average] +[info] (min, avg, max) = (12011.403, 12016.321, 12024.675), stdev = 5.232 +[info] CI (99.9%): [11996.175, 12036.467] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 65) +[info] # Run progress: 70.00% complete, ETA 01:20:20 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 20469.105 us/op +[info] # Warmup Iteration 2: 14486.904 us/op +[info] # Warmup Iteration 3: 14459.304 us/op +[info] # Warmup Iteration 4: 14468.363 us/op +[info] # Warmup Iteration 5: 14481.112 us/op +[info] Iteration 1: 14329.729 us/op +[info] Iteration 2: 14349.281 us/op +[info] Iteration 3: 14351.612 us/op +[info] Iteration 4: 14346.172 us/op +[info] Iteration 5: 14434.785 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 14362.316 ±(99.9%) 159.451 us/op [Average] +[info] (min, avg, max) = (14329.729, 14362.316, 14434.785), stdev = 41.409 +[info] CI (99.9%): [14202.865, 14521.767] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 70) +[info] # Run progress: 70.63% complete, ETA 01:18:40 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 31603.617 us/op +[info] # Warmup Iteration 2: 21043.553 us/op +[info] # Warmup Iteration 3: 21000.001 us/op +[info] # Warmup Iteration 4: 20883.357 us/op +[info] # Warmup Iteration 5: 20441.265 us/op +[info] Iteration 1: 20387.907 us/op +[info] Iteration 2: 20419.273 us/op +[info] Iteration 3: 20364.769 us/op +[info] Iteration 4: 20407.834 us/op +[info] Iteration 5: 20425.326 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 20401.022 ±(99.9%) 95.424 us/op [Average] +[info] (min, avg, max) = (20364.769, 20401.022, 20425.326), stdev = 24.781 +[info] CI (99.9%): [20305.597, 20496.446] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 75) +[info] # Run progress: 71.25% complete, ETA 01:17:00 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 47186.825 us/op +[info] # Warmup Iteration 2: 30151.324 us/op +[info] # Warmup Iteration 3: 30176.582 us/op +[info] # Warmup Iteration 4: 30182.051 us/op +[info] # Warmup Iteration 5: 30217.972 us/op +[info] Iteration 1: 30232.948 us/op +[info] Iteration 2: 30022.381 us/op +[info] Iteration 3: 29915.639 us/op +[info] Iteration 4: 29944.706 us/op +[info] Iteration 5: 29860.173 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 29995.169 ±(99.9%) 559.255 us/op [Average] +[info] (min, avg, max) = (29860.173, 29995.169, 30232.948), stdev = 145.237 +[info] CI (99.9%): [29435.914, 30554.425] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 80) +[info] # Run progress: 71.88% complete, ETA 01:15:19 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 52642.320 us/op +[info] # Warmup Iteration 2: 32155.574 us/op +[info] # Warmup Iteration 3: 32162.521 us/op +[info] # Warmup Iteration 4: 32116.602 us/op +[info] # Warmup Iteration 5: 32174.060 us/op +[info] Iteration 1: 32217.966 us/op +[info] Iteration 2: 32174.844 us/op +[info] Iteration 3: 31969.130 us/op +[info] Iteration 4: 32037.202 us/op +[info] Iteration 5: 32703.430 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 32220.514 ±(99.9%) 1109.523 us/op [Average] +[info] (min, avg, max) = (31969.130, 32220.514, 32703.430), stdev = 288.140 +[info] CI (99.9%): [31110.991, 33330.037] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 85) +[info] # Run progress: 72.50% complete, ETA 01:13:39 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 78797.771 us/op +[info] # Warmup Iteration 2: 35308.136 us/op +[info] # Warmup Iteration 3: 35324.019 us/op +[info] # Warmup Iteration 4: 34844.616 us/op +[info] # Warmup Iteration 5: 34506.204 us/op +[info] Iteration 1: 34450.308 us/op +[info] Iteration 2: 34252.408 us/op +[info] Iteration 3: 34233.567 us/op +[info] Iteration 4: 34214.403 us/op +[info] Iteration 5: 34206.000 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 34271.337 ±(99.9%) 391.395 us/op [Average] +[info] (min, avg, max) = (34206.000, 34271.337, 34450.308), stdev = 101.644 +[info] CI (99.9%): [33879.942, 34662.732] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 90) +[info] # Run progress: 73.13% complete, ETA 01:11:58 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 123711.719 us/op +[info] # Warmup Iteration 2: 38404.424 us/op +[info] # Warmup Iteration 3: 38377.964 us/op +[info] # Warmup Iteration 4: 38283.190 us/op +[info] # Warmup Iteration 5: 38204.194 us/op +[info] Iteration 1: 38144.184 us/op +[info] Iteration 2: 38161.868 us/op +[info] Iteration 3: 38043.646 us/op +[info] Iteration 4: 38015.024 us/op +[info] Iteration 5: 37969.378 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 38066.820 ±(99.9%) 320.635 us/op [Average] +[info] (min, avg, max) = (37969.378, 38066.820, 38161.868), stdev = 83.268 +[info] CI (99.9%): [37746.185, 38387.455] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 95) +[info] # Run progress: 73.75% complete, ETA 01:10:18 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 345333.557 us/op +[info] # Warmup Iteration 2: 40810.558 us/op +[info] # Warmup Iteration 3: 40837.849 us/op +[info] # Warmup Iteration 4: 40920.766 us/op +[info] # Warmup Iteration 5: 40918.210 us/op +[info] Iteration 1: 40885.270 us/op +[info] Iteration 2: 40843.038 us/op +[info] Iteration 3: 40621.682 us/op +[info] Iteration 4: 40618.817 us/op +[info] Iteration 5: 40581.796 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 40710.121 ±(99.9%) 547.851 us/op [Average] +[info] (min, avg, max) = (40581.796, 40710.121, 40885.270), stdev = 142.275 +[info] CI (99.9%): [40162.269, 41257.972] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_regex_mem +[info] # Parameters: (size = 100) +[info] # Run progress: 74.38% complete, ETA 01:08:38 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 400633.244 us/op +[info] # Warmup Iteration 2: 55881.875 us/op +[info] # Warmup Iteration 3: 55828.108 us/op +[info] # Warmup Iteration 4: 55920.780 us/op +[info] # Warmup Iteration 5: 55836.719 us/op +[info] Iteration 1: 55628.816 us/op +[info] Iteration 2: 55599.953 us/op +[info] Iteration 3: 55433.824 us/op +[info] Iteration 4: 55510.249 us/op +[info] Iteration 5: 55511.428 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_regex_mem": +[info] 55536.854 ±(99.9%) 300.793 us/op [Average] +[info] (min, avg, max) = (55433.824, 55536.854, 55628.816), stdev = 78.115 +[info] CI (99.9%): [55236.061, 55837.647] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 5) +[info] # Run progress: 75.00% complete, ETA 01:06:57 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 28.184 us/op +[info] # Warmup Iteration 2: 26.035 us/op +[info] # Warmup Iteration 3: 25.969 us/op +[info] # Warmup Iteration 4: 25.750 us/op +[info] # Warmup Iteration 5: 25.656 us/op +[info] Iteration 1: 25.481 us/op +[info] Iteration 2: 25.553 us/op +[info] Iteration 3: 25.875 us/op +[info] Iteration 4: 25.500 us/op +[info] Iteration 5: 25.453 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 25.572 ±(99.9%) 0.665 us/op [Average] +[info] (min, avg, max) = (25.453, 25.572, 25.875), stdev = 0.173 +[info] CI (99.9%): [24.907, 26.238] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 10) +[info] # Run progress: 75.63% complete, ETA 01:05:17 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 69.800 us/op +[info] # Warmup Iteration 2: 64.274 us/op +[info] # Warmup Iteration 3: 64.928 us/op +[info] # Warmup Iteration 4: 63.330 us/op +[info] # Warmup Iteration 5: 64.292 us/op +[info] Iteration 1: 63.804 us/op +[info] Iteration 2: 63.516 us/op +[info] Iteration 3: 63.393 us/op +[info] Iteration 4: 63.880 us/op +[info] Iteration 5: 63.218 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 63.562 ±(99.9%) 1.069 us/op [Average] +[info] (min, avg, max) = (63.218, 63.562, 63.880), stdev = 0.278 +[info] CI (99.9%): [62.493, 64.631] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 15) +[info] # Run progress: 76.25% complete, ETA 01:03:36 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 76.442 us/op +[info] # Warmup Iteration 2: 70.444 us/op +[info] # Warmup Iteration 3: 72.072 us/op +[info] # Warmup Iteration 4: 71.012 us/op +[info] # Warmup Iteration 5: 70.263 us/op +[info] Iteration 1: 69.227 us/op +[info] Iteration 2: 70.159 us/op +[info] Iteration 3: 69.248 us/op +[info] Iteration 4: 69.937 us/op +[info] Iteration 5: 69.322 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 69.579 ±(99.9%) 1.683 us/op [Average] +[info] (min, avg, max) = (69.227, 69.579, 70.159), stdev = 0.437 +[info] CI (99.9%): [67.895, 71.262] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 20) +[info] # Run progress: 76.88% complete, ETA 01:01:56 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 103.166 us/op +[info] # Warmup Iteration 2: 96.112 us/op +[info] # Warmup Iteration 3: 95.945 us/op +[info] # Warmup Iteration 4: 96.342 us/op +[info] # Warmup Iteration 5: 95.925 us/op +[info] Iteration 1: 95.570 us/op +[info] Iteration 2: 95.233 us/op +[info] Iteration 3: 96.440 us/op +[info] Iteration 4: 94.819 us/op +[info] Iteration 5: 95.120 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 95.436 ±(99.9%) 2.396 us/op [Average] +[info] (min, avg, max) = (94.819, 95.436, 96.440), stdev = 0.622 +[info] CI (99.9%): [93.041, 97.832] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 25) +[info] # Run progress: 77.50% complete, ETA 01:00:15 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 153.241 us/op +[info] # Warmup Iteration 2: 144.379 us/op +[info] # Warmup Iteration 3: 144.535 us/op +[info] # Warmup Iteration 4: 143.978 us/op +[info] # Warmup Iteration 5: 142.062 us/op +[info] Iteration 1: 143.677 us/op +[info] Iteration 2: 143.069 us/op +[info] Iteration 3: 142.750 us/op +[info] Iteration 4: 141.672 us/op +[info] Iteration 5: 145.143 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 143.262 ±(99.9%) 4.923 us/op [Average] +[info] (min, avg, max) = (141.672, 143.262, 145.143), stdev = 1.279 +[info] CI (99.9%): [138.339, 148.186] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 30) +[info] # Run progress: 78.13% complete, ETA 00:58:35 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 207.316 us/op +[info] # Warmup Iteration 2: 190.819 us/op +[info] # Warmup Iteration 3: 195.058 us/op +[info] # Warmup Iteration 4: 190.929 us/op +[info] # Warmup Iteration 5: 188.109 us/op +[info] Iteration 1: 187.580 us/op +[info] Iteration 2: 187.216 us/op +[info] Iteration 3: 185.825 us/op +[info] Iteration 4: 186.036 us/op +[info] Iteration 5: 185.760 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 186.483 ±(99.9%) 3.277 us/op [Average] +[info] (min, avg, max) = (185.760, 186.483, 187.580), stdev = 0.851 +[info] CI (99.9%): [183.207, 189.760] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 35) +[info] # Run progress: 78.75% complete, ETA 00:56:55 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 180.725 us/op +[info] # Warmup Iteration 2: 169.778 us/op +[info] # Warmup Iteration 3: 169.730 us/op +[info] # Warmup Iteration 4: 169.152 us/op +[info] # Warmup Iteration 5: 166.637 us/op +[info] Iteration 1: 169.256 us/op +[info] Iteration 2: 168.438 us/op +[info] Iteration 3: 167.909 us/op +[info] Iteration 4: 166.101 us/op +[info] Iteration 5: 166.218 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 167.585 ±(99.9%) 5.342 us/op [Average] +[info] (min, avg, max) = (166.101, 167.585, 169.256), stdev = 1.387 +[info] CI (99.9%): [162.243, 172.926] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 40) +[info] # Run progress: 79.38% complete, ETA 00:55:14 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 355.211 us/op +[info] # Warmup Iteration 2: 327.502 us/op +[info] # Warmup Iteration 3: 328.642 us/op +[info] # Warmup Iteration 4: 326.480 us/op +[info] # Warmup Iteration 5: 325.115 us/op +[info] Iteration 1: 324.017 us/op +[info] Iteration 2: 323.067 us/op +[info] Iteration 3: 327.579 us/op +[info] Iteration 4: 326.534 us/op +[info] Iteration 5: 332.772 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 326.794 ±(99.9%) 14.666 us/op [Average] +[info] (min, avg, max) = (323.067, 326.794, 332.772), stdev = 3.809 +[info] CI (99.9%): [312.128, 341.460] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 45) +[info] # Run progress: 80.00% complete, ETA 00:53:34 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 289.460 us/op +[info] # Warmup Iteration 2: 264.369 us/op +[info] # Warmup Iteration 3: 267.850 us/op +[info] # Warmup Iteration 4: 260.243 us/op +[info] # Warmup Iteration 5: 260.710 us/op +[info] Iteration 1: 260.295 us/op +[info] Iteration 2: 260.195 us/op +[info] Iteration 3: 261.785 us/op +[info] Iteration 4: 258.634 us/op +[info] Iteration 5: 258.982 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 259.978 ±(99.9%) 4.798 us/op [Average] +[info] (min, avg, max) = (258.634, 259.978, 261.785), stdev = 1.246 +[info] CI (99.9%): [255.180, 264.776] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 50) +[info] # Run progress: 80.63% complete, ETA 00:51:53 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 422.703 us/op +[info] # Warmup Iteration 2: 390.443 us/op +[info] # Warmup Iteration 3: 389.101 us/op +[info] # Warmup Iteration 4: 390.131 us/op +[info] # Warmup Iteration 5: 385.956 us/op +[info] Iteration 1: 386.232 us/op +[info] Iteration 2: 383.872 us/op +[info] Iteration 3: 388.063 us/op +[info] Iteration 4: 382.687 us/op +[info] Iteration 5: 383.846 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 384.940 ±(99.9%) 8.356 us/op [Average] +[info] (min, avg, max) = (382.687, 384.940, 388.063), stdev = 2.170 +[info] CI (99.9%): [376.584, 393.296] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 55) +[info] # Run progress: 81.25% complete, ETA 00:50:13 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 420.984 us/op +[info] # Warmup Iteration 2: 384.213 us/op +[info] # Warmup Iteration 3: 390.245 us/op +[info] # Warmup Iteration 4: 386.869 us/op +[info] # Warmup Iteration 5: 385.014 us/op +[info] Iteration 1: 381.183 us/op +[info] Iteration 2: 387.640 us/op +[info] Iteration 3: 380.728 us/op +[info] Iteration 4: 381.506 us/op +[info] Iteration 5: 384.683 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 383.148 ±(99.9%) 11.382 us/op [Average] +[info] (min, avg, max) = (380.728, 383.148, 387.640), stdev = 2.956 +[info] CI (99.9%): [371.765, 394.530] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 60) +[info] # Run progress: 81.88% complete, ETA 00:48:32 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 345.902 us/op +[info] # Warmup Iteration 2: 321.967 us/op +[info] # Warmup Iteration 3: 315.542 us/op +[info] # Warmup Iteration 4: 317.021 us/op +[info] # Warmup Iteration 5: 312.184 us/op +[info] Iteration 1: 306.610 us/op +[info] Iteration 2: 309.528 us/op +[info] Iteration 3: 308.354 us/op +[info] Iteration 4: 306.739 us/op +[info] Iteration 5: 310.893 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 308.425 ±(99.9%) 7.061 us/op [Average] +[info] (min, avg, max) = (306.610, 308.425, 310.893), stdev = 1.834 +[info] CI (99.9%): [301.364, 315.486] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 65) +[info] # Run progress: 82.50% complete, ETA 00:46:52 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 330.025 us/op +[info] # Warmup Iteration 2: 308.328 us/op +[info] # Warmup Iteration 3: 300.433 us/op +[info] # Warmup Iteration 4: 306.565 us/op +[info] # Warmup Iteration 5: 305.774 us/op +[info] Iteration 1: 301.368 us/op +[info] Iteration 2: 305.593 us/op +[info] Iteration 3: 300.768 us/op +[info] Iteration 4: 300.911 us/op +[info] Iteration 5: 301.710 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 302.070 ±(99.9%) 7.719 us/op [Average] +[info] (min, avg, max) = (300.768, 302.070, 305.593), stdev = 2.005 +[info] CI (99.9%): [294.351, 309.789] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 70) +[info] # Run progress: 83.13% complete, ETA 00:45:11 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 543.578 us/op +[info] # Warmup Iteration 2: 502.094 us/op +[info] # Warmup Iteration 3: 495.595 us/op +[info] # Warmup Iteration 4: 502.743 us/op +[info] # Warmup Iteration 5: 492.672 us/op +[info] Iteration 1: 502.186 us/op +[info] Iteration 2: 496.236 us/op +[info] Iteration 3: 492.680 us/op +[info] Iteration 4: 498.657 us/op +[info] Iteration 5: 501.158 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 498.183 ±(99.9%) 14.809 us/op [Average] +[info] (min, avg, max) = (492.680, 498.183, 502.186), stdev = 3.846 +[info] CI (99.9%): [483.374, 512.993] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 75) +[info] # Run progress: 83.75% complete, ETA 00:43:31 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 671.411 us/op +[info] # Warmup Iteration 2: 619.064 us/op +[info] # Warmup Iteration 3: 610.533 us/op +[info] # Warmup Iteration 4: 598.814 us/op +[info] # Warmup Iteration 5: 609.869 us/op +[info] Iteration 1: 600.752 us/op +[info] Iteration 2: 609.137 us/op +[info] Iteration 3: 605.453 us/op +[info] Iteration 4: 601.137 us/op +[info] Iteration 5: 600.129 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 603.322 ±(99.9%) 14.904 us/op [Average] +[info] (min, avg, max) = (600.129, 603.322, 609.137), stdev = 3.871 +[info] CI (99.9%): [588.417, 618.226] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 80) +[info] # Run progress: 84.38% complete, ETA 00:41:51 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 728.636 us/op +[info] # Warmup Iteration 2: 678.521 us/op +[info] # Warmup Iteration 3: 669.452 us/op +[info] # Warmup Iteration 4: 676.114 us/op +[info] # Warmup Iteration 5: 680.157 us/op +[info] Iteration 1: 665.299 us/op +[info] Iteration 2: 677.489 us/op +[info] Iteration 3: 666.645 us/op +[info] Iteration 4: 664.572 us/op +[info] Iteration 5: 665.137 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 667.829 ±(99.9%) 21.001 us/op [Average] +[info] (min, avg, max) = (664.572, 667.829, 677.489), stdev = 5.454 +[info] CI (99.9%): [646.828, 688.829] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 85) +[info] # Run progress: 85.00% complete, ETA 00:40:10 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 712.914 us/op +[info] # Warmup Iteration 2: 660.407 us/op +[info] # Warmup Iteration 3: 654.548 us/op +[info] # Warmup Iteration 4: 653.327 us/op +[info] # Warmup Iteration 5: 657.296 us/op +[info] Iteration 1: 653.864 us/op +[info] Iteration 2: 652.762 us/op +[info] Iteration 3: 648.883 us/op +[info] Iteration 4: 661.532 us/op +[info] Iteration 5: 668.393 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 657.087 ±(99.9%) 30.074 us/op [Average] +[info] (min, avg, max) = (648.883, 657.087, 668.393), stdev = 7.810 +[info] CI (99.9%): [627.013, 687.161] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 90) +[info] # Run progress: 85.63% complete, ETA 00:38:30 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 717.791 us/op +[info] # Warmup Iteration 2: 656.188 us/op +[info] # Warmup Iteration 3: 653.390 us/op +[info] # Warmup Iteration 4: 642.622 us/op +[info] # Warmup Iteration 5: 651.385 us/op +[info] Iteration 1: 652.606 us/op +[info] Iteration 2: 643.483 us/op +[info] Iteration 3: 655.183 us/op +[info] Iteration 4: 641.699 us/op +[info] Iteration 5: 643.063 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 647.207 ±(99.9%) 23.904 us/op [Average] +[info] (min, avg, max) = (641.699, 647.207, 655.183), stdev = 6.208 +[info] CI (99.9%): [623.303, 671.111] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 95) +[info] # Run progress: 86.25% complete, ETA 00:36:49 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 714.689 us/op +[info] # Warmup Iteration 2: 653.449 us/op +[info] # Warmup Iteration 3: 662.370 us/op +[info] # Warmup Iteration 4: 663.041 us/op +[info] # Warmup Iteration 5: 662.551 us/op +[info] Iteration 1: 654.282 us/op +[info] Iteration 2: 654.603 us/op +[info] Iteration 3: 665.952 us/op +[info] Iteration 4: 651.694 us/op +[info] Iteration 5: 650.934 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 655.493 ±(99.9%) 23.333 us/op [Average] +[info] (min, avg, max) = (650.934, 655.493, 665.952), stdev = 6.060 +[info] CI (99.9%): [632.160, 678.826] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper +[info] # Parameters: (size = 100) +[info] # Run progress: 86.88% complete, ETA 00:35:09 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 803.018 us/op +[info] # Warmup Iteration 2: 753.013 us/op +[info] # Warmup Iteration 3: 755.009 us/op +[info] # Warmup Iteration 4: 752.277 us/op +[info] # Warmup Iteration 5: 754.620 us/op +[info] Iteration 1: 743.472 us/op +[info] Iteration 2: 752.865 us/op +[info] Iteration 3: 740.854 us/op +[info] Iteration 4: 744.127 us/op +[info] Iteration 5: 762.911 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper": +[info] 748.846 ±(99.9%) 34.922 us/op [Average] +[info] (min, avg, max) = (740.854, 748.846, 762.911), stdev = 9.069 +[info] CI (99.9%): [713.924, 783.768] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 5) +[info] # Run progress: 87.50% complete, ETA 00:33:28 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 28.563 us/op +[info] # Warmup Iteration 2: 26.107 us/op +[info] # Warmup Iteration 3: 25.975 us/op +[info] # Warmup Iteration 4: 25.439 us/op +[info] # Warmup Iteration 5: 25.689 us/op +[info] Iteration 1: 25.660 us/op +[info] Iteration 2: 25.419 us/op +[info] Iteration 3: 25.410 us/op +[info] Iteration 4: 25.384 us/op +[info] Iteration 5: 25.735 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 25.522 ±(99.9%) 0.628 us/op [Average] +[info] (min, avg, max) = (25.384, 25.522, 25.735), stdev = 0.163 +[info] CI (99.9%): [24.894, 26.150] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 10) +[info] # Run progress: 88.13% complete, ETA 00:31:48 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 69.602 us/op +[info] # Warmup Iteration 2: 64.048 us/op +[info] # Warmup Iteration 3: 64.875 us/op +[info] # Warmup Iteration 4: 63.523 us/op +[info] # Warmup Iteration 5: 64.246 us/op +[info] Iteration 1: 63.739 us/op +[info] Iteration 2: 63.461 us/op +[info] Iteration 3: 62.969 us/op +[info] Iteration 4: 62.956 us/op +[info] Iteration 5: 62.929 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 63.211 ±(99.9%) 1.420 us/op [Average] +[info] (min, avg, max) = (62.929, 63.211, 63.739), stdev = 0.369 +[info] CI (99.9%): [61.790, 64.631] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 15) +[info] # Run progress: 88.75% complete, ETA 00:30:07 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 75.646 us/op +[info] # Warmup Iteration 2: 69.935 us/op +[info] # Warmup Iteration 3: 70.506 us/op +[info] # Warmup Iteration 4: 69.517 us/op +[info] # Warmup Iteration 5: 70.260 us/op +[info] Iteration 1: 70.350 us/op +[info] Iteration 2: 69.126 us/op +[info] Iteration 3: 69.698 us/op +[info] Iteration 4: 69.372 us/op +[info] Iteration 5: 69.055 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 69.520 ±(99.9%) 2.032 us/op [Average] +[info] (min, avg, max) = (69.055, 69.520, 70.350), stdev = 0.528 +[info] CI (99.9%): [67.488, 71.552] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 20) +[info] # Run progress: 89.38% complete, ETA 00:28:27 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 105.194 us/op +[info] # Warmup Iteration 2: 97.489 us/op +[info] # Warmup Iteration 3: 97.766 us/op +[info] # Warmup Iteration 4: 96.405 us/op +[info] # Warmup Iteration 5: 95.709 us/op +[info] Iteration 1: 95.938 us/op +[info] Iteration 2: 95.839 us/op +[info] Iteration 3: 94.797 us/op +[info] Iteration 4: 95.134 us/op +[info] Iteration 5: 95.147 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 95.371 ±(99.9%) 1.902 us/op [Average] +[info] (min, avg, max) = (94.797, 95.371, 95.938), stdev = 0.494 +[info] CI (99.9%): [93.469, 97.273] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 25) +[info] # Run progress: 90.00% complete, ETA 00:26:47 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 154.790 us/op +[info] # Warmup Iteration 2: 145.102 us/op +[info] # Warmup Iteration 3: 144.810 us/op +[info] # Warmup Iteration 4: 144.223 us/op +[info] # Warmup Iteration 5: 142.267 us/op +[info] Iteration 1: 144.021 us/op +[info] Iteration 2: 142.705 us/op +[info] Iteration 3: 144.333 us/op +[info] Iteration 4: 141.947 us/op +[info] Iteration 5: 144.118 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 143.425 ±(99.9%) 4.022 us/op [Average] +[info] (min, avg, max) = (141.947, 143.425, 144.333), stdev = 1.044 +[info] CI (99.9%): [139.403, 147.446] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 30) +[info] # Run progress: 90.63% complete, ETA 00:25:06 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 202.866 us/op +[info] # Warmup Iteration 2: 190.109 us/op +[info] # Warmup Iteration 3: 190.850 us/op +[info] # Warmup Iteration 4: 187.026 us/op +[info] # Warmup Iteration 5: 188.455 us/op +[info] Iteration 1: 187.546 us/op +[info] Iteration 2: 189.833 us/op +[info] Iteration 3: 187.632 us/op +[info] Iteration 4: 190.307 us/op +[info] Iteration 5: 190.337 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 189.131 ±(99.9%) 5.476 us/op [Average] +[info] (min, avg, max) = (187.546, 189.131, 190.337), stdev = 1.422 +[info] CI (99.9%): [183.655, 194.607] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 35) +[info] # Run progress: 91.25% complete, ETA 00:23:26 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 183.039 us/op +[info] # Warmup Iteration 2: 170.897 us/op +[info] # Warmup Iteration 3: 169.345 us/op +[info] # Warmup Iteration 4: 168.087 us/op +[info] # Warmup Iteration 5: 168.660 us/op +[info] Iteration 1: 165.390 us/op +[info] Iteration 2: 169.331 us/op +[info] Iteration 3: 166.340 us/op +[info] Iteration 4: 169.194 us/op +[info] Iteration 5: 166.718 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 167.394 ±(99.9%) 6.828 us/op [Average] +[info] (min, avg, max) = (165.390, 167.394, 169.331), stdev = 1.773 +[info] CI (99.9%): [160.567, 174.222] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 40) +[info] # Run progress: 91.88% complete, ETA 00:21:45 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 345.337 us/op +[info] # Warmup Iteration 2: 317.233 us/op +[info] # Warmup Iteration 3: 319.654 us/op +[info] # Warmup Iteration 4: 319.719 us/op +[info] # Warmup Iteration 5: 313.661 us/op +[info] Iteration 1: 318.881 us/op +[info] Iteration 2: 314.212 us/op +[info] Iteration 3: 318.207 us/op +[info] Iteration 4: 313.062 us/op +[info] Iteration 5: 313.211 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 315.515 ±(99.9%) 10.823 us/op [Average] +[info] (min, avg, max) = (313.062, 315.515, 318.881), stdev = 2.811 +[info] CI (99.9%): [304.692, 326.338] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 45) +[info] # Run progress: 92.50% complete, ETA 00:20:05 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 278.552 us/op +[info] # Warmup Iteration 2: 260.531 us/op +[info] # Warmup Iteration 3: 260.605 us/op +[info] # Warmup Iteration 4: 260.614 us/op +[info] # Warmup Iteration 5: 255.152 us/op +[info] Iteration 1: 259.993 us/op +[info] Iteration 2: 255.305 us/op +[info] Iteration 3: 260.313 us/op +[info] Iteration 4: 258.216 us/op +[info] Iteration 5: 262.100 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 259.185 ±(99.9%) 9.896 us/op [Average] +[info] (min, avg, max) = (255.305, 259.185, 262.100), stdev = 2.570 +[info] CI (99.9%): [249.289, 269.081] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 50) +[info] # Run progress: 93.13% complete, ETA 00:18:24 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 423.608 us/op +[info] # Warmup Iteration 2: 398.114 us/op +[info] # Warmup Iteration 3: 398.942 us/op +[info] # Warmup Iteration 4: 390.402 us/op +[info] # Warmup Iteration 5: 387.938 us/op +[info] Iteration 1: 386.495 us/op +[info] Iteration 2: 387.577 us/op +[info] Iteration 3: 386.050 us/op +[info] Iteration 4: 383.631 us/op +[info] Iteration 5: 387.283 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 386.207 ±(99.9%) 6.020 us/op [Average] +[info] (min, avg, max) = (383.631, 386.207, 387.577), stdev = 1.564 +[info] CI (99.9%): [380.187, 392.228] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 55) +[info] # Run progress: 93.75% complete, ETA 00:16:44 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 419.771 us/op +[info] # Warmup Iteration 2: 386.706 us/op +[info] # Warmup Iteration 3: 381.554 us/op +[info] # Warmup Iteration 4: 386.363 us/op +[info] # Warmup Iteration 5: 387.984 us/op +[info] Iteration 1: 381.680 us/op +[info] Iteration 2: 387.159 us/op +[info] Iteration 3: 381.319 us/op +[info] Iteration 4: 382.756 us/op +[info] Iteration 5: 387.345 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 384.052 ±(99.9%) 11.435 us/op [Average] +[info] (min, avg, max) = (381.319, 384.052, 387.345), stdev = 2.970 +[info] CI (99.9%): [372.617, 395.487] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 60) +[info] # Run progress: 94.38% complete, ETA 00:15:03 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 337.419 us/op +[info] # Warmup Iteration 2: 311.579 us/op +[info] # Warmup Iteration 3: 313.032 us/op +[info] # Warmup Iteration 4: 306.562 us/op +[info] # Warmup Iteration 5: 310.609 us/op +[info] Iteration 1: 308.760 us/op +[info] Iteration 2: 307.961 us/op +[info] Iteration 3: 305.653 us/op +[info] Iteration 4: 312.918 us/op +[info] Iteration 5: 316.626 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 310.384 ±(99.9%) 16.814 us/op [Average] +[info] (min, avg, max) = (305.653, 310.384, 316.626), stdev = 4.367 +[info] CI (99.9%): [293.570, 327.198] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 65) +[info] # Run progress: 95.00% complete, ETA 00:13:23 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 331.307 us/op +[info] # Warmup Iteration 2: 311.921 us/op +[info] # Warmup Iteration 3: 305.790 us/op +[info] # Warmup Iteration 4: 304.694 us/op +[info] # Warmup Iteration 5: 301.097 us/op +[info] Iteration 1: 303.590 us/op +[info] Iteration 2: 302.112 us/op +[info] Iteration 3: 302.393 us/op +[info] Iteration 4: 299.887 us/op +[info] Iteration 5: 305.723 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 302.741 ±(99.9%) 8.232 us/op [Average] +[info] (min, avg, max) = (299.887, 302.741, 305.723), stdev = 2.138 +[info] CI (99.9%): [294.510, 310.973] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 70) +[info] # Run progress: 95.63% complete, ETA 00:11:43 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 500.809 us/op +[info] # Warmup Iteration 2: 463.080 us/op +[info] # Warmup Iteration 3: 463.309 us/op +[info] # Warmup Iteration 4: 454.922 us/op +[info] # Warmup Iteration 5: 457.931 us/op +[info] Iteration 1: 457.987 us/op +[info] Iteration 2: 460.228 us/op +[info] Iteration 3: 453.527 us/op +[info] Iteration 4: 454.309 us/op +[info] Iteration 5: 453.260 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 455.862 ±(99.9%) 11.901 us/op [Average] +[info] (min, avg, max) = (453.260, 455.862, 460.228), stdev = 3.091 +[info] CI (99.9%): [443.961, 467.763] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 75) +[info] # Run progress: 96.25% complete, ETA 00:10:02 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 657.067 us/op +[info] # Warmup Iteration 2: 612.980 us/op +[info] # Warmup Iteration 3: 612.259 us/op +[info] # Warmup Iteration 4: 605.712 us/op +[info] # Warmup Iteration 5: 610.746 us/op +[info] Iteration 1: 603.309 us/op +[info] Iteration 2: 604.211 us/op +[info] Iteration 3: 618.969 us/op +[info] Iteration 4: 616.110 us/op +[info] Iteration 5: 621.002 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 612.720 ±(99.9%) 32.223 us/op [Average] +[info] (min, avg, max) = (603.309, 612.720, 621.002), stdev = 8.368 +[info] CI (99.9%): [580.497, 644.943] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 80) +[info] # Run progress: 96.88% complete, ETA 00:08:22 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 742.894 us/op +[info] # Warmup Iteration 2: 686.900 us/op +[info] # Warmup Iteration 3: 679.445 us/op +[info] # Warmup Iteration 4: 671.970 us/op +[info] # Warmup Iteration 5: 674.305 us/op +[info] Iteration 1: 669.689 us/op +[info] Iteration 2: 673.878 us/op +[info] Iteration 3: 671.827 us/op +[info] Iteration 4: 672.871 us/op +[info] Iteration 5: 671.076 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 671.868 ±(99.9%) 6.215 us/op [Average] +[info] (min, avg, max) = (669.689, 671.868, 673.878), stdev = 1.614 +[info] CI (99.9%): [665.653, 678.084] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 85) +[info] # Run progress: 97.50% complete, ETA 00:06:41 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 708.027 us/op +[info] # Warmup Iteration 2: 663.156 us/op +[info] # Warmup Iteration 3: 647.091 us/op +[info] # Warmup Iteration 4: 656.535 us/op +[info] # Warmup Iteration 5: 649.002 us/op +[info] Iteration 1: 655.996 us/op +[info] Iteration 2: 654.692 us/op +[info] Iteration 3: 651.706 us/op +[info] Iteration 4: 647.531 us/op +[info] Iteration 5: 645.976 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 651.181 ±(99.9%) 16.807 us/op [Average] +[info] (min, avg, max) = (645.976, 651.181, 655.996), stdev = 4.365 +[info] CI (99.9%): [634.374, 667.987] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 90) +[info] # Run progress: 98.13% complete, ETA 00:05:01 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 702.935 us/op +[info] # Warmup Iteration 2: 653.970 us/op +[info] # Warmup Iteration 3: 651.455 us/op +[info] # Warmup Iteration 4: 638.091 us/op +[info] # Warmup Iteration 5: 650.281 us/op +[info] Iteration 1: 639.115 us/op +[info] Iteration 2: 639.427 us/op +[info] Iteration 3: 649.930 us/op +[info] Iteration 4: 638.117 us/op +[info] Iteration 5: 645.536 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 642.425 ±(99.9%) 19.682 us/op [Average] +[info] (min, avg, max) = (638.117, 642.425, 649.930), stdev = 5.111 +[info] CI (99.9%): [622.743, 662.107] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 95) +[info] # Run progress: 98.75% complete, ETA 00:03:20 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 661.607 us/op +[info] # Warmup Iteration 2: 615.876 us/op +[info] # Warmup Iteration 3: 609.710 us/op +[info] # Warmup Iteration 4: 601.990 us/op +[info] # Warmup Iteration 5: 606.741 us/op +[info] Iteration 1: 598.580 us/op +[info] Iteration 2: 602.759 us/op +[info] Iteration 3: 601.572 us/op +[info] Iteration 4: 595.558 us/op +[info] Iteration 5: 607.158 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 601.126 ±(99.9%) 16.864 us/op [Average] +[info] (min, avg, max) = (595.558, 601.126, 607.158), stdev = 4.380 +[info] CI (99.9%): [584.261, 617.990] (assumes normal distribution) +[info] # JMH version: 1.32 +[info] # VM version: JDK 17.0.11, OpenJDK 64-Bit Server VM, 17.0.11+9 +[info] # VM invoker: /usr/lib/jvm/temurin-17-jdk-amd64/bin/java +[info] # VM options: +[info] # Blackhole mode: full + dont-inline hint +[info] # Warmup: 5 iterations, 10 s each +[info] # Measurement: 5 iterations, 10 s each +[info] # Timeout: 10 min per iteration +[info] # Threads: 1 thread, will synchronize iterations +[info] # Benchmark mode: Average time, time/op +[info] # Benchmark: benchmark.RegexBenchmark.email_accepting_zipper_mem +[info] # Parameters: (size = 100) +[info] # Run progress: 99.38% complete, ETA 00:01:40 +[info] # Fork: 1 of 1 +[info] # Warmup Iteration 1: 808.517 us/op +[info] # Warmup Iteration 2: 757.732 us/op +[info] # Warmup Iteration 3: 756.756 us/op +[info] # Warmup Iteration 4: 754.716 us/op +[info] # Warmup Iteration 5: 747.030 us/op +[info] Iteration 1: 755.683 us/op +[info] Iteration 2: 753.843 us/op +[info] Iteration 3: 749.083 us/op +[info] Iteration 4: 744.530 us/op +[info] Iteration 5: 742.462 us/op +[info] Result "benchmark.RegexBenchmark.email_accepting_zipper_mem": +[info] 749.120 ±(99.9%) 22.018 us/op [Average] +[info] (min, avg, max) = (742.462, 749.120, 755.683), stdev = 5.718 +[info] CI (99.9%): [727.102, 771.138] (assumes normal distribution) +[info] # Run complete. Total time: 04:27:50 +[info] REMEMBER: The numbers below are just data. To gain reusable insights, you need to follow up on +[info] why the numbers are the way they are. Use profilers (see -prof, -lprof), design factorial +[info] experiments, perform baseline and negative tests that provide experimental control, make sure +[info] the benchmarking environment is safe on JVM/OS/HW level, ask for reviews from the domain experts. +[info] Do not assume the numbers tell you what you want them to tell. +[info] Benchmark (size) Mode Cnt Score Error Units +[info] RegexBenchmark.abStar_accepting_regex 5 avgt 5 1.718 ± 0.185 us/op +[info] RegexBenchmark.abStar_accepting_regex 10 avgt 5 10.116 ± 0.283 us/op +[info] RegexBenchmark.abStar_accepting_regex 15 avgt 5 31.786 ± 0.882 us/op +[info] RegexBenchmark.abStar_accepting_regex 20 avgt 5 74.264 ± 2.577 us/op +[info] RegexBenchmark.abStar_accepting_regex 25 avgt 5 146.090 ± 3.507 us/op +[info] RegexBenchmark.abStar_accepting_regex 30 avgt 5 256.076 ± 9.722 us/op +[info] RegexBenchmark.abStar_accepting_regex 35 avgt 5 410.827 ± 4.600 us/op +[info] RegexBenchmark.abStar_accepting_regex 40 avgt 5 618.044 ± 11.066 us/op +[info] RegexBenchmark.abStar_accepting_regex 45 avgt 5 895.693 ± 22.044 us/op +[info] RegexBenchmark.abStar_accepting_regex 50 avgt 5 1239.258 ± 46.194 us/op +[info] RegexBenchmark.abStar_accepting_regex 55 avgt 5 1660.993 ± 32.586 us/op +[info] RegexBenchmark.abStar_accepting_regex 60 avgt 5 2205.404 ± 79.386 us/op +[info] RegexBenchmark.abStar_accepting_regex 65 avgt 5 2804.502 ± 73.930 us/op +[info] RegexBenchmark.abStar_accepting_regex 70 avgt 5 3533.339 ± 91.019 us/op +[info] RegexBenchmark.abStar_accepting_regex 75 avgt 5 4411.665 ± 181.586 us/op +[info] RegexBenchmark.abStar_accepting_regex 80 avgt 5 5317.288 ± 149.315 us/op +[info] RegexBenchmark.abStar_accepting_regex 85 avgt 5 6386.131 ± 161.737 us/op +[info] RegexBenchmark.abStar_accepting_regex 90 avgt 5 7766.553 ± 257.710 us/op +[info] RegexBenchmark.abStar_accepting_regex 95 avgt 5 9045.615 ± 368.430 us/op +[info] RegexBenchmark.abStar_accepting_regex 100 avgt 5 10531.468 ± 302.107 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 5 avgt 5 10.257 ± 0.099 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 10 avgt 5 59.411 ± 0.405 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 15 avgt 5 165.373 ± 0.745 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 20 avgt 5 347.550 ± 8.042 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 25 avgt 5 608.218 ± 3.153 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 30 avgt 5 981.560 ± 6.240 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 35 avgt 5 1556.398 ± 62.844 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 40 avgt 5 2148.328 ± 7.370 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 45 avgt 5 2972.931 ± 13.578 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 50 avgt 5 4040.328 ± 159.279 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 55 avgt 5 5060.148 ± 25.422 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 60 avgt 5 6724.749 ± 52.200 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 65 avgt 5 8363.355 ± 276.350 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 70 avgt 5 10321.880 ± 19.532 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 75 avgt 5 12303.517 ± 93.941 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 80 avgt 5 15142.450 ± 794.036 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 85 avgt 5 17798.814 ± 151.100 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 90 avgt 5 20900.861 ± 1227.450 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 95 avgt 5 24692.210 ± 3273.667 us/op +[info] RegexBenchmark.abStar_accepting_regex_mem 100 avgt 5 28660.343 ± 3526.225 us/op +[info] RegexBenchmark.abStar_accepting_zipper 5 avgt 5 1.069 ± 0.043 us/op +[info] RegexBenchmark.abStar_accepting_zipper 10 avgt 5 2.148 ± 0.094 us/op +[info] RegexBenchmark.abStar_accepting_zipper 15 avgt 5 3.403 ± 0.067 us/op +[info] RegexBenchmark.abStar_accepting_zipper 20 avgt 5 4.278 ± 0.103 us/op +[info] RegexBenchmark.abStar_accepting_zipper 25 avgt 5 5.623 ± 0.159 us/op +[info] RegexBenchmark.abStar_accepting_zipper 30 avgt 5 6.615 ± 0.165 us/op +[info] RegexBenchmark.abStar_accepting_zipper 35 avgt 5 7.813 ± 0.265 us/op +[info] RegexBenchmark.abStar_accepting_zipper 40 avgt 5 8.966 ± 0.387 us/op +[info] RegexBenchmark.abStar_accepting_zipper 45 avgt 5 10.132 ± 0.440 us/op +[info] RegexBenchmark.abStar_accepting_zipper 50 avgt 5 11.333 ± 0.361 us/op +[info] RegexBenchmark.abStar_accepting_zipper 55 avgt 5 12.820 ± 0.667 us/op +[info] RegexBenchmark.abStar_accepting_zipper 60 avgt 5 13.595 ± 0.414 us/op +[info] RegexBenchmark.abStar_accepting_zipper 65 avgt 5 12.067 ± 0.404 us/op +[info] RegexBenchmark.abStar_accepting_zipper 70 avgt 5 13.196 ± 0.515 us/op +[info] RegexBenchmark.abStar_accepting_zipper 75 avgt 5 13.803 ± 0.478 us/op +[info] RegexBenchmark.abStar_accepting_zipper 80 avgt 5 14.918 ± 0.685 us/op +[info] RegexBenchmark.abStar_accepting_zipper 85 avgt 5 16.216 ± 0.831 us/op +[info] RegexBenchmark.abStar_accepting_zipper 90 avgt 5 16.469 ± 0.596 us/op +[info] RegexBenchmark.abStar_accepting_zipper 95 avgt 5 17.290 ± 0.540 us/op +[info] RegexBenchmark.abStar_accepting_zipper 100 avgt 5 18.978 ± 0.857 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 5 avgt 5 2.669 ± 0.066 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 10 avgt 5 5.471 ± 0.057 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 15 avgt 5 8.247 ± 0.241 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 20 avgt 5 10.573 ± 0.231 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 25 avgt 5 14.218 ± 0.314 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 30 avgt 5 19.685 ± 0.329 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 35 avgt 5 23.082 ± 0.626 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 40 avgt 5 25.858 ± 0.477 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 45 avgt 5 29.805 ± 0.868 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 50 avgt 5 32.617 ± 1.067 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 55 avgt 5 31.025 ± 0.543 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 60 avgt 5 39.397 ± 1.475 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 65 avgt 5 49.392 ± 1.140 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 70 avgt 5 45.483 ± 0.936 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 75 avgt 5 48.622 ± 1.293 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 80 avgt 5 53.248 ± 1.408 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 85 avgt 5 54.534 ± 1.146 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 90 avgt 5 58.530 ± 2.906 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 95 avgt 5 62.675 ± 1.273 us/op +[info] RegexBenchmark.abStar_accepting_zipper_mem 100 avgt 5 65.660 ± 1.576 us/op +[info] RegexBenchmark.email_accepting_regex 5 avgt 5 14.479 ± 0.582 us/op +[info] RegexBenchmark.email_accepting_regex 10 avgt 5 63.107 ± 1.784 us/op +[info] RegexBenchmark.email_accepting_regex 15 avgt 5 140.479 ± 4.823 us/op +[info] RegexBenchmark.email_accepting_regex 20 avgt 5 271.257 ± 4.290 us/op +[info] RegexBenchmark.email_accepting_regex 25 avgt 5 418.221 ± 13.027 us/op +[info] RegexBenchmark.email_accepting_regex 30 avgt 5 750.992 ± 23.385 us/op +[info] RegexBenchmark.email_accepting_regex 35 avgt 5 1025.407 ± 39.910 us/op +[info] RegexBenchmark.email_accepting_regex 40 avgt 5 1690.905 ± 38.652 us/op +[info] RegexBenchmark.email_accepting_regex 45 avgt 5 2119.223 ± 67.212 us/op +[info] RegexBenchmark.email_accepting_regex 50 avgt 5 3013.542 ± 116.997 us/op +[info] RegexBenchmark.email_accepting_regex 55 avgt 5 3534.553 ± 82.552 us/op +[info] RegexBenchmark.email_accepting_regex 60 avgt 5 4176.843 ± 93.465 us/op +[info] RegexBenchmark.email_accepting_regex 65 avgt 5 5587.623 ± 280.479 us/op +[info] RegexBenchmark.email_accepting_regex 70 avgt 5 6862.979 ± 176.748 us/op +[info] RegexBenchmark.email_accepting_regex 75 avgt 5 8650.853 ± 142.532 us/op +[info] RegexBenchmark.email_accepting_regex 80 avgt 5 9148.193 ± 261.101 us/op +[info] RegexBenchmark.email_accepting_regex 85 avgt 5 11397.081 ± 187.999 us/op +[info] RegexBenchmark.email_accepting_regex 90 avgt 5 13581.383 ± 379.412 us/op +[info] RegexBenchmark.email_accepting_regex 95 avgt 5 15851.598 ± 438.220 us/op +[info] RegexBenchmark.email_accepting_regex 100 avgt 5 17424.544 ± 448.055 us/op +[info] RegexBenchmark.email_accepting_regex_mem 5 avgt 5 97.926 ± 0.471 us/op +[info] RegexBenchmark.email_accepting_regex_mem 10 avgt 5 336.453 ± 3.227 us/op +[info] RegexBenchmark.email_accepting_regex_mem 15 avgt 5 673.542 ± 3.941 us/op +[info] RegexBenchmark.email_accepting_regex_mem 20 avgt 5 1156.384 ± 8.869 us/op +[info] RegexBenchmark.email_accepting_regex_mem 25 avgt 5 1837.122 ± 13.741 us/op +[info] RegexBenchmark.email_accepting_regex_mem 30 avgt 5 2967.740 ± 21.515 us/op +[info] RegexBenchmark.email_accepting_regex_mem 35 avgt 5 3701.245 ± 34.258 us/op +[info] RegexBenchmark.email_accepting_regex_mem 40 avgt 5 7804.431 ± 59.788 us/op +[info] RegexBenchmark.email_accepting_regex_mem 45 avgt 5 6639.778 ± 31.797 us/op +[info] RegexBenchmark.email_accepting_regex_mem 50 avgt 5 11605.145 ± 98.380 us/op +[info] RegexBenchmark.email_accepting_regex_mem 55 avgt 5 12214.834 ± 51.894 us/op +[info] RegexBenchmark.email_accepting_regex_mem 60 avgt 5 12016.321 ± 20.146 us/op +[info] RegexBenchmark.email_accepting_regex_mem 65 avgt 5 14362.316 ± 159.451 us/op +[info] RegexBenchmark.email_accepting_regex_mem 70 avgt 5 20401.022 ± 95.424 us/op +[info] RegexBenchmark.email_accepting_regex_mem 75 avgt 5 29995.169 ± 559.255 us/op +[info] RegexBenchmark.email_accepting_regex_mem 80 avgt 5 32220.514 ± 1109.523 us/op +[info] RegexBenchmark.email_accepting_regex_mem 85 avgt 5 34271.337 ± 391.395 us/op +[info] RegexBenchmark.email_accepting_regex_mem 90 avgt 5 38066.820 ± 320.635 us/op +[info] RegexBenchmark.email_accepting_regex_mem 95 avgt 5 40710.121 ± 547.851 us/op +[info] RegexBenchmark.email_accepting_regex_mem 100 avgt 5 55536.854 ± 300.793 us/op +[info] RegexBenchmark.email_accepting_zipper 5 avgt 5 25.572 ± 0.665 us/op +[info] RegexBenchmark.email_accepting_zipper 10 avgt 5 63.562 ± 1.069 us/op +[info] RegexBenchmark.email_accepting_zipper 15 avgt 5 69.579 ± 1.683 us/op +[info] RegexBenchmark.email_accepting_zipper 20 avgt 5 95.436 ± 2.396 us/op +[info] RegexBenchmark.email_accepting_zipper 25 avgt 5 143.262 ± 4.923 us/op +[info] RegexBenchmark.email_accepting_zipper 30 avgt 5 186.483 ± 3.277 us/op +[info] RegexBenchmark.email_accepting_zipper 35 avgt 5 167.585 ± 5.342 us/op +[info] RegexBenchmark.email_accepting_zipper 40 avgt 5 326.794 ± 14.666 us/op +[info] RegexBenchmark.email_accepting_zipper 45 avgt 5 259.978 ± 4.798 us/op +[info] RegexBenchmark.email_accepting_zipper 50 avgt 5 384.940 ± 8.356 us/op +[info] RegexBenchmark.email_accepting_zipper 55 avgt 5 383.148 ± 11.382 us/op +[info] RegexBenchmark.email_accepting_zipper 60 avgt 5 308.425 ± 7.061 us/op +[info] RegexBenchmark.email_accepting_zipper 65 avgt 5 302.070 ± 7.719 us/op +[info] RegexBenchmark.email_accepting_zipper 70 avgt 5 498.183 ± 14.809 us/op +[info] RegexBenchmark.email_accepting_zipper 75 avgt 5 603.322 ± 14.904 us/op +[info] RegexBenchmark.email_accepting_zipper 80 avgt 5 667.829 ± 21.001 us/op +[info] RegexBenchmark.email_accepting_zipper 85 avgt 5 657.087 ± 30.074 us/op +[info] RegexBenchmark.email_accepting_zipper 90 avgt 5 647.207 ± 23.904 us/op +[info] RegexBenchmark.email_accepting_zipper 95 avgt 5 655.493 ± 23.333 us/op +[info] RegexBenchmark.email_accepting_zipper 100 avgt 5 748.846 ± 34.922 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 5 avgt 5 25.522 ± 0.628 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 10 avgt 5 63.211 ± 1.420 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 15 avgt 5 69.520 ± 2.032 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 20 avgt 5 95.371 ± 1.902 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 25 avgt 5 143.425 ± 4.022 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 30 avgt 5 189.131 ± 5.476 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 35 avgt 5 167.394 ± 6.828 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 40 avgt 5 315.515 ± 10.823 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 45 avgt 5 259.185 ± 9.896 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 50 avgt 5 386.207 ± 6.020 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 55 avgt 5 384.052 ± 11.435 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 60 avgt 5 310.384 ± 16.814 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 65 avgt 5 302.741 ± 8.232 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 70 avgt 5 455.862 ± 11.901 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 75 avgt 5 612.720 ± 32.223 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 80 avgt 5 671.868 ± 6.215 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 85 avgt 5 651.181 ± 16.807 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 90 avgt 5 642.425 ± 19.682 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 95 avgt 5 601.126 ± 16.864 us/op +[info] RegexBenchmark.email_accepting_zipper_mem 100 avgt 5 749.120 ± 22.018 us/op +[success] Total time: 16114 s (04:28:34), completed Nov 28, 2024, 5:38:54 PM