Improve: Filtering by name

Author: ashvardanian

.gitignore

@@ -1,4 +1,8 @@
+# Builds
 /target
+/__pycache__
+
+# Datasets
 /acgt_*.txt
 /xlsum.csv
 /leipzig1M.txt

bench_find.py

@@ -32,7 +32,7 @@
 import stringzilla as sz
 import ahocorasick as ahoc
 
-from utils import load_dataset, tokenize_dataset, add_common_args, now_ns, name_matches
+from utils import load_dataset, tokenize_dataset, add_common_args, now_ns, should_run
 
 
 def log_system_info():
@@ -173,15 +173,15 @@ def main():
     log_system_info()
 
     print("\n=== Substring Search Benchmarks ===")
-    if name_matches("str.find", filter_pattern):
+    if should_run("str.find", filter_pattern):
         bench_op("str.find", pythonic_str, tokens[::-1], count_find, args.time_limit)
-    if name_matches("stringzilla.Str.find", filter_pattern):
+    if should_run("stringzilla.Str.find", filter_pattern):
         bench_op("stringzilla.Str.find", stringzilla_str, tokens[::-1], count_find, args.time_limit)
-    if name_matches("str.rfind", filter_pattern):
+    if should_run("str.rfind", filter_pattern):
         bench_op("str.rfind", pythonic_str, tokens, count_rfind, args.time_limit)
-    if name_matches("stringzilla.Str.rfind", filter_pattern):
+    if should_run("stringzilla.Str.rfind", filter_pattern):
         bench_op("stringzilla.Str.rfind", stringzilla_str, tokens, count_rfind, args.time_limit)
-    if name_matches("pyahocorasick.iter", filter_pattern):
+    if should_run("pyahocorasick.iter", filter_pattern):
         bench_op("pyahocorasick.iter", pythonic_str, tokens[::-1], count_aho, args.time_limit)
 
     print("\n=== Character Set Search ===")
@@ -191,9 +191,9 @@ def main():
     else:
         re_chars = re.compile(r"[\t\n\r ]")  # whitespace: space, tab, LF, CR
         sz_chars = " \t\n\r"
-    if name_matches("re.finditer", filter_pattern):
+    if should_run("re.finditer", filter_pattern):
         bench_op("re.finditer", pythonic_str, [re_chars], count_regex, args.time_limit)
-    if name_matches("stringzilla.Str.find_first_of", filter_pattern):
+    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)
 
     return 0

bench_fingerprints.py

@@ -37,7 +37,7 @@
 import stringzillas as szs
 import stringzilla as sz
 
-from utils import load_dataset, tokenize_dataset, add_common_args, now_ns, name_matches
+from utils import load_dataset, tokenize_dataset, add_common_args, now_ns, should_run
 
 # For RAPIDS cuDF GPU-accelerated MinHash
 try:

bench_fingerprints.rs

@@ -49,7 +49,7 @@ use stringzilla::szs::{capabilities as szs_capabilities, version as szs_version}
 use stringzilla::szs::{AnyBytesTape, DeviceScope, Fingerprints, UnifiedAlloc, UnifiedVec};
 
 mod utils;
-use utils::{set_fingerprints_bytes_per_hash, HashesWallTime, should_run_benchmark};
+use utils::{set_fingerprints_bytes_per_hash, should_run, HashesWallTime};
 
 // Fixed n-gram widths for multi-scale fingerprinting
 const NGRAM_WIDTHS: [usize; 4] = [5, 9, 17, 33];

bench_hash.py

@@ -48,7 +48,7 @@
 import mmh3
 import cityhash
 
-from utils import load_dataset, tokenize_dataset, add_common_args, now_ns, name_matches
+from utils import load_dataset, tokenize_dataset, add_common_args, now_ns, should_run
 
 
 def log_system_info():
@@ -112,40 +112,40 @@ def run_stateless_benchmarks(
     print("\n=== Stateless Hash Benchmarks ===")
 
     # Python built-in hash
-    if name_matches("hash", filter_pattern):
+    if should_run("hash", filter_pattern):
         bench_hash_function("hash", tokens, lambda x: hash(x), time_limit_seconds)
 
     # xxHash
-    if name_matches("xxhash.xxh3_64", filter_pattern):
+    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)
 
     # StringZilla hashes
-    if name_matches("stringzilla.hash", filter_pattern):
+    if should_run("stringzilla.hash", filter_pattern):
         bench_hash_function("stringzilla.hash", tokens, lambda x: sz.hash(x), time_limit_seconds)
 
     # Google CRC32C (Castagnoli) one-shot
-    if name_matches("google_crc32c.value", filter_pattern):
+    if should_run("google_crc32c.value", filter_pattern):
         bench_hash_function("google_crc32c.value", tokens, lambda x: google_crc32c.value(x), time_limit_seconds)
 
     # MurmurHash3 — stateless
