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 <mcostalba@gmail.com>

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;
+    const TTEntry* tte = TT.retrieve(pos);
 
-    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;
-        }
-      }
+    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
 

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);
-}

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();