# looqueue-rs

A pure-rust, fully safe implementation of the lock-free FIFO queue algorithm described in [1].
The paper describes the algorithm for a multi-producer, multi-consumer queue with a custom memory reclamation mechanism and this crate exports an implementation of that algorithm in the `mpmc` module as well as an adaptation for single consumers in the `mpsc` module.

[1] _O. Giersch and J. Nolte, "Fast and Portable Concurrent FIFO Queues With Deterministic Memory Reclamation", in IEEE Transactions on Parallel and Distributed Systems, vol. 33, no. 3, pp. 604-616, 1 March 2022, doi: 10.1109/TPDS.2021.3097901_

## Usage

Add the following to your `Cargo.toml`

```toml
[dependencies]
loo = "0.1.0"
```

## Example

The API of this crate is similar to that of `std::mpsc`.
Creating new queue instances is achieved by calling either `mpmp::queue()` or `mpsc::queue()`, which return reference-counted `(producer, consumer)` handle tuples.
These handles can be cloned (with the exception of `mpsc::Consumer`) and send to threads as required.

```rust
use std::thread;

use loo::mpmc;

let (tx, rx) = mpmc::queue();

let handle = thread::spawn(move || {
    tx.push_back(1);
    tx.push_back(2);
    tx.push_back(3);
});

handle.join().unwrap();

assert_eq!(rx.pop_front(), Some(1));
assert_eq!(rx.pop_front(), Some(2));
assert_eq!(rx.pop_front(), Some(3));
assert_eq!(rx.pop_front(), None);
```

## License

`loo` is distributed under the terms of both the MIT license and the
Apache License (Version 2.0).

See [LICENSE-APACHE](LICENSE-APACHE) and [LICENSE-MIT](LICENSE-MIT) for details.