hashcodecs 1.2.1__tar.gz → 1.3.0__tar.gz

{hashcodecs-1.2.1 → hashcodecs-1.3.0}/BENCHMARK.md

@@ -6,7 +6,7 @@ Pin one logical CPU. Run each case in one thread. Collect 50 Rust samples and 15
 baseline with AVX2, the backend that hashcodecs selects on this host. Higher throughput wins.
 
 Build the Python wheel with CPython 3.12 and the full C API. Keep competitor values from the latest comparison run.
-Use `uv run python benchmarks/render_charts.py` to render the charts. Read exact values in
+Use `uv run --python 3.12 --no-project python benchmarks/render_charts.py` to render the charts. Read exact values in
 [docs/benchmarks/results.csv](docs/benchmarks/results.csv).
 
 ## Timing Controls
@@ -16,12 +16,16 @@ sampling time per case is at least their product, plus calibration; use lower va
 hashcodecs-only pass, use `--hashcodecs-only --samples 3 --minimum-sample-seconds 0.05` with each Python benchmark
 script.
 
+Each Rust Criterion harness collects 50 samples per case. Pass Criterion's `--sample-size` option for an exploratory
+run with a different count.
+
 ## Python Call Costs
 
 Run `python benchmarks/python_calls.py` to measure positional calls from 0 through 256 bytes in nanoseconds per
 call. Use `--keywords` for positional and keyword calls at 64 bytes, or `--thresholds` for latency around the
 GIL-detachment cutoffs. The `--thread-scaling` mode measures aggregate throughput with one, two, and four threads;
-it does not pin the process to one logical CPU.
+it does not pin the process to one logical CPU. Use `--buffer-inputs` to compare 64-byte and 4 KiB XXH3-64 calls
+across bytes, full and sliced memoryviews, writable and non-contiguous views, and `array('B')`.
 
 ## XXH3
 
@@ -30,10 +34,15 @@ For Python, run the upstream `xxhash` extension beside hashcodecs. Pass 32 equal
 The Rust remainder cases pass two or three equal-size long inputs. Run Python remainder cases with
 `python benchmarks/python_xxhash.py --batch-counts 2 3`.
 
+The Rust mixed benchmarks use `[1024, 1024, 4096, 4096]`, `[240, 240, 241, 241]`, and the reverse boundary order.
+The 1024/4096 case measures adjacent two-item long runs. The 240/241 cases measure both orders across the
+short/long dispatch boundary.
+
 Use the focused one-shot run to cover the AVX2 four-chain boundaries:
 
 ```sh
-cargo bench --bench xxhash -- --sample-size 50 "xxh3_(64|128)/(241|512|768|1024|1536|2048|4096)/hashcodecs"
+cargo bench --manifest-path benches/Cargo.toml --bench xxhash -- "xxh3_(64|128)/(240|241|512|768|1024|1536|2048|4096)/hashcodecs"
+cargo bench --manifest-path benches/Cargo.toml --bench xxhash -- "xxh3_batch/mixed/.*/hashcodecs_(64|128)"
 ```
 
 [![Rust XXH3 throughput](docs/benchmarks/xxh3-rust.svg)](docs/benchmarks/xxh3-rust.svg)
@@ -57,9 +66,10 @@ noisy cases insert `!` at the same boundaries. Both cases measure returned bytes
 
 ## Python Memoryview Inputs
 
-Use `--memoryview-input` for full immutable views and `--sliced-memoryview-input` for equal-length views with a
-nonzero starting offset. The latter covers the copy/stabilization path used by slices while keeping the encoded data
-identical.
+Use `--memoryview-input` for full immutable views and `--sliced-memoryview-input` for equal-length contiguous views
+with a nonzero starting offset. Full views can recover their exact immutable owner at detachment sizes; slices cover
+offset-buffer handling, which borrows under the GIL and stabilizes the input in free-threaded builds. The encoded data
+remains identical.
 
 [![Python Base64 memoryview inputs](docs/benchmarks/base64-python-memoryview.svg)](docs/benchmarks/base64-python-memoryview.svg)
 
