Improve: Benchmark section names

Author: ashvardanian

bench_find.py

@@ -173,16 +173,16 @@ def main():
     log_system_info()
 
     print("\n=== Substring Search Benchmarks ===")
-    if should_run("str.find", filter_pattern):
-        bench_op("str.find", pythonic_str, tokens[::-1], count_find, args.time_limit)
-    if should_run("stringzilla.Str.find", filter_pattern):
-        bench_op("stringzilla.Str.find", stringzilla_str, tokens[::-1], count_find, args.time_limit)
-    if should_run("str.rfind", filter_pattern):
-        bench_op("str.rfind", pythonic_str, tokens, count_rfind, args.time_limit)
-    if should_run("stringzilla.Str.rfind", filter_pattern):
-        bench_op("stringzilla.Str.rfind", stringzilla_str, tokens, count_rfind, args.time_limit)
-    if should_run("pyahocorasick.iter", filter_pattern):
-        bench_op("pyahocorasick.iter", pythonic_str, tokens[::-1], count_aho, args.time_limit)
+    if should_run("substring-forward/std.str.find()", filter_pattern):
+        bench_op("std.str.find()", pythonic_str, tokens[::-1], count_find, args.time_limit)
+    if should_run("substring-forward/stringzilla.Str.find()", filter_pattern):
+        bench_op("stringzilla.Str.find()", stringzilla_str, tokens[::-1], count_find, args.time_limit)
+    if should_run("substring-backward/std.str.rfind()", filter_pattern):
+        bench_op("std.str.rfind()", pythonic_str, tokens, count_rfind, args.time_limit)
+    if should_run("substring-backward/stringzilla.Str.rfind()", filter_pattern):
+        bench_op("stringzilla.Str.rfind()", stringzilla_str, tokens, count_rfind, args.time_limit)
+    if should_run("substring-forward/pyahocorasick.iter()", filter_pattern):
+        bench_op("pyahocorasick.iter()", pythonic_str, tokens[::-1], count_aho, args.time_limit)
 
     print("\n=== Character Set Search ===")
     if args.tokens == "lines":
@@ -191,10 +191,10 @@ def main():
     else:
         re_chars = re.compile(r"[\t\n\r ]")  # whitespace: space, tab, LF, CR
         sz_chars = " \t\n\r"
-    if should_run("re.finditer", filter_pattern):
-        bench_op("re.finditer", pythonic_str, [re_chars], count_regex, args.time_limit)
-    if should_run("stringzilla.Str.find_first_of", filter_pattern):
-        bench_op("stringzilla.Str.find_first_of", stringzilla_str, [sz_chars], count_byteset, args.time_limit)
+    if should_run("byteset-forward/std.re.finditer()", filter_pattern):
+        bench_op("std.re.finditer()", pythonic_str, [re_chars], count_regex, args.time_limit)
+    if should_run("byteset-forward/stringzilla.Str.find_first_of()", filter_pattern):
+        bench_op("stringzilla.Str.find_first_of()", stringzilla_str, [sz_chars], count_byteset, args.time_limit)
 
     return 0
 

bench_fingerprints.rs

@@ -46,7 +46,6 @@ RUSTFLAGS="-C target-cpu=native" \
 
 use core::convert::TryInto;
 use std::collections::hash_map::DefaultHasher;
-use std::env;
 use std::hash::{Hash, Hasher};
 
 use criterion::{Criterion, Throughput};
