mirror of
https://github.com/sockspls/badfish
synced 2025-07-12 12:09:14 +00:00
4b10578acb
Conceptually group hash clusters into super clusters of 256 clusters. This scheme allows us to use hash sizes up to 32 TB (= 2^32 super clusters = 2^40 clusters). Use 48 bits of the Zobrist key to choose the cluster index. We use 8 extra bits to mitigate the quantization error for very large hashes when scaling the hash key to cluster index. The hash index computation is organized to be compatible with the existing scheme for power-of-two hash sizes up to 128 GB. Fixes https://github.com/official-stockfish/Stockfish/issues/1349 closes https://github.com/official-stockfish/Stockfish/pull/2722 Passed non-regression STC: LLR: 2.93 (-2.94,2.94) {-1.50,0.50} Total: 37976 W: 7336 L: 7211 D: 23429 Ptnml(0-2): 578, 4295, 9149, 4356, 610 https://tests.stockfishchess.org/tests/view/5edcbaaef29b40b0fc95abc5 No functional change.
108 lines
3.3 KiB
C++
108 lines
3.3 KiB
C++
/*
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
|
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
|
|
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
|
|
Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, 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
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Stockfish 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/>.
|
|
*/
|
|
|
|
#ifndef TT_H_INCLUDED
|
|
#define TT_H_INCLUDED
|
|
|
|
#include "misc.h"
|
|
#include "types.h"
|
|
|
|
/// TTEntry struct is the 10 bytes transposition table entry, defined as below:
|
|
///
|
|
/// key 16 bit
|
|
/// move 16 bit
|
|
/// value 16 bit
|
|
/// eval value 16 bit
|
|
/// generation 5 bit
|
|
/// pv node 1 bit
|
|
/// bound type 2 bit
|
|
/// depth 8 bit
|
|
|
|
struct TTEntry {
|
|
|
|
Move move() const { return (Move )move16; }
|
|
Value value() const { return (Value)value16; }
|
|
Value eval() const { return (Value)eval16; }
|
|
Depth depth() const { return (Depth)depth8 + DEPTH_OFFSET; }
|
|
bool is_pv() const { return (bool)(genBound8 & 0x4); }
|
|
Bound bound() const { return (Bound)(genBound8 & 0x3); }
|
|
void save(Key k, Value v, bool pv, Bound b, Depth d, Move m, Value ev);
|
|
|
|
private:
|
|
friend class TranspositionTable;
|
|
|
|
uint16_t key16;
|
|
uint16_t move16;
|
|
int16_t value16;
|
|
int16_t eval16;
|
|
uint8_t genBound8;
|
|
uint8_t depth8;
|
|
};
|
|
|
|
|
|
/// A TranspositionTable is an array of Cluster, of size clusterCount. Each
|
|
/// cluster consists of ClusterSize number of TTEntry. Each non-empty TTEntry
|
|
/// contains information on exactly one position. The size of a Cluster should
|
|
/// divide the size of a cache line for best performance,
|
|
/// as the cacheline is prefetched when possible.
|
|
|
|
class TranspositionTable {
|
|
|
|
static constexpr int ClusterSize = 3;
|
|
static constexpr int ClustersPerSuperCluster = 256;
|
|
|
|
struct Cluster {
|
|
TTEntry entry[ClusterSize];
|
|
char padding[2]; // Pad to 32 bytes
|
|
};
|
|
|
|
static_assert(sizeof(Cluster) == 32, "Unexpected Cluster size");
|
|
|
|
public:
|
|
~TranspositionTable() { aligned_ttmem_free(mem); }
|
|
void new_search() { generation8 += 8; } // Lower 3 bits are used by PV flag and Bound
|
|
TTEntry* probe(const Key key, bool& found) const;
|
|
int hashfull() const;
|
|
void resize(size_t mbSize);
|
|
void clear();
|
|
|
|
TTEntry* first_entry(const Key key) const {
|
|
|
|
// The index is computed from
|
|
// Idx = (K48 * SCC) / 2^40, with K48 the 48 lowest bits swizzled.
|
|
|
|
const uint64_t firstTerm = uint32_t(key) * uint64_t(superClusterCount);
|
|
const uint64_t secondTerm = (uint16_t(key >> 32) * uint64_t(superClusterCount)) >> 16;
|
|
|
|
return &table[(firstTerm + secondTerm) >> 24].entry[0];
|
|
}
|
|
|
|
private:
|
|
friend struct TTEntry;
|
|
|
|
size_t superClusterCount;
|
|
Cluster* table;
|
|
void* mem;
|
|
uint8_t generation8; // Size must be not bigger than TTEntry::genBound8
|
|
};
|
|
|
|
extern TranspositionTable TT;
|
|
|
|
#endif // #ifndef TT_H_INCLUDED
|