X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fbook.cpp;h=fcaccf6f7560fe92c24cccc22428166f77ca5e03;hp=9839124c0efd12ee379447b59fd8382d0525c151;hb=500c7f44ab46ca6303c465586a17fa63b8488cb4;hpb=5c81602d14539f8259a715477315e28b5de7cb54 diff --git a/src/book.cpp b/src/book.cpp index 9839124c..fcaccf6f 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-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 @@ -20,43 +20,22 @@ /* The code in this file is based on the opening book code in PolyGlot - by Fabien Letouzey. PolyGlot is available under the GNU General + by Fabien Letouzey. PolyGlot is available under the GNU General Public License, and can be downloaded from http://wbec-ridderkerk.nl */ - -//// -//// Includes -//// - #include +#include #include "book.h" -#include "mersenne.h" #include "movegen.h" using namespace std; -//// -//// Global variables -//// - -Book OpeningBook; - - -//// -//// Local definitions -//// - namespace { - /// Book entry size in bytes - const int EntrySize = 16; - - - /// Random numbers from PolyGlot, used to compute book hash keys - - const uint64_t Random64[781] = { + // Random numbers from PolyGlot, used to compute book hash keys + const Key PolyGlotRandoms[781] = { 0x9D39247E33776D41ULL, 0x2AF7398005AAA5C7ULL, 0x44DB015024623547ULL, 0x9C15F73E62A76AE2ULL, 0x75834465489C0C89ULL, 0x3290AC3A203001BFULL, 0x0FBBAD1F61042279ULL, 0xE83A908FF2FB60CAULL, 0x0D7E765D58755C10ULL, @@ -320,60 +299,65 @@ namespace { 0xF8D626AAAF278509ULL }; + // 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; - /// Indices to the Random64[] array + // Piece offset is calculated as 64 * (PolyPiece ^ 1) where + // PolyPiece is: BP = 0, WP = 1, BN = 2, WN = 3 ... BK = 10, WK = 11 + const int PieceOfs[] = { 0, 64, 192, 320, 448, 576, 704, 0, + 0, 0, 128, 256, 384, 512, 640 }; - const int RandomPiece = 0; - const int RandomCastle = 768; - const int RandomEnPassant = 772; - const int RandomTurn = 780; + // book_key() builds up a PolyGlot hash key out of a position + uint64_t book_key(const Position& pos) { + uint64_t result = 0; + Bitboard b = pos.occupied_squares(); - /// Prototypes + while (b) + { + Square s = pop_1st_bit(&b); + result ^= ZobPiece[PieceOfs[pos.piece_on(s)] + s]; + } - 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); -} + if (pos.can_castle(WHITE_OO)) + result ^= ZobCastle[0]; + if (pos.can_castle(WHITE_OOO)) + result ^= ZobCastle[1]; -//// -//// Functions -//// + if (pos.can_castle(BLACK_OO)) + result ^= ZobCastle[2]; + if (pos.can_castle(BLACK_OOO)) + result ^= ZobCastle[3]; -/// Destructor. Be sure file is closed before we leave. + if (pos.ep_square() != SQ_NONE) + result ^= ZobEnPassant[square_file(pos.ep_square())]; -Book::~Book() { + if (pos.side_to_move() == WHITE) + result ^= ZobTurn[0]; - close(); + return result; + } } -/// Book::open() opens a book file with a given file name +/// Book c'tor. Make random number generation less deterministic, for book moves +Book::Book() : bookSize(0) { -void Book::open(const string& fName) { + for (int i = abs(get_system_time() % 10000); i > 0; i--) + RKiss.rand(); +} - // Close old file before opening the new - close(); - fileName = fName; - ifstream::open(fileName.c_str(), ifstream::in | ifstream::binary); - if (!is_open()) - return; +/// Book destructor. Be sure file is closed before we leave. - // Get the book size in number of entries - seekg(0, ios::end); - bookSize = tellg() / EntrySize; - seekg(0, ios::beg); +Book::~Book() { - if (!good()) - { - cerr << "Failed to open book file " << fileName << endl; - Application::exit_with_failure(); - } + close(); } @@ -382,74 +366,120 @@ void Book::open(const string& fName) { void Book::close() { - if (is_open()) - ifstream::close(); + if (bookFile.is_open()) + bookFile.close(); + + bookName = ""; + bookSize = 0; } -/// Book::file_name() returns the file name of the currently active book, -/// or the empty string if no book is open. +/// Book::open() opens a book file with a given file name + +void Book::open(const string& fileName) { + + // Close old file before opening the new + close(); + + bookFile.open(fileName.c_str(), ifstream::in | ifstream::binary); + + // Silently return when asked to open a non-exsistent file + if (!bookFile.is_open()) + return; -const string Book::file_name() const { + // Get the book size in number of entries + bookFile.seekg(0, ios::end); + bookSize = long(bookFile.tellg()) / sizeof(BookEntry); - return is_open() ? fileName : ""; + if (!bookFile.good()) + { + cerr << "Failed to open book file " << fileName << endl; + exit(EXIT_FAILURE); + } + + // Set only if successful + bookName = fileName; } /// Book::get_move() gets a book move for a given position. Returns -/// MOVE_NONE if no book move is found. +/// MOVE_NONE if no book move is found. If findBestMove is true then +/// return always the highest rated book move. -Move Book::get_move(const Position& pos) { +Move Book::get_move(const Position& pos, bool findBestMove) { - if (!is_open() || bookSize == 0) + if (!bookSize || !bookFile.is_open()) return MOVE_NONE; - int bookMove = 0, scoresSum = 0; - uint64_t key = book_key(pos); BookEntry entry; + int bookMove = MOVE_NONE; + unsigned score, scoresSum = 0, bestScore = 0; + uint64_t key = book_key(pos); // Choose a book move among the possible moves for the given position - for (int idx = find_key(key); idx < bookSize; idx++) + for (int idx = first_entry(key); idx < bookSize; idx++) { - read_entry(entry, idx); + entry = read_entry(idx); + if (entry.key != key) break; - int score = entry.count; - - assert(score > 0); - - // 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) + score = entry.count; + + if (!findBestMove) + { + // Choose book move according to its score. If a move has a very + // high score it has higher probability to be choosen than a move + // with lower score. Note that first entry is always chosen. + scoresSum += score; + if (RKiss.rand() % scoresSum < score) + bookMove = entry.move; + } + else if (score > bestScore) + { + bestScore = 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 promotion = (bookMove >> 12) & 7; + + if (promotion) + bookMove = int(make_promotion_move(move_from(Move(bookMove)), + move_to(Move(bookMove)), + PieceType(promotion + 1))); + // Verify the book move is legal + for (MoveList ml(pos); !ml.end(); ++ml) + if ((ml.move() & ~(3 << 14)) == bookMove) // Mask out special flags + return ml.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 +/// Book::first_entry() takes a book key as input, and does a binary search +/// through the book file for the given key. The index to the first (leftmost) +/// 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) { +int Book::first_entry(uint64_t key) { int left, right, mid; - BookEntry entry; - // Binary search (finds the leftmost entry) + // Binary search (finds the leftmost entry with given key) left = 0; right = bookSize - 1; @@ -461,8 +491,7 @@ int Book::find_key(uint64_t key) { assert(mid >= left && mid < right); - read_entry(entry, mid); - if (key <= entry.key) + if (key <= read_entry(mid).key) right = mid; else left = mid + 1; @@ -470,114 +499,42 @@ int Book::find_key(uint64_t key) { assert(left == right); - read_entry(entry, left); - return (entry.key == key)? left : bookSize; + return read_entry(left).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. +/// Book::operator>>() reads sizeof(T) chars from the file's binary byte +/// stream and converts them in a number of type T. +template +Book& Book::operator>>(T& n) { -void Book::read_entry(BookEntry& entry, int idx) { + n = 0; - assert(idx >= 0 && idx < bookSize); - assert(is_open()); + for (size_t i = 0; i < sizeof(T); i++) + n = T((n << 8) + bookFile.get()); - seekg(idx * EntrySize, ios_base::beg); - *this >> entry; - if (!good()) - { - cerr << "Failed to read book entry at index " << idx << endl; - Application::exit_with_failure(); - } + return *this; } -/// 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; -} - - -//// -//// Local definitions -//// - -namespace { - - 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); - - while (b) - { - Square s = pop_1st_bit(&b); - Piece p = pos.piece_on(s); +/// Book::read_entry() takes an integer index, and returns the BookEntry +/// at the given index in the book file. - assert(piece_is_ok(p)); - assert(color_of_piece(p) == c); +BookEntry Book::read_entry(int idx) { - 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) { - - /// 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 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; - } + assert(idx >= 0 && idx < bookSize); + assert(bookFile.is_open()); + BookEntry e; - uint64_t book_ep_key(const Position& pos) { - return (pos.ep_square() == SQ_NONE ? 0ULL : Random64[RandomEnPassant + square_file(pos.ep_square())]); - } + bookFile.seekg(idx * sizeof(BookEntry), ios_base::beg); + *this >> e.key >> e.move >> e.count >> e.learn; - uint64_t book_color_key(const Position& pos) { - return (pos.side_to_move() == WHITE ? Random64[RandomTurn] : 0ULL); + if (!bookFile.good()) + { + cerr << "Failed to read book entry at index " << idx << endl; + exit(EXIT_FAILURE); } + return e; }