SynchronizedCache.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/utils/NonCopyable.h"
#include "catapult/utils/SpinReaderWriterLock.h"
#include <boost/optional.hpp>
 
namespace catapult { namespace cache {
 
    namespace detail {
        // region CacheViewReadLockPair
 
        template<typename TCacheView>
        struct CacheViewReadLockPair {
        public:
            CacheViewReadLockPair(TCacheView&& cacheView, utils::SpinReaderWriterLock::ReaderLockGuard&& readLock)
                    : CacheView(std::move(cacheView))
                    , ReadLock(std::move(readLock))
            {}
 
        public:
            TCacheView CacheView;
 
            utils::SpinReaderWriterLock::ReaderLockGuard ReadLock;
        };
 
        // endregion
 
        // region CacheViewAccessor
 
        template<typename TCacheView>
        class CacheViewAccessor {
        public:
            explicit CacheViewAccessor(TCacheView* pCacheView) : m_pCacheView(pCacheView)
            {}
 
        public:
            explicit operator bool() const {
                return !!m_pCacheView;
            }
 
            const TCacheView* operator->() const {
                return m_pCacheView;
            }
 
            const TCacheView& operator*() const {
                return *m_pCacheView;
            }
 
        public:
            TCacheView* operator->() {
                return m_pCacheView;
            }
 
            TCacheView& operator*() {
                return *m_pCacheView;
            }
 
        private:
            TCacheView* m_pCacheView;
        };
 
        // endregion
    }
 
    // region LockedCacheView
 
    template<typename TCacheView>
    class LockedCacheView : public detail::CacheViewAccessor<TCacheView> {
    public:
        LockedCacheView(TCacheView&& cacheView, utils::SpinReaderWriterLock::ReaderLockGuard&& readLock)
                : detail::CacheViewAccessor<TCacheView>(&m_cacheView)
                , m_cacheView(std::move(cacheView))
                , m_readLock(std::move(readLock))
        {}
 
        LockedCacheView(LockedCacheView&& rhs)
                : detail::CacheViewAccessor<TCacheView>(&m_cacheView)
                , m_cacheView(std::move(rhs.m_cacheView))
                , m_readLock(std::move(rhs.m_readLock))
        {}
 
    private:
        TCacheView m_cacheView;
        utils::SpinReaderWriterLock::ReaderLockGuard m_readLock;
    };
 
    // endregion
 
    // region LockedCacheDelta
 
    template<typename TCacheView>
    class LockedCacheDelta : public detail::CacheViewAccessor<TCacheView> {
    public:
        explicit LockedCacheDelta(const std::shared_ptr<detail::CacheViewReadLockPair<TCacheView>>& pPair)
                : detail::CacheViewAccessor<TCacheView>(&pPair->CacheView)
                , m_pPair(pPair)
        {}
 
    private:
        std::shared_ptr<detail::CacheViewReadLockPair<TCacheView>> m_pPair;
    };
 
    // endregion
 
    // region OptionalLockedCacheDelta
 
    template<typename TCacheView>
    class OptionalLockedCacheDelta : public detail::CacheViewAccessor<TCacheView> {
    public:
        OptionalLockedCacheDelta() : detail::CacheViewAccessor<TCacheView>(nullptr)
        {}
 
        OptionalLockedCacheDelta(TCacheView& cacheView, utils::SpinReaderWriterLock::ReaderLockGuard&& readLock)
                : detail::CacheViewAccessor<TCacheView>(&cacheView)
                , m_readLock(std::move(readLock))
        {}
 
    private:
        boost::optional<utils::SpinReaderWriterLock::ReaderLockGuard> m_readLock;
    };
 
    // endregion
 
    // region LockableCacheDelta
 
    template<typename TCacheDelta>
    class LockableCacheDelta {
    public:
        LockableCacheDelta(TCacheDelta&& cacheDelta, const size_t& commitCounter, utils::SpinReaderWriterLock& lock)
                : m_cacheDelta(std::move(cacheDelta))
                , m_initialCommitCount(commitCounter)
                , m_commitCounter(commitCounter)
                , m_lock(lock)
        {}
 
