Bolt
moodycamel
Bolt | moodycamel | |
---|---|---|
3 | 11 | |
370 | 8,837 | |
- | - | |
0.0 | 3.9 | |
about 8 years ago | 11 months 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.
Bolt
-
AMD's CDNA 3 Compute Architecture
this is frankly starting to sound a lot like the ridiculous "blue bubbles" discourse.
AMD's products have generally failed to catch traction because their implementations are halfassed and buggy and incomplete (despite promising more features, these are often paper features or career-oriented development from now-departed developers). all of the same "developer B" stuff from openGL really applies to openCL as well.
http://richg42.blogspot.com/2014/05/the-truth-on-opengl-driv...
AMD has left a trail of abandoned code and disappointed developers in their wake. These two repos are the same thing for AMD's ecosystem and NVIDIA's ecosystem, how do you think the support story compares?
https://github.com/HSA-Libraries/Bolt
https://github.com/NVIDIA/thrust
in the last few years they have (once again) dumped everything and started over, ROCm supported essentially no consumer cards and rotated support rapidly even in the CDNA world. It offers no binary compatibility support story, it has to be compiled for specific chips within a generation, not even just "RDNA3" but "Navi 31 specifically". Etc etc. And nobody with consumer cards could access it until like, six months ago, and that still is only on windows, consumer cards are not even supported on linux (!).
https://geohot.github.io/blog/jekyll/update/2023/06/07/a-div...
This is on top of the actual problems that still remain, as geohot found out. Installing ROCm is a several-hour process that will involve debugging the platform just to get it to install, and then you will probably find that the actual code demos segfault when you run them.
AMD's development processes are not really open, and actual development is silo'd inside the company with quarterly code dumps outside. The current code is not guaranteed to run on the actual driver itself, they do not test it even in the supported configurations.
it hasn't got traction because it's a low-quality product and nobody can even access it and run it anyway.
-
High quality OpenCL compute libraries
what I'm saying is there are options on that that make it more likely for what you're looking to exist; I haven't surveyed the existing libs as much but without templates and the integration of single source you're not bound to find libraries to exist; it's why opencl doesn't have those things really; however I name droped the amd targetted OpenCL thrust equivalent - https://github.com/HSA-Libraries/Bolt - I don't know if you can really achieve opencl multi-accelerator compatibility with it though.
-
Nvidia in the Valley
OpenCL had a bit of a "second-mover curse" where instead of trying to solve one problem (GPGPU acceleration) it tried to solve everything (a generalized framework for heterogeneous dispatch) and it just kinda sucks to actually use. It's not that it's slower or faster, in principle it should be the same speed when dispatched to the hardware (+/- any C/C++ optimization gotchas of course), but it just requires an obscene amount of boilerplate to "draw the first triangle" (or, launch the first kernel), much like Vulkan.
HIP was supposed to rectify this, but now you're buying into AMD's custom language and its limitations... and there are limitations, things that CUDA can do that HIP can't (texture unit access was an early one - and texture units aren't just for texturing, they're for coalescing all kinds of 2d/3d/higher-dimensional memory access). And AMD has a history of abandoning these projects after a couple years and leaving them behind and unsupported... like their Thrust framework counterpart, Bolt, which hasn't been updated in 8 years now.
https://github.com/HSA-Libraries/Bolt
The old bit about "Vendor B" leaving behind a "trail of projects designed to pad resumes and show progress to middle managers" still reigns absolutely true with AMD. AMD has a big uphill climb in general to shake this reputation about being completely unserious with their software... and I'm not even talking about drivers here.
http://richg42.blogspot.com/2014/05/the-truth-on-opengl-driv...
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.
What are some alternatives?
Boost.Compute - A C++ GPU Computing Library for OpenCL
Thrust - [ARCHIVED] The C++ parallel algorithms library. See https://github.com/NVIDIA/cccl
MPMCQueue.h - A bounded multi-producer multi-consumer concurrent queue written in C++11
Taskflow - A General-purpose Parallel and Heterogeneous Task Programming System
junction - Concurrent data structures in C++
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
ArrayFire - ArrayFire: a general purpose GPU library.
libcds - A C++ library of Concurrent Data Structures