tensorfs 0.3.91__tar.gz → 0.3.93__tar.gz

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

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

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

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

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

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

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

@@ -195,12 +195,13 @@ are equal-sized).
 p.stats() -> {
   "host":    {"budget", "used", "ready_bytes", "registered_bytes", "memfd_bytes",
               "cached_bytes", "direct_bytes", "buffered_bytes", "inline_bytes", "direct_refused",
-              "disk_read_bytes",
+              "map_refused", "disk_read_bytes",
               "fills", "fill_bytes", "fill_ns", "evictions", "evicted_bytes", "register_failed",
               "trims"},
   "devices": [{"ordinal", "uuid", "granularity", "exportable", "budget", "committed", "mapped",
                "idle", "leased_bytes", "held_bytes", "over_budget_unreleasable", "reserved_va",
                "copies", "host_copy_bytes", "host_copy_ns", "disk_copy_bytes", "disk_copy_ns",
+               "mapped_copy_bytes", "mapped_copy_ns",
                "misses", "evictions", "evicted_bytes", "trims"}],
   "sets":    [{"id", "name", "nbytes", "regions", "host_ready_bytes", "host_memfd_bytes",
                "evictions", "evicted_bytes", "devices": [{"ordinal", "ready_bytes"}]}],
@@ -280,6 +281,20 @@ an unclosed plane ends.
 
 ## Changelog
 
+- v3.4 2026-10-02: the mapped device copy of v3.3 is removed; a device fill is again pinned
+  tier, else after a filling tier, else staging. In real first loads it never acted at full
+  CPU (the tier was ready first) and was slower where it did (L4 held to 4 CPUs, warm cache:
+  SDXL load to denoise 6.44 s -> 7.54 s, Anima 5.54 s -> 8.31 s): the pinned fill copied the
+  same bytes beside it. `mapped_copy_bytes`, `mapped_copy_ns` and `map_refused` stay in
+  `stats()` and read 0. Kept from v3.3: the page-cache query that answers on overlayfs and
+  where seccomp refuses `cachestat` (a pinned fill there copies cached bytes instead of
+  re-reading them), and `stats()["host"]["disk_read_bytes"]`.
+
+- v3.3 2026-10-02: `stats()["host"]["disk_read_bytes"]` exists. The plane has counted it
+  since v3.1 and this file listed it, but the Python facade never carried it: a caller read 0
+  whatever the disk did, so a "nothing read from disk" check on it could not fail. (v3.3 also
+  added a device copy from page-cache mappings; v3.4 removed it.)
+
 - 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

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

@@ -42,6 +42,8 @@ pub enum Mode {
 struct Fds {
     buffered: File,
     direct: Option<File>,
+    /// On overlayfs (a container's root): the file reports no page cache of its own.
+    overlay: bool,
 }
 
 pub struct Source {
@@ -54,9 +56,11 @@ pub struct Source {
 }
 
 /// Whether the page cache holds every page of `[off, off+len)`, from `cachestat(2)`: a pure
-/// query (unlike an `RWF_NOWAIT` read, which starts readahead on a miss). `None` where the
-/// kernel lacks it (< 6.5): the caller treats the range as cold.
-fn cached(f: &File, off: u64, len: u64) -> Option<bool> {
+/// query (unlike an `RWF_NOWAIT` read, which starts readahead on a miss). Where that cannot
+/// answer, the pages are counted through a mapping: a kernel without it (< 6.5), a container
+/// whose seccomp filter refuses it, and overlayfs (a container's root), whose files report no
+/// pages of their own.
+fn cached(f: &Fds, off: u64, len: u64) -> bool {
     #[repr(C)]
     struct Range {
         off: u64,
@@ -75,12 +79,40 @@ fn cached(f: &File, off: u64, len: u64) -> Option<bool> {
     let r = Range { off, len };
     let mut st = Stat::default();
     // SAFETY: the documented cachestat ABI; both structs outlive the call.
-    let rc = unsafe { libc::syscall(SYS_CACHESTAT, f.as_raw_fd(), &r, &mut st, 0) };
-    if rc != 0 {
-        return None;
-    }
+    let rc = unsafe { libc::syscall(SYS_CACHESTAT, f.buffered.as_raw_fd(), &r, &mut st, 0) };
     let page = 4096u64;
-    Some(st.nr_cache >= (off + len).div_ceil(page) - off / page)
+    if rc == 0 && st.nr_cache >= (off + len).div_ceil(page) - off / page {
+        return true;
+    }
+    (rc != 0 || f.overlay) && resident(&f.buffered, off, len)
+}
+
+fn overlay(f: &File) -> bool {
+    const OVERLAYFS_SUPER_MAGIC: i64 = 0x794c7630;
+    // SAFETY: out-param of the right type on our own descriptor.
+    let mut fs: libc::statfs = unsafe { std::mem::zeroed() };
+    #[allow(clippy::unnecessary_cast)] // f_type is not an i64 on every target
+    let magic = unsafe { libc::fstatfs(f.as_raw_fd(), &mut fs) == 0 }.then_some(fs.f_type as i64);
+    magic == Some(OVERLAYFS_SUPER_MAGIC)
+}
+
+/// Every page of `[off, off+len)` is in core, by `mincore(2)` over a mapping (never faults).
+fn resident(f: &File, off: u64, len: u64) -> bool {
+    let start = off - off % 4096;
+    let n = (off + len - start) as usize;
+    if n == 0 {
+        return true;
+    }
+    // SAFETY: a read-only shared mapping of our descriptor, unmapped below.
+    let p = unsafe { libc::mmap(std::ptr::null_mut(), n, libc::PROT_READ, libc::MAP_SHARED, f.as_raw_fd(), start as libc::off_t) };
+    if p == libc::MAP_FAILED {
+        return false;
+    }
+    let mut pages = vec![0u8; n.div_ceil(4096)];
+    // SAFETY: the vector holds one byte per page of the mapping.
+    let ok = unsafe { libc::mincore(p, n, pages.as_mut_ptr()) } == 0 && pages.iter().all(|b| b & 1 == 1);
+    unsafe { libc::munmap(p, n) };
+    ok
 }
 
 impl Source {
@@ -138,7 +170,7 @@ impl Source {
         } else {
             None
         };
-        let f = Arc::new(Fds { buffered, direct });
+        let f = Arc::new(Fds { overlay: overlay(&buffered), buffered, direct });
         self.fds.lock().unwrap().insert(obj.sha256.clone(), f.clone());
         Ok(f)
     }
@@ -169,7 +201,7 @@ impl Source {
         let end = o.off + item.len;
         let aligned = (dst as u64).wrapping_sub(o.off).is_multiple_of(a) && (end.is_multiple_of(a) || item.part_end);
         let direct = match (mode, &fds.direct) {
-            (Mode::Cache, Some(f)) if aligned && !cached(&fds.buffered, o.off, item.len).unwrap_or(false) => f,
+            (Mode::Cache, Some(f)) if aligned && !cached(&fds, o.off, item.len) => f,
             _ => {
                 read::read_into(lease, o, buf)?;
                 let t = if mode == Mode::Buffered { &tally.buffered_bytes } else { &tally.cached_bytes };

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

@@ -161,6 +161,10 @@ pub struct DevCounters {
     pub host_copy_ns: u64,
     pub disk_copy_bytes: u64,
     pub disk_copy_ns: u64,
+    /// 0.3.92's copies from page-cache mappings, removed in 0.3.93: always 0, kept for callers
+    /// that read them.
+    pub mapped_copy_bytes: u64,
+    pub mapped_copy_ns: u64,
     pub misses: u64,
     pub evictions: u64,
     pub evicted_bytes: u64,
@@ -1636,6 +1640,8 @@ pub struct HostStats {
     pub buffered_bytes: u64,
     pub inline_bytes: u64,
     pub direct_refused: u64,
+    /// Always 0 since 0.3.93 (see `mapped_copy_bytes`).
+    pub map_refused: u64,
     /// Bytes this process caused the block layer to read (`/proc/self/io` read_bytes).
     pub disk_read_bytes: u64,
     pub counters: HostCounters,

{tensorfs-0.3.91 → tensorfs-0.3.93}/crates/tensorfs-plane/tests/common/mod.rs

@@ -118,10 +118,12 @@ impl Fixture {
             .unwrap_or(0)
     }
 
-    /// Evict our own blob files from the page cache so a fill has to go to disk.
+    /// Evict our own blob files from the page cache so a fill has to go to disk. Written back
+    /// first: a dirty page stays whatever the advice.
     pub fn drop_cache(&self) {
         for o in &self.objects {
             let f = std::fs::File::open(self.store.blob_path(&o.sha256)).unwrap();
+            f.sync_all().unwrap();
             // SAFETY: advice on our own descriptor.
             unsafe { libc::posix_fadvise(f.as_raw_fd(), 0, 0, libc::POSIX_FADV_DONTNEED) };
         }

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

@@ -120,7 +120,8 @@ fn stats<'p>(py: Python<'p>, s: Stats) -> PyResult<Bound<'p, PyDict>> {
         "registered_bytes" => h.registered_bytes, "memfd_bytes" => h.memfd_bytes,
         "cached_bytes" => h.cached_bytes, "direct_bytes" => h.direct_bytes,
         "buffered_bytes" => h.buffered_bytes, "inline_bytes" => h.inline_bytes,
-        "direct_refused" => h.direct_refused, "fills" => c.fills, "fill_bytes" => c.fill_bytes,
+        "direct_refused" => h.direct_refused, "map_refused" => h.map_refused,
+        "disk_read_bytes" => h.disk_read_bytes, "fills" => c.fills, "fill_bytes" => c.fill_bytes,
         "fill_ns" => c.fill_ns, "evictions" => c.evictions, "evicted_bytes" => c.evicted_bytes,
         "register_failed" => c.register_failed, "trims" => c.trims,
     );
@@ -135,6 +136,7 @@ fn stats<'p>(py: Python<'p>, s: Stats) -> PyResult<Bound<'p, PyDict>> {
             "reserved_va" => d.reserved_va, "copies" => c.copies,
             "host_copy_bytes" => c.host_copy_bytes, "host_copy_ns" => c.host_copy_ns,
             "disk_copy_bytes" => c.disk_copy_bytes, "disk_copy_ns" => c.disk_copy_ns,
+            "mapped_copy_bytes" => c.mapped_copy_bytes, "mapped_copy_ns" => c.mapped_copy_ns,
             "misses" => c.misses, "evictions" => c.evictions, "evicted_bytes" => c.evicted_bytes,
             "trims" => c.trims,
         ))?;

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

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

{tensorfs-0.3.91 → tensorfs-0.3.93}/python/tensorfs/plane.pyi

@@ -42,6 +42,8 @@ class HostStats(TypedDict):
     buffered_bytes: int
     inline_bytes: int
     direct_refused: int
+    map_refused: int  # always 0 since 0.3.93
+    disk_read_bytes: int  # read from storage by this process, from /proc/self/io
     fills: int
     fill_bytes: int
     fill_ns: int
@@ -68,6 +70,8 @@ class DeviceStats(TypedDict):
     host_copy_ns: int
     disk_copy_bytes: int
     disk_copy_ns: int
+    mapped_copy_bytes: int  # always 0 since 0.3.93 (0.3.92 copied from page-cache mappings)
+    mapped_copy_ns: int
     misses: int
     evictions: int
     evicted_bytes: int