exec_policy.h

#ifndef ADIAR_EXEC_POLICY_H
#define ADIAR_EXEC_POLICY_H
 
#include <algorithm>
#include <limits>
 
#include <adiar/type_traits.h>
 
namespace adiar
{
 
  class exec_policy
  {
  public:
    enum class access : char
    {
      Auto,
      Random_Access,
      Priority_Queue
    };
 
    enum class memory : char
    {
      Auto,
      Internal,
      External
    };
 
    class quantify
    {
    public:
      enum algorithm : char
      {
        Nested,
        Singleton
      };
 
      class transposition_growth
      {
      private:
        static constexpr float min_val = 0.0f;
 
      public:
        static constexpr transposition_growth
        min()
        {
          return min_val;
        }
 
        static constexpr transposition_growth
        max()
        {
          return std::numeric_limits<float>::max();
        }
 
      private:
        float _value;
 
        static constexpr float
        from_float(float f)
        {
          // Truncate `f` to be in the interval [0.0f, ...)
          return f < min_val ? min_val : f;
        }
 
      public:
        constexpr transposition_growth()
          : _value(1.5f)
        {}
 
        constexpr transposition_growth(float value)
          : _value(from_float(value))
        {}
 
        operator float() const
        {
          return this->_value;
        }
      };
 
      class transposition_max
      {
      public:
        static constexpr transposition_max
        min()
        {
          return std::numeric_limits<unsigned char>::min();
        }
 
        static constexpr transposition_max
        max()
        {
          return std::numeric_limits<unsigned char>::max();
        }
 
      private:
        unsigned char _value;
 
      public:
        constexpr transposition_max()
          : _value(std::numeric_limits<unsigned char>::min())
        {}
 
        constexpr transposition_max(unsigned char value)
          : _value(value)
        {}
 
        operator unsigned char() const
        {
          return this->_value;
        }
      };
    };
 
  private:
    // TODO: Merge all enums into a single 64 bit integer to safe on space?
 
    access _access = access::Auto;
 
    memory _memory = memory::Auto;
 
    quantify::algorithm _quantify__algorithm = quantify::Nested;
 
    quantify::transposition_growth _quantify__transposition_growth /*default*/;
 
    quantify::transposition_max _quantify__transposition_max /*default*/;
    ;
 
  public:
    exec_policy() = default;
 
    exec_policy(const exec_policy&) = default;
 
    exec_policy(exec_policy&&) = default;
 
    exec_policy(const access& am)
      : _access(am)
    {}
 
    exec_policy(const memory& mm)
      : _memory(mm)
    {}
 
    exec_policy(const quantify::algorithm& qa)
      : _quantify__algorithm(qa)
    {}
 
    exec_policy(const quantify::transposition_growth& tg)
      : _quantify__transposition_growth(tg)
    {}
 
    exec_policy(const quantify::transposition_max& tm)
      : _quantify__transposition_max(tm)
    {}
 
    // TODO: constructor with defaults for a specific 'version number'?
 
  public:
    exec_policy&
    operator=(const exec_policy&) = default;
 
    exec_policy&
    operator=(exec_policy&&) = default;
 
  public:
    template <typename T>
    const T&
    get() const;
 
  public:
    bool
    operator==(const exec_policy& ep) const
    {
      // Order based from the most generic to the most specific setting.
      return this->_memory == ep._memory && this->_access == ep._access
        && this->_quantify__algorithm == ep._quantify__algorithm
        && this->_quantify__transposition_growth == ep._quantify__transposition_growth
        && this->_quantify__transposition_max == ep._quantify__transposition_max;
    }
 
    bool
    operator!=(const exec_policy& ep) const
    {
      return !(*this == ep);
    }
 
  public:
    exec_policy&
    set(const access& am)
    {
      this->_access = am;
      return *this;
    }
 
    exec_policy
    operator&(const access& am) const
    {
      exec_policy ep = *this;
      return ep.set(am);
    }
 
    exec_policy&
    set(const memory& mm)
    {
      this->_memory = mm;
      return *this;
    }
 
    exec_policy
    operator&(const memory& mm) const
    {
      exec_policy ep = *this;
      return ep.set(mm);
    }
 
    exec_policy&
    set(const quantify::algorithm& qa)
    {
      this->_quantify__algorithm = qa;
      return *this;
    }
 
    exec_policy
    operator&(const quantify::algorithm& qa) const
    {
      exec_policy ep = *this;
      return ep.set(qa);
    }
 
    exec_policy&
    set(const quantify::transposition_growth& tg)
    {
      this->_quantify__transposition_growth = tg;
      return *this;
    }
 
    exec_policy
    operator&(const quantify::transposition_growth& tg) const
    {
      exec_policy ep = *this;
      return ep.set(tg);
    }
 
    exec_policy&
    set(const quantify::transposition_max& tm)
    {
      this->_quantify__transposition_max = tm;
      return *this;
    }
 
    exec_policy
    operator&(const quantify::transposition_max& tm) const
    {
      exec_policy ep = *this;
      return ep.set(tm);
    }
  };
 
  template <>
  inline const exec_policy::access&
  exec_policy::get<exec_policy::access>() const
  {
    return this->_access;
  }
 
  template <>
  inline const exec_policy::memory&
  exec_policy::get<exec_policy::memory>() const
  {
    return this->_memory;
  }
 
  template <>
  inline const exec_policy::quantify::algorithm&
  exec_policy::get<exec_policy::quantify::algorithm>() const
  {
    return this->_quantify__algorithm;
  }
 
  template <>
  inline const exec_policy::quantify::transposition_growth&
  exec_policy::get<exec_policy::quantify::transposition_growth>() const
  {
    return this->_quantify__transposition_growth;
  }
 
  template <>
  inline const exec_policy::quantify::transposition_max&
  exec_policy::get<exec_policy::quantify::transposition_max>() const
  {
    return this->_quantify__transposition_max;
  }
 
 
 
  template <
    typename A,
    typename B,
    typename = enable_if<needs_conversion<A, exec_policy> && needs_conversion<B, exec_policy>>>
  exec_policy
  operator&(const A& a, const B& b)
  {
    return exec_policy(a) & b;
  }
 
}
 
#endif // ADIAR_EXEC_POLICY_H