Projects sharing features with Concurrencpp

JCTools is a Java concurrency library providing a collection of lock-less and wait-free data structures. It serves as a toolkit for managing thread-safe data exchange, specifically designed to optimize high-throughput messaging and producer-consumer patterns in multi-threaded applications. The library distinguishes itself by implementing specialized queue structures that minimize contention and maximize throughput. By utilizing techniques such as cache-line padding, memory-barrier-based synchronization, and relaxed-consistency memory ordering, it avoids the performance bottlenecks often assoc

This project is a structured Rust programming curriculum and systems programming course designed to take learners from beginner to expert levels. It provides a comprehensive set of training materials focused on mastering the core syntax, idioms, and technical foundations of the Rust language. The project features a specialized language transition framework that maps concepts from C++, managed languages, and dynamic typing to Rust idioms. This allows developers from different ecosystems to translate architectural patterns and memory models into idiomatic Rust. The training covers a broad rang

ArrayFire is a hardware-agnostic compute framework and JIT-compiled tensor engine designed for high-performance numerical computing. It serves as a GPU numerical computing library and parallel signal processing toolkit that abstracts hardware backends, allowing the same codebase to execute across various GPU architectures and CPUs. The project distinguishes itself through a JIT engine that uses expression compilation to fuse operations and minimize memory overhead. It employs a deferred execution graph to optimize computation chains and provides interoperability primitives to share data and e

The libdispatch Project, (a.k.a. Grand Central Dispatch), for concurrency on multicore hardware

Smart queue that executes tasks in threadpool-like manner

Event loop friendly C++ actor micro-framework, supervisable

Powerful multi-threaded coroutine dispatcher and parallel execution engine

VexCL is a C++ vector expression template library for OpenCL/CUDA/OpenMP

A C++ GPU Computing Library for OpenCL

Reactive computation tree library for non-blocking concurrent Common Lisp

A full-featured NATS messaging client for Common Lisp.

C++11 thread-safe container for sharing data between threads (synchronized queue)

This project is a single-producer single-consumer concurrent queue for C++ designed for lock-free data exchange between threads. It provides a thread-safe mechanism to transfer data without the use of mutexes or locks. The queue is implemented as a contiguous circular buffer that supports dynamic capacity growth to prevent data loss when the queue reaches its limit. It utilizes atomic synchronization and wait-free index management to coordinate data access between the writing and reading threads. The library covers inter-thread communication and buffer management, offering both blocking and

Run etcd as an asynchronous inferior process

The project alpaka has moved to https://github.com/alpaka-group/alpaka

The project alpaka has moved to https://github.com/alpaka-group/cupla

Concurrency primitives, safe memory reclamation mechanisms and non-blocking (including lock-free) data structures designed to aid in the research, design and implementation of high performance concurrent systems developed in C99+.

A bleeding-edge, lock-free, wait-free, continuation-stealing tasking library built on C++20's coroutines

High performance Transactional Memory for Common Lisp

Cpp-taskflow is a C++ task-parallelism framework and task graph scheduler designed to manage and execute complex dependency graphs of parallel tasks across CPU and GPU hardware. It provides a parallel algorithm library for high-performance implementations of reductions, sorts, pipelines, and iterations. The framework distinguishes itself through its ability to offload heavy computational workloads from a task graph to graphics processors for acceleration. It also includes a task profiling tool and a performance analysis interface for visualizing task execution flow and dependency structures t

BS::thread_pool: a fast, lightweight, modern, and easy-to-use C++17 / C++20 / C++23 thread pool library

A modern, fast, lightweight thread pool library based on C++2x

Fine-grained concurrency for Ruby

EventMachine is a reactor-pattern network framework for Ruby that provides an asynchronous I/O library for performing non-blocking network and file operations. It functions as a network server framework used to build scalable TCP and UDP servers and clients that process multiple simultaneous requests. The framework implements a concurrency model that dispatches network events to registered handlers using a single-threaded event loop. This approach allows for the management of high-concurrency network connections without the overhead of multi-threaded programming. The library covers the devel

Thin, unified, C++-flavored wrappers for the CUDA APIs

Common Lisp distributed computation framework implemented using Swank Client