Struct MpscFanIn 

pub struct MpscFanIn;

Builder + handle factory for an N-producer fan-in. After construction, move each MpscFanInProducer to its producing thread and the single MpscFanInConsumer to its consuming thread.

Implementations

impl MpscFanIn

pub fn with_capacity<T: Send + 'static>( producer_count: usize, per_ring_capacity: usize, ) -> (Vec<MpscFanInProducer<T>>, MpscFanInConsumer<T>)

Build producer_count SPSC rings of capacity per_ring_capacity and return matched producer / consumer handles.

Examples found in repository

examples/perf_features.rs (line 356)

        fn fanin(cap: usize) -> (Vec<MpscFanInProducer<u64>>, MpscFanInConsumer<u64>) {
            let (mut ps, c) = MpscFanIn::with_capacity::<u64>(PRODUCERS, cap);
            for p in ps.iter_mut() {
                for i in 0..cap / 2 {
                    let _ = p.try_push(i as u64);
                }
            }
            (ps, c)
        }

examples/sample_app.rs (line 187)

fn many_venue_fan_in() {
    use subms_spsc_ring_buffer::MpscFanIn;

    println!("\n== mpsc-fan-in: three venue feeds -> one strategy ==");
    let venues = 3usize;
    let per_venue = 20_000u64;
    let (mut producers, mut consumer) = MpscFanIn::with_capacity::<Tick>(venues, 256);

    let mut feeds = Vec::new();
    for venue in 0..venues {
        let mut p = producers.remove(0);
        feeds.push(thread::spawn(move || {
            for seq in 0..per_venue {
                let tick = Tick {
                    seq,
                    price_cents: 40_000 + venue as u32,
                };
                while p.try_push(tick).is_err() {
                    std::hint::spin_loop();
                }
            }
        }));
    }
    let total = per_venue * venues as u64;
    let strategy = thread::spawn(move || {
        let mut got = 0u64;
        while got < total {
            if consumer.try_pop().is_some() {
                got += 1;
            }
        }
        got
    });
    for f in feeds {
        f.join().unwrap();
    }
    let got = strategy.join().unwrap();
    println!("  {venues} feeds x {per_venue} ticks -> consumer drained {got}");
    assert_eq!(got, total);
}