@@ -76,6 +86,15 @@ into a decode investigation:
 python benchmarks/python_base64_batch.py --item-sizes 4096 --batch-sizes 512 768 1024 1280 2048 --decode-only
 ```
 
+Add `--memoryview-input` to wrap every matrix input in an exact memoryview. This mode compares independent views
+against the matching one-item loops and reusable-output paths.
+
+[![Python Base64 memoryview batch throughput](docs/benchmarks/base64-python-batch-memoryview.svg)](docs/benchmarks/base64-python-batch-memoryview.svg)
+
+```sh
+python benchmarks/python_base64_batch.py --item-sizes 1048576 --batch-sizes 8 --memoryview-input --decode-only
+```
+
 Use a single operation when recording a sampling profile, or compare traced allocations without a sampler:
 
 ```sh
@@ -118,3 +137,27 @@ Pass `bytearray` inputs to the Base64 API.
 Pass `bytearray` inputs to the MurmurHash3 API.
 
 [![Mutable Python MurmurHash3 inputs](docs/benchmarks/murmur3-python-mutable.svg)](docs/benchmarks/murmur3-python-mutable.svg)
+
+## Reproduction
+
+Run the benchmark
+
+```
+uv sync --python 3.12 --frozen --group benchmark --no-install-project
+
+uv run --python 3.12 --refresh-package hashcodecs --no-project --with . --with mmh3==5.2.1 --with pybase64==1.4.3 --with xxhash==3.8.1 python benchmarks/python_base64.py --hashcodecs-only
+
+uv run --python 3.12 --refresh-package hashcodecs --no-project --with . --with mmh3==5.2.1 --with pybase64==1.4.3 --with xxhash==3.8.1 python benchmarks/python_base64_batch.py --hashcodecs-only
+
+uv run --python 3.12 --refresh-package hashcodecs --no-project --with . --with mmh3==5.2.1 --with pybase64==1.4.3 --with xxhash==3.8.1 python benchmarks/python_murmur3.py --hashcodecs-only
+
+uv run --python 3.12 --refresh-package hashcodecs --no-project --with . --with mmh3==5.2.1 --with pybase64==1.4.3 --with xxhash==3.8.1 python benchmarks/python_murmur3.py --hashcodecs-only --incremental
+
+uv run --python 3.12 --refresh-package hashcodecs --no-project --with . --with mmh3==5.2.1 --with pybase64==1.4.3 --with xxhash==3.8.1 python benchmarks/python_xxhash.py --hashcodecs-only
+```
+
+Update the documentation
+
+```
+uv run --python 3.12 --no-project python benchmarks/render_charts.py
+```

{hashcodecs-1.2.1 → hashcodecs-1.3.0}/CHANGELOG.md

@@ -4,6 +4,43 @@ This file records notable user-facing changes to `hashcodecs`. Version 1.0.0 sta
 
 ## [Unreleased]
 
+## [1.3.0] - 2026-09-04
+
+### What's Changed
+* chore: expand XXH3 benchmark coverage by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/61
+* refactor: split Base64 decoder bindings by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/62
+* refactor: declare Base64 binding schema by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/63
+* perf: inspect exact CPython memoryviews directly by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/64
+* refactor: avoid copying Base64 fallback inputs by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/65
+* chore: strengthen runtime coverage and benchmarks by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/66
+* fix: avoid unnecessary batch snapshots and scalar grouping by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/67
+* refactor: generate Base64 binding metadata by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/68
+* perf: remove advanced decode and batch allocations by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/69
+* refactor: finish native codec cleanup by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/70
+* chore: verify source distributions in CI by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/71
+* fix: stabilize aliased Base64 decode inputs by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/72
+* perf: remove Python batch input copies by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/73
+* fix: use strict fast paths for decode-into by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/74
+* refactor: streamline native bindings and benchmarks by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/75
+* fix: restore XXH fast paths and wheel compatibility by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/76
+* refactor: use four-lane AArch64 XXH3 accumulation by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/77
+* refactor: clarify internal names and technical prose by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/78
+* fix: restore Base64 batch encode throughput by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/79
+* refactor: clarify internal naming by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/80
+* refactor: simplify internal decode and dispatch paths by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/81
+* fix: harden hashers and optimize codec paths by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/82
+* refactor: centralize Python Base64 decode routing by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/83
+* refactor: standardize Rust callback and input names by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/84
+* refactor: clarify codec routing and CPU capabilities by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/85
+* refactor: consolidate base64 batch ownership by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/86
+* refactor: reduce XXH3 dispatch overhead by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/87
+* Fix Base64 batch alias stabilization and AVX2 streaming stores by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/88
+* fix: restore Base64 encode fast paths by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/89
+* fix: restore Base64 memoryview batch throughput by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/90
+
+
+**Full Changelog**: https://github.com/kozistr/hashcodecs-rs/compare/v1.2.1...v1.3.0
+
 ## [1.2.1] - 2026-08-26
 
 ### What's Changed