-    if name_matches("mmh3.hash32", filter_pattern):
+    if should_run("mmh3.hash32", filter_pattern):
         bench_hash_function("mmh3.hash32", tokens, lambda x: mmh3.hash(x, signed=False), time_limit_seconds)
-    if name_matches("mmh3.hash64", filter_pattern):
+    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 name_matches("mmh3.hash128", filter_pattern):
+    if should_run("mmh3.hash128", filter_pattern):
         bench_hash_function("mmh3.hash128", tokens, lambda x: mmh3.hash128(x, signed=False), time_limit_seconds)
 
     # CityHash — stateless
-    if name_matches("cityhash.CityHash64", filter_pattern):
+    if should_run("cityhash.CityHash64", filter_pattern):
         bench_hash_function("cityhash.CityHash64", tokens, lambda x: cityhash.CityHash64(x), time_limit_seconds)
-    if name_matches("cityhash.CityHash128", filter_pattern):
+    if should_run("cityhash.CityHash128", filter_pattern):
         bench_hash_function("cityhash.CityHash128", tokens, lambda x: cityhash.CityHash128(x), time_limit_seconds)
 
     # Reference bounds
-    if name_matches("blake3.digest", filter_pattern):
+    if should_run("blake3.digest", filter_pattern):
         bench_hash_function("blake3.digest", tokens, lambda x: blake3.blake3(x).digest(), time_limit_seconds)
 
-    if name_matches("stringzilla.bytesum", filter_pattern):
+    if should_run("stringzilla.bytesum", filter_pattern):
         bench_hash_function("stringzilla.bytesum", tokens, lambda x: sz.bytesum(x), time_limit_seconds)
 
 
