From 91cc82aa2566e6b6fa60cf82298250d6e4e2dd46 Mon Sep 17 00:00:00 2001 From: Marco Costalba Date: Tue, 30 Dec 2014 10:31:50 +0100 Subject: [PATCH] Let material probing to access per-thread table It is up to material (and pawn) table look up code to know where the per-thread tables are, so change API to reflect this. Also some comment fixing while there No functional change. --- src/bitboard.cpp | 2 +- src/endgame.h | 4 +-- src/evaluate.cpp | 7 +++-- src/material.cpp | 69 ++++++++++++++++++++++++------------------------ src/material.h | 24 ++++++++--------- src/pawns.cpp | 18 +++++++------ src/pawns.h | 2 +- src/position.cpp | 2 +- src/search.cpp | 2 +- src/tt.cpp | 2 +- 10 files changed, 66 insertions(+), 66 deletions(-) diff --git a/src/bitboard.cpp b/src/bitboard.cpp index edadb8e3..4771e677 100644 --- a/src/bitboard.cpp +++ b/src/bitboard.cpp @@ -18,7 +18,7 @@ */ #include -#include // For memset +#include // For std::memset #include "bitboard.h" #include "bitcount.h" diff --git a/src/endgame.h b/src/endgame.h index c3d5dd03..c7f73000 100644 --- a/src/endgame.h +++ b/src/endgame.h @@ -76,7 +76,7 @@ template struct EndgameBase { virtual ~EndgameBase() {} - virtual Color color() const = 0; + virtual Color strong_side() const = 0; virtual T operator()(const Position&) const = 0; }; @@ -85,7 +85,7 @@ template SCALE_FUNS)>::type> struct Endgame : public EndgameBase { explicit Endgame(Color c) : strongSide(c), weakSide(~c) {} - Color color() const { return strongSide; } + Color strong_side() const { return strongSide; } T operator()(const Position&) const; private: diff --git a/src/evaluate.cpp b/src/evaluate.cpp index 1c27b29d..8416162d 100644 --- a/src/evaluate.cpp +++ b/src/evaluate.cpp @@ -19,6 +19,7 @@ #include #include +#include // For std::memset #include #include @@ -26,7 +27,6 @@ #include "evaluate.h" #include "material.h" #include "pawns.h" -#include "thread.h" namespace { @@ -677,7 +677,6 @@ namespace { EvalInfo ei; Score score, mobility[2] = { SCORE_ZERO, SCORE_ZERO }; - Thread* thisThread = pos.this_thread(); // Initialize score by reading the incrementally updated scores included // in the position object (material + piece square tables). @@ -685,7 +684,7 @@ namespace { score = pos.psq_score(); // Probe the material hash table - ei.mi = Material::probe(pos, thisThread->materialTable, thisThread->endgames); + ei.mi = Material::probe(pos); score += ei.mi->imbalance(); // If we have a specialized evaluation function for the current material @@ -694,7 +693,7 @@ namespace { return ei.mi->evaluate(pos); // Probe the pawn hash table - ei.pi = Pawns::probe(pos, thisThread->pawnsTable); + ei.pi = Pawns::probe(pos); score += apply_weight(ei.pi->pawns_score(), Weights[PawnStructure]); // Initialize attack and king safety bitboards diff --git a/src/material.cpp b/src/material.cpp index 6aeb117a..3ff42dae 100644 --- a/src/material.cpp +++ b/src/material.cpp @@ -17,11 +17,12 @@ along with this program. If not, see . */ -#include // For std::min +#include // For std::min #include -#include +#include // For std::memset #include "material.h" +#include "thread.h" using namespace std; @@ -32,7 +33,7 @@ namespace { // pair pawn knight bishop rook queen const int Linear[6] = { 1852, -162, -1122, -183, 249, -154 }; - const int QuadraticSameSide[][PIECE_TYPE_NB] = { + const int QuadraticOurs[][PIECE_TYPE_NB] = { // OUR PIECES // pair pawn knight bishop rook queen { 0 }, // Bishop pair @@ -43,7 +44,7 @@ namespace { {-177, 25, 129, 142, -137, 0 } // Queen }; - const int QuadraticOppositeSide[][PIECE_TYPE_NB] = { + const int QuadraticTheirs[][PIECE_TYPE_NB] = { // THEIR PIECES // pair pawn knight bishop rook queen { 0 }, // Bishop pair @@ -56,7 +57,7 @@ namespace { // Endgame evaluation and scaling functions are accessed directly and not through // the function maps because they correspond to more than one material hash key. - Endgame EvaluateKXK[] = { Endgame(WHITE), Endgame(BLACK) }; + Endgame EvaluateKXK[] = { Endgame(WHITE), Endgame(BLACK) }; Endgame ScaleKBPsK[] = { Endgame(WHITE), Endgame(BLACK) }; Endgame ScaleKQKRPs[] = { Endgame(WHITE), Endgame(BLACK) }; @@ -104,8 +105,8 @@ namespace { int v = Linear[pt1]; for (int pt2 = NO_PIECE_TYPE; pt2 <= pt1; ++pt2) - v += QuadraticSameSide[pt1][pt2] * pieceCount[Us][pt2] - + QuadraticOppositeSide[pt1][pt2] * pieceCount[Them][pt2]; + v += QuadraticOurs[pt1][pt2] * pieceCount[Us][pt2] + + QuadraticTheirs[pt1][pt2] * pieceCount[Them][pt2]; bonus += pieceCount[Us][pt1] * v; } @@ -117,19 +118,16 @@ namespace { namespace Material { -/// Material::probe() takes a position object as input, looks up a MaterialEntry -/// object, and returns a pointer to it. If the material configuration is not -/// already present in the table, it is computed and stored there, so we don't -/// have to recompute everything when the same material configuration occurs again. +/// Material::probe() looks up the current position's material configuration in +/// the material hash table. It returns a pointer to the Entry if the position +/// is found. Otherwise a new Entry is computed and stored there, so we don't +/// have to recompute all when the same material configuration occurs again. -Entry* probe(const Position& pos, Table& entries, Endgames& endgames) { +Entry* probe(const Position& pos) { Key key = pos.material_key(); - Entry* e = entries[key]; + Entry* e = pos.this_thread()->materialTable[key]; - // If e->key matches the position's material hash key, it means that we - // have analysed this material configuration before, and we can simply - // return the information we found the last time instead of recomputing it. if (e->key == key) return e; @@ -141,7 +139,7 @@ Entry* probe(const Position& pos, Table& entries, Endgames& endgames) { // Let's look if we have a specialized evaluation function for this particular // material configuration. Firstly we look for a fixed configuration one, then // for a generic one if the previous search failed. - if (endgames.probe(key, e->evaluationFunction)) + if (pos.this_thread()->endgames.probe(key, e->evaluationFunction)) return e; if (is_KXK(pos)) @@ -156,22 +154,19 @@ Entry* probe(const Position& pos, Table& entries, Endgames& endgames) { return e; } - // OK, we didn't find any special evaluation function for the current - // material configuration. Is there a suitable scaling function? - // - // We face problems when there are several conflicting applicable - // scaling functions and we need to decide which one to use. + // OK, we didn't find any special evaluation function for the current material + // configuration. Is there a suitable specialized scaling function? EndgameBase* sf; - if (endgames.probe(key, sf)) + if (pos.this_thread()->endgames.probe(key, sf)) { - e->scalingFunction[sf->color()] = sf; + e->scalingFunction[sf->strong_side()] = sf; // Only strong color assigned return e; } - // Generic scaling functions that refer to more than one material - // distribution. They should be probed after the specialized ones. - // Note that these ones don't return after setting the function. + // We didn't find any specialized scaling function, so fall back on generic + // ones that refer to more than one material distribution. Note that in this + // case we don't return after setting the function. if (is_KBPsKs(pos)) e->scalingFunction[WHITE] = &ScaleKBPsK[WHITE]; @@ -187,16 +182,18 @@ Entry* probe(const Position& pos, Table& entries, Endgames& endgames) { Value npm_w = pos.non_pawn_material(WHITE); Value npm_b = pos.non_pawn_material(BLACK); - if (npm_w + npm_b == VALUE_ZERO && pos.pieces(PAWN)) + if (npm_w + npm_b == VALUE_ZERO && pos.pieces(PAWN)) // Only pawns on the board { if (!pos.count(BLACK)) { assert(pos.count(WHITE) >= 2); + e->scalingFunction[WHITE] = &ScaleKPsK[WHITE]; } else if (!pos.count(WHITE)) { assert(pos.count(BLACK) >= 2); + e->scalingFunction[BLACK] = &ScaleKPsK[BLACK]; } else if (pos.count(WHITE) == 1 && pos.count(BLACK) == 1) @@ -208,14 +205,16 @@ Entry* probe(const Position& pos, Table& entries, Endgames& endgames) { } } - // No pawns makes it difficult to win, even with a material advantage. This - // catches some trivial draws like KK, KBK and KNK and gives a very drawish - // scale factor for cases such as KRKBP and KmmKm (except for KBBKN). + // Zero or just one pawn makes it difficult to win, even with a small material + // advantage. This catches some trivial draws like KK, KBK and KNK and gives a + // drawish scale factor for cases such as KRKBP and KmmKm (except for KBBKN). if (!pos.count(WHITE) && npm_w - npm_b <= BishopValueMg) - e->factor[WHITE] = uint8_t(npm_w < RookValueMg ? SCALE_FACTOR_DRAW : npm_b <= BishopValueMg ? 4 : 12); + e->factor[WHITE] = uint8_t(npm_w < RookValueMg ? SCALE_FACTOR_DRAW : + npm_b <= BishopValueMg ? 4 : 12); if (!pos.count(BLACK) && npm_b - npm_w <= BishopValueMg) - e->factor[BLACK] = uint8_t(npm_b < RookValueMg ? SCALE_FACTOR_DRAW : npm_w <= BishopValueMg ? 4 : 12); + e->factor[BLACK] = uint8_t(npm_b < RookValueMg ? SCALE_FACTOR_DRAW : + npm_w <= BishopValueMg ? 4 : 12); if (pos.count(WHITE) == 1 && npm_w - npm_b <= BishopValueMg) e->factor[WHITE] = (uint8_t) SCALE_FACTOR_ONEPAWN; @@ -226,13 +225,13 @@ Entry* probe(const Position& pos, Table& entries, Endgames& endgames) { // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder // for the bishop pair "extended piece", which allows us to be more flexible // in defining bishop pair bonuses. - const int pieceCount[COLOR_NB][PIECE_TYPE_NB] = { + const int PieceCount[COLOR_NB][PIECE_TYPE_NB] = { { pos.count(WHITE) > 1, pos.count(WHITE), pos.count(WHITE), pos.count(WHITE) , pos.count(WHITE), pos.count(WHITE) }, { pos.count(BLACK) > 1, pos.count(BLACK), pos.count(BLACK), pos.count(BLACK) , pos.count(BLACK), pos.count(BLACK) } }; - e->value = (int16_t)((imbalance(pieceCount) - imbalance(pieceCount)) / 16); + e->value = int16_t((imbalance(PieceCount) - imbalance(PieceCount)) / 16); return e; } diff --git a/src/material.h b/src/material.h index 581e7585..7e5dcadc 100644 --- a/src/material.h +++ b/src/material.h @@ -30,11 +30,11 @@ namespace Material { /// Material::Entry contains various information about a material configuration. /// It contains a material imbalance evaluation, a function pointer to a special /// endgame evaluation function (which in most cases is NULL, meaning that the -/// standard evaluation function will be used), and "scale factors". +/// standard evaluation function will be used), and scale factors. /// -/// The scale factors are used to scale the evaluation score up or down. -/// For instance, in KRB vs KR endgames, the score is scaled down by a factor -/// of 4, which will result in scores of absolute value less than one pawn. +/// The scale factors are used to scale the evaluation score up or down. For +/// instance, in KRB vs KR endgames, the score is scaled down by a factor of 4, +/// which will result in scores of absolute value less than one pawn. struct Entry { @@ -43,12 +43,11 @@ struct Entry { bool specialized_eval_exists() const { return evaluationFunction != NULL; } Value evaluate(const Position& pos) const { return (*evaluationFunction)(pos); } - // scale_factor takes a position and a color as input, and returns a scale factor - // for the given color. We have to provide the position in addition to the color, - // because the scale factor need not be a constant: It can also be a function - // which should be applied to the position. For instance, in KBP vs K endgames, - // a scaling function for draws with rook pawns and wrong-colored bishops. - + // scale_factor takes a position and a color as input and returns a scale factor + // for the given color. We have to provide the position in addition to the color + // because the scale factor may also be a function which should be applied to + // the position. For instance, in KBP vs K endgames, the scaling function looks + // for rook pawns and wrong-colored bishops. ScaleFactor scale_factor(const Position& pos, Color c) const { return !scalingFunction[c] || (*scalingFunction[c])(pos) == SCALE_FACTOR_NONE @@ -59,13 +58,14 @@ struct Entry { int16_t value; uint8_t factor[COLOR_NB]; EndgameBase* evaluationFunction; - EndgameBase* scalingFunction[COLOR_NB]; + EndgameBase* scalingFunction[COLOR_NB]; // Could be one for each + // side (e.g. KPKP, KBPsKs) Phase gamePhase; }; typedef HashTable Table; -Entry* probe(const Position& pos, Table& entries, Endgames& endgames); +Entry* probe(const Position& pos); } // namespace Material diff --git a/src/pawns.cpp b/src/pawns.cpp index 80dead4f..6ec718ff 100644 --- a/src/pawns.cpp +++ b/src/pawns.cpp @@ -24,6 +24,7 @@ #include "bitcount.h" #include "pawns.h" #include "position.h" +#include "thread.h" namespace { @@ -202,9 +203,9 @@ namespace { namespace Pawns { -/// init() initializes some tables used by evaluation. Instead of hard-coded -/// tables, when makes sense, we prefer to calculate them with a formula to -/// reduce independent parameters and to allow easier tuning and better insight. +/// Pawns::init() initializes some tables needed by evaluation. Instead of using +/// hard-coded tables, when makes sense, we prefer to calculate them with a formula +/// to reduce independent parameters and to allow easier tuning and better insight. void init() { @@ -220,14 +221,15 @@ void init() } -/// probe() takes a position as input, computes a Entry object, and returns a -/// pointer to it. The result is also stored in a hash table, so we don't have -/// to recompute everything when the same pawn structure occurs again. +/// Pawns::probe() looks up the current position's pawns configuration in +/// the pawns hash table. It returns a pointer to the Entry if the position +/// is found. Otherwise a new Entry is computed and stored there, so we don't +/// have to recompute all when the same pawns configuration occurs again. -Entry* probe(const Position& pos, Table& entries) { +Entry* probe(const Position& pos) { Key key = pos.pawn_key(); - Entry* e = entries[key]; + Entry* e = pos.this_thread()->pawnsTable[key]; if (e->key == key) return e; diff --git a/src/pawns.h b/src/pawns.h index 04aced77..40a40403 100644 --- a/src/pawns.h +++ b/src/pawns.h @@ -80,7 +80,7 @@ struct Entry { typedef HashTable Table; void init(); -Entry* probe(const Position& pos, Table& entries); +Entry* probe(const Position& pos); } // namespace Pawns diff --git a/src/position.cpp b/src/position.cpp index eed6d885..d29e7713 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -19,7 +19,7 @@ #include #include -#include +#include // For std::memset #include #include diff --git a/src/search.cpp b/src/search.cpp index 83c06a62..006834a7 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include // For std::memset #include #include diff --git a/src/tt.cpp b/src/tt.cpp index 19f21de2..76cd9218 100644 --- a/src/tt.cpp +++ b/src/tt.cpp @@ -17,7 +17,7 @@ along with this program. If not, see . */ -#include +#include // For std::memset #include #include "bitboard.h" -- 2.39.2