Struct rerun::external::re_chunk::external::crossbeam::deque::Stealer

pub struct Stealer<T> {
    inner: Arc<CachePadded<Inner<T>>>,
    flavor: Flavor,
}

A stealer handle of a worker queue.

Stealers can be shared among threads.

Task schedulers typically have a single worker queue per worker thread.

Examples

use crossbeam_deque::{Steal, Worker};

let w = Worker::new_lifo();
w.push(1);
w.push(2);

let s = w.stealer();
assert_eq!(s.steal(), Steal::Success(1));
assert_eq!(s.steal(), Steal::Success(2));
assert_eq!(s.steal(), Steal::Empty);

Fields

inner: Arc<CachePadded<Inner<T>>>

flavor: Flavor

Implementations

impl<T> Stealer<T>

pub fn is_empty(&self) -> bool

Returns true if the queue is empty.

use crossbeam_deque::Worker;

let w = Worker::new_lifo();
let s = w.stealer();

assert!(s.is_empty());
w.push(1);
assert!(!s.is_empty());

pub fn len(&self) -> usize

Returns the number of tasks in the deque.

use crossbeam_deque::Worker;

let w = Worker::new_lifo();
let s = w.stealer();

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

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

Steals a task from the queue.

Examples

use crossbeam_deque::{Steal, Worker};

let w = Worker::new_lifo();
w.push(1);
w.push(2);

let s = w.stealer();
assert_eq!(s.steal(), Steal::Success(1));
assert_eq!(s.steal(), Steal::Success(2));

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

Steals a batch of tasks and pushes them into another 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::Worker;

let w1 = Worker::new_fifo();
w1.push(1);
w1.push(2);
w1.push(3);
w1.push(4);

let s = w1.stealer();
let w2 = Worker::new_fifo();

let _ = s.steal_batch(&w2);
assert_eq!(w2.pop(), Some(1));
assert_eq!(w2.pop(), Some(2));

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

Steals no more than limit of tasks and pushes them into another 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::Worker;

let w1 = Worker::new_fifo();
w1.push(1);
w1.push(2);
w1.push(3);
w1.push(4);
w1.push(5);
w1.push(6);

let s = w1.stealer();
let w2 = Worker::new_fifo();

let _ = s.steal_batch_with_limit(&w2, 2);
assert_eq!(w2.pop(), Some(1));
assert_eq!(w2.pop(), Some(2));
assert_eq!(w2.pop(), None);

w1.push(7);
w1.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 _ = s.steal_batch_with_limit(&w2, std::usize::MAX);
assert_eq!(w2.len(), 3);

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

Steals a batch of tasks, pushes them into another 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::{Steal, Worker};

let w1 = Worker::new_fifo();
w1.push(1);
w1.push(2);
w1.push(3);
w1.push(4);

let s = w1.stealer();
let w2 = Worker::new_fifo();

assert_eq!(s.steal_batch_and_pop(&w2), Steal::Success(1));
assert_eq!(w2.pop(), Some(2));

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 another 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::{Steal, Worker};

let w1 = Worker::new_fifo();
w1.push(1);
w1.push(2);
w1.push(3);
w1.push(4);
w1.push(5);
w1.push(6);

let s = w1.stealer();
let w2 = Worker::new_fifo();

assert_eq!(s.steal_batch_with_limit_and_pop(&w2, 2), Steal::Success(1));
assert_eq!(w2.pop(), Some(2));
assert_eq!(w2.pop(), None);

w1.push(7);
w1.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.
assert_eq!(s.steal_batch_with_limit_and_pop(&w2, std::usize::MAX), Steal::Success(3));
assert_eq!(w2.pop(), Some(4));
assert_eq!(w2.pop(), Some(5));
assert_eq!(w2.pop(), None);

Trait Implementations

impl<T> Clone for Stealer<T>

fn clone(&self) -> Stealer<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Stealer<T>

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

Formats the value using the given formatter.

impl<T> Send for Stealer<T>

where T: Send,

impl<T> Sync for Stealer<T>

where T: Send,