X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Ftt.cpp;h=7efc6a0918872d6eb75be6f018c94667c720fc17;hp=0396b287cc5734b9517569e1124f91ddf0fcde73;hb=84451191f3e16be2d532353b4df3d870b84b4f5d;hpb=f4140ecc0c78d3d89f4e2459105e3ce3a1ab3ce1 diff --git a/src/tt.cpp b/src/tt.cpp index 0396b287..7efc6a09 100644 --- a/src/tt.cpp +++ b/src/tt.cpp @@ -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-2009 Marco Costalba + Copyright (C) 2008-2010 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 @@ -25,17 +25,13 @@ #include #include #include +#if !defined(__hpux) +# include +#endif #include "movegen.h" #include "tt.h" -#if defined(_MSC_VER) -#include -#endif - -// This is the number of TTEntry slots for each position -static const int ClusterSize = 4; - // The main transposition table TranspositionTable TT; @@ -59,22 +55,20 @@ TranspositionTable::~TranspositionTable() { /// TranspositionTable::set_size sets the size of the transposition table, /// measured in megabytes. -void TranspositionTable::set_size(unsigned mbSize) { +void TranspositionTable::set_size(size_t mbSize) { - assert(mbSize >= 4 && mbSize <= 4096); - - unsigned newSize = 1024; + size_t newSize = 1024; // We store a cluster of ClusterSize number of TTEntry for each position // and newSize is the maximum number of storable positions. - while ((2 * newSize) * ClusterSize * (sizeof(TTEntry)) <= (mbSize << 20)) + while ((2 * newSize) * sizeof(TTCluster) <= (mbSize << 20)) newSize *= 2; if (newSize != size) { size = newSize; delete [] entries; - entries = new TTEntry[size * ClusterSize]; + entries = new TTCluster[size]; if (!entries) { std::cerr << "Failed to allocate " << mbSize @@ -93,7 +87,7 @@ void TranspositionTable::set_size(unsigned mbSize) { void TranspositionTable::clear() { - memset(entries, 0, size * ClusterSize * sizeof(TTEntry)); + memset(entries, 0, size * sizeof(TTCluster)); } @@ -103,7 +97,7 @@ void TranspositionTable::clear() { inline TTEntry* TranspositionTable::first_entry(const Key posKey) const { - return entries + ((uint32_t(posKey) & (size - 1)) * ClusterSize); + return entries[uint32_t(posKey) & (size - 1)].data; } @@ -127,10 +121,11 @@ void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d, { if (!tte->key() || tte->key() == posKey32) // empty or overwrite old { - // Do not overwrite when new type is VALUE_TYPE_EVAL - if (tte->key() && t == VALUE_TYPE_EVAL) + // Do not overwrite when new type is VALUE_TYPE_EV_LO + if (tte->key() && t == VALUE_TYPE_EV_LO) return; + // Preserve any exsisting ttMove if (m == MOVE_NONE) m = tte->move(); @@ -174,20 +169,25 @@ TTEntry* TranspositionTable::retrieve(const Key posKey) const { /// blocking function and do not stalls the CPU waiting for data /// to be loaded from RAM, that can be very slow. When we will /// subsequently call retrieve() the TT data will be already -/// quickly accessible in L1/l2 CPU cache. +/// quickly accessible in L1/L2 CPU cache. +#if defined(__hpux) +void TranspositionTable::prefetch(const Key) const {} // Not supported on HP UX +#else void TranspositionTable::prefetch(const Key posKey) const { -#if defined(_MSC_VER) - _mm_prefetch((char*)first_entry(posKey), _MM_HINT_T0); -#else - // We need to force an asm volatile here because gcc builtin - // is optimized away by Intel compiler. - char* addr = (char*)first_entry(posKey); - asm volatile("prefetcht0 %0" :: "m" (addr)); +#if defined(__INTEL_COMPILER) || defined(__ICL) + // This hack prevents prefetches to be optimized away by + // Intel compiler. Both MSVC and gcc seems not affected. + __asm__ (""); #endif + + char const* addr = (char*)first_entry(posKey); + _mm_prefetch(addr, _MM_HINT_T2); + _mm_prefetch(addr+64, _MM_HINT_T2); // 64 bytes ahead } +#endif /// TranspositionTable::new_search() is called at the beginning of every new /// search. It increments the "generation" variable, which is used to @@ -213,7 +213,9 @@ void TranspositionTable::insert_pv(const Position& pos, Move pv[]) { for (int i = 0; pv[i] != MOVE_NONE; i++) { - store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, Depth(-127*OnePly), pv[i]); + TTEntry *tte = retrieve(p.get_key()); + if (!tte || tte->move() != pv[i]) + store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, Depth(-127*OnePly), pv[i]); p.do_move(pv[i], st); } } @@ -225,27 +227,26 @@ void TranspositionTable::insert_pv(const Position& pos, Move pv[]) { /// will often get single-move PVs when the search stops while failing high, /// and a single-move PV means that we don't have a ponder move. -void TranspositionTable::extract_pv(const Position& pos, Move pv[]) { - - int ply; - Position p(pos); - StateInfo st[100]; +void TranspositionTable::extract_pv(const Position& pos, Move pv[], const int PLY_MAX) { - for (ply = 0; pv[ply] != MOVE_NONE; ply++) - p.do_move(pv[ply], st[ply]); - - bool stop; const TTEntry* tte; - for (stop = false, tte = retrieve(p.get_key()); - tte && tte->move() != MOVE_NONE && !stop; - tte = retrieve(p.get_key()), ply++) + StateInfo st; + Position p(pos); + int ply = 0; + + // Update position to the end of current PV + while (pv[ply] != MOVE_NONE) + p.do_move(pv[ply++], st); + + // Try to add moves from TT while possible + while ( (tte = retrieve(p.get_key())) != NULL + && tte->move() != MOVE_NONE + && move_is_legal(p, tte->move()) + && (!p.is_draw() || ply < 2) + && ply < PLY_MAX) { - if (!move_is_legal(p, tte->move())) - break; pv[ply] = tte->move(); - p.do_move(pv[ply], st[ply]); - for (int j = 0; j < ply; j++) - if (st[j].key == p.get_key()) stop = true; + p.do_move(pv[ply++], st); } pv[ply] = MOVE_NONE; }