evaluator_proxy.tcc

Go to the documentation of this file.

 
#if !defined(ULTRA_EVALUATOR_PROXY_H)
#  error "Don't include this file directly, include the specific .h instead"
#endif
 
#if !defined(ULTRA_EVALUATOR_PROXY_TCC)
#define      ULTRA_EVALUATOR_PROXY_TCC

template<Evaluator E>
evaluator_proxy<E>::evaluator_proxy(E eva, bitwidth ts) : eva_(std::move(eva)),
                                                          cache_(ts)
{
  static_assert(!std::derived_from<E, evaluator_proxy>);
 
  if (!ts)
    ultraWARNING("Evaluator proxy cache is disabled");
}

template<Evaluator E>
evaluator_fitness_t<E> evaluator_proxy<E>::operator()(
  const evaluator_individual_t<E> &prg) const
{
  if (!cache_.bits())
    return eva_(prg);
 
  if (const auto cached_fit(cache_.find(prg.signature())); cached_fit)
  {
    // Hash collision checking code can severely slow down the program.
#if !defined(NDEBUG)
    const auto effective_fit(eva_(prg));
 
    if (!almost_equal(*cached_fit, effective_fit))  [[unlikely]]
    {
      ultraERROR("COLLISION [{} != {}]",
                 internal::streamed(*cached_fit),
                 internal::streamed(effective_fit));
      return effective_fit;
    }
 
    // The above comparison may produce false positives.
    // E.g. it fails if a component of the fitness is function of the program's
    // length.
    // For example if the fitness is a 2D vector (where the first component
    // is the "score" on the training set and the second one is the effective
    // length of the program), then the following two programs:
    //
    // PROGRAM A                 PROGRAM B
    // ------------------        ------------------
    // [000] FADD 3 3            [000] FADD 3 3
    // [001] FADD 3 3            [001] FADD [000] [000]
    // [002] FADD [000] [001]
    //
    // have the same signature, the same stored "score" but distinct
    // effective size and so distinct fitnesses.
#endif
 
    return *cached_fit;
  }
 
  // Not found in cache.
  const auto effective_fit(eva_(prg));
  cache_.insert(prg.signature(), effective_fit);
 
  return effective_fit;
}

template<Evaluator E>
evaluator_fitness_t<E> evaluator_proxy<E>::fast(
  const evaluator_individual_t<E> &prg) const
{
  if constexpr (requires { eva_.fast(prg); })
    return eva_.fast(prg);
 
  return operator()(prg);
}

template<Evaluator E>
bool evaluator_proxy<E>::load_cache(std::istream &in) const
{
  return cache_.load(in);
}

template<Evaluator E>
bool evaluator_proxy<E>::load(std::istream &in)
{
  return load_eva(in, &eva_) && load_cache(in);
}

// \param[out] out output stream
template<Evaluator E>
bool evaluator_proxy<E>::save_cache(std::ostream &out) const
{
  return cache_.save(out);
}

template<Evaluator E>
bool evaluator_proxy<E>::save(std::ostream &out) const
{
  return save_eva(out, eva_) && save_cache(out);
}

template<Evaluator E>
void evaluator_proxy<E>::clear() const noexcept
{
  cache_.clear();
}

template<Evaluator E>
void evaluator_proxy<E>::clear(const hash_t &h) const
{
  cache_.clear(h);
}

template<Evaluator E>
bool evaluator_proxy<E>::set_parallel_evaluation(unsigned helpers,
                                                 std::size_t min_samples)
{
  if constexpr (requires {eva_.set_parallel_evaluation(helpers, min_samples);})
    return eva_.set_parallel_evaluation(helpers, min_samples);
 
  return false;
}

template<Evaluator E>
const E &evaluator_proxy<E>::core() const noexcept
{
  return eva_;
}
 
#endif  // include guard