I wrote a demo with the jiffy mpsc module on Win10. Mostly it wen well but I came across once with panic info:

thread '' panicked at 'called Option::unwrap() on a None value', C:\Users\testuser.cargo\registry\src\mirrors.ustc.edu.cn-15f9db60536bad60\nolock-0.4.0\src\queues\mpsc\jiffy\node.rs:93:25
note: run with RUST_BACKTRACE=1 environment variable to display a backtrace

I read the function comments and found that the unwrap() function is meant to be safe. Would there be any bug in it?

My test code is below:

use std::thread;
use std::time::{Duration, Instant};
use core_affinity::{CoreId, get_core_ids};
use polars::prelude::{DataFrame, NamedFromOwned, Series};

fn main() {
    loop {
        let (mut receiver, mut sender) = nolock::queues::mpsc::jiffy::queue::<Instant>();
        let times = 10000;
        let times_clone = times.clone();

        let receiver = thread::spawn(move || {
            core_affinity::set_for_current(CoreId { id: 3 });
            let mut num = 0;
            let mut sum_latency = 0.0;
            let mut latencies = vec![];
            for idx in 0..times_clone {
                if let Some(info) = receiver.dequeue() {
                    let a = info.elapsed().as_secs_f64();
                    latencies.push(a);
                }
            }
            let series = Series::from_vec("", latencies);
            let df = DataFrame::new(vec![series]).unwrap();
            println!("{:?}", df.describe(None));
        });

        thread::spawn(move || {
            core_affinity::set_for_current(CoreId { id: 4 });
            for idx in 0..times {
                thread::sleep(Duration::from_millis(1));
                let start = Instant::now();
                sender.enqueue(start);
            }
        });
        receiver.join();
    }
}

Idea

Using Const-Generics to specify the Size of bounded Queues.

Benefits

This would allow us to use Arrays instead of Vecs, which is good as well as encoding the Size of the Queue somewhere else. The Fact that we would use Arrays with a known size might also allow the compiler to remove more bounds checks but that has not been tested.

Problems

The Fact that the size of the Queues would be encoded in the Type itself, means that callers must specify the Size of the Queue as well or also have a const generic on them for the size. This could very quickly infect a lot of the Code-Base if they are used very frequently or in key places.

Alternative

Use const generics for internal Queues that are sometimes used as Part of building other (often unbounded) Queues, this could still give a nice performance improvement in some cases (more testing required).