Concurrency

Experimental lock-free structures in Rust. Implemented Atomic pointer with high 16-bits as tag. Compatible in API with those in crossbeam_epoch. Lock-

This program exports useful APIs for Wayland desktop integration. Implemented: Active window title, app_id and on which output (monitor) Close active

ClockBound Summary: ClockBound allows you to generate and compare bounded timestamps that include accumulated error as reported from the local chronyd

with_lock Deadlock freedom Docs Example Say you have this code: use std::sync::Mutex; fn main() { let a = Mutex::new(2); let b = Mutex::new(3

cooptex cooptex provides deadlock-free Mutexes. The [CoopMutex::lock] method wraps the [std::sync::Mutex] return value with a Result that will request

macel Multi-Architecture Code Emission Library (macel) is a library which implements a low-level intermediate representation meant to expose on machin

gethostname.rs gethostname() for all platforms. use gethostname::gethostname; println!("Hostname: {:?}", gethostname()); Prior art hostname also prov

niceware My blog post: Porting Niceware to Rust A Rust port of niceware. Sections of this README have been copied from the original project. This libr

Real-Time Ring Buffer Ripped off of https://github.com/crossbeam-rs/crossbeam/pull/338. Isolated from the rest of crossbeam with git-filter-repo: git-

Concurrency extensions for Future

regmap some well-known and known-to-be-good computer architectures, such as the Microchip PIC product line, or many of the AVR processor family, were

Uncertain<T> Fast and correct computations with uncertain values. When working with values which are not exactly determined, such as sensor data, it c

Harmonious distributed data processing & analysis in Rust

Desync [dependencies] desync = "0.5" Desync is a library for Rust that provides a model of concurrency based around the idea of scheduling operations

Software Transactional Memory This library implements software transactional memory, often abbreviated with STM. It is designed closely to haskells ST

RingChannel Bounded MPMC channel abstraction on top of a ring buffer. Using RingChannel RingChannel is available on crates.io, simply add it as a depe

acto-rs library This library is a proof of concept, never run in any production setup and is fairly untested. Use at your own risk. You were warned. T

cht cht provides a lockfree hash table that supports fully concurrent lookups, insertions, modifications, and deletions. The table may also be concurr

rust-intmap Specialized hashmap for u64 keys Might be missing some functionality but you can remove, add, get and clear for now. Be aware that no effo

hopper - an unbounded mpsc with bounded memory Hopper provides a version of the rust standard mpsc that is unbounded but consumes a bounded amount of

rayon-logs Presentation rayon-logs is a logging extension for the rayon library. The library is available on crates.io. Logs are performance oriented

shred - Shared resource dispatcher This library allows to dispatch systems, which can have interdependencies, shared and exclusive resource access, in

arpx Automate and relate multiple processes. Description arpx runs PROCESSES as they are defined in PROFILES. PROFILES allow for the configuration of

Correctly implementing distributed algorithms such as the Paxos and Raft consensus protocols is notoriously difficult due to the presence of nondeterm

scoped-threadpool-rs A library for scoped and cached threadpools. For more details, see the docs. Getting Started scoped-threadpool-rs is available on

Pillars for Transactional Systems and Data Grids Lever is a library for writing transactional systems (esp. for in-memory data). It consists of variou

Sluice Asynchronous byte buffers and pipes for concurrent I/O programming. Documentation Check the documentation for up-to-date usage and examples. Li

Thread-ID Get a unique ID for the current thread in Rust. For diagnostics and debugging it can often be useful to get an ID that is different for ever

workerpool A worker threadpool used to execute a number of jobs atop stateful workers in parallel. It spawns a specified number of worker threads and

Implementation of a highly-scalable and ergonomic actor model for Rust Axiom Axiom brings a highly-scalable actor model to the Rust language based on

Session Types for Rust This is an implementation of session types for Rust. Using this library, you can implement bi-directional process communication

MultiQueue2: Fast MPMC Broadcast Queue MultiQueue2 is a fast bounded mpmc queue that supports broadcast/broadcast style operations MultiQueue was deve