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
3 changes: 1 addition & 2 deletions quest/m1/release-perf/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -61,7 +61,7 @@ usually pays for a feature.
| `track_gap_flush/64` | 1.5 us | 6.2 us | 4.1x | same |
| `stats/session-report/1000x10` | 11.0 us | 86.8 us | 7.9x | [Stats report](/quest/m1/release-perf/stats-report.md) |
| `track_gc/idle/16384` | 11.6 ns | 73.7 ns | 6.3x | [Idle GC](/quest/m1/release-perf/gc-idle.md) |
| `origin/resume_overlap/sequence/1r_64g_32c` | 93 us | 426 us | 4.6x | [Resume duplicates](/quest/m1/release-perf/resume-duplicates.md) |
| `origin/resume_overlap/sequence/1r_64g_32c` | 93 us | 426 us | 4.6x | fixed in [moq-dev/moq#6292](https://github.com/moq-dev/moq/pull/6292) |
| `session_delivery_group_cost/moq-transport-22/.../viewers=64/.../fetch` | 1.19 ms | 3.86 ms | 3.2x | accepted (above) |
| `group_write_frames/single/8192` | 424 us | 486 us | 1.17x | [Re-check](/quest/m1/release-perf/recheck.md) |

Expand Down Expand Up @@ -94,7 +94,6 @@ one.

- [FETCH fan-out](/quest/m1/release-perf/fetch-fanout.md) - a relay serves later viewers' lite FETCHes of a group from its cache, so per-viewer cost falls with viewers again
- [Sparse gaps](/quest/m1/release-perf/sparse-gaps.md) - an arrival and a gap flush cost O(log gaps), not O(gaps)
- [Resume duplicates](/quest/m1/release-perf/resume-duplicates.md) - an ordered resume skips copies of an already-delivered group without consuming them
- [Idle GC](/quest/m1/release-perf/gc-idle.md) - an idle track GC skips the wall-clock pass when nothing is due
- [Stats report](/quest/m1/release-perf/stats-report.md) - the stats drain locks each row once and its bench counts the wire walk; per-label bytes stay, at an accepted O(live sessions)
- [Re-check](/quest/m1/release-perf/recheck.md) - the screen-only moves are re-measured with instruction counts, and the ones that hold are fixed or accepted
Expand Down
33 changes: 0 additions & 33 deletions quest/m1/release-perf/resume-duplicates.md

This file was deleted.

70 changes: 56 additions & 14 deletions rs/moq-net/benches/origin.rs
Original file line number Diff line number Diff line change
Expand Up @@ -1337,6 +1337,20 @@ struct ResumeOverlap {
readers: Vec<ResumeReader>,
}

impl ResumeOverlap {
#[inline(never)]
fn drain(&mut self, retained: usize) {
let waiter = kio::Waiter::noop();
for reader in &mut self.readers {
let mut delivered = 0;
while let Poll::Ready(Ok(Some(_))) = reader.poll_group(&waiter) {
delivered += 1;
}
assert_eq!(delivered, retained, "every group once");
}
}
}

enum ResumeReader {
Arrival(track::Subscriber),
Sequence(track::Ordered),
Expand All @@ -1351,7 +1365,20 @@ impl ResumeReader {
}
}

async fn resume_overlap(readers: usize, retained: usize, routes: usize, ordered: bool) -> ResumeOverlap {
struct ResumeShape {
readers: usize,
retained: usize,
routes: usize,
waiting: bool,
}

async fn resume_overlap(shape: ResumeShape, ordered: bool) -> ResumeOverlap {
let ResumeShape {
readers,
retained,
routes,
waiting,
} = shape;
let (producer, driver) = origin::Producer::new(origin::Config::default());
tokio::spawn(moq_net::time::run(driver));
let epoch = Epoch::mint();
Expand Down Expand Up @@ -1391,8 +1418,14 @@ async fn resume_overlap(readers: usize, retained: usize, routes: usize, ordered:
subscribers.push(subscriber);
}
let waiter = kio::Waiter::noop();
for _ in 1..routes {
generations.push(generation(&mut (0..retained).rev()));
for route in 1..routes + usize::from(waiting) {
generations.push(if waiting && route == routes {
// The serving copy has answered but not produced a group. It has not yet
// bounded the overlapping copies, which must still skip each other's replay.
generation(&mut std::iter::empty())
} else {
generation(&mut (0..retained).rev())
});
let (_, latest) = generations.last().unwrap();
moq_clock::timeout(COPY_WAIT, support::wanted(latest.demand()))
.await
Expand Down Expand Up @@ -1429,8 +1462,16 @@ async fn resume_overlap(readers: usize, retained: usize, routes: usize, ordered:
fn bench_resume_overlap(c: &mut Criterion) {
let mut group = c.benchmark_group("origin/resume_overlap");
group.sample_size(10);
for (order, ordered) in [("arrival", false), ("sequence", true)] {
for (order, ordered, waiting) in [
("arrival", false, false),
("sequence", true, false),
("arrival_waiting", false, true),
("sequence_waiting", true, true),
] {
for (readers, retained, routes) in RESUME_OVERLAP {
if waiting && !(readers == 1 && retained == 64 && routes >= 2) {
continue;
}
group.throughput(Throughput::Elements((readers * retained) as u64));
group.bench_function(
BenchmarkId::new(order, format!("{readers}r_{retained}g_{routes}c")),
Expand All @@ -1439,18 +1480,19 @@ fn bench_resume_overlap(c: &mut Criterion) {
.enable_all()
.build()
.unwrap();
let waiter = kio::Waiter::noop();
b.iter_batched_ref(
|| runtime.block_on(resume_overlap(readers, retained, routes, ordered)),
|rig| {
for reader in &mut rig.readers {
let mut delivered = 0;
while let Poll::Ready(Ok(Some(_))) = reader.poll_group(&waiter) {
delivered += 1;
}
assert_eq!(delivered, retained, "every group once");
}
|| {
runtime.block_on(resume_overlap(
ResumeShape {
readers,
retained,
routes,
waiting,
},
ordered,
))
},
|rig| rig.drain(retained),
BatchSize::PerIteration,
);
},
Expand Down
8 changes: 8 additions & 0 deletions rs/moq-net/src/model/delivered.rs
Original file line number Diff line number Diff line change
Expand Up @@ -22,6 +22,11 @@ impl Delivered {
.is_some_and(|(_, last)| sequence <= *last)
}

/// The first sequence above the handed-out prefix, or none once every sequence is past.
pub fn floor(&self) -> Option<u64> {
self.runs.get(&0).map_or(Some(0), |last| last.checked_add(1))
}

/// Whether every sequence in `groups` was handed out, or is below the floor.
pub fn covers(&self, groups: std::ops::Range<u64>) -> bool {
groups.is_empty()
Expand Down Expand Up @@ -104,6 +109,7 @@ mod test {
assert_eq!(runs(&delivered), [(4, 8)]);
assert!(delivered.contains(4) && delivered.contains(8));
assert!(!delivered.contains(3) && !delivered.contains(9));
assert_eq!(delivered.floor(), Some(0), "a run above a gap is not the prefix");
assert!(delivered.covers(4..9) && delivered.covers(9..9));
assert!(!delivered.covers(3..5) && !delivered.covers(8..10));
}
Expand All @@ -117,6 +123,7 @@ mod test {
assert_eq!(runs(&delivered), [(0, 0), (u64::MAX, u64::MAX)]);
delivered.forget_below(u64::MAX);
assert_eq!(runs(&delivered), [(0, u64::MAX)]);
assert_eq!(delivered.floor(), None);
}

#[test]
Expand All @@ -134,6 +141,7 @@ mod test {
assert_eq!(runs(&delivered), [(0, 6), (9, 9), (12, 12)]);
assert_eq!(delivered.above_gap(), Some(9));
assert!(delivered.contains(4), "below the floor counts as handed out");
assert_eq!(delivered.floor(), Some(7));

// A floor inside a gap keeps the run above it.
delivered.forget_below(11);
Expand Down
122 changes: 117 additions & 5 deletions rs/moq-net/src/model/resume.rs
Original file line number Diff line number Diff line change
Expand Up @@ -576,6 +576,18 @@ impl Subscriber {
}
}

/// Invalidate a reservation below the containing reader's past prefix.
pub(super) fn skip_ordered(&mut self, floor: Option<u64>) {
let mut reader = self.reader();
if reader
.peeked
.as_ref()
.is_some_and(|peeked| floor.is_none_or(|floor| peeked.sequence < floor))
{
reader.peeked = None;
}
}

/// Poll for the next datagram in arrival order. `delivered` decides which replaced
/// copies still have a group to hand out, once groups were asked for.
pub(super) fn poll_recv_datagram(
Expand Down Expand Up @@ -1112,12 +1124,18 @@ impl Reader {
self.groups_read = true;
let groups = self.groups;
let budget = self.mirrored.max_delay;
let floor = if ordered { delivered.floor() } else { Some(0) };
let mut lowest: Option<Candidate> = None;
for index in 0..self.copies.len() {
let copy = &mut self.copies[index];
// What a replaced copy holds is past the reader's budget once a newer group
// superseded it a full budget ago.
if copy.done.is_some() || copy.expired(budget, waiter) {
// A fully handed-out bounded copy still backs groups being read, but cannot
// supply another one. Keep its recovery lease without polling its empty range.
if copy.done.is_some()
|| copy.end().is_some_and(|end| delivered.covers(groups.0..end))
|| copy.expired(budget, waiter)
{
continue;
}
loop {
Expand All @@ -1130,6 +1148,9 @@ impl Reader {
}
Poll::Ready(Ok(sub)) => sub,
};
if ordered {
sub.skip_ordered(floor);
}
let res = sub.poll_peek_group(ordered, waiter);
match res {
Poll::Pending => break,
Expand All @@ -1138,10 +1159,11 @@ impl Reader {
let Sub::Ready(sub) = &mut self.copies[index].sub else {
unreachable!()
};
let _ = match ordered {
true => sub.poll_next_group(waiter),
false => sub.poll_recv_group(waiter),
};
if ordered {
sub.skip_ordered(sequence.checked_add(1));
} else {
let _ = sub.poll_recv_group(waiter);
}
continue;
}
if lowest.as_ref().is_none_or(|lowest| sequence <= lowest.sequence) {
Expand Down Expand Up @@ -2495,6 +2517,96 @@ mod test {
}
}

#[test]
fn a_fresh_nested_reader_ends_after_its_outer_reader_already_passed_its_groups() {
let routes = Producer::new();
let outer = logical(&routes);
let a = copy();
routes.serve(a.consume());
let mut sub = subscribe(&outer, HOUR);
for sequence in 0..4 {
write(&a, sequence);
}
assert_eq!(drain(&mut sub, true), [0, 1, 2, 3]);

let nested_routes = Producer::new();
let nested = logical(&nested_routes);
let b = copy();
for sequence in 0..4 {
write(&b, sequence);
}
nested_routes.serve(b.consume());
routes.serve(nested.consume());
let waiter = kio::Waiter::noop();
assert!(sub.poll_next_group(&waiter).is_pending());

// The nested reader has handed nothing out itself. Its containing reader's
// past prefix must also release the replaced copy when its serving copy ends.
let c = copy();
for sequence in 0..4 {
write(&c, sequence);
}
c.finish().unwrap();
nested_routes.serve(c.consume());
assert!(matches!(sub.poll_next_group(&waiter), Poll::Ready(Ok(None))));
}

#[test]
fn ordered_replay_skips_unbounded_copies_while_a_nested_route_waits() {
for nested in [false, true] {
let routes = Producer::new();
let inner = logical(&routes);
let outer_routes = Producer::new();
let outer = logical(&outer_routes);
outer_routes.serve(inner.consume());
let a = copy();
routes.serve(a.consume());
let mut sub = subscribe(if nested { &outer } else { &inner }, HOUR);
sub.set_groups(..0);
for sequence in 0..4 {
write(&a, sequence);
}
assert!(
drain(&mut sub, true).is_empty(),
"subscribe the nested reader before switching"
);
let b = copy();
for sequence in 0..4 {
write(&b, sequence);
}
routes.serve(b.consume());
assert!(drain(&mut sub, true).is_empty());
let c = track::Request::new(Arc::new(broadcast::Info::default()), "video");
routes.serve(c.consume());
assert!(drain(&mut sub, true).is_empty());
sub.set_groups(..);
assert_eq!(drain(&mut sub, true), [0, 1, 2, 3], "nested={nested}");
{
let readers = routes.readers.lock().unwrap();
let reader = readers.iter().find_map(Weak::upgrade).unwrap();
let reader = reader.lock().unwrap();
let Sub::Ready(older) = &reader.copies[0].sub else {
panic!("older copy ready")
};
assert_eq!(
older.delivered_runs(),
0,
"duplicates were never handed out on the older copy: nested={nested}"
);
}
let c = c.accept(crate::track::Info::timed());
for sequence in 0..5 {
write(&c, sequence);
}
assert_eq!(drain(&mut sub, true), [4], "a newly ready copy inherits the floor");
c.finish().unwrap();
assert!(
matches!(sub.poll_next_group(&kio::Waiter::noop()), Poll::Ready(Ok(None))),
"nested end propagates past covered copies"
);
}
}

/// A replaced copy is bounded only once the new copy delivers its first group: a group
/// buffered on it must be read before a later group on the serving copy.
#[test]
Expand Down
Loading
Loading