crossync

crossync is a robust library providing blazingly fast concurrent data structures for Rust, designed specifically for multithreaded applications. It leverages atomic operations, sophisticated backoff strategies, and internal locking mechanisms to ensure efficient shared access, making it a valuable resource for developers working with concurrency.

Key Features

• Concurrent Collections: Libraries for shared state management including queues and message passing.
• Interior Mutability: A feature that allows for synchronized access, ensuring safe interaction with data.
• Reference-Counted Handles: Supports sharing containers without duplicating data, enhancing performance while maintaining data integrity.

Concurrent Data Structures

AtomicVec

AtomicVec<T> is a thread-safe collection allowing concurrent push and pop operations. It utilizes block-based allocation and atomic indices to manage resources efficiently, making it ideal for work queues and dynamic collections.

Features:

• Supports shared and exclusive locking for access and reset operations.
• Integrates automatic block recycling and free-list management.
• Facilitates conversion to a standard Vec<T> by consuming its elements.

Usage Example:

use std::thread;
use crossync::atomic::AtomicVec;

let h = AtomicVec::new();
h.push("hello");
let b = h.clone();
drop(h);

{
    let b = b.clone();
    let t = thread::spawn(move || {
        if let Some(v) = b.pop() {
            assert_eq!(v, "hello");
        }
    });
    t.join().unwrap();
}

assert!(b.pop().is_none());

AtomicHashMap

AtomicHashMap<K, V> is a concurrent hash map supporting safe insertion and retrieval of key-value pairs.

Features:

• Resizable storage to accommodate growing collections.

Usage Example:

use std::thread;
use crossync::atomic::AtomicHashMap;

let h = AtomicHashMap::new();
h.insert("c", "hello");
let b = h.clone();
drop(h);

{
    let b = b.clone();
    let t = thread::spawn(move || {
        if let Some(mut v) = b.get_mut("c") {
            *v = "world";
        }
    });
    t.join().unwrap();
}

assert_eq!(b.get("c").unwrap(), "world");

AtomicBuffer

AtomicBuffer<T> is a thread-safe ring buffer designed for concurrent producer-consumer scenarios with per-slot sequence numbers.

Usage Example:

use crossync::atomic::AtomicBuffer;
use std::thread;

let buffer = AtomicBuffer::with_capacity(2);

let producer = {
    let buffer = buffer.clone();
    thread::spawn(move || {
        buffer.push_box(Box::new(1)).unwrap();
        buffer.push_box(Box::new(2)).unwrap();
    })
};

let consumer = {
    let buffer = buffer.clone();
    thread::spawn(move || {
        let mut count = 1;
        while count <= 2 {
            if let Some(value) = buffer.pop_box() {
                assert_eq!(*value, count);
                count += 1;
            }
        }
    })
};

producer.join().unwrap();
consumer.join().unwrap();

Additional Structures

The library also includes:

• AtomicCell: A lock-assisted container for single value access with interior mutability.
• AtomicArray: A thread-safe array for concurrent reads and writes using atomic indices and locks.
• RwLock: A synchronization primitive supporting multiple readers or a single writer without lock poisoning.
• Barrier: Coordinates groups of threads, acting as a synchronization point until a specified number of arrivals are reached.

For further details on usage and implementation strategies, please refer to the README and additional documentation files.