fuzzgpu 0.1.7__tar.gz → 0.2.0__tar.gz

{fuzzgpu-0.1.7 → fuzzgpu-0.2.0}/Cargo.lock

@@ -372,7 +372,7 @@ dependencies = [
 
 [[package]]
 name = "fuzzgpu-core"
-version = "0.1.7"
+version = "0.2.0"
 dependencies = [
  "bytemuck",
  "criterion",
@@ -386,7 +386,7 @@ dependencies = [
 
 [[package]]
 name = "fuzzgpu-python"
-version = "0.1.7"
+version = "0.2.0"
 dependencies = [
  "fuzzgpu-core",
  "log",

{fuzzgpu-0.1.7 → fuzzgpu-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fuzzgpu
-Version: 0.1.7
+Version: 0.2.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -37,7 +37,7 @@ Project-URL: Repository, https://github.com/kuntal-devrat/fuzzgpu
 
 *Cross-platform GPU compute via WebGPU (`wgpu`) & Multi-Core CPU parallelism with Rayon. Zero CUDA dependencies.*
 
-[![PyPI Version](https://img.shields.io/badge/pypi-v0.1.7-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
+[![PyPI Version](https://img.shields.io/badge/pypi-v0.2.0-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?style=flat-square)](https://opensource.org/licenses/MIT)
 [![Rust](https://img.shields.io/badge/rust-1.87+-orange.svg?style=flat-square)](https://www.rust-lang.org)
 [![Cross Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux%20%7C%20WASM-lightgrey.svg?style=flat-square)](https://github.com/kuntal-devrat/fuzzgpu)
@@ -60,28 +60,60 @@ No NVIDIA CUDA drivers or complex toolkits required.
 
 ---
 
-## What's New in v0.1.7
+## What's New in v0.2.0
+
+### Production hardening
+- **Kernel `get()` panics eliminated** — all four GPU kernels (`GpuLevenshteinKernel`,
+  `GpuJaroKernel`, `GpuNeedlemanAffineKernel`, `GpuDamerauKernel`) previously called
+  `.unwrap()` on `OnceLock::get()` after initialization, which could panic the Python
+  interpreter under rare concurrent races. Replaced with `.ok_or_else(...)` returning
+  a proper `FuzzGpuError::NoDevice`.
+- **`debug_assert!` → real release guards** — `MyersPattern::new`, `jaro_bitpar`, `jaro_4way`
+  were guarded only by `debug_assert!`. In release builds, calling them with inputs outside
+  their contract (non-ASCII or > 64 bytes) would silently produce wrong results. Promoted to
+  proper `assert!` with descriptive messages that surface immediately in both debug and release.
+
+### New API surface
+- **`fuzz.cdist`** — pairwise score matrix, mirrors `rapidfuzz.fuzz.cdist`. Delegates to
+  `process.cdist` with `ratio` as the default scorer.
+- **`DamerauLevenshtein.editops` / `.opcodes`** — full Lowrance-Wagner traceback returning
+  `Editops` / `Opcodes` (insert/delete/replace), completing parity with rapidfuzz's alignment
+  API for this module.
+- **`fuzz.__all__`** now includes `partial_ratio_alignment` and `cdist` (were missing).
+
+### API correctness fixes
+- **`Jaro.similarity` / `JaroWinkler.similarity` `score_cutoff`** — changed default from
+  `0.0` to `None`, matching rapidfuzz's semantics (`0.0` treated scores of exactly 0.0 as
+  filtered, which was wrong).
+- **`ratio_batch(workers=)`** — was silently ignored (`del workers`). Now wires up a
+  `ThreadPoolExecutor` for the processor path; the no-processor path continues to use Rayon
+  internally (ignoring `workers` is correct there — Rayon already uses all cores).
+- **`process.cdist` fast path** — rewrote to use `fuzz_ratio_batch` row-by-row (each row
+  runs under Rayon across all cores) instead of a dead `raw = _native.fuzz_ratio_batch`
+  assignment followed by the same loop. Removed the dead `raw:` type-hint-only line.
+- **`process.cdist` silent swallow** — `except Exception: pass` replaced with
+  `warnings.warn(...)` so unexpected fast-path failures are visible instead of silently
+  producing slow results.
+
+### Includes all v0.1.7 fixes
+All fixes from v0.1.7 are included — see the v0.1.7 changelog below.
+
+---
+
+<details>
+<summary><b>Previous (v0.1.7)</b></summary>
 
 ### Bug fixes (Windows DX12 / Jaro shader)
 - **Jaro GPU shader FXC crash fixed** — `jaro.wgsl` and `jaro_matrix.wgsl` used dynamic vector
-  component writes (`v[j >> 5u] = ...`) in `bit_set()`. FXC (the DX12 HLSL compiler) cannot
-  emit a dynamic register-indexed store for a non-constant index, causing a hard compile failure
-  with `X3550`/`X3511` on every Windows DX12 runner — all 11 Jaro GPU tests were panicking.
-  Fixed by rewriting `bit_set` with `select()`-based static construction, which compiles
-  identically on all backends (Vulkan, Metal, DX12).
+  component writes (`v[j >> 5u] = ...`) in `bit_set()`. Fixed by rewriting `bit_set` with
+  `select()`-based static construction (Vulkan, Metal, DX12 all compile identically).
 
 ### Bug fixes (arity mismatch — wasm & fuzz crates)
-- **`fuzzgpu-wasm`** — `partial_ratio`, `token_sort_ratio`, `token_set_ratio`, `wratio` gained
-  a `score_cutoff: f64` parameter in the v0.1.6 Rust core rewrite for rapidfuzz parity, but
-  the WASM bindings were not updated, causing 4 `E0061` compile errors. Fixed by passing
-  `0.0` as the cutoff (no cutoff — identical to the previous behaviour).
-- **`fuzzgpu-fuzz`** — same four callsites in `fuzz/src/lib.rs` had the same arity mismatch.
-  Fixed identically.
-
-### Includes all v0.1.6 features
-All features from v0.1.6 are included — see the v0.1.6 changelog below.
+- **`fuzzgpu-wasm`** and **`fuzzgpu-fuzz`** — 4 × `E0061` arity mismatch for
+  `partial_ratio`/`token_sort_ratio`/`token_set_ratio`/`wratio`. Fixed by passing `0.0`
+  as the cutoff.
 
----
+</details>
 
 <details>
 <summary><b>Previous (v0.1.6)</b></summary>
@@ -131,27 +163,61 @@ The full Python layer is now byte-identical to rapidfuzz 3.14.5 over a 169,744-p
 
 ## Benchmark Results
 
-*Hardware: Intel(R) Iris(R) Xe Graphics (Vulkan) + Intel Core i7 (Rayon uses all cores)*
-*Versions: fuzzgpu 0.1.6 · rapidfuzz 3.14.5 · python-Levenshtein 0.27.4*
+*Hardware: Intel(R) Iris(R) Xe Graphics — integrated GPU (Vulkan) + Intel Core i7 (Rayon, all cores)*
+*Versions: fuzzgpu 0.2.0 · rapidfuzz 3.14.5 · python-Levenshtein 0.27.4*
 *Median of 7 runs after warmup. Reproduce: `python benchmarks/bench_compare.py`*
 
+> **GPU class note:** These numbers are from an **integrated GPU** (iGPU), which shares memory
+> bandwidth with the CPU and has a ~1 ms dispatch round-trip. On a **discrete GPU** (dGPU) the
+> GPU columns improve significantly — expect 3–10× better GPU throughput and GPU routing kicking
+> in at much smaller batch sizes (threshold drops from ~500 pairs to ~64 pairs automatically).
+> Concurrency gains (multiple Python threads, after the wgpu fix ships) add a further 2–4×
+> on top for server workloads regardless of GPU class.
+
 ### Levenshtein Batch (1 query × N candidates, 10-char strings)
 | Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | vs RF (GPU) | vs RF (CPU) |
 | :--- | :---: | :---: | :---: | :---: | :---: |
-| **100** | 0.12 ms | 0.01 ms | 0.03 ms | 0.25× | 2.21× |
-| **1,000** | 0.83 ms | 0.09 ms | 0.15 ms | 0.18× | 1.67× |
-| **10,000** | 2.60 ms | 0.87 ms | 1.47 ms | 0.57× | 1.68× |
-| **50,000** | 9.92 ms | 5.04 ms | 6.38 ms | 0.64× | 1.27× |
+| **100** | 0.04 ms | 0.00 ms | 0.01 ms | 0.24× | 1.90× |
+| **1,000** | 0.50 ms | 0.04 ms | 0.07 ms | 0.13× | 1.89× |
+| **10,000** | 1.53 ms | 0.40 ms | 0.64 ms | 0.42× | 1.61× |
+| **50,000** | 6.87 ms | 3.36 ms | 4.46 ms | 0.65× | 1.33× |
 
 ### Damerau-Levenshtein Batch (unrestricted Lowrance-Wagner)
 | Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | vs RF (GPU) | vs RF (CPU) |
 | :--- | :---: | :---: | :---: | :---: | :---: |
-| **1,000** | 0.58 ms | 0.40 ms | 1.63 ms | 2.81× | 4.06× |
-| **10,000** | 2.95 ms | 2.15 ms | 20.86 ms | 7.06× | 9.70× |
-| **50,000** | 17.49 ms | 12.08 ms | 120.25 ms | 6.88× | 9.95× |
+| **100** | 0.04 ms | 0.04 ms | 0.10 ms | 2.68× | 2.63× |
+| **1,000** | 0.21 ms | 0.20 ms | 0.98 ms | 4.71× | 4.89× |
+| **10,000** | 1.39 ms | 1.49 ms | 9.93 ms | 7.14× | 6.67× |
+| **50,000** | 10.19 ms | 9.91 ms | 66.57 ms | 6.54× | 6.72× |
 
 > **Note:** rapidfuzz's `DamerauLevenshtein` uses Optimal String Alignment (OSA). fuzzgpu implements the **unrestricted** Lowrance-Wagner (1975) algorithm which allows non-adjacent transpositions. For example: `damerau("ca", "abc") == 2` (fuzzgpu) vs `3` (rapidfuzz OSA). Use `fuzzgpu.distance.OSA` for OSA-compatible semantics.
 
+### Jaro-Winkler Batch (p = 0.1)
+| Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | vs RF (GPU) | vs RF (CPU) |
+| :--- | :---: | :---: | :---: | :---: | :---: |
+| **100** | 0.02 ms | 0.01 ms | 0.02 ms | 0.87× | 1.14× |
+| **1,000** | 0.18 ms | 0.13 ms | 0.12 ms | 0.70× | 0.94× |
+| **10,000** | 1.01 ms | 0.83 ms | 0.97 ms | 0.96× | 1.18× |
+| **50,000** | 5.61 ms | 3.25 ms | 6.69 ms | 1.19× | 2.06× |
+
+### Needleman-Wunsch Affine Batch (match=1, mismatch=-1, gap_open=-2, gap_extend=-1)
+| Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` |
+| :--- | :---: | :---: | :---: |
+| **100** | 0.07 ms | 0.05 ms | — |
+| **1,000** | 1.65 ms | 0.43 ms | — |
+| **10,000** | 12.49 ms | 3.91 ms | — |
+| **50,000** | 47.86 ms | 26.95 ms | — |
+
+> rapidfuzz has no Needleman-Wunsch API — no comparison available.
+
+### Levenshtein Cross-Product Matrix (`cdist`)
+| Matrix Size | Total Pairs | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | python-Levenshtein | vs RF (GPU) | vs RF (CPU) |
+| :--- | :---: | :---: | :---: | :---: | :---: | :---: | :---: |
+| **10 × 10** | 100 | 0.05 ms | 0.02 ms | 0.01 ms | 0.06 ms | 0.18× | 0.56× |
+| **50 × 50** | 2,500 | 0.58 ms | 0.11 ms | 0.09 ms | 2.17 ms | 0.16× | 0.81× |
+| **100 × 100** | 10,000 | 0.67 ms | 0.25 ms | 0.18 ms | 5.75 ms | 0.27× | 0.70× |
+| **200 × 200** | 40,000 | 1.19 ms | 0.81 ms | 0.61 ms | 22.31 ms | 0.51× | 0.75× |
+
 ---
 
 ## Installation
@@ -163,7 +229,7 @@ pip install fuzzgpu
 ```toml
 # Rust
 [dependencies]
-fuzzgpu-core = "0.1.7"
+fuzzgpu-core = "0.2.0"
 ```
 
 ---
@@ -259,7 +325,7 @@ fuzzgpu.set_cpu_only(True)       # force CPU-only mode
 
 ```toml
 [dependencies]
-fuzzgpu-core = "0.1.7"                                        # GPU + CPU fallback
+fuzzgpu-core = "0.2.0"                                        # GPU + CPU fallback
 # fuzzgpu-core = { version = "0.1.7", default-features = false } # CPU-only
 ```
 

{fuzzgpu-0.1.7 → fuzzgpu-0.2.0}/README.md

@@ -8,7 +8,7 @@
 
 *Cross-platform GPU compute via WebGPU (`wgpu`) & Multi-Core CPU parallelism with Rayon. Zero CUDA dependencies.*
 
-[![PyPI Version](https://img.shields.io/badge/pypi-v0.1.7-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
+[![PyPI Version](https://img.shields.io/badge/pypi-v0.2.0-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?style=flat-square)](https://opensource.org/licenses/MIT)
 [![Rust](https://img.shields.io/badge/rust-1.87+-orange.svg?style=flat-square)](https://www.rust-lang.org)
 [![Cross Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux%20%7C%20WASM-lightgrey.svg?style=flat-square)](https://github.com/kuntal-devrat/fuzzgpu)
@@ -31,28 +31,60 @@ No NVIDIA CUDA drivers or complex toolkits required.
 
 ---
 
-## What's New in v0.1.7
+## What's New in v0.2.0
+
+### Production hardening
+- **Kernel `get()` panics eliminated** — all four GPU kernels (`GpuLevenshteinKernel`,
+  `GpuJaroKernel`, `GpuNeedlemanAffineKernel`, `GpuDamerauKernel`) previously called
+  `.unwrap()` on `OnceLock::get()` after initialization, which could panic the Python
+  interpreter under rare concurrent races. Replaced with `.ok_or_else(...)` returning
+  a proper `FuzzGpuError::NoDevice`.
+- **`debug_assert!` → real release guards** — `MyersPattern::new`, `jaro_bitpar`, `jaro_4way`
+  were guarded only by `debug_assert!`. In release builds, calling them with inputs outside
+  their contract (non-ASCII or > 64 bytes) would silently produce wrong results. Promoted to
+  proper `assert!` with descriptive messages that surface immediately in both debug and release.
+
+### New API surface
+- **`fuzz.cdist`** — pairwise score matrix, mirrors `rapidfuzz.fuzz.cdist`. Delegates to
+  `process.cdist` with `ratio` as the default scorer.
+- **`DamerauLevenshtein.editops` / `.opcodes`** — full Lowrance-Wagner traceback returning
+  `Editops` / `Opcodes` (insert/delete/replace), completing parity with rapidfuzz's alignment
+  API for this module.
+- **`fuzz.__all__`** now includes `partial_ratio_alignment` and `cdist` (were missing).
+
+### API correctness fixes
+- **`Jaro.similarity` / `JaroWinkler.similarity` `score_cutoff`** — changed default from
+  `0.0` to `None`, matching rapidfuzz's semantics (`0.0` treated scores of exactly 0.0 as
+  filtered, which was wrong).
+- **`ratio_batch(workers=)`** — was silently ignored (`del workers`). Now wires up a
+  `ThreadPoolExecutor` for the processor path; the no-processor path continues to use Rayon
+  internally (ignoring `workers` is correct there — Rayon already uses all cores).
+- **`process.cdist` fast path** — rewrote to use `fuzz_ratio_batch` row-by-row (each row
+  runs under Rayon across all cores) instead of a dead `raw = _native.fuzz_ratio_batch`
+  assignment followed by the same loop. Removed the dead `raw:` type-hint-only line.
+- **`process.cdist` silent swallow** — `except Exception: pass` replaced with
+  `warnings.warn(...)` so unexpected fast-path failures are visible instead of silently
+  producing slow results.
+
+### Includes all v0.1.7 fixes
+All fixes from v0.1.7 are included — see the v0.1.7 changelog below.
+
+---
+
+<details>
+<summary><b>Previous (v0.1.7)</b></summary>
 
 ### Bug fixes (Windows DX12 / Jaro shader)
 - **Jaro GPU shader FXC crash fixed** — `jaro.wgsl` and `jaro_matrix.wgsl` used dynamic vector
-  component writes (`v[j >> 5u] = ...`) in `bit_set()`. FXC (the DX12 HLSL compiler) cannot
-  emit a dynamic register-indexed store for a non-constant index, causing a hard compile failure
-  with `X3550`/`X3511` on every Windows DX12 runner — all 11 Jaro GPU tests were panicking.
-  Fixed by rewriting `bit_set` with `select()`-based static construction, which compiles
-  identically on all backends (Vulkan, Metal, DX12).
+  component writes (`v[j >> 5u] = ...`) in `bit_set()`. Fixed by rewriting `bit_set` with
+  `select()`-based static construction (Vulkan, Metal, DX12 all compile identically).
 
 ### Bug fixes (arity mismatch — wasm & fuzz crates)
-- **`fuzzgpu-wasm`** — `partial_ratio`, `token_sort_ratio`, `token_set_ratio`, `wratio` gained
-  a `score_cutoff: f64` parameter in the v0.1.6 Rust core rewrite for rapidfuzz parity, but
-  the WASM bindings were not updated, causing 4 `E0061` compile errors. Fixed by passing
-  `0.0` as the cutoff (no cutoff — identical to the previous behaviour).
-- **`fuzzgpu-fuzz`** — same four callsites in `fuzz/src/lib.rs` had the same arity mismatch.
-  Fixed identically.
-
-### Includes all v0.1.6 features
-All features from v0.1.6 are included — see the v0.1.6 changelog below.
+- **`fuzzgpu-wasm`** and **`fuzzgpu-fuzz`** — 4 × `E0061` arity mismatch for
+  `partial_ratio`/`token_sort_ratio`/`token_set_ratio`/`wratio`. Fixed by passing `0.0`
+  as the cutoff.
 
----
+</details>
 
 <details>
 <summary><b>Previous (v0.1.6)</b></summary>
@@ -102,27 +134,61 @@ The full Python layer is now byte-identical to rapidfuzz 3.14.5 over a 169,744-p
 
 ## Benchmark Results
 
-*Hardware: Intel(R) Iris(R) Xe Graphics (Vulkan) + Intel Core i7 (Rayon uses all cores)*
-*Versions: fuzzgpu 0.1.6 · rapidfuzz 3.14.5 · python-Levenshtein 0.27.4*
+*Hardware: Intel(R) Iris(R) Xe Graphics — integrated GPU (Vulkan) + Intel Core i7 (Rayon, all cores)*
+*Versions: fuzzgpu 0.2.0 · rapidfuzz 3.14.5 · python-Levenshtein 0.27.4*
 *Median of 7 runs after warmup. Reproduce: `python benchmarks/bench_compare.py`*
 
+> **GPU class note:** These numbers are from an **integrated GPU** (iGPU), which shares memory
+> bandwidth with the CPU and has a ~1 ms dispatch round-trip. On a **discrete GPU** (dGPU) the
+> GPU columns improve significantly — expect 3–10× better GPU throughput and GPU routing kicking
+> in at much smaller batch sizes (threshold drops from ~500 pairs to ~64 pairs automatically).
+> Concurrency gains (multiple Python threads, after the wgpu fix ships) add a further 2–4×
+> on top for server workloads regardless of GPU class.
+
 ### Levenshtein Batch (1 query × N candidates, 10-char strings)
 | Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | vs RF (GPU) | vs RF (CPU) |
 | :--- | :---: | :---: | :---: | :---: | :---: |
-| **100** | 0.12 ms | 0.01 ms | 0.03 ms | 0.25× | 2.21× |
-| **1,000** | 0.83 ms | 0.09 ms | 0.15 ms | 0.18× | 1.67× |
-| **10,000** | 2.60 ms | 0.87 ms | 1.47 ms | 0.57× | 1.68× |
-| **50,000** | 9.92 ms | 5.04 ms | 6.38 ms | 0.64× | 1.27× |
+| **100** | 0.04 ms | 0.00 ms | 0.01 ms | 0.24× | 1.90× |
+| **1,000** | 0.50 ms | 0.04 ms | 0.07 ms | 0.13× | 1.89× |
+| **10,000** | 1.53 ms | 0.40 ms | 0.64 ms | 0.42× | 1.61× |
+| **50,000** | 6.87 ms | 3.36 ms | 4.46 ms | 0.65× | 1.33× |
 
 ### Damerau-Levenshtein Batch (unrestricted Lowrance-Wagner)
 | Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | vs RF (GPU) | vs RF (CPU) |
 | :--- | :---: | :---: | :---: | :---: | :---: |
-| **1,000** | 0.58 ms | 0.40 ms | 1.63 ms | 2.81× | 4.06× |
-| **10,000** | 2.95 ms | 2.15 ms | 20.86 ms | 7.06× | 9.70× |
-| **50,000** | 17.49 ms | 12.08 ms | 120.25 ms | 6.88× | 9.95× |
+| **100** | 0.04 ms | 0.04 ms | 0.10 ms | 2.68× | 2.63× |
+| **1,000** | 0.21 ms | 0.20 ms | 0.98 ms | 4.71× | 4.89× |
+| **10,000** | 1.39 ms | 1.49 ms | 9.93 ms | 7.14× | 6.67× |
+| **50,000** | 10.19 ms | 9.91 ms | 66.57 ms | 6.54× | 6.72× |
 
 > **Note:** rapidfuzz's `DamerauLevenshtein` uses Optimal String Alignment (OSA). fuzzgpu implements the **unrestricted** Lowrance-Wagner (1975) algorithm which allows non-adjacent transpositions. For example: `damerau("ca", "abc") == 2` (fuzzgpu) vs `3` (rapidfuzz OSA). Use `fuzzgpu.distance.OSA` for OSA-compatible semantics.
 
+### Jaro-Winkler Batch (p = 0.1)
+| Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | vs RF (GPU) | vs RF (CPU) |
+| :--- | :---: | :---: | :---: | :---: | :---: |
+| **100** | 0.02 ms | 0.01 ms | 0.02 ms | 0.87× | 1.14× |
+| **1,000** | 0.18 ms | 0.13 ms | 0.12 ms | 0.70× | 0.94× |
+| **10,000** | 1.01 ms | 0.83 ms | 0.97 ms | 0.96× | 1.18× |
+| **50,000** | 5.61 ms | 3.25 ms | 6.69 ms | 1.19× | 2.06× |
+
+### Needleman-Wunsch Affine Batch (match=1, mismatch=-1, gap_open=-2, gap_extend=-1)
+| Batch Size | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` |
+| :--- | :---: | :---: | :---: |
+| **100** | 0.07 ms | 0.05 ms | — |
+| **1,000** | 1.65 ms | 0.43 ms | — |
+| **10,000** | 12.49 ms | 3.91 ms | — |
+| **50,000** | 47.86 ms | 26.95 ms | — |
+
+> rapidfuzz has no Needleman-Wunsch API — no comparison available.
+
+### Levenshtein Cross-Product Matrix (`cdist`)
+| Matrix Size | Total Pairs | `fuzzgpu` (GPU) | `fuzzgpu` (CPU) | `rapidfuzz` | python-Levenshtein | vs RF (GPU) | vs RF (CPU) |
+| :--- | :---: | :---: | :---: | :---: | :---: | :---: | :---: |
+| **10 × 10** | 100 | 0.05 ms | 0.02 ms | 0.01 ms | 0.06 ms | 0.18× | 0.56× |
+| **50 × 50** | 2,500 | 0.58 ms | 0.11 ms | 0.09 ms | 2.17 ms | 0.16× | 0.81× |
+| **100 × 100** | 10,000 | 0.67 ms | 0.25 ms | 0.18 ms | 5.75 ms | 0.27× | 0.70× |
+| **200 × 200** | 40,000 | 1.19 ms | 0.81 ms | 0.61 ms | 22.31 ms | 0.51× | 0.75× |
+
 ---
 
 ## Installation
@@ -134,7 +200,7 @@ pip install fuzzgpu
 ```toml
 # Rust
 [dependencies]
-fuzzgpu-core = "0.1.7"
+fuzzgpu-core = "0.2.0"
 ```
 
 ---
@@ -230,7 +296,7 @@ fuzzgpu.set_cpu_only(True)       # force CPU-only mode
 
 ```toml
 [dependencies]
-fuzzgpu-core = "0.1.7"                                        # GPU + CPU fallback
+fuzzgpu-core = "0.2.0"                                        # GPU + CPU fallback
 # fuzzgpu-core = { version = "0.1.7", default-features = false } # CPU-only
 ```
 

{fuzzgpu-0.1.7 → fuzzgpu-0.2.0}/crates/fuzzgpu-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fuzzgpu-core"
-version = "0.1.7"
+version = "0.2.0"
 edition = "2021"
 description = "GPU-accelerated fuzzy string matching engine"
 license = "MIT"

{fuzzgpu-0.1.7 → fuzzgpu-0.2.0}/crates/fuzzgpu-core/benches/bench.rs

@@ -13,7 +13,9 @@ use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use fuzzgpu_core::damerau::damerau_levenshtein_batch;
 use fuzzgpu_core::fuzz::ratio;
 use fuzzgpu_core::jaro::{jaro_winkler, jaro_winkler_batch};
-use fuzzgpu_core::levenshtein::{levenshtein_cdist_cpu, levenshtein_distance_raw, LevenshteinKernel};
+use fuzzgpu_core::levenshtein::{
+    levenshtein_cdist_cpu, levenshtein_distance_raw, LevenshteinKernel,
+};
 use fuzzgpu_core::needleman::{needleman_wunsch_affine, needleman_wunsch_affine_batch};
 use fuzzgpu_core::simd::levenshtein_myers;
 
@@ -24,7 +26,9 @@ fn gen_strings(count: usize, len: usize, seed: u64) -> Vec<String> {
     for _ in 0..count {
         let mut s = String::with_capacity(len);
         for _ in 0..len {
-            state = state.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+            state = state
+                .wrapping_mul(6364136223846793005)
+                .wrapping_add(1442695040888963407);
             s.push((b'a' + ((state >> 33) as u8 % 26)) as char);
         }
         out.push(s);
@@ -47,7 +51,11 @@ fn cpu_benches(c: &mut Criterion) {
     let long = gen_strings(2, 256, 3);
 
     let mut g = c.benchmark_group("scalar");
-    for (name, s) in [("short_8", &short), ("medium_64", &medium), ("long_256", &long)] {
+    for (name, s) in [
+        ("short_8", &short),
+        ("medium_64", &medium),
+        ("long_256", &long),
+    ] {
         let (s1, s2) = (&s[0], &s[1]);
         g.bench_function(format!("levenshtein/{name}"), |b| {
             b.iter(|| black_box(levenshtein_distance_raw(s1, s2)))
@@ -62,7 +70,11 @@ fn cpu_benches(c: &mut Criterion) {
             b.iter(|| black_box(ratio(s1, s2)))
         });
         g.bench_function(format!("needleman_affine/{name}"), |b| {
-            b.iter(|| black_box(needleman_wunsch_affine(s1, s2, MATCH, MISMATCH, GAP_OPEN, GAP_EXTEND)))
+            b.iter(|| {
+                black_box(needleman_wunsch_affine(
+                    s1, s2, MATCH, MISMATCH, GAP_OPEN, GAP_EXTEND,
+                ))
+            })
         });
         g.bench_function(format!("damerau/{name}"), |b| {
             b.iter(|| black_box(fuzzgpu_core::damerau::damerau_levenshtein_distance(s1, s2)))
@@ -89,14 +101,27 @@ fn cpu_benches(c: &mut Criterion) {
         b.iter(|| black_box(jaro_winkler_batch(query, &cand_refs, 0.1)))
     });
     g.bench_function("needleman_affine_batch_1000", |b| {
-        b.iter(|| black_box(needleman_wunsch_affine_batch(query, &cand_refs, MATCH, MISMATCH, GAP_OPEN, GAP_EXTEND)))
+        b.iter(|| {
+            black_box(needleman_wunsch_affine_batch(
+                query, &cand_refs, MATCH, MISMATCH, GAP_OPEN, GAP_EXTEND,
+            ))
+        })
     });
     // Long-string needleman (80 chars): the anti-diagonal wavefront GPU path's
     // target workload; Rayon CPU is the comparison baseline.
     let cands_nw80 = gen_strings(1000, 80, 0xAB);
     let cand_refs_nw80: Vec<&str> = cands_nw80.iter().map(|s| s.as_str()).collect();
     g.bench_function("needleman_affine_batch_1000_long80_large", |b| {
-        b.iter(|| black_box(needleman_wunsch_affine_batch(query, &cand_refs_nw80, MATCH, MISMATCH, GAP_OPEN, GAP_EXTEND)))
+        b.iter(|| {
+            black_box(needleman_wunsch_affine_batch(
+                query,
+                &cand_refs_nw80,
+                MATCH,
+                MISMATCH,
+                GAP_OPEN,
+                GAP_EXTEND,
+            ))
+        })
     });
     g.bench_function("damerau_batch_1000", |b| {
         b.iter(|| black_box(damerau_levenshtein_batch(query, &cand_refs)))
@@ -128,8 +153,9 @@ fn cpu_benches(c: &mut Criterion) {
         b.iter(|| black_box(levenshtein_cdist_cpu(&refs_a_1k, &refs_b_1k)))
     });
     // Sequential 10 x 1000 pairs: the CPU baseline for the batched-GPU bench.
-    let cands10: Vec<Vec<String>> =
-        (0..10).map(|i| gen_strings(1000, 16, 0x100 + i as u64)).collect();
+    let cands10: Vec<Vec<String>> = (0..10)
+        .map(|i| gen_strings(1000, 16, 0x100 + i as u64))
+        .collect();
     let ops10: Vec<Vec<(&str, &str)>> = cands10.iter().map(|c| make_pairs(query, c)).collect();
     g.bench_function("levenshtein_10x1000_seq_cpu", |b| {
         b.iter(|| {
@@ -190,13 +216,23 @@ fn gpu_benches(c: &mut Criterion) {
     match GpuNeedlemanAffineKernel::get() {
         Ok(kernel) => {
             g.bench_function("needleman_affine_batch_1000", |b| {
-                b.iter(|| black_box(kernel.compute_batch(&pairs, MATCH, MISMATCH, GAP_OPEN, GAP_EXTEND)))
+                b.iter(|| {
+                    black_box(kernel.compute_batch(&pairs, MATCH, MISMATCH, GAP_OPEN, GAP_EXTEND))
+                })
             });
             // 80-char pairs: routes to the anti-diagonal wavefront kernel.
             let cands_nw80 = gen_strings(1000, 80, 0xAB);
             let pairs_nw80 = make_pairs(query, &cands_nw80);
             g.bench_function("needleman_affine_batch_1000_long80_large", |b| {
-                b.iter(|| black_box(kernel.compute_batch(&pairs_nw80, MATCH, MISMATCH, GAP_OPEN, GAP_EXTEND)))
+                b.iter(|| {
+                    black_box(kernel.compute_batch(
+                        &pairs_nw80,
+                        MATCH,
+                        MISMATCH,
+                        GAP_OPEN,
+                        GAP_EXTEND,
+                    ))
+                })
             });
         }
         Err(e) => {
@@ -247,9 +283,11 @@ fn gpu_benches(c: &mut Criterion) {
             });
             // 10 x 1000 pairs: one batched dispatch+readback vs 10 sequential
             // sync-round-trips. Same total work as cpu_batch/..._seq_cpu.
-            let cands10: Vec<Vec<String>> =
-                (0..10).map(|i| gen_strings(1000, 16, 0x100 + i as u64)).collect();
-            let ops10: Vec<Vec<(&str, &str)>> = cands10.iter().map(|c| make_pairs(query, c)).collect();
+            let cands10: Vec<Vec<String>> = (0..10)
+                .map(|i| gen_strings(1000, 16, 0x100 + i as u64))
+                .collect();
+            let ops10: Vec<Vec<(&str, &str)>> =
+                cands10.iter().map(|c| make_pairs(query, c)).collect();
             g.bench_function("levenshtein_10x1000_seq", |b| {
                 b.iter(|| {
                     for op in &ops10 {
@@ -268,10 +306,16 @@ fn gpu_benches(c: &mut Criterion) {
             });
         }
         Err(e) => {
-            eprintln!("WARN: no GPU device, skipping large-scale GpuLevenshteinKernel benches: {e}");
+            eprintln!(
+                "WARN: no GPU device, skipping large-scale GpuLevenshteinKernel benches: {e}"
+            );
             g.bench_function("levenshtein_batch_100k_large", |b| b.iter(|| black_box(0)));
-            g.bench_function("levenshtein_batch_1000_long256_large", |b| b.iter(|| black_box(0)));
-            g.bench_function("levenshtein_cdist_1000x1000_large", |b| b.iter(|| black_box(0)));
+            g.bench_function("levenshtein_batch_1000_long256_large", |b| {
+                b.iter(|| black_box(0))
+            });
+            g.bench_function("levenshtein_cdist_1000x1000_large", |b| {
+                b.iter(|| black_box(0))
+            });
             g.bench_function("levenshtein_10x1000_seq", |b| b.iter(|| black_box(0)));
             g.bench_function("levenshtein_10x1000_batched", |b| b.iter(|| black_box(0)));
         }