use crate::Context;
use core::{convert::Infallible, num::NonZeroUsize, time::Duration};
use std::{
collections::HashSet,
sync::{
Arc, Mutex,
atomic::{AtomicUsize, Ordering},
},
thread,
time::Instant,
};
use super::{
super::{
Ack, AckReceiver, Answer, Delivery, Downstream, Effect, Inbox, Item, ItemId, Lifecycle,
LifecycleTap, NodeName, Observation, Outbox, Payload, RecordingTap, Settled, Sink, Station,
Taps, Thread, Wake, Wanted, ack_channel, channel,
feed::{FeedContext, FeedPolicy, Fixed, MemoryAware, Pressure, Steady},
lane::{block_on, block_until},
},
StreamLane, StreamOptions, Streamed,
};
use crate::{Async, AsyncStreamOperator, Feed, Fin, StreamOperator};
fn width(n: usize) -> NonZeroUsize {
NonZeroUsize::new(n).expect("the test's own width")
}
fn seats(in_flight: usize, feed: usize) -> StreamOptions {
StreamOptions::new()
.with_in_flight(width(in_flight))
.with_feed_policy(Box::new(Fixed::of(width(feed))))
}
fn delivery(values: &[u64]) -> (Delivery<u64>, AckReceiver<ItemId>) {
let (ack, answers) = ack_channel();
let items = values
.iter()
.enumerate()
.map(|(seq, &value)| Item::new(ItemId::new(seq as u64), value))
.collect();
(Delivery::new(Payload::Batch(items), ack), answers)
}
fn settled(answers: &AckReceiver<ItemId>, within: Duration) -> Option<Settled<ItemId>> {
let deadline = Instant::now() + within;
loop {
match answers.take() {
Answer::Settled(settled) => return Some(settled),
Answer::HungUp => return None,
Answer::Waiting if Instant::now() >= deadline => return None,
Answer::Waiting => thread::sleep(Duration::from_millis(2)),
}
}
}
fn drainer(inbox: Inbox<ItemId, u64>) -> (thread::JoinHandle<()>, Arc<Mutex<Vec<u64>>>) {
let taken = Arc::new(Mutex::new(Vec::new()));
let into = Arc::clone(&taken);
let handle = thread::spawn(move || {
while let Some(wake) = inbox.park(Duration::from_millis(20)) {
let Wake::Delivered(delivery) = wake else {
continue;
};
let (payload, ack) = delivery.into_parts();
let released: HashSet<ItemId> = payload.keys().copied().collect();
let values: Vec<u64> = payload.into_iter().map(|item| *item.value()).collect();
into.lock().expect("the collector").extend(values);
if let Some(ack) = ack {
ack.send(Ack::new(released, "consumer", Lifecycle::Persisted(())));
}
}
});
(handle, taken)
}
fn held_drainer(inbox: Inbox<ItemId, Held>) -> (thread::JoinHandle<()>, Arc<Mutex<Vec<u64>>>) {
let taken = Arc::new(Mutex::new(Vec::new()));
let into = Arc::clone(&taken);
let handle = thread::spawn(move || {
while let Some(wake) = inbox.park(Duration::from_millis(20)) {
let Wake::Delivered(delivery) = wake else {
continue;
};
let (payload, ack) = delivery.into_parts();
let released: HashSet<ItemId> = payload.keys().copied().collect();
let values: Vec<u64> = payload
.into_iter()
.map(|item| item.into_value().0)
.collect();
into.lock().expect("the collector").extend(values);
if let Some(ack) = ack {
ack.send(Ack::new(released, "consumer", Lifecycle::Persisted(())));
}
}
});
(handle, taken)
}
struct Passing;
impl StreamOperator for Passing {
type Error = Infallible;
type In = u64;
type Out = u64;
fn run(
&mut self,
_ctx: &Context,
delivery: Delivery<Self::In>,
feed: Feed<Self::Out>,
) -> Result<Fin, Self::Error> {
for item in delivery.into_items() {
if feed.give(item.into_value()).is_err() {
return Ok(Fin::Stopped);
}
}
Ok(Fin::Spent)
}
}
struct Fanning;
impl StreamOperator for Fanning {
type Error = Infallible;
type In = u64;
type Out = u64;
fn run(
&mut self,
_ctx: &Context,
delivery: Delivery<Self::In>,
feed: Feed<Self::Out>,
) -> Result<Fin, Self::Error> {
for item in delivery.into_items() {
for step in 0..item.into_value() {
if feed.give(step).is_err() {
return Ok(Fin::Stopped);
}
}
}
Ok(Fin::Spent)
}
}
struct Crowding {
live: Arc<AtomicUsize>,
peak: Arc<AtomicUsize>,
}
impl StreamOperator for Crowding {
type Error = Infallible;
type In = u64;
type Out = u64;
fn run(
&mut self,
_ctx: &Context,
delivery: Delivery<Self::In>,
feed: Feed<Self::Out>,
) -> Result<Fin, Self::Error> {
let now = self.live.fetch_add(1, Ordering::AcqRel) + 1;
self.peak.fetch_max(now, Ordering::AcqRel);
for item in delivery.into_items() {
let _ = feed.give(item.into_value());
}
thread::sleep(Duration::from_millis(60));
self.live.fetch_sub(1, Ordering::AcqRel);
Ok(Fin::Spent)
}
}
struct Remembering {
seen: u64,
}
impl StreamOperator for Remembering {
type Error = Infallible;
type In = u64;
type Out = u64;
fn run(
&mut self,
_ctx: &Context,
delivery: Delivery<Self::In>,
feed: Feed<Self::Out>,
) -> Result<Fin, Self::Error> {
for item in delivery.into_items() {
self.seen += item.into_value();
if feed.give(self.seen).is_err() {
return Ok(Fin::Stopped);
}
}
Ok(Fin::Spent)
}
}
#[derive(Debug, derive_more::Display)]
#[display("this delivery's read went bad half way through")]
struct WentBad;
impl core::error::Error for WentBad {}
struct DyingOnce {
died: bool,
}
impl StreamOperator for DyingOnce {
type Error = WentBad;
type In = u64;
type Out = u64;
fn run(
&mut self,
_ctx: &Context,
delivery: Delivery<Self::In>,
feed: Feed<Self::Out>,
) -> Result<Fin, Self::Error> {
for item in delivery.into_items() {
let _ = feed.give(item.into_value());
}
if self.died {
return Ok(Fin::Spent);
}
self.died = true;
Err(WentBad)
}
}
struct Endless;
impl StreamOperator for Endless {
type Error = Infallible;
type In = u64;
type Out = u64;
fn run(
&mut self,
ctx: &Context,
_delivery: Delivery<Self::In>,
feed: Feed<Self::Out>,
) -> Result<Fin, Self::Error> {
for step in 0..PREFIX {
if feed.give(step).is_err() {
return Ok(Fin::Stopped);
}
}
let mut next = PREFIX;
loop {
if ctx.shutdown().is_shutdown() {
return Ok(Fin::Stopped);
}
if feed.give(next).is_err() {
return Ok(Fin::Stopped);
}
next += 1;
}
}
}
const PREFIX: u64 = 3;
struct AwaitedFanning;
impl AsyncStreamOperator for AwaitedFanning {
type Error = Infallible;
type In = u64;
type Out = u64;
async fn run(
&mut self,
_ctx: &Context,
delivery: Delivery<Self::In>,
feed: Feed<Self::Out>,
) -> Result<Fin, Self::Error> {
for item in delivery.into_items() {
for step in 0..item.into_value() {
if feed.give_async(step).await.is_err() {
return Ok(Fin::Stopped);
}
}
}
Ok(Fin::Spent)
}
}
#[derive(Debug, Default)]
struct Watching {
seen: Mutex<Vec<(usize, usize)>>,
}
impl FeedPolicy for Watching {
fn capacity(&self, ctx: &FeedContext<'_>) -> NonZeroUsize {
self
.seen
.lock()
.expect("the recorder")
.push((ctx.in_flight(), ctx.width().get()));
width(4)
}
}
#[derive(Debug, PartialEq, Eq)]
struct Held(u64);
#[derive(Debug)]
enum Demuxed {
Left(Held),
Right(Held),
}
struct Demuxing;
impl StreamOperator for Demuxing {
type Error = Infallible;
type In = u64;
type Out = Demuxed;
fn run(
&mut self,
_ctx: &Context,
delivery: Delivery<Self::In>,
feed: Feed<Self::Out>,
) -> Result<Fin, Self::Error> {
for item in delivery.into_items() {
let value = item.into_value();
let product = if value.is_multiple_of(2) {
Demuxed::Left(Held(value))
} else {
Demuxed::Right(Held(value))
};
if feed.give(product).is_err() {
return Ok(Fin::Stopped);
}
}
Ok(Fin::Spent)
}
}
struct DemuxedDownstream {
left: Option<Outbox<ItemId, Held>>,
right: Option<Outbox<ItemId, Held>>,
}
impl Sink<Demuxed> for DemuxedDownstream {
fn arity(&self) -> usize {
2
}
fn connected(&self) -> Wanted {
let mut mask = Wanted::none();
if self.left.is_some() {
mask = mask.with(0);
}
if self.right.is_some() {
mask = mask.with(1);
}
mask
}
fn carries(&self, edge: usize, output: &Demuxed) -> bool {
match (edge, output) {
(0, Demuxed::Left(_)) => self.left.is_some(),
(1, Demuxed::Right(_)) => self.right.is_some(),
_ => false,
}
}
fn nudges(&self) -> Vec<Box<dyn crate::Rings>> {
let mut ringers: Vec<Box<dyn crate::Rings>> = Vec::new();
for edge in self.left.iter().chain(self.right.iter()) {
ringers.push(Box::new(edge.nudge()) as Box<dyn crate::Rings>);
}
ringers
}
async fn deliver(
&mut self,
edge: usize,
batch: Vec<Item<Demuxed>>,
ack: crate::AckSender<ItemId>,
) -> bool {
let (slot, want_left) = match edge {
0 => (self.left.as_ref(), true),
1 => (self.right.as_ref(), false),
_ => return false,
};
let Some(edge) = slot else {
return false;
};
let mut taken: Vec<Item<Held>> = Vec::with_capacity(batch.len());
for message in batch {
let (id, value) = message.into_parts();
match (value, want_left) {
(Demuxed::Left(held), true) | (Demuxed::Right(held), false) => {
taken.push(Item::new(id, held));
}
_ => return false,
}
}
edge
.deliver_async(Delivery::new(Payload::Batch(taken), ack))
.await
.is_ok()
}
}
struct Holding;
impl StreamOperator for Holding {
type Error = Infallible;
type In = u64;
type Out = Held;
fn run(
&mut self,
_ctx: &Context,
delivery: Delivery<Self::In>,
feed: Feed<Self::Out>,
) -> Result<Fin, Self::Error> {
for item in delivery.into_items() {
if feed.give(Held(item.into_value())).is_err() {
return Ok(Fin::Stopped);
}
}
Ok(Fin::Spent)
}
}
struct Overpromising {
edges: Vec<Outbox<ItemId, Held>>,
}
impl Sink<Held> for Overpromising {
fn arity(&self) -> usize {
self.edges.len()
}
fn nudges(&self) -> Vec<Box<dyn crate::Rings>> {
self
.edges
.iter()
.map(|edge| Box::new(edge.nudge()) as Box<dyn crate::Rings>)
.collect()
}
async fn deliver(
&mut self,
edge: usize,
batch: Vec<Item<Held>>,
ack: crate::AckSender<ItemId>,
) -> bool {
self.edges[edge]
.deliver_async(Delivery::new(Payload::Batch(batch), ack))
.await
.is_ok()
}
}
#[derive(Debug, Default)]
struct Refusals {
seen: Mutex<Vec<String>>,
}
impl LifecycleTap for Refusals {
fn observe(&self, _node: &NodeName, observation: &Observation) {
if let Some(skip) = observation.skip() {
self
.seen
.lock()
.expect("the refusals log")
.push(skip.reason().as_str().to_owned());
}
}
}
#[test]
fn one_delivery_is_streamed_through_the_lane_and_settles_at_its_ending() {
let (out, inbox) = channel::<ItemId, u64>(64);
let (collector, taken) = drainer(inbox);
let tap = Arc::new(RecordingTap::new());
let mut lane = StreamLane::new(
Context::new("fan"),
seats(1, 4),
[Fanning],
Downstream::from_iter([out]),
Thread::new(),
)
.with_effect(Effect::Pure)
.with_taps(Taps::new().with(Arc::clone(&tap) as Arc<dyn LifecycleTap>));
assert_eq!(lane.width(), 1);
let (delivery, answers) = delivery(&[5]);
block_on(lane.admit(delivery)).expect("the lane has a body");
assert_eq!(lane.in_flight(), 1);
block_on(lane.drain());
assert_eq!(lane.in_flight(), 0);
assert_eq!(lane.idle(), 1);
drop(lane);
collector.join().expect("the collector thread");
assert_eq!(*taken.lock().expect("the collector"), [0, 1, 2, 3, 4]);
let answer = settled(&answers, Duration::from_secs(2)).expect("the delivery was answered");
assert_eq!(answer.observation().station(), Some(Station::Processed));
let info = answer
.observation()
.info::<Streamed>()
.expect("the lane's own info type");
assert_eq!(info.given(), 5);
assert_eq!(info.projected(), 5);
assert_eq!(info.skipped(), 0);
assert_eq!(info.fin(), Some(Fin::Spent));
let spoken: Vec<_> = tap
.seen()
.into_iter()
.filter(|(node, _)| node == "fan")
.collect();
assert_eq!(spoken, [("fan".to_owned(), Station::Processed)]);
}
#[test]
fn in_flight_bounds_how_many_runs_are_live_at_once() {
let (out, inbox) = channel::<ItemId, u64>(256);
let (collector, _taken) = drainer(inbox);
let live = Arc::new(AtomicUsize::new(0));
let peak = Arc::new(AtomicUsize::new(0));
let bodies: Vec<Crowding> = (0..2)
.map(|_| Crowding {
live: Arc::clone(&live),
peak: Arc::clone(&peak),
})
.collect();
let mut lane = StreamLane::new(
Context::new("crowd"),
seats(2, 8),
bodies,
Downstream::from_iter([out]),
Thread::new(),
);
assert_eq!(lane.width(), 2);
block_on(async {
for value in 1..=4u64 {
let (delivery, _answers) = delivery(&[value]);
lane.admit(delivery).await.expect("the lane has bodies");
assert!(
lane.in_flight() <= 2,
"the admission bound is what the lane counts"
);
}
lane.drain().await;
});
drop(lane);
collector.join().expect("the collector thread");
assert_eq!(
peak.load(Ordering::Acquire),
2,
"two permits means exactly two runs live at the busiest moment"
);
assert_eq!(live.load(Ordering::Acquire), 0);
}
#[test]
fn a_warm_instance_keeps_what_it_learned_for_the_next_delivery() {
let (out, inbox) = channel::<ItemId, u64>(64);
let (collector, taken) = drainer(inbox);
let mut lane = StreamLane::new(
Context::new("remember"),
seats(1, 4),
[Remembering { seen: 0 }],
Downstream::from_iter([out]),
Thread::new(),
);
block_on(async {
for value in [10u64, 5, 1] {
let (delivery, _answers) = delivery(&[value]);
lane.admit(delivery).await.expect("the lane has a body");
lane.drain().await;
}
});
drop(lane);
collector.join().expect("the collector thread");
assert_eq!(*taken.lock().expect("the collector"), [10, 15, 16]);
}
#[test]
fn a_lane_whose_every_line_has_drained_answers_instead_of_parking() {
let (out, inbox) = channel::<ItemId, u64>(64);
let (collector, _taken) = drainer(inbox);
let mut lane = StreamLane::new(
Context::new("drained"),
seats(1, 4),
[Passing],
Downstream::from_iter([out]),
Thread::new(),
);
let (delivery, answers) = delivery(&[7]);
block_on(lane.admit(delivery)).expect("the lane has a body");
let deadline = Instant::now() + Duration::from_secs(5);
while !lane.live[0].yielded.is_disconnected() {
assert!(Instant::now() < deadline, "the body ends on its own");
thread::yield_now();
}
let taken: Vec<u64> = lane.live[0].yielded.drain().collect();
assert_eq!(taken, [7], "the body fed its one item before it ended");
assert!(
lane.live[0].drained(),
"the feed has hung up and what it held is taken — the state the window leaves behind"
);
let answered = block_until(lane.woken(), Some(Instant::now() + Duration::from_secs(5)));
let answered = answered.expect(
"a park over an arm set that is placeholders throughout has no waker in it and never returns",
);
assert_eq!(
answered, None,
"nothing more can arrive on any line, and the hang-up is what that state IS"
);
block_on(lane.drain());
assert_eq!(lane.in_flight(), 0);
assert_eq!(lane.idle(), 1, "the instance went back to the warm set");
drop(lane);
collector.join().expect("the collector thread");
let answer = settled(&answers, Duration::from_secs(2)).expect("the delivery was answered");
assert_eq!(
answer.observation().info::<Streamed>().map(Streamed::fin),
Some(Some(Fin::Spent)),
"the run's own ending reached the settlement"
);
}
#[test]
fn a_narrow_feed_carries_a_wide_stream() {
let (out, inbox) = channel::<ItemId, u64>(4);
let (collector, taken) = drainer(inbox);
let mut lane = StreamLane::new(
Context::new("narrow"),
seats(1, 1),
[Fanning],
Downstream::from_iter([out]),
Thread::new(),
);
let (delivery, answers) = delivery(&[2_000]);
block_on(async {
lane.admit(delivery).await.expect("the lane has a body");
lane.drain().await;
});
drop(lane);
collector.join().expect("the collector thread");
let taken = taken.lock().expect("the collector");
assert_eq!(taken.len(), 2_000);
assert!(
taken.iter().copied().eq(0..2_000),
"a bounded feed reorders nothing"
);
let answer = settled(&answers, Duration::from_secs(2)).expect("the delivery was answered");
let info = answer
.observation()
.info::<Streamed>()
.expect("the lane's own info type");
assert_eq!(info.given(), 2_000);
assert_eq!(info.projected(), 2_000);
}
#[test]
fn an_err_dead_letters_the_delivery_and_the_next_one_still_runs() {
let (out, inbox) = channel::<ItemId, u64>(64);
let (collector, taken) = drainer(inbox);
let tap = Arc::new(RecordingTap::new());
let mut lane = StreamLane::new(
Context::new("dying"),
seats(1, 8),
[DyingOnce { died: false }],
Downstream::from_iter([out]),
Thread::new(),
)
.with_taps(Taps::new().with(Arc::clone(&tap) as Arc<dyn LifecycleTap>));
let (first, failing) = delivery(&[1, 2, 3]);
let (second, surviving) = delivery(&[4, 5]);
block_on(async {
lane.admit(first).await.expect("the lane has a body");
lane.drain().await;
lane.admit(second).await.expect("the pool is not poisoned");
lane.drain().await;
});
drop(lane);
collector.join().expect("the collector thread");
assert_eq!(*taken.lock().expect("the collector"), [1, 2, 3, 4, 5]);
let answer = settled(&failing, Duration::from_secs(2)).expect("the failed delivery was answered");
assert_eq!(answer.observation().station(), Some(Station::Failed));
assert_eq!(
answer
.observation()
.failure()
.expect("the error rides the settlement")
.to_string(),
WentBad.to_string()
);
assert!(
answer.released().is_empty(),
"a failed delivery is released by nothing, so its sender can re-deliver it"
);
let answer = settled(&surviving, Duration::from_secs(2)).expect("the next delivery ran");
assert_eq!(answer.observation().station(), Some(Station::Processed));
let spoken: Vec<_> = tap
.seen()
.into_iter()
.filter(|(node, _)| node == "dying")
.map(|(_, station)| station)
.collect();
assert_eq!(spoken, [Station::Failed, Station::Processed]);
}
#[test]
fn a_stop_winds_a_run_down_and_the_ending_says_so() {
let (out, inbox) = channel::<ItemId, u64>(8);
let (collector, taken) = drainer(inbox);
let mut lane = StreamLane::new(
Context::new("endless"),
seats(1, 4),
[Endless],
Downstream::from_iter([out]),
Thread::new(),
);
let (delivery, answers) = delivery(&[1]);
block_on(lane.admit(delivery)).expect("the lane has a body");
lane.stop();
block_on(lane.drain());
drop(lane);
collector.join().expect("the collector thread");
assert!(
taken.lock().expect("the collector").len() >= PREFIX as usize,
"a wound-down run keeps what it had already given"
);
let answer = settled(&answers, Duration::from_secs(2)).expect("the delivery was answered");
assert_eq!(answer.observation().station(), Some(Station::Processed));
let info = answer
.observation()
.info::<Streamed>()
.expect("the lane's own info type");
assert_eq!(info.fin(), Some(Fin::Stopped));
}
#[test]
fn the_feed_policy_is_asked_at_every_spawn_and_shown_the_count() {
let (out, inbox) = channel::<ItemId, u64>(256);
let (collector, _taken) = drainer(inbox);
let watching = Arc::new(Watching::default());
let policy = Arc::clone(&watching);
let live = Arc::new(AtomicUsize::new(0));
let peak = Arc::new(AtomicUsize::new(0));
let bodies: Vec<Crowding> = (0..2)
.map(|_| Crowding {
live: Arc::clone(&live),
peak: Arc::clone(&peak),
})
.collect();
let mut lane = StreamLane::new(
Context::new("asked"),
StreamOptions::new()
.with_in_flight(width(2))
.with_feed_policy(Box::new(Recorded(policy))),
bodies,
Downstream::from_iter([out]),
Thread::new(),
);
block_on(async {
for value in 1..=3u64 {
let (delivery, _answers) = delivery(&[value]);
lane.admit(delivery).await.expect("the lane has bodies");
}
lane.drain().await;
});
drop(lane);
collector.join().expect("the collector thread");
let seen = watching.seen.lock().expect("the recorder").clone();
assert_eq!(seen.len(), 3, "once per delivery, at its spawn");
assert_eq!(seen[0], (0, 2));
assert_eq!(seen[1], (1, 2));
assert!(seen[2].0 <= 2, "never past the width: {:?}", seen[2]);
assert_eq!(seen[2].1, 2);
}
#[derive(Debug)]
struct Recorded(Arc<Watching>);
impl FeedPolicy for Recorded {
fn capacity(&self, ctx: &FeedContext<'_>) -> NonZeroUsize {
self.0.capacity(ctx)
}
}
#[test]
fn a_memory_aware_policy_cuts_to_the_floor_under_pressure_through_the_lane() {
for (pressure, expected) in [(Pressure::NONE, 32usize), (Pressure::CRITICAL, 2usize)] {
let (out, inbox) = channel::<ItemId, u64>(64);
let (collector, taken) = drainer(inbox);
let options = StreamOptions::new()
.with_feed_policy(Box::new(MemoryAware::between(width(2), width(32))))
.with_memory_probe(Box::new(Steady::at(pressure)));
let mut lane = StreamLane::new(
Context::new("aware"),
options,
[Fanning],
Downstream::from_iter([out]),
Thread::new(),
);
assert_eq!(
lane.options().feed_policy().capacity(&FeedContext::new(
0,
width(1),
lane.options().memory_probe()
)),
width(expected)
);
let (delivery, _answers) = delivery(&[40]);
block_on(async {
lane.admit(delivery).await.expect("the lane has a body");
lane.drain().await;
});
drop(lane);
collector.join().expect("the collector thread");
assert_eq!(taken.lock().expect("the collector").len(), 40);
}
}
#[test]
fn the_awaited_face_is_driven_by_the_same_lane() {
let (out, inbox) = channel::<ItemId, u64>(4);
let (collector, taken) = drainer(inbox);
let mut lane: StreamLane<AwaitedFanning, _, Thread, Async> = StreamLane::new(
Context::new("awaited"),
seats(1, 2),
[AwaitedFanning],
Downstream::from_iter([out]),
Thread::new(),
);
let (delivery, answers) = delivery(&[500]);
block_on(async {
lane.admit(delivery).await.expect("the lane has a body");
lane.drain().await;
});
drop(lane);
collector.join().expect("the collector thread");
let taken = taken.lock().expect("the collector");
assert_eq!(taken.len(), 500);
assert!(taken.iter().copied().eq(0..500));
let answer = settled(&answers, Duration::from_secs(2)).expect("the delivery was answered");
let info = answer
.observation()
.info::<Streamed>()
.expect("the lane's own info type");
assert_eq!(info.given(), 500);
assert_eq!(info.fin(), Some(Fin::Spent));
}
#[test]
fn a_lane_with_no_body_hands_the_delivery_back() {
let (out, inbox) = channel::<ItemId, u64>(8);
let (collector, _taken) = drainer(inbox);
let mut lane: StreamLane<Passing, _> = StreamLane::new(
Context::new("empty"),
seats(1, 4),
[],
Downstream::from_iter([out]),
Thread::new(),
);
assert_eq!(lane.width(), 0);
let (delivery, _answers) = delivery(&[1]);
assert!(
block_on(lane.admit(delivery)).is_err(),
"waiting cannot resolve a lane that has nothing to run with"
);
drop(lane);
collector.join().expect("the collector thread");
}
#[test]
fn an_item_no_edge_carries_is_counted_rather_than_announced() {
let mut lane = StreamLane::new(
Context::new("unwired"),
seats(1, 8),
[Fanning],
Downstream::<u64>::new(),
Thread::new(),
);
let (delivery, answers) = delivery(&[6]);
block_on(async {
lane.admit(delivery).await.expect("the lane has a body");
lane.drain().await;
});
let answer = settled(&answers, Duration::from_secs(2)).expect("the delivery was answered");
let info = answer
.observation()
.info::<Streamed>()
.expect("the lane's own info type");
assert_eq!(info.given(), 6);
assert_eq!(info.projected(), 0);
assert_eq!(info.skipped(), 6);
}
#[test]
fn the_seats_carry_the_shipped_defaults_and_the_rendering_hides_the_advisors() {
let options = StreamOptions::new();
assert_eq!(options.in_flight(), super::DEFAULT_IN_FLIGHT);
assert_eq!(
options
.feed_policy()
.capacity(&FeedContext::new(0, width(1), options.memory_probe())),
super::super::DEFAULT_FEED_DEPTH
);
let rendered = format!("{options:?}");
assert!(rendered.contains("in_flight"), "{rendered}");
assert!(!rendered.contains("Fixed"), "{rendered}");
}
#[test]
fn a_multi_product_lane_streams_a_payload_that_does_not_copy() {
let (left, left_inbox) = channel::<ItemId, Held>(64);
let (right, right_inbox) = channel::<ItemId, Held>(64);
let (left_taker, lefts) = held_drainer(left_inbox);
let (right_taker, rights) = held_drainer(right_inbox);
let mut lane = StreamLane::new(
Context::new("demux"),
seats(1, 4),
[Demuxing],
DemuxedDownstream {
left: Some(left),
right: Some(right),
},
Thread::new(),
)
.with_effect(Effect::Pure);
let (delivery, answers) = delivery(&[1, 2, 3, 4]);
block_on(lane.admit(delivery)).expect("the lane has a body");
block_on(lane.drain());
drop(lane);
left_taker.join().expect("the left collector");
right_taker.join().expect("the right collector");
assert_eq!(*lefts.lock().expect("the left collector"), [2, 4]);
assert_eq!(*rights.lock().expect("the right collector"), [1, 3]);
let answer = settled(&answers, Duration::from_secs(2)).expect("the delivery was answered");
let info = answer
.observation()
.info::<Streamed>()
.expect("the lane's own info type");
assert_eq!(info.given(), 4);
assert_eq!(info.projected(), 4);
assert_eq!(info.skipped(), 0);
}
#[test]
fn one_output_that_two_edges_carry_is_moved_into_the_last_and_copied_for_the_first() {
let (first, first_inbox) = channel::<ItemId, u64>(64);
let (second, second_inbox) = channel::<ItemId, u64>(64);
let (firsts, from_first) = drainer(first_inbox);
let (seconds, from_second) = drainer(second_inbox);
let mut lane = StreamLane::new(
Context::new("both"),
seats(1, 4),
[Passing],
Downstream::from_iter([first, second]),
Thread::new(),
)
.with_effect(Effect::Pure);
let (delivery, answers) = delivery(&[7, 8]);
block_on(lane.admit(delivery)).expect("the lane has a body");
block_on(lane.drain());
drop(lane);
firsts.join().expect("the first collector");
seconds.join().expect("the second collector");
assert_eq!(*from_first.lock().expect("the first collector"), [7, 8]);
assert_eq!(*from_second.lock().expect("the second collector"), [7, 8]);
let answer = settled(&answers, Duration::from_secs(2)).expect("the delivery was answered");
let info = answer
.observation()
.info::<Streamed>()
.expect("the lane's own info type");
assert_eq!(info.given(), 2);
assert_eq!(info.projected(), 2);
assert_eq!(info.skipped(), 0);
}
#[test]
fn a_second_seat_a_payload_cannot_fill_is_refused_by_name() {
let (first, first_inbox) = channel::<ItemId, Held>(64);
let (second, second_inbox) = channel::<ItemId, Held>(64);
let (firsts, from_first) = held_drainer(first_inbox);
let (seconds, from_second) = held_drainer(second_inbox);
let refusals = Arc::new(Refusals::default());
let mut lane = StreamLane::new(
Context::new("overpromised"),
seats(1, 4),
[Holding],
Overpromising {
edges: vec![first, second],
},
Thread::new(),
)
.with_effect(Effect::Pure)
.with_taps(Taps::new().with(Arc::clone(&refusals) as Arc<dyn LifecycleTap>));
let (delivery, answers) = delivery(&[11]);
block_on(lane.admit(delivery)).expect("the lane has a body");
block_on(lane.drain());
drop(lane);
firsts.join().expect("the first collector");
seconds.join().expect("the second collector");
assert_eq!(
*from_first.lock().expect("the first collector"),
[] as [u64; 0]
);
assert_eq!(*from_second.lock().expect("the second collector"), [11]);
assert_eq!(
*refusals.seen.lock().expect("the refusals log"),
[super::UNDIVIDABLE],
"announced once for the batch, under the label a tap matches"
);
let answer = settled(&answers, Duration::from_secs(2)).expect("the delivery was answered");
let info = answer
.observation()
.info::<Streamed>()
.expect("the lane's own info type");
assert_eq!(info.given(), 1);
assert_eq!(info.projected(), 1);
assert_eq!(info.skipped(), 0);
}
#[test]
#[ignore = "a measurement, not an assertion — see the module note"]
fn the_measured_knee_is_where_the_default_sits() {
const FAN: u64 = 200_000;
const ROUNDS: usize = 7;
const DEPTHS: [usize; 8] = [8, 32, 64, 128, 256, 512, 1_024, 2_048];
let mut best = [0.0f64; DEPTHS.len()];
for _ in 0..ROUNDS {
for (slot, depth) in DEPTHS.iter().enumerate() {
let (out, inbox) = channel::<ItemId, u64>(64);
let (collector, taken) = drainer(inbox);
let mut lane = StreamLane::new(
Context::new("knee"),
seats(1, *depth),
[Fanning],
Downstream::from_iter([out]),
Thread::new(),
);
let (delivery, _answers) = delivery(&[FAN]);
let started = Instant::now();
block_on(async {
lane.admit(delivery).await.expect("the lane has a body");
lane.drain().await;
});
let elapsed = started.elapsed();
drop(lane);
collector.join().expect("the collector thread");
assert_eq!(taken.lock().expect("the collector").len(), FAN as usize);
let rate = f64::from(u32::try_from(FAN).expect("the fan fits")) / elapsed.as_secs_f64();
best[slot] = best[slot].max(rate);
}
}
let table: Vec<(usize, f64)> = DEPTHS.iter().copied().zip(best).collect();
let floor = table[0].1;
println!("\nfeed depth | items/second | relative | step");
let mut previous = floor;
for (depth, rate) in &table {
println!(
"{depth:>10} | {rate:>12.0} | {:>7.2}x | {:+.1}%",
rate / floor,
(rate / previous - 1.0) * 100.0
);
previous = *rate;
}
}
#[test]
#[ignore = "a measurement, not an assertion — see the module note"]
fn what_a_movable_feed_bound_would_cost_per_give() {
const ITEMS: usize = 500_000;
const DEPTH: usize = 64;
const ROUNDS: usize = 7;
fn plain() -> Duration {
let (tx, rx) = flume::bounded::<u64>(DEPTH);
let started = Instant::now();
let taker = thread::spawn(move || while rx.recv().is_ok() {});
for item in 0..ITEMS as u64 {
tx.send(item).expect("the taker is there");
}
drop(tx);
taker.join().expect("the taker thread");
started.elapsed()
}
fn permitted() -> Duration {
let (tx, rx) = flume::unbounded::<u64>();
let (give_back, permits) = flume::bounded::<()>(DEPTH);
for _ in 0..DEPTH {
give_back.send(()).expect("the permit line has room");
}
let started = Instant::now();
let taker = thread::spawn(move || {
while rx.recv().is_ok() {
let _ = give_back.send(());
}
});
for item in 0..ITEMS as u64 {
permits.recv().expect("a permit comes back");
tx.send(item).expect("the taker is there");
}
drop(tx);
taker.join().expect("the taker thread");
started.elapsed()
}
let mut fastest_plain = Duration::MAX;
let mut fastest_permitted = Duration::MAX;
for _ in 0..ROUNDS {
fastest_plain = fastest_plain.min(plain());
fastest_permitted = fastest_permitted.min(permitted());
}
let cost = fastest_permitted.as_secs_f64() / fastest_plain.as_secs_f64() - 1.0;
println!("\nplain bounded channel : {fastest_plain:?}");
println!("semaphore-backed bound: {fastest_permitted:?}");
println!(
"cost of a movable bound on the plain path: {:+.1}%",
cost * 100.0
);
}