X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fbook.cpp;h=494c9c1121cfca0af4410ab249d7bd1c0b5e6456;hp=bd2f48186492c87f7bbc9cef96a45c68fdc08295;hb=c2d42ea8339b49e52a116e488214a14fda09d413;hpb=bb751d6c890f5c50c642366d601740366cfae8d0
diff --git a/src/book.cpp b/src/book.cpp
index bd2f4818..494c9c11 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-2010 Marco Costalba, Joona Kiiski, Tord Romstad
- 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 .
*/
@@ -19,39 +20,23 @@
/*
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
#include "book.h"
-#include "mersenne.h"
+#include "misc.h"
#include "movegen.h"
-
-////
-//// Global variables
-////
-
-Book OpeningBook;
-
-
-////
-//// Local definitions
-////
+using namespace std;
namespace {
- /// 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,
@@ -315,264 +300,231 @@ 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
-
- const int RandomPiece = 0;
- const int RandomCastle = 768;
- const int RandomEnPassant = 772;
- const int RandomTurn = 780;
+ // 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 };
-
- /// 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
- };
+ // 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
-
- 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);
+ while (b)
+ {
+ Square s = pop_1st_bit(&b);
+ result ^= ZobPiece[PieceOfs[pos.piece_on(s)] + s];
+ }
- uint64_t read_integer(FILE *file, int size);
+ if (pos.can_castle(WHITE_OO))
+ result ^= ZobCastle[0];
-}
+ if (pos.can_castle(WHITE_OOO))
+ result ^= ZobCastle[1];
+ if (pos.can_castle(BLACK_OO))
+ result ^= ZobCastle[2];
-////
-//// Functions
-////
+ if (pos.can_castle(BLACK_OOO))
+ result ^= ZobCastle[3];
+ if (pos.ep_square() != SQ_NONE)
+ result ^= ZobEnPassant[file_of(pos.ep_square())];
-/// Constructor
+ if (pos.side_to_move() == WHITE)
+ result ^= ZobTurn[0];
-Book::Book() {
- bookFile = NULL;
- bookSize = 0;
+ 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 std::string &fName) {
- fileName = fName;
- bookFile = fopen(fileName.c_str(), "rb");
- if(bookFile != NULL) {
- if(fseek(bookFile, 0, SEEK_END) == -1) {
- std::cerr << "Failed to open book file " << fileName << std::endl;
- exit(EXIT_FAILURE);
- }
- bookSize = ftell(bookFile) / 16;
- if(bookSize == -1) {
- std::cerr << "Failed to open book file " << fileName << std::endl;
- exit(EXIT_FAILURE);
- }
- }
+ for (int i = abs(system_time() % 10000); i > 0; i--)
+ RKiss.rand();
}
-/// Book::close() closes the currently open book file.
+/// Book destructor. Be sure file is closed before we leave.
-void Book::close() {
- if(bookFile != NULL && fclose(bookFile) == EOF) {
- std::cerr << "Failed to close book file" << std::endl;
- exit(EXIT_FAILURE);
- }
+Book::~Book() {
+
+ close();
}
-/// Book::is_open() tests whether a book file has been opened.
+/// Book::close() closes the file only if it is open, otherwise the call fails
+/// and the failbit internal state flag is set.
+
+void Book::close() {
+
+ if (bookFile.is_open())
+ bookFile.close();
-bool Book::is_open() const {
- return bookFile != NULL && bookSize != 0;
+ 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 name
+
+void Book::open(const string& fileName) {
+
+ // Close old file before opening the new
+ close();
+
+ bookFile.open(fileName.c_str(), ifstream::in | ifstream::binary |ios::ate);
+
+ // Silently return when asked to open a non-exsistent file
+ if (!bookFile.is_open())
+ return;
+
+ // Get the book size in number of entries, we are already at the file end
+ bookSize = long(bookFile.tellg()) / sizeof(BookEntry);
-const std::string Book::file_name() const {
- return this->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 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;
- assert(score > 0);
-
- bestScore += score;
- if(int(genrand_int32() % bestScore) < score)
- bestMove = move;
- }
- 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)
- return moves[j].move;
- }
+
+/// Book::probe() gets a book move for a given position. Returns MOVE_NONE
+/// if no book move is found. If findBest is true then returns always the
+/// highest rated move otherwise chooses randomly based on the move score.
+
+Move Book::probe(const Position& pos, bool findBest) {
+
+ if (!bookSize || !bookFile.is_open())
+ return MOVE_NONE;
+
+ BookEntry entry;
+ unsigned scoresSum = 0, bestScore = 0, bookMove = 0;
+ uint64_t key = book_key(pos);
+ int idx = first_entry(key) - 1;
+
+ // Choose a book move among the possible moves for the given position
+ while (++idx < bookSize && (entry = read_entry(idx), entry.key == key))
+ {
+ scoresSum += entry.count;
+
+ // 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.
+ if ( RKiss.rand() % scoresSum < entry.count
+ || (findBest && entry.count > bestScore))
+ bookMove = entry.move;
+
+ if (entry.count > bestScore)
+ bestScore = entry.count;
}
+
+ if (!bookMove)
+ return MOVE_NONE;
+
+ // 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 = 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 (unsigned(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) const {
+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;
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;
+ if (key <= read_entry(mid).key)
+ right = mid;
+ else
+ left = mid + 1;
}
assert(left == right);
- this->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 n) const {
- assert(n >= 0 && n < bookSize);
- assert(bookFile != NULL);
+ n = 0;
- if(fseek(bookFile, n*16, SEEK_SET) == -1) {
- std::cerr << "Failed to read book entry at index " << n << std::endl;
- exit(EXIT_FAILURE);
- }
+ for (size_t i = 0; i < sizeof(T); i++)
+ n = T((n << 8) + bookFile.get());
- entry.key = read_integer(bookFile, 8);
- entry.move = read_integer(bookFile, 2);
- entry.count = read_integer(bookFile, 2);
- entry.n = read_integer(bookFile, 2);
- entry.sum = read_integer(bookFile, 2);
+ return *this;
}
-////
-//// Local definitions
-////
+/// Book::read_entry() takes an integer index, and returns the BookEntry
+/// at the given index in the book file.
-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);
- 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);
- }
- }
-
- 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)];
- }
+BookEntry Book::read_entry(int idx) {
+ assert(idx >= 0 && idx < bookSize);
+ assert(bookFile.is_open());
- uint64_t book_castle_key(const Position &pos) {
- uint64_t result = 0ULL;
+ BookEntry e;
- 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;
- }
+ bookFile.seekg(idx * sizeof(BookEntry), ios_base::beg);
-
- uint64_t book_ep_key(const Position &pos) {
- return (pos.ep_square() == SQ_NONE)?
- 0ULL : Random64[RandomEnPassant + square_file(pos.ep_square())];
- }
+ *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;
- }
-
-
- uint64_t read_integer(FILE *file, int size) {
- uint64_t n = 0ULL;;
- int i;
- int b;
-
- assert(file != NULL);
- assert(size > 0 && size <= 8);
-
- for(i = 0; i < size; i++) {
- b = fgetc(file);
- if(b == EOF) {
- std::cerr << "Failed to read " << size << " bytes from book file"
- << std::endl;
- exit(EXIT_FAILURE);
- }
- assert(b >= 0 && b < 256);
- n = (n << 8) | b;
- }
- return n;
+ if (!bookFile.good())
+ {
+ cerr << "Failed to read book entry at index " << idx << endl;
+ exit(EXIT_FAILURE);
}
-
+ return e;
}