SpinReaderWriterLock.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/exceptions.h"
#include "catapult/functions.h"
#include <atomic>
#include <thread>
 
namespace catapult { namespace utils {
 
    template<typename TReaderNotificationPolicy>
    class BasicSpinReaderWriterLock : private TReaderNotificationPolicy {
    private:
        // 0[active writer]|1234567[total writers]|01234567[total readers]
        static constexpr uint16_t Active_Writer_Flag = 0x8000;
        static constexpr uint16_t Pending_Writer_Mask = 0x7F00;
        static constexpr uint16_t Reader_Mask = 0x00FF;
        static constexpr uint16_t Writer_Mask = Pending_Writer_Mask | Active_Writer_Flag;
 
        static constexpr uint16_t Active_Reader_Increment = 0x0001;
        static constexpr uint16_t Pending_Writer_Increment = 0x0100;
 
    private:
#pragma push_macro("Yield")
#undef Yield
        static void Yield() {
            std::this_thread::yield();
        }
#pragma pop_macro("Yield")
 
    private:
        class LockGuard {
        protected:
            explicit LockGuard(const action& resetFunc)
                    : m_resetFunc(resetFunc)
                    , m_isMoved(false)
            {}
 
            ~LockGuard() {
                if (m_isMoved)
                    return;
 
                m_resetFunc();
            }
 
        public:
            LockGuard(LockGuard&& rhs) : m_resetFunc(rhs.m_resetFunc), m_isMoved(false) {
                rhs.m_isMoved = true;
            }
 
        private:
            action m_resetFunc;
            bool m_isMoved;
        };
 
    public:
        struct WriterLockGuard : public LockGuard {
        public:
            explicit WriterLockGuard(std::atomic<uint16_t>& value, bool& isActive)
                    : LockGuard([&value, &isActive]() {
                        // unset the active writer flag and change the writer to a reader
                        value.fetch_sub(Active_Writer_Flag + Pending_Writer_Increment - Active_Reader_Increment);
                        isActive = false;
                    })
            {}
 
            WriterLockGuard(WriterLockGuard&&) = default;
        };
 
        struct ReaderLockGuard : public LockGuard {
        public:
            explicit ReaderLockGuard(std::atomic<uint16_t>& value, TReaderNotificationPolicy& notificationPolicy)
                    : LockGuard([&value, &notificationPolicy]() {
                        // decrease the number of readers by one
                        value.fetch_sub(Active_Reader_Increment);
                        notificationPolicy.readerReleased();
                    })
                    , m_value(value)
                    , m_isWriterActive(false) {
                notificationPolicy.readerAcquired();
            }
 
            ReaderLockGuard(ReaderLockGuard&&) = default;
 
        public:
            WriterLockGuard promoteToWriter() {
                markActiveWriter();
 
                // mark a pending write by changing the reader to a writer
                m_value.fetch_add(Pending_Writer_Increment - Active_Reader_Increment);
 
                // wait for exclusive access (when there is no active writer and no readers)
                uint16_t expected = m_value & Pending_Writer_Mask;
                while (!m_value.compare_exchange_strong(expected, expected | Active_Writer_Flag)) {
                    Yield();
                    expected = m_value & Pending_Writer_Mask;
                }
 
                return WriterLockGuard(m_value, m_isWriterActive);
            }
 
        private:
            void markActiveWriter() {
                if (m_isWriterActive)
                    CATAPULT_THROW_RUNTIME_ERROR("reader lock has already been promoted");
 
                m_isWriterActive = true;
            }
 
        private:
            std::atomic<uint16_t>& m_value;
            bool m_isWriterActive;
        };
 
    public:
        BasicSpinReaderWriterLock() : m_value(0)
        {}
 
    public:
        inline ReaderLockGuard acquireReader() {
            uint16_t current = m_value;
            for (;;) {
                // wait for any pending writes to complete
                if (0 != (current & Pending_Writer_Mask)) {
                    Yield();
                    current = m_value;
                    continue;
                }
 
                // try to increment the number of readers by one
                uint16_t desired = current + Active_Reader_Increment;
                if (m_value.compare_exchange_strong(current, desired))
                    break;
 
                Yield();
            }
 
            return ReaderLockGuard(m_value, *this);
        }
 
    public:
        inline bool isWriterPending() const {
            return isSet(Pending_Writer_Mask);
        }
 
        inline bool isWriterActive() const {
            return isSet(Active_Writer_Flag);
        }
 
        inline bool isReaderActive() const {
            return isSet(Reader_Mask);
        }
 
    private:
        inline bool isSet(uint16_t mask) const {
            return 0 != (m_value & mask);
        }
 
    private:
        std::atomic<uint16_t> m_value;
    };
 
    struct NoOpReaderNotificationPolicy {
        constexpr void readerAcquired()
        {}
 
        constexpr void readerReleased()
        {}
    };
}}
 
#ifdef ENABLE_CATAPULT_DIAGNOSTICS
#include "ReentrancyCheckReaderNotificationPolicy.h"
#endif
 
namespace catapult { namespace utils {
 
#ifdef ENABLE_CATAPULT_DIAGNOSTICS
    using DefaultReaderNotificationPolicy = ReentrancyCheckReaderNotificationPolicy;
#else
    using DefaultReaderNotificationPolicy = NoOpReaderNotificationPolicy;
#endif
 
    using SpinReaderWriterLock = BasicSpinReaderWriterLock<DefaultReaderNotificationPolicy>;
}}