Free the CUDA context on Gpu drop (fix cuCtxCreate OOM)

Gpu had no Drop impl, so every finished fragment leaked its CUDA context
and loaded module. Each context reserves a few hundred MB of device
memory, so after a few dozen fragments cuCtxCreate started failing with
"out of memory" and the worker spun claiming fragments it could never
run.

Add Drop for Gpu (cuModuleUnload + cuCtxDestroy) and drop the now-stale
allow(dead_code) on the ctx field. Add an ignore-gated GPU regression
test that creates/drops a Gpu 64 times: it passes with the fix and dies
at iteration ~56 with the exact OOM without it. Bump version to 0.1.7.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: MagicalTux

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "decryptd"
-version = "0.1.6"
+version = "0.1.7"
 edition = "2024"
 license = "Proprietary"
 authors = ["Karpeles Lab Inc"]

Cargo.toml

@@ -33,6 +33,7 @@ unsafe extern "C" {
     fn cuCtxCreate_v2(pctx: *mut CuContext, flags: u32, dev: CuDevice) -> CuResult;
     fn cuCtxDestroy_v2(ctx: CuContext) -> CuResult;
     fn cuModuleLoadData(module: *mut CuModule, image: *const c_void) -> CuResult;
+    fn cuModuleUnload(module: CuModule) -> CuResult;
     fn cuModuleGetFunction(
         func: *mut CuFunction,
         module: CuModule,
@@ -120,7 +121,6 @@ impl Drop for DeviceBuf {
 
 /// An initialized CUDA context with a module loaded.
 pub struct Gpu {
-    #[allow(dead_code)]
     ctx: CuContext,
     module: CuModule,
     dev: CuDevice,
@@ -207,6 +207,20 @@ impl Gpu {
     }
 }
 
+impl Drop for Gpu {
+    /// Release the module and context. Without this every finished fragment leaks
+    /// its CUDA context; after enough fragments `cuCtxCreate` starts failing with
+    /// `out of memory` (each context reserves device memory) and no further work
+    /// runs. `cuCtxDestroy` alone frees the module too, but unload it explicitly
+    /// so the ordering mirrors acquisition.
+    fn drop(&mut self) {
+        unsafe {
+            cuModuleUnload(self.module);
+            cuCtxDestroy_v2(self.ctx);
+        }
+    }
+}
+
 /// Run the generic kernel `entry` over `[start, end]` (inclusive), tiling by `tile`
 /// items per launch. `data` is the opaque job blob (uploaded once). Returns the raw
 /// output records (`out_count * record_size` bytes, concatenated across tiles), and
@@ -307,3 +321,33 @@ impl DeviceBufView {
         )
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Regression test for the leaked-context OOM: create and drop a `Gpu` many
+    /// times and confirm `cuCtxCreate` keeps succeeding. Before `Drop for Gpu`,
+    /// each iteration leaked its context and this loop died with "out of memory"
+    /// after a few dozen rounds. Needs a real GPU + a cubin, so it's `#[ignore]`d;
+    /// run manually with the cubin path in DECRYPTD_TEST_CUBIN:
+    ///   DECRYPTD_TEST_CUBIN=/path/to/x.sm89.cubin cargo test --release -- --ignored gpu_context
+    #[test]
+    #[ignore]
+    fn gpu_context_is_freed_across_runs() {
+        let Ok(path) = std::env::var("DECRYPTD_TEST_CUBIN") else {
+            panic!("set DECRYPTD_TEST_CUBIN to a cubin matching this GPU's arch");
+        };
+        let bytes = std::fs::read(&path).expect("read cubin");
+        // Tag arch 0 so the "skip cubins newer than the GPU" filter always keeps
+        // it; the real cubin must still match this GPU for cuModuleLoadData.
+        let cubins = vec![(0u32, bytes)];
+        for i in 0..64 {
+            let gpu = Gpu::load_first(&cubins)
+                .unwrap_or_else(|e| panic!("iteration {i}: load_first failed: {e}"));
+            // Touch it so the context is really used, then drop at end of scope.
+            let _ = gpu.compute_capability();
+            drop(gpu);
+        }
+    }
+}