moodycamel
Taskflow
Our great sponsors
moodycamel | Taskflow | |
---|---|---|
11 | 24 | |
8,808 | 9,520 | |
- | 1.7% | |
3.9 | 7.9 | |
10 months ago | 7 days ago | |
C++ | C++ | |
GNU General Public License v3.0 or later | GNU General Public License v3.0 or later |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
moodycamel
-
Professional Usernames
Other than that... if your stuff is good, that's a much better signal than a professional username. I've seen a lot of decently unprofessional usernames out there that get taken pretty seriously because of the good work behind them. My recent favorite is "moodycamel" who authored a great concurrent queue library in C++.
-
How should you "fix your timestep" for physics?
In c++ the moodycamel ConcurrentQueue is a good choice.
-
Efficient asynchronous programming -- search keywords/basic pointers (ha)/examples?
Here's a decent concurrent queue: moodycamel::ConcurrentQueue.
-
moodycamel VS lockfree_mpmc_queue - a user suggested alternative
2 projects | 21 Apr 2022
-
Lockless Queue Not Working
Lock free programming is hard, and probably harder than you think. I would not even try something like that myself. I would look for existing solutions, something like https://github.com/cameron314/concurrentqueue for example.
-
Simple Blocking/Nonblocking Concurrent (thread-safe) Queue Adapter, header only library
I needed a concurrent queue that would block when attempting to pop an empty queue, which allows the consuming thread to suspend while it's waiting for work. I found that using mutexes allowed me to develop a simple template adapter had several advantages with few drawbacks when compared to non-blocking queues: it can use a variety of containers, the code can be reviewed and verified as to its correctness (very hard to do with fancy concurrent programming that avoids mutexes), and it is only slightly slower than fancier solutions (when I benchmarked it originally, it was 4x slower than Moody Camel's concurrent queue, which to me is fine performance).
-
Matthias Killat - Lock-free programming for real-time systems - Meeting C++ 2021
Not literatue but an example. This is a lock-free (not wait-free!) multi-producer multi-consumer queue, not a FIFO, but access patterns should be similar - if not the same: https://github.com/cameron314/concurrentqueue
-
Learning Clojure made me return back to C/C++
If I do implement it, the most likely route I'd take is make a compiler in Clojure/clojurescript that uses Instaparse (I have a more-or-less-clojure grammar written that I was tinkering with) and generate C++ code that uses Immer for its data structures and Zug for transducers and what my not-quite-clojure would support would be heavily dependent on what the C++ code and libraries I use can do. I'd use Taskflow to implement a core.async style system (not sure how to implement channels, maybe this but I'm unsure if its a good fit, but I also haven't looked). I would ultimately want to be able to interact with C++ code, so having some way to call C++ classes (even templated ones) would be a must. I'm unsure if I would just copy (and extend as needed) Clojure's host interop functionality or not. I had toyed with the idea that you can define the native types (including templates) as part of the type annotations and then the user-level code basically just looks like a normal function. But I didn't take it very far yet, haven't had the time. The reason I'd take this approach is that I'm writing a good bit of C++ again and I'd love to do that in this not-quite-clojure language, if I did make it. A bunch of languages, like Haxe and Nim compile to C or C++, so I think its a perfectly reasonable approach, and if interop works well enough, then just like Clojure was able to leverage the Java ecosystem, not-quite-clojure could be bootstrapped by leveraging the C++ ecosystem. But its mostly just a vague dream right now.
-
Recommendations for C++ library for shared memory (multiple producers/single consumer)
I would recommend https://github.com/cameron314/concurrentqueue as it's very battle tested and fast.
-
fmtlog: fastest C++ logging library using fmtlib syntax
This was explicitly considered for spdlog (using the moodycamel::ConcurrentQueue) but rejected for the above reason. I'm not involved in the development of spdlog but personally I agree, for me it's important that log output is not all mixed up.
Taskflow
-
Improvements of Clojure in his time
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.
- Taskflow: A General-Purpose Parallel and Heterogeneous Task Programming System
-
How to go from intermediate to advance in C++?
Also, you can take a look to good libraries. The problem is that very often libraries are heavily templated, so It could be hard. For example, I like the style of the Taskflow library, I think is very clear, is relatively small, while makes use of more advanced techniques: https://github.com/taskflow/taskflow
-
gcl v1.1 released - Graph Concurrent Library for C++
Cool. Thanks! How does it compare to taskflow?
-
std::execution from the metal up - Paul Bendixen - Meeting C++ 2022
I've not seen yet, but it's been a bit since I looked last, any evidence of being able to build a computation graph and "save" it to re-run on new inputs. Something like https://github.com/taskflow/taskflow
-
Proper abstraction for this?
It seems you're describing something a generic parallel task framework. Check taskflow for a production ready example https://github.com/taskflow/taskflow/blob/master/
-
That one technology, question, or skill you never learned, and now you are haunted by during every new job conversation...
- https://github.com/taskflow/taskflow (I recommend to learn it first since its API and documentation are excellent)
-
Parallel Computations in C++: Where Do I Begin?
If you want some sort of "job" system, where you submit items to a some sort of queue to be processed in parallel, try searching for a thread pool - there isn't one in the standard library, but there's about a million implementations online. There are more complicated versions of that idea, that describe computation as a directed acyclic graph, such as taskflow.
-
High level overview of my custom game engine
The tooling decisions affect engine design though. For example if you want to have visual representation of job graph as it happened in specific frame of interest you need to pass the information around about job relationships and output it to a tool of choice. For example see https://github.com/taskflow/taskflow
-
Is there any good reason not to build an open-source C++ project on Intels oneTBB?
I am aware of DAGs of task based threading library like Taskflow and HPX however the benefit they have is not obvious to me, as the following sequential section depends on the parallel part being completed fully. If you want to suggest elaboration on the benefits of this approach would be welcome.
What are some alternatives?
Boost.Compute - A C++ GPU Computing Library for OpenCL
tbb - oneAPI Threading Building Blocks (oneTBB) [Moved to: https://github.com/oneapi-src/oneTBB]
MPMCQueue.h - A bounded multi-producer multi-consumer concurrent queue written in C++11
tensorflow - An Open Source Machine Learning Framework for Everyone
readerwriterqueue - A fast single-producer, single-consumer lock-free queue for C++
HPX - The C++ Standard Library for Parallelism and Concurrency
RaftLib - The RaftLib C++ library, streaming/dataflow concurrency via C++ iostream-like operators
C++ Actor Framework - An Open Source Implementation of the Actor Model in C++
libcds - A C++ library of Concurrent Data Structures
entt - Gaming meets modern C++ - a fast and reliable entity component system (ECS) and much more
Thrust - [ARCHIVED] The C++ parallel algorithms library. See https://github.com/NVIDIA/cccl
libunifex - Unified Executors