From a64d524d026bc78e4779fa3249649271d905df2d Mon Sep 17 00:00:00 2001 From: Joost VandeVondele Date: Mon, 23 Apr 2018 08:45:50 +0200 Subject: [PATCH] Remove template W param Different W template parameters for the different statEntries are not needed, simplify by consistently using 32. Passed STC: LLR: 2.96 (-2.94,2.94) [-3.00,1.00] Total: 21683 W: 4545 L: 4424 D: 12714 http://tests.stockfishchess.org/tests/view/5ad797550ebc595700526e59 Passed LTC: LLR: 2.96 (-2.94,2.94) [-3.00,1.00] Total: 110391 W: 16551 L: 16562 D: 77278 http://tests.stockfishchess.org/tests/view/5ad7a88f0ebc595700526e61 Closes https://github.com/official-stockfish/Stockfish/pull/1557 Bench: 5120532 --- src/movepick.cpp | 2 +- src/movepick.h | 42 +++++++++++++++++++++--------------------- src/search.cpp | 2 +- 3 files changed, 23 insertions(+), 23 deletions(-) diff --git a/src/movepick.cpp b/src/movepick.cpp index 7ef7cafa..e1042ea6 100644 --- a/src/movepick.cpp +++ b/src/movepick.cpp @@ -111,7 +111,7 @@ void MovePicker::score() { for (auto& m : *this) if (Type == CAPTURES) m.value = PieceValue[MG][pos.piece_on(to_sq(m))] - + (*captureHistory)[pos.moved_piece(m)][to_sq(m)][type_of(pos.piece_on(to_sq(m)))]; + + (*captureHistory)[pos.moved_piece(m)][to_sq(m)][type_of(pos.piece_on(to_sq(m)))] / 16; else if (Type == QUIETS) m.value = (*mainHistory)[pos.side_to_move()][from_to(m)] diff --git a/src/movepick.h b/src/movepick.h index fc409a02..ae61be7f 100644 --- a/src/movepick.h +++ b/src/movepick.h @@ -33,7 +33,7 @@ /// be a move or even a nested history. We use a class instead of naked value /// to directly call history update operator<<() on the entry so to use stats /// tables at caller sites as simple multi-dim arrays. -template +template class StatsEntry { static const bool IsInt = std::is_integral::value; @@ -47,23 +47,22 @@ public: operator TT() const { return entry; } void operator<<(int bonus) { + assert(abs(bonus) <= D); // Ensure range is [-D, D] + assert(D < std::numeric_limits::max()); // Ensure we don't overflow - assert(abs(bonus) <= D); // Ensure range is [-W * D, W * D] - assert(W * D < std::numeric_limits::max()); // Ensure we don't overflow + entry += bonus - entry * abs(bonus) / D; - entry += bonus * W - entry * abs(bonus) / D; - - assert(abs(entry) <= W * D); + assert(abs(entry) <= D); } }; /// Stats is a generic N-dimensional array used to store various statistics. -/// The first template T parameter is the base type of the array, the W parameter -/// is the weight applied to the bonuses when we update values with the << operator, -/// the D parameter limits the range of updates (range is [-W * D, W * D]), and -/// the last parameters (Size and Sizes) encode the dimensions of the array. -template -struct Stats : public std::array, Size> +/// The first template parameter T is the base type of the array, the second +/// template parameter D limits the range of updates in [-D, D] when we update +/// values with the << operator, while the last parameters (Size and Sizes) +/// encode the dimensions of the array. +template +struct Stats : public std::array, Size> { T* get() { return this->at(0).get(); } @@ -73,34 +72,35 @@ struct Stats : public std::array, Size> } }; -template -struct Stats : public std::array, Size> { +template +struct Stats : public std::array, Size> { T* get() { return this->at(0).get(); } }; -/// Different tables use different W/D parameter, name them to ease readibility -enum StatsParams { W2 = 2, W32 = 32, D324 = 324, D936 = 936, NOT_USED = 0 }; +/// In stats table, D=0 means that the template parameter is not used +enum StatsParams { NOT_USED = 0 }; + /// ButterflyHistory records how often quiet moves have been successful or /// unsuccessful during the current search, and is used for reduction and move /// ordering decisions. It uses 2 tables (one for each color) indexed by /// the move's from and to squares, see chessprogramming.wikispaces.com/Butterfly+Boards -typedef Stats ButterflyHistory; +typedef Stats ButterflyHistory; /// CounterMoveHistory stores counter moves indexed by [piece][to] of the previous /// move, see chessprogramming.wikispaces.com/Countermove+Heuristic -typedef Stats CounterMoveHistory; +typedef Stats CounterMoveHistory; /// CapturePieceToHistory is addressed by a move's [piece][to][captured piece type] -typedef Stats CapturePieceToHistory; +typedef Stats CapturePieceToHistory; /// PieceToHistory is like ButterflyHistory but is addressed by a move's [piece][to] -typedef Stats PieceToHistory; +typedef Stats PieceToHistory; /// ContinuationHistory is the combined history of a given pair of moves, usually /// the current one given a previous one. The nested history table is based on /// PieceToHistory instead of ButterflyBoards. -typedef Stats ContinuationHistory; +typedef Stats ContinuationHistory; /// MovePicker class is used to pick one pseudo legal move at a time from the diff --git a/src/search.cpp b/src/search.cpp index 897121fd..15f870f5 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -92,7 +92,7 @@ namespace { // History and stats update bonus, based on depth int stat_bonus(Depth depth) { int d = depth / ONE_PLY; - return d > 17 ? 0 : d * d + 2 * d - 2; + return d > 17 ? 0 : 32 * d * d + 64 * d - 64; } // Skill structure is used to implement strength limit -- 2.39.2