C++ Concurrency

Open-source C++ projects categorized as Concurrency
Topics: CPP Cpp17 Async Cpp20 C++

Top 23 C++ Concurrency Projects

  • Swoole

    🚀 Coroutine-based concurrency library for PHP

  • Project mention: Performance benchmark of PHP runtimes | dev.to | 2024-01-17

    Swoole

  • Taskflow

    A General-purpose Parallel and Heterogeneous Task Programming System

  • Project mention: Improvements of Clojure in his time | /r/Clojure | 2023-06-16

    For parallel programming nowadays, personally I reach for C++ Taskflow when I really care about performance, or a mix of core.async and running multiple load balanced instances when I’m doing more traditional web backend stuff in Clojure.

  • WorkOS

    The modern identity platform for B2B SaaS. The APIs are flexible and easy-to-use, supporting authentication, user identity, and complex enterprise features like SSO and SCIM provisioning.

    WorkOS logo
  • ZeroMQ

    ZeroMQ core engine in C++, implements ZMTP/3.1

  • Project mention: Lightweight and fast AMQP (0-9-1) server | news.ycombinator.com | 2024-04-07

    Slightly OT:

    Are ZeroMQ and NanoMQ still widely used (and recommended)?

    https://github.com/zeromq/libzmq

    https://github.com/nanomq/nanomq

  • moodycamel

    A fast multi-producer, multi-consumer lock-free concurrent queue for C++11

  • ArrayFire

    ArrayFire: a general purpose GPU library.

  • Project mention: Learn WebGPU | news.ycombinator.com | 2023-04-27

    Loads of people have stated why easy GPU interfaces are difficult to create, but we solve many difficult things all the time.

    Ultimately I think CPUs are just satisfactory for the vast vast majority of workloads. Servers rarely come with any GPUs to speak of. The ecosystem around GPUs is unattractive. CPUs have SIMD instructions that can help. There are so many reasons not to use GPUs. By the time anyone seriously considers using GPUs they're, in my imagination, typically seriously starved for performance, and looking to control as much of the execution details as possible. GPU programmers don't want an automagic solution.

    So I think the demand for easy GPU interfaces is just very weak, and therefore no effort has taken off. The amount of work needed to make it as easy to use as CPUs is massive, and the only reason anyone would even attempt to take this on is to lock you in to expensive hardware (see CUDA).

    For a practical suggestion, have you taken a look at https://arrayfire.com/ ? It can run on both CUDA and OpenCL, and it has C++, Rust and Python bindings.

  • readerwriterqueue

    A fast single-producer, single-consumer lock-free queue for C++

  • C++ Actor Framework

    An Open Source Implementation of the Actor Model in C++

  • Project mention: C++ Jobs - Q3 2023 | /r/cpp | 2023-07-04

    CAF

  • InfluxDB

    Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.

    InfluxDB logo
  • NCCL

    Optimized primitives for collective multi-GPU communication

  • Project mention: MPI jobs to test | /r/HPC | 2023-06-06

    % rm -rf /tmp/nccl ; git clone --recursive https://github.com/NVIDIA/nccl.git ; cd nccl ; git grep MPI Cloning into 'nccl'... remote: Enumerating objects: 2769, done. remote: Counting objects: 100% (336/336), done. remote: Compressing objects: 100% (140/140), done. remote: Total 2769 (delta 201), reused 287 (delta 196), pack-reused 2433 Receiving objects: 100% (2769/2769), 3.04 MiB | 3.37 MiB/s, done. Resolving deltas: 100% (1820/1820), done. README.md:NCCL (pronounced "Nickel") is a stand-alone library of standard communication routines for GPUs, implementing all-reduce, all-gather, reduce, broadcast, reduce-scatter, as well as any send/receive based communication pattern. It has been optimized to achieve high bandwidth on platforms using PCIe, NVLink, NVswitch, as well as networking using InfiniBand Verbs or TCP/IP sockets. NCCL supports an arbitrary number of GPUs installed in a single node or across multiple nodes, and can be used in either single- or multi-process (e.g., MPI) applications. src/collectives/broadcast.cc:/* Deprecated original "in place" function, similar to MPI */

  • libcds

    A C++ library of Concurrent Data Structures

  • HPX

    The C++ Standard Library for Parallelism and Concurrency

  • Project mention: Does anyone know any good open source project to optimize? | /r/cpp | 2023-06-07
  • parallel-hashmap

    A family of header-only, very fast and memory-friendly hashmap and btree containers.

  • Project mention: The One Billion Row Challenge in CUDA: from 17 minutes to 17 seconds | news.ycombinator.com | 2024-04-13

    Standard library maps/unordered_maps are themselves notoriously slow anyway. A sparse_hash_map from abseil or parallel-hashmaps[1] would be better.

    [1] https://github.com/greg7mdp/parallel-hashmap

  • concurrencpp

    Modern concurrency for C++. Tasks, executors, timers and C++20 coroutines to rule them all

  • Project mention: Is anyone using coroutines seriously? | /r/cpp | 2023-12-05

    I am using concurrencpp for my project. What I like about it is that it's basically a thread pool factory with coroutines. It allows for better structuring / organizing of multithreaded work. So for me the main advantage of coroutines is that the code looks easier to follow

  • thread-pool

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

  • moderngpu

    Patterns and behaviors for GPU computing

  • Boost.Compute

    A C++ GPU Computing Library for OpenCL

  • junction

    Concurrent data structures in C++

  • MPMCQueue.h

    A bounded multi-producer multi-consumer concurrent queue written in C++11

  • stdgpu

    stdgpu: Efficient STL-like Data Structures on the GPU

  • CacheLib

    Pluggable in-process caching engine to build and scale high performance services

  • C++React

    C++React: A reactive programming library for C++11.

  • RaftLib

    The RaftLib C++ library, streaming/dataflow concurrency via C++ iostream-like operators

  • SPSCQueue.h

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

  • continuable

    C++14 asynchronous allocation aware futures (supporting then, exception handling, coroutines and connections)

  • SaaSHub

    SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

    SaaSHub logo
NOTE: The open source projects on this list are ordered by number of github stars. The number of mentions indicates repo mentiontions in the last 12 Months or since we started tracking (Dec 2020). The latest post mention was on 2024-04-13.

C++ Concurrency related posts

Index

What are some of the best open-source Concurrency projects in C++? This list will help you:

Project Stars
1 Swoole 18,203
2 Taskflow 9,520
3 ZeroMQ 9,256
4 moodycamel 8,785
5 ArrayFire 4,395
6 readerwriterqueue 3,429
7 C++ Actor Framework 3,095
8 NCCL 2,796
9 libcds 2,469
10 HPX 2,417
11 parallel-hashmap 2,307
12 concurrencpp 2,028
13 thread-pool 1,911
14 moderngpu 1,562
15 Boost.Compute 1,496
16 junction 1,365
17 MPMCQueue.h 1,079
18 stdgpu 1,077
19 CacheLib 1,075
20 C++React 997
21 RaftLib 922
22 SPSCQueue.h 821
23 continuable 809
SaaSHub - Software Alternatives and Reviews
SaaSHub helps you find the best software and product alternatives
www.saashub.com