cache.cc

Go to the documentation of this file.

 
#include <mutex>
 
#include "kernel/cache.h"
 
namespace vita
{
cache::cache(unsigned bits) : mutex_(), k_mask((1ull << bits) - 1),
                              table_(1ull << bits), seal_(1)
{
  Expects(bits);
  Ensures(is_valid());
}
 
inline std::size_t cache::index(const hash_t &h) const
{
  return h.data[0] & k_mask;
}
 
void cache::clear()
{
  std::unique_lock lock(mutex_);
 
  ++seal_;
 
  // for (auto &s : table_)
  // {
  //   s.hash = hash_t();
  //   s.fitness = {};
  // }
}
 
void cache::clear(const hash_t &h)
{
  std::unique_lock lock(mutex_);
 
  table_[index(h)].hash = hash_t();
 
  // An alternative to invalidate the slot:
  //   table_[index(h)].seal = 0;
  // It works because the first valid seal is 1.
}
 
const fitness_t &cache::find(const hash_t &h) const
{
  std::shared_lock lock(mutex_);
 
  const slot &s(table_[index(h)]);
  const bool ret(seal_ == s.seal && h == s.hash);
 
  if (ret)
    return s.fitness;
 
  static const fitness_t empty{};
  return empty;
}
 
void cache::insert(const hash_t &h, const fitness_t &fitness)
{
  std::unique_lock lock(mutex_);
 
  slot s;
  s.hash    =       h;
  s.fitness = fitness;
  s.seal    =   seal_;
 
  table_[index(s.hash)] = s;
}
 
bool cache::load(std::istream &in)
{
  std::unique_lock lock(mutex_);
 
  decltype(seal_) t_seal;
  if (!(in >> t_seal))
    return false;
 
  std::size_t n;
  if (!(in >> n))
    return false;
 
  for (decltype(n) i(0); i < n; ++i)
  {
    slot s;
    s.seal = t_seal;
 
    if (!s.hash.load(in))
      return false;
    if (!s.fitness.load(in))
      return false;
 
    table_[index(s.hash)] = s;
  }
 
  seal_ = t_seal;
 
  return true;
}
 
bool cache::save(std::ostream &out) const
{
  std::shared_lock lock(mutex_);
 
  out << seal_ << ' ' << '\n';
 
  std::size_t num(0);
  for (const auto &s : table_)
    if (!s.hash.empty())
      ++num;
  out << num << '\n';
 
  for (const auto &s : table_)
    if (s.seal == seal_ && !s.hash.empty())
    {
      s.hash.save(out);
      s.fitness.save(out);
    }
 
  return out.good();
}
 
bool cache::is_valid() const
{
  return true;
}
 
}  // namespace vita