Struct BufferUnordered

pub struct BufferUnordered<S: Stream> { /* private fields */ }

Stream for the buffered_unordered method.

Examples

use futures::channel::oneshot;
use futures::stream::{self, StreamExt};
use futures_buffered::BufferedStreamExt;

let (send_one, recv_one) = oneshot::channel();
let (send_two, recv_two) = oneshot::channel();

let stream_of_futures = stream::iter(vec![recv_one, recv_two]);
let mut buffered = stream_of_futures.buffered_unordered(10);

send_two.send(2i32)?;
assert_eq!(buffered.next().await, Some(Ok(2i32)));

send_one.send(1i32)?;
assert_eq!(buffered.next().await, Some(Ok(1i32)));

assert_eq!(buffered.next().await, None);

Benchmarks

Speed

Running 65536 100us timers with 256 concurrent jobs in a single threaded tokio runtime:

futures::stream::BufferUnordered    time:   [420.33 ms 422.57 ms 424.83 ms]
futures_buffered::BufferUnordered   time:   [363.39 ms 365.59 ms 367.78 ms]

Memory usage

Running 512000 Ready<i32> futures with 256 concurrent jobs.

• count: the number of times alloc/dealloc was called
• alloc: the number of cumulative bytes allocated
• dealloc: the number of cumulative bytes deallocated

futures::stream::BufferUnordered
    count:    1024002
    alloc:    40960144 B
    dealloc:  40960000 B

futures_buffered::BufferUnordered
    count:    2
    alloc:    8264 B
    dealloc:  0 B

Trait Implementations

impl<St> Stream for BufferUnordered<St>

where St: Stream, St::Item: Future,

type Item = <<St as Stream>::Item as Future>::Output

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<'__pin, S: Stream> Unpin for BufferUnordered<S>

where __Origin<'__pin, S>: Unpin,