X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fbook.cpp;h=85a88fcb801e3499376d3038a8087bebbc2bdc4f;hp=a98acf491f24dba4f4a29562d6ddce7d730f06b9;hb=d9b96f0e492583bfb461e7e3c9510ddeae1e3fce;hpb=afadc33fb430abd2ba2783a62180cf971b13652f diff --git a/src/book.cpp b/src/book.cpp index a98acf49..85a88fcb 100644 --- a/src/book.cpp +++ b/src/book.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 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 @@ -30,18 +30,12 @@ //// #include +#include #include "book.h" -#include "mersenne.h" #include "movegen.h" - -//// -//// Global variables -//// - -Book OpeningBook; - +using namespace std; //// //// Local definitions @@ -49,12 +43,10 @@ Book OpeningBook; namespace { - /// Book entry size in bytes + // Book entry size in bytes const int EntrySize = 16; - - /// Random numbers from PolyGlot, used to compute book hash keys. - + // Random numbers from PolyGlot, used to compute book hash keys const uint64_t Random64[781] = { 0x9D39247E33776D41ULL, 0x2AF7398005AAA5C7ULL, 0x44DB015024623547ULL, 0x9C15F73E62A76AE2ULL, 0x75834465489C0C89ULL, 0x3290AC3A203001BFULL, @@ -319,26 +311,18 @@ namespace { 0xF8D626AAAF278509ULL }; + // Indices to the Random64[] array + const int PieceIdx = 0; + const int CastleIdx = 768; + const int EnPassantIdx = 772; + const int TurnIdx = 780; - /// Indices to the Random64[] array - - const int RandomPiece = 0; - const int RandomCastle = 768; - const int RandomEnPassant = 772; - const int RandomTurn = 780; - - - /// Prototypes - + // Local functions 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); } @@ -346,56 +330,63 @@ namespace { //// Functions //// +// C'tor. Make random number generation less deterministic, for book moves +Book::Book() { -/// Constructor + for (int i = abs(get_system_time() % 10000); i > 0; i--) + RKiss.rand(); +} -Book::Book() : bookSize(0) {} +/// Destructor. Be sure file is closed before we leave. -/// Book::open() opens a book file with a given file name +Book::~Book() { -void Book::open(const std::string& fName) { + close(); +} - fileName = fName; - bookFile.open(fileName.c_str(), std::ifstream::in | std::ifstream::binary); - if (!bookFile.is_open()) - return; - // get the book size in number of entries - bookFile.seekg(0, std::ios::end); - bookSize = bookFile.tellg() / EntrySize; - bookFile.seekg(0, std::ios::beg); +/// 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. - if (!bookFile.good()) - { - std::cerr << "Failed to open book file " << fileName << std::endl; - bookFile.close(); - exit(EXIT_FAILURE); - } +void Book::close() { + + if (is_open()) + ifstream::close(); } -/// Book::close() closes the currently open book file +/// Book::open() opens a book file with a given file name -void Book::close() { +void Book::open(const string& fName) { - if (bookFile.is_open()) - bookFile.close(); -} + // Close old file before opening the new + close(); + fileName = fName; + ifstream::open(fileName.c_str(), ifstream::in | ifstream::binary); -/// Book::is_open() tests whether a book file has been opened. + // Silently return when asked to open a non-exsistent file + if (!is_open()) + return; -bool Book::is_open() const { + // Get the book size in number of entries + seekg(0, ios::end); + bookSize = long(tellg()) / EntrySize; + seekg(0, ios::beg); - return bookFile.is_open() && bookSize != 0; + if (!good()) + { + cerr << "Failed to open book file " << fileName << endl; + exit(EXIT_FAILURE); + } } /// 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() { // Not const to compile on HP-UX 11.X return is_open() ? fileName : ""; } @@ -404,41 +395,68 @@ const std::string Book::file_name() const { /// 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 { +Move Book::get_move(const Position& pos, bool findBestMove) { - if (!is_open()) + if (!is_open() || bookSize == 0) return MOVE_NONE; - int bookMove = 0, scoresSum = 0; - uint64_t key = book_key(pos); BookEntry entry; + int bookMove = MOVE_NONE; + unsigned scoresSum = 0, bestScore = 0; + uint64_t key = book_key(pos); // Choose a book move among the possible moves for the given position - for (int i = find_key(key); i < bookSize; i++) + for (int idx = find_key(key); idx < bookSize; idx++) { - read_entry(entry, i); + read_entry(entry, idx); if (entry.key != key) break; - int score = entry.count; + unsigned score = entry.count; - assert(score > 0); + // If findBestMove is true choose highest rated book move + if (findBestMove) + { + if (score > bestScore) + { + bestScore = score; + bookMove = entry.move; + } + continue; + } // 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) + if (RKiss.rand() % scoresSum < score) bookMove = entry.move; } if (!bookMove) return MOVE_NONE; - 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; + // A PolyGlot book move is encoded as follows: + // + // bit 0- 5: destination square (from 0 to 63) + // bit 6-11: origin square (from 0 to 63) + // bit 12-13-14: promotion piece (from KNIGHT == 1 to QUEEN == 4) + // + // Castling moves follow "king captures rook" representation. So in case + // book move is a promotion we have to convert to our representation, in + // all other cases we can directly compare with a Move after having + // masked out special Move's flags that are not supported by PolyGlot. + int p = (bookMove >> 12) & 7; + + if (p) + bookMove = int(make_promotion_move(move_from(Move(bookMove)), + move_to(Move(bookMove)), PieceType(p + 1))); + + // Verify the book move is legal + MoveStack mlist[MOVES_MAX]; + MoveStack* last = generate(pos, mlist); + for (MoveStack* cur = mlist; cur != last; cur++) + if ((int(cur->move) & ~(3 << 14)) == bookMove) // Mask out special flags + return cur->move; return MOVE_NONE; } @@ -449,7 +467,7 @@ Move Book::get_move(const Position& pos) const { /// 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; @@ -460,22 +478,24 @@ int Book::find_key(uint64_t key) const { assert(left <= right); - while(left < right) + while (left < right) { mid = (left + right) / 2; assert(mid >= left && mid < right); read_entry(entry, mid); + if (key <= entry.key) right = mid; else left = mid + 1; } + assert(left == right); read_entry(entry, left); - return (entry.key == key)? left : bookSize; + return entry.key == key ? left : bookSize; } @@ -483,23 +503,38 @@ int Book::find_key(uint64_t key) const { /// 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. -void Book::read_entry(BookEntry& entry, int n) const { +void Book::read_entry(BookEntry& entry, int idx) { - assert(n >= 0 && n < bookSize); + assert(idx >= 0 && idx < bookSize); assert(is_open()); - bookFile.seekg(n * EntrySize, 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; - bookFile.close(); + cerr << "Failed to read book entry at index " << idx << endl; 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]; + uint64_t n = 0; + + read(buf, size); + + // Numbers are stored on disk as a binary byte stream + for (int i = 0; i < size; i++) + n = (n << 8) + (unsigned char)buf[i]; + + return n; } @@ -511,22 +546,13 @@ namespace { uint64_t book_key(const Position& pos) { - uint64_t result = 0ULL; + uint64_t result = 0; + Bitboard b = pos.occupied_squares(); - for (Color c = WHITE; c <= BLACK; c++) + while (b) { - Bitboard b = pos.pieces_of_color(c); - - while (b != EmptyBoardBB) - { - 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); - } + Square s = pop_1st_bit(&b); + result ^= book_piece_key(pos.piece_on(s), s); } result ^= book_castle_key(pos); @@ -538,74 +564,41 @@ namespace { uint64_t book_piece_key(Piece p, Square s) { - /// Convert pieces to the range 0..11 + // 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)]; + return Random64[PieceIdx + (PieceTo12[int(p)]^1) * 64 + int(s)]; } uint64_t book_castle_key(const Position& pos) { - uint64_t result = 0ULL; + uint64_t result = 0; if (pos.can_castle_kingside(WHITE)) - result ^= Random64[RandomCastle+0]; + result ^= Random64[CastleIdx + 0]; if (pos.can_castle_queenside(WHITE)) - result ^= Random64[RandomCastle+1]; + result ^= Random64[CastleIdx + 1]; if (pos.can_castle_kingside(BLACK)) - result ^= Random64[RandomCastle+2]; + result ^= Random64[CastleIdx + 2]; if (pos.can_castle_queenside(BLACK)) - result ^= Random64[RandomCastle+3]; + result ^= Random64[CastleIdx + 3]; return result; } uint64_t book_ep_key(const Position& pos) { - return (pos.ep_square() == SQ_NONE ? 0ULL : Random64[RandomEnPassant + square_file(pos.ep_square())]); - } - - 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; - } - - - uint64_t read_integer64(std::ifstream& file) { - - return read_integer(file, 8); + return pos.ep_square() == SQ_NONE ? 0 : Random64[EnPassantIdx + square_file(pos.ep_square())]; } - uint64_t read_integer(std::ifstream& file, int size) { - - char buf[8]; - file.read(buf, size); - - if (!file.good()) - { - std::cerr << "Failed to read " << size << " bytes from book file" << std::endl; - file.close(); - exit(EXIT_FAILURE); - } - - // Numbers are stored on disk in big endian format - uint64_t n = 0ULL; - for (int i = 0; i < size; i++) - n = (n << 8) + (unsigned char)buf[i]; + uint64_t book_color_key(const Position& pos) { - return n; + return pos.side_to_move() == WHITE ? Random64[TurnIdx] : 0; } }