Displaying 1 to 20 from 26 results

libcds - A C++ library of Concurrent Data Structures

  •    C++

The Concurrent Data Structures (CDS) library is a collection of concurrent containers that don't require external (manual) synchronization for shared access, and safe memory reclamation (SMR) algorithms like Hazard Pointer and user-space RCU that is used as an epoch-based SMR. CDS is mostly header-only template library. Only SMR core implementation is segregated to .so/.dll file.

JCTools - Java Concurrency Tools for the JVM

  •    Java

Java Concurrency Tools for the JVM. This project aims to offer some concurrent data structures currently missing from the JDK.

tla-rust - writing correct lock-free and distributed stateful systems in Rust, assisted by TLA+

  •    TLA

Stable stateful systems through modeling, linear types and simulation. I like to use things that wake me up at 4am as rarely as possible. Unfortunately, infrastructure vendors don't focus on reliability. Even if a company gives reliability lip service, it's unlikely that they use techniques like modeling or simulation to create a rock-solid core. Let's just build an open-source distributed store that takes correctness seriously at the local storage, sharding, and distributed transactional layers.




hashmap - A Golang lock-free thread-safe HashMap optimized for fastest read access.

  •    Go

A Golang lock-free thread-safe HashMap optimized for fastest read access. The benchmarks were run with Golang 1.10.1 on MacOS.

capture-thread - Framework for loggers, tracers, and mockers in multithreaded C++ programs.

  •    C++

Framework for loggers, tracers, and mockers in multithreaded C++ programs.When developing C++ projects, instrumentation is frequently used to collect information from the system, inject information into the system, or both. The role of this information within the system rarely lines up with the actual structure of the project.

L4 - L4 (Lock-Free on Read) Hashtable is a C++ library that implements hash table with arbitray byte stream keys/values

  •    C++

L4 (Lock-Free on Read) Hashtable is a C++ library that provides a fixed-size hashtable, where keys and values are arbitrary bytes.L4 HashTable is optimized for lookup operations. It uses Epoch Queue (deterministic garbage collector) to achieve lock-free lookup operations.

bus - Efficient, lock-free, bounded Rust broadcast channel

  •    Rust

Bus provides a lock-free, bounded, single-producer, multi-consumer, broadcast channel. It uses a circular buffer and atomic instructions to implement a lock-free single-producer, multi-consumer channel. The interface is similar to that of the std::sync::mpsc channels, except that multiple consumers (readers of the channel) can be produced, whereas only a single sender can exist. Furthermore, in contrast to most multi-consumer FIFO queues, bus is broadcast; every send goes to every consumer.


rust-evmap - A lock-free, eventually consistent, concurrent multi-value map.

  •    Rust

A lock-free, eventually consistent, concurrent multi-value map. This map implementation allows reads and writes to execute entirely in parallel, with no implicit synchronization overhead. Reads never take locks on their critical path, and neither do writes assuming there is a single writer (multi-writer is possible using a Mutex), which significantly improves performance under contention.

SPSCQueue - A bounded single-producer single-consumer wait-free and lock-free queue written in C++11

  •    C++

A single producer single consumer wait-free and lock-free fixed size queue written in C++11. Create a SPSCqueue holding items of type T with capacity capacity. Capacity need to be greater than 2.

TokenBucket - Lock-free implementation of the token bucket algorithm in C++

  •    C++

Lock-free implementation of the token bucket algorithm in C++11. This project was created by Erik Rigtorp <erik@rigtorp.se>.

fcgi-function - fcgi Function is C/C++ based Interface which build on top of FastCGI with built in for nginx server to have c/c++ functional handler support, it also provided useful collection tools to enhance the facilities

  •    C

fcgi Function is C/C++ based Interface which build on top of FastCGI with built in for nginx server to have c/c++ functional handler support, it also provided useful collection tools to enhance the facilities. It can be integrated with NGINX webserver FASTCGI Module

onering - A collection of concurrent ring buffers

  •    Go

Well, no, it's not really just one ring, but a collection of concurrent ring buffers for different scenarios, so it's even better! These queues don't use CAS operations to make them suitable for low latency/real-time environments and as a side effect of that, they preserve total order of messages. As a reward for finding flaws/bugs in this, I offer 64bit of random numbers for each. A couple of things in it were inspired by the very cool LMAX Disruptor, so thanks @mjpt777! It's not anywhere near as intrusive and opinionated as the Disruptor though. It's not a framework and its main goal is to be (very) simple.

lock-free - Lock-Free data structures

  •    D

A library for lock-free data structures. They need doubly-linked list still needs a thorough review and some polishing. That said all unittests pass on X86_64.

sled - A high performance lock free map type for go.

  •    Go

Sled is a high performance Key/Value store based on a ctrie data structure. Sled is non-blocking and thread safe, meaning it is safe to access from any number of threads simultaneously. Any type of data can be stored in a key, but sled maintains the benefits of the Go type system by enforcing the type. Values must be accessed by passing an empty type value of the same type into the Get method.

MPMCQueue.NET - Bounded multiple producers multiple consumers queue for .NET

  •    CSharp

According to the classification it's MPMC, array-based, fails on overflow, does not require GC, w/o priorities, causal FIFO, blocking producers and consumers queue. The algorithm is pretty simple and fast. It's not lockfree in the official meaning, just implemented by means of atomic RMW operations w/o mutexes. The cost of enqueue/dequeue is 1 CAS per operation. No amortization, just 1 CAS. No dynamic memory allocation/management during operation. Producers and consumers are separated from each other (as in the two-lock queue), i.e. do not touch the same data while queue is not empty.

NonBlocking - Implementation of a lock-free dictionary on .Net.

  •    CSharp

There is a subtle difference in when keys are unreferenced after Remove. ConcurrentDictionary drops keys eagerly on Remove, while in the case of NonBlocking dictionary only the value is removed and the corresponding key is dropped lazily. ConcurrentDictionary performs Remove under a lock and as such it can expell both the key and the value "atomically". That is not the case for NonBlocking dictionary and thus only values are immediately removed. The corresponding dead key will remain in the dictionary and may become live again after a corresponding Add, or, if still dead, "shaken off" when there is a shortage of free slots.

lockfree - ⚡️ lock-free utilities in Go

  •    Go

Package lock-free offers lock-free utilities in Go. We would love to have your experiences. Feel free to submit an issue for requesting a new implementation or bug report.






We have large collection of open source products. Follow the tags from Tag Cloud >>


Open source products are scattered around the web. Please provide information about the open source projects you own / you use. Add Projects.