TT.h

Go to the documentation of this file.

#pragma once

 
#include "../Types.h"
#include <atomic>
#include <cstdint>
#include <optional>

enum class Bound : uint8_t {
  NONE = 0,      
  UPPER = 1,     
  LOWER = 2,     
  EXACT = 3,     
  LAZY_MASK = 4  
};

struct TTEntry {
  uint64_t data;      
  uint64_t signature; 

  bool probe(uint64_t key, uint64_t &out_data) const {
    uint64_t d = __atomic_load_n(&data, __ATOMIC_RELAXED);
    uint64_t s = __atomic_load_n(&signature, __ATOMIC_RELAXED);
    if ((s ^ d) == key) {
      out_data = d;
      return true;
    }
    return false;
  }

  void save(uint64_t key, int16_t score, int16_t sEval, uint8_t depth,
            Bound bound, uint16_t move, uint8_t age) {
    uint64_t newData =
        (static_cast<uint64_t>(move) << 48) |
        (static_cast<uint64_t>(static_cast<uint16_t>(score)) << 32) |
        (static_cast<uint64_t>(static_cast<uint16_t>(sEval)) << 16) |
        (static_cast<uint64_t>(depth) << 8) |
        (static_cast<uint64_t>(static_cast<uint8_t>(bound) & 0x7) << 5) |
        (age & 0x1F);
 
    __atomic_store_n(&signature, key ^ newData, __ATOMIC_RELAXED);
    __atomic_store_n(&data, newData, __ATOMIC_RELAXED);
  }
 
  // Helpers for extracting fields
  static uint16_t getMove(uint64_t d) { return static_cast<uint16_t>(d >> 48); }
  static int16_t getScore(uint64_t d) { return static_cast<int16_t>((d >> 32) & 0xFFFF); }
  static int16_t getStaticEval(uint64_t d) { return static_cast<int16_t>((d >> 16) & 0xFFFF); }
  static uint8_t getDepth(uint64_t d) { return static_cast<uint8_t>((d >> 8) & 0xFF); }
  static Bound getBound(uint64_t d) { return static_cast<Bound>((d >> 5) & 0x7); }
  static uint8_t getAge(uint64_t d) { return static_cast<uint8_t>(d & 0x1F); }
};

struct alignas(16) EvalEntry {
  std::atomic<uint64_t> payload;   
  std::atomic<uint64_t> signature; 

  void store(uint64_t key, int16_t score) {
    uint64_t p = static_cast<uint64_t>(static_cast<uint16_t>(score));
    uint64_t s = key ^ p;
    signature.store(s, std::memory_order_relaxed);
    payload.store(p, std::memory_order_relaxed);
  }

  bool probe(uint64_t key, int16_t &score) const {
    uint64_t p = payload.load(std::memory_order_relaxed);
    uint64_t s = signature.load(std::memory_order_relaxed);
    if ((s ^ p) == key) {
      score = static_cast<int16_t>(p & 0xFFFF);
      return true;
    }
    return false;
  }
};

struct alignas(64) Cluster {
  TTEntry entries[3]; 
  EvalEntry eval;     
};
static_assert(sizeof(Cluster) == 64, "Cluster must be exactly 64 bytes");

class TranspositionTable {
private:
  Cluster *table_ = nullptr; 
  size_t clusterCount_ = 0;  
  size_t indexMask_ = 0;     
  uint8_t currentAge_ = 0;   
  bool disableTT_ = false;   
  int numThreads_ = 1;       
  bool usingHugePages_ = false; 
 
public:
  TranspositionTable() = default;
  ~TranspositionTable();

  void resize(size_t mb);

  void clear();

  void newSearch() { currentAge_ = (currentAge_ + 1) & 0x1F; }
 
  void setDisabled(bool disabled) { disableTT_ = disabled; }
  void setNumThreads(int n) { numThreads_ = n; }

  int hashfull() const;

  void prefetch(uint64_t key) const;

  bool probe(uint64_t key, int depth, int &score, Move &bestMove,
             int &entryDepth, Bound &entryBound) const;

  Move probeMove(uint64_t key) const;

  std::optional<int> probeScore(uint64_t key) const;

  bool probeEval(uint64_t key, int16_t &score) const;

  void storeEval(uint64_t key, int16_t score);

  void store(uint64_t key, int depth, int score, Bound bound, Move bestMove,
             int staticEval = 0);
 
  // Persistence and debugging
  void dumpToFile(const std::string &filename) const;
  bool saveFullToFile(const std::string &filename) const;
  bool loadFullFromFile(const std::string &filename);
 
private:
  size_t index(uint64_t key) const { return key & indexMask_; }
  int ageDiff(uint8_t entryAge) const {
    return (currentAge_ >= entryAge) ? (currentAge_ - entryAge)
                                     : (32 - entryAge + currentAge_);
  }
};