    public:
        OptionalLockedCacheDelta<TCacheDelta> tryLock() {
            auto readLock = m_lock.acquireReader();
            return m_initialCommitCount != m_commitCounter
                    ? OptionalLockedCacheDelta<TCacheDelta>()
                    : OptionalLockedCacheDelta<TCacheDelta>(m_cacheDelta, std::move(readLock));
        }
 
    private:
        TCacheDelta m_cacheDelta;
        size_t m_initialCommitCount;
        const size_t& m_commitCounter;
        utils::SpinReaderWriterLock& m_lock;
    };
 
    // endregion
 
    // region SynchronizedCache
 
    template<typename TCache>
    class SynchronizedCache {
    public:
        using CacheValueType = typename TCache::CacheValueType;
        using CacheViewType = typename TCache::CacheViewType;
        using CacheDeltaType = typename TCache::CacheDeltaType;
        using CacheReadOnlyType = typename TCache::CacheReadOnlyType;
 
    public:
        explicit SynchronizedCache(TCache&& cache)
                : m_cache(std::move(cache))
                , m_commitCounter(0)
        {}
 
    public:
        LockedCacheView<CacheViewType> createView() const {
            auto readLock = m_lock.acquireReader();
            return LockedCacheView<CacheViewType>(m_cache.createView(), std::move(readLock));
        }
 
        LockedCacheDelta<CacheDeltaType> createDelta() {
            auto readLock = m_lock.acquireReader();
 
            // notice that this is not a foolproof check since multiple threads could create multiple deltas at the same time
            // but it is good enough as a sanity check
            if (m_pWeakDeltaPair.lock())
                CATAPULT_THROW_RUNTIME_ERROR("only a single attached delta of a cache is allowed at a time");
 
            auto delta = m_cache.createDelta();
            auto pPair = std::make_shared<detail::CacheViewReadLockPair<CacheDeltaType>>(std::move(delta), std::move(readLock));
            m_pWeakDeltaPair = pPair;
            return LockedCacheDelta<CacheDeltaType>(pPair);
        }
 
        LockableCacheDelta<CacheDeltaType> createDetachedDelta() const {
            auto readLock = m_lock.acquireReader();
            auto delta = m_cache.createDetachedDelta();
            return LockableCacheDelta<CacheDeltaType>(std::move(delta), m_commitCounter, m_lock);
        }
 
        void commit() {
            auto pDeltaPair = m_pWeakDeltaPair.lock();
            if (!pDeltaPair)
                CATAPULT_THROW_RUNTIME_ERROR("attempting to commit changes to a cache without any outstanding attached deltas");
 
            auto writeLock = pDeltaPair->ReadLock.promoteToWriter();
            m_cache.commit(pDeltaPair->CacheView);
            ++m_commitCounter;
        }
 
    protected:
        TCache& cache() {
            return m_cache;
        }
 
    private:
        TCache m_cache;
        size_t m_commitCounter;
        std::weak_ptr<detail::CacheViewReadLockPair<CacheDeltaType>> m_pWeakDeltaPair;
        mutable utils::SpinReaderWriterLock m_lock;
    };
 
    // endregion
 
    // region SynchronizedCacheWithInit
 
    template<typename TCache>
    class SynchronizedCacheWithInit : public SynchronizedCache<TCache> {
    public:
        explicit SynchronizedCacheWithInit(TCache&& cache)
                : SynchronizedCache<TCache>(std::move(cache))
                , m_isInitCalled(false)
        {}
 
    public:
        template<typename... TArgs>
        void init(TArgs&&... args) {
            if (m_isInitCalled)
                CATAPULT_THROW_RUNTIME_ERROR("init has already been called for cache");
 
            this->cache().init(std::forward<TArgs>(args)...);
            m_isInitCalled = true;
        }
 
    private:
        bool m_isInitCalled;
    };
 
    // endregion
}}