Crate parcoll 

ParColl

This crate provides optimized collections which can be used in concurrent runtimes.

It provides optimized ring-based SPSC (const bounded or unbounded), SPMC (const bounded or unbounded), and const bounded MPMC queue.

All queues are lock-free (or lock-free with the proper generics), generalized and can be either be cache-padded or not.

use parcoll::{Consumer, Producer};

fn mpmc() {
    let (producer, consumer) = parcoll::mpmc::new_cache_padded_bounded::<_, 256>();
    let producer2 = producer.clone();
    let consumer2 = consumer.clone(); // You can clone the consumer

    producer.maybe_push(1).unwrap();
    producer.maybe_push(2).unwrap();

    let mut slice = [std::mem::MaybeUninit::uninit(); 3];
    let popped = consumer.pop_many(&mut slice);

    assert_eq!(popped, 2);
    assert_eq!(unsafe { slice[0].assume_init() }, 1);
    assert_eq!(unsafe { slice[1].assume_init() }, 2);
}

fn spsc_unbounded() {
    let (producer, consumer) = parcoll::spsc::new_cache_padded_unbounded();

    producer.maybe_push(1).unwrap();
    producer.maybe_push(2).unwrap();

    let mut slice = [std::mem::MaybeUninit::uninit(); 3];
    let popped = consumer.pop_many(&mut slice);

    assert_eq!(popped, 2);
    assert_eq!(unsafe { slice[0].assume_init() }, 1);
    assert_eq!(unsafe { slice[1].assume_init() }, 2);
}

fn spmc() {
    let (producer1, consumer1) = parcoll::spmc::new_bounded::<_, 256>();
    let (producer2, consumer2) = parcoll::spmc::new_bounded::<_, 256>();

    for i in 0..100 {
        producer1.maybe_push(i).unwrap();
    }

    consumer1.steal_into(&producer2);

    assert_eq!(producer2.len(), 50);
    assert_eq!(consumer1.len(), 50);
}

Re-exports

pub use orengine_utils;

Modules

buffer_version

mpmc

This module contains the implementation of the MPMC queue.

multi_consumer

This module provides the MultiConsumer, the MultiConsumerSpawner, the MultiLockFreeConsumerSpawner and the MultiLockFreeConsumer traits for multi-consumer queues.

multi_producer

This module provides the MultiProducer, the MultiProducerSpawner, the MultiLockFreeProducer and the MultiLockFreeProducerSpawner traits.

naive_rw_lock

This module provides NaiveRWLock and its guards.

number_types

single_consumer

This module provides the SingleConsumer, the SingleConsumerSpawner, the SingleLockFreeConsumerSpawner and the SingleLockFreeConsumer traits for single-consumer queues.

single_producer

spmc

This module provides implementations of single-producer multi-consumer queues.

spmc_producer

spsc

This module provides implementations of single-producer single-consumer queues.

sync_cell

This module provides the SyncCell and the LockFreeSyncCell traits.

Structs

LightArc

A light-weight reference-counted pointer to a value.

MutexVecQueue

A wrapper around LightArc<Mutex<VecQueue<T>>>. It can be used as a global queue.

VecQueue

A queue that uses a vector to store the elements.

Enums

LockFreePopErr

Represents the possible errors that can occur when lock-free popping a value from a queue.

LockFreePushErr

Represents the possible errors that can occur when lock-free pushing a value into a queue.

LockFreePushManyErr

Represents the possible errors that can occur when lock-free pushing many values into a queue.

Traits

BatchReceiver

A batch receiver of the multi-consumer queue. It is used to move half of the values from the queue to this receiver on overflow.

Consumer

A consumer of a queue.

LockFreeBatchReceiver

A lock-free batch receiver of the multi-consumer queue. It is used to move half of the values from the queue to this receiver on overflow.

LockFreeConsumer

A lock-free consumer of a queue.

LockFreeProducer

A lock-free producer of a queue.

Producer

A producer of a queue.