Split transposition table lookup in a separate function
[stockfish] / src / tt.cpp
index 146e591f4462f5cb612b9a7e18d6dec190f8c5c6..1959693258c3d8e0e6dbad995103ed0ee766cbe2 100644 (file)
@@ -6,12 +6,12 @@
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
-  
+
   Glaurung is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
-  
+
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
@@ -105,23 +105,29 @@ void TranspositionTable::store(const Position &pos, Value v, Depth d,
                                Move m, ValueType type) {
   TTEntry *tte, *replace;
 
-  tte = replace = entries + int(pos.get_key() & (size - 1)) * 4;
+  tte = replace = first_entry(pos);
   for (int i = 0; i < 4; i++)
   {
-    if ((tte+i)->key() == pos.get_key())
+    if (!(tte+i)->key()) // still empty
     {
-        if (m == MOVE_NONE)
-            m = (tte+i)->move();
-        
         *(tte+i) = TTEntry(pos.get_key(), v, type, d, m, generation);
+        writes++;
         return;
     }
-    if (replace->generation() == generation)
+    if ((tte+i)->key() == pos.get_key()) // overwrite old
     {
-        if ((tte+i)->generation() != generation || (tte+i)->depth() < replace->depth())
-            replace = tte+i;
+        if (m == MOVE_NONE)
+            m = (tte+i)->move();
+
+        *(tte+i) = TTEntry(pos.get_key(), v, type, d, m, generation);
+        return;
     }
-    else if ((tte+i)->generation() != generation && (tte+i)->depth() < replace->depth())
+    if (   i == 0  // already is (replace == tte+i), common case
+        || replace->generation() < (tte+i)->generation())
+        continue;
+
+    if (    replace->generation() > (tte+i)->generation()
+        || (tte+i)->depth() < replace->depth())
         replace = tte+i;
   }
   *replace = TTEntry(pos.get_key(), v, type, d, m, generation);
@@ -130,35 +136,31 @@ 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.
-
-bool TranspositionTable::retrieve(const Position &pos, Value *value,
-                                  Depth *d, Move *move,
-                                  ValueType *type) const {
-  TTEntry *tte;
-  bool found = false;
-
-  tte = entries + int(pos.get_key() & (size - 1)) * 4;
-  for (int i = 0; i < 4 && !found ; i++)
-      if ((tte+i)->key() == pos.get_key())
-      {
-          tte = tte + i;
-          found = true;
-      }
-  if (!found) {
-      *move = MOVE_NONE;
-      return false;
+/// transposition table. Returns a pointer to the TTEntry or NULL
+/// if position is not found.
+
+const TTEntry* TranspositionTable::retrieve(const Position &pos) const {
+
+  TTEntry *tte = first_entry(pos);
+
+  for (int i = 0; i < 4; i++)
+  {
+      tte += i;
+      if (tte->key() == pos.get_key())
+          return tte;
   }
-  *value = tte->value();
-  *type = tte->type();
-  *d = tte->depth();
-  *move = tte->move();
-  return true;
+  return NULL;
 }
 
 
+/// TranspositionTable::first_entry returns a pointer to the first
+/// entry of a cluster given a position.
+
+inline TTEntry* TranspositionTable::first_entry(const Position &pos) const {
+
+  return entries + (int(pos.get_key() & (size - 1)) << 2);
+}
+
 /// TranspositionTable::new_search() is called at the beginning of every new
 /// search.  It increments the "generation" variable, which is used to
 /// distinguish transposition table entries from previous searches from
@@ -171,7 +173,7 @@ void TranspositionTable::new_search() {
 }
 
 
-/// TranspositionTable::insert_pv() is called at the end of a search 
+/// TranspositionTable::insert_pv() is called at the end of a search
 /// iteration, and inserts the PV back into the PV.  This makes sure the
 /// old PV moves are searched first, even if the old TT entries have been
 /// overwritten.
@@ -206,36 +208,9 @@ TTEntry::TTEntry() {
 }
 
 TTEntry::TTEntry(Key k, Value v, ValueType t, Depth d, Move m,
-                 int generation) {
-  key_ = k;
-  data = (m & 0x7FFFF) | (t << 20) | (generation << 23);
-  value_ = v;
-  depth_ = int16_t(d);
-}
+                 int generation) :
+  key_ (k), data((m & 0x7FFFF) | (t << 20) | (generation << 23)),
+  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);
-}