@@ -60,8 +59,8 @@ use stringzilla::szs::{AnyBytesTape, DeviceScope, Fingerprints, UnifiedAlloc, Un
 
 mod utils;
 use utils::{
-    install_panic_hook, load_dataset, set_fingerprints_bytes_per_hash, should_run, HashesWallTime,
-    ResultExt,
+    get_env_parsed, install_panic_hook, load_dataset, set_fingerprints_bytes_per_hash, should_run,
+    HashesWallTime, ResultExt,
 };
 
 // Fixed n-gram widths for multi-scale fingerprinting
@@ -181,20 +180,8 @@ fn bench_fingerprints(c: &mut Criterion<HashesWallTime>) {
         .as_chars()
         .expect("Dataset must be valid UTF-8 for fingerprinting");
 
-    let batch_size = env::var("STRINGWARS_BATCH")
-        .unwrap_or_else(|_| "1024".to_string())
-        .parse::<usize>()
-        .unwrap_or_else(|e| {
-            panic!(
-                "STRINGWARS_BATCH must be a valid number for fingerprinting benchmarks: {}",
-                e
-            )
-        });
-
-    let ndim = env::var("STRINGWARS_NDIM")
-        .ok()
-        .and_then(|v| v.parse::<usize>().ok())
-        .unwrap_or(256);
+    let batch_size: usize = get_env_parsed("STRINGWARS_BATCH", 1024);
+    let ndim: usize = get_env_parsed("STRINGWARS_NDIM", 256);
 
     if batch_size == 0 {
         panic!("STRINGWARS_BATCH must be greater than zero for fingerprinting benchmarks.");
@@ -314,9 +301,9 @@ fn bench_fingerprints(c: &mut Criterion<HashesWallTime>) {
     min_counts.resize(batch_size * ndim, 0);
 
     // StringZilla: 1x CPU
-    if should_run("fingerprinting/stringzillas::Fingerprints(1xCPU)") {
+    if should_run("fingerprinting/stringzillas/Fingerprints(1xCPU)") {
         g.throughput(Throughput::Elements(per_batch_hash_ops));
-        g.bench_function("stringzillas::Fingerprints(1xCPU)", |b| {
+        g.bench_function("stringzillas/Fingerprints(1xCPU)", |b| {
             start_idx = 0;
             b.iter(|| {
                 let (batch_bytes_view, _batch_chars_view, actual) = tokens_tape_slice(
@@ -350,12 +337,12 @@ fn bench_fingerprints(c: &mut Criterion<HashesWallTime>) {
 
     // StringZilla: Nx CPU
     if should_run(&format!(
-        "fingerprinting/stringzillas::Fingerprints({}xCPU)",
+        "fingerprinting/stringzillas/Fingerprints({}xCPU)",
         num_cores
     )) {
         g.throughput(Throughput::Elements(per_batch_hash_ops));
         g.bench_function(
-            &format!("stringzillas::Fingerprints({}xCPU)", num_cores),
+            &format!("stringzillas/Fingerprints({}xCPU)", num_cores),
             |b| {
                 start_idx = 0;
                 b.iter(|| {
@@ -407,9 +394,9 @@ fn bench_fingerprints(c: &mut Criterion<HashesWallTime>) {
 
     // StringZilla: 1x GPU (if available)
     if let (Ok(gpu), Some(engine)) = (maybe_gpu.as_ref(), maybe_sz_gpu.as_ref()) {
-        if should_run("fingerprinting/stringzillas::Fingerprints(1xGPU)") {
+        if should_run("fingerprinting/stringzillas/Fingerprints(1xGPU)") {
             g.throughput(Throughput::Elements(per_batch_hash_ops));
-            g.bench_function("stringzillas::Fingerprints(1xGPU)", |b| {
+            g.bench_function("stringzillas/Fingerprints(1xGPU)", |b| {
                 start_idx = 0;
                 b.iter(|| {
                     let (batch_bytes_view, _batch_chars_view, actual) = tokens_tape_slice(
@@ -451,9 +438,9 @@ fn bench_fingerprints(c: &mut Criterion<HashesWallTime>) {
     let mut out = Vec::with_capacity(batch_size);
     let mut combined_signature = Vec::with_capacity(ndim);
 
-    if should_run("fingerprinting/pc::MinHash<ByteGrams>") {
+    if should_run("fingerprinting/pc/MinHash<ByteGrams>()") {
         g.throughput(Throughput::Elements(per_batch_hash_ops));
-        g.bench_function("pc::MinHash<ByteGrams>", |b| {
+        g.bench_function("pc/MinHash<ByteGrams>()", |b| {
             start_idx = 0;
             b.iter(|| {
                 let (batch_bytes_view, _batch_chars_view, actual) = tokens_tape_slice(
@@ -500,9 +487,9 @@ fn bench_fingerprints(c: &mut Criterion<HashesWallTime>) {
 
     // Serial MinHash baseline implementing correct independent hash functions
     // This addresses the flaw in probabilistic_collections where hash function index is ignored
-    if should_run("fingerprinting/serial::MinHash<ByteGrams>") {
+    if should_run("fingerprinting/serial/MinHash<ByteGrams>()") {
         g.throughput(Throughput::Elements(per_batch_hash_ops));
-        g.bench_function("serial::MinHash<ByteGrams>", |b| {
+        g.bench_function("serial/MinHash<ByteGrams>()", |b| {
             // Pre-construct hash parameters for independent universal hash functions
             // Each hash function uses: hash_i(x) = (a_i * hash(x) + b_i) mod mersenne_prime
 

bench_hash.py

@@ -114,34 +114,34 @@ def run_stateless_benchmarks(
     print("\n=== Stateless Hash Benchmarks ===")
 
     # Python built-in hash
-    if should_run("hash", filter_pattern):
-        bench_hash_function("hash", tokens, lambda x: hash(x), time_limit_seconds)
+    if should_run("stateless/std.hash()", filter_pattern):
+        bench_hash_function("std.hash()", tokens, lambda x: hash(x), time_limit_seconds)
 
     # xxHash
-    if should_run("xxhash.xxh3_64", filter_pattern):
-        bench_hash_function("xxhash.xxh3_64", tokens, lambda x: xxhash.xxh3_64(x).intdigest(), time_limit_seconds)
+    if should_run("stateless/xxhash.xxh3_64()", filter_pattern):
+        bench_hash_function("xxhash.xxh3_64()", tokens, lambda x: xxhash.xxh3_64(x).intdigest(), time_limit_seconds)
 
     # StringZilla hashes
-    if should_run("stringzilla.hash", filter_pattern):
-        bench_hash_function("stringzilla.hash", tokens, lambda x: sz.hash(x), time_limit_seconds)
+    if should_run("stateless/stringzilla.hash()", filter_pattern):
+        bench_hash_function("stringzilla.hash()", tokens, lambda x: sz.hash(x), time_limit_seconds)
 
     # Google CRC32C (Castagnoli) one-shot
-    if should_run("google_crc32c.value", filter_pattern):
-        bench_hash_function("google_crc32c.value", tokens, lambda x: google_crc32c.value(x), time_limit_seconds)
+    if should_run("stateless/google_crc32c.value()", filter_pattern):
+        bench_hash_function("google_crc32c.value()", tokens, lambda x: google_crc32c.value(x), time_limit_seconds)
 
     # MurmurHash3 — stateless
-    if should_run("mmh3.hash32", filter_pattern):
-        bench_hash_function("mmh3.hash32", tokens, lambda x: mmh3.hash(x, signed=False), time_limit_seconds)
-    if should_run("mmh3.hash64", filter_pattern):
-        bench_hash_function("mmh3.hash64", tokens, lambda x: mmh3.hash64(x, signed=False)[0], time_limit_seconds)
-    if should_run("mmh3.hash128", filter_pattern):
-        bench_hash_function("mmh3.hash128", tokens, lambda x: mmh3.hash128(x, signed=False), time_limit_seconds)
+    if should_run("stateless/mmh3.hash32()", filter_pattern):
+        bench_hash_function("mmh3.hash32()", tokens, lambda x: mmh3.hash(x, signed=False), time_limit_seconds)
+    if should_run("stateless/mmh3.hash64()", filter_pattern):
+        bench_hash_function("mmh3.hash64()", tokens, lambda x: mmh3.hash64(x, signed=False)[0], time_limit_seconds)
+    if should_run("stateless/mmh3.hash128()", filter_pattern):
+        bench_hash_function("mmh3.hash128()", tokens, lambda x: mmh3.hash128(x, signed=False), time_limit_seconds)
 
     # CityHash — stateless
-    if should_run("cityhash.CityHash64", filter_pattern):
-        bench_hash_function("cityhash.CityHash64", tokens, lambda x: cityhash.CityHash64(x), time_limit_seconds)
-    if should_run("cityhash.CityHash128", filter_pattern):
-        bench_hash_function("cityhash.CityHash128", tokens, lambda x: cityhash.CityHash128(x), time_limit_seconds)
+    if should_run("stateless/cityhash.CityHash64()", filter_pattern):
+        bench_hash_function("cityhash.CityHash64()", tokens, lambda x: cityhash.CityHash64(x), time_limit_seconds)
+    if should_run("stateless/cityhash.CityHash128()", filter_pattern):
+        bench_hash_function("cityhash.CityHash128()", tokens, lambda x: cityhash.CityHash128(x), time_limit_seconds)
 
 
 def bench_stateful_hash(
@@ -189,16 +189,16 @@ def run_stateful_benchmarks(
     print("\n=== Stateful Hash Benchmarks ===")
 
     # xxHash stateful
-    if should_run("xxhash.xxh3_64", filter_pattern):
-        bench_stateful_hash("xxhash.xxh3_64", tokens, lambda: xxhash.xxh3_64(), time_limit_seconds)
+    if should_run("stateful/xxhash.xxh3_64()", filter_pattern):
+        bench_stateful_hash("xxhash.xxh3_64()", tokens, lambda: xxhash.xxh3_64(), time_limit_seconds)
 
     # StringZilla stateful hasher
-    if should_run("stringzilla.Hasher", filter_pattern):
-        bench_stateful_hash("stringzilla.Hasher", tokens, lambda: sz.Hasher(), time_limit_seconds)
+    if should_run("stateful/stringzilla.Hasher()", filter_pattern):
+        bench_stateful_hash("stringzilla.Hasher()", tokens, lambda: sz.Hasher(), time_limit_seconds)
 
     # Google CRC32C (Castagnoli) stateful
-    if should_run("google_crc32c.Checksum", filter_pattern):
-        bench_stateful_hash("google_crc32c.Checksum", tokens, lambda: google_crc32c.Checksum(), time_limit_seconds)
+    if should_run("stateful/google_crc32c.Checksum()", filter_pattern):
+        bench_stateful_hash("google_crc32c.Checksum()", tokens, lambda: google_crc32c.Checksum(), time_limit_seconds)
 
 
 def run_checksum_benchmarks(
@@ -210,20 +210,20 @@ def run_checksum_benchmarks(
     print("\n=== Checksum Hash Benchmarks ===")
 
     # StringZilla bytesum - reference lower bound
-    if should_run("stringzilla.bytesum", filter_pattern):
-        bench_hash_function("stringzilla.bytesum", tokens, lambda x: sz.bytesum(x), time_limit_seconds)
+    if should_run("checksum/stringzilla.bytesum()", filter_pattern):
+        bench_hash_function("stringzilla.bytesum()", tokens, lambda x: sz.bytesum(x), time_limit_seconds)
 
     # Blake3 - cryptographic hash
-    if should_run("blake3.digest", filter_pattern):
-        bench_hash_function("blake3.digest", tokens, lambda x: blake3.blake3(x).digest(), time_limit_seconds)
+    if should_run("checksum/blake3.blake3()", filter_pattern):
+        bench_hash_function("blake3.blake3()", tokens, lambda x: blake3.blake3(x).digest(), time_limit_seconds)
 
     # SHA256 via hashlib (Python standard library)
-    if should_run("hashlib.sha256", filter_pattern):
-        bench_hash_function("hashlib.sha256", tokens, lambda x: hashlib.sha256(x).digest(), time_limit_seconds)
+    if should_run("checksum/hashlib.sha256()", filter_pattern):
+        bench_hash_function("hashlib.sha256()", tokens, lambda x: hashlib.sha256(x).digest(), time_limit_seconds)
 
     # SHA256 via StringZilla
-    if should_run("stringzilla.Sha256", filter_pattern):
-        bench_hash_function("stringzilla.Sha256", tokens, lambda x: sz.Sha256().update(x).digest(), time_limit_seconds)
+    if should_run("checksum/stringzilla.Sha256()", filter_pattern):
+        bench_hash_function("stringzilla.Sha256()", tokens, lambda x: sz.Sha256().update(x).digest(), time_limit_seconds)
 
 
 _main_epilog = """