cache.h

Go to the documentation of this file.

 
#if !defined(ULTRA_CACHE_H)
#define      ULTRA_CACHE_H
 
#include <algorithm>
#include <bit>
#include <mutex>
#include <optional>
#include <shared_mutex>
#include <vector>
 
#include "kernel/fitness.h"
#include "kernel/hash_t.h"
 
namespace ultra
{

using bitwidth = unsigned;


template<Fitness F, std::size_t LOCK_GROUP_SIZE = 128>
class cache
{
public:
  // ---- Constructors ----
  cache() = default;  // empty cache
  explicit cache(bitwidth);
 
  // ---- Capacity ----
  [[nodiscard]] bitwidth bits() const;
 
  // ---- Modifiers ----
  void resize(bitwidth);
  void clear() noexcept;
  void clear(const hash_t &);
  void insert(const hash_t &, const F &);
 
  // ---- Misc ----
  [[nodiscard]] std::optional<F> find(const hash_t &) const;
 
  [[nodiscard]] bool is_valid() const;
 
  // ---- Serialization ----
  bool load(std::istream &);
  bool save(std::ostream &) const;
 
private:
  static constexpr bitwidth max_cache_bitwidth {30}; // about 1 billion slots
 
  // ---- Private support methods ----
  [[nodiscard]] std::size_t index(const hash_t &) const noexcept;
  [[nodiscard]] std::size_t lock_index(std::size_t) const noexcept;
  [[nodiscard]] static std::size_t table_size(bitwidth);
 
  // ---- Private data members ----
  struct slot
  {
    hash_t hash;
    F fitness;
    unsigned seal {0};
  };
 
  std::vector<slot> table_ {};
  mutable std::vector<std::shared_mutex> locks_ {};  // group-level locks
 
  std::uint64_t k_mask {0};
  decltype(slot::seal) seal_ {1};
 
  // Check the number of slots per lock.
  static_assert(LOCK_GROUP_SIZE > 0, "LOCK_GROUP_SIZE must be greater than 0");
};
 
#include "kernel/cache.tcc"
 
}  // namespace ultra
 
#endif  // include guard