tensorfs 0.3.65__tar.gz → 0.3.66__tar.gz

{tensorfs-0.3.65 → tensorfs-0.3.66}/Cargo.lock

@@ -439,7 +439,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tensorfs-core"
-version = "0.3.65"
+version = "0.3.66"
 dependencies = [
  "fs2",
  "libc",
@@ -454,7 +454,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-py"
-version = "0.3.65"
+version = "0.3.66"
 dependencies = [
  "pyo3",
  "tensorfs-core",

{tensorfs-0.3.65 → tensorfs-0.3.66}/Cargo.toml

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

{tensorfs-0.3.65 → tensorfs-0.3.66}/PKG-INFO

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

{tensorfs-0.3.65 → tensorfs-0.3.66}/crates/tensorfs-core/src/bin/tfs/fetch.rs

@@ -1358,6 +1358,7 @@ struct PullProgress {
 struct PullProgressState {
     total_bytes: u64,
     held_bytes: u64,
+    wanted_objects: u64,
     origin_bytes: u64,
     cache_bytes: u64,
     origin_objects: u64,
@@ -1371,6 +1372,7 @@ impl PullProgress {
             state: Mutex::new(PullProgressState {
                 total_bytes: 0,
                 held_bytes: 0,
+                wanted_objects: 0,
                 origin_bytes: 0,
                 cache_bytes: 0,
                 origin_objects: 0,
@@ -1385,6 +1387,7 @@ impl PullProgress {
         let mut state = self.state.lock().unwrap();
         state.total_bytes = plan.declared_bytes();
         state.held_bytes = plan.held_bytes();
+        state.wanted_objects = plan.wanted.len() as u64;
         state.last = Some(Instant::now());
         print_progress(&state);
     }
@@ -1447,11 +1450,12 @@ impl PullProgress {
 ///
 /// Every counter is always present, including a zero. A consumer that reads an absent key
 /// as zero cannot tell a cache that answered nothing from a build that never reported the
-/// door at all, and those are the two states worth telling apart.
+/// door at all, and those are the two states worth telling apart. `wanted_objects` is the
+/// plan's count of objects to land; a pod host sizes this pull's storage reservation from it.
 fn print_progress(state: &PullProgressState) {
     eprintln!(
-        "{{\"event\":\"pull.progress\",\"total_bytes\":{},\"held_bytes\":{},\"origin_bytes\":{},\"cache_bytes\":{},\"origin_objects\":{},\"cache_objects\":{}}}",
-        state.total_bytes, state.held_bytes, state.origin_bytes, state.cache_bytes,
+        "{{\"event\":\"pull.progress\",\"total_bytes\":{},\"held_bytes\":{},\"wanted_objects\":{},\"origin_bytes\":{},\"cache_bytes\":{},\"origin_objects\":{},\"cache_objects\":{}}}",
+        state.total_bytes, state.held_bytes, state.wanted_objects, state.origin_bytes, state.cache_bytes,
         state.origin_objects, state.cache_objects
     );
 }

{tensorfs-0.3.65 → tensorfs-0.3.66}/crates/tensorfs-core/src/catalog.rs

@@ -62,6 +62,11 @@ fn sql(what: impl AsRef<str>, error: rusqlite::Error) -> Refusal {
     }
 }
 
+/// Whether a catalog refusal is SQLite's busy timeout expiring behind another writer.
+fn busy(refusal: &Refusal) -> bool {
+    refusal.code == Code::IO_FAILED && refusal.detail.ends_with("database is locked")
+}
+
 fn io(what: impl AsRef<str>, error: std::io::Error) -> Refusal {
     crate::store::classify_io(what, error)
 }
@@ -115,7 +120,20 @@ fn connect(path: &Path) -> Result<Connection> {
         .entry(path.to_path_buf())
         .or_default() += 1;
     crate::stats::catalog_opened();
-    let connection = Connection::open(path).map_err(|error| sql("open catalog", error))?;
+    let connection = Connection::open(path).map_err(|error| {
+        // SQLite reports a full descriptor table only as "unable to open"; the table
+        // itself answers whether that is what happened.
+        if crate::descriptors::available().is_some_and(|free| free == 0) {
+            crate::descriptors::exhausted(&std::io::Error::from_raw_os_error(
+                rustix::io::Errno::MFILE.raw_os_error(),
+            ));
+            return Refusal {
+                code: Code::FD_HEADROOM,
+                detail: format!("open catalog: no file descriptor ({error})"),
+            };
+        }
+        sql("open catalog", error)
+    })?;
     connection
         .busy_timeout(BUSY_TIMEOUT)
         .map_err(|error| sql("set catalog busy timeout", error))?;
@@ -372,6 +390,22 @@ impl Catalog {
         Ok(catalog)
     }
 
+    /// `open` for an object admission. A catalog busy past SQLite's timeout while this
+    /// process's own admission batches keep committing is a queue, not a failure: the
+    /// verified bytes wait for their turn instead of being thrown away and fetched again.
+    /// Busy with no batch committed in the meantime is another writer's lock, and refuses.
+    pub(crate) fn open_admitting(root: &Path) -> Result<Self> {
+        loop {
+            let committed = crate::stats::snapshot().admission_batches;
+            match Self::open(root) {
+                Err(refusal)
+                    if busy(&refusal) && crate::stats::snapshot().admission_batches > committed => {
+                }
+                opened => return opened,
+            }
+        }
+    }
+
     pub fn open(root: &Path) -> Result<Self> {
         let path = Self::path(root);
         validated(&path)?;
@@ -1473,16 +1507,7 @@ impl WriterGuard {
             .read(true)
             .write(true)
             .open(&path)
-            .map_err(|error| {
-                if crate::descriptors::exhausted(&error) {
-                    Refusal {
-                        code: Code::FD_HEADROOM,
-                        detail: format!("create writer marker: {error}"),
-                    }
-                } else {
-                    io("create writer marker", error)
-                }
-            })?;
+            .map_err(|error| io("create writer marker", error))?;
         file.try_lock_exclusive()
             .map_err(|error| io("lock writer marker", error))?;
         Ok(Self {

{tensorfs-0.3.65 → tensorfs-0.3.66}/crates/tensorfs-core/src/ingest/preflight.rs

@@ -239,6 +239,26 @@ fn profile_plan(plan: &SourcePlan) -> ProfilePlan {
     }
 }
 
+/// The one reviewed profile these member heads plan under, chosen from their headers alone:
+/// several matching profiles that plan identically are one answer; different plans refuse
+/// `AMBIGUOUS_CLASSIFICATION` naming them, and none refuses `UNREGISTERED_FINGERPRINT`.
+pub fn select_profile(
+    registry_locator: &str,
+    registry_bytes: &[u8],
+    heads: &[MemberHead],
+    scratch: &Path,
+) -> Result<String> {
+    let staged = stage(scratch, heads)?;
+    source::plan_source(
+        registry_locator,
+        registry_bytes,
+        staged.carriers(),
+        None,
+        None,
+    )
+    .map(|plan| plan.profile)
+}
+
 /// Decide the conversion plan for every requested profile, from headers alone.
 ///
 /// One [`source::plan_source`] call per profile, over one carrier set — which is precisely

{tensorfs-0.3.65 → tensorfs-0.3.66}/crates/tensorfs-core/src/ingest/source.rs

@@ -690,12 +690,6 @@ fn plan_source_prepared(
         }
         for assignments in profile_assignments(profile, &registry, carriers, &headers) {
             matches.push((profile, assignments));
-            if matches.len() >= 2 {
-                break;
-            }
-        }
-        if matches.len() >= 2 {
-            break;
         }
     }
     if matches.is_empty() {
@@ -704,20 +698,61 @@ fn plan_source_prepared(
             "carrier set matches no reviewed source profile",
         );
     }
-    if matches.len() != 1 {
-        let profiles: Vec<&str> = matches
+    // Every match is planned. Matches whose plans are identical (the same sources, order,
+    // target and session under different profile names) are one answer, named by the most
+    // specific profile; only genuinely different plans are ambiguous.
+    let mut planned = Vec::with_capacity(matches.len());
+    let mut first_error = None;
+    for (profile, assignments) in matches {
+        match plan_match(
+            profile,
+            assignments,
+            carriers,
+            &set,
+            &registry,
+            registry_locator,
+            registry_bytes,
+            spec_variant,
+        ) {
+            Ok(result) => planned.push((profile, result)),
+            Err(error) => {
+                first_error.get_or_insert(error);
+            }
+        }
+    }
+    if planned.is_empty() {
+        return Err(first_error.expect("every match was planned or refused"));
+    }
+    let same = |left: &SourcePlan, right: &SourcePlan| {
+        (
+            &left.session,
+            &left.construction_order,
+            &left.sources,
+            &left.target,
+        ) == (
+            &right.session,
+            &right.construction_order,
+            &right.sources,
+            &right.target,
+        )
+    };
+    if planned
+        .iter()
+        .any(|(_, (plan, _))| !same(plan, &planned[0].1 .0))
+    {
+        let mut profiles: Vec<&str> = planned
             .iter()
             .map(|(profile, _)| profile.name.as_str())
             .collect();
-        let mut members: Vec<String> = matches
+        profiles.dedup();
+        let mut members: Vec<String> = planned
             .iter()
-            .flat_map(|(_, assignments)| {
-                assignments.iter().map(|assignment| {
-                    let carrier = &carriers[assignment.carrier];
-                    carrier
-                        .member
+            .flat_map(|(_, (plan, _))| {
+                plan.sources.iter().map(|source| {
+                    source
+                        .source_member
                         .clone()
-                        .unwrap_or_else(|| carrier.path.display().to_string())
+                        .unwrap_or_else(|| source.path.display().to_string())
                 })
             })
             .collect();
@@ -731,7 +766,42 @@ fn plan_source_prepared(
             ),
         );
     }
-    let (profile, mut assignments) = matches.remove(0);
+    planned.sort_by_key(|(profile, _)| {
+        (
+            std::cmp::Reverse(specificity(profile)),
+            profile.name.clone(),
+        )
+    });
+    let (_, (plan, prepared)) = planned.swap_remove(0);
+    Ok((plan, prepared))
+}
+
+/// How exactly a profile binds its components: provider members, then member prefixes.
+fn specificity(profile: &SourceProfile) -> (usize, usize) {
+    let exact = profile
+        .components
+        .iter()
+        .filter(|component| component.source_member.is_some())
+        .count();
+    let prefixed = profile
+        .components
+        .iter()
+        .filter(|component| component.source_member_prefix.is_some())
+        .count();
+    (exact, prefixed)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn plan_match(
+    profile: &SourceProfile,
+    mut assignments: Vec<SourceAssignment>,
+    carriers: &[CarrierInput],
+    set: &CarrierSet,
+    registry: &FingerprintRegistry,
+    registry_locator: &str,
+    registry_bytes: &[u8],
+    spec_variant: Option<usize>,
+) -> Result<(SourcePlan, Prepared)> {
     assignments.sort_by(|left, right| left.component.cmp(&right.component));
     let sources: Vec<(String, CarrierInput)> = assignments
         .iter()
@@ -762,7 +832,7 @@ fn plan_source_prepared(
                 .map(|key| (component.component.clone(), key.clone()))
         })
         .collect();
-    let mut prepared = prepare_with_registry(&target, &sources, &set, &registry, spec_variant)?;
+    let mut prepared = prepare_with_registry(&target, &sources, set, registry, spec_variant)?;
     prepared.plan.apply_order(&order)?;
     prepared.plan.check_converts_something()?;
     let plan = SourcePlan {

{tensorfs-0.3.65 → tensorfs-0.3.66}/crates/tensorfs-core/src/store.rs

@@ -158,6 +158,14 @@ const EDQUOT: i32 = 69;
 /// the owner re-issued the fetch, which re-planned, re-asked, and failed at the same byte.
 /// On rented hardware, forever. Naming the condition is what lets a caller stop.
 pub(crate) fn classify_io(what: impl AsRef<str>, e: std::io::Error) -> Refusal {
+    // A full descriptor table is the process's shortage, not the Store's: every open in
+    // the Store says so the same way, and a transfer treats it as backpressure.
+    if crate::descriptors::exhausted(&e) {
+        return Refusal {
+            code: Code::FD_HEADROOM,
+            detail: format!("{}: no file descriptor ({e})", what.as_ref()),
+        };
+    }
     if matches!(e.raw_os_error(), Some(ENOSPC) | Some(EDQUOT)) {
         return Refusal {
             code: Code::CAPACITY_EXHAUSTED,
@@ -1362,16 +1370,7 @@ impl Store {
                 .create_new(true)
                 .mode(0o600)
                 .open(&tmp)
-                .map_err(|e| {
-                    if crate::descriptors::exhausted(&e) {
-                        Refusal {
-                            code: Code::FD_HEADROOM,
-                            detail: format!("create temp {}: {e}", tmp.display()),
-                        }
-                    } else {
-                        io(format!("create temp {}", tmp.display()), e)
-                    }
-                })?;
+                .map_err(|e| io(format!("create temp {}", tmp.display()), e))?;
             match f.try_lock_exclusive() {
                 Ok(()) => break (tmp, f),
                 // Only a reaper can hold the lock on a name this process just minted: it
@@ -1473,7 +1472,10 @@ impl Store {
         fault: &Fault,
         operation: Option<&str>,
     ) -> Result<Put> {
-        let catalog = crate::catalog::Catalog::open(&self.root)?;
+        let catalog = match crate::catalog::Catalog::open_admitting(&self.root) {
+            Ok(catalog) => catalog,
+            Err(refusal) => return cleanup(&verified.tmp, refusal),
+        };
         let _writer = crate::catalog::WriterGuard::acquire(&self.root)?;
         let object = ObjectRef {
             sha256: verified.sha256.clone(),

{tensorfs-0.3.65 → tensorfs-0.3.66}/crates/tensorfs-core/src/transport/tests.rs

@@ -2876,9 +2876,76 @@ fn paced_objects(size: usize, count: usize) -> (Vec<ObjectRef>, Bodies) {
     (declared, Arc::new(serve))
 }
 
-/// Walk `subset` from `origin` into a fresh store; the rate and what the walk reports.
-/// Every object is proven local and verified by `plan.complete` before the rate counts.
-fn paced_walk(origin: &Origin, streams: usize, subset: &[ObjectRef]) -> (f64, super::WalkOutcome) {
+/// How many GETs the origin itself was serving at once, counted where it serves them.
+#[derive(Default)]
+struct Concurrency {
+    now: AtomicUsize,
+    peak: AtomicUsize,
+}
+
+impl Concurrency {
+    fn enter(&self) {
+        let now = self.now.fetch_add(1, Ordering::AcqRel) + 1;
+        self.peak.fetch_max(now, Ordering::AcqRel);
+    }
+    fn leave(&self) {
+        self.now.fetch_sub(1, Ordering::AcqRel);
+    }
+    fn reset(&self) -> usize {
+        self.peak.swap(0, Ordering::AcqRel)
+    }
+}
+
+/// An origin that paces every body at `chunk` per `gap`. With `shared`, all connections
+/// draw from one schedule (the link is the limit); without, each has its own (one GET is
+/// the limit). It counts the GETs in flight on its own side of the socket.
+fn paced_origin(
+    body: Bodies,
+    chunk: usize,
+    gap: Duration,
+    shared: bool,
+) -> (Origin, Arc<Concurrency>) {
+    let serving = Arc::new(Concurrency::default());
+    let link = Arc::new(Mutex::new(std::time::Instant::now()));
+    let counted = Arc::clone(&serving);
+    let origin = origin(Arc::new(move |request: &Request| {
+        let body = body(request.path.trim_start_matches("/obj/"));
+        let (link, serving) = (Arc::clone(&link), Arc::clone(&counted));
+        Serve::Script(Box::new(move |socket: &mut TcpStream| {
+            serving.enter();
+            let head = format!(
+                "HTTP/1.1 200 OK\r\ncontent-length: {}\r\nconnection: close\r\n\r\n",
+                body.len()
+            );
+            let _ = socket.write_all(head.as_bytes());
+            let mut own = std::time::Instant::now();
+            for piece in body.chunks(chunk) {
+                let due = if shared {
+                    let mut next = link.lock().unwrap();
+                    *next = (*next).max(std::time::Instant::now()) + gap;
+                    *next
+                } else {
+                    own += gap;
+                    own
+                };
+                let now = std::time::Instant::now();
+                if due > now {
+                    std::thread::sleep(due - now);
+                }
+                if socket.write_all(piece).is_err() {
+                    break;
+                }
+            }
+            serving.leave();
+        }))
+    }));
+    (origin, serving)
+}
+
+/// Walk `subset` from `origin` into a fresh store and prove every object local and
+/// verified. The ledger samples each second: its stall floor (six samples) is far above
+/// any pause a loaded test box puts between two chunks, and nothing here is timed.
+fn paced_walk(origin: &Origin, streams: usize, subset: &[ObjectRef]) -> super::WalkOutcome {
     let root = temporary(&format!("paced-{streams}-{}", subset.len()));
     let store = Store::init(&root).unwrap();
     let (plan, _) = FetchPlan::of_objects(&store, "paced", subset).unwrap();
@@ -2891,8 +2958,6 @@ fn paced_walk(origin: &Origin, streams: usize, subset: &[ObjectRef]) -> (f64, su
             )
         })
         .collect();
-    let ledger = Ledger::with_resolution(Duration::from_millis(200));
-    let started = std::time::Instant::now();
     let walked = super::pull::fetch_wanted(
         &store,
         &plan,
@@ -2900,12 +2965,11 @@ fn paced_walk(origin: &Origin, streams: usize, subset: &[ObjectRef]) -> (f64, su
         &local_policy(),
         &Anonymous,
         Deadline::none(),
-        &ledger,
+        &Ledger::with_resolution(Duration::from_secs(1)),
         streams,
         None,
     )
     .unwrap();
-    let seconds = started.elapsed().as_secs_f64();
     plan.complete(&store).unwrap();
     for object in subset {
         let mut bytes = Vec::new();
@@ -2922,109 +2986,78 @@ fn paced_walk(origin: &Origin, streams: usize, subset: &[ObjectRef]) -> (f64, su
     }
     let _ = std::fs::remove_dir_all(root);
     assert_eq!(walked.fetched as usize, subset.len());
-    (walked.bytes_moved as f64 / 1e6 / seconds, walked)
+    let declared: u64 = subset.iter().map(|o| o.length).sum();
+    assert_eq!(walked.bytes_moved, declared, "every declared byte, once");
+    walked
 }
 
-/// Run 1225's shape: one GET is the limit, not the link. Each connection drips ~0.4 MB/s,
-/// so a walk held at 16 streams is held at 16 times that however fast the link is. The
-/// paced walk measures that each doubling buys goodput, grows past 16, and every object
-/// still crosses the one door and verifies.
+/// Run 1225's shape: one GET is the limit, not the link. Each connection is paced at
+/// ~0.2 MB/s on its own schedule, so every doubling of streams doubles what the origin
+/// can hand over. The walk must climb to its ceiling, and the ORIGIN must have served
+/// that many GETs at once. Nothing here asserts a rate or a duration.
 #[test]
 fn a_walk_grows_past_sixteen_while_one_get_is_the_limit() {
-    const SIZE: usize = 512 << 10;
-    const CHUNK: usize = 8 << 10;
-    let gap = Duration::from_millis(20);
-    let (declared, body) = paced_objects(SIZE, 384);
-    let origin = origin(Arc::new(move |request: &Request| Serve::Drip {
-        body: body(request.path.trim_start_matches("/obj/")),
-        chunk: CHUNK,
-        gap,
-        ttfb: Duration::from_millis(20),
-    }));
-    let one_get = CHUNK as f64 / gap.as_secs_f64() / 1e6;
+    let (declared, body) = paced_objects(1 << 20, 320);
+    let (origin, serving) = paced_origin(body, 4 << 10, Duration::from_millis(20), false);
 
-    let (held, fixed) = paced_walk(&origin, 16, &declared[..48]);
-    let (paced, grew) = paced_walk(&origin, super::PULL_STREAMS, &declared);
-    println!(
-        "one GET {one_get:.2} MB/s; held at 16: {held:.1} MB/s; paced: {paced:.1} MB/s, \
-         ended at {} streams via {:?}",
-        grew.streams, grew.levels
-    );
-    assert_eq!(fixed.streams, 16);
-    assert!(fixed.levels.is_empty(), "an explicit 16 is a fixed walk");
+    let fixed = paced_walk(&origin, 16, &declared[..32]);
     assert!(
-        held <= 16.0 * one_get * 1.1,
-        "the control is capped by 16 GETs: {held:.1}"
+        fixed.streams == 16 && fixed.levels.is_empty(),
+        "an explicit 16 is a fixed walk: {fixed:?}"
     );
-    assert!(
-        grew.streams >= 64,
-        "goodput followed every doubling: {grew:?}"
+    // The origin counts a GET until its handler returns, which can overlap the next GET
+    // by a scheduling instant; the fixed walk's peak is reported, not asserted.
+    let held = serving.reset();
+    let grew = paced_walk(&origin, super::PULL_STREAMS, &declared[32..]);
+    let peak = serving.reset();
+    println!(
+        "fixed peak {held}; paced peak {peak}, ended at {} via {:?}",
+        grew.streams, grew.levels
     );
-    // The socket-side goodput each level measured is the mechanism; the wall rate also
-    // pays this box's disk, which other tests share, so it is only held to beating 16.
-    let (first, last) = (grew.levels[0], grew.levels[grew.levels.len() - 1]);
-    assert!(
-        last.bytes_per_second >= 3.0 * first.bytes_per_second,
-        "the top level moved {:.1} MB/s against {:.1} at 16",
-        last.bytes_per_second / 1e6,
-        first.bytes_per_second / 1e6
+    assert_eq!(
+        grew.streams,
+        super::PULL_STREAMS,
+        "growth stopped early: {grew:?}"
     );
     assert!(
-        paced > held,
-        "paced {paced:.1} MB/s did not beat 16 streams at {held:.1}"
+        peak > 64,
+        "the origin never served more than {peak} GETs at once: {grew:?}"
     );
+    for pair in grew.levels.windows(2) {
+        assert_eq!(
+            pair[1].streams,
+            2 * pair[0].streams,
+            "levels double: {grew:?}"
+        );
+    }
 }
 
-/// The other half of the rule: when the LINK is the limit, a doubling buys nothing and the
-/// walk stops growing instead of piling up partial objects. Every connection shares one
-/// ~13 MB/s schedule here, which 16 streams already fill.
+/// The other half of the rule: when the LINK is the limit, a doubling buys nothing and
+/// the walk stops growing instead of piling up partial objects. Every connection shares
+/// one schedule here, which a handful of streams already fill.
 #[test]
 fn a_walk_does_not_grow_when_the_link_is_the_limit() {
-    const SIZE: usize = 512 << 10;
-    const CHUNK: usize = 16 << 10;
-    let slot = Duration::from_micros(1250); // one 16 KiB chunk per slot: ~13 MB/s shared
-    let (declared, body) = paced_objects(SIZE, 96);
-    let link = Arc::new(Mutex::new(std::time::Instant::now()));
-    let origin = origin(Arc::new(move |request: &Request| {
-        let body = body(request.path.trim_start_matches("/obj/"));
-        let link = Arc::clone(&link);
-        Serve::Script(Box::new(move |socket: &mut TcpStream| {
-            let head = format!(
-                "HTTP/1.1 200 OK\r\ncontent-length: {}\r\nconnection: close\r\n\r\n",
-                body.len()
-            );
-            let _ = socket.write_all(head.as_bytes());
-            for piece in body.chunks(CHUNK) {
-                let due = {
-                    let mut next = link.lock().unwrap();
-                    let now = std::time::Instant::now();
-                    *next = (*next).max(now) + slot;
-                    *next
-                };
-                let now = std::time::Instant::now();
-                if due > now {
-                    std::thread::sleep(due - now);
-                }
-                if socket.write_all(piece).is_err() {
-                    return;
-                }
-            }
-        }))
-    }));
-    let (held, _) = paced_walk(&origin, 16, &declared);
-    let (rate, walked) = paced_walk(&origin, super::PULL_STREAMS, &declared);
+    let (declared, body) = paced_objects(512 << 10, 160);
+    let (origin, serving) = paced_origin(body, 16 << 10, Duration::from_micros(1250), true);
+    let walked = paced_walk(&origin, super::PULL_STREAMS, &declared);
+    let peak = serving.reset();
     println!(
-        "shared link: held at 16 {held:.1} MB/s; paced {rate:.1} MB/s, ended at {} streams via {:?}",
+        "shared link: peak {peak}, ended at {} via {:?}",
         walked.streams, walked.levels
     );
     assert!(
-        walked.streams <= 32,
-        "a full link earned no growth: {walked:?}"
+        walked.streams < super::PULL_STREAMS,
+        "a full link grew the walk to its ceiling: peak {peak}, {walked:?}"
     );
-    let levels = &walked.levels;
+    // It stopped because a doubling stopped paying, as it measured it.
+    let last = walked
+        .levels
+        .windows(2)
+        .last()
+        .expect("at least one probe past 16");
     assert!(
-        levels.len() == 2 && levels[1].bytes_per_second < super::GAIN * levels[0].bytes_per_second,
-        "the one probe past 16 measured the full link and stopped: {levels:?}"
+        last[1].bytes_per_second < super::GAIN * last[0].bytes_per_second,
+        "the walk stopped without a doubling that failed to pay: {walked:?}"
     );
 }
 

{tensorfs-0.3.65 → tensorfs-0.3.66}/crates/tensorfs-core/tests/anima_hf_profile.rs

@@ -164,3 +164,14 @@ fn anima_hf_refuses_a_missing_component_before_payload_transfer() {
     assert_ne!(error.code, Code::IO_FAILED, "{error:?}");
     assert!(!path.exists());
 }
+
+#[test]
+fn anima_hf_selects_its_profile_without_being_named() {
+    let path = scratch("select");
+    assert_eq!(
+        preflight::select_profile(BUILTIN_REGISTRY, BUILTIN_REGISTRY_BYTES, &heads(), &path)
+            .unwrap(),
+        PROFILE
+    );
+    assert!(!path.exists());
+}