Blocking while popping

[rocket-matt]

Is there a better way to block until you have something to pop other than:

while input.is_empty() {}
let x = input.pop().unwrap();

?

[mgeier]

If you expect to be waiting for more than a few hundred nanoseconds, it's probably better to use a queue that has a proper blocking API? Maybe crossbeam::channel?

If you are only waiting for a short time, you can use rtrb, but depending on your application, you might want to add something like spin_loop() or some more fancy way to avoid maxing out the CPU. But other than that, I think your code is fine.

Another, not necessarily better way to do it:

let x = loop {
    if let Ok(item) = input.pop() {
        break item;
    }
    // relax a while
};

And yet another, but this time definitely worse way of doing it:

fn crazy(input: &mut rtrb::Consumer<i32>) -> i32 {
    input.pop().unwrap_or_else(|_| {
        // relax a while
        crazy(input)
    })
}
let x = crazy(&mut input);

Apart from being crazy, this will also quickly lead to a stack overflow.
I was just curious if that would work.

[gootorov]

In case anyone finds this useful, here's my approach:

let backoff = crossbeam_utils::Backoff::new();
loop {
    match consumer.pop() {
        Ok(item) => {
            backoff.reset();

            // do stuff with `item`
            // ...
        }
        Err(rtrb::PopError::Empty) => {
            if backoff.is_completed() {
                thread::sleep(Duration::from_micros(/* your desirable duration */));
            } else {
                backoff.snooze();
            }
        }
    }
}

This still keeps Producer::push very fast, while potentially trading off some latency on the consumer side.
As a bonus - if you replace thread::sleep with tokio::time::sleep/tokio_timerfd::sleep (or similar), then you can have a producer in sync code, and a consumer in async code.