Displaying 1 to 15 from 15 results

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

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.

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.