@@ -127,7 +164,8 @@ This file records notable user-facing changes to `hashcodecs`. Version 1.0.0 sta
 - Initial Python and Rust APIs for Base64 and MurmurHash3.
 - Runtime SIMD dispatch and platform-specific CPython wheels.
 
-[Unreleased]: https://github.com/kozistr/hashcodecs-rs/compare/v1.2.1...HEAD
+[Unreleased]: https://github.com/kozistr/hashcodecs-rs/compare/v1.3.0...HEAD
+[1.3.0]: https://github.com/kozistr/hashcodecs-rs/compare/v1.2.1...v1.3.0
 [1.2.1]: https://github.com/kozistr/hashcodecs-rs/compare/v1.2.0...v1.2.1
 [1.2.0]: https://github.com/kozistr/hashcodecs-rs/compare/v1.1.0...v1.2.0
 [1.1.0]: https://github.com/kozistr/hashcodecs-rs/compare/v1.0.0...v1.1.0

{hashcodecs-1.2.1 → hashcodecs-1.3.0}/CITATION.cff

@@ -5,8 +5,8 @@ authors:
     given-names: Hyeongchan
     orcid: https://orcid.org/0000-0002-1729-0580
 title: "hashcodecs: SIMD-accelerated Base64, MurmurHash3, and XXH3 for Python and Rust"
-version: 1.2.1
-date-released: 2026-08-26
+version: 1.3.0
+date-released: 2026-09-04
 license: "MIT OR Apache-2.0"
 repository-code: "https://github.com/kozistr/hashcodecs-rs"
 url: "https://github.com/kozistr/hashcodecs-rs"

{hashcodecs-1.2.1 → hashcodecs-1.3.0}/Cargo.lock

