fuzzgpu 0.2.0__tar.gz → 0.3.0__tar.gz

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

@@ -308,9 +308,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.17.0"
+version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"
+checksum = "252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34"
 
 [[package]]
 name = "equivalent"
@@ -372,7 +372,7 @@ dependencies = [
 
 [[package]]
 name = "fuzzgpu-core"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "bytemuck",
  "criterion",
@@ -386,7 +386,7 @@ dependencies = [
 
 [[package]]
 name = "fuzzgpu-python"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "fuzzgpu-core",
  "log",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fuzzgpu
-Version: 0.2.0
+Version: 0.3.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -37,7 +37,8 @@ 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.2.0-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
+[![PyPI 
+Version](https://img.shields.io/badge/pypi-v0.3.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,7 +61,7 @@ No NVIDIA CUDA drivers or complex toolkits required.
 
 ---
 
-## What's New in v0.2.0
+## What's New in v0.3.0
 
 ### Production hardening
 - **Kernel `get()` panics eliminated** — all four GPU kernels (`GpuLevenshteinKernel`,
@@ -164,7 +165,7 @@ 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 — integrated GPU (Vulkan) + Intel Core i7 (Rayon, all cores)*
-*Versions: fuzzgpu 0.2.0 · rapidfuzz 3.14.5 · python-Levenshtein 0.27.4*
+*Versions: fuzzgpu 0.3.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
@@ -229,7 +230,7 @@ pip install fuzzgpu
 ```toml
 # Rust
 [dependencies]
-fuzzgpu-core = "0.2.0"
+fuzzgpu-core = "0.3.0"
 ```
 
 ---
@@ -325,7 +326,7 @@ fuzzgpu.set_cpu_only(True)       # force CPU-only mode
 
 ```toml
 [dependencies]
-fuzzgpu-core = "0.2.0"                                        # GPU + CPU fallback
+fuzzgpu-core = "0.3.0"                                        # GPU + CPU fallback
 # fuzzgpu-core = { version = "0.1.7", default-features = false } # CPU-only
 ```
 
@@ -471,7 +472,7 @@ cargo test --workspace
 | `FUZZGPU_DEBUG` | Log GPU→CPU fallback decisions |
 | `FUZZGPU_SIMD` | Force ISA: `portable\|neon\|avx2\|avx512` |
 | `FUZZGPU_READBACK_TIMEOUT_MS` | GPU readback timeout (default 10000 ms) |
-| `FUZZGPU_SKIP_DISPATCH_LOCK` | Bypass serialization lock (repro only) |
+| `FUZZGPU_SKIP_DISPATCH_LOCK` | Opt-in GPU dispatch serialization (safety valve for the rare gfx-rs/wgpu#10085 crash class on Intel D3D12; dispatch is fully concurrent by default) |
 | `FUZZGPU_REQUIRE_GPU` | In tests: fail instead of skip when no GPU |
 | `WGPU_BACKEND` | Force wgpu backend: `vulkan\|metal\|dx12` |
 | `PROPTEST_CASES` | Override proptest case count |

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

@@ -8,7 +8,8 @@
 
 *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.2.0-blue.svg?style=flat-square)](https://pypi.org/project/fuzzgpu/)
+[![PyPI 
+Version](https://img.shields.io/badge/pypi-v0.3.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,7 +32,7 @@ No NVIDIA CUDA drivers or complex toolkits required.
 
 ---
 
-## What's New in v0.2.0
+## What's New in v0.3.0
 
 ### Production hardening
 - **Kernel `get()` panics eliminated** — all four GPU kernels (`GpuLevenshteinKernel`,
@@ -135,7 +136,7 @@ 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 — integrated GPU (Vulkan) + Intel Core i7 (Rayon, all cores)*
-*Versions: fuzzgpu 0.2.0 · rapidfuzz 3.14.5 · python-Levenshtein 0.27.4*
+*Versions: fuzzgpu 0.3.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
@@ -200,7 +201,7 @@ pip install fuzzgpu
 ```toml
 # Rust
 [dependencies]
-fuzzgpu-core = "0.2.0"
+fuzzgpu-core = "0.3.0"
 ```
 
 ---
@@ -296,7 +297,7 @@ fuzzgpu.set_cpu_only(True)       # force CPU-only mode
 
 ```toml
 [dependencies]
-fuzzgpu-core = "0.2.0"                                        # GPU + CPU fallback
+fuzzgpu-core = "0.3.0"                                        # GPU + CPU fallback
 # fuzzgpu-core = { version = "0.1.7", default-features = false } # CPU-only
 ```
 
@@ -442,7 +443,7 @@ cargo test --workspace
 | `FUZZGPU_DEBUG` | Log GPU→CPU fallback decisions |
 | `FUZZGPU_SIMD` | Force ISA: `portable\|neon\|avx2\|avx512` |
 | `FUZZGPU_READBACK_TIMEOUT_MS` | GPU readback timeout (default 10000 ms) |
-| `FUZZGPU_SKIP_DISPATCH_LOCK` | Bypass serialization lock (repro only) |
+| `FUZZGPU_SKIP_DISPATCH_LOCK` | Opt-in GPU dispatch serialization (safety valve for the rare gfx-rs/wgpu#10085 crash class on Intel D3D12; dispatch is fully concurrent by default) |
 | `FUZZGPU_REQUIRE_GPU` | In tests: fail instead of skip when no GPU |
 | `WGPU_BACKEND` | Force wgpu backend: `vulkan\|metal\|dx12` |
 | `PROPTEST_CASES` | Override proptest case count |

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

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

{fuzzgpu-0.2.0 → fuzzgpu-0.3.0}/crates/fuzzgpu-core/src/gpu.rs

@@ -25,25 +25,23 @@ pub fn require_gpu() -> bool {
         .unwrap_or(false)
 }
 
-/// Whether the dispatch-serialization workaround is bypassed. Shared by the
-/// test-only lock below and the production [`GpuEngine::dispatch_lock`] so
-/// `FUZZGPU_SKIP_DISPATCH_LOCK=1` disables BOTH — the repro harness needs the
-/// bypass to reproduce upstream gfx-rs/wgpu#10085 under real concurrency.
-pub(crate) fn dispatch_lock_bypass() -> bool {
+/// Opt-in dispatch serialization (safety valve). `FUZZGPU_SKIP_DISPATCH_LOCK=1`
+/// re-enables the GPU-dispatch serialization that used to be the default
+/// workaround for the rare gfx-rs/wgpu#10085 crash class (heap corruption on
+/// Intel D3D12 under >=3 concurrent dispatchers on a shared device). Dispatch
+/// is fully concurrent by default; set this env var on affected Intel hardware
+/// to serialize both the production dispatch path and the test suite.
+pub(crate) fn dispatch_serialize() -> bool {
     std::env::var("FUZZGPU_SKIP_DISPATCH_LOCK")
         .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
         .unwrap_or(false)
 }
 
-/// Serialize GPU access across tests. This is a workaround for a wgpu/driver
-/// crash on Intel Iris Xe under >=3 concurrent dispatchers on the shared
-/// device (heap corruption on DX12, segfault on Vulkan) — see
-/// `repro/wgpu-parallel-crash` and upstream gfx-rs/wgpu#10085.
-///
-/// Setting `FUZZGPU_SKIP_DISPATCH_LOCK=1` bypasses the workaround so the
-/// underlying crash can be reproduced / bisected in CI or locally.
+/// Serialize GPU access across tests. Only active when
+/// `FUZZGPU_SKIP_DISPATCH_LOCK=1` (opt-in safety valve); by default returns
+/// `None` so the test suite runs with fully concurrent GPU dispatch.
 pub fn gpu_test_lock() -> Option<std::sync::MutexGuard<'static, ()>> {
-    if dispatch_lock_bypass() {
+    if !dispatch_serialize() {
         return None;
     }
     Some(
@@ -99,21 +97,10 @@ pub(crate) fn effective_shader_source(real: &'static str) -> std::borrow::Cow<'s
     std::borrow::Cow::Borrowed(real)
 }
 
-/// Serialize GPU access across tests.
-///
-/// This is a workaround for a `wgpu-core` bug (`Queue::drop` spurious
-/// `assert!(queue_empty)` panic under concurrent dispatch) filed as
-/// gfx-rs/wgpu#10085. The fix is in branch `fix/queue-drop-drain-loop`
-/// (PR pending merge into `gfx-rs/wgpu`).
-///
-/// **Removal plan:** once the wgpu fix ships in a released version and
-/// `fuzzgpu` bumps its dependency to that version, remove:
-/// - This lock and its static
-/// - `dispatch_lock_bypass()` and `FUZZGPU_SKIP_DISPATCH_LOCK` support
-/// - `GpuEngine::dispatch_lock` field and `dispatch_lock()` method
-///
-/// Setting `FUZZGPU_SKIP_DISPATCH_LOCK=1` bypasses the workaround so the
-/// underlying crash can be reproduced / bisected in CI or locally.
+/// Test-suite dispatch serialization, active only when
+/// `FUZZGPU_SKIP_DISPATCH_LOCK=1` (opt-in safety valve for the rare
+/// gfx-rs/wgpu#10085 crash class on Intel D3D12). By default the suite runs
+/// with fully concurrent GPU dispatch.
 pub static GPU_TEST_DISPATCH_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
 
 /// Serializes tests that mutate `GPU_THRESHOLD_OVERRIDE`.
@@ -236,13 +223,11 @@ pub struct GpuEngine {
     pub info: GpuInfo,
     pub max_buffer_size: u64,
     pub max_storage_buffer_binding_size: u32,
-    /// Serializes GPU dispatch across threads. The upstream wgpu/driver crash
-    /// (gfx-rs/wgpu#10085) triggers under >=3 concurrent dispatchers on the
-    /// shared device (Intel iGPUs, DX12/Vulkan) — e.g. two Python threads
-    /// calling the GIL-releasing GPU bindings simultaneously. Every public GPU
+    /// Opt-in dispatch serialization (safety valve for the rare
+    /// gfx-rs/wgpu#10085 crash class on Intel D3D12). By default dispatch is
+    /// fully concurrent; when `FUZZGPU_SKIP_DISPATCH_LOCK=1` every public GPU
     /// entry point holds this lock for the duration of its dispatch + readback,
-    /// so at most one submission is ever in flight. `FUZZGPU_SKIP_DISPATCH_LOCK`
-    /// bypasses it (repro harness only).
+    /// so at most one submission is ever in flight.
     dispatch_lock: std::sync::Mutex<()>,
 }
 
@@ -533,11 +518,11 @@ impl GpuEngine {
         Ok(bytes)
     }
 
-    /// Take the production dispatch lock (see the field doc). Returns `None`
-    /// when `FUZZGPU_SKIP_DISPATCH_LOCK` is set so the repro harness can
-    /// reproduce upstream #10085 under real concurrency.
+    /// Take the opt-in dispatch serialization lock (see the field doc).
+    /// Returns `None` unless `FUZZGPU_SKIP_DISPATCH_LOCK=1` is set — dispatch
+    /// is fully concurrent by default.
     pub(crate) fn dispatch_lock(&self) -> Option<std::sync::MutexGuard<'_, ()>> {
-        if dispatch_lock_bypass() {
+        if !dispatch_serialize() {
             return None;
         }
         Some(self.dispatch_lock.lock().unwrap_or_else(|e| e.into_inner()))
@@ -722,13 +707,16 @@ mod tests {
 
     /// `set_gpu_threshold` must override the auto value and be resettable to
     /// auto (`None`) at runtime (a `Mutex`, not a one-shot `OnceLock`). The
-    /// override is global, so this test holds the GPU test lock — serializing
-    /// it against every other GPU test, which would otherwise see the
-    /// temporary override (e.g. a 1000-pair fault-injection test routed to
-    /// CPU instead of dispatching) — and restores `None` before returning.
+    /// override is global, so this test holds `GPU_THRESHOLD_TEST_LOCK` —
+    /// excluding every other test that mutates or force-reads the override
+    /// (fault-injection tests route to CPU instead of dispatching when a
+    /// concurrent test steals the override mid-flight) — and restores `None`
+    /// before returning.
     #[test]
     fn test_set_gpu_threshold_override_and_reset() {
-        let _gpu_guard = gpu_test_lock();
+        let _thr = GPU_THRESHOLD_TEST_LOCK
+            .lock()
+            .unwrap_or_else(|e| e.into_inner());
         GpuEngine::set_gpu_threshold(Some(1234));
         assert_eq!(GpuEngine::gpu_threshold_override(), Some(1234));
         if let Ok(engine) = GpuEngine::get() {
@@ -808,12 +796,20 @@ mod tests {
         disarm_shader_error_fault();
     }
 
-    /// dispatch_lock_bypass must read FUZZGPU_SKIP_DISPATCH_LOCK and return
-    /// true only when it is set to '1' or 'true' (case-insensitive).
+    /// dispatch_serialize must read FUZZGPU_SKIP_DISPATCH_LOCK and return
+    /// true only when it is set to '1' or 'true' (case-insensitive). The
+    /// serialization is opt-in: unset (default) means fully concurrent.
     #[test]
-    fn test_dispatch_lock_bypass_default_is_false() {
+    fn test_dispatch_serialize_opt_in() {
+        std::env::remove_var("FUZZGPU_SKIP_DISPATCH_LOCK");
+        assert!(!dispatch_serialize());
+        std::env::set_var("FUZZGPU_SKIP_DISPATCH_LOCK", "1");
+        assert!(dispatch_serialize());
+        std::env::set_var("FUZZGPU_SKIP_DISPATCH_LOCK", "true");
+        assert!(dispatch_serialize());
+        std::env::set_var("FUZZGPU_SKIP_DISPATCH_LOCK", "0");
+        assert!(!dispatch_serialize());
         std::env::remove_var("FUZZGPU_SKIP_DISPATCH_LOCK");
-        assert!(!dispatch_lock_bypass());
     }
 
     /// force_gpu_threshold sets the override and its Drop resets to None.

{fuzzgpu-0.2.0 → fuzzgpu-0.3.0}/crates/fuzzgpu-core/src/jaro.rs

@@ -817,7 +817,8 @@ pub mod gpu_ext {
                 // Decode 4×u32 per pair and assemble the f64 score host-side
                 // (bit-exact with the CPU reference). GPU_RECOMPUTE pairs are
                 // returned as -1.0; compute_batch recomputes them on CPU.
-                for (t, part) in raw.chunks_exact(4).enumerate() {
+                for (t, chunk_start) in (0..raw.len()).step_by(4).enumerate() {
+                    let part = &raw[chunk_start..chunk_start + 4];
                     if part[0] == GPU_RECOMPUTE {
                         gpu_results.push(-1.0);
                     } else {

{fuzzgpu-0.2.0 → fuzzgpu-0.3.0}/crates/fuzzgpu-core/src/levenshtein.rs

@@ -2040,8 +2040,9 @@ pub mod gpu_ext {
             };
             // Force GPU dispatch: below the auto threshold the fault is never
             // exercised because the batch routes to CPU before reaching the GPU
-            // readback path.
-            GpuEngine::set_gpu_threshold(Some(1));
+            // readback path. The RAII guard holds the threshold lock, so no
+            // concurrent test can steal or reset the override mid-dispatch.
+            let _force = crate::gpu::force_gpu_threshold(1);
 
             let a = gen_strings(1000, 0xABCDEF01);
             let b = gen_strings(1000, 0x23456789);
@@ -2054,7 +2055,6 @@ pub mod gpu_ext {
             crate::gpu::arm_readback_timeout_fault();
             let result = kernel.compute(&pairs);
             crate::gpu::disarm_readback_timeout_fault();
-            GpuEngine::set_gpu_threshold(None);
 
             match result {
                 Err(FuzzGpuError::Timeout(_)) => {} // expected
@@ -2070,7 +2070,7 @@ pub mod gpu_ext {
             let Some(kernel) = gpu_kernel_or_skip() else {
                 return;
             };
-            GpuEngine::set_gpu_threshold(Some(1));
+            let _force = crate::gpu::force_gpu_threshold(1);
 
             let a = gen_strings(30, 0x11111111);
             let b = gen_strings(30, 0x22222222);
@@ -2080,7 +2080,6 @@ pub mod gpu_ext {
             crate::gpu::arm_readback_timeout_fault();
             let result = kernel.compute_matrix(&refs_a, &refs_b);
             crate::gpu::disarm_readback_timeout_fault();
-            GpuEngine::set_gpu_threshold(None);
 
             match result {
                 Err(FuzzGpuError::Timeout(_)) => {} // expected
@@ -2097,7 +2096,7 @@ pub mod gpu_ext {
             let Some(kernel) = gpu_kernel_or_skip() else {
                 return;
             };
-            GpuEngine::set_gpu_threshold(Some(1));
+            let _force = crate::gpu::force_gpu_threshold(1);
 
             let a = gen_strings(1000, 0x0BADF00D);
             let b = gen_strings(1000, 0xF00DBABE);
@@ -2110,7 +2109,6 @@ pub mod gpu_ext {
             crate::gpu::arm_small_buffer_fault();
             let result = kernel.compute(&pairs);
             crate::gpu::disarm_small_buffer_fault();
-            GpuEngine::set_gpu_threshold(None);
 
             match result {
                 Err(FuzzGpuError::BufferError(_)) => {} // expected

{fuzzgpu-0.2.0 → fuzzgpu-0.3.0}/crates/fuzzgpu-core/src/needleman.rs

@@ -1485,7 +1485,6 @@ mod tests {
     #[cfg(feature = "gpu")]
     mod gpu_tests {
         use super::*;
-        use crate::gpu::GpuEngine;
         use crate::needleman::gpu_ext::GpuNeedlemanAffineKernel;
 
         fn gpu_kernel_or_skip() -> Option<&'static GpuNeedlemanAffineKernel> {
@@ -1532,7 +1531,9 @@ mod tests {
             let Some(kernel) = gpu_kernel_or_skip() else {
                 return;
             };
-            GpuEngine::set_gpu_threshold(Some(1));
+            // RAII: holds the threshold lock so no concurrent test can steal
+            // the override, and restores `None` on drop.
+            let _force = crate::gpu::force_gpu_threshold(1);
 
             let mut state: u64 = 0xDEAD_CAFE;
             let mut pairs: Vec<(String, String)> = Vec::with_capacity(500);
@@ -1567,7 +1568,6 @@ mod tests {
                 .map(|(a, b)| needleman_wunsch_affine(a, b, 2, -1, -3, -1))
                 .collect();
             assert_eq!(gpu, cpu, "GPU NW must match CPU for normal scoring range");
-            GpuEngine::set_gpu_threshold(None);
         }
     }
 }

{fuzzgpu-0.2.0 → fuzzgpu-0.3.0}/crates/fuzzgpu-core/src/simd.rs

@@ -779,7 +779,7 @@ pub fn jaro_bitpar(a: &[u8], b: &[u8]) -> f64 {
 
         let cand = pos_b[a[i] as usize] & window & !matched_b;
         if cand != 0 {
-            let lowest = cand & cand.wrapping_neg();
+            let lowest = cand.isolate_lowest_one();
             matched_b |= lowest;
             matched_a |= 1u64 << i;
             matches += 1;

{fuzzgpu-0.2.0 → fuzzgpu-0.3.0}/crates/fuzzgpu-core/tests/differential.rs

@@ -532,17 +532,27 @@ mod gpu_differential {
     use fuzzgpu_core::needleman::gpu_ext::GpuNeedlemanAffineKernel;
     use std::sync::{Mutex, MutexGuard};
 
-    /// Serializes GPU access across the differential tests. The lib suite's
-    /// equivalent (`gpu::GPU_TEST_DISPATCH_LOCK`) is `#[cfg(test)]`-only and
-    /// invisible to integration tests, so this is a local copy — the same
-    /// workaround for the same wgpu/driver crash (gfx-rs/wgpu#10085) observed
-    /// under >=3 concurrent dispatchers on the shared device (Intel Iris Xe).
+    /// Opt-in GPU serialization across the differential tests, mirroring the
+    /// lib's contract: fully concurrent by default; when
+    /// `FUZZGPU_SKIP_DISPATCH_LOCK=1` (opt-in safety valve for the rare
+    /// gfx-rs/wgpu#10085 crash class) the lock serializes dispatch.
     static GPU_TEST_DISPATCH_LOCK: Mutex<()> = Mutex::new(());
 
-    fn gpu_test_lock() -> MutexGuard<'static, ()> {
-        GPU_TEST_DISPATCH_LOCK
-            .lock()
-            .unwrap_or_else(|e| e.into_inner())
+    fn dispatch_serialize() -> bool {
+        std::env::var("FUZZGPU_SKIP_DISPATCH_LOCK")
+            .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
+            .unwrap_or(false)
+    }
+
+    fn gpu_test_lock() -> Option<MutexGuard<'static, ()>> {
+        if !dispatch_serialize() {
+            return None;
+        }
+        Some(
+            GPU_TEST_DISPATCH_LOCK
+                .lock()
+                .unwrap_or_else(|e| e.into_inner()),
+        )
     }
 
     /// When `FUZZGPU_REQUIRE_GPU` is set (CI with a software Vulkan adapter),

{fuzzgpu-0.2.0 → fuzzgpu-0.3.0}/crates/fuzzgpu-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fuzzgpu-python"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 description = "Python bindings for FuzzGPU: GPU-accelerated fuzzy string matching engine"
 license = "MIT"
@@ -17,7 +17,7 @@ default = ["gpu"]
 gpu = ["fuzzgpu-core/gpu"]
 
 [dependencies]
-fuzzgpu-core = { path = "../fuzzgpu-core", version = "0.2.0", default-features = false }
+fuzzgpu-core = { path = "../fuzzgpu-core", version = "0.3.0", default-features = false }
 pyo3 = { workspace = true, features = ["abi3-py310"] }
 numpy = "0.23"
 pollster = { workspace = true }

{fuzzgpu-0.2.0 → fuzzgpu-0.3.0}/crates/fuzzgpu-wasm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fuzzgpu-wasm"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 
 [workspace]

{fuzzgpu-0.2.0 → fuzzgpu-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "fuzzgpu"
-version = "0.2.0"
+version = "0.3.0"
 description = "Hardware-accelerated fuzzy string matching & sequence alignment — cross-platform, no CUDA required"
 readme = "README.md"
 license = { text = "MIT" }