ConcurrentParam.h

Go to the documentation of this file.

#pragma once
 
#include "GlobalParam.h"
#include <shared_mutex>
 
namespace iguana {

  using concurrent_key_t = std::size_t;
 
  // ==================================================================================
  // ConcurrentParam
  // ==================================================================================

  template <typename T>
  class ConcurrentParam
  {
 
    public:

      ConcurrentParam(std::string const& model, std::string const& name);
      virtual ~ConcurrentParam() = default;

      virtual T const Load(concurrent_key_t const key) const = 0;

      virtual void Save(T const& value, concurrent_key_t const key) = 0;

      virtual bool HasKey(concurrent_key_t const key) const = 0;

      virtual bool NeedsUpdate(T const& value, concurrent_key_t const key) const = 0;
 
    protected:

      mutable std::shared_mutex m_mutex;

      std::string const m_name;
  };
 
  // ==================================================================================
  // SingleThreadParam
  // ==================================================================================

  template <typename T>
  class SingleThreadParam : public ConcurrentParam<T>
  {
 
    public:
      SingleThreadParam(std::string const& name);
      ~SingleThreadParam() override = default;
      T const Load(concurrent_key_t const key) const override;
      void Save(T const& value, concurrent_key_t const key) override;
      bool HasKey(concurrent_key_t const key) const override;
      bool NeedsUpdate(T const& value, concurrent_key_t const key) const override;
 
    private:

      T m_value;

      bool m_empty{true};
  };
 
  // ==================================================================================
  // MemoizedParam
  // ==================================================================================

  template <typename T>
  class MemoizedParam : public ConcurrentParam<T>
  {
 
    public:
      MemoizedParam(std::string const& name);
      ~MemoizedParam() override = default;
      T const Load(concurrent_key_t const key) const override;
      void Save(T const& value, concurrent_key_t const key) override;
      bool HasKey(concurrent_key_t const key) const override;
      bool NeedsUpdate(T const& value, concurrent_key_t const key) const override;
 
    private:

      std::unordered_map<concurrent_key_t, T> m_container;
  };
 
 
  // ==================================================================================
  // ConcurrentParamFactory
  // ==================================================================================

  class ConcurrentParamFactory
  {
 
    public:
      ConcurrentParamFactory() = delete;

      static void CheckConcurrencyModel()
      {
        if(GlobalConcurrencyModel() == "none")
          GlobalConcurrencyModel = "memoize"; // the safest default, but not the fastest for single-threaded users
        if(GlobalConcurrencyModel() != "single" && GlobalConcurrencyModel() != "memoize")
          throw std::runtime_error("unknown GlobalConcurrencyModel '" + GlobalConcurrencyModel() + "'; valid options are 'single' or 'memoize'");
      }

      template <typename T>
      static std::unique_ptr<ConcurrentParam<T>> Create(std::string const& name)
      {
        CheckConcurrencyModel();
        if(GlobalConcurrencyModel() == "single")
          return std::make_unique<SingleThreadParam<T>>(name);
        else
          return std::make_unique<MemoizedParam<T>>(name);
      }
  };
 
 
  // ==================================================================================
  // Keysmith
  // ==================================================================================

  template <typename... Ts>
  class Keysmith
  {
 
    public:

      Keysmith()
      {
        ConcurrentParamFactory::CheckConcurrencyModel();
        if(GlobalConcurrencyModel() == "single") {
          m_make_key = [](Ts const&... args) -> concurrent_key_t { return 0; };
        }
        else {
          m_make_key = [](Ts const&... args) -> concurrent_key_t {
            std::size_t seed = 0;
            (hash_combine(seed, args), ...);
            return seed;
          };
        }
      }

      concurrent_key_t MakeKey(Ts const&... args)
      {
        return m_make_key(args...);
      }
 
    private:

      template <typename T>
      static void hash_combine(std::size_t& seed, T const& value)
      {
        seed ^= std::hash<T>{}(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
      }

      std::function<concurrent_key_t(Ts...)> m_make_key;
  };
 
}