tensorfs 0.3.32__tar.gz → 0.3.34__tar.gz

{tensorfs-0.3.32 → tensorfs-0.3.34}/Cargo.lock

@@ -392,7 +392,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tensorfs-core"
-version = "0.3.32"
+version = "0.3.34"
 dependencies = [
  "fs2",
  "minicbor",
@@ -404,7 +404,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-py"
-version = "0.3.32"
+version = "0.3.34"
 dependencies = [
  "pyo3",
  "tensorfs-core",

{tensorfs-0.3.32 → tensorfs-0.3.34}/Cargo.toml

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

{tensorfs-0.3.32 → tensorfs-0.3.34}/PKG-INFO

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

{tensorfs-0.3.32 → tensorfs-0.3.34}/crates/tensorfs-core/src/ingest/source.rs

@@ -809,6 +809,8 @@ pub struct PreparedModelSources {
     pub deferred_ops: usize,
     pub converted_bytes: u64,
     pub largest_op_bytes: u64,
+    /// Minimum body admission for the next atomic op, without writing that op.
+    pub required_write_bytes: u64,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -1112,6 +1114,24 @@ pub fn prepare_model_source_with_registry(
     request: &PrepareModelSource,
     registry_locator: &str,
     registry_bytes: &[u8],
+) -> Result<PreparedModelSources> {
+    prepare_model_source_with_registry_budget(
+        store,
+        request,
+        registry_locator,
+        registry_bytes,
+        None,
+    )
+}
+
+/// An explicit body budget never admits an oversized op. Zero advances only metadata
+/// and replay, reporting the next atomic body's native byte count for host admission.
+pub fn prepare_model_source_with_registry_budget(
+    store: &Store,
+    request: &PrepareModelSource,
+    registry_locator: &str,
+    registry_bytes: &[u8],
+    write_budget_bytes: Option<u64>,
 ) -> Result<PreparedModelSources> {
     // The guard bridges local snapshot publication and recipient root adoption. A
     // predecessor can be released between them, but GC cannot remove the saved bytes.
@@ -1171,7 +1191,10 @@ pub fn prepare_model_source_with_registry(
         request,
         registry_locator,
         registry_bytes,
-        &mut transaction::Budget::new(durability::INTERVAL_BYTES),
+        &mut match write_budget_bytes {
+            Some(limit) => transaction::Budget::bounded(limit),
+            None => transaction::Budget::new(durability::INTERVAL_BYTES),
+        },
     )
 }
 
@@ -1365,6 +1388,7 @@ fn prepare_model_source_with_budget(
                 deferred_ops: 0,
                 converted_bytes: 0,
                 largest_op_bytes: 0,
+                required_write_bytes: 0,
             });
         }
         crate::catalog::SourcePreparation::Open(writer) => writer,
@@ -1381,6 +1405,7 @@ fn prepare_model_source_with_budget(
         deferred_ops: 0,
         converted_bytes: 0,
         largest_op_bytes: 0,
+        required_write_bytes: 0,
     };
     let mut needed = std::collections::BTreeSet::new();
     for (requested, (plan_hex, prepared)) in request.profiles.iter().zip(plans) {
@@ -1470,6 +1495,7 @@ fn prepare_model_source_with_budget(
         result.converted_roles += progress.converted_roles;
         result.converted_bytes += progress.written;
         result.largest_op_bytes = budget.largest_op;
+        result.required_write_bytes = budget.required_write_bytes;
         result.resumed_roles += progress.resumed_roles;
         result.deferred_ops += progress.deferred_ops;
         if let Some(outcome) = outcome {
@@ -2526,6 +2552,58 @@ mod tests {
         fs::remove_dir_all(root).unwrap();
     }
 
+    #[test]
+    fn strict_source_pass_reports_body_admission_then_resumes_without_reconversion() {
+        let root = temporary("strict-source-admission");
+        let (store, registry, request) = fixture_sized(&root, false, Some(1024));
+        let advance = |limit| {
+            prepare_model_source_with_registry_budget(
+                &store,
+                &request,
+                "fixture:registry",
+                &registry,
+                Some(limit),
+            )
+            .unwrap()
+        };
+        for limit in [0, 4095] {
+            let held = advance(limit);
+            assert!(!held.complete);
+            assert_eq!(held.converted_roles, 0);
+            assert_eq!(held.converted_bytes, 0);
+            assert_eq!(held.largest_op_bytes, 0);
+            assert_eq!(held.required_write_bytes, 4096);
+            assert_eq!(held.deferred_ops, 2);
+        }
+        let first = advance(4096);
+        assert!(!first.complete);
+        assert_eq!(first.converted_bytes, 4096);
+        assert_eq!(first.converted_roles, 1);
+        assert_eq!(first.required_write_bytes, 0);
+        let held = advance(0);
+        assert_eq!(held.converted_bytes, 0);
+        assert_eq!(held.resumed_roles, 1);
+        assert_eq!(held.required_write_bytes, 4096);
+        assert_eq!(held.checkpoints, first.checkpoints);
+        let completed = advance(4096);
+        assert!(completed.complete);
+        assert_eq!(completed.converted_bytes, 4096);
+        assert_eq!(completed.resumed_roles, 1);
+        let replay = advance(0);
+        assert!(replay.replayed && replay.complete);
+        assert_eq!(replay.sources, completed.sources);
+        assert_eq!(replay.converted_bytes, 0);
+        assert_eq!(replay.required_write_bytes, 0);
+        let clean = Store::init(&root.join("clean")).unwrap();
+        let expected =
+            prepare_model_source_with_registry(&clean, &request, "fixture:registry", &registry)
+                .unwrap();
+        assert_eq!(completed.sources, expected.sources);
+        release_model_source(&store, &request.operation_id).unwrap();
+        release_model_source(&clean, &request.operation_id).unwrap();
+        fs::remove_dir_all(root).unwrap();
+    }
+
     #[test]
     fn one_pass_budget_is_shared_by_profiles_and_allows_one_oversized_op() {
         for limit in [1024, 4096] {

{tensorfs-0.3.32 → tensorfs-0.3.34}/crates/tensorfs-core/src/ingest/transaction.rs

@@ -444,6 +444,8 @@ pub struct Budget {
     used: u64,
     stopped: bool,
     pub largest_op: u64,
+    strict: bool,
+    pub required_write_bytes: u64,
 }
 
 impl Budget {
@@ -453,12 +455,25 @@ impl Budget {
             used: 0,
             stopped: false,
             largest_op: 0,
+            strict: false,
+            required_write_bytes: 0,
+        }
+    }
+    pub fn bounded(limit: u64) -> Self {
+        Self {
+            strict: true,
+            ..Self::new(limit)
         }
     }
     fn take(&mut self, bytes: u64) -> bool {
         if self.stopped {
             return false;
         }
+        if self.strict && self.used == 0 && bytes > self.limit {
+            self.required_write_bytes = bytes;
+            self.stopped = true;
+            return false;
+        }
         if self.used > 0 && bytes > self.limit.saturating_sub(self.used) {
             self.stopped = true;
             return false;

{tensorfs-0.3.32 → tensorfs-0.3.34}/crates/tensorfs-core/src/repo_cache.rs

@@ -1085,6 +1085,8 @@ mod backfill_tests {
 #[cfg(test)]
 mod exit_wait_tests {
     use super::*;
+    use std::sync::atomic::{AtomicU64, Ordering};
+    use std::sync::mpsc;
     use std::sync::Arc;
     use std::time::{Duration, Instant};
 
@@ -1093,11 +1095,24 @@ mod exit_wait_tests {
         struct Paced<'a>(&'a [u8]);
         impl Read for Paced<'_> {
             fn read(&mut self, out: &mut [u8]) -> std::io::Result<usize> {
-                std::thread::sleep(Duration::from_millis(5));
                 let take = out.len().min(4096);
                 self.0.read(&mut out[..take])
             }
         }
+        struct Progress {
+            activity: Arc<BackfillActivity>,
+            elapsed_ms: Arc<AtomicU64>,
+        }
+        impl store::Progress for Progress {
+            fn admitted(&self) {}
+            fn moved(&self, bytes: u64) {
+                // Advance time only after real bytes were copied and hashed. Thread
+                // startup, filesystem scheduling and final fsync are not a stalled
+                // transfer injected by this test.
+                self.elapsed_ms.fetch_add(5, Ordering::SeqCst);
+                self.activity.moved(bytes);
+            }
+        }
         let root = std::env::temp_dir().join(format!(
             "tensorfs-exit-moving-{}-{}",
             std::process::id(),
@@ -1110,22 +1125,51 @@ mod exit_wait_tests {
             Duration::from_millis(10),
         )));
         activity.offered();
-        let observed = activity.clone();
+        let elapsed_ms = Arc::new(AtomicU64::new(0));
+        let clock = elapsed_ms.clone();
+        let started = Instant::now();
+        let (sampled, observation) = mpsc::channel();
+        activity.pending.lock().unwrap().1 =
+            Ledger::with_clock(Duration::from_millis(10), move || {
+                let elapsed = clock.load(Ordering::SeqCst);
+                if elapsed >= 320 && std::thread::current().name() == Some("copy-wait") {
+                    let _ = sampled.send(());
+                }
+                started + Duration::from_millis(elapsed)
+            });
+        let observed = Progress {
+            activity: activity.clone(),
+            elapsed_ms: elapsed_ms.clone(),
+        };
         let target = destination.clone();
         let wanted = object.clone();
-        let started = Instant::now();
+        let (finish, finishing) = mpsc::channel();
         let copy = std::thread::spawn(move || {
-            let result =
-                publish_stream(&mut Paced(&data), &target, &wanted, Some(observed.as_ref()));
-            observed.finished();
+            let result = publish_stream(&mut Paced(&data), &target, &wanted, Some(&observed));
+            finishing.recv().unwrap();
+            observed.activity.finished();
             result
         });
-        assert!(activity.wait(), "a moving copy was abandoned");
-        assert_eq!(copy.join().unwrap(), Ok(true));
+        let waiting = activity.clone();
+        let waiter = std::thread::Builder::new()
+            .name("copy-wait".into())
+            .spawn(move || waiting.wait())
+            .unwrap();
+        // The wait must actually sample a pending copy after more than the initial
+        // 60 ms floor, before finished() can make it return trivially. This timeout
+        // is only a deadlock guard; it is not the liveness clock being qualified.
+        let sampled_pending = observation.recv_timeout(Duration::from_secs(5));
+        finish.send(()).unwrap();
         assert!(
-            started.elapsed() > Duration::from_millis(60),
-            "copy never outlived the initial silence floor"
+            sampled_pending.is_ok(),
+            "wait never observed the moving copy"
         );
+        assert!(waiter.join().unwrap(), "a moving copy was abandoned");
+        assert_eq!(copy.join().unwrap(), Ok(true));
+        let state = activity.pending.lock().unwrap();
+        assert!(Duration::from_millis(elapsed_ms.load(Ordering::SeqCst)) > state.1.floor());
+        assert_eq!(state.1.still().moved, object.length);
+        drop(state);
         assert_eq!(
             verify_path(&destination, CacheKind::Blob, &object, None),
             Ok(())

{tensorfs-0.3.32 → tensorfs-0.3.34}/crates/tensorfs-core/src/transport/ledger.rs

@@ -137,6 +137,8 @@ pub struct Ledger {
     sample: Duration,
     worst_gap: Mutex<Duration>,
     progress: Mutex<Progress>,
+    #[cfg(test)]
+    clock: Option<Box<dyn Fn() -> Instant + Send + Sync>>,
 }
 
 impl Ledger {
@@ -155,9 +157,30 @@ impl Ledger {
                 advanced: Instant::now(),
                 worst_still: Duration::ZERO,
             }),
+            #[cfg(test)]
+            clock: None,
         }
     }
 
+    #[cfg(test)]
+    pub(crate) fn with_clock(
+        sample: Duration,
+        clock: impl Fn() -> Instant + Send + Sync + 'static,
+    ) -> Self {
+        let mut ledger = Self::with_resolution(sample);
+        ledger.progress.lock().unwrap().advanced = clock();
+        ledger.clock = Some(Box::new(clock));
+        ledger
+    }
+
+    fn now(&self) -> Instant {
+        #[cfg(test)]
+        if let Some(clock) = &self.clock {
+            return clock();
+        }
+        Instant::now()
+    }
+
     pub fn sample(&self) -> Duration {
         self.sample
     }
@@ -215,7 +238,7 @@ impl Ledger {
     /// stream cannot raise the bar the next stream is judged by.
     fn advance(&self, bytes: u64) {
         let mut progress = self.progress.lock().unwrap();
-        let now = Instant::now();
+        let now = self.now();
         let gap = now.saturating_duration_since(progress.advanced);
         if gap > progress.worst_still {
             progress.worst_still = gap;
@@ -238,7 +261,7 @@ impl Ledger {
         let progress = self.progress.lock().unwrap();
         Still {
             moved: progress.moved,
-            silent: progress.advanced.elapsed(),
+            silent: self.now().saturating_duration_since(progress.advanced),
         }
     }
 }

{tensorfs-0.3.32 → tensorfs-0.3.34}/crates/tensorfs-py/src/store.rs

@@ -1073,7 +1073,7 @@ impl PyStore {
 
     /// Advance the exact source plan over verified physical carriers. Checkpoint heads are
     /// local progress until the RecordOwner acknowledges their complete upload.
-    #[pyo3(signature = (operation_id, source_selection_digest, profiles, roster, landed, *, checkpoints=Vec::new(), adopt_from_operation_id=None, registry=None))]
+    #[pyo3(signature = (operation_id, source_selection_digest, profiles, roster, landed, *, checkpoints=Vec::new(), adopt_from_operation_id=None, registry=None, write_budget_bytes=None))]
     #[allow(clippy::too_many_arguments, clippy::type_complexity)]
     fn prepare_model_source<'p>(
         &self,
@@ -1086,6 +1086,7 @@ impl PyStore {
         checkpoints: Vec<(String, String, u64)>,
         adopt_from_operation_id: Option<String>,
         registry: Option<Vec<u8>>,
+        write_budget_bytes: Option<u64>,
     ) -> PyResult<Bound<'p, PyDict>> {
         let checkpoints = checkpoints
             .into_iter()
@@ -1126,14 +1127,21 @@ impl PyStore {
             adopt_from_operation_id,
         };
         let prepared = py
-            .detach(|| match &registry {
-                Some(bytes) => model_source::prepare_model_source_with_registry(
+            .detach(|| {
+                let (locator, bytes) = match &registry {
+                    Some(bytes) => ("supplied:native-registry", bytes.as_slice()),
+                    None => (
+                        model_source::BUILTIN_REGISTRY,
+                        model_source::BUILTIN_REGISTRY_BYTES,
+                    ),
+                };
+                model_source::prepare_model_source_with_registry_budget(
                     &self.store,
                     &request,
-                    "supplied:native-registry",
+                    locator,
                     bytes,
-                ),
-                None => model_source::prepare_model_source(&self.store, &request),
+                    write_budget_bytes,
+                )
             })
             .or_refuse(py)?;
         let out = PyDict::new(py);
@@ -1145,6 +1153,11 @@ impl PyStore {
         out.set_item("deferred_ops", prepared.deferred_ops)?;
         out.set_item("converted_bytes", prepared.converted_bytes)?;
         out.set_item("largest_op_bytes", prepared.largest_op_bytes)?;
+        out.set_item("required_write_bytes", prepared.required_write_bytes)?;
+        out.set_item(
+            "write_interval_bytes",
+            tensorfs_core::durability::INTERVAL_BYTES,
+        )?;
         let rows = PyList::empty(py);
         for source in prepared.sources {
             let row = PyDict::new(py);
@@ -1208,6 +1221,7 @@ impl PyStore {
             checkpoints,
             adopt_from_operation_id,
             registry,
+            None,
         )
     }
 
@@ -2798,6 +2812,56 @@ impl PyLease {
         Ok(PyBytes::new(py, &bytes))
     }
 
+    /// Read a bounded semantic part from a header already covered by this read lease.
+    /// This is the same native range reader used by derived writers, without a writer.
+    #[allow(clippy::too_many_arguments)]
+    fn read_part_into(
+        &self,
+        py: Python<'_>,
+        header: &[u8],
+        component: &str,
+        key: &str,
+        role: &str,
+        off: u64,
+        into: &Bound<'_, PyAny>,
+    ) -> PyResult<()> {
+        let header_ref = ObjectRef::of(header);
+        let header = Header::parse(header).or_refuse(py)?;
+        let name = format!("{component}/{key}/{role}");
+        let part = header
+            .components
+            .iter()
+            .find(|(candidate, _)| candidate == component)
+            .and_then(|(_, tensors)| tensors.iter().find(|(candidate, _)| candidate == key))
+            .and_then(|(_, tensor)| tensor.parts.iter().find(|(candidate, _)| candidate == role))
+            .map(|(_, part)| part)
+            .ok_or_else(|| missing(py, "model tensor part", &name))?;
+        let mut buffer = Writable::new(py, into)?;
+        let destination = buffer.slice();
+        let guard = self.lease.lock_py_attached(py).unwrap();
+        let lease = guard.as_ref().ok_or_else(|| released(py))?;
+        lease
+            .covers(&ObjectRange {
+                obj: header_ref,
+                off: 0,
+                len: 0,
+            })
+            .or_refuse(py)?;
+        py.detach(|| {
+            lease.recheck(&self.meta)?;
+            read::read_part_into(
+                lease,
+                &name,
+                part,
+                off,
+                destination.len() as u64,
+                destination,
+            )?;
+            lease.recheck(&self.meta)
+        })
+        .or_refuse(py)
+    }
+
     /// **The streaming shape.** One plan, a ring of CALLER-owned slots, and a reader pool
     /// that never stops at a batch boundary.
     ///

{tensorfs-0.3.32 → tensorfs-0.3.34}/pyproject.toml

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

{tensorfs-0.3.32 → tensorfs-0.3.34}/python/tensorfs/_ext.pyi

@@ -108,6 +108,8 @@ class PreparedModelSource(TypedDict):
     deferred_ops: int
     converted_bytes: int
     largest_op_bytes: int
+    required_write_bytes: int
+    write_interval_bytes: int
 
 class ManifestRow(TypedDict):
     manifest_id: str
@@ -351,6 +353,9 @@ class ReadLease:
         self, object: str, object_length: int, off: int, length: int, into: object
     ) -> None: ...
     def read_asset(self, header: _Bytes, name: str, max_bytes: int = 67108864) -> _Bytes: ...
+    def read_part_into(
+        self, header: _Bytes, component: str, key: str, role: str, off: int, into: object
+    ) -> None: ...
     def stream(
         self,
         plan: ReadPlan,
@@ -519,6 +524,7 @@ class Store:
         checkpoints: Sequence[tuple[str, str, int]] = ...,
         adopt_from_operation_id: str | None = ...,
         registry: bytes | None = None,
+        write_budget_bytes: int | None = None,
     ) -> PreparedModelSource: ...
     def checkpoint_page(
         self, head_id: str, head_length: int, *, operation_id: str, slot: str,