TTEntry simplification

[stockfish] / src / tt.h

diff --git a/src/tt.h b/src/tt.h
index 9babce8cdc9f10e14500c1f9c4e5cdc6a071d033..94ee78e70f233f9126bee035e1213403551bee8f 100644 (file)
--- a/src/tt.h
+++ b/src/tt.h
@@ -21,9 +21,7 @@
 #if !defined(TT_H_INCLUDED)
 #define TT_H_INCLUDED
 
-////
-//// Includes
-////
+#include <iostream>
 
 #include "depth.h"
 #include "move.h"
@@ -34,6 +32,39 @@
 //// Types
 ////
 
+
+/// A simple fixed size hash table used to store pawns and material
+/// configurations. It is basically just an array of Entry objects.
+/// Without cluster concept or overwrite policy.
+
+template<class Entry, int HashSize>
+class SimpleHash {
+
+  SimpleHash(const SimpleHash&);
+  SimpleHash& operator=(const SimpleHash&);
+
+public:
+  SimpleHash() {
+
+    entries = new Entry[HashSize];
+    if (!entries)
+    {
+        std::cerr << "Failed to allocate " << HashSize * sizeof(Entry)
+                  << " bytes for material hash table." << std::endl;
+        exit(EXIT_FAILURE);
+    }
+    memset(entries, 0, HashSize * sizeof(Entry));
+  }
+
+  ~SimpleHash() { delete [] entries; }
+
+  Entry* find(Key key) const { return entries + ((uint32_t)key & (HashSize - 1)); }
+
+protected:
+  Entry* entries;
+};
+
+
 /// The TTEntry class is the class of transposition table entries
 ///
 /// A TTEntry needs 128 bits to be stored
@@ -47,40 +78,45 @@
 ///
 /// the 32 bits of the data field are so defined
 ///
-/// bit  0-16: move
-/// bit 17-20: not used
+/// bit  0-15: move
+/// bit 16-20: not used
 /// bit 21-22: value type
 /// bit 23-31: generation
 
 class TTEntry {
 
 public:
-  void save(uint32_t k, Value v, ValueType t, Depth d, Move m, int g, Value statV, Value kd) {
-
-      key32 = k;
-      data = (m & 0x1FFFF) | (t << 21) | (g << 23);
-      value16     = int16_t(v);
-      depth16     = int16_t(d);
-      staticValue = int16_t(statV);
-      staticValueMargin  = int16_t(kd);
+  void save(uint32_t k, Value v, ValueType t, Depth d, Move m, int g, Value statV, Value statM) {
+
+    key32        = (uint32_t)k;
+    move16       = (uint16_t)m;
+    valueType    = (uint8_t)t;
+    generation8  = (uint8_t)g;
+    value16      = (int16_t)v;
+    depth16      = (int16_t)d;
+    staticValue  = (int16_t)statV;
+    staticMargin = (int16_t)statM;
   }
+  void set_generation(int g) { generation8 = (uint8_t)g; }
 
   uint32_t key() const { return key32; }
   Depth depth() const { return Depth(depth16); }
-  Move move() const { return Move(data & 0x1FFFF); }
+  Move move() const { return Move(move16); }
   Value value() const { return Value(value16); }
-  ValueType type() const { return ValueType((data >> 21) & 3); }
-  int generation() const { return data >> 23; }
+  ValueType type() const { return ValueType(valueType); }
+  int generation() const { return generation8; }
   Value static_value() const { return Value(staticValue); }
-  Value static_value_margin() const { return Value(staticValueMargin); }
+  Value static_value_margin() const { return Value(staticMargin); }
 
 private:
   uint32_t key32;
-  uint32_t data;
+  uint16_t move16;
+  uint8_t valueType;
+  uint8_t generation8;
   int16_t value16;
   int16_t depth16;
   int16_t staticValue;
-  int16_t staticValueMargin;
+  int16_t staticMargin;
 };
 
 
@@ -114,11 +150,12 @@ public:
   TTEntry* retrieve(const Key posKey) const;
   void new_search();
   TTEntry* first_entry(const Key posKey) const;
+  void refresh(const TTEntry* tte) const;
 
 private:
   size_t size;
   TTCluster* entries;
-  uint8_t generation;
+  uint8_t generation; // To properly compare, size must be smaller then TT stored value
 };
 
 extern TranspositionTable TT;
@@ -130,7 +167,16 @@ extern TranspositionTable TT;
 
 inline TTEntry* TranspositionTable::first_entry(const Key posKey) const {
 
-  return entries[uint32_t(posKey) & (size - 1)].data;
+  return entries[((uint32_t)posKey) & (size - 1)].data;
+}
+
+
+/// TranspositionTable::refresh updates the 'generation' value of the TTEntry
+/// to avoid aging. Normally called after a TT hit, before to return.
+
+inline void TranspositionTable::refresh(const TTEntry* tte) const {
+
+  const_cast<TTEntry*>(tte)->set_generation(generation);
 }
 
 #endif // !defined(TT_H_INCLUDED)