memory optimization

Exclusivefrog28 · Exclusivefrog28 · commit ca04e6f6fdae · 2024-04-09T15:51:58.000+02:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -26,7 +26,7 @@ add_subdirectory(src)
 target_link_libraries(ChessEngine src)
 
 if (NOT WASM)
-#    add_subdirectory(tests)
+    add_subdirectory(tests)
 endif ()
 
 if (WASM)
diff --git a/src/Move.h b/src/Move.h
@@ -23,11 +23,11 @@ namespace Moves {
 	};
 
 	struct Move {
-		int_fast8_t start;
-		int_fast8_t end;
-		Type promotionType;
-		MoveFlag flag;
-		Color player;
+		int8_t start : 8;
+		int8_t end : 8;
+		Type promotionType : 4;
+		MoveFlag flag : 4;
+		Color player : 1;
 
 		bool operator==(const Move&other) const {
 			return (start == other.start && end == other.end && promotionType == other.promotionType &&
@@ -54,7 +54,7 @@ namespace Moves {
 
 	constexpr Move NULL_MOVE = Move{0, 0, Pieces::EMPTY, QUIET, Color::WHITE};
 
-	constexpr int_fast8_t MAILBOX[120] = {
+	constexpr int8_t MAILBOX[120] = {
 		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 		-1, 0, 1, 2, 3, 4, 5, 6, 7, -1,
@@ -69,7 +69,7 @@ namespace Moves {
 		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1
 	};
 
-	constexpr int_fast8_t MAILBOX64[64] = {
+	constexpr int8_t MAILBOX64[64] = {
 		21, 22, 23, 24, 25, 26, 27, 28,
 		31, 32, 33, 34, 35, 36, 37, 38,
 		41, 42, 43, 44, 45, 46, 47, 48,
@@ -81,8 +81,8 @@ namespace Moves {
 	};
 
 	constexpr bool SLIDE[7] = {false, false, false, true, true, true, false};
-	constexpr int_fast8_t OFFSETS[7] = {0, 4, 8, 4, 4, 8, 8};
-	constexpr int_fast8_t OFFSET[7][8] = {
+	constexpr int8_t OFFSETS[7] = {0, 4, 8, 4, 4, 8, 8};
+	constexpr int8_t OFFSET[7][8] = {
 		{0, 0, 0, 0, 0, 0, 0, 0},
 		{8, 9, 11, 16, 0, 0, 0, 0},
 		{-21, -19, -12, -8, 8, 12, 19, 21},
diff --git a/src/Search.cpp b/src/Search.cpp
@@ -7,7 +7,7 @@
 #include <thread>
 #include <format>
 
-#define MATE_SCORE 32768 // 1 << 15
+#define MATE_SCORE INT32_MAX
 
 TranspositionTable Search::tt = TranspositionTable();
 
@@ -74,8 +74,8 @@ Move Search::search(ChessBoard&board, const int timeAllowed) {
 
 	if (search.lastPV.empty()) {
 		auto entry = tt.getEntry(board.hashCode, 0);
-		std::cout << "problem HASH: " << board.hashCode << " TT: key- " << entry.key << ", move- " << entry.bestMove << ", type- " << entry.nodeType() <<
-				", depth- " << entry.depth() << ", score- " << entry.score() << std::endl;
+		std::cout << "problem HASH: " << board.hashCode << " TT: key- " << entry.key << ", move- " << entry.bestMove << ", type- " << entry.nodeType <<
+				", depth- " << entry.depth << ", score- " << entry.score << std::endl;
 		return NULL_MOVE;
 	}
 
@@ -348,14 +348,14 @@ std::vector<Move> Search::collectPV(const int depth) const {
 	int pvDepth = 0;
 	while (tt.contains(board.hashCode)) {
 		const TranspositionTable::Entry entry = tt.getEntry(board.hashCode, 0);
-		if (entry.nodeType() != TranspositionTable::EXACT) break;
+		if (entry.nodeType != TranspositionTable::EXACT || entry.depth < 1) break;
 		Move move = entry.bestMove;
 
 		if (pvPositions.contains(board.hashCode)) {
 			std::cout << "Cycle in PV!" << std::endl;
 			board.makeMove(move);
 			pv.push_back(move);
-			scores.push_back(entry.score());
+			scores.push_back(entry.score);
 			pvDepth++;
 			break;
 		}
@@ -381,7 +381,7 @@ std::vector<Move> Search::collectPV(const int depth) const {
 		pvPositions.insert(board.hashCode);
 		board.makeMove(move);
 		pv.push_back(move);
-		scores.push_back(entry.score());
+		scores.push_back(entry.score);
 		pvDepth++;
 	}
 	std::string pvString;
@@ -404,20 +404,20 @@ std::vector<Move> Search::collectPV(const int depth) const {
 bool Search::getTransposition(const uint64_t hash, const int depth, const int ply, int&score, const int&alpha, const int&beta, Move&hashMove) {
 	if (tt.contains(hash)) {
 		const TranspositionTable::Entry entry = tt.getEntry(hash, ply);
-		if (entry.depth() >= depth) {
-			switch (entry.nodeType()) {
+		if (entry.depth >= depth) {
+			switch (entry.nodeType) {
 				case TranspositionTable::EXACT:
-					score = entry.score();
+					score = entry.score;
 					return true;
 				case TranspositionTable::UPPERBOUND:
-					if (entry.score() <= alpha) {
-						score = entry.score();
+					if (entry.score <= alpha) {
+						score = entry.score;
 						return true;
 					}
 					break;
 				case TranspositionTable::LOWERBOUND:
-					if (entry.score() >= beta) {
-						score = entry.score();
+					if (entry.score >= beta) {
+						score = entry.score;
 						return true;
 					}
 				default: break;
diff --git a/src/TranspositionTable.cpp b/src/TranspositionTable.cpp
@@ -1,18 +1,19 @@
 #include "TranspositionTable.h"
 #include <cmath>
+#include <cstdio>
 
 #include "MoveGenerator.h"
 
-#define MATE_SCORE 32768 // 1 << 15
-#define MIN_MATE_SCORE 16384 // 1 << 14
+#define MATE_SCORE INT32_MAX
+#define MIN_MATE_SCORE (INT32_MAX - 1024)
 
 TranspositionTable::Entry TranspositionTable::getEntry(const uint64_t key, const int ply) {
 	const int index = key % TT_SIZE;
 	Entry entry = entries[index];
 
-	if (abs(entry.score()) >= MIN_MATE_SCORE) {
-		const int sign = entry.score() > 0 ? 1 : -1;
-		entry.setScore(sign * (abs(entry.score()) - ply));
+	if (abs(entry.score) >= MIN_MATE_SCORE) {
+		const int sign = entry.score > 0 ? 1 : -1;
+		entry.score = sign * (abs(entry.score) - ply);
 	}
 	reads++;
 
@@ -21,7 +22,7 @@ TranspositionTable::Entry TranspositionTable::getEntry(const uint64_t key, const
 
 bool TranspositionTable::contains(const uint64_t key) {
 	const int index = key % TT_SIZE;
-	const bool exists = entries[index].nodeType() != EMPTY;
+	const bool exists = entries[index].nodeType != EMPTY;
 	const bool sameKey = (entries[index].key == key);
 	if (exists && !sameKey) collisions++;
 
@@ -36,17 +37,17 @@ void TranspositionTable::setEntry(const ChessBoard&board, const Move bestMove, c
 		score = sign * (abs(score) + ply);
 	}
 
-	const NodeType savedType = entries[index].nodeType();
+	const NodeType savedType = entries[index].nodeType;
 
-	const Entry entry = Entry(board.hashCode, bestMove, depth, score, nodeType);
+	const Entry entry = {board.hashCode, bestMove, score, static_cast<uint8_t>(depth), nodeType};
 
 	//REPLACEMENT SCHEME
 	// 1. Prefer EXACT nodes to bounds
 	// 2. Prefer deeper nodes to shallower
 
 	if (savedType != EMPTY) {
 		if ((savedType != EXACT && nodeType != EXACT) || (savedType == EXACT && nodeType == EXACT)) {
-			if (entries[index].depth() <= depth) write(index, entry);
+			if (entries[index].depth <= depth) write(index, entry);
 		}
 		else if (savedType != EXACT) write(index, entry);
 	}
@@ -67,16 +68,14 @@ void TranspositionTable::resetCounters() {
 int TranspositionTable::occupancy() const {
 	int occupied = 0;
 	for (int i = 0; i < TT_SIZE; i++) {
-		if (entries[i].nodeType() != EMPTY) occupied++;
+		if (entries[i].nodeType != EMPTY) occupied++;
 	}
 	return occupied;
 }
 
 void TranspositionTable::clear() {
 	resetCounters();
 	for (Entry&entry: entries) {
-		entry.setNodeType(EMPTY);
+		entry.nodeType = EMPTY;
 	}
 }
-
-TranspositionTable::TranspositionTable()= default;
diff --git a/src/TranspositionTable.h b/src/TranspositionTable.h
@@ -18,63 +18,31 @@ class TranspositionTable {
         LOWERBOUND = 2,
         UPPERBOUND = 3,
     };
-
     struct Entry {
-        uint64_t key;
-        Move bestMove{};
-        uint32_t data;
-
-        uint8_t depth() const {
-            return (data & 0xFF0000) >> 16;
-        }
-
-        int16_t score() const {
-            return data & 0xFFFF;
-        }
-
-        void setScore(int16_t score) {
-            data = (data & 0xFFF0000) | score;
-        }
-
-        NodeType nodeType() const {
-            return (NodeType) ((data & 0xF000000) >> 24);
-        }
-
-        void setNodeType(NodeType nodeType) {
-            data = (data & 0x0FFFFFF) | (((uint8_t) nodeType) << 24);
-        }
-
-        Entry(uint64_t key, Move bestMove, int depth, int score, NodeType nodeType) {
-            this->key = key;
-            this->bestMove = bestMove;
-            this->data = 0 | (0xFFFF & ((int16_t) score)) | (((uint8_t) depth) << 16) | (((uint8_t) nodeType) << 24);
-        }
-
-        Entry() = default;
+        uint64_t key : 64;
+        Move bestMove;
+        int32_t score : 32;
+        uint8_t depth : 8;
+        NodeType nodeType : 2;
     };
 
-    TranspositionTable();
-
     bool contains(uint64_t key);
 
     Entry getEntry(uint64_t key, int ply);
 
-    void setEntry(const ChessBoard &board, Move bestMove, int depth, int score, NodeType nodeType, int ply);
+    void setEntry(const ChessBoard&board, Move bestMove, int depth, int score, NodeType nodeType, int ply);
 
     int reads;
     int writes;
     int collisions;
-
     void resetCounters();
-
     int occupancy() const;
-
     void clear();
 
     std::array<Entry, TT_SIZE> entries;
 
 private:
-    void write(int index, const Entry &entry);
+    void write(int index, const Entry&entry);
 
 
 };
diff --git a/tests/TranspositionTest.cpp b/tests/TranspositionTest.cpp
@@ -4,15 +4,15 @@
 #include "TranspositionTable.h"
 #include "catch2/internal/catch_windows_h_proxy.hpp"
 
-#define MATE_SCORE 32768 // 1 << 15
+#define MATE_SCORE INT32_MAX
 
 auto tt = TranspositionTable();
 
 TEST_CASE("TT - rw", "[TranspositionTests]") {
 	ChessBoard board;
 	board.setPosition("8/RP1qb1B1/2p2P2/6n1/P7/p3k3/Q3b1BK/6R1 w - - 0 1");
 	tt.setEntry(board, Interface::CLI::parseMove("f6e7", board), 1, 1, TranspositionTable::EXACT, 1);
-	auto readEntry = tt.getEntry(board.hashCode, 1);
+	const auto readEntry = tt.getEntry(board.hashCode, 1);
 	CHECK(readEntry.bestMove == Interface::CLI::parseMove("f6e7", board));
 	CHECK(readEntry.depth == 1);
 	CHECK(readEntry.score == 1);
