ConcurrentCache.hpp

#pragma once
 
#include <mutex>
#include <shared_mutex>
#include <thread>
#include <tuple>
#include <type_traits>
#include <unordered_map>
 
#include <dune/common/hash.hh>
 
namespace AMDiS
{
  template <class Container>
  struct ConsecutivePolicy;
 
  template <class Container>
  struct ThreadLocalPolicy;
 
  template <class Container>
  struct StaticLockedPolicy;
 
 
 
  template <class Key,
            class Data,
            template <class> class Policy = ThreadLocalPolicy,
            class Container = std::unordered_map<Key, Data>>
  class ConcurrentCache;
 
 
#ifdef DOXYGEN
 
  template <class Container>
  class ConcurrentCachePolicy;
#endif
 
  // implementation of the consecutive policy. Data is stored in instance variable.
  template <class Container>
  struct ConsecutivePolicy
  {
    using key_type = typename Container::key_type;
    using data_type = typename Container::mapped_type;
    using container_type = Container;
 
    template <class F, class... Args>
    data_type const& get_or_init(key_type const& key, F&& f, Args&&... args) const
    {
      return impl(std::is_default_constructible<data_type>{}, key, FWD(f), FWD(args)...);
    }
 
  private:
    // data_type is default_constructible
    template <class F, class... Args>
    data_type const& impl(std::true_type, key_type const& key, F&& f, Args&&... args) const
    {
      data_type empty;
      auto it = cachedData_.emplace(key, std::move(empty));
      if (it.second) {
        data_type data = f(key, FWD(args)...);
        it.first->second = std::move(data);
      }
      return it.first->second;
    }
 
    // data_type is not default_constructible
    template <class F, class... Args>
    data_type const& impl(std::false_type, key_type const& key, F&& f, Args&&... args) const
    {
      auto it = cachedData_.find(key);
      if (it != cachedData_.end())
        return it->second;
      else {
        data_type data = f(key, FWD(args)...);
        auto it = cachedData_.emplace(key, std::move(data));
        return it.first->second;
      }
    }
 
    mutable container_type cachedData_;
  };
 
 
  // implementation of the ThreadLocal policy. Data is stored in thread_local variable.
  template <class Container>
  struct ThreadLocalPolicy
  {
    using key_type = typename Container::key_type;
    using data_type = typename Container::mapped_type;
    using container_type = Container;
 
    template <class F, class... Args>
    static data_type const& get_or_init(key_type const& key, F&& f, Args&&... args)
    {
      return impl(std::is_default_constructible<data_type>{}, key, FWD(f), FWD(args)...);
    }
 
  private:
    // data_type is default_constructible
    template <class F, class... Args>
    static data_type const& impl(std::true_type, key_type const& key, F&& f, Args&&... args)
    {
      // Container to store the cached values
      thread_local container_type cached_data;
 
      data_type empty;
      auto it = cached_data.emplace(key, std::move(empty));
      if (it.second) {
        data_type data = f(key, FWD(args)...);
        it.first->second = std::move(data);
      }
      return it.first->second;
    }
 
    // data_type is not default_constructible
    template <class F, class... Args>
    static data_type const& impl(std::false_type, key_type const& key, F&& f, Args&&... args)
    {
      // Container to store the cached values
      thread_local container_type cached_data;
 
      auto it = cached_data.find(key);
      if (it != cached_data.end())
        return it->second;
      else {
        data_type data = f(key, FWD(args)...);
        auto it = cached_data.emplace(key, std::move(data));
        return it.first->second;
      }
    }
  };
 
 
  // implementation of the Shared policy. Data is stored in static variable.
  template <class Container>
  struct StaticLockedPolicy
  {
    using key_type = typename Container::key_type;
    using data_type = typename Container::mapped_type;
    using container_type = Container;
 
    template <class F, class... Args>
    static data_type const& get_or_init(key_type const& key, F&& f, Args&&... args)
    {
      // Container to store the cached values
      static container_type cached_data;
 
      // mutex used to access the data in the container, necessary since
      // access emplace is read-write.
      using mutex_type = std::shared_timed_mutex;
      static mutex_type access_mutex;
 
      // first try to lock for read-only, if an element for key is found, return it,
      // if not, obtain a unique_lock to insert a new element and initialize it.
      std::shared_lock<mutex_type> read_lock(access_mutex);
      auto it = cached_data.find(key);
      if (it != cached_data.end())
        return it->second;
      else {
        read_lock.unlock();
        data_type data = f(key, FWD(args)...);
        std::unique_lock<mutex_type> write_lock(access_mutex);
        auto new_it = cached_data.emplace(key, std::move(data));
        return new_it.first->second;
      }
    }
  };
 
 
  template <class Key, class Data, template <class> class Policy, class Container>
  class ConcurrentCache
      : protected Policy<Container>
  {
    using key_type = Key;
    using data_type = Data;
 
  public:
 
 
    template <class F, class... Args>
    data_type const& get(key_type const& key, F&& f, Args&&... args) const
    {
      static_assert(std::is_invocable_r_v<data_type, F, key_type, Args...>,
        "Functor F must have the signature data_type(key_type, Args...)");
 
      return ConcurrentCache::get_or_init(key, FWD(f), FWD(args)...);
    }
  };
 
} // end namespace AMDiS