X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsyzygy%2Ftbprobe.cpp;h=b761b38141b6d6abbe43e1f356859d8719642de2;hp=9debcc6f9393409494ea91af9a768b6fbea2ea0d;hb=b36489742b3cfd045c1960fa299199401cd0265d;hpb=876f07cbeea5b583ca75685cefa0fd4be1e904a4 diff --git a/src/syzygy/tbprobe.cpp b/src/syzygy/tbprobe.cpp index 9debcc6f..b761b381 100644 --- a/src/syzygy/tbprobe.cpp +++ b/src/syzygy/tbprobe.cpp @@ -1,7 +1,7 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (c) 2013 Ronald de Man - Copyright (C) 2016 Marco Costalba, Lucas Braesch + Copyright (C) 2016-2017 Marco Costalba, Lucas Braesch Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -65,10 +65,10 @@ inline Square operator^(Square s, int i) { return Square(int(s) ^ i); } // like captures and pawn moves but we can easily recover the correct dtz of the // previous move if we know the position's WDL score. int dtz_before_zeroing(WDLScore wdl) { - return wdl == WDLWin ? 1 : - wdl == WDLCursedWin ? 101 : - wdl == WDLCursedLoss ? -101 : - wdl == WDLLoss ? -1 : 0; + return wdl == WDLWin ? 1 : + wdl == WDLCursedWin ? 101 : + wdl == WDLBlessedLoss ? -101 : + wdl == WDLLoss ? -1 : 0; } // Return the sign of a number (-1, 0, 1) @@ -125,18 +125,39 @@ struct PairsData { int groupLen[TBPIECES+1]; // Number of pieces in a given group: KRKN -> (3, 1) }; -// Helper struct to avoid to manually define entry copy c'tor as we should -// because default one is not compatible with std::atomic_bool. +// Helper struct to avoid manually defining entry copy constructor as we +// should because the default one is not compatible with std::atomic_bool. struct Atomic { Atomic() = default; Atomic(const Atomic& e) { ready = e.ready.load(); } // MSVC 2013 wants assignment within body std::atomic_bool ready; }; -struct WDLEntry : public Atomic { - WDLEntry(const std::string& code); - ~WDLEntry(); +// We define types for the different parts of the WDLEntry and DTZEntry with +// corresponding specializations for pieces or pawns. + +struct WDLEntryPiece { + PairsData* precomp; +}; + +struct WDLEntryPawn { + uint8_t pawnCount[2]; // [Lead color / other color] + WDLEntryPiece file[2][4]; // [wtm / btm][FILE_A..FILE_D] +}; + +struct DTZEntryPiece { + PairsData* precomp; + uint16_t map_idx[4]; // WDLWin, WDLLoss, WDLCursedWin, WDLBlessedLoss + uint8_t* map; +}; +struct DTZEntryPawn { + uint8_t pawnCount[2]; + DTZEntryPiece file[4]; + uint8_t* map; +}; + +struct TBEntry : public Atomic { void* baseAddress; uint64_t mapping; Key key; @@ -144,46 +165,24 @@ struct WDLEntry : public Atomic { int pieceCount; bool hasPawns; bool hasUniquePieces; +}; + +// Now the main types: WDLEntry and DTZEntry +struct WDLEntry : public TBEntry { + WDLEntry(const std::string& code); + ~WDLEntry(); union { - struct { - PairsData* precomp; - } pieceTable[2]; // [wtm / btm] - - struct { - uint8_t pawnCount[2]; // [Lead color / other color] - struct { - PairsData* precomp; - } file[2][4]; // [wtm / btm][FILE_A..FILE_D] - } pawnTable; + WDLEntryPiece pieceTable[2]; // [wtm / btm] + WDLEntryPawn pawnTable; }; }; -struct DTZEntry : public Atomic { +struct DTZEntry : public TBEntry { DTZEntry(const WDLEntry& wdl); ~DTZEntry(); - - void* baseAddress; - uint64_t mapping; - Key key; - Key key2; - int pieceCount; - bool hasPawns; - bool hasUniquePieces; union { - struct { - PairsData* precomp; - uint16_t map_idx[4]; // WDLWin, WDLLoss, WDLCursedWin, WDLCursedLoss - uint8_t* map; - } pieceTable; - - struct { - uint8_t pawnCount[2]; - struct { - PairsData* precomp; - uint16_t map_idx[4]; - } file[4]; - uint8_t* map; - } pawnTable; + DTZEntryPiece pieceTable; + DTZEntryPawn pawnTable; }; }; @@ -229,10 +228,10 @@ template inline void swap_byte(T& x) { char tmp, *c = (char*)&x; - if (Half) // Fix a MSVC 2015 warning - for (int i = 0; i < Half; ++i) - tmp = c[i], c[i] = c[End - i], c[End - i] = tmp; + for (int i = 0; i < Half; ++i) + tmp = c[i], c[i] = c[End - i], c[End - i] = tmp; } +template<> inline void swap_byte(uint8_t&) {} template T number(void* addr) { @@ -342,6 +341,10 @@ public: #ifndef _WIN32 struct stat statbuf; int fd = ::open(fname.c_str(), O_RDONLY); + + if (fd == -1) + return *baseAddress = nullptr, nullptr; + fstat(fd, &statbuf); *mapping = statbuf.st_size; *baseAddress = mmap(nullptr, statbuf.st_size, PROT_READ, MAP_SHARED, fd, 0); @@ -354,6 +357,10 @@ public: #else HANDLE fd = CreateFile(fname.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr); + + if (fd == INVALID_HANDLE_VALUE) + return *baseAddress = nullptr, nullptr; + DWORD size_high; DWORD size_low = GetFileSize(fd, &size_high); HANDLE mmap = CreateFileMapping(fd, nullptr, PAGE_READONLY, size_high, size_low, nullptr); @@ -381,8 +388,7 @@ public: || *data++ != *TB_MAGIC) { std::cerr << "Corrupted table in file " << fname << std::endl; unmap(*baseAddress, *mapping); - *baseAddress = nullptr; - return nullptr; + return *baseAddress = nullptr, nullptr; } return data; @@ -483,15 +489,15 @@ void HashTable::insert(const std::vector& pieces) { TBFile file(code.insert(code.find('K', 1), "v") + ".rtbw"); // KRK -> KRvK - if (!file.is_open()) + if (!file.is_open()) // Only WDL file is checked return; file.close(); MaxCardinality = std::max((int)pieces.size(), MaxCardinality); - wdlTable.push_back(WDLEntry(code)); - dtzTable.push_back(DTZEntry(wdlTable.back())); + wdlTable.emplace_back(code); + dtzTable.emplace_back(wdlTable.back()); insert(wdlTable.back().key , &wdlTable.back(), &dtzTable.back()); insert(wdlTable.back().key2, &wdlTable.back(), &dtzTable.back()); @@ -532,14 +538,14 @@ int decompress_pairs(PairsData* d, uint64_t idx) { // // I(k) = k * d->span + d->span / 2 (1) - // First step is to get the 'k' of the I(k) nearest to our idx, using defintion (1) + // First step is to get the 'k' of the I(k) nearest to our idx, using definition (1) uint32_t k = idx / d->span; // Then we read the corresponding SparseIndex[] entry uint32_t block = number(&d->sparseIndex[k].block); int offset = number(&d->sparseIndex[k].offset); - // Now compute the difference idx - I(k). From defintion of k we know that + // Now compute the difference idx - I(k). From definition of k we know that // // idx = k * d->span + idx % d->span (2) // @@ -661,7 +667,7 @@ int map_score(DTZEntry* entry, File f, int value, WDLScore wdl) { if ( (wdl == WDLWin && !(flags & TBFlag::WinPlies)) || (wdl == WDLLoss && !(flags & TBFlag::LossPlies)) || wdl == WDLCursedWin - || wdl == WDLCursedLoss) + || wdl == WDLBlessedLoss) value *= 2; return value + 1; @@ -674,7 +680,7 @@ int map_score(DTZEntry* entry, File f, int value, WDLScore wdl) { // idx = Binomial[1][s1] + Binomial[2][s2] + ... + Binomial[k][sk] // template::type> -T do_probe_table(const Position& pos, Entry* entry, WDLScore wdl, ProbeState* result) { +T do_probe_table(const Position& pos, Entry* entry, WDLScore wdl, ProbeState* result) { const bool IsWDL = std::is_same::value; @@ -714,8 +720,9 @@ T do_probe_table(const Position& pos, Entry* entry, WDLScore wdl, ProbeState* r assert(type_of(pc) == PAWN); leadPawns = b = pos.pieces(color_of(pc), PAWN); - while (b) + do squares[size++] = pop_lsb(&b) ^ flipSquares; + while (b); leadPawnsCnt = size; @@ -738,11 +745,13 @@ T do_probe_table(const Position& pos, Entry* entry, WDLScore wdl, ProbeState* r // Now we are ready to get all the position pieces (but the lead pawns) and // directly map them to the correct color and square. b = pos.pieces() ^ leadPawns; - while (b) { + do { Square s = pop_lsb(&b); squares[size] = s ^ flipSquares; pieces[size++] = Piece(pos.piece_on(s) ^ flipColor); - } + } while (b); + + assert(size >= 2); // Then we reorder the pieces to have the same sequence as the one stored // in precomp->pieces[i]: the sequence that ensures the best compression. @@ -979,8 +988,8 @@ uint8_t* set_sizes(PairsData* d, uint8_t* data) { d->flags = *data++; if (d->flags & TBFlag::SingleValue) { - d->blocksNum = d->span = - d->blockLengthSize = d->sparseIndexSize = 0; // Broken MSVC zero-init + d->blocksNum = d->blockLengthSize = 0; + d->span = d->sparseIndexSize = 0; // Broken MSVC zero-init d->minSymLen = *data++; // Here we store the single value return data; } @@ -1108,7 +1117,7 @@ void do_init(Entry& e, T& p, uint8_t* data) { for (File f = FILE_A; f <= MaxFile; ++f) for (int i = 0; i < Sides; i++) { (d = item(p, i, f).precomp)->sparseIndex = (SparseEntry*)data; - data += d->sparseIndexSize * sizeof(SparseEntry) ; + data += d->sparseIndexSize * sizeof(SparseEntry); } for (File f = FILE_A; f <= MaxFile; ++f) @@ -1207,7 +1216,7 @@ WDLScore search(Position& pos, ProbeState* result) { moveCount++; - pos.do_move(move, st, pos.gives_check(move)); + pos.do_move(move, st); value = -search(pos, result); pos.undo_move(move); @@ -1293,7 +1302,7 @@ void Tablebases::init(const std::string& paths) { if (MapA1D1D4[s1] == idx && (idx || s1 == SQ_B1)) // SQ_B1 is mapped to 0 { for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2) - if ((StepAttacksBB[KING][s1] | s1) & s2) + if ((PseudoAttacks[KING][s1] | s1) & s2) continue; // Illegal position else if (!off_A1H8(s1) && off_A1H8(s2) > 0) @@ -1444,7 +1453,7 @@ int Tablebases::probe_dtz(Position& pos, ProbeState* result) { return 0; if (*result != CHANGE_STM) - return (dtz + 100 * (wdl == WDLCursedLoss || wdl == WDLCursedWin)) * sign_of(wdl); + return (dtz + 100 * (wdl == WDLBlessedLoss || wdl == WDLCursedWin)) * sign_of(wdl); // DTZ stores results for the other side, so we need to do a 1-ply search and // find the winning move that minimizes DTZ. @@ -1455,7 +1464,7 @@ int Tablebases::probe_dtz(Position& pos, ProbeState* result) { { bool zeroing = pos.capture(move) || type_of(pos.moved_piece(move)) == PAWN; - pos.do_move(move, st, pos.gives_check(move)); + pos.do_move(move, st); // For zeroing moves we want the dtz of the move _before_ doing it, // otherwise we will get the dtz of the next move sequence. Search the @@ -1518,6 +1527,8 @@ static int has_repeated(StateInfo *st) // no moves were filtered out. bool Tablebases::root_probe(Position& pos, Search::RootMoves& rootMoves, Value& score) { + assert(rootMoves.size()); + ProbeState result; int dtz = probe_dtz(pos, &result); @@ -1529,7 +1540,7 @@ bool Tablebases::root_probe(Position& pos, Search::RootMoves& rootMoves, Value& // Probe each move for (size_t i = 0; i < rootMoves.size(); ++i) { Move move = rootMoves[i].pv[0]; - pos.do_move(move, st, pos.gives_check(move)); + pos.do_move(move, st); int v = 0; if (pos.checkers() && dtz > 0) { @@ -1563,16 +1574,16 @@ bool Tablebases::root_probe(Position& pos, Search::RootMoves& rootMoves, Value& // Obtain 50-move counter for the root position. // In Stockfish there seems to be no clean way, so we do it like this: - int cnt50 = st.previous->rule50; + int cnt50 = st.previous ? st.previous->rule50 : 0; // Use 50-move counter to determine whether the root position is // won, lost or drawn. - int wdl = 0; + WDLScore wdl = WDLDraw; if (dtz > 0) - wdl = (dtz + cnt50 <= 100) ? 2 : 1; + wdl = (dtz + cnt50 <= 100) ? WDLWin : WDLCursedWin; else if (dtz < 0) - wdl = (-dtz + cnt50 <= 100) ? -2 : -1; + wdl = (-dtz + cnt50 <= 100) ? WDLLoss : WDLBlessedLoss; // Determine the score to report to the user. score = WDL_to_value[wdl + 2]; @@ -1580,9 +1591,9 @@ bool Tablebases::root_probe(Position& pos, Search::RootMoves& rootMoves, Value& // If the position is winning or losing, but too few moves left, adjust the // score to show how close it is to winning or losing. // NOTE: int(PawnValueEg) is used as scaling factor in score_to_uci(). - if (wdl == 1 && dtz <= 100) + if (wdl == WDLCursedWin && dtz <= 100) score = (Value)(((200 - dtz - cnt50) * int(PawnValueEg)) / 200); - else if (wdl == -1 && dtz >= -100) + else if (wdl == WDLBlessedLoss && dtz >= -100) score = -(Value)(((200 + dtz - cnt50) * int(PawnValueEg)) / 200); // Now be a bit smart about filtering out moves. @@ -1665,7 +1676,7 @@ bool Tablebases::root_probe_wdl(Position& pos, Search::RootMoves& rootMoves, Val // Probe each move for (size_t i = 0; i < rootMoves.size(); ++i) { Move move = rootMoves[i].pv[0]; - pos.do_move(move, st, pos.gives_check(move)); + pos.do_move(move, st); WDLScore v = -Tablebases::probe_wdl(pos, &result); pos.undo_move(move);