From 68d46fb9ced63008ad2456152efeff6de953c226 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 14 Oct 2026 11:57:27 -0700 Subject: [PATCH 1/3] chore: claim TS export backlog quest Co-Authored-By: GPT-6 From 7a9243968f3164399dd555589fbdb1457dfd96db Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 14 Oct 2026 13:34:00 -0700 Subject: [PATCH 2/3] fix(ts): leave due-frame backlogs in their sources Co-Authored-By: GPT-6 --- quest/m1/README.md | 1 - quest/m1/ts-export-backlog.md | 35 ----- rs/moq-mux/benches/export.rs | 14 +- rs/moq-mux/src/container/ts/export.rs | 144 ++++++++++++------- rs/moq-mux/src/container/ts/export_test.rs | 60 ++++++++ rs/moq-mux/src/container/ts/release.rs | 147 +++++++++++++++++++- rs/moq-mux/src/container/ts/release_test.rs | 51 +++++++ 7 files changed, 359 insertions(+), 93 deletions(-) delete mode 100644 quest/m1/ts-export-backlog.md diff --git a/quest/m1/README.md b/quest/m1/README.md index 2923a4ab573..c42eb6e4775 100644 --- a/quest/m1/README.md +++ b/quest/m1/README.md @@ -147,7 +147,6 @@ above them. - [Audio warmup](/quest/m1/audio-warmup.md) - a viewer joining an Opus rendition mid-stream never hears the unconverged first 80 ms - [#3021](/quest/m1/3021-moq-gst-anchor-generated-media-timelines-to-wall-clock.md) - moq-gst picks the broadcast wall epoch; a restarted source is a new epoch, not a forward re-anchor - [moqsrc A/V alignment](/quest/m1/gst-src-av-sync.md) - every `moqsrc` pad of a run shares one timestamp reference and segment base -- [TS export backlog](/quest/m1/ts-export-backlog.md) - `export ts` reads a track only until a frame is due, like FLV and MKV, so a backlog stays in the source - [CLI stdin shutdown on release](/quest/m1/cli-stdin-release.md) - backport only the runtime-teardown fix so a stopped CLI exits while its stdin writer stays open - [Draft 14-16 updates](/quest/m1/ietf-legacy-updates.md) - Rust and JS apply and answer moq-transport 14-16 request updates without ending or leaking the request - [Tail arrivals](/quest/m1/tail-arrivals.md) - a track judges its pending tail from recorded arrivals, not a cache scan, and errors a reader whose tail ends short diff --git a/quest/m1/ts-export-backlog.md b/quest/m1/ts-export-backlog.md deleted file mode 100644 index f5dd6866ef1..00000000000 --- a/quest/m1/ts-export-backlog.md +++ /dev/null @@ -1,35 +0,0 @@ -# [S] TS export leaves a backlog in its sources - -## Goal - -`moq export ts` reads a track only until it has a frame due, so a backlog (a -stalled sink, a large retained group) stays in the source and goes out as it -falls due instead of being queued whole in the jitter buffer first. Output -order, deadlines, and late drops are unchanged. A regression test on mock time -shows the bound, at zero and nonzero delay. - -## Plan - -[#5309](https://github.com/moq-dev/moq/pull/5309) bounded FLV and MKV this way -with the jitter buffer's `full` check: a track is full once a frame of it is -due, or holds any frame without a delay. TS still drains every ready frame, as -it did before that PR. Reuse the same check rather than a TS-specific bound, -and bound `--passthrough` too, whose release path drains ready frames the same way. -Bounding reads leaves arrived frames unread, so each read must judge a frame's -deadline on when its source was last empty, as FLV and MKV do, not on when it -was read: otherwise a slow sink makes frames that arrived on time late. The -regression test covers that slow-sink case for each path. - -This waited for the TS work then in flight, -[#5349](https://github.com/moq-dev/moq/pull/5349) (passthrough export) and -[#5305](https://github.com/moq-dev/moq/pull/5305) (stitch catalog bound); both -have landed. - -Watch for TS-only interactions: the zero-delay path lays grid slots from each -released frame, the program tables hold one frame per track before they are -built, and tune-in alignment drops audio ahead of the first video. Do not cap -how far ahead of now a track is read: a track sent ahead of the others (TS video -often leads audio) would be read late, skewing the leads and drift the clock -measures. A joiner still reads its retained group to the live edge while the -clock is acquired, as FLV and MKV do. Run the TS export benchmarks to show the -cost. diff --git a/rs/moq-mux/benches/export.rs b/rs/moq-mux/benches/export.rs index d35a1b7f66a..df6c204ba09 100644 --- a/rs/moq-mux/benches/export.rs +++ b/rs/moq-mux/benches/export.rs @@ -83,6 +83,12 @@ async fn export(format: &str, source: moq_mux::Source, stream: moq_mux::catalog: std::hint::black_box(chunk); chunks += 1; } + } else if format == "ts" { + let mut export = moq_mux::container::ts::Export::new(source).await.unwrap(); + while let Some(chunk) = export.next().await.unwrap() { + std::hint::black_box(chunk); + chunks += 1; + } } else { let mut export = moq_mux::container::mkv::Export::new(source, stream).with_fragment_duration(Duration::ZERO); while let Some(chunk) = export.next().await.unwrap() { @@ -101,7 +107,7 @@ fn bench_export(c: &mut Criterion) { let mut group = c.benchmark_group("container-export"); group.sample_size(10); group.measurement_time(Duration::from_secs(1)); - for format in ["flv", "mkv"] { + for format in ["flv", "mkv", "ts"] { for tracks in [1, 4, 16] { for frames in [1, 16, 64] { group.throughput(Throughput::Elements((tracks * frames) as u64)); @@ -111,7 +117,11 @@ fn bench_export(c: &mut Criterion) { || runtime.block_on(prepare(tracks, frames)), |(source, stream, fixture)| { let chunks = runtime.block_on(export(format, source, stream)); - assert_eq!(chunks, 1 + tracks * frames); + if format == "ts" { + assert!(chunks > 0); + } else { + assert_eq!(chunks, 1 + tracks * frames); + } fixture }, BatchSize::PerIteration, diff --git a/rs/moq-mux/src/container/ts/export.rs b/rs/moq-mux/src/container/ts/export.rs index 2cd39d8e005..04f29eed5e8 100644 --- a/rs/moq-mux/src/container/ts/export.rs +++ b/rs/moq-mux/src/container/ts/export.rs @@ -251,6 +251,13 @@ struct Track { pack: Option, } +/// Shared program state needed while reading one track. +struct Input<'a> { + waiting_for_header: bool, + video_start: Option, + jitter: &'a mut jitter::Buffer, +} + impl Track { /// A track reading `source`, its PID filled in by the catalog. fn new(source: ExportSource, kind: Kind) -> Self { @@ -298,6 +305,58 @@ impl Track { self.release(name, jitter, false) } + /// Read until a frame is due, or hold the first frame until the program tables are built. + fn fill(&mut self, name: &str, waiter: &kio::Waiter, input: &mut Input<'_>) -> crate::Result<()> { + if self.pending.is_some() || self.finished { + return Ok(()); + } + let is_video = matches!(self.kind, Kind::Video(_)); + loop { + if !input.waiting_for_header && input.jitter.full(&self.pid) { + break; + } + match self.source.poll_read(waiter)? { + Poll::Ready(Some(frame)) => { + if input.waiting_for_header && !self.source.header_ready() { + continue; + } + let pending = Pending { + frame, + restart: self.base.0 + self.source.markers(), + skip: self.base.1 + self.source.skips(), + arrived: self.empty, + read: web_async::time::Instant::now(), + }; + // A new timeline must reach the reset before tune-in alignment can drop it. + if let Some(start) = input.video_start + && !is_video && pending.restart == self.restart + && pending.frame.timestamp < start + { + continue; + } + if input.waiting_for_header { + self.pending = Some(pending); + break; + } + self.queue(name, pending, input.jitter)?; + } + Poll::Ready(None) => { + self.finished = true; + break; + } + Poll::Pending => { + self.empty = web_async::time::Instant::now(); + break; + } + } + } + // Nothing more can come in below the frames still held for their DTS. + if self.finished && !input.waiting_for_header { + self.release(name, input.jitter, true)?; + } + Ok(()) + } + /// Queue each AC-3 sync frame of a passed-through PES on its own, due at its own decode /// time: a receiver's buffer holds and decodes each on its own, and the whole PES would /// overflow it. A frame the last PES began decodes ahead of this PES, so the jitter buffer @@ -1003,8 +1062,8 @@ impl Export { si.poll(waiter); } - // 2. Read every frame the sources have: into the jitter buffer, or before the - // program tables are built, one per track. + // 2. Read each source until it has a frame due, or before the program tables + // are built, hold one per track. self.fill(waiter)?; // 3. Build the program tables once the layout is resolved and every @@ -1109,6 +1168,25 @@ impl Export { let drain = self.max_drain(); self.lay(Some(schedule::slot(decode.saturating_sub(drain.as_nanos()))))?; } + if self.queue.is_empty() { + // Releasing a due frame opens room in its source. Read it before parking: + // a zero-delay slot may need another frame to prove the slot is complete. + let track = self.tracks.get_mut(&name).expect("the released frame's track"); + let finished = track.finished; + track.fill( + &name, + waiter, + &mut Input { + waiting_for_header: false, + video_start: self.video_start, + jitter: &mut self.jitter, + }, + )?; + if !finished && track.finished { + self.schedule + .set_ended(self.tracks.values().all(|track| track.finished)); + } + } } self.lay_due(waiter)?; if let Some(out) = self.pop() { @@ -1198,7 +1276,7 @@ impl Export { })) } - /// Read every frame the sources have ready. + /// Read each source until it has a frame due. /// /// Before the program tables are built, each track holds its first frame instead, /// and slices that arrive before their codec config resolves are dropped: a receiver @@ -1206,53 +1284,13 @@ impl Export { /// keyframe that carries the parameter sets. [`ExportSource`] has already transformed /// Annex-B avc3/hev1 into length-prefixed form and resolved the avcC/hvcC. fn fill(&mut self, waiter: &kio::Waiter) -> crate::Result<()> { - let waiting_for_header = self.psi.is_none(); - let video_start = self.video_start; - for (name, track) in self.tracks.iter_mut() { - if track.pending.is_some() || track.finished { - continue; - } - let is_video = matches!(track.kind, Kind::Video(_)); - loop { - match track.source.poll_read(waiter)? { - Poll::Ready(Some(frame)) => { - if waiting_for_header && !track.source.header_ready() { - continue; - } - let pending = Pending { - frame, - restart: track.base.0 + track.source.markers(), - skip: track.base.1 + track.source.skips(), - arrived: track.empty, - read: web_async::time::Instant::now(), - }; - // A new timeline must reach the reset before tune-in alignment can drop it. - if let Some(start) = video_start - && !is_video && pending.restart == track.restart - && pending.frame.timestamp < start - { - continue; - } - if waiting_for_header { - track.pending = Some(pending); - break; - } - track.queue(name, pending, &mut self.jitter)?; - } - Poll::Ready(None) => { - track.finished = true; - break; - } - Poll::Pending => { - track.empty = web_async::time::Instant::now(); - break; - } - } - } - // Nothing more can come in below the frames still held for their DTS. - if track.finished && !waiting_for_header { - track.release(name, &mut self.jitter, true)?; - } + let mut input = Input { + waiting_for_header: self.psi.is_none(), + video_start: self.video_start, + jitter: &mut self.jitter, + }; + for (name, track) in &mut self.tracks { + track.fill(name, waiter, &mut input)?; } Ok(()) } @@ -1542,6 +1580,12 @@ impl Export { stats } + /// How many access units are waiting in the jitter buffer. + #[cfg(test)] + pub(super) fn buffered(&self) -> usize { + self.jitter.len() + } + /// When the next queued frame is due, or the next grid slot while media is queued or /// every source has finished and the tail runs out. #[cfg(test)] diff --git a/rs/moq-mux/src/container/ts/export_test.rs b/rs/moq-mux/src/container/ts/export_test.rs index 11017463886..bbd7ac92732 100644 --- a/rs/moq-mux/src/container/ts/export_test.rs +++ b/rs/moq-mux/src/container/ts/export_test.rs @@ -9044,3 +9044,63 @@ async fn a_switch_reads_the_instance_it_followed() { "nothing of the newer instance: {pts:?}" ); } + +/// A sink stall leaves arrived media in its source rather than draining it into the jitter buffer. +#[tokio::test(start_paused = true)] +async fn a_backlog_stays_in_the_source_until_due() { + use crate::container::test_util::{Live, raw_frame}; + + for delay in [Duration::ZERO, Duration::from_millis(100)] { + let mut config = AudioConfig::new(AAC { profile: 2 }, 44100, 2); + config.description = Some(Bytes::from_static(&[0x12, 0x10])); + let mut live = Live::audio(config); + let mut export = Export::new(live.source().await).await.unwrap().with_delay(delay); + let start = tokio::time::Instant::now(); + live.track.write(raw_frame(0, b"first", true)).unwrap(); + // A zero-delay slot needs a later frame to prove it is complete. + live.track.write(raw_frame(40_000, b"warm", false)).unwrap(); + while !export + .next() + .await + .unwrap() + .unwrap() + .payload + .windows(5) + .any(|part| part == b"first") + {} + // Acquiring the first clock advances mock time; the publisher keeps capturing on it. + let base = 40_000 + start.elapsed().as_micros() as u64; + for index in 1..=50 { + tokio::time::advance(Duration::from_millis(20)).await; + live.track + .write(raw_frame(base + index * 20_000, b"backlog", false)) + .unwrap(); + } + // Settle the final zero-delay slot while the publication stays live. + live.track.write(raw_frame(base + 1_040_000, b"tail", false)).unwrap(); + // Keep the sink stalled until every backlog frame has reached its deadline. + tokio::time::advance(delay).await; + let mut frames = 0; + while frames < 50 { + let frame = tokio::time::timeout(DRAIN, export.next()) + .await + .unwrap_or_else(|_| { + panic!( + "{delay:?}: {frames}/50 frames released, {} buffered, {} dropped", + export.buffered(), + export.dropped() + ) + }) + .unwrap() + .unwrap(); + frames += frame.payload.windows(7).filter(|part| *part == b"backlog").count(); + assert!( + export.buffered() <= 1, + "{delay:?}: {} frames buffered", + export.buffered() + ); + } + assert_eq!(frames, 50); + assert_eq!(export.dropped(), 0, "the sink's stall does not make arrived media late"); + } +} diff --git a/rs/moq-mux/src/container/ts/release.rs b/rs/moq-mux/src/container/ts/release.rs index 4b9146a648d..e570e342c3d 100644 --- a/rs/moq-mux/src/container/ts/release.rs +++ b/rs/moq-mux/src/container/ts/release.rs @@ -1,6 +1,7 @@ //! Writes a [`Passthrough`](super::Passthrough) track back out as the multiplex it carries. -use std::task::Poll; +use std::sync::{Arc, Mutex}; +use std::task::{Poll, Wake, Waker}; use std::time::Duration; use web_async::time::Instant; @@ -9,6 +10,77 @@ use crate::catalog::{CatalogFormat, Stream}; use crate::container::{ExportSource, Frame}; use crate::jitter::{self, Arrival, Push}; +/// Availability observed even while a sink leaves its source unpolled. +struct Readable { + state: Mutex, +} + +struct Availability { + empty: Instant, + first: Option, + polling: bool, + during: Option, + // Weak registrations keep observing the source without keeping its caller alive. + waiters: kio::WaiterList, +} + +impl Readable { + fn new() -> Self { + Self { + state: Mutex::new(Availability { + empty: Instant::now(), + first: None, + polling: false, + during: None, + waiters: kio::WaiterList::new(), + }), + } + } + + fn begin(&self, waiter: &kio::Waiter) { + let mut state = self.state.lock().unwrap(); + debug_assert!(!state.polling); + state.polling = true; + state.during = None; + waiter.register(&mut state.waiters); + } + + fn end(&self, pending: bool) { + let mut state = self.state.lock().unwrap(); + state.polling = false; + if pending { + // A notification racing the empty read belongs to the next batch. + state.first = state.during.take(); + state.empty = Instant::now(); + } + state.during = None; + } + + fn arrived(&self) -> Instant { + let state = self.state.lock().unwrap(); + state.first.unwrap_or(state.empty) + } +} + +impl Wake for Readable { + fn wake(self: Arc) { + self.wake_by_ref(); + } + + fn wake_by_ref(self: &Arc) { + let mut waiters = { + let mut state = self.state.lock().unwrap(); + let now = Instant::now(); + state.first.get_or_insert(now); + if state.polling { + state.during.get_or_insert(now); + } + state.waiters.take() + }; + waiters.wake(); + } +} + /// Writes the multiplex a broadcast's [`m2ts`](hang::catalog::M2ts) track carries back out /// byte-identical, each object a fixed delay after its PCR time, like an SRT receiver. /// @@ -26,6 +98,8 @@ pub struct Release { catalog: Option>, /// The `m2ts` track, once a catalog names it. track: Option<(String, ExportSource)>, + readable: Arc, + input: kio::Waiter, finished: bool, /// An object has gone out. released: bool, @@ -45,10 +119,14 @@ impl Release { ); } let catalog = source.catalog(catalog_format).await?; + let readable = Arc::new(Readable::new()); + let input = kio::Waiter::new(Waker::from(readable.clone())); let mut release = Self { source, catalog: Some(catalog), track: None, + readable, + input, finished: false, released: false, delay: Duration::ZERO, @@ -101,6 +179,12 @@ impl Release { self.jitter.out_of_tolerance() } + /// How many objects are waiting in the jitter buffer. + #[cfg(test)] + pub(super) fn buffered(&self) -> usize { + self.jitter.len() + } + /// The next object, at its time: whole TS packets, verbatim, stamped with the PCR time of /// its first byte. Returns `None` once the track, or a catalog that never named one, ends. pub async fn next(&mut self) -> crate::Result> { @@ -120,7 +204,13 @@ impl Release { && let Some((name, track)) = self.track.as_mut() { loop { - let frame = match track.poll_read(waiter) { + if self.jitter.full(&()) { + break; + } + self.readable.begin(waiter); + let polled = track.poll_read(&self.input); + self.readable.end(polled.is_pending()); + let frame = match polled { Poll::Ready(Ok(Some(frame))) => frame, Poll::Ready(Ok(None)) => { self.finished = true; @@ -129,11 +219,11 @@ impl Release { Poll::Ready(Err(err)) => return Poll::Ready(Err(err)), Poll::Pending => break, }; - // The track wakes the release as each object lands, so the read times its arrival. - // The last empty poll would let one landing past its deadline out late instead. + // A sink can leave arrived objects unread. The first notification after + // an empty read distinguishes that backlog from a late network burst. let read = Instant::now(); let arrival = Arrival { - arrived: read, + arrived: self.readable.arrived().min(read), read, decode: frame.timestamp, restart: track.markers(), @@ -191,3 +281,50 @@ impl Release { Ok(()) } } + +#[cfg(test)] +mod tests { + use super::*; + + #[tokio::test(start_paused = true)] + async fn a_notification_during_an_empty_read_is_kept() { + let readable = Arc::new(Readable::new()); + let input = kio::Waiter::new(Waker::from(readable.clone())); + let caller = kio::Waiter::noop(); + let start = Instant::now(); + readable.begin(&caller); + tokio::time::advance(Duration::from_millis(20)).await; + input.waker().wake_by_ref(); + tokio::time::advance(Duration::from_millis(20)).await; + readable.end(true); + assert_eq!(readable.arrived(), start + Duration::from_millis(20)); + readable.begin(&caller); + readable.end(true); + assert_eq!(readable.arrived(), start + Duration::from_millis(40)); + } + + #[tokio::test(start_paused = true)] + async fn observing_a_stalled_sink_keeps_no_caller_alive() { + use std::sync::atomic::{AtomicUsize, Ordering}; + struct Caller(AtomicUsize); + impl Wake for Caller { + fn wake(self: Arc) { + self.0.fetch_add(1, Ordering::Relaxed); + } + } + let readable = Arc::new(Readable::new()); + let input = kio::Waiter::new(Waker::from(readable.clone())); + let wakes = Arc::new(Caller(AtomicUsize::new(0))); + let caller = kio::Waiter::new(Waker::from(wakes.clone())); + readable.begin(&caller); + readable.end(true); + drop(caller); + assert_eq!(Arc::strong_count(&wakes), 1); + tokio::time::advance(Duration::from_millis(20)).await; + let arrived = Instant::now(); + input.waker().wake_by_ref(); + tokio::time::advance(Duration::from_secs(1)).await; + assert_eq!(readable.arrived(), arrived); + assert_eq!(wakes.0.load(Ordering::Relaxed), 0); + } +} diff --git a/rs/moq-mux/src/container/ts/release_test.rs b/rs/moq-mux/src/container/ts/release_test.rs index ba6073ac4af..4e99f00d9f5 100644 --- a/rs/moq-mux/src/container/ts/release_test.rs +++ b/rs/moq-mux/src/container/ts/release_test.rs @@ -351,3 +351,54 @@ async fn an_msf_catalog_is_refused() { }; assert!(err.to_string().contains("MSF"), "{err}"); } + +/// Objects received while a sink stalls stay in the source and retain their arrival bound. +#[tokio::test(start_paused = true)] +async fn a_backlog_stays_in_the_source_until_due() { + let mut objects = import(KYRION).await.objects; + // Keep the capture in one retained group: joining newer groups is a separate + // live-edge policy, while this regression bounds an unread group itself. + for object in &mut objects { + object.group = 0; + } + let origin = objects[0].micros; + for delay in [Duration::ZERO, Duration::from_millis(100)] { + let republished = republish(objects.clone(), move |_, object| { + Duration::from_micros(object.micros - origin) + }); + let source = crate::source::announced(&republished.consumer).await; + let mut release = Release::new(source, CatalogFormat::Hang) + .await + .unwrap() + .with_delay(delay); + let first = release.next().await.unwrap().unwrap(); + let first = objects + .iter() + .position(|object| object.payload == first.payload) + .unwrap(); + let acquired = release.buffered(); + + // The publisher keeps its capture pace while the sink stops polling. Sleeping + // on the paused clock lets each publication wake at its own scheduled instant. + tokio::time::sleep(RECORDING).await; + for (index, object) in objects.iter().enumerate().skip(first + 1) { + let output = tokio::time::timeout(STALL, release.next()) + .await + .expect("every arrived object is released") + .unwrap() + .unwrap(); + assert!(output.payload == object.payload, "{delay:?}: object {index}"); + assert!( + release.buffered() <= acquired.max(1), + "{delay:?}: {} objects buffered after acquiring with {acquired}", + release.buffered() + ); + } + assert_eq!(release.buffered(), 0); + assert_eq!( + release.dropped(), + 0, + "the sink's stall does not make arrived objects late" + ); + } +} From 6b5a90984f89059e2d3af6dad430f4009cb8c4de Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Wed, 14 Oct 2026 17:46:32 -0700 Subject: [PATCH 3/3] fix(ts): park the passthrough source waiter between reads A waiter kept for the whole release records only eight lists, so group turnover let each later read stack another registration on a quiet future group. Holding it in a kio::Park retires an overflowed waiter, as every other long-lived poll does. Co-Authored-By: Claude Opus 5.5 --- rs/moq-mux/src/container/ts/release.rs | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/rs/moq-mux/src/container/ts/release.rs b/rs/moq-mux/src/container/ts/release.rs index e570e342c3d..611b9360fdb 100644 --- a/rs/moq-mux/src/container/ts/release.rs +++ b/rs/moq-mux/src/container/ts/release.rs @@ -1,7 +1,7 @@ //! Writes a [`Passthrough`](super::Passthrough) track back out as the multiplex it carries. use std::sync::{Arc, Mutex}; -use std::task::{Poll, Wake, Waker}; +use std::task::{Context, Poll, Wake, Waker}; use std::time::Duration; use web_async::time::Instant; @@ -99,7 +99,10 @@ pub struct Release { /// The `m2ts` track, once a catalog names it. track: Option<(String, ExportSource)>, readable: Arc, - input: kio::Waiter, + /// Wakes `readable`, which forwards to the caller. + notify: Waker, + /// Keeps the source's registrations alive while a sink leaves it unpolled. + input: kio::Park, finished: bool, /// An object has gone out. released: bool, @@ -120,13 +123,13 @@ impl Release { } let catalog = source.catalog(catalog_format).await?; let readable = Arc::new(Readable::new()); - let input = kio::Waiter::new(Waker::from(readable.clone())); let mut release = Self { source, catalog: Some(catalog), track: None, + notify: Waker::from(readable.clone()), readable, - input, + input: kio::Park::default(), finished: false, released: false, delay: Duration::ZERO, @@ -208,7 +211,9 @@ impl Release { break; } self.readable.begin(waiter); - let polled = track.poll_read(&self.input); + // The park retires a waiter whose registrations overflowed its records. + let input = self.input.hold(&Context::from_waker(&self.notify)); + let polled = track.poll_read(input); self.readable.end(polled.is_pending()); let frame = match polled { Poll::Ready(Ok(Some(frame))) => frame,