Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
40 changes: 0 additions & 40 deletions quest/m1/precut-fixes/tail-ledger-bound.md

This file was deleted.

17 changes: 9 additions & 8 deletions rs/moq-net/src/lite/subscriber.rs
Original file line number Diff line number Diff line change
Expand Up @@ -11197,7 +11197,7 @@ impl TrackServe {
let widened = (changed && demand.is_some())
.then(|| subscription.start().or(active.started.flatten()).unwrap_or(0)..u64::MAX);
if let Ok(mut tail) = active.tail.write() {
tail.set_grace(producer.tail_grace(subscription.budget()));
tail.follow(producer, subscription.budget());
let now = self.subscriber.runtime.now();
for groups in lowered.into_iter().chain(widened) {
tail.demand(groups, now);
Expand Down Expand Up @@ -11387,11 +11387,12 @@ impl TrackServe {
tracing::debug!(id, broadcast = %self.subscriber.log_path(&self.path), track = %self.name, "subscribe started");

// A pipelined SUBSCRIBE has no copy, so no max age, until it is adopted.
let grace = match &copy {
Some(copy) => copy.producer.tail_grace(subscription.budget()),
None => tail::grace(subscription.budget()),
};
let tail = kio::Producer::new(Tail::new(grace));
let tail = kio::Producer::new(Tail::new(tail::grace(subscription.budget())));
if let Some(copy) = &copy
&& let Ok(mut tail) = tail.write()
{
tail.follow(&copy.producer, subscription.budget());
}
let mut entry = TrackEntry::new(copy, tail.clone());
let version = self.subscriber.version;
if version.has_datagrams() && !version.has_datagram_tracks() {
Expand Down Expand Up @@ -12764,7 +12765,7 @@ impl ServeLoop {
PipelinedState::Open(active) => &active.tail,
};
if let Ok(mut tail) = tail.write() {
tail.set_grace(self.serving.tail_grace(pipelined.pref.budget()));
tail.follow(&self.serving, pipelined.pref.budget());
}
self.serving.seen_subscription(Some(pipelined.pref));
match pipelined.state {
Expand Down Expand Up @@ -13069,7 +13070,7 @@ impl ServeLoop {
if !serve.subscriber.version.has_track_stream() {
tail.end();
}
tail.set_grace(serving.tail_grace(budget.unwrap_or_default()));
tail.follow(serving, budget.unwrap_or_default());
tail.expire(serve.subscriber.runtime.now());
}
Settle::new(&serve.subscriber.runtime, active.tail.consume())
Expand Down
66 changes: 49 additions & 17 deletions rs/moq-net/src/model/cache.rs
Original file line number Diff line number Diff line change
Expand Up @@ -725,16 +725,20 @@ pub(super) struct Track {
// account drops. Raw codec only: an Extra here would keep this account alive.
encoder: Mutex<Option<flate::Encoder>>,

// What this track's readers' records bill, how many bill anything, and the eviction debt
// the track could not pay itself, which those readers pay; see [`Reader`].
// What this track's readers' records bill, how many bill anything, the tail ledgers' bills,
// and the eviction debt the track could not pay itself, which those readers pay; see
// [`Reader`].
readers: Readers,
}

/// What a track's readers bill for their records, and the debt they owe.
#[derive(Default)]
struct Readers {
// Records only: the mean [`Reader::ends`] compares against, which a tail never skews.
bytes: AtomicU64,
count: AtomicU64,
// Tail ledgers: room for the debt like the records, but never one to end.
tails: AtomicU64,
debt: AtomicU64,
}

Expand Down Expand Up @@ -949,16 +953,28 @@ impl Track {
Reader {
track: self.clone(),
bytes: 0,
record: true,
}
}

/// Open an empty bill against this account for a subscription's tail ledger: it pays the
/// readers' debt by folding, but never ends, since a publisher's drops are final.
pub(super) fn tail(self: &Arc<Self>) -> Reader {
Reader {
track: self.clone(),
bytes: 0,
record: false,
}
}

/// Hand the part of `debt` this track could not pay to its readers, up to what their
/// records bill beyond what they already owe.
/// records and tails bill beyond what they already owe.
pub(super) fn owe_readers(&self, debt: &mut u64) {
let readers = &self.readers;
let mut shifted = 0;
let _ = readers.debt.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |owed| {
let room = readers.bytes.load(Ordering::Relaxed).saturating_sub(owed);
let billed = readers.bytes.load(Ordering::Relaxed) + readers.tails.load(Ordering::Relaxed);
let room = billed.saturating_sub(owed);
shifted = room.min(*debt);
(shifted > 0).then_some(owed + shifted)
});
Expand Down Expand Up @@ -1365,37 +1381,44 @@ impl Drop for Charge {
}
}

/// What one reader's record bills to its track's account, and its share of the debt the
/// track could not pay. Released on drop.
pub(super) struct Reader {
/// What one reader's record, or one subscription's tail ledger, bills to its track's account,
/// and its share of the debt the track could not pay. Released on drop.
///
/// Only a record can [`Self::ends`]; a tail pays by folding, so it stays out of the mean
/// that decides which record to end.
pub(crate) struct Reader {
track: Arc<Track>,
bytes: u64,
record: bool,
}

impl Reader {
/// Bill `bytes` in all, settling the track's debt after a growth: call with no track lock
/// held.
pub(super) fn set(&mut self, bytes: u64) {
pub(crate) fn set(&mut self, bytes: u64) {
Comment thread
kixelated marked this conversation as resolved.
Resolved
if bytes == self.bytes {
return;
}
let readers = &self.track.readers;
match (self.bytes, bytes) {
(0, _) => readers.count.fetch_add(1, Ordering::Relaxed),
(_, 0) => readers.count.fetch_sub(1, Ordering::Relaxed),
_ => 0,
};
let billed = if self.record { &readers.bytes } else { &readers.tails };
if self.record {
match (self.bytes, bytes) {
(0, _) => readers.count.fetch_add(1, Ordering::Relaxed),
(_, 0) => readers.count.fetch_sub(1, Ordering::Relaxed),
_ => 0,
};
}
if bytes > self.bytes {
let grown = bytes - self.bytes;
readers.bytes.fetch_add(grown, Ordering::Relaxed);
billed.fetch_add(grown, Ordering::Relaxed);
self.track.pool.add(grown);
self.track.written.fetch_add(grown, Ordering::Relaxed);
self.bytes = bytes;
self.track.charge_over();
} else {
// Whatever a record frees pays toward its readers' debt, however it shrank.
let shrunk = self.bytes - bytes;
readers.bytes.fetch_sub(shrunk, Ordering::Relaxed);
billed.fetch_sub(shrunk, Ordering::Relaxed);
let _ = readers.debt.fetch_update(Ordering::Relaxed, Ordering::Relaxed, |debt| {
(debt > 0).then(|| debt.saturating_sub(shrunk))
});
Expand All @@ -1406,7 +1429,7 @@ impl Reader {

/// The debt the track's readers owe, forgiven once the pool is back within its capacity:
/// nothing needs the room any more, as the track forgives its own debt.
pub(super) fn debt(&self) -> u64 {
pub(crate) fn debt(&self) -> u64 {
let readers = &self.track.readers;
let pool = &self.track.pool;
if pool.capacity().is_none_or(|capacity| pool.used() <= capacity) {
Expand All @@ -1422,11 +1445,20 @@ impl Reader {
pub(super) fn ends(&self) -> bool {
let readers = &self.track.readers;
let count = readers.count.load(Ordering::Relaxed);
self.bytes > ENTRY_OVERHEAD
self.record
&& self.bytes > ENTRY_OVERHEAD
&& u128::from(self.bytes) * u128::from(count) >= u128::from(readers.bytes.load(Ordering::Relaxed))
}
}

impl std::fmt::Debug for Reader {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Reader")
.field("bytes", &self.bytes)
.finish_non_exhaustive()
}
}

impl Drop for Reader {
fn drop(&mut self) {
self.set(0);
Expand Down
26 changes: 26 additions & 0 deletions rs/moq-net/src/model/record.rs
Original file line number Diff line number Diff line change
Expand Up @@ -465,6 +465,32 @@ mod test {
small.settle(|| track.clone(), &mut (), None).unwrap();
}

/// A tail's bill pays the readers' debt but is no record to end: it never joins the mean
/// that picks which record ends, whether it is small or large.
#[test]
fn a_tail_bill_never_skews_which_record_ends() {
let (_pool, track) = account();
let mut records = [track.reader(), track.reader()];
records[0].set(1_536);
records[1].set(2_880);
let mut tail = track.tail();
tail.set(RUN_OVERHEAD);
assert!(
!records[0].ends(),
"the mean is the records' 2208 B, not the tail's share"
);
assert!(records[1].ends());
assert!(!tail.ends(), "a tail never ends");
tail.set(100_000);
assert!(
records[1].ends(),
"a large tail does not lift the mean over every record"
);
drop(tail);
assert!(records[1].ends());
assert!(!records[0].ends());
}

/// Whatever a bill frees pays its readers' debt, however it shrank, and the debt is forgiven
/// once the pool is back within its capacity: nothing needs the room any more.
#[test]
Expand Down
6 changes: 6 additions & 0 deletions rs/moq-net/src/model/track.rs
Original file line number Diff line number Diff line change
Expand Up @@ -5273,6 +5273,12 @@ impl Producer {
ledger::grace(clamp_max_delay(budget, self.state.read().max_age_bound()))
}

/// An empty bill against this track's cache account, for a subscription's tail ledger.
#[cfg_attr(not(feature = "async"), allow(dead_code, reason = "async-only"))]
pub(crate) fn tail_bill(&self) -> cache::Reader {
self.state.read().cache.tail()
}

/// Create a [`Requests`] handle that serves on-demand fetches of uncached
/// (old) groups. Most producers never need this; a relay creates one to fetch
/// past groups from upstream.
Expand Down
Loading