X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fbook.cpp;h=8e4778eed711813b5ad6c3a46ff77b783aa859c9;hp=3ca5efe31cc41d38fc6b373e1eeb8dcdbc47e6a7;hb=a03b8074c884086d13b80e1d291b3800a4512a3c;hpb=c034cce27c5dfb28f4b3c430e365675710ec96c2 diff --git a/src/book.cpp b/src/book.cpp index 3ca5efe3..8e4778ee 100644 --- a/src/book.cpp +++ b/src/book.cpp @@ -1,17 +1,18 @@ /* - Glaurung, a UCI chess playing engine. - Copyright (C) 2004-2008 Tord Romstad + Stockfish, a UCI chess playing engine derived from Glaurung 2.1 + Copyright (C) 2004-2008 Tord Romstad (Glaurung author) + Copyright (C) 2008 Marco Costalba - Glaurung is free software: you can redistribute it and/or modify + 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. - - Glaurung is distributed in the hope that it will be useful, + + 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 . */ @@ -34,6 +35,7 @@ #include "mersenne.h" #include "movegen.h" +using namespace std; //// //// Global variables @@ -48,7 +50,11 @@ Book OpeningBook; namespace { - /// Random numbers from PolyGlot, used to compute book hash keys. + /// Book entry size in bytes + const int EntrySize = 16; + + + /// Random numbers from PolyGlot, used to compute book hash keys const uint64_t Random64[781] = { 0x9D39247E33776D41ULL, 0x2AF7398005AAA5C7ULL, 0x44DB015024623547ULL, @@ -316,31 +322,20 @@ namespace { /// Indices to the Random64[] array - - const int RandomPiece = 0; - const int RandomCastle = 768; - const int RandomEnPassant = 772; - const int RandomTurn = 780; - - /// Convert pieces to the range 0..1 - - const int PieceTo12[] = { - 0, 0, 2, 4, 6, 8, 10, 0, 0, 1, 3, 5, 7, 9, 11 - }; + const int RandomPiece = 0; + const int RandomCastle = 768; + const int RandomEnPassant = 772; + const int RandomTurn = 780; /// Prototypes - - uint64_t book_key(const Position &pos); - uint64_t book_piece_key(Piece p, Square s); - uint64_t book_castle_key(const Position &pos); - uint64_t book_ep_key(const Position &pos); - uint64_t book_color_key(const Position &pos); - uint16_t read_integer16(std::ifstream& file); - uint64_t read_integer64(std::ifstream& file); - uint64_t read_integer(std::ifstream& file, int size); + uint64_t book_key(const Position& pos); + uint64_t book_piece_key(Piece p, Square s); + uint64_t book_castle_key(const Position& pos); + uint64_t book_ep_key(const Position& pos); + uint64_t book_color_key(const Position& pos); } @@ -349,99 +344,98 @@ namespace { //// -/// Constructor - -Book::Book() : bookSize(0) {} - - -/// Book::open() opens a book file with a given file name. +/// Book::open() opens a book file with a given file name -void Book::open(const std::string &fName) { +void Book::open(const string& fName) { fileName = fName; - bookFile.open(fileName.c_str(), std::ifstream::in | std::ifstream::binary); - if (!bookFile.is_open()) + ifstream::open(fileName.c_str(), ifstream::in | ifstream::binary); + if (!is_open()) return; - bookFile.seekg(0, std::ios::end); - bookSize = bookFile.tellg() / 16; - bookFile.seekg(0, std::ios::beg); + // Get the book size in number of entries + seekg(0, ios::end); + bookSize = tellg() / EntrySize; + seekg(0, ios::beg); - if (!bookFile.good()) + if (!good()) { - std::cerr << "Failed to open book file " << fileName << std::endl; + cerr << "Failed to open book file " << fileName << endl; + close(); exit(EXIT_FAILURE); } } -/// Book::close() closes the currently open book file. +/// Book::close() closes the file only if it is open, otherwise +/// we can end up in a little mess due to how std::ifstream works. void Book::close() { - if (bookFile.is_open()) - bookFile.close(); -} - - -/// Book::is_open() tests whether a book file has been opened. - -bool Book::is_open() const { - - return bookFile.is_open() && bookSize != 0; + if (is_open()) + ifstream::close(); } /// Book::file_name() returns the file name of the currently active book, /// or the empty string if no book is open. -const std::string Book::file_name() const { +const string Book::file_name() const { - return bookFile.is_open() ? fileName : ""; + return is_open() ? fileName : ""; } - -/// Book::get_move() gets a book move for a given position. Returns + +/// Book::get_move() gets a book move for a given position. Returns /// MOVE_NONE if no book move is found. -Move Book::get_move(const Position &pos) const { - if(this->is_open()) { - int bestMove = 0, bestScore = 0, move, score; - uint64_t key = book_key(pos); - BookEntry entry; - - for(int i = this->find_key(key); i < bookSize; i++) { - this->read_entry(entry, i); - if(entry.key != key) - break; - move = entry.move; - score = entry.count; +Move Book::get_move(const Position& pos) { + + if (!is_open() || bookSize == 0) + return MOVE_NONE; + + int bookMove = 0, scoresSum = 0; + uint64_t key = book_key(pos); + BookEntry entry; + + // Choose a book move among the possible moves for the given position + for (int idx = find_key(key); idx < bookSize; idx++) + { + read_entry(entry, idx); + if (entry.key != key) + break; + + int score = entry.count; + assert(score > 0); - bestScore += score; - if(int(genrand_int32() % bestScore) < score) - bestMove = move; - } + // Choose book move according to its score. If a move has a very + // high score it has more probability to be choosen then a one with + // lower score. Note that first entry is always chosen. + scoresSum += score; + if (int(genrand_int32() % scoresSum) < score) + bookMove = entry.move; + } + if (!bookMove) + return MOVE_NONE; - if(bestMove != 0) { - MoveStack moves[256]; - int n, j; - n = generate_legal_moves(pos, moves); - for(j = 0; j < n; j++) - if((int(moves[j].move) & 07777) == bestMove) + MoveStack moves[256]; + int n = generate_legal_moves(pos, moves); + for (int j = 0; j < n; j++) + if ((int(moves[j].move) & 07777) == bookMove) return moves[j].move; - } - } + return MOVE_NONE; } /// Book::find_key() takes a book key as input, and does a binary search -/// through the book file for the given key. The index to the first book -/// entry with the same key as the input is returned. When the key is not +/// through the book file for the given key. The index to the first book +/// entry with the same key as the input is returned. When the key is not /// found in the book file, bookSize is returned. -int Book::find_key(uint64_t key) const { +int Book::find_key(uint64_t key) { + int left, right, mid; BookEntry entry; @@ -451,46 +445,60 @@ int Book::find_key(uint64_t key) const { assert(left <= right); - while(left < right) { - mid = (left + right) / 2; - assert(mid >= left && mid < right); + while (left < right) + { + mid = (left + right) / 2; - this->read_entry(entry, mid); + assert(mid >= left && mid < right); - if(key <= entry.key) - right = mid; - else - left = mid + 1; + read_entry(entry, mid); + if (key <= entry.key) + right = mid; + else + left = mid + 1; } assert(left == right); - this->read_entry(entry, left); - + read_entry(entry, left); return (entry.key == key)? left : bookSize; } /// Book::read_entry() takes a BookEntry reference and an integer index as /// input, and looks up the opening book entry at the given index in the book -/// file. The book entry is copied to the first input parameter. +/// file. The book entry is copied to the first input parameter. -void Book::read_entry(BookEntry& entry, int n) const { +void Book::read_entry(BookEntry& entry, int idx) { - assert(n >= 0 && n < bookSize); - assert(bookFile.is_open()); + assert(idx >= 0 && idx < bookSize); + assert(is_open()); - bookFile.seekg(n*16, std::ios_base::beg); - if (!bookFile.good()) + seekg(idx * EntrySize, ios_base::beg); + *this >> entry; + if (!good()) { - std::cerr << "Failed to read book entry at index " << n << std::endl; - exit(EXIT_FAILURE); + cerr << "Failed to read book entry at index " << idx << endl; + close(); + exit(EXIT_FAILURE); } - entry.key = read_integer64(bookFile); - entry.move = read_integer16(bookFile); - entry.count = read_integer16(bookFile); - entry.n = read_integer16(bookFile); - entry.sum = read_integer16(bookFile); +} + + +/// Book::read_integer() reads size chars from the file stream +/// and converts them in an integer number. + +uint64_t Book::read_integer(int size) { + + char buf[8]; + read(buf, size); + + // Numbers are stored on disk as a binary byte stream + uint64_t n = 0ULL; + for (int i = 0; i < size; i++) + n = (n << 8) + (unsigned char)buf[i]; + + return n; } @@ -500,92 +508,67 @@ void Book::read_entry(BookEntry& entry, int n) const { namespace { - uint64_t book_key(const Position &pos) { + uint64_t book_key(const Position& pos) { + uint64_t result = 0ULL; - for(Color c = WHITE; c <= BLACK; c++) { - Bitboard b = pos.pieces_of_color(c); - Square s; - Piece p; - while(b != EmptyBoardBB) { - s = pop_1st_bit(&b); - p = pos.piece_on(s); - assert(piece_is_ok(p)); - assert(color_of_piece(p) == c); - - result ^= book_piece_key(p, s); - } - } + for (Color c = WHITE; c <= BLACK; c++) + { + Bitboard b = pos.pieces_of_color(c); + while (b) + { + Square s = pop_1st_bit(&b); + Piece p = pos.piece_on(s); + + assert(piece_is_ok(p)); + assert(color_of_piece(p) == c); + + result ^= book_piece_key(p, s); + } + } result ^= book_castle_key(pos); result ^= book_ep_key(pos); result ^= book_color_key(pos); - return result; } - + uint64_t book_piece_key(Piece p, Square s) { - return Random64[RandomPiece + (PieceTo12[int(p)]^1)*64 + int(s)]; + + /// Convert pieces to the range 0..11 + static const int PieceTo12[] = { 0, 0, 2, 4, 6, 8, 10, 0, 0, 1, 3, 5, 7, 9, 11 }; + + return Random64[RandomPiece + (PieceTo12[int(p)]^1) * 64 + int(s)]; } - uint64_t book_castle_key(const Position &pos) { + uint64_t book_castle_key(const Position& pos) { + uint64_t result = 0ULL; - if(pos.can_castle_kingside(WHITE)) - result ^= Random64[RandomCastle+0]; - if(pos.can_castle_queenside(WHITE)) - result ^= Random64[RandomCastle+1]; - if(pos.can_castle_kingside(BLACK)) - result ^= Random64[RandomCastle+2]; - if(pos.can_castle_queenside(BLACK)) - result ^= Random64[RandomCastle+3]; - return result; - } + if (pos.can_castle_kingside(WHITE)) + result ^= Random64[RandomCastle+0]; - - uint64_t book_ep_key(const Position &pos) { - return (pos.ep_square() == SQ_NONE)? - 0ULL : Random64[RandomEnPassant + square_file(pos.ep_square())]; - } + if (pos.can_castle_queenside(WHITE)) + result ^= Random64[RandomCastle+1]; - - uint64_t book_color_key(const Position &pos) { - return (pos.side_to_move() == WHITE)? Random64[RandomTurn] : 0ULL; - } - - - uint16_t read_integer16(std::ifstream& file) { - - uint64_t n = read_integer(file, 2); - assert(n == (uint16_t)n); - return (uint16_t)n; - } + if (pos.can_castle_kingside(BLACK)) + result ^= Random64[RandomCastle+2]; + if (pos.can_castle_queenside(BLACK)) + result ^= Random64[RandomCastle+3]; - uint64_t read_integer64(std::ifstream& file) { - - return read_integer(file, 8); + return result; } - uint64_t read_integer(std::ifstream& file, int size) { - - char buf[8]; - file.read(buf, size); + uint64_t book_ep_key(const Position& pos) { + return (pos.ep_square() == SQ_NONE ? 0ULL : Random64[RandomEnPassant + square_file(pos.ep_square())]); + } - if (!file.good()) - { - std::cerr << "Failed to read " << size << " bytes from book file" - << std::endl; - exit(EXIT_FAILURE); - } - // Numbers are stored in little endian format - uint64_t n = 0ULL; - for (int i = 0; i < size; i++) - n = (n << 8) + (unsigned char)buf[i]; - return n; + uint64_t book_color_key(const Position& pos) { + return (pos.side_to_move() == WHITE ? Random64[RandomTurn] : 0ULL); } }