cache_set.hpp

Go to the documentation of this file.

// Copyright (c) 2021 MIT Digital Currency Initiative
//                    Federal Reserve Bank of Boston
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef CACHE_SET_H_INC
#define CACHE_SET_H_INC
 
#include <cassert>
#include <queue>
#include <shared_mutex>
#include <unordered_set>
 
namespace cbdc {
    template<typename K, typename H = std::hash<K>>
    class cache_set {
      public:
        cache_set() = delete;
 
        explicit cache_set(size_t max_size) : m_max_size(max_size) {
            m_vals.max_load_factor(std::numeric_limits<float>::max());
            static constexpr auto buckets_factor = 2;
            m_vals.rehash(buckets_factor * max_size);
        };
 
        template<typename T>
        auto add(T&& val) -> bool {
            std::unique_lock<std::shared_mutex> l(m_mut);
            auto added = m_vals.emplace(std::forward<T>(val));
            if(added.second) {
                m_eviction_queue.push(std::ref(*added.first));
                if(m_eviction_queue.size() >= m_max_size) {
                    auto& v = m_eviction_queue.front();
                    m_vals.erase(v);
                    m_eviction_queue.pop();
                }
            }
            assert(m_eviction_queue.size() <= m_max_size);
            return added.second;
        }
 
        [[nodiscard]] auto contains(const K& val) const -> bool {
            std::shared_lock<std::shared_mutex> l(m_mut);
            return m_vals.find(val) != m_vals.end();
        }
 
      private:
        std::unordered_set<K, H> m_vals;
        std::queue<std::reference_wrapper<const K>> m_eviction_queue;
        size_t m_max_size;
        mutable std::shared_mutex m_mut;
    };
}
 
#endif