ConcurrentParam.h

#pragma once
 
#include "GlobalParam.h"
 
namespace iguana {

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

  template <typename T>
  class ConcurrentParam
  {
 
    public:

      ConcurrentParam(std::string const& model);
      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;

      bool NeedsHashing() const { return m_needs_hashing; }

      virtual std::size_t GetSize() const = 0;

      bool IsEmpty() const { return m_empty; }
 
    protected:

      bool m_needs_hashing;

      std::mutex m_mutex;

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

  template <typename T>
  class SingleThreadParam : public ConcurrentParam<T>
  {
 
    public:
      SingleThreadParam();
      ~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;
      std::size_t GetSize() const override;
 
    private:

      T m_value;
  };
 
  // ==================================================================================
  // MemoizedParam
  // ==================================================================================

  template <typename T>
  class MemoizedParam : public ConcurrentParam<T>
  {

      using container_t = std::unordered_map<concurrent_key_t, T>;
 
    public:
      MemoizedParam();
      ~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;
      std::size_t GetSize() const override;
 
    private:

      container_t m_container;
  };
 
  // ==================================================================================
  // ConcurrentParamFactory
  // ==================================================================================

  class ConcurrentParamFactory
  {
 
    public:
      ConcurrentParamFactory() = delete;

      template <typename T>
      static std::unique_ptr<ConcurrentParam<T>> Create()
      {
 
        if(GlobalConcurrencyModel() == "none")
          GlobalConcurrencyModel = "memoize"; // the safest default, but not the fastest for single-threaded users
 
        if(GlobalConcurrencyModel() == "single")
          return std::make_unique<SingleThreadParam<T>>();
        else if(GlobalConcurrencyModel() == "memoize")
          return std::make_unique<MemoizedParam<T>>();
 
        throw std::runtime_error("unknown GlobalConcurrencyModel '" + GlobalConcurrencyModel() + "'; valid options are 'single' or 'memoize'");
      }
  };
 
}