git.sesse.net Git - stockfish/blob - src/tt.h

   1 /*
   2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   3   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
   4   Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
   5
   6   Stockfish is free software: you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published by
   8   the Free Software Foundation, either version 3 of the License, or
   9   (at your option) any later version.
  10
  11   Stockfish is distributed in the hope that it will be useful,
  12   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14   GNU General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #if !defined(TT_H_INCLUDED)
  21 #define TT_H_INCLUDED
  22
  23 #include "misc.h"
  24 #include "types.h"
  25
  26 /// The TTEntry is the class of transposition table entries
  27 ///
  28 /// A TTEntry needs 128 bits to be stored
  29 ///
  30 /// bit  0-31: key
  31 /// bit 32-63: data
  32 /// bit 64-79: value
  33 /// bit 80-95: depth
  34 /// bit 96-111: static value
  35 /// bit 112-127: margin of static value
  36 ///
  37 /// the 32 bits of the data field are so defined
  38 ///
  39 /// bit  0-15: move
  40 /// bit 16-20: not used
  41 /// bit 21-22: value type
  42 /// bit 23-31: generation
  43
  44 class TTEntry {
  45
  46 public:
  47   void save(uint32_t k, Value v, Bound b, Depth d, Move m, int g, Value ev, Value em) {
  48
  49     key32        = (uint32_t)k;
  50     move16       = (uint16_t)m;
  51     bound        = (uint8_t)b;
  52     generation8  = (uint8_t)g;
  53     value16      = (int16_t)v;
  54     depth16      = (int16_t)d;
  55     evalValue    = (int16_t)ev;
  56     evalMargin   = (int16_t)em;
  57   }
  58   void set_generation(int g) { generation8 = (uint8_t)g; }
  59
  60   uint32_t key() const      { return key32; }
  61   Depth depth() const       { return (Depth)depth16; }
  62   Move move() const         { return (Move)move16; }
  63   Value value() const       { return (Value)value16; }
  64   Bound type() const        { return (Bound)bound; }
  65   int generation() const    { return (int)generation8; }
  66   Value eval_value() const  { return (Value)evalValue; }
  67   Value eval_margin() const { return (Value)evalMargin; }
  68
  69 private:
  70   uint32_t key32;
  71   uint16_t move16;
  72   uint8_t bound, generation8;
  73   int16_t value16, depth16, evalValue, evalMargin;
  74 };
  75
  76
  77 /// A TranspositionTable consists of a power of 2 number of clusters and each
  78 /// cluster consists of ClusterSize number of TTEntry. Each non-empty entry
  79 /// contains information of exactly one position. Size of a cluster shall not be
  80 /// bigger than a cache line size. In case it is less, it should be padded to
  81 /// guarantee always aligned accesses.
  82
  83 class TranspositionTable {
  84
  85   static const unsigned ClusterSize = 4; // A cluster is 64 Bytes
  86
  87 public:
  88  ~TranspositionTable() { delete [] table; }
  89   void new_search() { generation++; }
  90
  91   TTEntry* probe(const Key key) const;
  92   TTEntry* first_entry(const Key key) const;
  93   void refresh(const TTEntry* tte) const;
  94   void set_size(size_t mbSize);
  95   void clear();
  96   void store(const Key key, Value v, Bound type, Depth d, Move m, Value statV, Value kingD);
  97
  98 private:
  99   uint32_t hashMask;
 100   TTEntry* table;
 101   uint8_t generation; // Size must be not bigger then TTEntry::generation8
 102 };
 103
 104 extern TranspositionTable TT;
 105
 106
 107 /// TranspositionTable::first_entry() returns a pointer to the first entry of
 108 /// a cluster given a position. The lowest order bits of the key are used to
 109 /// get the index of the cluster.
 110
 111 inline TTEntry* TranspositionTable::first_entry(const Key key) const {
 112
 113   return table + ((uint32_t)key & hashMask);
 114 }
 115
 116
 117 /// TranspositionTable::refresh() updates the 'generation' value of the TTEntry
 118 /// to avoid aging. Normally called after a TT hit.
 119
 120 inline void TranspositionTable::refresh(const TTEntry* tte) const {
 121
 122   const_cast<TTEntry*>(tte)->set_generation(generation);
 123 }
 124
 125 #endif // !defined(TT_H_INCLUDED)