wait-free spsc linked-list queue with individually reusable nodes

Related tags

llq
Overview

llq

Cargo Documentation

A wait-free single-producer single-consumer linked-list queue with individually reusable nodes.

Queue operations do not block or allocate memory. Individual nodes are allocated and managed separately, and can be reused on multiple queues.

Examples

Using a queue to send values between threads:

use llq::{Node, Queue};

let (mut producer, mut consumer) = Queue::<usize>::new().split();

producer.push(Node::new(0));
producer.push(Node::new(1));
producer.push(Node::new(2));

std::thread::spawn(move || {
    assert_eq!(*consumer.pop().unwrap(), 0);
    assert_eq!(*consumer.pop().unwrap(), 1);
    assert_eq!(*consumer.pop().unwrap(), 2);
    assert!(consumer.pop().is_none());
}).join().unwrap();

Reusing a node between multiple queues:

use llq::{Node, Queue};

let (mut producer1, mut consumer1) = Queue::<usize>::new().split();
let (mut producer2, mut consumer2) = Queue::<usize>::new().split();

let node = Node::new(3);
producer1.push(node);
let node = consumer1.pop().unwrap();
producer2.push(node);
let node = consumer2.pop().unwrap();

assert_eq!(*node, 3);

License

llq is distributed under the terms of both the MIT license and the Apache license, version 2.0. Contributions are accepted under the same terms.

Releases(v0.1.1)
Owner
glowcoil
glowcoil
A priority queue for Rust with efficient change function.

PriorityQueue This crate implements a Priority Queue with a function to change the priority of an object. Priority and items are stored in an IndexMap

null 73 Jun 12, 2021
Rust Persistent Data Structures

Rust Persistent Data Structures Rust Persistent Data Structures provides fully persistent data structures with structural sharing. Setup To use rpds a

Diogo Sousa 643 Jun 13, 2021
A proof of concept implementation of cyclic data structures in stable, safe, Rust.

A proof of concept implementation of cyclic data structures in stable, safe, Rust. This demonstrates the combined power of the static-rc crate and the

null 80 Jun 14, 2021
Doubly-Linked List Implementation in Rust

Doubly-Linked List Implementation in Rust Purely for educational and recreational purposes. For real world production please use std::collections::Lin

Tsoding 3 May 3, 2021
A number of collections, such as linked-lists, binary-trees, or B-Trees are most easily implemented with aliasing pointers.

StaticRc is a safe reference-counted pointer, similar to Rc or Arc, though performing its reference-counting at compile-time rather than run-time, and

null 162 Jun 15, 2021
RiteLinked - LinkedHashMap & LinkedHashSet in Rust

RiteLinked -- HashMap-like containers that hold their key-value pairs in a user controllable order RiteLinked provides more up to date versions of Lin

Rite Database 32 May 27, 2021
Parameterized routing for generic resources in Rust

Usher Usher provides an easy way to construct parameterized routing trees in Rust. The nodes of these trees is naturally generic, allowing Usher to le

Isaac Whitfield 31 Feb 25, 2021
Ternary search tree collection in rust

tst Ternary search tree collection in rust with similar API to std::collections as it possible. Ternary search tree is a type of trie (sometimes calle

Alexey Pervushin 15 Dec 5, 2020
Extra iterator adaptors, iterator methods, free functions, and macros.

Itertools Extra iterator adaptors, functions and macros. Please read the API documentation here How to use with cargo: [dependencies] itertools = "0.1

null 1.3k Jun 14, 2021