tensorfs 0.3.90__tar.gz → 0.3.91__tar.gz

{tensorfs-0.3.90 → tensorfs-0.3.91}/Cargo.lock

@@ -449,7 +449,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tensorfs-core"
-version = "0.3.90"
+version = "0.3.91"
 dependencies = [
  "fs2",
  "libc",
@@ -464,7 +464,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-plane"
-version = "0.3.90"
+version = "0.3.91"
 dependencies = [
  "libc",
  "libloading",
@@ -474,7 +474,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-py"
-version = "0.3.90"
+version = "0.3.91"
 dependencies = [
  "pyo3",
  "tensorfs-core",

{tensorfs-0.3.90 → tensorfs-0.3.91}/Cargo.toml

@@ -3,5 +3,5 @@ resolver = "2"
 members = ["crates/tensorfs-core", "crates/tensorfs-plane", "crates/tensorfs-py"]
 
 [workspace.package]
-version = "0.3.90"
+version = "0.3.91"
 edition = "2021"

{tensorfs-0.3.90 → tensorfs-0.3.91}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorfs
-Version: 0.3.90
+Version: 0.3.91
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Rust

{tensorfs-0.3.90 → tensorfs-0.3.91}/crates/tensorfs-plane/API.md

@@ -1,4 +1,4 @@
-# tensorfs.plane — Python API (v3.1, 2026-10-02)
+# tensorfs.plane — Python API (v3.2, 2026-10-02)
 
 The weight plane moves bytes; cozy-runtime decides. The plane never measures free memory,
 never picks victims among equals, never reorders a schedule. It ships inside the `tensorfs`
@@ -240,10 +240,16 @@ stream cannot drain is `Poisoned`.
 **Poison is latched plane-wide**: an ambiguous driver outcome (a failed unmap or rollback, an
 undrainable copy failure, a driver mapping that disagrees with the books) or a lease dropped
 unreleased makes every later call raise `Poisoned` with the first cause; the runtime replaces
-the executor. A poisoned plane never unmaps, unregisters or frees a range (copies may still
-touch it): `ws.close()`, `cur.close()` and `p.close()` raise `Poisoned` and the process keeps
-the ranges until it exits. Capacity never poisons (`BudgetExceeded`, `Shortfall` leave the
-plane usable).
+the executor. A poisoned plane never unmaps, unregisters or frees a range while it lives
+(copies may still touch it): `ws.close()`, `cur.close()` and `p.close()` raise `Poisoned`.
+Capacity never poisons (`BudgetExceeded`, `Shortfall` leave the plane usable).
+
+**A plane collected without `close()`** (its handles dropped in any order, or poisoned) is
+torn down when its last handle goes: its threads stop, and once every device has run all
+queued work, its device ranges are unmapped, its handles released and its pinned RAM let go as
+`close()` would. Only a device that cannot be synchronized keeps its ranges and the pinned
+tier until the process exits. Closing is still the contract: collection order decides when
+an unclosed plane ends.
 
 ## Host tier across processes
 
@@ -274,6 +280,11 @@ plane usable).
 
 ## Changelog
 
+- v3.2 2026-10-02 (W3: fd and thread growth per weight set): a plane collected unclosed or
+  poisoned is torn down at its last handle (threads, device memory, pinned memfds) once its
+  devices are synchronized; before, its reader threads stayed and a poisoned plane kept its
+  memfds for the life of the process.
+
 - v3.1 2026-10-02 (Xid 31; W3 run 2675): a failed copy is reported only after its stream drained;
   an undrainable one poisons; a poisoned plane never unmaps (close raises `Poisoned`).
   `verify_bytes()` after release raises `Invalid`. Pinned-tier claims: close and eviction punch

{tensorfs-0.3.90 → tensorfs-0.3.91}/crates/tensorfs-plane/src/cuda.rs

@@ -106,6 +106,7 @@ pub struct Driver {
     pub ctx_get_current: F<*mut CUcontext>,
     pub ctx_set_current: F<CUcontext>,
     pub ctx_synchronize: unsafe extern "C" fn() -> CUresult,
+    pub mem_get_info: unsafe extern "C" fn(*mut usize, *mut usize) -> CUresult,
     pub stream_create: unsafe extern "C" fn(*mut CUstream, c_uint) -> CUresult,
     pub stream_destroy: F<CUstream>,
     pub stream_synchronize: F<CUstream>,
@@ -189,6 +190,7 @@ impl Driver {
             ctx_get_current: load!(lib, b"cuCtxGetCurrent"),
             ctx_set_current: load!(lib, b"cuCtxSetCurrent"),
             ctx_synchronize: load!(lib, b"cuCtxSynchronize"),
+            mem_get_info: load!(lib, b"cuMemGetInfo_v2"),
             stream_create: load!(lib, b"cuStreamCreate"),
             stream_destroy: load!(lib, b"cuStreamDestroy_v2"),
             stream_synchronize: load!(lib, b"cuStreamSynchronize"),

{tensorfs-0.3.90 → tensorfs-0.3.91}/crates/tensorfs-plane/src/cursor.rs

@@ -72,6 +72,10 @@ pub(crate) struct Cur {
 }
 
 impl Cur {
+    /// (device slot, ring base, ring length, ring handles), for a plane torn down unclosed.
+    pub(crate) fn into_ring(self) -> (usize, u64, u64, Vec<Chunk>) {
+        (self.dev, self.ring_base, self.ring_len, self.ring_chunks)
+    }
     fn streamed_total(&self) -> u64 {
         if self.total == u64::MAX {
             return u64::MAX;

{tensorfs-0.3.90 → tensorfs-0.3.91}/crates/tensorfs-plane/src/device.rs

@@ -431,8 +431,13 @@ impl Mover {
         }
     }
 
-    pub fn stop(&self) {
+    /// Close the queue: the thread drains its stream, frees its buffers and exits by itself.
+    pub fn detach(&self) {
         self.tx.lock().unwrap().take();
+    }
+
+    pub fn stop(&self) {
+        self.detach();
         if let Some(t) = self.thread.lock().unwrap().take() {
             let _ = t.join();
         }

{tensorfs-0.3.90 → tensorfs-0.3.91}/crates/tensorfs-plane/src/io.rs

@@ -278,10 +278,16 @@ impl Readers {
         self.q.1.notify_one();
     }
 
-    /// Finish queued jobs, then stop the threads.
-    pub fn shutdown(&self) {
+    /// Let the threads exit once the queue is empty; waits for nothing (the caller may be one
+    /// of them).
+    pub fn stop(&self) {
         self.q.0.lock().unwrap().stop = true;
         self.q.1.notify_all();
+    }
+
+    /// Finish queued jobs, then stop the threads.
+    pub fn shutdown(&self) {
+        self.stop();
         for t in self.threads.lock().unwrap().drain(..) {
             let _ = t.join();
         }

{tensorfs-0.3.90 → tensorfs-0.3.91}/crates/tensorfs-plane/src/plane.rs

@@ -1555,33 +1555,72 @@ impl Drop for Plane {
 }
 
 impl Drop for Inner {
-    /// The last reference can go while copies are still on the device: a plane dropped with a
-    /// fill queued ends inside that copy's completion. Pinned ranges are unregistered and
-    /// unmapped only after every copy reading them; a poisoned plane (or one whose events
-    /// cannot be waited) keeps them for the life of the process instead. Device ranges are
-    /// never unmapped here.
+    /// The last reference can go without `close()`: handles collected in any order, a plane
+    /// dropped with a fill queued (it ends inside that copy's completion), a poisoned plane.
+    /// Its threads stop, and once every device has run all queued work its ranges are unmapped,
+    /// its handles released and its pinned tier let go, exactly as `close()` would. A device
+    /// that cannot be synchronized keeps its ranges and the pinned tier for the life of the
+    /// process: a copy may still touch them.
     fn drop(&mut self) {
+        self.readers.stop();
+        for dev in &self.devices {
+            for m in &dev.movers {
+                m.detach();
+            }
+        }
         let c = self.core.get_mut().unwrap_or_else(|p| p.into_inner());
-        let mut settled = c.poisoned.is_none();
-        for w in c.sets.iter_mut().flatten() {
-            for h in &mut w.hregs {
-                settled &= sync_all(&mut h.pending).is_ok();
+        if teardown(&self.devices, c).is_err() {
+            for w in c.sets.iter().flatten() {
+                std::mem::forget(w.host.clone());
             }
-            for dw in w.devs.iter_mut().flatten() {
-                for reg in &mut dw.regs {
-                    if let DState::Filling(ev) = &reg.state {
-                        settled &= ev.sync().is_ok();
-                    }
-                    settled &= sync_all(&mut reg.pending).is_ok();
+        }
+    }
+}
+
+/// Free everything the books still hold, after the devices ran all queued work.
+fn teardown(devices: &[DeviceRt], c: &mut Core) -> Result<()> {
+    for dev in devices {
+        let _g = dev.bind()?;
+        // SAFETY: the device's context is bound.
+        cuda::check("cuCtxSynchronize", unsafe { (cuda::driver()?.ctx_synchronize)() })?;
+    }
+    let mut rings: Vec<(usize, u64, u64, Vec<Chunk>)> = c.cursors.drain().map(|(_, k)| k.into_ring()).collect();
+    for (d, dev) in devices.iter().enumerate() {
+        let _g = dev.bind()?;
+        let mut chunks = Vec::new();
+        for (_, base, len, held) in rings.iter_mut().filter(|r| r.0 == d && r.2 > 0) {
+            device::unmap_span(*base, *len)?;
+            device::free_va(*base, *len)?;
+            chunks.append(held);
+        }
+        for w in c.sets.iter_mut().flatten() {
+            let Some(dw) = w.devs[d].take() else { continue };
+            for (reg, region) in dw.regs.into_iter().zip(&w.layout.regions) {
+                if !reg.chunks.is_empty() {
+                    device::unmap_span(dw.base + region.offset, region.span)?;
+                    chunks.extend(reg.chunks);
                 }
             }
+            device::free_va(dw.base, w.layout.nbytes)?;
         }
-        if !settled {
-            for w in c.sets.iter().flatten() {
-                std::mem::forget(w.host.clone());
+        c.arenas[d].put_idle(chunks);
+        c.arenas[d].release_idle()?;
+    }
+    let first = devices.first().map(|d| d.ctx);
+    for w in c.sets.iter_mut().flatten() {
+        for (r, (h, region)) in w.hregs.iter_mut().zip(&w.layout.regions).enumerate() {
+            if h.registered {
+                let _g = first.map(CtxGuard::enter).transpose()?;
+                w.host.unregister(region.offset)?;
+                h.registered = false;
+            }
+            if matches!(h.state, HState::Ready) {
+                w.host.release(r as u32, region.offset, region.span)?;
+                h.state = HState::Absent;
             }
         }
     }
+    Ok(())
 }
 
 #[derive(Debug, Clone, Default)]

tensorfs-0.3.91/crates/tensorfs-plane/tests/census.rs

@@ -0,0 +1,189 @@
+//! What a plane leaves behind in its process: descriptors, plane memfds, store files and
+//! threads return to the baseline however a plane ends: closed, or collected unclosed with a
+//! handle outliving it. Alone in its binary: the census is process-wide.
+
+mod common;
+
+use std::time::Duration;
+
+use common::*;
+use tensorfs_plane::cuda::{self, CUstream, CtxGuard};
+use tensorfs_plane::{Error, Plane, PlaneConfig, Tier};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct Census {
+    fds: usize,
+    memfds: usize,
+    store: usize,
+    threads: usize,
+}
+
+fn census(fx: &Fixture) -> Census {
+    let root = fx.root.to_string_lossy().to_string();
+    let links: Vec<String> = std::fs::read_dir("/proc/self/fd")
+        .unwrap()
+        .filter_map(|e| std::fs::read_link(e.ok()?.path()).ok())
+        .map(|p| p.to_string_lossy().to_string())
+        .collect();
+    let threads = std::fs::read_dir("/proc/self/task")
+        .unwrap()
+        .filter_map(|e| std::fs::read_to_string(e.ok()?.path().join("comm")).ok())
+        .filter(|name| name.starts_with("tfs-plane"))
+        .count();
+    Census {
+        // The directory read holds one descriptor of its own.
+        fds: links.len() - 1,
+        memfds: links.iter().filter(|l| l.contains("memfd:tfs-plane")).count(),
+        store: links.iter().filter(|l| l.starts_with(&root)).count(),
+        threads,
+    }
+}
+
+/// The baseline: the census once no plane thread is left (a joined thread's task entry can
+/// outlive the join by a moment).
+fn baseline(fx: &Fixture) -> Census {
+    let quiet = Census { threads: 0, ..census(fx) };
+    let seen = settled(fx, &quiet);
+    assert_eq!(seen.threads, 0, "plane threads outlived every plane");
+    seen
+}
+
+/// Threads of an unclosed plane exit on their own: wait for the census to settle.
+fn settled(fx: &Fixture, want: &Census) -> Census {
+    let mut seen = census(fx);
+    for _ in 0..2000 {
+        if &seen == want {
+            break;
+        }
+        std::thread::sleep(Duration::from_millis(1));
+        seen = census(fx);
+    }
+    seen
+}
+
+#[test]
+fn host_planes_leave_no_descriptors_or_threads() {
+    let fx = Fixture::new("census");
+    let cycle = |closed: bool| {
+        let plane = host_only();
+        let a = fx.register(&plane, None);
+        let b = fx.register(&plane, Some(plane.host_fd(a).unwrap()));
+        plane.set_pinned_budget(1 << 30).unwrap();
+        let ticket = plane.want(a, Tier::Pinned, None, 0, false).unwrap();
+        ticket.wait().unwrap();
+        plane.want(b, Tier::Pinned, Some(&[0]), 0, false).unwrap().wait().unwrap();
+        if closed {
+            plane.close_ws(a).unwrap();
+            plane.close().unwrap();
+        }
+        // Unclosed: a ticket outlives the handle, so the plane ends when the ticket goes.
+        drop(plane);
+        drop(ticket);
+    };
+    cycle(true);
+    let base = baseline(&fx);
+    for closed in [true, false, false, true, false] {
+        cycle(closed);
+        assert_eq!(settled(&fx, &base), base, "after a plane {}", if closed { "closed" } else { "dropped unclosed" });
+    }
+}
+
+const DEV: i32 = 0;
+
+struct Stream(CUstream, #[allow(dead_code)] CtxGuard);
+impl Stream {
+    fn new() -> Stream {
+        let (_, ctx) = cuda::primary_context(DEV).unwrap();
+        let g = CtxGuard::enter(ctx).unwrap();
+        let mut s: CUstream = std::ptr::null_mut();
+        let d = cuda::driver().unwrap();
+        cuda::check("cuStreamCreate", unsafe { (d.stream_create)(&mut s, cuda::STREAM_NON_BLOCKING) }).unwrap();
+        Stream(s, g)
+    }
+    fn raw(&self) -> u64 {
+        self.0 as u64
+    }
+}
+impl Drop for Stream {
+    fn drop(&mut self) {
+        let d = cuda::driver().unwrap();
+        unsafe {
+            (d.stream_synchronize)(self.0);
+            (d.stream_destroy)(self.0);
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum End {
+    Closed,
+    /// The plane handle goes first; a view of leased bytes holds the last reference.
+    Unclosed,
+    /// A lease is dropped unreleased: `close` refuses, the plane is collected poisoned.
+    Poisoned,
+}
+
+fn device_cycle(fx: &Fixture, end: End) {
+    let p = Plane::open(PlaneConfig {
+        devices: vec![DEV],
+        readers: 4,
+        staging_buffers: 3,
+        staging_bytes: 16 << 20,
+        ..Default::default()
+    })
+    .unwrap();
+    let ws = fx.register(&p, None);
+    let s = Stream::new();
+    p.set_pinned_budget(1 << 30).unwrap();
+    p.want(ws, Tier::Pinned, Some(&[0, 1]), 0, false).unwrap().wait().unwrap();
+    p.set_vram_budget(DEV, 1 << 30).unwrap();
+    p.want(ws, Tier::Device(DEV), Some(&[0]), 0, false).unwrap().wait().unwrap();
+    let home = p.acquire(ws, DEV, 0, s.raw(), None).unwrap();
+    let view = home.view().unwrap();
+    // Region 1 streams from the pinned tier, region 2 from disk through staging.
+    let cur = p.stream(ws, DEV, &[1, 2], 1, 1, 0, "census", None).unwrap();
+    cur.acquire(1, s.raw()).unwrap().release(s.raw()).unwrap();
+    let last = cur.acquire(2, s.raw()).unwrap();
+    home.release(s.raw()).unwrap();
+    match end {
+        End::Closed => {
+            last.release(s.raw()).unwrap();
+            drop(view);
+            cur.close().unwrap();
+            p.close().unwrap();
+        }
+        End::Unclosed => {
+            last.release(s.raw()).unwrap();
+            drop(p);
+            drop(cur);
+            drop(view);
+        }
+        End::Poisoned => {
+            drop(last);
+            drop(view);
+            drop(cur);
+            assert!(matches!(p.close(), Err(Error::Poisoned(_))));
+            drop(p);
+        }
+    }
+}
+
+#[test]
+#[ignore = "GPU"]
+fn device_planes_leave_no_descriptors_threads_or_device_memory() {
+    let fx = Fixture::new("gpu-census");
+    let free = || {
+        let (_, ctx) = cuda::primary_context(DEV).unwrap();
+        let _g = CtxGuard::enter(ctx).unwrap();
+        let (mut free, mut total) = (0usize, 0usize);
+        cuda::check("cuMemGetInfo", unsafe { (cuda::driver().unwrap().mem_get_info)(&mut free, &mut total) }).unwrap();
+        free
+    };
+    device_cycle(&fx, End::Closed);
+    let (base, vram) = (baseline(&fx), free());
+    for end in [End::Closed, End::Unclosed, End::Unclosed, End::Poisoned, End::Closed, End::Poisoned] {
+        device_cycle(&fx, end);
+        assert_eq!(settled(&fx, &base), base, "after a plane ended {end:?}");
+        assert_eq!(free(), vram, "device memory after a plane ended {end:?}");
+    }
+}

{tensorfs-0.3.90 → tensorfs-0.3.91}/crates/tensorfs-plane/tests/gpu.rs

@@ -662,7 +662,7 @@ mod copy_faults {
 
     #[test]
     #[ignore = "GPU"]
-    fn an_undrainable_failure_poisons_and_nothing_is_unmapped_under_it() {
+    fn an_undrainable_failure_poisons_and_its_ranges_outlive_the_queued_copies() {
         let fx = Fixture::new("gpu-undrained");
         let p = staging_plane();
         let ws = fx.register(&p, None);
@@ -675,9 +675,12 @@ mod copy_faults {
         assert!(matches!(r, Err(Error::Poisoned(_))), "{r:?}");
         assert!(matches!(p.close_ws(ws), Err(Error::Poisoned(_))), "a poisoned plane must not unmap");
         assert!(matches!(p.drop_regions(ws, Tier::Device(DEV), None), Err(Error::Poisoned(_))));
+        // Collecting it waits for the device before anything is unmapped: the copies still
+        // queued behind the gate land in mapped memory.
+        let opener = open_later(&gate);
         drop(p);
-        gate.open();
-        std::thread::sleep(Duration::from_millis(200));
+        assert!(gate.is_open(), "the plane was torn down while its copies still waited on the device");
+        opener.join().unwrap();
         healthy();
     }
 

{tensorfs-0.3.90 → tensorfs-0.3.91}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "tensorfs"
-version = "0.3.90"
+version = "0.3.91"
 description = "TensorFS — canonical tensor artifact substrate"
 requires-python = ">=3.12"
 classifiers = [

{tensorfs-0.3.90 → tensorfs-0.3.91}/python/tensorfs/_ext.pyi

@@ -164,6 +164,7 @@ class Refusal(Exception):
     code: str
     detail: str
 
+class AdapterTargetUnsupported(Refusal): ...
 class AmbiguousClassification(Refusal): ...
 class ArchiveRefused(Refusal): ...
 class ArithOverflow(Refusal): ...

{tensorfs-0.3.90 → tensorfs-0.3.91}/python/tensorfs/errors.py

@@ -22,6 +22,7 @@ from __future__ import annotations
 
 from . import _ext
 from ._ext import (
+    AdapterTargetUnsupported,
     AmbiguousClassification,
     ArchiveRefused,
     ArithOverflow,
@@ -181,6 +182,7 @@ CODES: dict[str, type[Refusal]] = _ext.CODES
 
 __all__ = [
     "CODES",
+    "AdapterTargetUnsupported",
     "AmbiguousClassification",
     "ArchiveRefused",
     "ArithOverflow",