Skip to content

Commit

Permalink
tt_hash_table: less verbose method naming
Browse files Browse the repository at this point in the history 
Now that the TtHashTable is a class we don't need the verbose naming.
Also renamed the file to reflect the class name.

Signed-off-by: Hans Binderup <[email protected]>
  • Loading branch information
@hansbinderup
hansbinderup committed Mar 5, 2025
1 parent fb1cdcb commit 2e3443f
Show file tree
Hide file tree
Showing 4 changed files with 39 additions and 34 deletions.
8 changes: 4 additions & 4 deletions src/engine/tt_hash.h → src/engine/tt_hash_table.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,7 +23,7 @@ struct TtHashEntry {

class TtHashTable {
public:
static void clearTable()
static void clear()
{
std::ranges::fill(s_ttHashTable, TtHashEntry {});
s_hashCount = 0;
Expand All @@ -41,7 +41,7 @@ class TtHashTable {
return std::min((1000 * s_hashCount) / s_ttHashSize, 1000UL);
}

constexpr static std::optional<int32_t> readHashEntry(uint64_t key, int32_t alpha, int32_t beta, uint8_t depth, uint8_t ply)
constexpr static std::optional<int32_t> readEntry(uint64_t key, int32_t alpha, int32_t beta, uint8_t depth, uint8_t ply)
{
auto& entry = s_ttHashTable[key % s_ttHashSize];

Expand Down Expand Up @@ -83,7 +83,7 @@ class TtHashTable {
return std::nullopt;
}

constexpr static void writeHashEntry(uint64_t key, int32_t score, uint8_t depth, uint8_t ply, TtHashFlag flag)
constexpr static void writeEntry(uint64_t key, int32_t score, uint8_t depth, uint8_t ply, TtHashFlag flag)
{
auto& entry = s_ttHashTable[key % s_ttHashSize];

Expand All @@ -109,7 +109,7 @@ class TtHashTable {
constexpr static inline std::size_t s_ttHashSize { (s_hashTableSizeMb * 1024 * 1024) / sizeof(TtHashEntry) };
constexpr static inline uint8_t s_generationMask { 0xF }; /* 4-bit wrapping generation (max 16 generations allowed) */

static inline std::array<TtHashEntry, s_ttHashSize> s_ttHashTable;
static inline std::array<TtHashEntry, s_ttHashSize> s_ttHashTable; /* TODO: make dynamic so size can be adjusted from UCI */
static inline uint64_t s_hashCount {};
static inline uint8_t s_currentGeneration {};
};
Expand Down
8 changes: 4 additions & 4 deletions src/evaluation/evaluator.h
View file
Original file line number Diff line number Diff line change
@@ -1,7 +1,7 @@
#pragma once

#include "src/engine/move_handling.h"
#include "src/engine/tt_hash.h"
#include "src/engine/tt_hash_table.h"
#include "src/evaluation/material_scoring.h"
#include "src/evaluation/move_scoring.h"
#include "src/evaluation/pv_table.h"
Expand Down Expand Up @@ -241,7 +241,7 @@ class Evaluator {
}

const bool isPvNode = (beta - alpha) > 1;
const auto hashScore = engine::TtHashTable::readHashEntry(m_hash, alpha, beta, depth, m_ply);
const auto hashScore = engine::TtHashTable::readEntry(m_hash, alpha, beta, depth, m_ply);
if (!isPvNode && hashScore.has_value()) {
return hashScore.value();
}
Expand Down Expand Up @@ -336,7 +336,7 @@ class Evaluator {
return 0;

if (score >= beta) {
engine::TtHashTable::writeHashEntry(m_hash, score, depth, m_ply, engine::TtHashBeta);
engine::TtHashTable::writeEntry(m_hash, score, depth, m_ply, engine::TtHashBeta);
m_scoring.killerMoves().update(move, m_ply);
return beta;
}
Expand All @@ -362,7 +362,7 @@ class Evaluator {
}
}

engine::TtHashTable::writeHashEntry(m_hash, alpha, depth, m_ply, hashFlag);
engine::TtHashTable::writeEntry(m_hash, alpha, depth, m_ply, hashFlag);
return alpha;
}

Expand Down
8 changes: 6 additions & 2 deletions src/uci_handler.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,9 +21,13 @@ class UciHandler {
s_isRunning = true;

s_board.reset();
engine::TtHashTable::clearTable();
engine::TtHashTable::clear();
s_evaluator.reset();

/* const auto board = parsing::FenParser::parse("pk6/8/8/6Bb/8/PPPP4/8/PK6 w - - 0 0"); */
/* engine::printBoardDebug(s_fileLogger, board.value()); */
/* s_evaluator.printEvaluation(board.value(), 5); */

std::array<char, s_inputBufferSize> buffer;
while (s_isRunning && std::cin.getline(buffer.data(), buffer.size())) {
processInput(std::string_view(buffer.data()));
Expand Down Expand Up @@ -132,7 +136,7 @@ class UciHandler {
{
s_board.reset();
s_evaluator.reset();
engine::TtHashTable::clearTable();
engine::TtHashTable::clear();

return true;
}
Expand Down
49 changes: 25 additions & 24 deletions tests/src/test_tt_hash_table.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,9 +2,10 @@
#include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers.hpp>

#include <src/engine/tt_hash.h>
#define private public
#include <src/engine/tt_hash_table.h>

using namespace engine::tt;
using namespace engine;

constexpr int32_t alpha = -100;
constexpr int32_t beta = 100;
Expand All @@ -13,46 +14,46 @@ constexpr uint8_t ply = 2;

TEST_CASE("Transposition Table - Basic Write & Read", "[TT]")
{
clearTable();
TtHashTable::TtHashTable::clear();

uint64_t key = 0x123456789ABCDEF;
int32_t score = 42;

writeHashEntry(key, score, depth, ply, TtHashExact);
auto retrieved = readHashEntry(key, alpha, beta, depth, ply);
TtHashTable::writeEntry(key, score, depth, ply, TtHashExact);
auto retrieved = TtHashTable::TtHashTable::readEntry(key, alpha, beta, depth, ply);

REQUIRE(retrieved.has_value());
REQUIRE(retrieved.value() == score);
}

TEST_CASE("Transposition Table - Depth Overwrite Rule", "[TT]")
{
clearTable();
TtHashTable::clear();

uint64_t key = 0xDEADBEEFCAFEBABE;
int32_t oldScore = 10;
int32_t newScore = 50;

writeHashEntry(key, oldScore, 3, ply, TtHashExact);
writeHashEntry(key, newScore, 6, ply, TtHashExact); // Deeper depth
TtHashTable::writeEntry(key, oldScore, 3, ply, TtHashExact);
TtHashTable::writeEntry(key, newScore, 6, ply, TtHashExact); // Deeper depth

auto retrieved = readHashEntry(key, alpha, beta, 4, ply);
auto retrieved = TtHashTable::readEntry(key, alpha, beta, 4, ply);
REQUIRE(retrieved.has_value());
REQUIRE(retrieved.value() == newScore);
}

TEST_CASE("Transposition Table - Collision Handling", "[TT]")
{
clearTable();
TtHashTable::clear();

uint64_t key1 = 0x1111111111111111;
uint64_t key2 = key1 + s_ttHashSize; // Forces collision
uint64_t key2 = key1 + TtHashTable::s_ttHashSize; // Forces collision

writeHashEntry(key1, 30, depth, ply, TtHashExact);
writeHashEntry(key2, 99, depth, ply, TtHashExact);
TtHashTable::writeEntry(key1, 30, depth, ply, TtHashExact);
TtHashTable::writeEntry(key2, 99, depth, ply, TtHashExact);

auto retrieved1 = readHashEntry(key1, alpha, beta, depth, ply);
auto retrieved2 = readHashEntry(key2, alpha, beta, depth, ply);
auto retrieved1 = TtHashTable::readEntry(key1, alpha, beta, depth, ply);
auto retrieved2 = TtHashTable::readEntry(key2, alpha, beta, depth, ply);

REQUIRE_FALSE(retrieved1.has_value());

Expand All @@ -62,17 +63,17 @@ TEST_CASE("Transposition Table - Collision Handling", "[TT]")

TEST_CASE("Transposition Table - Score Clamping for Mating Scores", "[TT]")
{
clearTable();
TtHashTable::clear();

constexpr int32_t nearMate = s_mateValue - 10;

uint64_t key = 0xCAFEBABEDEADBEEF;

writeHashEntry(key, nearMate, depth, ply, TtHashExact);
TtHashTable::writeEntry(key, nearMate, depth, ply, TtHashExact);

SECTION("From same ply")
{
auto retrieved = readHashEntry(key, alpha, beta, depth, ply);
auto retrieved = TtHashTable::readEntry(key, alpha, beta, depth, ply);

REQUIRE(retrieved.has_value());
REQUIRE(retrieved.value() == nearMate); // same score
Expand All @@ -81,7 +82,7 @@ TEST_CASE("Transposition Table - Score Clamping for Mating Scores", "[TT]")
SECTION("From higher ply")
{
uint8_t plyOffset = 5;
auto retrieved = readHashEntry(key, alpha, beta, depth, ply + plyOffset);
auto retrieved = TtHashTable::readEntry(key, alpha, beta, depth, ply + plyOffset);

REQUIRE(retrieved.has_value());
REQUIRE(retrieved.value() == nearMate - plyOffset); // lower score
Expand All @@ -90,7 +91,7 @@ TEST_CASE("Transposition Table - Score Clamping for Mating Scores", "[TT]")
SECTION("From lower ply")
{
uint8_t plyOffset = 1;
auto retrieved = readHashEntry(key, alpha, beta, depth, ply - plyOffset);
auto retrieved = TtHashTable::readEntry(key, alpha, beta, depth, ply - plyOffset);

REQUIRE(retrieved.has_value());
REQUIRE(retrieved.value() == nearMate + plyOffset); // higher score
Expand All @@ -99,14 +100,14 @@ TEST_CASE("Transposition Table - Score Clamping for Mating Scores", "[TT]")

TEST_CASE("Transposition Table - Clear Functionality", "[TT]")
{
clearTable();
TtHashTable::clear();

uint64_t key = 0xF00DBABE12345678;
writeHashEntry(key, 77, depth, ply, TtHashExact);
TtHashTable::writeEntry(key, 77, depth, ply, TtHashExact);

clearTable();
TtHashTable::clear();

auto retrieved = readHashEntry(key, alpha, beta, depth, ply);
auto retrieved = TtHashTable::readEntry(key, alpha, beta, depth, ply);
REQUIRE_FALSE(retrieved.has_value()); // Should be cleared
}

0 comments on commit 2e3443f

Please sign in to comment.