hashcodecs 1.2.1__tar.gz → 1.4.0__tar.gz

{hashcodecs-1.2.1 → hashcodecs-1.4.0}/.gitignore

@@ -10,6 +10,9 @@ site/
 .venv*/
 .coverage
 coverage.xml
+*.profraw
+*.lcov
+*.log
 
 # These are backup files generated by rustfmt
 **/*.rs.bk

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

@@ -6,9 +6,13 @@ 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).
 
+The standard and URL-safe Python decode panels report CPython 3.12.10 measurements from 2026-09-09; the lenient
+decode chart retains its 2026-09-05 measurements. Each value is the median of 15 samples lasting at least 0.2
+seconds each, with one logical CPU pinned.
+
 ## Timing Controls
 
 Every Python benchmark accepts `--samples` (default: 15) and `--minimum-sample-seconds` (default: 0.2). Their
@@ -16,12 +20,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 +38,38 @@ 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`.
 
+To measure a branch against its parent, build both extensions with the same Python and Rust toolchains, then run:
+
+```sh
+uv run --frozen --no-sync python benchmarks/compare_xxh3_batches.py path/to/parent/_hashcodecs.pyd path/to/branch/_hashcodecs.pyd
+```
+
+Use the corresponding `.so` paths on Linux or macOS. The comparison loads both builds into one interpreter, pins
+one CPU, and alternates their timing order across 15 samples. It checks matching digests and covers bytes,
+bytearrays, and writable memoryviews. Use `--batch-counts 2 9 32 33 --sizes 64` to inspect small batches and the
+32-result stack boundary. Positive `change_percent` values mean higher branch throughput.
+
+The [32-item parent comparison](docs/benchmarks/xxh3-batch-parent-comparison.csv) records CPython 3.12.10 results
+against parent commit `f17ab86`, measured on 2026-09-05. These paired measurements also cover the 256 KiB
+GIL-detachment threshold and 1 MiB items. The Python XXH3 chart uses the candidate's allocating-batch measurements;
+packed-output and upstream values retain their prior measurements.
+
+Across the 30 paired 32-item cases, branch throughput ranges from 2.59% lower to 2.70% higher than the parent.
+The [stack-boundary comparison](docs/benchmarks/xxh3-batch-boundary-comparison.csv) covers counts 2 and 33 with
+64-byte items: two-item bytearray batches lose 5.40–6.05%, and 33-item bytes batches lose 6.06–7.05%. These
+measurements show residual overhead for some small-input batches; they do not establish zero regression.
+
+The Rust mixed benchmarks use `[1024, 1024, 4096, 4096]`, `[257, 258, 259, 260]`, `[240, 240, 241, 241]`, and the
+reverse boundary order. The 1024/4096 case measures adjacent two-item long runs. The 257–260 case measures a
+four-item run with one shared stripe count and distinct final stripes. 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)"
+cargo bench --manifest-path benches/Cargo.toml --bench xxhash -- "xxh3_prepared"
 ```
 
 [![Rust XXH3 throughput](docs/benchmarks/xxh3-rust.svg)](docs/benchmarks/xxh3-rust.svg)
@@ -55,11 +91,17 @@ noisy cases insert `!` at the same boundaries. Both cases measure returned bytes
 
 [![Lenient Python Base64 throughput](docs/benchmarks/base64-python-lenient.svg)](docs/benchmarks/base64-python-lenient.svg)
 
+## Wrapped Python Base64
+
+Run `python benchmarks/python_base64.py --wrapped` with CPython 3.15 or newer. The benchmark inserts newlines after
+76 output characters and measures returned bytes and a reusable `bytearray`.
+
 ## 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 +118,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 +169,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.4.0/CHANGELOG.md

@@ -0,0 +1,209 @@
+# Changelog
+
+This file records notable user-facing changes to `hashcodecs`. Version 1.0.0 starts the stable Python API policy.
+
+## [Unreleased]
+
+## [1.4.0] - 2026-09-10
+
+### What's Changed
+* refactor: flatten internal module layout by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/91
+* refactor: prepare Base64 decoder policies once by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/92
+* refactor: consolidate binding and dispatch cleanup by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/93
+* refactor: simplify project module layout by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/94
+* refactor: prepare codec policies and unify bindings by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/95
+* refactor: accelerate Base64 codec hot paths by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/96
+* fix: protect XXH3 batches from GC reentrancy by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/97
+* refactor: unify Base64 decode execution by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/98
+* refactor: flatten Base64 binding ownership by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/99
+* refactor: improve XXH3 loads and internal naming by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/100
+* refactor: reduce Base64 decoder setup and retry costs by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/101
+* fix: preserve Base64 decode boundaries and restore ARM coverage by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/102
+* refactor: keep XXH3 AVX2 tail chains in registers by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/103
+* refactor: store AVX2 Base64 vectors in smaller groups by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/104
+* fix: reduce Python overhead and align canonical decoding by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/106
+* refactor: reduce cached AVX2 encoder setup by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/107
+* feat: optimize XXH3 seeded and batch hashing by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/108
+* Optimize AVX2 Base64 decoding by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/109
+* refactor: optimize Python batch orchestration by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/110
+* feat: optimize XXH3 batches and wrapped Base64 by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/111
+* Fuse Base64 SIMD lookup paths and Murmur3 hex output by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/112
+* fix: preserve custom alphabets and batch typing by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/113
+
+
+**Full Changelog**: https://github.com/kozistr/hashcodecs-rs/compare/v1.3.0...v1.4.0
+
+## [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
+* fix: harden buffer and lenient decode paths by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/58
+* Refactor Murmur SIMD and centralize XXH3 long dispatch by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/59
+* Repair sdist verification and roll back unpublished 1.2.1 by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/60
+
+
+**Full Changelog**: https://github.com/kozistr/hashcodecs-rs/compare/v1.2.0...v1.2.1
+
+## [1.2.0] - 2026-08-25
+
+### What's Changed
+* fix: harden free-threaded bindings and API correctness by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/47
+* feat: accelerate Python batch outputs by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/48
+* feat: add native lenient Base64 decoding by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/49
+* update: tune Python detach thresholds by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/50
+* fix: harden Base64 binding edge cases by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/51
+* fix: stabilize Base64 GIL release test by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/52
+* feat: accelerate XXH3 batch remainders by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/53
+* perf: refresh Base64 batch benchmarks by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/54
+* perf: accelerate XXH3 long inputs by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/55
+* perf: profile Base64 batch allocations by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/56
+* refactor: organize Python binding infrastructure by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/57
+
+
+**Full Changelog**: https://github.com/kozistr/hashcodecs-rs/compare/v1.1.0...v1.2.0
+
+## [1.1.0] - 2026-08-23
+
+### What's Changed
+* chore: use trusted publishing for crates.io by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/44
+* refactor: establish clean architecture boundaries by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/45
+* feat: borrow contiguous Python buffers by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/46
+
+
+**Full Changelog**: https://github.com/kozistr/hashcodecs-rs/compare/v1.0.0...v1.1.0
+
+## [1.0.0] - 2026-08-22
+
+### What's Changed
+* Expand Python and Rust API documentation by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/36
+* feat: move base64 batch aliases into Rust by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/37
+* feat: support free-threaded Python wheels by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/38
+* Update benchmark and Python support docs by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/39
+* chore: reduce CI runner usage and latency by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/40
+* build: prepare 1.0 release by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/41
+* build: publish Rust crate from release workflow by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/42
+* feat: expose namespaced Rust API by @kozistr in https://github.com/kozistr/hashcodecs-rs/pull/43
+
+
+**Full Changelog**: https://github.com/kozistr/hashcodecs-rs/compare/v0.6.1...v1.0.0
+
+## [0.6.1] - 2026-08-22
+
+### Added
+
+- Reusable output buffers for XXH3 batch operations.
+- A Read the Docs site with Python and Rust API documentation.
+
+## [0.6.0] - 2026-08-21
+
+### Added
+
+- SIMD-accelerated XXH3-64 and XXH3-128 APIs.
+- Native one-shot and batch bindings built on the full CPython API.
+
+### Changed
+
+- Faster Base64 and XXH3 hot paths, including small XXH3 inputs and large AVX2 Base64 inputs.
+- One runtime dispatch layer now selects SIMD backends for each codec and hash implementation.
+
+## [0.5.0] - 2026-08-12
+
+### Added
+
+- Batch Base64 APIs that write into caller-provided buffers.
+
+### Changed
+
+- Faster unpadded Base64 and Python decoding paths with fewer aligned-input copies.
+- Release validation now runs before packaging and publication.
+
+## [0.4.0] - 2026-08-10
+
+### Added
+
+- CPython 3.15 support.
+- Native Base64 batch APIs.
+
+### Changed
+
+- Faster SIMD Base64 codecs and mutable Python buffer handling.
+- Simpler URL-safe Base64 wrappers.
+
+## [0.3.0] - 2026-08-09
+
+### Added
+
+- Reusable Python output buffers for allocation-sensitive Base64 operations.
+
+### Changed
+
+- Faster AVX2 Base64 decoding and SIMD encoding paths.
+
+## [0.2.0] - 2026-08-09
+
+### Added
+
+- Incremental MurmurHash3 hashers.
+- SIMD implementations for each MurmurHash3 variant and additional codec backends.
+
+### Fixed
+
+- Short NEON Base64 blocks and scalar backend detection on non-x86 systems.
+
+## [0.1.0] - 2026-08-09
+
+### Added
+
+- 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.4.0...HEAD
+[1.4.0]: https://github.com/kozistr/hashcodecs-rs/compare/v1.3.0...v1.4.0
+[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
+[1.0.0]: https://github.com/kozistr/hashcodecs-rs/compare/v0.6.1...v1.0.0
+[0.6.1]: https://github.com/kozistr/hashcodecs-rs/compare/v0.6.0...v0.6.1
+[0.6.0]: https://github.com/kozistr/hashcodecs-rs/compare/v0.5.0...v0.6.0
+[0.5.0]: https://github.com/kozistr/hashcodecs-rs/compare/v0.4.0...v0.5.0
+[0.4.0]: https://github.com/kozistr/hashcodecs-rs/compare/v0.3.0...v0.4.0
+[0.3.0]: https://github.com/kozistr/hashcodecs-rs/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/kozistr/hashcodecs-rs/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/kozistr/hashcodecs-rs/tree/v0.1.0

{hashcodecs-1.2.1 → hashcodecs-1.4.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.4.0
+date-released: 2026-09-10
 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.4.0}/Cargo.lock

@@ -194,21 +194,32 @@ dependencies = [
 
 [[package]]
 name = "hashcodecs"
-version = "1.2.1"
+version = "1.4.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.4.0}/Cargo.toml

@@ -1,8 +1,9 @@
 [package]
 name = "hashcodecs"
-version = "1.2.1"
+version = "1.4.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"
@@ -10,6 +11,7 @@ keywords = ["base64", "simd", "murmur3", "xxhash", "python"]
 categories = ["encoding", "algorithms"]
 readme = "README.md"
 include = [
+    "/generated/**",
     "/src/**",
     "/benches/**",
     "/tests/sanitizers.rs",
@@ -19,6 +21,11 @@ include = [
     "/LICENSE-MIT",
 ]
 
+[workspace]
+members = [".", "benches"]
+default-members = ["."]
+resolver = "3"
+
 [lib]
 name = "hashcodecs"
 crate-type = ["rlib", "cdylib"]
@@ -37,28 +44,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.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hashcodecs
-Version: 1.2.1
+Version: 1.4.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 prepared seeds and 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,36 @@ assert_eq!(
     hashcodecs::xxhash::xxh3_64(b"", 0),
     0x2d06_8005_38d3_94c2
 );
+
+let seeded_input = vec![7; 1024];
+let prepared = hashcodecs::xxhash::PreparedXxh3::new(42);
+assert_eq!(
+    prepared.hash_64(&seeded_input),
+    hashcodecs::xxhash::xxh3_64(&seeded_input, 42)
+);
+
+let inputs: &[&[u8]] = &[b"hello", b"world"];
+assert_eq!(
+    prepared.hash_64_batch(inputs),
+    hashcodecs::xxhash::xxh3_64_batch(inputs, 42)
+);
+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 +225,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,22 +239,24 @@ 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
-decode. The run pins one logical CPU and uses 15 samples with a 0.2-second minimum per sample. Read the
+In the focused 2026-09-09 hashcodecs-only run on the benchmark host, `hashcodecs.xxh3_64` processes a 1 MiB input
+at 91.27 GiB/s. In the full 2026-09-02 run, the Base64 batch API reaches 11.84 GiB/s for encode and 6.23 GiB/s for
+decode with 256 B items in batches of 64. Each 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).
 
 ## Development
@@ -248,14 +270,12 @@ uv build
 Run the primary local checks:
 
 ```sh
-cargo fmt --check
-cargo clippy --all-targets --features python -- -D warnings
-cargo test --features python
-uv run --frozen --no-sync ruff check . --no-cache
-uv run --frozen --no-sync ruff format --check .
-uv run --frozen --no-sync pytest tests --cov=hashcodecs --cov-branch --cov-fail-under=100
+just check
 ```
 
+`just check` builds and reinstalls the current wheel before running Python tests. Run `just full-check` before
+committing to also check release builds, Rust core coverage, and the extracted source distribution.
+
 Optimized paths are also checked with differential fuzzing, Kani, strict-provenance Miri, AddressSanitizer, and
 MemorySanitizer in CI.