@@ -194,15 +194,15 @@ def run_stateful_benchmarks(
     print("\n=== Stateful Hash Benchmarks ===")
 
     # xxHash stateful
-    if name_matches("xxhash.xxh3_64", filter_pattern):
+    if should_run("xxhash.xxh3_64", filter_pattern):
         bench_stateful_hash("xxhash.xxh3_64", tokens, lambda: xxhash.xxh3_64(), time_limit_seconds)
 
     # StringZilla stateful hasher
-    if name_matches("stringzilla.Hasher", filter_pattern):
+    if should_run("stringzilla.Hasher", filter_pattern):
         bench_stateful_hash("stringzilla.Hasher", tokens, lambda: sz.Hasher(), time_limit_seconds)
 
     # Google CRC32C (Castagnoli) stateful
-    if name_matches("google_crc32c.Checksum", filter_pattern):
+    if should_run("google_crc32c.Checksum", filter_pattern):
         bench_stateful_hash("google_crc32c.Checksum", tokens, lambda: google_crc32c.Checksum(), time_limit_seconds)
 
 

bench_memory.py

@@ -31,7 +31,7 @@
 from Crypto.Cipher import AES as PyCryptoDomeAES
 import cv2
 
-from utils import add_common_args, load_dataset, name_matches, now_ns, tokenize_dataset
+from utils import add_common_args, load_dataset, should_run, now_ns, tokenize_dataset
 
 
 def log_system_info():
@@ -258,55 +258,55 @@ def main() -> int:
     tokens_mv = [memoryview(bytearray(token)) for token in tokens_b]
 
     # Python bytes.translate (always allocating)
-    if name_matches("bytes.translate(new)", pattern):
+    if should_run("bytes.translate(new)", pattern):
         bench_translate("bytes.translate(new)", tokens_b, reverse, bytes_translate, args.time_limit)
 
     # OpenCV allocating
-    if name_matches("opencv.LUT(new)", pattern):
+    if should_run("opencv.LUT(new)", pattern):
         bench_translate("opencv.LUT(new)", tokens_np, reverse_np, opencv_lut_allocating, args.time_limit)
 
     # OpenCV in-place
-    if name_matches("opencv.LUT(inplace)", pattern):
+    if should_run("opencv.LUT(inplace)", pattern):
         bench_translate("opencv.LUT(inplace)", tokens_np, reverse_np, opencv_lut_inplace, args.time_limit)
 
     # NumPy indexing allocating
-    if name_matches("numpy.indexing(new)", pattern):
+    if should_run("numpy.indexing(new)", pattern):
         bench_translate("numpy.indexing(new)", tokens_np, reverse_np, numpy_lut_indexing_allocating, args.time_limit)
 
     # NumPy indexing in-place
-    if name_matches("numpy.indexing(inplace)", pattern):
+    if should_run("numpy.indexing(inplace)", pattern):
         bench_translate("numpy.indexing(inplace)", tokens_np, reverse_np, numpy_lut_indexing_inplace, args.time_limit)
 
     # NumPy take allocating
-    if name_matches("numpy.take(new)", pattern):
+    if should_run("numpy.take(new)", pattern):
         bench_translate("numpy.take(new)", tokens_np, reverse_np, numpy_lut_take_allocating, args.time_limit)
 
     # NumPy take in-place
-    if name_matches("numpy.take(inplace)", pattern):
+    if should_run("numpy.take(inplace)", pattern):
         bench_translate("numpy.take(inplace)", tokens_np, reverse_np, numpy_lut_take_inplace, args.time_limit)
 
     # StringZilla allocating
-    if name_matches("stringzilla.translate(new)", pattern):
+    if should_run("stringzilla.translate(new)", pattern):
         bench_translate("stringzilla.translate(new)", tokens_b, reverse, sz_translate_allocating, args.time_limit)
 
     # StringZilla in-place (need memoryviews for each token)
-    if name_matches("stringzilla.translate(inplace)", pattern):
+    if should_run("stringzilla.translate(inplace)", pattern):
         bench_translate("stringzilla.translate(inplace)", tokens_mv, reverse, sz_translate_inplace, args.time_limit)
 
     # ---------------- Random byte generation ----------------
     print()
     print("--- Random Byte Generation ---")
     sizes = sizes_from_tokens(tokens_b)
 
-    if name_matches("pycryptodome.AES-CTR", pattern):
+    if should_run("pycryptodome.AES-CTR", pattern):
         bench_generator("pycryptodome.AES-CTR", sizes, make_pycryptodome_aes_ctr(), args.time_limit)
-    if name_matches("stringzilla.fill_random", pattern):
+    if should_run("stringzilla.fill_random", pattern):
         bench_generator("stringzilla.fill_random", sizes, make_stringzilla_fill_random(), args.time_limit)
-    if name_matches("stringzilla.random", pattern):
+    if should_run("stringzilla.random", pattern):
         bench_generator("stringzilla.random", sizes, sz.random, args.time_limit)
-    if name_matches("numpy.PCG64", pattern):
+    if should_run("numpy.PCG64", pattern):
         bench_generator("numpy.PCG64", sizes, make_numpy_pcg64(), args.time_limit)
-    if name_matches("numpy.Philox", pattern):
+    if should_run("numpy.Philox", pattern):
         bench_generator("numpy.Philox", sizes, make_numpy_philox(), args.time_limit)
 
     return 0

bench_sequence.py

@@ -49,7 +49,7 @@
     # cuDF sorts run on GPU; nothing to set for CPU threads here
     pass
 
-from utils import load_dataset, tokenize_dataset, add_common_args, now_ns, name_matches
+from utils import load_dataset, tokenize_dataset, add_common_args, now_ns, should_run
 
 
 def log_system_info():
@@ -134,22 +134,22 @@ def main():
     print("\n=== Sort Benchmarks ===")
 
     # Python list.sort
-    if name_matches("list.sort", filter_pattern):
+    if should_run("list.sort", filter_pattern):
         py_list = list(tokens)
         bench_sort_operation("list.sort", lambda: py_list.sort(), len(tokens))
 
     # StringZilla
-    if name_matches("stringzilla.Strs.sorted", filter_pattern):
+    if should_run("stringzilla.Strs.sorted", filter_pattern):
         sz_strs = sz.Strs(tokens)
         bench_sort_operation("stringzilla.Strs.sorted", lambda: sz_strs.sorted(), len(tokens))
 
     # Pandas
-    if name_matches("pandas.Series.sort_values", filter_pattern):
+    if should_run("pandas.Series.sort_values", filter_pattern):
         s = pd.Series(tokens)
         bench_sort_operation("pandas.Series.sort_values", lambda: s.sort_values(ignore_index=True), len(tokens))
 
     # PyArrow
-    if name_matches("pyarrow.compute.sort_indices", filter_pattern):
+    if should_run("pyarrow.compute.sort_indices", filter_pattern):
         # Choose Arrow string type without timing the conversion
         INT32_MAX = 2_147_483_647
         total_bytes = 0
@@ -167,12 +167,12 @@ def _pa_sort_call():
         bench_sort_operation("pyarrow.compute.sort_indices", _pa_sort_call, len(tokens))
 
     # Polars
-    if name_matches("polars.Series.sort", filter_pattern):
+    if should_run("polars.Series.sort", filter_pattern):
         ps = pl.Series(tokens)
         bench_sort_operation("polars.Series.sort", lambda: ps.sort(), len(tokens))
 
     # cuDF GPU (if available)
-    if CUDF_AVAILABLE and name_matches("cudf.Series.sort_values", filter_pattern):
+    if CUDF_AVAILABLE and should_run("cudf.Series.sort_values", filter_pattern):
         cs = cudf.Series(tokens)
         bench_sort_operation("cudf.Series.sort_values", lambda: cs.sort_values(ignore_index=True), len(tokens))