X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fbook.cpp;h=1c2d30e0a41df95358a23cd9bdf1b8ace8944315;hp=e14de41589f392248777f31f7634e7072f3c7a76;hb=55bd27b8f08a151128d7065fa2819aa3e9605299;hpb=6b5322ce000d6a8a6f845beda2d7e149e1baea0c diff --git a/src/book.cpp b/src/book.cpp index e14de415..1c2d30e0 100644 --- a/src/book.cpp +++ b/src/book.cpp @@ -35,6 +35,16 @@ using namespace std; namespace { + // A Polyglot book is a series of "entries" of 16 bytes. All integers are + // stored in big-endian format, with highest byte first (regardless of size). + // The entries are ordered according to the key in ascending order. + struct BookEntry { + uint64_t key; + uint16_t move; + uint16_t count; + uint32_t learn; + }; + // Random numbers from PolyGlot, used to compute book hash keys const Key PolyGlotRandoms[781] = { 0x9D39247E33776D41ULL, 0x2AF7398005AAA5C7ULL, 0x44DB015024623547ULL, @@ -301,10 +311,10 @@ namespace { }; // Offsets to the PolyGlotRandoms[] array of zobrist keys - const Key* ZobPiece = PolyGlotRandoms + 0; - const Key* ZobCastle = PolyGlotRandoms + 768; - const Key* ZobEnPassant = PolyGlotRandoms + 772; - const Key* ZobTurn = PolyGlotRandoms + 780; + const Key* ZobPiece = PolyGlotRandoms; + const Key* ZobCastle = ZobPiece + 12 * 64; // Pieces * squares + const Key* ZobEnPassant = ZobCastle + 4; // Castle flags + const Key* ZobTurn = ZobEnPassant + 8; // Number of files // book_key() returns the PolyGlot hash key of the given position uint64_t book_key(const Position& pos) { @@ -314,12 +324,12 @@ namespace { while (b) { - // Piece offset is at 64 * polyPiece where polyPiece is defined as: + // In PolyGlotRandoms[] pieces are stored in the following sequence: // BP = 0, WP = 1, BN = 2, WN = 3, ... BK = 10, WK = 11 Square s = pop_lsb(&b); Piece p = pos.piece_on(s); - int polyPiece = 2 * (type_of(p) - 1) + (color_of(p) == WHITE); - key ^= ZobPiece[64 * polyPiece + s]; + int pieceOfs = 2 * (type_of(p) - 1) + (color_of(p) == WHITE); + key ^= ZobPiece[64 * pieceOfs + s]; } b = pos.can_castle(ALL_CASTLES); @@ -338,20 +348,20 @@ namespace { } // namespace -Book::Book() : size(0) { +PolyglotBook::PolyglotBook() { - for (int i = Time::current_time().msec() % 10000; i > 0; i--) + for (int i = Time::now() % 10000; i > 0; i--) RKiss.rand(); // Make random number generation less deterministic } -Book::~Book() { if (is_open()) close(); } +PolyglotBook::~PolyglotBook() { if (is_open()) close(); } -/// Book::operator>>() reads sizeof(T) chars from the file's binary byte stream -/// and converts them in a number of type T. A Polyglot book stores numbers in +/// operator>>() reads sizeof(T) chars from the file's binary byte stream and +/// converts them in a number of type T. A Polyglot book stores numbers in /// big-endian format. -template Book& Book::operator>>(T& n) { +template PolyglotBook& PolyglotBook::operator>>(T& n) { n = 0; for (size_t i = 0; i < sizeof(T); i++) @@ -360,48 +370,35 @@ template Book& Book::operator>>(T& n) { return *this; } -template<> Book& Book::operator>>(BookEntry& e) { +template<> PolyglotBook& PolyglotBook::operator>>(BookEntry& e) { return *this >> e.key >> e.move >> e.count >> e.learn; } -/// Book::open() tries to open a book file with the given name after closing -/// any exsisting one. - -bool Book::open(const char* fName) { +/// open() tries to open a book file with the given name after closing any +/// exsisting one. - fileName = ""; +bool PolyglotBook::open(const char* fName) { if (is_open()) // Cannot close an already closed file close(); - ifstream::open(fName, ifstream::in | ifstream::binary | ios::ate); - - if (!is_open()) - { - clear(); - return false; // Silently fail if the file is not found - } - - // Get the book size in number of entries, we are already at the end of file - size = (size_t)tellg() / sizeof(BookEntry); - - if (!good()) - { - cerr << "Failed to open book file " << fName << endl; - exit(EXIT_FAILURE); - } + ifstream::open(fName, ifstream::in | ifstream::binary); - fileName = fName; // Set only if successful - return true; + fileName = is_open() ? fName : ""; + ifstream::clear(); // Reset any error flag to allow retry ifstream::open() + return !fileName.empty(); } -/// Book::probe() tries to find a book move for the given position. If no move -/// is found returns MOVE_NONE. If pickBest is true returns always the highest +/// probe() tries to find a book move for the given position. If no move is +/// found returns MOVE_NONE. If pickBest is true returns always the highest /// rated move, otherwise randomly chooses one, based on the move score. -Move Book::probe(const Position& pos, const string& fName, bool pickBest) { +Move PolyglotBook::probe(const Position& pos, const string& fName, bool pickBest) { + + if (fileName != fName && !open(fName.c_str())) + return MOVE_NONE; BookEntry e; uint16_t best = 0; @@ -409,10 +406,7 @@ Move Book::probe(const Position& pos, const string& fName, bool pickBest) { Move move = MOVE_NONE; uint64_t key = book_key(pos); - if (fileName != fName && !open(fName.c_str())) - return MOVE_NONE; - - binary_search(key); + seekg(find_first(key) * sizeof(BookEntry), ios_base::beg); while (*this >> e, e.key == key && good()) { @@ -446,24 +440,23 @@ Move Book::probe(const Position& pos, const string& fName, bool pickBest) { // Add 'special move' flags and verify it is legal for (MoveList ml(pos); !ml.end(); ++ml) - if (move == (ml.move() & 0x3FFF)) + if (move == (ml.move() ^ type_of(ml.move()))) return ml.move(); return MOVE_NONE; } -/// Book::binary_search() takes a book key as input, and does a binary search -/// through the book file for the given key. File stream current position is set -/// to the leftmost book entry with the same key as the input. +/// find_first() takes a book key as input, and does a binary search through +/// the book file for the given key. Returns the index of the leftmost book +/// entry with the same key as the input. -void Book::binary_search(uint64_t key) { +size_t PolyglotBook::find_first(uint64_t key) { - size_t low, high, mid; - BookEntry e; + seekg(0, ios::end); // Move pointer to end, so tellg() gets file's size - low = 0; - high = size - 1; + size_t low = 0, mid, high = (size_t)tellg() / sizeof(BookEntry) - 1; + BookEntry e; assert(low <= high); @@ -484,5 +477,5 @@ void Book::binary_search(uint64_t key) { assert(low == high); - seekg(low * sizeof(BookEntry), ios_base::beg); + return low; }