pub struct Injector<T> { /* private fields */ }
Expand description

An injector queue.

This is a FIFO queue that can be shared among multiple threads. Task schedulers typically have a single injector queue, which is the entry point for new tasks.

Examples

use crossbeam_deque::{Injector, Steal};

let q = Injector::new();
q.push(1);
q.push(2);

assert_eq!(q.steal(), Steal::Success(1));
assert_eq!(q.steal(), Steal::Success(2));
assert_eq!(q.steal(), Steal::Empty);

Implementations§

source§

impl<T> Injector<T>

source

pub fn new() -> Injector<T>

Creates a new injector queue.

Examples
use crossbeam_deque::Injector;

let q = Injector::<i32>::new();
source

pub fn push(&self, task: T)

Pushes a task into the queue.

Examples
use crossbeam_deque::Injector;

let w = Injector::new();
w.push(1);
w.push(2);
source

pub fn steal(&self) -> Steal<T>

Steals a task from the queue.

Examples
use crossbeam_deque::{Injector, Steal};

let q = Injector::new();
q.push(1);
q.push(2);

assert_eq!(q.steal(), Steal::Success(1));
assert_eq!(q.steal(), Steal::Success(2));
assert_eq!(q.steal(), Steal::Empty);
source

pub fn steal_batch(&self, dest: &Worker<T>) -> Steal<()>

Steals a batch of tasks and pushes them into a worker.

How many tasks exactly will be stolen is not specified. That said, this method will try to steal around half of the tasks in the queue, but also not more than some constant limit.

Examples
use crossbeam_deque::{Injector, Worker};

let q = Injector::new();
q.push(1);
q.push(2);
q.push(3);
q.push(4);

let w = Worker::new_fifo();
let _ = q.steal_batch(&w);
assert_eq!(w.pop(), Some(1));
assert_eq!(w.pop(), Some(2));
source

pub fn steal_batch_with_limit( &self, dest: &Worker<T>, limit: usize ) -> Steal<()>

Steals no more than of tasks and pushes them into a worker.

How many tasks exactly will be stolen is not specified. That said, this method will try to steal around half of the tasks in the queue, but also not more than some constant limit.

Examples
use crossbeam_deque::{Injector, Worker};

let q = Injector::new();
q.push(1);
q.push(2);
q.push(3);
q.push(4);
q.push(5);
q.push(6);

let w = Worker::new_fifo();
let _ = q.steal_batch_with_limit(&w, 2);
assert_eq!(w.pop(), Some(1));
assert_eq!(w.pop(), Some(2));
assert_eq!(w.pop(), None);

q.push(7);
q.push(8);
// Setting a large limit does not guarantee that all elements will be popped. In this case,
// half of the elements are currently popped, but the number of popped elements is considered
// an implementation detail that may be changed in the future.
let _ = q.steal_batch_with_limit(&w, std::usize::MAX);
assert_eq!(w.len(), 3);
source

pub fn steal_batch_and_pop(&self, dest: &Worker<T>) -> Steal<T>

Steals a batch of tasks, pushes them into a worker, and pops a task from that worker.

How many tasks exactly will be stolen is not specified. That said, this method will try to steal around half of the tasks in the queue, but also not more than some constant limit.

Examples
use crossbeam_deque::{Injector, Steal, Worker};

let q = Injector::new();
q.push(1);
q.push(2);
q.push(3);
q.push(4);

let w = Worker::new_fifo();
assert_eq!(q.steal_batch_and_pop(&w), Steal::Success(1));
assert_eq!(w.pop(), Some(2));
source

pub fn steal_batch_with_limit_and_pop( &self, dest: &Worker<T>, limit: usize ) -> Steal<T>

Steals no more than limit of tasks, pushes them into a worker, and pops a task from that worker.

How many tasks exactly will be stolen is not specified. That said, this method will try to steal around half of the tasks in the queue, but also not more than the given limit.

Examples
use crossbeam_deque::{Injector, Steal, Worker};

let q = Injector::new();
q.push(1);
q.push(2);
q.push(3);
q.push(4);
q.push(5);
q.push(6);

let w = Worker::new_fifo();
assert_eq!(q.steal_batch_with_limit_and_pop(&w, 2), Steal::Success(1));
assert_eq!(w.pop(), Some(2));
assert_eq!(w.pop(), None);

q.push(7);
// Setting a large limit does not guarantee that all elements will be popped. In this case,
// half of the elements are currently popped, but the number of popped elements is considered
// an implementation detail that may be changed in the future.
assert_eq!(q.steal_batch_with_limit_and_pop(&w, std::usize::MAX), Steal::Success(3));
assert_eq!(w.pop(), Some(4));
assert_eq!(w.pop(), Some(5));
assert_eq!(w.pop(), None);
source

pub fn is_empty(&self) -> bool

Returns true if the queue is empty.

Examples
use crossbeam_deque::Injector;

let q = Injector::new();

assert!(q.is_empty());
q.push(1);
assert!(!q.is_empty());
source

pub fn len(&self) -> usize

Returns the number of tasks in the queue.

Examples
use crossbeam_deque::Injector;

let q = Injector::new();

assert_eq!(q.len(), 0);
q.push(1);
assert_eq!(q.len(), 1);
q.push(1);
assert_eq!(q.len(), 2);

Trait Implementations§

source§

impl<T> Debug for Injector<T>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl<T> Default for Injector<T>

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl<T> Drop for Injector<T>

source§

fn drop(&mut self)

Executes the destructor for this type. Read more
source§

impl<T: Send> Send for Injector<T>

source§

impl<T: Send> Sync for Injector<T>

Auto Trait Implementations§

§

impl<T> RefUnwindSafe for Injector<T>
where T: RefUnwindSafe,

§

impl<T> Unpin for Injector<T>
where T: Unpin,

§

impl<T> !UnwindSafe for Injector<T>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> Pointable for T

source§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.