From a230dc14045691667ffce46619de60497edceb88 Mon Sep 17 00:00:00 2001 From: Marco Costalba Date: Sat, 6 Sep 2008 15:53:43 +0200 Subject: [PATCH] Split transposition table lookup in a separate function This slims down the code and is a prerequisite for future patches. Signed-off-by: Marco Costalba --- src/search.cpp | 52 ++++++++++++++++++++++++++------------------------ src/tt.cpp | 45 ++++++------------------------------------- src/tt.h | 16 +++++++--------- 3 files changed, 40 insertions(+), 73 deletions(-) diff --git a/src/search.cpp b/src/search.cpp index 6bab114c..2779bf8c 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -240,6 +240,7 @@ namespace { bool singleReply, bool mateThreat); bool ok_to_do_nullmove(const Position &pos); bool ok_to_prune(const Position &pos, Move m, Move threat, Depth d); + bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply); bool fail_high_ply_1(); int current_search_time(); @@ -458,7 +459,7 @@ void think(const Position &pos, bool infinite, bool ponder, int time, // We're ready to start thinking. Call the iterative deepening loop // function: - id_loop(pos, searchMoves); + id_loop(pos, searchMoves);; if(UseLogFile) LogFile.close(); @@ -859,14 +860,11 @@ namespace { // Transposition table lookup. At PV nodes, we don't use the TT for // pruning, but only for move ordering. - Value ttValue; - Depth ttDepth; - Move ttMove = MOVE_NONE; - ValueType ttValueType; + const TTEntry* tte = TT.retrieve(pos); - TT.retrieve(pos, &ttValue, &ttDepth, &ttMove, &ttValueType); + Move ttMove = (tte ? tte->move() : MOVE_NONE); - // Internal iterative deepening. + // Go with internal iterative deepening if we don't have a TT move. if(UseIIDAtPVNodes && ttMove == MOVE_NONE && depth >= 5*OnePly) { search_pv(pos, ss, alpha, beta, depth-2*OnePly, ply, threadID); ttMove = ss[ply].pv[ply]; @@ -1045,24 +1043,14 @@ namespace { return beta-1; // Transposition table lookup - bool ttFound; - Value ttValue; - Depth ttDepth; - Move ttMove = MOVE_NONE; - ValueType ttValueType; - - ttFound = TT.retrieve(pos, &ttValue, &ttDepth, &ttMove, &ttValueType); - if(ttFound) { - ttValue = value_from_tt(ttValue, ply); - if(ttDepth >= depth - || ttValue >= Max(value_mate_in(100), beta) - || ttValue < Min(value_mated_in(100), beta)) { - if((is_lower_bound(ttValueType) && ttValue >= beta) || - (is_upper_bound(ttValueType) && ttValue < beta)) { - ss[ply].currentMove = ttMove; - return ttValue; - } - } + const TTEntry* tte = TT.retrieve(pos); + + Move ttMove = (tte ? tte->move() : MOVE_NONE); + + if (tte && ok_to_use_TT(tte, depth, beta, ply)) + { + ss[ply].currentMove = ttMove; // can be MOVE_NONE ? + return value_from_tt(tte->value(), ply); } Value approximateEval = quick_evaluate(pos); @@ -1590,6 +1578,20 @@ namespace { lock_release(&(sp->lock)); } + // ok_to_use_TT() returns true if a transposition table score + // can be used at a given point in search. + + bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply) { + + Value v = value_from_tt(tte->value(), ply); + + return ( tte->depth() >= depth + || v >= Max(value_mate_in(100), beta) + || v < Min(value_mated_in(100), beta)) + + && ( (is_lower_bound(tte->type()) && v >= beta) + || (is_upper_bound(tte->type()) && v < beta)); + } /// The RootMove class diff --git a/src/tt.cpp b/src/tt.cpp index 268c21f8..19596932 100644 --- a/src/tt.cpp +++ b/src/tt.cpp @@ -136,29 +136,20 @@ void TranspositionTable::store(const Position &pos, Value v, Depth d, /// TranspositionTable::retrieve looks up the current position in the -/// transposition table, and extracts the value, value type, depth and -/// best move if the position is found. The return value is true if -/// the position is found, and false if it isn't. +/// transposition table. Returns a pointer to the TTEntry or NULL +/// if position is not found. + +const TTEntry* TranspositionTable::retrieve(const Position &pos) const { -bool TranspositionTable::retrieve(const Position &pos, Value *value, - Depth *d, Move *move, - ValueType *type) const { TTEntry *tte = first_entry(pos); for (int i = 0; i < 4; i++) { tte += i; if (tte->key() == pos.get_key()) - { - *value = tte->value(); - *type = tte->type(); - *d = tte->depth(); - *move = tte->move(); - return true; - } + return tte; } - *move = MOVE_NONE; - return false; + return NULL; } @@ -222,28 +213,4 @@ TTEntry::TTEntry(Key k, Value v, ValueType t, Depth d, Move m, value_(v), depth_(int16_t(d)) {} -/// Functions for extracting data from TTEntry objects. - -inline Key TTEntry::key() const { - return key_; -} - -inline Depth TTEntry::depth() const { - return Depth(depth_); -} - -inline Move TTEntry::move() const { - return Move(data & 0x7FFFF); -} - -inline Value TTEntry::value() const { - return Value(value_); -} - -inline ValueType TTEntry::type() const { - return ValueType((data >> 20) & 3); -} -inline int TTEntry::generation() const { - return (data >> 23); -} diff --git a/src/tt.h b/src/tt.h index 4ca34412..ec3d72b4 100644 --- a/src/tt.h +++ b/src/tt.h @@ -40,12 +40,12 @@ class TTEntry { public: TTEntry(); TTEntry(Key k, Value v, ValueType t, Depth d, Move m, int generation); - Key key() const; - Depth depth() const; - Move move() const; - Value value() const; - ValueType type() const; - int generation() const; + Key key() const { return key_; } + Depth depth() const { return Depth(depth_); } + Move move() const { return Move(data & 0x7FFFF); } + Value value() const { return Value(value_); } + ValueType type() const { return ValueType((data >> 20) & 3); } + int generation() const { return (data >> 23); } private: Key key_; @@ -54,7 +54,6 @@ private: int16_t depth_; }; - /// The transposition table class. This is basically just a huge array /// containing TTEntry objects, and a few methods for writing new entries /// and reading new ones. @@ -67,8 +66,7 @@ public: void set_size(unsigned mbSize); void clear(); void store(const Position &pos, Value v, Depth d, Move m, ValueType type); - bool retrieve(const Position &pos, Value *value, Depth *d, Move *move, - ValueType *type) const; + const TTEntry* retrieve(const Position &pos) const; void new_search(); void insert_pv(const Position &pos, Move pv[]); int full(); -- 2.39.2