freertos-addons
cs_libguarded
Our great sponsors
freertos-addons | cs_libguarded | |
---|---|---|
2 | 10 | |
434 | 218 | |
- | 0.0% | |
2.9 | 5.0 | |
about 2 months ago | about 1 month ago | |
C | C++ | |
MIT License | 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.
freertos-addons
-
FreeRTOS Guarded Data Structure
To make this work you also need a small wrapper class around a mutex that provides the lock and unlock functions. Here is a quick one that works or the freertos-addons library has a good implementation.
- Good project to show off programming skills
cs_libguarded
- MutexProtected: A C++ Pattern for Easier Concurrency
-
Using shared_ptr for reloadable config
I know this article was trying to come up with an excuse to use a shared_ptr, but atomic smart pointers are a lot more error prone than wrapping mutexes in an appropriate interface that hides the complexity and forces you to use them correctly.
-
Ban thread locking classes/functions?
The approach I would recommend would be to use mutexes but wrap them in a convenience library designed to make them difficult to misuse: https://github.com/copperspice/cs_libguarded
-
FreeRTOS Guarded Data Structure
I was inspired by the great copperspice library libguarded and wanted something similar for when I have to go back to micro's and FreeRTOS. The basic idea of the library is to prevent access to a shared data structure unless the mutex lock associated with it is also acquired. This is to prevent situations where someone forgets to get the lock before reading or writing to shared memory.
-
Strategies for serialization of a class in a concurrent fashion
I'm personally partial to the basic guarded type from https://github.com/copperspice/cs_libguarded due to its simplicity.
-
Why Rust mutexes look like they do
The Rust strategy for mutexes sounds a lot like libguarded, which now that I've read this article is occurs to me that the former was likely have been the inspiration for the latter.
This is pretty much what libguarded does.
-
How would you recommend implementing an iterator that holds a resource?
Also I don't think that operating this way is good to begin with. See how libGuard operates - it is way way cleaner and more flexible https://github.com/copperspice/cs_libguarded
-
A C++ locking wrapper
have you heard of https://github.com/copperspice/cs_libguarded ? it sounds like a similar idea, but supports other stuff like rcu as well
-
Having fun overloading the operator->
https://github.com/copperspice/cs_libguarded#cslibguarded
What are some alternatives?
Lua-RTOS-ESP32 - Lua RTOS for ESP32
ultimatepp - U++ is a C++ cross-platform rapid application development framework focused on programmer's productivity. It includes a set of libraries (GUI, SQL, Network etc.), and integrated development environment (TheIDE).
MuditaOS - Mobile operating system based on FreeRTOS™ optimized for E Ink displays - developed for Mudita Pure minimalist phone
concurrencpp - Modern concurrency for C++. Tasks, executors, timers and C++20 coroutines to rule them all
nuclei-sdk - Nuclei RISC-V Software Development Kit
concurrent-resource - A header-only C++ library that allows easily creating thread-safe, concurrency friendly resources.
Folly - An open-source C++ library developed and used at Facebook.
parking_lot - Compact and efficient synchronization primitives for Rust. Also provides an API for creating custom synchronization primitives.
lock_ios - iostream synchronization manipulator for concurrency
ThreadSafeVar - Simple wrapper to create thread safe variable with a mutex.
rwspinlock - Slim, simple, cross-process, reader-writer unfair fast spin lock for Windows