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,
};
// 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;
-
- // PieceOffset is calculated as 64 * (PolyPiece ^ 1) where PolyPiece
- // is: BP = 0, WP = 1, BN = 2, WN = 3 ... BK = 10, WK = 11
- const int PieceOffset[] = { 0, 64, 192, 320, 448, 576, 704, 0,
- 0, 0, 128, 256, 384, 512, 640 };
+ 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) {
while (b)
{
- Square s = pop_1st_bit(&b);
- key ^= ZobPiece[PieceOffset[pos.piece_on(s)] + s];
+ // 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 pieceOfs = 2 * (type_of(p) - 1) + (color_of(p) == WHITE);
+ key ^= ZobPiece[64 * pieceOfs + s];
}
- b = (pos.can_castle(WHITE_OO) << 0) | (pos.can_castle(WHITE_OOO) << 1)
- | (pos.can_castle(BLACK_OO) << 2) | (pos.can_castle(BLACK_OOO) << 3);
+ b = pos.can_castle(ALL_CASTLES);
while (b)
- key ^= ZobCastle[pop_1st_bit(&b)];
+ key ^= ZobCastle[pop_lsb(&b)];
if (pos.ep_square() != SQ_NONE)
key ^= ZobEnPassant[file_of(pos.ep_square())];
} // 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<unsigned>(); // 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<typename T> Book& Book::operator>>(T& n) {
+template<typename T> PolyglotBook& PolyglotBook::operator>>(T& n) {
n = 0;
for (size_t i = 0; i < sizeof(T); i++)
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.
+/// open() tries to open a book file with the given name after closing any
+/// exsisting one.
-bool Book::open(const char* fName) {
-
- 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())
- 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;
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())
{
// 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<unsigned>() % sum < e.count)
+ if ( (sum && RKiss.rand<unsigned>() % sum < e.count)
|| (pickBest && e.count == best))
move = Move(e.move);
}
// the special Move's flags (bit 14-15) that are not supported by PolyGlot.
int pt = (move >> 12) & 7;
if (pt)
- move = make_promotion(from_sq(move), to_sq(move), PieceType(pt + 1));
+ move = make<PROMOTION>(from_sq(move), to_sq(move), PieceType(pt + 1));
// Add 'special move' flags and verify it is legal
- for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
- if (move == (ml.move() & 0x3FFF))
+ for (MoveList<LEGAL> ml(pos); !ml.end(); ++ml)
+ 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);
assert(low == high);
- seekg(low * sizeof(BookEntry), ios_base::beg);
+ return low;
}