Merge branch 'eval_cache'

[stockfish] / src / tt.h

diff --git a/src/tt.h b/src/tt.h
index 03147bf1a8f5aadb8deb0162902b023d0c574c32..c41f231e2a251ec8f3035a5509abdca3e6232635 100644 (file)
--- a/src/tt.h
+++ b/src/tt.h
@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+  Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -20,12 +20,9 @@
 #if !defined(TT_H_INCLUDED)
 #define TT_H_INCLUDED
 
-#include <iostream>
-
-#include "move.h"
+#include "misc.h"
 #include "types.h"
 
-
 /// The TTEntry is the class of transposition table entries
 ///
 /// A TTEntry needs 128 bits to be stored
@@ -47,33 +44,71 @@
 class TTEntry {
 
 public:
-  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 save(uint32_t k, Value v, Bound b, Depth d, Move m, int g) {
+
+    key32       = (uint32_t)k;
+    move16      = (uint16_t)m;
+    bound       = (uint8_t)b;
+    generation8 = (uint8_t)g;
+    valueUpper = (int16_t)(b & BOUND_UPPER ? v : VALUE_NONE);
+    depthUpper = (int16_t)(b & BOUND_UPPER ? d : DEPTH_NONE);
+    valueLower = (int16_t)(b & BOUND_LOWER ? v : VALUE_NONE);
+    depthLower = (int16_t)(b & BOUND_LOWER ? d : DEPTH_NONE);
+  }
+
+  void update(Value v, Bound b, Depth d, Move m, int g) {
+
+    move16      = (uint16_t)m;
+    generation8 = (uint8_t)g;
+
+    if (bound == BOUND_EXACT)
+        bound = BOUND_UPPER | BOUND_LOWER; // Drop 'EXACT' flag
+
+    if (b & BOUND_UPPER)
+    {
+        valueUpper = (int16_t)v;
+        depthUpper = (int16_t)d;
+
+        if ((bound & BOUND_LOWER) && v < valueLower)
+        {
+            bound ^= BOUND_LOWER;
+            valueLower = VALUE_NONE;
+            depthLower = DEPTH_NONE;
+        }
+    }
+
+    if (b & BOUND_LOWER)
+    {
+        valueLower = (int16_t)v;
+        depthLower = (int16_t)d;
+
+        if ((bound & BOUND_UPPER) && v > valueUpper)
+        {
+            bound ^= BOUND_UPPER;
+            valueUpper = VALUE_NONE;
+            depthUpper = DEPTH_NONE;
+        }
+    }
+
+    bound |= (uint8_t)b;
   }
+
   void set_generation(int g) { generation8 = (uint8_t)g; }
 
   uint32_t key() const              { return key32; }
-  Depth depth() const               { return (Depth)depth16; }
+  Depth depth() const               { return (Depth)depthLower; }
+  Depth depth_upper() const         { return (Depth)depthUpper; }
   Move move() const                 { return (Move)move16; }
-  Value value() const               { return (Value)value16; }
-  ValueType type() const            { return (ValueType)valueType; }
+  Value value() const               { return (Value)valueLower; }
+  Value value_upper() const         { return (Value)valueUpper; }
+  Bound type() const                { return (Bound)bound; }
   int generation() const            { return (int)generation8; }
-  Value static_value() const        { return (Value)staticValue; }
-  Value static_value_margin() const { return (Value)staticMargin; }
 
 private:
   uint32_t key32;
   uint16_t move16;
-  uint8_t valueType, generation8;
-  int16_t value16, depth16, staticValue, staticMargin;
+  uint8_t bound, generation8;
+  int16_t valueLower, depthLower, valueUpper, depthUpper;
 };
 
 
@@ -103,7 +138,7 @@ public:
   ~TranspositionTable();
   void set_size(size_t mbSize);
   void clear();
-  void store(const Key posKey, Value v, ValueType type, Depth d, Move m, Value statV, Value kingD);
+  void store(const Key posKey, Value v, Bound b, Depth d, Move m);
   TTEntry* probe(const Key posKey) const;
   void new_search();
   TTEntry* first_entry(const Key posKey) const;
@@ -136,38 +171,4 @@ inline void TranspositionTable::refresh(const TTEntry* tte) const {
   const_cast<TTEntry*>(tte)->set_generation(generation);
 }
 
-
-/// 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>
-struct SimpleHash {
-
-  typedef SimpleHash<Entry, HashSize> Base;
-
-  void init() {
-
-    if (entries)
-        return;
-
-    entries = new (std::nothrow) Entry[HashSize];
-    if (!entries)
-    {
-        std::cerr << "Failed to allocate " << HashSize * sizeof(Entry)
-                  << " bytes for hash table." << std::endl;
-        exit(EXIT_FAILURE);
-    }
-    memset(entries, 0, HashSize * sizeof(Entry));
-  }
-
-  virtual ~SimpleHash() { delete [] entries; }
-
-  Entry* probe(Key key) const { return entries + ((uint32_t)key & (HashSize - 1)); }
-  void prefetch(Key key) const { ::prefetch((char*)probe(key)); }
-
-protected:
-  Entry* entries;
-};
-
 #endif // !defined(TT_H_INCLUDED)