TranspositionTable.hpp

Go to the documentation of this file.

/*
 * ======================================================================================
 *
 * ░▒▓███████▓▒░░▒▓████████▓▒░▒▓███████▓▒░       ░▒▓███████▓▒░ ░▒▓██████▓▒░▒▓████████▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓███████▓▒░░▒▓██████▓▒░ ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓███████▓▒░░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░ ░▒▓█▓▒░
 * ░▒▓███████▓▒░░▒▓████████▓▒░▒▓█▓▒░░▒▓█▓▒░      ░▒▓███████▓▒░ ░▒▓██████▓▒░  ░▒▓█▓▒░
 *
 * ======================================================================================
 */


 
#pragma once
 
#include <cstddef> // IWYU pragma: keep - for size_t
#include <cstdint> // IWYU pragma: keep - for std::uint_least8_t
#include <libbenbot/eval/Score.hpp>
#include <libchess/moves/Move.hpp>
#include <optional>
#include <span>
#include <utility>
 
namespace chess::game {
struct Position;
} // namespace chess::game
 
namespace ben_bot {
 
namespace search {
    struct Bounds;
} // namespace search
 
using chess::game::Position;
using chess::moves::Move;
using std::size_t;

enum class EvalType : std::uint_least8_t {
    Exact, 
    Alpha, 
    Beta   
};

struct [[nodiscard]] TTData final {
    size_t searchedDepth { 0uz };

    eval::Value eval { UINT16_C(0) };

    EvalType evalType { EvalType::Alpha };

    std::optional<Move> bestMove;
 
    constexpr auto operator==(const TTData& other) const noexcept -> bool = default;
};

class TranspositionTable final {
public:
    explicit TranspositionTable(const size_t initialSize = 16uz)
    {
        resize(initialSize);
    }
 
    ~TranspositionTable() { deallocate(); }
 
    TranspositionTable(const TranspositionTable&)            = delete;
    TranspositionTable& operator=(const TranspositionTable&) = delete;
 
    TranspositionTable(TranspositionTable&& other) noexcept;
    TranspositionTable& operator=(TranspositionTable&& other) noexcept;

    [[nodiscard]] auto find(const Position& pos) const -> std::optional<TTData>;

    using ProbedEval = std::pair<eval::Value, EvalType>;

    [[nodiscard]] auto probe_eval(
        const Position& pos, size_t depth, const search::Bounds& bounds) const
        -> std::optional<ProbedEval>;

    [[nodiscard]] auto get_best_response(
        const Position& pos, Move move) const
        -> std::optional<Move>;

    void store(const Position& pos, const TTData& record);

    void clear();

    [[clang::reinitializes]] void resize(size_t sizeMB);

    [[nodiscard]] auto hashfull() const -> size_t;

    void new_search() noexcept;

    void prefetch(const Position& pos) const noexcept;
 
private:
    struct Entry;
    struct Cluster;
 
    void deallocate();
 
    [[nodiscard]] auto index_table(size_t clusterIdx) const noexcept -> Cluster&;
 
    // this is the hash function
    [[nodiscard]] auto find_cluster(std::uint64_t key) const noexcept -> std::span<Entry>;
 
    Cluster* table { nullptr };
 
    size_t clusterCount { 0uz };
 
    std::uint8_t generation { UINT8_C(0) };
};
 
} // namespace ben_bot