@@ -194,21 +194,32 @@ dependencies = [
 
 [[package]]
 name = "hashcodecs"
-version = "1.2.1"
+version = "1.3.0"
+dependencies = [
+ "base64",
+ "memchr",
+ "mimalloc",
+ "murmur3",
+ "pyo3",
+ "pyo3-build-config",
+ "xxhash-c-sys",
+ "xxhash-rust",
+]
+
+[[package]]
+name = "hashcodecs-benchmarks"
+version = "0.0.0"
 dependencies = [
  "base64",
  "base64-turbo",
  "criterion",
  "fastmurmur3",
- "memchr",
+ "hashcodecs",
  "mimalloc",
  "mm3h",
  "murmur3",
  "murmurs",
- "pyo3",
- "pyo3-build-config",
  "xxhash-c-sys",
- "xxhash-rust",
 ]
 
 [[package]]

{hashcodecs-1.2.1 → hashcodecs-1.3.0}/Cargo.toml

@@ -1,8 +1,9 @@
 [package]
 name = "hashcodecs"
-version = "1.2.1"
+version = "1.3.0"
 edition = "2024"
 rust-version = "1.89"
+autobenches = false
 description = "SIMD-accelerated Base64 codecs and fast MurmurHash3 and xxHash implementations"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/kozistr/hashcodecs-rs"
@@ -19,6 +20,11 @@ include = [
     "/LICENSE-MIT",
 ]
 
+[workspace]
+members = [".", "benches"]
+default-members = ["."]
+resolver = "3"
+
 [lib]
 name = "hashcodecs"
 crate-type = ["rlib", "cdylib"]
@@ -37,28 +43,10 @@ pyo3-build-config = { version = "0.29.2", optional = true }
 
 [dev-dependencies]
 base64 = "=0.23.1"
-base64-turbo = "=0.3.0"
-criterion = { version = "=0.8.2", default-features = false, features = ["cargo_bench_support"] }
-fastmurmur3 = "=0.2.0"
-mimalloc = "=0.1.52"
-mm3h = "=0.1.3"
 murmur3 = "=0.5.2"
-murmurs = "=1.0.5"
 xxhash-c-sys = "=0.8.7"
 xxhash-rust = { version = "=0.8.18", features = ["xxh3"] }
 
-[[bench]]
-name = "base64"
-harness = false
-
-[[bench]]
-name = "murmur3"
-harness = false
-
-[[bench]]
-name = "xxhash"
-harness = false
-
 [[test]]
 name = "sanitizers"
 path = "tests/sanitizers.rs"

{hashcodecs-1.2.1 → hashcodecs-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hashcodecs
-Version: 1.2.1
+Version: 1.3.0
 Summary: SIMD-accelerated Base64, MurmurHash3, and xxHash codecs
 Project-URL: Documentation, https://hashcodecs-rs.readthedocs.io/
 Project-URL: Repository, https://github.com/kozistr/hashcodecs-rs
@@ -43,20 +43,20 @@ Description-Content-Type: text/markdown
 
 <p align="center">
   <a href="BENCHMARK.md">
-    <img src="docs/benchmarks/performance-at-a-glance.svg" alt="CPython 3.12 URL-safe Base64 encoding and decoding benchmark">
+    <img src="docs/benchmarks/performance-at-a-glance.svg" alt="CPython 3.12 standard Base64 encoding and decoding benchmark">
   </a>
 </p>
 
 SIMD-accelerated Base64, MurmurHash3, and XXH3 for Python and Rust.
 
 Move byte-heavy work into Rust without changing your Python inputs. `hashcodecs` accepts `bytes`, `bytearray`, and
-`memoryview`, selects the best available SIMD backend, and exposes batch and reusable-buffer APIs.
+`memoryview`, selects the highest-priority supported SIMD backend, and exposes batch and reusable-buffer APIs.
 
 ## Features
 
 - Base64 encode and decode with standard, URL-safe, padded, unpadded, wrapped, and canonical modes.
 - MurmurHash3 x86-32, x86-128, and x64-128 with one-shot and incremental APIs.
-- Bit-for-bit compatible XXH3-64 and XXH3-128 with one-shot and native batch APIs.
+- Bit-for-bit compatible XXH3-64 and XXH3-128 with allocating and allocation-free native batch APIs.
 - Caller-managed `*_into` outputs for allocation-sensitive workloads.
 - Runtime dispatch across AVX-512, AVX2, SSE4.1, SSSE3, NEON, and scalar implementations where applicable.
 - Direct CPython buffer handling for `bytes`, `bytearray`, and `memoryview` inputs.
@@ -146,17 +146,25 @@ assert_eq!(
     hashcodecs::xxhash::xxh3_64(b"", 0),
     0x2d06_8005_38d3_94c2
 );
+
+let inputs: &[&[u8]] = &[b"hello", b"world"];
+let mut hashes = [0_u64; 2];
+let mut index = 0;
+hashcodecs::xxhash::xxh3_64_batch_for_each(inputs, 0, |hash| {
+    hashes[index] = hash;
+    index += 1;
+});
+assert_eq!(index, inputs.len());
 ```
 
 ## Architecture
 
-The Rust core owns algorithm behavior and SIMD dispatch. A substantial CPython layer handles argument parsing, buffer
-ownership, reusable outputs, and GIL decisions; root-level Python modules provide typed public exports without
-adding per-call wrappers.
+The Rust core owns algorithm behavior and SIMD dispatch. The CPython layer handles argument parsing, buffers,
+reusable outputs, and GIL decisions. Root-level Python modules provide typed exports without per-call wrappers.
 
-Each Rust algorithm exposes a small public façade. Base64 groups internals by encode and decode operation and
+Each Rust algorithm exposes a small public module. Base64 groups internals by encode and decode operation and
 places ISA kernels such as `encode/avx2.rs` and `decode/ssse3.rs` under their operation. MurmurHash3 groups code by
-canonical variant. XXH3 uses processing-stage modules, with long-input ISA kernels under `xxhash/long/`.
+canonical variant. XXH3 uses processing-stage modules. Long-input ISA kernels are under `xxhash/long_inputs/`.
 
 See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for the module layout, dispatch model, algorithm data flows,
 CPython boundary, and safety invariants.
@@ -206,9 +214,10 @@ Read the focused cases, commands, and values in [BENCHMARK.md](BENCHMARK.md). Re
 Comparison crates and Python packages are development-only dependencies and are not included in consumer builds.
 
 ```sh
-cargo bench --bench base64
-cargo bench --bench murmur3
-cargo bench --bench xxhash
+cargo bench --manifest-path benches/Cargo.toml --bench base64
+cargo bench --manifest-path benches/Cargo.toml --bench murmur3
+cargo bench --manifest-path benches/Cargo.toml --bench xxhash
+cargo bench --manifest-path benches/Cargo.toml --bench crossover
 
 uv sync --group benchmark --no-install-project
 uv run --no-project --with . python benchmarks/python_base64.py
@@ -219,21 +228,22 @@ uv run --no-project --with . python benchmarks/python_xxhash.py
 ```
 
 The Python benchmarks expose focused modes such as `--into`, `--lenient`, `--bytearray-input`, `--memoryview-input`,
-`--sliced-memoryview-input`, `--incremental`, `--large`, and `--hashcodecs-only`. All scripts also accept `--samples` and
-`--minimum-sample-seconds`; use `--help` on a benchmark script for its supported modes and defaults.
+`--sliced-memoryview-input`, `--buffer-inputs`, `--incremental`, `--large`, and `--hashcodecs-only`. All scripts also
+accept `--samples` and `--minimum-sample-seconds`; use `--help` on a benchmark script for its supported modes and
+defaults.
 
 For the same-ISA Windows XXH3 comparison shown above, rebuild the C baseline with:
 
 ```powershell
 $env:CFLAGS='/O2 /arch:AVX2'
 cargo clean -p xxhash-c-sys
-cargo bench --bench xxhash
+cargo bench --manifest-path benches/Cargo.toml --bench xxhash
 ```
 
 ## Performance snapshot
 
-In the full 2026-08-23 hashcodecs-only run on the benchmark host, `hashcodecs.xxh3_64` processes a 1 MiB input at
-79.20 GiB/s. With 256 B items in batches of 64, the Base64 batch API reaches 8.80 GiB/s for encode and 7.58 GiB/s for
+In the full 2026-09-02 hashcodecs-only run on the benchmark host, `hashcodecs.xxh3_64` processes a 1 MiB input at
+90.07 GiB/s. With 256 B items in batches of 64, the Base64 batch API reaches 11.84 GiB/s for encode and 6.23 GiB/s for
 decode. The run pins one logical CPU and uses 15 samples with a 0.2-second minimum per sample. Read the
 [benchmark details](BENCHMARK.md) and [raw comparison results](docs/benchmarks/results.csv).
 

{hashcodecs-1.2.1 → hashcodecs-1.3.0}/README.md

@@ -12,20 +12,20 @@
 
 <p align="center">
   <a href="BENCHMARK.md">
-    <img src="docs/benchmarks/performance-at-a-glance.svg" alt="CPython 3.12 URL-safe Base64 encoding and decoding benchmark">
+    <img src="docs/benchmarks/performance-at-a-glance.svg" alt="CPython 3.12 standard Base64 encoding and decoding benchmark">
   </a>
 </p>
 
 SIMD-accelerated Base64, MurmurHash3, and XXH3 for Python and Rust.
 
 Move byte-heavy work into Rust without changing your Python inputs. `hashcodecs` accepts `bytes`, `bytearray`, and
-`memoryview`, selects the best available SIMD backend, and exposes batch and reusable-buffer APIs.
+`memoryview`, selects the highest-priority supported SIMD backend, and exposes batch and reusable-buffer APIs.
 
 ## Features
 
 - Base64 encode and decode with standard, URL-safe, padded, unpadded, wrapped, and canonical modes.
 - MurmurHash3 x86-32, x86-128, and x64-128 with one-shot and incremental APIs.
-- Bit-for-bit compatible XXH3-64 and XXH3-128 with one-shot and native batch APIs.
+- Bit-for-bit compatible XXH3-64 and XXH3-128 with allocating and allocation-free native batch APIs.
 - Caller-managed `*_into` outputs for allocation-sensitive workloads.
 - Runtime dispatch across AVX-512, AVX2, SSE4.1, SSSE3, NEON, and scalar implementations where applicable.
 - Direct CPython buffer handling for `bytes`, `bytearray`, and `memoryview` inputs.
@@ -115,17 +115,25 @@ assert_eq!(
     hashcodecs::xxhash::xxh3_64(b"", 0),
     0x2d06_8005_38d3_94c2
 );
+
+let inputs: &[&[u8]] = &[b"hello", b"world"];
+let mut hashes = [0_u64; 2];
+let mut index = 0;
+hashcodecs::xxhash::xxh3_64_batch_for_each(inputs, 0, |hash| {
+    hashes[index] = hash;
+    index += 1;
+});
+assert_eq!(index, inputs.len());
 ```
 
 ## Architecture
 
-The Rust core owns algorithm behavior and SIMD dispatch. A substantial CPython layer handles argument parsing, buffer
-ownership, reusable outputs, and GIL decisions; root-level Python modules provide typed public exports without
-adding per-call wrappers.
+The Rust core owns algorithm behavior and SIMD dispatch. The CPython layer handles argument parsing, buffers,
+reusable outputs, and GIL decisions. Root-level Python modules provide typed exports without per-call wrappers.
 
-Each Rust algorithm exposes a small public façade. Base64 groups internals by encode and decode operation and
+Each Rust algorithm exposes a small public module. Base64 groups internals by encode and decode operation and
 places ISA kernels such as `encode/avx2.rs` and `decode/ssse3.rs` under their operation. MurmurHash3 groups code by
-canonical variant. XXH3 uses processing-stage modules, with long-input ISA kernels under `xxhash/long/`.
+canonical variant. XXH3 uses processing-stage modules. Long-input ISA kernels are under `xxhash/long_inputs/`.
 
 See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for the module layout, dispatch model, algorithm data flows,
 CPython boundary, and safety invariants.
@@ -175,9 +183,10 @@ Read the focused cases, commands, and values in [BENCHMARK.md](BENCHMARK.md). Re
 Comparison crates and Python packages are development-only dependencies and are not included in consumer builds.
 
 ```sh
-cargo bench --bench base64
-cargo bench --bench murmur3
-cargo bench --bench xxhash
+cargo bench --manifest-path benches/Cargo.toml --bench base64
+cargo bench --manifest-path benches/Cargo.toml --bench murmur3
+cargo bench --manifest-path benches/Cargo.toml --bench xxhash
+cargo bench --manifest-path benches/Cargo.toml --bench crossover
 
 uv sync --group benchmark --no-install-project
 uv run --no-project --with . python benchmarks/python_base64.py
@@ -188,21 +197,22 @@ uv run --no-project --with . python benchmarks/python_xxhash.py
 ```
 
 The Python benchmarks expose focused modes such as `--into`, `--lenient`, `--bytearray-input`, `--memoryview-input`,
-`--sliced-memoryview-input`, `--incremental`, `--large`, and `--hashcodecs-only`. All scripts also accept `--samples` and
-`--minimum-sample-seconds`; use `--help` on a benchmark script for its supported modes and defaults.
+`--sliced-memoryview-input`, `--buffer-inputs`, `--incremental`, `--large`, and `--hashcodecs-only`. All scripts also
+accept `--samples` and `--minimum-sample-seconds`; use `--help` on a benchmark script for its supported modes and
+defaults.
 
 For the same-ISA Windows XXH3 comparison shown above, rebuild the C baseline with:
 
 ```powershell
 $env:CFLAGS='/O2 /arch:AVX2'
 cargo clean -p xxhash-c-sys
-cargo bench --bench xxhash
+cargo bench --manifest-path benches/Cargo.toml --bench xxhash
 ```
 
 ## Performance snapshot
 
-In the full 2026-08-23 hashcodecs-only run on the benchmark host, `hashcodecs.xxh3_64` processes a 1 MiB input at
-79.20 GiB/s. With 256 B items in batches of 64, the Base64 batch API reaches 8.80 GiB/s for encode and 7.58 GiB/s for
+In the full 2026-09-02 hashcodecs-only run on the benchmark host, `hashcodecs.xxh3_64` processes a 1 MiB input at
+90.07 GiB/s. With 256 B items in batches of 64, the Base64 batch API reaches 11.84 GiB/s for encode and 6.23 GiB/s for
 decode. The run pins one logical CPU and uses 15 samples with a 0.2-second minimum per sample. Read the
 [benchmark details](BENCHMARK.md) and [raw comparison results](docs/benchmarks/results.csv).
 

hashcodecs-1.3.0/benches/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+name = "hashcodecs-benchmarks"
+version = "0.0.0"
+edition = "2024"
+publish = false
+
+[dev-dependencies]
+base64 = "=0.23.1"
+base64-turbo = "=0.3.0"
+criterion = { version = "=0.8.2", default-features = false, features = ["cargo_bench_support"] }
+fastmurmur3 = "=0.2.0"
+hashcodecs = { path = ".." }
+mimalloc = "=0.1.52"
+mm3h = "=0.1.3"
+murmur3 = "=0.5.2"
+murmurs = "=1.0.5"
+xxhash-c-sys = "=0.8.7"
+
+[[bench]]
+name = "base64"
+path = "base64.rs"
+harness = false
+
+[[bench]]
+name = "murmur3"
+path = "murmur3.rs"
+harness = false
+
+[[bench]]
+name = "xxhash"
+path = "xxhash.rs"
+harness = false
+
+[[bench]]
+name = "crossover"
+path = "crossover.rs"
+harness = false

{hashcodecs-1.2.1 → hashcodecs-1.3.0}/benches/base64.rs

@@ -7,7 +7,6 @@ use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_m
 mod support;
 
 const SIZES: [usize; 4] = [1024, 4 * 1024, 1024 * 1024, 8 * 1024 * 1024];
-const SAMPLE_SIZE: usize = 50;
 
 fn data(size: usize) -> Vec<u8> {
     (0..size)
@@ -23,6 +22,17 @@ macro_rules! benchmark {
     };
 }
 
+macro_rules! benchmark_encode {
+    ($group:expr, $size:expr, $input:expr, $name:literal, $function:expr) => {
+        $group.bench_with_input(BenchmarkId::new($name, $size), $input, |bench, input| {
+            bench.iter(|| {
+                let output = black_box(($function)(black_box(input)));
+                black_box(output.bytes().fold(0_u8, u8::wrapping_add))
+            });
+        });
+    };
+}
+
 fn base64(c: &mut Criterion) {
     support::pin_to_one_cpu();
     standard_encode(c);
@@ -42,19 +52,18 @@ fn standard_encode(c: &mut Criterion) {
         );
         assert_eq!(base64_turbo::STANDARD.encode(&input), expected);
 
-        group.sample_size(SAMPLE_SIZE);
         group.throughput(Throughput::Bytes(size as u64));
-        benchmark!(
+        benchmark_encode!(
             group,
             size,
             &input,
             "hashcodecs",
             hashcodecs::base64::b64encode
         );
-        benchmark!(group, size, &input, "base64", |input: &[u8]| {
+        benchmark_encode!(group, size, &input, "base64", |input: &[u8]| {
             base64::engine::general_purpose::STANDARD.encode(input)
         });
-        benchmark!(group, size, &input, "base64-turbo", |input: &[u8]| {
+        benchmark_encode!(group, size, &input, "base64-turbo", |input: &[u8]| {
             base64_turbo::STANDARD.encode(input)
         });
     }
@@ -72,19 +81,18 @@ fn urlsafe_encode(c: &mut Criterion) {
         );
         assert_eq!(base64_turbo::URL_SAFE.encode(&input), expected);
 
-        group.sample_size(SAMPLE_SIZE);
         group.throughput(Throughput::Bytes(size as u64));
-        benchmark!(
+        benchmark_encode!(
             group,
             size,
             &input,
             "hashcodecs",
             hashcodecs::base64::b64encode_urlsafe
         );
-        benchmark!(group, size, &input, "base64", |input: &[u8]| {
+        benchmark_encode!(group, size, &input, "base64", |input: &[u8]| {
             base64::engine::general_purpose::URL_SAFE.encode(input)
         });
-        benchmark!(group, size, &input, "base64-turbo", |input: &[u8]| {
+        benchmark_encode!(group, size, &input, "base64-turbo", |input: &[u8]| {
             base64_turbo::URL_SAFE.encode(input)
         });
     }
@@ -104,7 +112,6 @@ fn standard_decode(c: &mut Criterion) {
         );
         assert_eq!(base64_turbo::STANDARD.decode(&input).unwrap(), expected);
 
-        group.sample_size(SAMPLE_SIZE);
         group.throughput(Throughput::Bytes(size as u64));
         benchmark!(
             group,
@@ -142,7 +149,6 @@ fn urlsafe_decode(c: &mut Criterion) {
         );
         assert_eq!(base64_turbo::URL_SAFE.decode(&input).unwrap(), expected);
 
-        group.sample_size(SAMPLE_SIZE);
         group.throughput(Throughput::Bytes(size as u64));
         benchmark!(
             group,
@@ -171,7 +177,7 @@ criterion_group! {
     name = benches;
     config = Criterion::default()
         .measurement_time(Duration::from_secs(1))
-        .sample_size(30)
+        .sample_size(support::SAMPLE_SIZE)
         .warm_up_time(Duration::from_millis(500));
     targets = base64
 }