sync.h

Go to the documentation of this file.

 
#pragma once
 
#include <freertos/FreeRTOS.h>
#include <freertos/portmacro.h>
#include <freertos/semphr.h>
 
namespace vsync
{
class MutexLock
{
public:
    explicit MutexLock(SemaphoreHandle_t mutex) : _mutex(mutex)
    {
        if (this->_mutex != nullptr)
        {
            xSemaphoreTake(this->_mutex, portMAX_DELAY);
        }
    }
    ~MutexLock()
    {
        if (this->_mutex != nullptr)
        {
            xSemaphoreGive(this->_mutex);
        }
    }
    MutexLock(const MutexLock&) = delete;
    MutexLock& operator=(const MutexLock&) = delete;
 
private:
    SemaphoreHandle_t _mutex;
};
 
template <typename T> class SpinGuarded
{
public:
    SpinGuarded() = default;
    explicit SpinGuarded(const T& initial) : _value(initial) {}
    SpinGuarded(const SpinGuarded&) = delete;
    SpinGuarded& operator=(const SpinGuarded&) = delete;
 
    T load() const
    {
        const Section section(&this->_lock);
        return this->_value;
    }
 
    void store(const T& value)
    {
        const Section section(&this->_lock);
        this->_value = value;
    }
 
    template <typename F> decltype(auto) update(F&& f)
    {
        const Section section(&this->_lock);
        return f(this->_value);
    }
 
    template <typename F> decltype(auto) inspect(F&& f) const
    {
        const Section section(&this->_lock);
        return f(this->_value);
    }
 
private:
    class Section
    {
    public:
        explicit Section(portMUX_TYPE* lock) : _lock(lock) { portENTER_CRITICAL(this->_lock); }
        ~Section() { portEXIT_CRITICAL(this->_lock); }
        Section(const Section&) = delete;
        Section& operator=(const Section&) = delete;
 
    private:
        portMUX_TYPE* _lock;
    };
 
    mutable portMUX_TYPE _lock = portMUX_INITIALIZER_UNLOCKED;
    T _value{};
};
} // namespace vsync