diff --git a/DroidFish/jni/stockfish/Android.mk b/DroidFish/jni/stockfish/Android.mk index 2bf0652..1cb5de2 100644 --- a/DroidFish/jni/stockfish/Android.mk +++ b/DroidFish/jni/stockfish/Android.mk @@ -1,7 +1,7 @@ LOCAL_PATH := $(call my-dir) SF_SRC_FILES := \ - benchmark.cpp main.cpp movegen.cpp pawns.cpp thread.cpp uci.cpp \ + benchmark.cpp main.cpp movegen.cpp pawns.cpp thread.cpp uci.cpp psqt.cpp \ bitbase.cpp endgame.cpp material.cpp movepick.cpp position.cpp timeman.cpp ucioption.cpp \ bitboard.cpp evaluate.cpp misc.cpp search.cpp tt.cpp syzygy/tbprobe.cpp diff --git a/DroidFish/jni/stockfish/benchmark.cpp b/DroidFish/jni/stockfish/benchmark.cpp index 605c95a..8f3e6ae 100644 --- a/DroidFish/jni/stockfish/benchmark.cpp +++ b/DroidFish/jni/stockfish/benchmark.cpp @@ -17,7 +17,6 @@ along with this program. If not, see . */ -#include #include #include #include @@ -27,14 +26,13 @@ #include "position.h" #include "search.h" #include "thread.h" -#include "tt.h" #include "uci.h" using namespace std; namespace { -const char* Defaults[] = { +const vector Defaults = { "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 10", "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 11", @@ -105,22 +103,22 @@ void benchmark(const Position& current, istream& is) { Options["Hash"] = ttSize; Options["Threads"] = threads; - TT.clear(); + Search::reset(); if (limitType == "time") - limits.movetime = atoi(limit.c_str()); // movetime is in ms + limits.movetime = stoi(limit); // movetime is in ms else if (limitType == "nodes") - limits.nodes = atoi(limit.c_str()); + limits.nodes = stoi(limit); else if (limitType == "mate") - limits.mate = atoi(limit.c_str()); + limits.mate = stoi(limit); else - limits.depth = atoi(limit.c_str()); + limits.depth = stoi(limit); if (fenFile == "default") - fens.assign(Defaults, Defaults + 37); + fens = Defaults; else if (fenFile == "current") fens.push_back(current.fen()); @@ -128,7 +126,7 @@ void benchmark(const Position& current, istream& is) { else { string fen; - ifstream file(fenFile.c_str()); + ifstream file(fenFile); if (!file.is_open()) { @@ -144,8 +142,7 @@ void benchmark(const Position& current, istream& is) { } uint64_t nodes = 0; - Search::StateStackPtr st; - Time::point elapsed = Time::now(); + TimePoint elapsed = now(); for (size_t i = 0; i < fens.size(); ++i) { @@ -158,13 +155,15 @@ void benchmark(const Position& current, istream& is) { else { + Search::StateStackPtr st; + limits.startTime = now(); Threads.start_thinking(pos, limits, st); - Threads.wait_for_think_finished(); - nodes += Search::RootPos.nodes_searched(); + Threads.main()->join(); + nodes += Threads.nodes_searched(); } } - elapsed = std::max(Time::now() - elapsed, Time::point(1)); // Avoid a 'divide by zero' + elapsed = now() - elapsed + 1; // Ensure positivity to avoid a 'divide by zero' dbg_print(); // Just before to exit diff --git a/DroidFish/jni/stockfish/bitbase.cpp b/DroidFish/jni/stockfish/bitbase.cpp index a018d3c..0eb3b98 100644 --- a/DroidFish/jni/stockfish/bitbase.cpp +++ b/DroidFish/jni/stockfish/bitbase.cpp @@ -17,7 +17,9 @@ along with this program. If not, see . */ +#include #include +#include #include #include "bitboard.h" @@ -51,20 +53,19 @@ namespace { WIN = 4 }; - inline Result& operator|=(Result& r, Result v) { return r = Result(r | v); } + Result& operator|=(Result& r, Result v) { return r = Result(r | v); } struct KPKPosition { - - KPKPosition(unsigned idx); + KPKPosition() = default; + explicit KPKPosition(unsigned idx); operator Result() const { return result; } Result classify(const std::vector& db) { return us == WHITE ? classify(db) : classify(db); } - private: template Result classify(const std::vector& db); Color us; - Square bksq, wksq, psq; + Square ksq[COLOR_NB], psq; Result result; }; @@ -82,13 +83,12 @@ bool Bitbases::probe(Square wksq, Square wpsq, Square bksq, Color us) { void Bitbases::init() { + std::vector db(MAX_INDEX); unsigned idx, repeat = 1; - std::vector db; - db.reserve(MAX_INDEX); // Initialize db with known win / draw positions for (idx = 0; idx < MAX_INDEX; ++idx) - db.push_back(KPKPosition(idx)); + db[idx] = KPKPosition(idx); // Iterate through the positions until none of the unknown positions can be // changed to either wins or draws (15 cycles needed). @@ -107,69 +107,73 @@ namespace { KPKPosition::KPKPosition(unsigned idx) { - wksq = Square((idx >> 0) & 0x3F); - bksq = Square((idx >> 6) & 0x3F); - us = Color ((idx >> 12) & 0x01); - psq = make_square(File((idx >> 13) & 0x3), RANK_7 - Rank((idx >> 15) & 0x7)); - result = UNKNOWN; + ksq[WHITE] = Square((idx >> 0) & 0x3F); + ksq[BLACK] = Square((idx >> 6) & 0x3F); + us = Color ((idx >> 12) & 0x01); + psq = make_square(File((idx >> 13) & 0x3), RANK_7 - Rank((idx >> 15) & 0x7)); // Check if two pieces are on the same square or if a king can be captured - if ( distance(wksq, bksq) <= 1 - || wksq == psq - || bksq == psq - || (us == WHITE && (StepAttacksBB[PAWN][psq] & bksq))) + if ( distance(ksq[WHITE], ksq[BLACK]) <= 1 + || ksq[WHITE] == psq + || ksq[BLACK] == psq + || (us == WHITE && (StepAttacksBB[PAWN][psq] & ksq[BLACK]))) result = INVALID; - else if (us == WHITE) - { - // Immediate win if a pawn can be promoted without getting captured - if ( rank_of(psq) == RANK_7 - && wksq != psq + DELTA_N - && ( distance(bksq, psq + DELTA_N) > 1 - ||(StepAttacksBB[KING][wksq] & (psq + DELTA_N)))) - result = WIN; - } + // Immediate win if a pawn can be promoted without getting captured + else if ( us == WHITE + && rank_of(psq) == RANK_7 + && ksq[us] != psq + DELTA_N + && ( distance(ksq[~us], psq + DELTA_N) > 1 + || (StepAttacksBB[KING][ksq[us]] & (psq + DELTA_N)))) + result = WIN; + // Immediate draw if it is a stalemate or a king captures undefended pawn - else if ( !(StepAttacksBB[KING][bksq] & ~(StepAttacksBB[KING][wksq] | StepAttacksBB[PAWN][psq])) - || (StepAttacksBB[KING][bksq] & psq & ~StepAttacksBB[KING][wksq])) + else if ( us == BLACK + && ( !(StepAttacksBB[KING][ksq[us]] & ~(StepAttacksBB[KING][ksq[~us]] | StepAttacksBB[PAWN][psq])) + || (StepAttacksBB[KING][ksq[us]] & psq & ~StepAttacksBB[KING][ksq[~us]]))) result = DRAW; + + // Position will be classified later + else + result = UNKNOWN; } template Result KPKPosition::classify(const std::vector& db) { - // White to Move: If one move leads to a position classified as WIN, the result + // White to move: If one move leads to a position classified as WIN, the result // of the current position is WIN. If all moves lead to positions classified // as DRAW, the current position is classified as DRAW, otherwise the current // position is classified as UNKNOWN. // - // Black to Move: If one move leads to a position classified as DRAW, the result + // Black to move: If one move leads to a position classified as DRAW, the result // of the current position is DRAW. If all moves lead to positions classified // as WIN, the position is classified as WIN, otherwise the current position is // classified as UNKNOWN. - const Color Them = (Us == WHITE ? BLACK : WHITE); + const Color Them = (Us == WHITE ? BLACK : WHITE); + const Result Good = (Us == WHITE ? WIN : DRAW); + const Result Bad = (Us == WHITE ? DRAW : WIN); Result r = INVALID; - Bitboard b = StepAttacksBB[KING][Us == WHITE ? wksq : bksq]; + Bitboard b = StepAttacksBB[KING][ksq[Us]]; while (b) - r |= Us == WHITE ? db[index(Them, bksq, pop_lsb(&b), psq)] - : db[index(Them, pop_lsb(&b), wksq, psq)]; - - if (Us == WHITE && rank_of(psq) < RANK_7) - { - Square s = psq + DELTA_N; - r |= db[index(BLACK, bksq, wksq, s)]; // Single push - - if (rank_of(psq) == RANK_2 && s != wksq && s != bksq) - r |= db[index(BLACK, bksq, wksq, s + DELTA_N)]; // Double push - } + r |= Us == WHITE ? db[index(Them, ksq[Them] , pop_lsb(&b), psq)] + : db[index(Them, pop_lsb(&b), ksq[Them] , psq)]; if (Us == WHITE) - return result = r & WIN ? WIN : r & UNKNOWN ? UNKNOWN : DRAW; - else - return result = r & DRAW ? DRAW : r & UNKNOWN ? UNKNOWN : WIN; + { + if (rank_of(psq) < RANK_7) // Single push + r |= db[index(Them, ksq[Them], ksq[Us], psq + DELTA_N)]; + + if ( rank_of(psq) == RANK_2 // Double push + && psq + DELTA_N != ksq[Us] + && psq + DELTA_N != ksq[Them]) + r |= db[index(Them, ksq[Them], ksq[Us], psq + DELTA_N + DELTA_N)]; + } + + return result = r & Good ? Good : r & UNKNOWN ? UNKNOWN : Bad; } } // namespace diff --git a/DroidFish/jni/stockfish/bitboard.cpp b/DroidFish/jni/stockfish/bitboard.cpp index 32efaed..7a4d73c 100644 --- a/DroidFish/jni/stockfish/bitboard.cpp +++ b/DroidFish/jni/stockfish/bitboard.cpp @@ -18,7 +18,6 @@ */ #include -#include // For std::memset #include "bitboard.h" #include "bitcount.h" @@ -56,7 +55,7 @@ namespace { const uint64_t DeBruijn64 = 0x3F79D71B4CB0A89ULL; const uint32_t DeBruijn32 = 0x783A9B23; - int MS1BTable[256]; // To implement software msb() + int MSBTable[256]; // To implement software msb() Square BSFTable[SQUARE_NB]; // To implement software bitscan Bitboard RookTable[0x19000]; // To store rook attacks Bitboard BishopTable[0x1480]; // To store bishop attacks @@ -69,7 +68,7 @@ namespace { // bsf_index() returns the index into BSFTable[] to look up the bitscan. Uses // Matt Taylor's folding for 32 bit case, extended to 64 bit by Kim Walisch. - FORCE_INLINE unsigned bsf_index(Bitboard b) { + unsigned bsf_index(Bitboard b) { b ^= b - 1; return Is64Bit ? (b * DeBruijn64) >> 58 : ((unsigned(b) ^ unsigned(b >> 32)) * DeBruijn32) >> 26; @@ -109,7 +108,7 @@ Square msb(Bitboard b) { result += 8; } - return Square(result + MS1BTable[b32]); + return Square(result + MSBTable[b32]); } #endif // ifndef USE_BSFQ @@ -125,9 +124,9 @@ const std::string Bitboards::pretty(Bitboard b) { for (Rank r = RANK_8; r >= RANK_1; --r) { for (File f = FILE_A; f <= FILE_H; ++f) - s.append(b & make_square(f, r) ? "| X " : "| "); + s += b & make_square(f, r) ? "| X " : "| "; - s.append("|\n+---+---+---+---+---+---+---+---+\n"); + s += "|\n+---+---+---+---+---+---+---+---+\n"; } return s; @@ -145,8 +144,8 @@ void Bitboards::init() { BSFTable[bsf_index(SquareBB[s])] = s; } - for (Bitboard b = 1; b < 256; ++b) - MS1BTable[b] = more_than_one(b) ? MS1BTable[b - 1] : lsb(b); + for (Bitboard b = 2; b < 256; ++b) + MSBTable[b] = MSBTable[b - 1] + !more_than_one(b); for (File f = FILE_A; f <= FILE_H; ++f) FileBB[f] = f > FILE_A ? FileBB[f - 1] << 1 : FileABB; @@ -201,17 +200,15 @@ void Bitboards::init() { PseudoAttacks[QUEEN][s1] = PseudoAttacks[BISHOP][s1] = attacks_bb(s1, 0); PseudoAttacks[QUEEN][s1] |= PseudoAttacks[ ROOK][s1] = attacks_bb< ROOK>(s1, 0); - for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2) - { - Piece pc = (PseudoAttacks[BISHOP][s1] & s2) ? W_BISHOP : - (PseudoAttacks[ROOK][s1] & s2) ? W_ROOK : NO_PIECE; + for (Piece pc = W_BISHOP; pc <= W_ROOK; ++pc) + for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2) + { + if (!(PseudoAttacks[pc][s1] & s2)) + continue; - if (pc == NO_PIECE) - continue; - - LineBB[s1][s2] = (attacks_bb(pc, s1, 0) & attacks_bb(pc, s2, 0)) | s1 | s2; - BetweenBB[s1][s2] = attacks_bb(pc, s1, SquareBB[s2]) & attacks_bb(pc, s2, SquareBB[s1]); - } + LineBB[s1][s2] = (attacks_bb(pc, s1, 0) & attacks_bb(pc, s2, 0)) | s1 | s2; + BetweenBB[s1][s2] = attacks_bb(pc, s1, SquareBB[s2]) & attacks_bb(pc, s2, SquareBB[s1]); + } } } @@ -249,7 +246,7 @@ namespace { { 728, 10316, 55013, 32803, 12281, 15100, 16645, 255 } }; Bitboard occupancy[4096], reference[4096], edges, b; - int i, size; + int age[4096] = {0}, current = 0, i, size; // attacks[s] is a pointer to the beginning of the attacks table for square 's' attacks[SQ_A1] = table; @@ -298,22 +295,21 @@ namespace { magics[s] = rng.sparse_rand(); while (popcount((magics[s] * masks[s]) >> 56) < 6); - std::memset(attacks[s], 0, size * sizeof(Bitboard)); - // A good magic must map every possible occupancy to an index that // looks up the correct sliding attack in the attacks[s] database. // Note that we build up the database for square 's' as a side // effect of verifying the magic. - for (i = 0; i < size; ++i) + for (++current, i = 0; i < size; ++i) { - Bitboard& attack = attacks[s][index(s, occupancy[i])]; + unsigned idx = index(s, occupancy[i]); - if (attack && attack != reference[i]) + if (age[idx] < current) + { + age[idx] = current; + attacks[s][idx] = reference[i]; + } + else if (attacks[s][idx] != reference[i]) break; - - assert(reference[i]); - - attack = reference[i]; } } while (i < size); } diff --git a/DroidFish/jni/stockfish/bitboard.h b/DroidFish/jni/stockfish/bitboard.h index aa4e171..4aecf41 100644 --- a/DroidFish/jni/stockfish/bitboard.h +++ b/DroidFish/jni/stockfish/bitboard.h @@ -200,14 +200,6 @@ inline Bitboard passed_pawn_mask(Color c, Square s) { } -/// squares_of_color() returns a bitboard representing all the squares of the -/// same color of the given one. - -inline Bitboard squares_of_color(Square s) { - return DarkSquares & s ? DarkSquares : ~DarkSquares; -} - - /// aligned() returns true if the squares s1, s2 and s3 are aligned either on a /// straight or on a diagonal line. @@ -231,7 +223,7 @@ template<> inline int distance(Square x, Square y) { return distance(rank_ /// piece of type Pt (bishop or rook) placed on 's'. The helper magic_index() /// looks up the index using the 'magic bitboards' approach. template -FORCE_INLINE unsigned magic_index(Square s, Bitboard occupied) { +inline unsigned magic_index(Square s, Bitboard occupied) { Bitboard* const Masks = Pt == ROOK ? RookMasks : BishopMasks; Bitboard* const Magics = Pt == ROOK ? RookMagics : BishopMagics; @@ -271,13 +263,13 @@ inline Bitboard attacks_bb(Piece pc, Square s, Bitboard occupied) { # if defined(_MSC_VER) && !defined(__INTEL_COMPILER) -FORCE_INLINE Square lsb(Bitboard b) { +inline Square lsb(Bitboard b) { unsigned long idx; _BitScanForward64(&idx, b); return (Square) idx; } -FORCE_INLINE Square msb(Bitboard b) { +inline Square msb(Bitboard b) { unsigned long idx; _BitScanReverse64(&idx, b); return (Square) idx; @@ -285,28 +277,28 @@ FORCE_INLINE Square msb(Bitboard b) { # elif defined(__arm__) -FORCE_INLINE int lsb32(uint32_t v) { +inline int lsb32(uint32_t v) { __asm__("rbit %0, %1" : "=r"(v) : "r"(v)); return __builtin_clz(v); } -FORCE_INLINE Square msb(Bitboard b) { +inline Square msb(Bitboard b) { return (Square) (63 - __builtin_clzll(b)); } -FORCE_INLINE Square lsb(Bitboard b) { +inline Square lsb(Bitboard b) { return (Square) (uint32_t(b) ? lsb32(uint32_t(b)) : 32 + lsb32(uint32_t(b >> 32))); } # else // Assumed gcc or compatible compiler -FORCE_INLINE Square lsb(Bitboard b) { // Assembly code by Heinz van Saanen +inline Square lsb(Bitboard b) { // Assembly code by Heinz van Saanen Bitboard idx; __asm__("bsfq %1, %0": "=r"(idx): "rm"(b) ); return (Square) idx; } -FORCE_INLINE Square msb(Bitboard b) { +inline Square msb(Bitboard b) { Bitboard idx; __asm__("bsrq %1, %0": "=r"(idx): "rm"(b) ); return (Square) idx; @@ -324,7 +316,7 @@ Square msb(Bitboard b); /// pop_lsb() finds and clears the least significant bit in a non-zero bitboard -FORCE_INLINE Square pop_lsb(Bitboard* b) { +inline Square pop_lsb(Bitboard* b) { const Square s = lsb(*b); *b &= *b - 1; return s; diff --git a/DroidFish/jni/stockfish/endgame.cpp b/DroidFish/jni/stockfish/endgame.cpp index 2c87b2a..97e7e12 100644 --- a/DroidFish/jni/stockfish/endgame.cpp +++ b/DroidFish/jni/stockfish/endgame.cpp @@ -71,7 +71,7 @@ namespace { assert(pos.count(strongSide) == 1); - if (file_of(pos.list(strongSide)[0]) >= FILE_E) + if (file_of(pos.square(strongSide)) >= FILE_E) sq = Square(sq ^ 7); // Mirror SQ_H1 -> SQ_A1 if (strongSide == BLACK) @@ -96,12 +96,9 @@ namespace { string fen = sides[0] + char(8 - sides[0].length() + '0') + "/8/8/8/8/8/8/" + sides[1] + char(8 - sides[1].length() + '0') + " w - - 0 10"; - return Position(fen, false, NULL).material_key(); + return Position(fen, false, nullptr).material_key(); } - template - void delete_endgame(const typename M::value_type& p) { delete p.second; } - } // namespace @@ -128,17 +125,11 @@ Endgames::Endgames() { add("KRPPKRP"); } -Endgames::~Endgames() { - for_each(m1.begin(), m1.end(), delete_endgame); - for_each(m2.begin(), m2.end(), delete_endgame); -} - -template +template void Endgames::add(const string& code) { - - map((Endgame*)0)[key(code, WHITE)] = new Endgame(WHITE); - map((Endgame*)0)[key(code, BLACK)] = new Endgame(BLACK); + map()[key(code, WHITE)] = std::unique_ptr>(new Endgame(WHITE)); + map()[key(code, BLACK)] = std::unique_ptr>(new Endgame(BLACK)); } @@ -156,8 +147,8 @@ Value Endgame::operator()(const Position& pos) const { if (pos.side_to_move() == weakSide && !MoveList(pos).size()) return VALUE_DRAW; - Square winnerKSq = pos.king_square(strongSide); - Square loserKSq = pos.king_square(weakSide); + Square winnerKSq = pos.square(strongSide); + Square loserKSq = pos.square(weakSide); Value result = pos.non_pawn_material(strongSide) + pos.count(strongSide) * PawnValueEg @@ -167,8 +158,8 @@ Value Endgame::operator()(const Position& pos) const { if ( pos.count(strongSide) || pos.count(strongSide) ||(pos.count(strongSide) && pos.count(strongSide)) - ||(pos.count(strongSide) > 1 && opposite_colors(pos.list(strongSide)[0], - pos.list(strongSide)[1]))) + ||(pos.count(strongSide) > 1 && opposite_colors(pos.squares(strongSide)[0], + pos.squares(strongSide)[1]))) result += VALUE_KNOWN_WIN; return strongSide == pos.side_to_move() ? result : -result; @@ -183,9 +174,9 @@ Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, KnightValueMg + BishopValueMg, 0)); assert(verify_material(pos, weakSide, VALUE_ZERO, 0)); - Square winnerKSq = pos.king_square(strongSide); - Square loserKSq = pos.king_square(weakSide); - Square bishopSq = pos.list(strongSide)[0]; + Square winnerKSq = pos.square(strongSide); + Square loserKSq = pos.square(weakSide); + Square bishopSq = pos.square(strongSide); // kbnk_mate_table() tries to drive toward corners A1 or H8. If we have a // bishop that cannot reach the above squares, we flip the kings in order @@ -212,9 +203,9 @@ Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, weakSide, VALUE_ZERO, 0)); // Assume strongSide is white and the pawn is on files A-D - Square wksq = normalize(pos, strongSide, pos.king_square(strongSide)); - Square bksq = normalize(pos, strongSide, pos.king_square(weakSide)); - Square psq = normalize(pos, strongSide, pos.list(strongSide)[0]); + Square wksq = normalize(pos, strongSide, pos.square(strongSide)); + Square bksq = normalize(pos, strongSide, pos.square(weakSide)); + Square psq = normalize(pos, strongSide, pos.square(strongSide)); Color us = strongSide == pos.side_to_move() ? WHITE : BLACK; @@ -237,10 +228,10 @@ Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, RookValueMg, 0)); assert(verify_material(pos, weakSide, VALUE_ZERO, 1)); - Square wksq = relative_square(strongSide, pos.king_square(strongSide)); - Square bksq = relative_square(strongSide, pos.king_square(weakSide)); - Square rsq = relative_square(strongSide, pos.list(strongSide)[0]); - Square psq = relative_square(strongSide, pos.list(weakSide)[0]); + Square wksq = relative_square(strongSide, pos.square(strongSide)); + Square bksq = relative_square(strongSide, pos.square(weakSide)); + Square rsq = relative_square(strongSide, pos.square(strongSide)); + Square psq = relative_square(strongSide, pos.square(weakSide)); Square queeningSq = make_square(file_of(psq), RANK_1); Value result; @@ -280,7 +271,7 @@ Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, RookValueMg, 0)); assert(verify_material(pos, weakSide, BishopValueMg, 0)); - Value result = Value(PushToEdges[pos.king_square(weakSide)]); + Value result = Value(PushToEdges[pos.square(weakSide)]); return strongSide == pos.side_to_move() ? result : -result; } @@ -293,8 +284,8 @@ Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, RookValueMg, 0)); assert(verify_material(pos, weakSide, KnightValueMg, 0)); - Square bksq = pos.king_square(weakSide); - Square bnsq = pos.list(weakSide)[0]; + Square bksq = pos.square(weakSide); + Square bnsq = pos.square(weakSide); Value result = Value(PushToEdges[bksq] + PushAway[distance(bksq, bnsq)]); return strongSide == pos.side_to_move() ? result : -result; } @@ -310,9 +301,9 @@ Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, QueenValueMg, 0)); assert(verify_material(pos, weakSide, VALUE_ZERO, 1)); - Square winnerKSq = pos.king_square(strongSide); - Square loserKSq = pos.king_square(weakSide); - Square pawnSq = pos.list(weakSide)[0]; + Square winnerKSq = pos.square(strongSide); + Square loserKSq = pos.square(weakSide); + Square pawnSq = pos.square(weakSide); Value result = Value(PushClose[distance(winnerKSq, loserKSq)]); @@ -335,8 +326,8 @@ Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, QueenValueMg, 0)); assert(verify_material(pos, weakSide, RookValueMg, 0)); - Square winnerKSq = pos.king_square(strongSide); - Square loserKSq = pos.king_square(weakSide); + Square winnerKSq = pos.square(strongSide); + Square loserKSq = pos.square(weakSide); Value result = QueenValueEg - RookValueEg @@ -365,15 +356,15 @@ ScaleFactor Endgame::operator()(const Position& pos) const { // be detected even when the weaker side has some pawns. Bitboard pawns = pos.pieces(strongSide, PAWN); - File pawnFile = file_of(pos.list(strongSide)[0]); + File pawnsFile = file_of(lsb(pawns)); - // All pawns are on a single rook file ? - if ( (pawnFile == FILE_A || pawnFile == FILE_H) - && !(pawns & ~file_bb(pawnFile))) + // All pawns are on a single rook file? + if ( (pawnsFile == FILE_A || pawnsFile == FILE_H) + && !(pawns & ~file_bb(pawnsFile))) { - Square bishopSq = pos.list(strongSide)[0]; - Square queeningSq = relative_square(strongSide, make_square(pawnFile, RANK_8)); - Square kingSq = pos.king_square(weakSide); + Square bishopSq = pos.square(strongSide); + Square queeningSq = relative_square(strongSide, make_square(pawnsFile, RANK_8)); + Square kingSq = pos.square(weakSide); if ( opposite_colors(queeningSq, bishopSq) && distance(queeningSq, kingSq) <= 1) @@ -381,17 +372,17 @@ ScaleFactor Endgame::operator()(const Position& pos) const { } // If all the pawns are on the same B or G file, then it's potentially a draw - if ( (pawnFile == FILE_B || pawnFile == FILE_G) - && !(pos.pieces(PAWN) & ~file_bb(pawnFile)) + if ( (pawnsFile == FILE_B || pawnsFile == FILE_G) + && !(pos.pieces(PAWN) & ~file_bb(pawnsFile)) && pos.non_pawn_material(weakSide) == 0 && pos.count(weakSide) >= 1) { // Get weakSide pawn that is closest to the home rank Square weakPawnSq = backmost_sq(weakSide, pos.pieces(weakSide, PAWN)); - Square strongKingSq = pos.king_square(strongSide); - Square weakKingSq = pos.king_square(weakSide); - Square bishopSq = pos.list(strongSide)[0]; + Square strongKingSq = pos.square(strongSide); + Square weakKingSq = pos.square(weakSide); + Square bishopSq = pos.square(strongSide); // There's potential for a draw if our pawn is blocked on the 7th rank, // the bishop cannot attack it or they only have one pawn left @@ -428,11 +419,11 @@ ScaleFactor Endgame::operator()(const Position& pos) const { assert(pos.count(weakSide) == 1); assert(pos.count(weakSide) >= 1); - Square kingSq = pos.king_square(weakSide); - Square rsq = pos.list(weakSide)[0]; + Square kingSq = pos.square(weakSide); + Square rsq = pos.square(weakSide); if ( relative_rank(weakSide, kingSq) <= RANK_2 - && relative_rank(weakSide, pos.king_square(strongSide)) >= RANK_4 + && relative_rank(weakSide, pos.square(strongSide)) >= RANK_4 && relative_rank(weakSide, rsq) == RANK_3 && ( pos.pieces(weakSide, PAWN) & pos.attacks_from(kingSq) @@ -456,11 +447,11 @@ ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, weakSide, RookValueMg, 0)); // Assume strongSide is white and the pawn is on files A-D - Square wksq = normalize(pos, strongSide, pos.king_square(strongSide)); - Square bksq = normalize(pos, strongSide, pos.king_square(weakSide)); - Square wrsq = normalize(pos, strongSide, pos.list(strongSide)[0]); - Square wpsq = normalize(pos, strongSide, pos.list(strongSide)[0]); - Square brsq = normalize(pos, strongSide, pos.list(weakSide)[0]); + Square wksq = normalize(pos, strongSide, pos.square(strongSide)); + Square bksq = normalize(pos, strongSide, pos.square(weakSide)); + Square wrsq = normalize(pos, strongSide, pos.square(strongSide)); + Square wpsq = normalize(pos, strongSide, pos.square(strongSide)); + Square brsq = normalize(pos, strongSide, pos.square(weakSide)); File f = file_of(wpsq); Rank r = rank_of(wpsq); @@ -480,7 +471,7 @@ ScaleFactor Endgame::operator()(const Position& pos) const { if ( r == RANK_6 && distance(bksq, queeningSq) <= 1 && rank_of(wksq) + tempo <= RANK_6 - && (rank_of(brsq) == RANK_1 || (!tempo && distance(file_of(brsq), f) >= 3))) + && (rank_of(brsq) == RANK_1 || (!tempo && distance(brsq, wpsq) >= 3))) return SCALE_FACTOR_DRAW; if ( r >= RANK_6 @@ -552,9 +543,9 @@ ScaleFactor Endgame::operator()(const Position& pos) const { // Test for a rook pawn if (pos.pieces(PAWN) & (FileABB | FileHBB)) { - Square ksq = pos.king_square(weakSide); - Square bsq = pos.list(weakSide)[0]; - Square psq = pos.list(strongSide)[0]; + Square ksq = pos.square(weakSide); + Square bsq = pos.square(weakSide); + Square psq = pos.square(strongSide); Rank rk = relative_rank(strongSide, psq); Square push = pawn_push(strongSide); @@ -567,7 +558,7 @@ ScaleFactor Endgame::operator()(const Position& pos) const { { int d = distance(psq + 3 * push, ksq); - if (d <= 2 && !(d == 0 && ksq == pos.king_square(strongSide) + 2 * push)) + if (d <= 2 && !(d == 0 && ksq == pos.square(strongSide) + 2 * push)) return ScaleFactor(24); else return ScaleFactor(48); @@ -595,9 +586,9 @@ ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, RookValueMg, 2)); assert(verify_material(pos, weakSide, RookValueMg, 1)); - Square wpsq1 = pos.list(strongSide)[0]; - Square wpsq2 = pos.list(strongSide)[1]; - Square bksq = pos.king_square(weakSide); + Square wpsq1 = pos.squares(strongSide)[0]; + Square wpsq2 = pos.squares(strongSide)[1]; + Square bksq = pos.square(weakSide); // Does the stronger side have a passed pawn? if (pos.pawn_passed(strongSide, wpsq1) || pos.pawn_passed(strongSide, wpsq2)) @@ -610,11 +601,11 @@ ScaleFactor Endgame::operator()(const Position& pos) const { && relative_rank(strongSide, bksq) > r) { switch (r) { - case RANK_2: return ScaleFactor(10); + case RANK_2: return ScaleFactor(9); case RANK_3: return ScaleFactor(10); - case RANK_4: return ScaleFactor(15); - case RANK_5: return ScaleFactor(20); - case RANK_6: return ScaleFactor(40); + case RANK_4: return ScaleFactor(14); + case RANK_5: return ScaleFactor(21); + case RANK_6: return ScaleFactor(44); default: assert(false); } } @@ -631,15 +622,14 @@ ScaleFactor Endgame::operator()(const Position& pos) const { assert(pos.count(strongSide) >= 2); assert(verify_material(pos, weakSide, VALUE_ZERO, 0)); - Square ksq = pos.king_square(weakSide); + Square ksq = pos.square(weakSide); Bitboard pawns = pos.pieces(strongSide, PAWN); - Square psq = pos.list(strongSide)[0]; // If all pawns are ahead of the king, on a single rook file and // the king is within one file of the pawns, it's a draw. if ( !(pawns & ~in_front_bb(weakSide, rank_of(ksq))) && !((pawns & ~FileABB) && (pawns & ~FileHBB)) - && distance(ksq, psq) <= 1) + && distance(ksq, lsb(pawns)) <= 1) return SCALE_FACTOR_DRAW; return SCALE_FACTOR_NONE; @@ -656,10 +646,10 @@ ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, BishopValueMg, 1)); assert(verify_material(pos, weakSide, BishopValueMg, 0)); - Square pawnSq = pos.list(strongSide)[0]; - Square strongBishopSq = pos.list(strongSide)[0]; - Square weakBishopSq = pos.list(weakSide)[0]; - Square weakKingSq = pos.king_square(weakSide); + Square pawnSq = pos.square(strongSide); + Square strongBishopSq = pos.square(strongSide); + Square weakBishopSq = pos.square(weakSide); + Square weakKingSq = pos.square(weakSide); // Case 1: Defending king blocks the pawn, and cannot be driven away if ( file_of(weakKingSq) == file_of(pawnSq) @@ -706,15 +696,15 @@ ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, BishopValueMg, 2)); assert(verify_material(pos, weakSide, BishopValueMg, 0)); - Square wbsq = pos.list(strongSide)[0]; - Square bbsq = pos.list(weakSide)[0]; + Square wbsq = pos.square(strongSide); + Square bbsq = pos.square(weakSide); if (!opposite_colors(wbsq, bbsq)) return SCALE_FACTOR_NONE; - Square ksq = pos.king_square(weakSide); - Square psq1 = pos.list(strongSide)[0]; - Square psq2 = pos.list(strongSide)[1]; + Square ksq = pos.square(weakSide); + Square psq1 = pos.squares(strongSide)[0]; + Square psq2 = pos.squares(strongSide)[1]; Rank r1 = rank_of(psq1); Rank r2 = rank_of(psq2); Square blockSq1, blockSq2; @@ -777,9 +767,9 @@ ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, BishopValueMg, 1)); assert(verify_material(pos, weakSide, KnightValueMg, 0)); - Square pawnSq = pos.list(strongSide)[0]; - Square strongBishopSq = pos.list(strongSide)[0]; - Square weakKingSq = pos.king_square(weakSide); + Square pawnSq = pos.square(strongSide); + Square strongBishopSq = pos.square(strongSide); + Square weakKingSq = pos.square(weakSide); if ( file_of(weakKingSq) == file_of(pawnSq) && relative_rank(strongSide, pawnSq) < relative_rank(strongSide, weakKingSq) @@ -800,8 +790,8 @@ ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, weakSide, VALUE_ZERO, 0)); // Assume strongSide is white and the pawn is on files A-D - Square pawnSq = normalize(pos, strongSide, pos.list(strongSide)[0]); - Square weakKingSq = normalize(pos, strongSide, pos.king_square(weakSide)); + Square pawnSq = normalize(pos, strongSide, pos.square(strongSide)); + Square weakKingSq = normalize(pos, strongSide, pos.square(weakSide)); if (pawnSq == SQ_A7 && distance(SQ_A8, weakKingSq) <= 1) return SCALE_FACTOR_DRAW; @@ -815,9 +805,9 @@ ScaleFactor Endgame::operator()(const Position& pos) const { template<> ScaleFactor Endgame::operator()(const Position& pos) const { - Square pawnSq = pos.list(strongSide)[0]; - Square bishopSq = pos.list(weakSide)[0]; - Square weakKingSq = pos.king_square(weakSide); + Square pawnSq = pos.square(strongSide); + Square bishopSq = pos.square(weakSide); + Square weakKingSq = pos.square(weakSide); // King needs to get close to promoting pawn to prevent knight from blocking. // Rules for this are very tricky, so just approximate. @@ -840,9 +830,9 @@ ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, weakSide, VALUE_ZERO, 1)); // Assume strongSide is white and the pawn is on files A-D - Square wksq = normalize(pos, strongSide, pos.king_square(strongSide)); - Square bksq = normalize(pos, strongSide, pos.king_square(weakSide)); - Square psq = normalize(pos, strongSide, pos.list(strongSide)[0]); + Square wksq = normalize(pos, strongSide, pos.square(strongSide)); + Square bksq = normalize(pos, strongSide, pos.square(weakSide)); + Square psq = normalize(pos, strongSide, pos.square(strongSide)); Color us = strongSide == pos.side_to_move() ? WHITE : BLACK; diff --git a/DroidFish/jni/stockfish/endgame.h b/DroidFish/jni/stockfish/endgame.h index d7a7681..f24ac93 100644 --- a/DroidFish/jni/stockfish/endgame.h +++ b/DroidFish/jni/stockfish/endgame.h @@ -21,7 +21,10 @@ #define ENDGAME_H_INCLUDED #include +#include #include +#include +#include #include "position.h" #include "types.h" @@ -63,11 +66,9 @@ enum EndgameType { /// Endgame functions can be of two types depending on whether they return a -/// Value or a ScaleFactor. Type eg_fun::type returns either ScaleFactor -/// or Value depending on whether the template parameter is 0 or 1. - -template struct eg_fun { typedef Value type; }; -template<> struct eg_fun<1> { typedef ScaleFactor type; }; +/// Value or a ScaleFactor. +template using +eg_type = typename std::conditional<(E < SCALING_FUNCTIONS), Value, ScaleFactor>::type; /// Base and derived templates for endgame evaluation and scaling functions @@ -75,13 +76,13 @@ template<> struct eg_fun<1> { typedef ScaleFactor type; }; template struct EndgameBase { - virtual ~EndgameBase() {} + virtual ~EndgameBase() = default; virtual Color strong_side() const = 0; virtual T operator()(const Position&) const = 0; }; -template SCALING_FUNCTIONS)>::type> +template> struct Endgame : public EndgameBase { explicit Endgame(Color c) : strongSide(c), weakSide(~c) {} @@ -99,23 +100,24 @@ private: class Endgames { - typedef std::map::type>*> M1; - typedef std::map::type>*> M2; + template using Map = std::map>>; - M1 m1; - M2 m2; + template> + void add(const std::string& code); - M1& map(M1::mapped_type) { return m1; } - M2& map(M2::mapped_type) { return m2; } + template + Map& map() { + return std::get::value>(maps); + } - template void add(const std::string& code); + std::pair, Map> maps; public: Endgames(); - ~Endgames(); - template T probe(Key key, T& eg) { - return eg = map(eg).count(key) ? map(eg)[key] : NULL; + template + EndgameBase* probe(Key key) { + return map().count(key) ? map()[key].get() : nullptr; } }; diff --git a/DroidFish/jni/stockfish/evaluate.cpp b/DroidFish/jni/stockfish/evaluate.cpp index 45c5b0a..44a0669 100644 --- a/DroidFish/jni/stockfish/evaluate.cpp +++ b/DroidFish/jni/stockfish/evaluate.cpp @@ -30,17 +30,50 @@ namespace { + namespace Trace { + + enum Term { // First 8 entries are for PieceType + MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, TOTAL, TERM_NB + }; + + double scores[TERM_NB][COLOR_NB][PHASE_NB]; + + double to_cp(Value v) { return double(v) / PawnValueEg; } + + void add(int idx, Color c, Score s) { + scores[idx][c][MG] = to_cp(mg_value(s)); + scores[idx][c][EG] = to_cp(eg_value(s)); + } + + void add(int idx, Score w, Score b = SCORE_ZERO) { + add(idx, WHITE, w); add(idx, BLACK, b); + } + + std::ostream& operator<<(std::ostream& os, Term t) { + + if (t == MATERIAL || t == IMBALANCE || t == Term(PAWN) || t == TOTAL) + os << " --- --- | --- --- | "; + else + os << std::setw(5) << scores[t][WHITE][MG] << " " + << std::setw(5) << scores[t][WHITE][EG] << " | " + << std::setw(5) << scores[t][BLACK][MG] << " " + << std::setw(5) << scores[t][BLACK][EG] << " | "; + + os << std::setw(5) << scores[t][WHITE][MG] - scores[t][BLACK][MG] << " " + << std::setw(5) << scores[t][WHITE][EG] - scores[t][BLACK][EG] << " \n"; + + return os; + } + } + + using namespace Trace; + // Struct EvalInfo contains various information computed and collected // by the evaluation functions. struct EvalInfo { - // Pointers to material and pawn hash table entries - Material::Entry* mi; - Pawns::Entry* pi; - // attackedBy[color][piece type] is a bitboard representing all squares - // attacked by a given color and piece type, attackedBy[color][ALL_PIECES] - // contains all squares attacked by the given color. + // attacked by a given color and piece type (can be also ALL_PIECES). Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB]; // kingRing[color] is the zone around the king which is considered @@ -61,38 +94,29 @@ namespace { // KingAttackWeights array. int kingAttackersWeight[COLOR_NB]; - // kingAdjacentZoneAttacksCount[color] is the number of attacks to squares - // directly adjacent to the king of the given color. Pieces which attack - // more than one square are counted multiple times. For instance, if black's - // king is on g8 and there's a white knight on g5, this knight adds - // 2 to kingAdjacentZoneAttacksCount[BLACK]. + // kingAdjacentZoneAttacksCount[color] is the number of attacks by the given + // color to squares directly adjacent to the enemy king. Pieces which attack + // more than one square are counted multiple times. For instance, if there is + // a white knight on g5 and black's king is on g8, this white knight adds 2 + // to kingAdjacentZoneAttacksCount[WHITE]. int kingAdjacentZoneAttacksCount[COLOR_NB]; Bitboard pinnedPieces[COLOR_NB]; + Pawns::Entry* pi; }; - namespace Tracing { - enum Terms { // First 8 entries are for PieceType - MATERIAL = 8, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, TOTAL, TERMS_NB - }; + // Evaluation weights, indexed by the corresponding evaluation term + enum { Mobility, PawnStructure, PassedPawns, Space, KingSafety }; - Score scores[COLOR_NB][TERMS_NB]; - EvalInfo ei; - ScaleFactor sf; + const struct Weight { int mg, eg; } Weights[] = { + {289, 344}, {233, 201}, {221, 273}, {46, 0}, {322, 0} + }; - double to_cp(Value v); - void write(int idx, Color c, Score s); - void write(int idx, Score w, Score b = SCORE_ZERO); - void print(std::stringstream& ss, const char* name, int idx); - std::string do_trace(const Position& pos); + Score operator*(Score s, const Weight& w) { + return make_score(mg_value(s) * w.mg / 256, eg_value(s) * w.eg / 256); } - // Evaluation weights, indexed by evaluation term - enum { Mobility, PawnStructure, PassedPawns, Space, KingSafety }; - const struct Weight { int mg, eg; } Weights[] = { - {289, 344}, {233, 201}, {221, 273}, {46, 0}, {321, 0} - }; #define V(v) Value(v) #define S(mg, eg) make_score(mg, eg) @@ -102,55 +126,58 @@ namespace { // friendly pieces. const Score MobilityBonus[][32] = { {}, {}, - { S(-65,-50), S(-42,-30), S(-9,-10), S( 3, 0), S(15, 10), S(27, 20), // Knights - S( 37, 28), S( 42, 31), S(44, 33) }, - { S(-52,-47), S(-28,-23), S( 6, 1), S(20, 15), S(34, 29), S(48, 43), // Bishops - S( 60, 55), S( 68, 63), S(74, 68), S(77, 72), S(80, 75), S(82, 77), - S( 84, 79), S( 86, 81) }, - { S(-47,-53), S(-31,-26), S(-5, 0), S( 1, 16), S( 7, 32), S(13, 48), // Rooks - S( 18, 64), S( 22, 80), S(26, 96), S(29,109), S(31,115), S(33,119), - S( 35,122), S( 36,123), S(37,124) }, - { S(-42,-40), S(-28,-23), S(-5, -7), S( 0, 0), S( 6, 10), S(11, 19), // Queens - S( 13, 29), S( 18, 38), S(20, 40), S(21, 41), S(22, 41), S(22, 41), - S( 22, 41), S( 23, 41), S(24, 41), S(25, 41), S(25, 41), S(25, 41), - S( 25, 41), S( 25, 41), S(25, 41), S(25, 41), S(25, 41), S(25, 41), - S( 25, 41), S( 25, 41), S(25, 41), S(25, 41) } + { S(-70,-52), S(-52,-37), S( -7,-17), S( 0, -6), S( 8, 5), S( 16, 9), // Knights + S( 23, 20), S( 31, 21), S( 36, 22) }, + { S(-49,-44), S(-22,-13), S( 16, 0), S( 27, 11), S( 38, 19), S( 52, 34), // Bishops + S( 56, 44), S( 65, 47), S( 67, 51), S( 73, 56), S( 81, 59), S( 83, 69), + S( 95, 72), S(100, 75) }, + { S(-49,-57), S(-22,-14), S(-10, 18), S( -5, 39), S( -4, 50), S( -2, 58), // Rooks + S( 6, 78), S( 11, 86), S( 17, 92), S( 19,103), S( 26,111), S( 27,115), + S( 36,119), S( 41,121), S( 50,122) }, + { S(-41,-24), S(-26, -8), S( 0, 6), S( 2, 14), S( 12, 27), S( 21, 40), // Queens + S( 22, 45), S( 37, 55), S( 40, 57), S( 43, 63), S( 50, 68), S( 52, 74), + S( 56, 80), S( 66, 84), S( 68, 85), S( 69, 88), S( 71, 92), S( 72, 94), + S( 80, 96), S( 89, 98), S( 94,101), S(102,113), S(106,114), S(107,116), + S(112,125), S(113,127), S(117,137), S(122,143) } }; - // Outpost[PieceType][Square] contains bonuses for knights and bishops outposts, - // indexed by piece type and square (from white's point of view). - const Value Outpost[][SQUARE_NB] = { - {// A B C D E F G H - V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Knights - V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), - V(0), V(0), V(4), V(8), V(8), V(4), V(0), V(0), - V(0), V(4),V(17),V(26),V(26),V(17), V(4), V(0), - V(0), V(8),V(26),V(35),V(35),V(26), V(8), V(0), - V(0), V(4),V(17),V(17),V(17),V(17), V(4), V(0) }, - { - V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // Bishops - V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), - V(0), V(0), V(5), V(5), V(5), V(5), V(0), V(0), - V(0), V(5),V(10),V(10),V(10),V(10), V(5), V(0), - V(0),V(10),V(21),V(21),V(21),V(21),V(10), V(0), - V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0) } + // Outpost[knight/bishop][supported by pawn] contains bonuses for knights and + // bishops outposts, bigger if outpost piece is supported by a pawn. + const Score Outpost[][2] = { + { S(42,11), S(63,17) }, // Knights + { S(18, 5), S(27, 8) } // Bishops }; - // Threat[defended/weak][minor/major attacking][attacked PieceType] contains + // Threat[defended/weak][minor/rook attacking][attacked PieceType] contains // bonuses according to which piece type attacks which one. const Score Threat[][2][PIECE_TYPE_NB] = { - { { S(0, 0), S( 0, 0), S(19, 37), S(24, 37), S(44, 97), S(35,106) }, // Defended Minor - { S(0, 0), S( 0, 0), S( 9, 14), S( 9, 14), S( 7, 14), S(24, 48) } }, // Defended Major - { { S(0, 0), S( 0,32), S(33, 41), S(31, 50), S(41,100), S(35,104) }, // Weak Minor - { S(0, 0), S( 0,27), S(26, 57), S(26, 57), S(0 , 43), S(23, 51) } } // Weak Major + { { S(0, 0), S( 0, 0), S(19, 37), S(24, 37), S(44, 97), S(35,106) }, // Minor on Defended + { S(0, 0), S( 0, 0), S( 9, 14), S( 9, 14), S( 7, 14), S(24, 48) } }, // Rook on Defended + { { S(0, 0), S( 0,32), S(33, 41), S(31, 50), S(41,100), S(35,104) }, // Minor on Weak + { S(0, 0), S( 0,27), S(26, 57), S(26, 57), S(0 , 43), S(23, 51) } } // Rook on Weak }; // ThreatenedByPawn[PieceType] contains a penalty according to which piece // type is attacked by an enemy pawn. - const Score ThreatenedByPawn[] = { - S(0, 0), S(0, 0), S(87, 118), S(84, 122), S(114, 203), S(121, 217) + const Score ThreatenedByPawn[PIECE_TYPE_NB] = { + S(0, 0), S(0, 0), S(107, 138), S(84, 122), S(114, 203), S(121, 217) }; + // Passed[mg/eg][rank] contains midgame and endgame bonuses for passed pawns. + // We don't use a Score because we process the two components independently. + const Value Passed[][RANK_NB] = { + { V(0), V( 1), V(34), V(90), V(214), V(328) }, + { V(7), V(14), V(37), V(63), V(134), V(189) } + }; + + // PassedFile[File] contains a bonus according to the file of a passed pawn. + const Score PassedFile[] = { + S( 12, 10), S( 3, 10), S( 1, -8), S(-27, -12), + S(-27, -12), S( 1, -8), S( 3, 10), S( 12, 10) + }; + + const Score ThreatenedByHangingPawn = S(40, 60); + // Assorted bonuses and penalties used by evaluation const Score KingOnOne = S( 2, 58); const Score KingOnMany = S( 6,125); @@ -162,6 +189,8 @@ namespace { const Score TrappedRook = S(92, 0); const Score Unstoppable = S( 0, 20); const Score Hanging = S(31, 26); + const Score PawnAttackThreat = S(20, 20); + const Score Checked = S(20, 20); // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only @@ -175,7 +204,7 @@ namespace { // by the space evaluation. In the middlegame, each side is given a bonus // based on how many squares inside this area are safe and available for // friendly minor pieces. - const Bitboard SpaceMask[] = { + const Bitboard SpaceMask[COLOR_NB] = { (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank2BB | Rank3BB | Rank4BB), (FileCBB | FileDBB | FileEBB | FileFBB) & (Rank7BB | Rank6BB | Rank5BB) }; @@ -184,26 +213,17 @@ namespace { // in KingDanger[]. Various little "meta-bonuses" measuring the strength // of the enemy attack are added up into an integer, which is used as an // index to KingDanger[]. - // - // KingAttackWeights[PieceType] contains king attack weights by piece type - const int KingAttackWeights[] = { 0, 0, 6, 2, 5, 5 }; - - // Bonuses for enemy's safe checks - const int QueenContactCheck = 92; - const int RookContactCheck = 68; - const int QueenCheck = 50; - const int RookCheck = 36; - const int BishopCheck = 7; - const int KnightCheck = 14; - - // KingDanger[attackUnits] contains the actual king danger weighted - // scores, indexed by a calculated integer number. Score KingDanger[512]; - // apply_weight() weighs score 's' by weight 'w' trying to prevent overflow - Score apply_weight(Score s, const Weight& w) { - return make_score(mg_value(s) * w.mg / 256, eg_value(s) * w.eg / 256); - } + // KingAttackWeights[PieceType] contains king attack weights by piece type + const int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 7, 5, 4, 1 }; + + // Penalties for enemy's safe checks + const int QueenContactCheck = 89; + const int QueenCheck = 50; + const int RookCheck = 45; + const int BishopCheck = 6; + const int KnightCheck = 14; // init_eval_info() initializes king bitboards for given color adding @@ -212,13 +232,13 @@ namespace { template void init_eval_info(const Position& pos, EvalInfo& ei) { - const Color Them = (Us == WHITE ? BLACK : WHITE); + const Color Them = (Us == WHITE ? BLACK : WHITE); const Square Down = (Us == WHITE ? DELTA_S : DELTA_N); ei.pinnedPieces[Us] = pos.pinned_pieces(Us); - - Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from(pos.king_square(Them)); - ei.attackedBy[Us][ALL_PIECES] = ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us); + Bitboard b = ei.attackedBy[Them][KING] = pos.attacks_from(pos.square(Them)); + ei.attackedBy[Them][ALL_PIECES] |= b; + ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][PAWN] = ei.pi->pawn_attacks(Us); // Init king safety tables only if we are going to use them if (pos.non_pawn_material(Us) >= QueenValueMg) @@ -233,37 +253,10 @@ namespace { } - // evaluate_outpost() evaluates bishop and knight outpost squares - - template - Score evaluate_outpost(const Position& pos, const EvalInfo& ei, Square s) { - - const Color Them = (Us == WHITE ? BLACK : WHITE); - - assert (Pt == BISHOP || Pt == KNIGHT); - - // Initial bonus based on square - Value bonus = Outpost[Pt == BISHOP][relative_square(Us, s)]; - - // Increase bonus if supported by pawn, especially if the opponent has - // no minor piece which can trade with the outpost piece. - if (bonus && (ei.attackedBy[Us][PAWN] & s)) - { - if ( !pos.pieces(Them, KNIGHT) - && !(squares_of_color(s) & pos.pieces(Them, BISHOP))) - bonus += bonus + bonus / 2; - else - bonus += bonus / 2; - } - - return make_score(bonus * 2, bonus / 2); - } - - // evaluate_pieces() assigns bonuses and penalties to the pieces of a given color - template - Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility, Bitboard* mobilityArea) { + template + Score evaluate_pieces(const Position& pos, EvalInfo& ei, Score* mobility, const Bitboard* mobilityArea) { Bitboard b; Square s; @@ -271,7 +264,7 @@ namespace { const PieceType NextPt = (Us == WHITE ? Pt : PieceType(Pt + 1)); const Color Them = (Us == WHITE ? BLACK : WHITE); - const Square* pl = pos.list(Us); + const Square* pl = pos.squares(Us); ei.attackedBy[Us][Pt] = 0; @@ -283,7 +276,7 @@ namespace { : pos.attacks_from(s); if (ei.pinnedPieces[Us] & s) - b &= LineBB[pos.king_square(Us)][s]; + b &= LineBB[pos.square(Us)][s]; ei.attackedBy[Us][ALL_PIECES] |= ei.attackedBy[Us][Pt] |= b; @@ -301,21 +294,17 @@ namespace { | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]); - int mob = Pt != QUEEN ? popcount(b & mobilityArea[Us]) - : popcount(b & mobilityArea[Us]); + int mob = popcount(b & mobilityArea[Us]); mobility[Us] += MobilityBonus[Pt][mob]; - // Decrease score if we are attacked by an enemy pawn. The remaining part - // of threat evaluation must be done later when we have full attack info. - if (ei.attackedBy[Them][PAWN] & s) - score -= ThreatenedByPawn[Pt]; - if (Pt == BISHOP || Pt == KNIGHT) { // Bonus for outpost square - if (!(pos.pieces(Them, PAWN) & pawn_attack_span(Us, s))) - score += evaluate_outpost(pos, ei, s); + if ( relative_rank(Us, s) >= RANK_4 + && relative_rank(Us, s) <= RANK_6 + && !(pos.pieces(Them, PAWN) & pawn_attack_span(Us, s))) + score += Outpost[Pt == BISHOP][!!(ei.attackedBy[Us][PAWN] & s)]; // Bonus when behind a pawn if ( relative_rank(Us, s) < RANK_5 @@ -358,7 +347,7 @@ namespace { // Penalize when trapped by the king, even more if king cannot castle if (mob <= 3 && !ei.pi->semiopen_file(Us, file_of(s))) { - Square ksq = pos.king_square(Us); + Square ksq = pos.square(Us); if ( ((file_of(ksq) < FILE_E) == (file_of(s) < file_of(ksq))) && (rank_of(ksq) == rank_of(s) || relative_rank(Us, ksq) == RANK_1) @@ -368,29 +357,29 @@ namespace { } } - if (Trace) - Tracing::write(Pt, Us, score); + if (DoTrace) + Trace::add(Pt, Us, score); // Recursively call evaluate_pieces() of next piece type until KING excluded - return score - evaluate_pieces(pos, ei, mobility, mobilityArea); + return score - evaluate_pieces(pos, ei, mobility, mobilityArea); } template<> - Score evaluate_pieces(const Position&, EvalInfo&, Score*, Bitboard*) { return SCORE_ZERO; } + Score evaluate_pieces(const Position&, EvalInfo&, Score*, const Bitboard*) { return SCORE_ZERO; } template<> - Score evaluate_pieces(const Position&, EvalInfo&, Score*, Bitboard*) { return SCORE_ZERO; } + Score evaluate_pieces(const Position&, EvalInfo&, Score*, const Bitboard*) { return SCORE_ZERO; } // evaluate_king() assigns bonuses and penalties to a king of a given color - template + template Score evaluate_king(const Position& pos, const EvalInfo& ei) { const Color Them = (Us == WHITE ? BLACK : WHITE); Bitboard undefended, b, b1, b2, safe; int attackUnits; - const Square ksq = pos.king_square(Us); + const Square ksq = pos.square(Us); // King shelter and enemy pawns storm Score score = ei.pi->king_safety(pos, ksq); @@ -411,12 +400,12 @@ namespace { // number and types of the enemy's attacking pieces, the number of // attacked and undefended squares around our king and the quality of // the pawn shelter (current 'score' value). - attackUnits = std::min(77, ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) - + 10 * ei.kingAdjacentZoneAttacksCount[Them] - + 19 * popcount(undefended) - + 9 * (ei.pinnedPieces[Us] != 0) - - mg_value(score) * 63 / 512 - - !pos.count(Them) * 60; + attackUnits = std::min(72, ei.kingAttackersCount[Them] * ei.kingAttackersWeight[Them]) + + 9 * ei.kingAdjacentZoneAttacksCount[Them] + + 27 * popcount(undefended) + + 11 * !!ei.pinnedPieces[Us] + - 64 * !pos.count(Them) + - mg_value(score) / 8; // Analyse the enemy's safe queen contact checks. Firstly, find the // undefended squares around the king reachable by the enemy queen... @@ -425,29 +414,13 @@ namespace { { // ...and then remove squares not supported by another enemy piece b &= ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT] - | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]; + | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK] + | ei.attackedBy[Them][KING]; if (b) attackUnits += QueenContactCheck * popcount(b); } - // Analyse the enemy's safe rook contact checks. Firstly, find the - // undefended squares around the king reachable by the enemy rooks... - b = undefended & ei.attackedBy[Them][ROOK] & ~pos.pieces(Them); - - // Consider only squares where the enemy's rook gives check - b &= PseudoAttacks[ROOK][ksq]; - - if (b) - { - // ...and then remove squares not supported by another enemy piece - b &= ( ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT] - | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][QUEEN]); - - if (b) - attackUnits += RookContactCheck * popcount(b); - } - // Analyse the enemy's safe distance checks for sliders and knights safe = ~(ei.attackedBy[Us][ALL_PIECES] | pos.pieces(Them)); @@ -457,30 +430,42 @@ namespace { // Enemy queen safe checks b = (b1 | b2) & ei.attackedBy[Them][QUEEN]; if (b) + { attackUnits += QueenCheck * popcount(b); + score -= Checked; + } // Enemy rooks safe checks b = b1 & ei.attackedBy[Them][ROOK]; if (b) + { attackUnits += RookCheck * popcount(b); + score -= Checked; + } // Enemy bishops safe checks b = b2 & ei.attackedBy[Them][BISHOP]; if (b) + { attackUnits += BishopCheck * popcount(b); + score -= Checked; + } // Enemy knights safe checks b = pos.attacks_from(ksq) & ei.attackedBy[Them][KNIGHT] & safe; if (b) + { attackUnits += KnightCheck * popcount(b); + score -= Checked; + } // Finally, extract the king danger score from the KingDanger[] // array and subtract the score from evaluation. score -= KingDanger[std::max(std::min(attackUnits, 399), 0)]; } - if (Trace) - Tracing::write(KING, Us, score); + if (DoTrace) + Trace::add(KING, Us, score); return score; } @@ -489,20 +474,41 @@ namespace { // evaluate_threats() assigns bonuses according to the type of attacking piece // and the type of attacked one. - template + template Score evaluate_threats(const Position& pos, const EvalInfo& ei) { - const Color Them = (Us == WHITE ? BLACK : WHITE); + const Color Them = (Us == WHITE ? BLACK : WHITE); + const Square Up = (Us == WHITE ? DELTA_N : DELTA_S); + const Square Left = (Us == WHITE ? DELTA_NW : DELTA_SE); + const Square Right = (Us == WHITE ? DELTA_NE : DELTA_SW); + const Bitboard TRank2BB = (Us == WHITE ? Rank2BB : Rank7BB); + const Bitboard TRank7BB = (Us == WHITE ? Rank7BB : Rank2BB); enum { Defended, Weak }; - enum { Minor, Major }; + enum { Minor, Rook }; - Bitboard b, weak, defended; + Bitboard b, weak, defended, safeThreats; Score score = SCORE_ZERO; + // Non-pawn enemies attacked by a pawn + weak = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Us][PAWN]; + + if (weak) + { + b = pos.pieces(Us, PAWN) & ( ~ei.attackedBy[Them][ALL_PIECES] + | ei.attackedBy[Us][ALL_PIECES]); + + safeThreats = (shift_bb(b) | shift_bb(b)) & weak; + + if (weak ^ safeThreats) + score += ThreatenedByHangingPawn; + + while (safeThreats) + score += ThreatenedByPawn[type_of(pos.piece_on(pop_lsb(&safeThreats)))]; + } + // Non-pawn enemies defended by a pawn - defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) - & ei.attackedBy[Them][PAWN]; + defended = (pos.pieces(Them) ^ pos.pieces(Them, PAWN)) & ei.attackedBy[Them][PAWN]; // Add a bonus according to the kind of attacking pieces if (defended) @@ -511,9 +517,9 @@ namespace { while (b) score += Threat[Defended][Minor][type_of(pos.piece_on(pop_lsb(&b)))]; - b = defended & (ei.attackedBy[Us][ROOK]); + b = defended & ei.attackedBy[Us][ROOK]; while (b) - score += Threat[Defended][Major][type_of(pos.piece_on(pop_lsb(&b)))]; + score += Threat[Defended][Rook][type_of(pos.piece_on(pop_lsb(&b)))]; } // Enemies not defended by a pawn and under our attack @@ -528,9 +534,9 @@ namespace { while (b) score += Threat[Weak][Minor][type_of(pos.piece_on(pop_lsb(&b)))]; - b = weak & (ei.attackedBy[Us][ROOK] | ei.attackedBy[Us][QUEEN]); + b = weak & ei.attackedBy[Us][ROOK]; while (b) - score += Threat[Weak][Major][type_of(pos.piece_on(pop_lsb(&b)))]; + score += Threat[Weak][Rook][type_of(pos.piece_on(pop_lsb(&b)))]; b = weak & ~ei.attackedBy[Them][ALL_PIECES]; if (b) @@ -541,8 +547,23 @@ namespace { score += more_than_one(b) ? KingOnMany : KingOnOne; } - if (Trace) - Tracing::write(Tracing::THREAT, Us, score); + // Bonus if some pawns can safely push and attack an enemy piece + b = pos.pieces(Us, PAWN) & ~TRank7BB; + b = shift_bb(b | (shift_bb(b & TRank2BB) & ~pos.pieces())); + + b &= ~pos.pieces() + & ~ei.attackedBy[Them][PAWN] + & (ei.attackedBy[Us][ALL_PIECES] | ~ei.attackedBy[Them][ALL_PIECES]); + + b = (shift_bb(b) | shift_bb(b)) + & pos.pieces(Them) + & ~ei.attackedBy[Us][PAWN]; + + if (b) + score += popcount(b) * PawnAttackThreat; + + if (DoTrace) + Trace::add(THREAT, Us, score); return score; } @@ -550,7 +571,7 @@ namespace { // evaluate_passed_pawns() evaluates the passed pawns of the given color - template + template Score evaluate_passed_pawns(const Position& pos, const EvalInfo& ei) { const Color Them = (Us == WHITE ? BLACK : WHITE); @@ -569,20 +590,19 @@ namespace { int r = relative_rank(Us, s) - RANK_2; int rr = r * (r - 1); - // Base bonus based on rank - Value mbonus = Value(17 * rr), ebonus = Value(7 * (rr + r + 1)); + Value mbonus = Passed[MG][r], ebonus = Passed[EG][r]; if (rr) { Square blockSq = s + pawn_push(Us); // Adjust bonus based on the king's proximity - ebonus += distance(pos.king_square(Them), blockSq) * 5 * rr - - distance(pos.king_square(Us ), blockSq) * 2 * rr; + ebonus += distance(pos.square(Them), blockSq) * 5 * rr + - distance(pos.square(Us ), blockSq) * 2 * rr; // If blockSq is not the queening square then consider also a second push if (relative_rank(Us, blockSq) != RANK_8) - ebonus -= distance(pos.king_square(Us), blockSq + pawn_push(Us)) * rr; + ebonus -= distance(pos.square(Us), blockSq + pawn_push(Us)) * rr; // If the pawn is free to advance, then increase the bonus if (pos.empty(blockSq)) @@ -602,7 +622,7 @@ namespace { // If there aren't any enemy attacks, assign a big bonus. Otherwise // assign a smaller bonus if the block square isn't attacked. - int k = !unsafeSquares ? 15 : !(unsafeSquares & blockSq) ? 9 : 0; + int k = !unsafeSquares ? 18 : !(unsafeSquares & blockSq) ? 8 : 0; // If the path to queen is fully defended, assign a big bonus. // Otherwise assign a smaller bonus if the block square is defended. @@ -621,14 +641,14 @@ namespace { if (pos.count(Us) < pos.count(Them)) ebonus += ebonus / 4; - score += make_score(mbonus, ebonus); + score += make_score(mbonus, ebonus) + PassedFile[file_of(s)]; } - if (Trace) - Tracing::write(Tracing::PASSED, Us, apply_weight(score, Weights[PassedPawns])); + if (DoTrace) + Trace::add(PASSED, Us, score * Weights[PassedPawns]); // Add the scores to the middlegame and endgame eval - return apply_weight(score, Weights[PassedPawns]); + return score * Weights[PassedPawns]; } @@ -656,10 +676,10 @@ namespace { behind |= (Us == WHITE ? behind >> 8 : behind << 8); behind |= (Us == WHITE ? behind >> 16 : behind << 16); - // Since SpaceMask[Us] is fully on our half of the board + // Since SpaceMask[Us] is fully on our half of the board... assert(unsigned(safe >> (Us == WHITE ? 32 : 0)) == 0); - // Count safe + (behind & safe) with a single popcount + // ...count safe + (behind & safe) with a single popcount int bonus = popcount((Us == WHITE ? safe << 32 : safe >> 32) | (behind & safe)); int weight = pos.count(Us) + pos.count(Us) + pos.count(Them) + pos.count(Them); @@ -668,238 +688,216 @@ namespace { } - // do_evaluate() is the evaluation entry point, called directly from evaluate() + // evaluate_initiative() computes the initiative correction value for the position, i.e. + // second order bonus/malus based on the known attacking/defending status of the players. + Score evaluate_initiative(const Position& pos, const EvalInfo& ei, const Score positional_score) { - template - Value do_evaluate(const Position& pos) { + int pawns = pos.count(WHITE) + pos.count(BLACK); + int king_separation = distance(pos.square(WHITE), pos.square(BLACK)); + int asymmetry = ei.pi->pawn_asymmetry(); - assert(!pos.checkers()); + // Compute the initiative bonus for the attacking side + int attacker_bonus = 8 * (pawns + asymmetry + king_separation) - 120; - EvalInfo ei; - Score score, mobility[2] = { SCORE_ZERO, SCORE_ZERO }; + // Now apply the bonus: note that we find the attacking side by extracting the sign + // of the endgame value of "positional_score", and that we carefully cap the bonus so + // that the endgame score with the correction will never be divided by more than two. + int eg = eg_value(positional_score); + int value = ((eg > 0) - (eg < 0)) * std::max( attacker_bonus , -abs( eg / 2 ) ); - // Initialize score by reading the incrementally updated scores included - // in the position object (material + piece square tables). - // Score is computed from the point of view of white. - score = pos.psq_score(); - - // Probe the material hash table - ei.mi = Material::probe(pos); - score += ei.mi->imbalance(); - - // If we have a specialized evaluation function for the current material - // configuration, call it and return. - if (ei.mi->specialized_eval_exists()) - return ei.mi->evaluate(pos); - - // Probe the pawn hash table - ei.pi = Pawns::probe(pos); - score += apply_weight(ei.pi->pawns_score(), Weights[PawnStructure]); - - // Initialize attack and king safety bitboards - init_eval_info(pos, ei); - init_eval_info(pos, ei); - - ei.attackedBy[WHITE][ALL_PIECES] |= ei.attackedBy[WHITE][KING]; - ei.attackedBy[BLACK][ALL_PIECES] |= ei.attackedBy[BLACK][KING]; - - // Do not include in mobility squares protected by enemy pawns or occupied by our pawns or king - Bitboard mobilityArea[] = { ~(ei.attackedBy[BLACK][PAWN] | pos.pieces(WHITE, PAWN, KING)), - ~(ei.attackedBy[WHITE][PAWN] | pos.pieces(BLACK, PAWN, KING)) }; - - // Evaluate pieces and mobility - score += evaluate_pieces(pos, ei, mobility, mobilityArea); - score += apply_weight(mobility[WHITE] - mobility[BLACK], Weights[Mobility]); - - // Evaluate kings after all other pieces because we need complete attack - // information when computing the king safety evaluation. - score += evaluate_king(pos, ei) - - evaluate_king(pos, ei); - - // Evaluate tactical threats, we need full attack information including king - score += evaluate_threats(pos, ei) - - evaluate_threats(pos, ei); - - // Evaluate passed pawns, we need full attack information including king - score += evaluate_passed_pawns(pos, ei) - - evaluate_passed_pawns(pos, ei); - - // If both sides have only pawns, score for potential unstoppable pawns - if (!pos.non_pawn_material(WHITE) && !pos.non_pawn_material(BLACK)) - { - Bitboard b; - if ((b = ei.pi->passed_pawns(WHITE)) != 0) - score += int(relative_rank(WHITE, frontmost_sq(WHITE, b))) * Unstoppable; - - if ((b = ei.pi->passed_pawns(BLACK)) != 0) - score -= int(relative_rank(BLACK, frontmost_sq(BLACK, b))) * Unstoppable; - } - - // Evaluate space for both sides, only during opening - if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 2 * QueenValueMg + 4 * RookValueMg + 2 * KnightValueMg) - { - Score s = evaluate_space(pos, ei) - evaluate_space(pos, ei); - score += apply_weight(s, Weights[Space]); - } - - // Scale winning side if position is more drawish than it appears - Color strongSide = eg_value(score) > VALUE_DRAW ? WHITE : BLACK; - ScaleFactor sf = ei.mi->scale_factor(pos, strongSide); - - // If we don't already have an unusual scale factor, check for certain - // types of endgames, and use a lower scale for those. - if ( ei.mi->game_phase() < PHASE_MIDGAME - && (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN)) - { - if (pos.opposite_bishops()) - { - // Endgame with opposite-colored bishops and no other pieces (ignoring pawns) - // is almost a draw, in case of KBP vs KB is even more a draw. - if ( pos.non_pawn_material(WHITE) == BishopValueMg - && pos.non_pawn_material(BLACK) == BishopValueMg) - sf = more_than_one(pos.pieces(PAWN)) ? ScaleFactor(32) : ScaleFactor(8); - - // Endgame with opposite-colored bishops, but also other pieces. Still - // a bit drawish, but not as drawish as with only the two bishops. - else - sf = ScaleFactor(50 * sf / SCALE_FACTOR_NORMAL); - } - // Endings where weaker side can place his king in front of the opponent's - // pawns are drawish. - else if ( abs(eg_value(score)) <= BishopValueEg - && ei.pi->pawn_span(strongSide) <= 1 - && !pos.pawn_passed(~strongSide, pos.king_square(~strongSide))) - sf = ei.pi->pawn_span(strongSide) ? ScaleFactor(56) : ScaleFactor(38); - } - - // Interpolate between a middlegame and a (scaled by 'sf') endgame score - Value v = mg_value(score) * int(ei.mi->game_phase()) - + eg_value(score) * int(PHASE_MIDGAME - ei.mi->game_phase()) * sf / SCALE_FACTOR_NORMAL; - - v /= int(PHASE_MIDGAME); - - // In case of tracing add all single evaluation contributions for both white and black - if (Trace) - { - Tracing::write(Tracing::MATERIAL, pos.psq_score()); - Tracing::write(Tracing::IMBALANCE, ei.mi->imbalance()); - Tracing::write(PAWN, ei.pi->pawns_score()); - Tracing::write(Tracing::MOBILITY, apply_weight(mobility[WHITE], Weights[Mobility]) - , apply_weight(mobility[BLACK], Weights[Mobility])); - Tracing::write(Tracing::SPACE, apply_weight(evaluate_space(pos, ei), Weights[Space]) - , apply_weight(evaluate_space(pos, ei), Weights[Space])); - Tracing::write(Tracing::TOTAL, score); - Tracing::ei = ei; - Tracing::sf = sf; - } - - return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; - } - - - // Tracing function definitions - - double Tracing::to_cp(Value v) { return double(v) / PawnValueEg; } - - void Tracing::write(int idx, Color c, Score s) { scores[c][idx] = s; } - - void Tracing::write(int idx, Score w, Score b) { - - write(idx, WHITE, w); - write(idx, BLACK, b); - } - - void Tracing::print(std::stringstream& ss, const char* name, int idx) { - - Score wScore = scores[WHITE][idx]; - Score bScore = scores[BLACK][idx]; - - switch (idx) { - case MATERIAL: case IMBALANCE: case PAWN: case TOTAL: - ss << std::setw(15) << name << " | --- --- | --- --- | " - << std::setw(5) << to_cp(mg_value(wScore - bScore)) << " " - << std::setw(5) << to_cp(eg_value(wScore - bScore)) << " \n"; - break; - default: - ss << std::setw(15) << name << " | " << std::noshowpos - << std::setw(5) << to_cp(mg_value(wScore)) << " " - << std::setw(5) << to_cp(eg_value(wScore)) << " | " - << std::setw(5) << to_cp(mg_value(bScore)) << " " - << std::setw(5) << to_cp(eg_value(bScore)) << " | " - << std::setw(5) << to_cp(mg_value(wScore - bScore)) << " " - << std::setw(5) << to_cp(eg_value(wScore - bScore)) << " \n"; - } - } - - std::string Tracing::do_trace(const Position& pos) { - - std::memset(scores, 0, sizeof(scores)); - - Value v = do_evaluate(pos); - v = pos.side_to_move() == WHITE ? v : -v; // White's point of view - - std::stringstream ss; - ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2) - << " Eval term | White | Black | Total \n" - << " | MG EG | MG EG | MG EG \n" - << "----------------+-------------+-------------+-------------\n"; - - print(ss, "Material", MATERIAL); - print(ss, "Imbalance", IMBALANCE); - print(ss, "Pawns", PAWN); - print(ss, "Knights", KNIGHT); - print(ss, "Bishops", BISHOP); - print(ss, "Rooks", ROOK); - print(ss, "Queens", QUEEN); - print(ss, "Mobility", MOBILITY); - print(ss, "King safety", KING); - print(ss, "Threats", THREAT); - print(ss, "Passed pawns", PASSED); - print(ss, "Space", SPACE); - - ss << "----------------+-------------+-------------+-------------\n"; - print(ss, "Total", TOTAL); - - ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n"; - - return ss.str(); + return make_score( 0 , value ) ; } } // namespace -namespace Eval { +/// evaluate() is the main evaluation function. It returns a static evaluation +/// of the position always from the point of view of the side to move. - /// evaluate() is the main evaluation function. It returns a static evaluation - /// of the position always from the point of view of the side to move. +template +Value Eval::evaluate(const Position& pos) { - Value evaluate(const Position& pos) { - return do_evaluate(pos); + assert(!pos.checkers()); + + EvalInfo ei; + Score score, mobility[2] = { SCORE_ZERO, SCORE_ZERO }; + + // Initialize score by reading the incrementally updated scores included + // in the position object (material + piece square tables). + // Score is computed from the point of view of white. + score = pos.psq_score(); + + // Probe the material hash table + Material::Entry* me = Material::probe(pos); + score += me->imbalance(); + + // If we have a specialized evaluation function for the current material + // configuration, call it and return. + if (me->specialized_eval_exists()) + return me->evaluate(pos); + + // Probe the pawn hash table + ei.pi = Pawns::probe(pos); + score += ei.pi->pawns_score() * Weights[PawnStructure]; + + // Initialize attack and king safety bitboards + ei.attackedBy[WHITE][ALL_PIECES] = ei.attackedBy[BLACK][ALL_PIECES] = 0; + init_eval_info(pos, ei); + init_eval_info(pos, ei); + + // Pawns blocked or on ranks 2 and 3. Will be excluded from the mobility area + Bitboard blockedPawns[] = { + pos.pieces(WHITE, PAWN) & (shift_bb(pos.pieces()) | Rank2BB | Rank3BB), + pos.pieces(BLACK, PAWN) & (shift_bb(pos.pieces()) | Rank7BB | Rank6BB) + }; + + // Do not include in mobility squares protected by enemy pawns, or occupied + // by our blocked pawns or king. + Bitboard mobilityArea[] = { + ~(ei.attackedBy[BLACK][PAWN] | blockedPawns[WHITE] | pos.square(WHITE)), + ~(ei.attackedBy[WHITE][PAWN] | blockedPawns[BLACK] | pos.square(BLACK)) + }; + + // Evaluate pieces and mobility + score += evaluate_pieces(pos, ei, mobility, mobilityArea); + score += (mobility[WHITE] - mobility[BLACK]) * Weights[Mobility]; + + // Evaluate kings after all other pieces because we need complete attack + // information when computing the king safety evaluation. + score += evaluate_king(pos, ei) + - evaluate_king(pos, ei); + + // Evaluate tactical threats, we need full attack information including king + score += evaluate_threats(pos, ei) + - evaluate_threats(pos, ei); + + // Evaluate passed pawns, we need full attack information including king + score += evaluate_passed_pawns(pos, ei) + - evaluate_passed_pawns(pos, ei); + + // If both sides have only pawns, score for potential unstoppable pawns + if (!pos.non_pawn_material(WHITE) && !pos.non_pawn_material(BLACK)) + { + Bitboard b; + if ((b = ei.pi->passed_pawns(WHITE)) != 0) + score += int(relative_rank(WHITE, frontmost_sq(WHITE, b))) * Unstoppable; + + if ((b = ei.pi->passed_pawns(BLACK)) != 0) + score -= int(relative_rank(BLACK, frontmost_sq(BLACK, b))) * Unstoppable; } + // Evaluate space for both sides, only during opening + if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 12222) + score += (evaluate_space(pos, ei) - evaluate_space(pos, ei)) * Weights[Space]; + + // Evaluate initiative + score += evaluate_initiative(pos, ei, score); - /// trace() is like evaluate(), but instead of returning a value, it returns - /// a string (suitable for outputting to stdout) that contains the detailed - /// descriptions and values of each evaluation term. It's mainly used for - /// debugging. - std::string trace(const Position& pos) { - return Tracing::do_trace(pos); + // Scale winning side if position is more drawish than it appears + Color strongSide = eg_value(score) > VALUE_DRAW ? WHITE : BLACK; + ScaleFactor sf = me->scale_factor(pos, strongSide); + + // If we don't already have an unusual scale factor, check for certain + // types of endgames, and use a lower scale for those. + if ( me->game_phase() < PHASE_MIDGAME + && (sf == SCALE_FACTOR_NORMAL || sf == SCALE_FACTOR_ONEPAWN)) + { + if (pos.opposite_bishops()) + { + // Endgame with opposite-colored bishops and no other pieces (ignoring pawns) + // is almost a draw, in case of KBP vs KB is even more a draw. + if ( pos.non_pawn_material(WHITE) == BishopValueMg + && pos.non_pawn_material(BLACK) == BishopValueMg) + sf = more_than_one(pos.pieces(PAWN)) ? ScaleFactor(31) : ScaleFactor(9); + + // Endgame with opposite-colored bishops, but also other pieces. Still + // a bit drawish, but not as drawish as with only the two bishops. + else + sf = ScaleFactor(46 * sf / SCALE_FACTOR_NORMAL); + } + // Endings where weaker side can place his king in front of the opponent's + // pawns are drawish. + else if ( abs(eg_value(score)) <= BishopValueEg + && ei.pi->pawn_span(strongSide) <= 1 + && !pos.pawn_passed(~strongSide, pos.square(~strongSide))) + sf = ei.pi->pawn_span(strongSide) ? ScaleFactor(51) : ScaleFactor(37); } + // Interpolate between a middlegame and a (scaled by 'sf') endgame score + Value v = mg_value(score) * int(me->game_phase()) + + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL; - /// init() computes evaluation weights, usually at startup + v /= int(PHASE_MIDGAME); - void init() { - - const double MaxSlope = 7.5; - const double Peak = 1280; - double t = 0.0; - - for (int i = 1; i < 400; ++i) - { - t = std::min(Peak, std::min(0.025 * i * i, t + MaxSlope)); - KingDanger[i] = apply_weight(make_score(int(t), 0), Weights[KingSafety]); - } + // In case of tracing add all single evaluation terms + if (DoTrace) + { + Trace::add(MATERIAL, pos.psq_score()); + Trace::add(IMBALANCE, me->imbalance()); + Trace::add(PAWN, ei.pi->pawns_score()); + Trace::add(MOBILITY, mobility[WHITE] * Weights[Mobility] + , mobility[BLACK] * Weights[Mobility]); + Trace::add(SPACE, evaluate_space(pos, ei) * Weights[Space] + , evaluate_space(pos, ei) * Weights[Space]); + Trace::add(TOTAL, score); } -} // namespace Eval + return (pos.side_to_move() == WHITE ? v : -v) + Eval::Tempo; // Side to move point of view +} + +// Explicit template instantiations +template Value Eval::evaluate(const Position&); +template Value Eval::evaluate(const Position&); + + +/// trace() is like evaluate(), but instead of returning a value, it returns +/// a string (suitable for outputting to stdout) that contains the detailed +/// descriptions and values of each evaluation term. Useful for debugging. + +std::string Eval::trace(const Position& pos) { + + std::memset(scores, 0, sizeof(scores)); + + Value v = evaluate(pos); + v = pos.side_to_move() == WHITE ? v : -v; // White's point of view + + std::stringstream ss; + ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2) + << " Eval term | White | Black | Total \n" + << " | MG EG | MG EG | MG EG \n" + << "----------------+-------------+-------------+-------------\n" + << " Material | " << Term(MATERIAL) + << " Imbalance | " << Term(IMBALANCE) + << " Pawns | " << Term(PAWN) + << " Knights | " << Term(KNIGHT) + << " Bishop | " << Term(BISHOP) + << " Rooks | " << Term(ROOK) + << " Queens | " << Term(QUEEN) + << " Mobility | " << Term(MOBILITY) + << " King safety | " << Term(KING) + << " Threats | " << Term(THREAT) + << " Passed pawns | " << Term(PASSED) + << " Space | " << Term(SPACE) + << "----------------+-------------+-------------+-------------\n" + << " Total | " << Term(TOTAL); + + ss << "\nTotal Evaluation: " << to_cp(v) << " (white side)\n"; + + return ss.str(); +} + + +/// init() computes evaluation weights, usually at startup + +void Eval::init() { + + const int MaxSlope = 8700; + const int Peak = 1280000; + int t = 0; + + for (int i = 0; i < 400; ++i) + { + t = std::min(Peak, std::min(i * i * 27, t + MaxSlope)); + KingDanger[i] = make_score(t / 1000, 0) * Weights[KingSafety]; + } +} diff --git a/DroidFish/jni/stockfish/evaluate.h b/DroidFish/jni/stockfish/evaluate.h index d859582..28e9075 100644 --- a/DroidFish/jni/stockfish/evaluate.h +++ b/DroidFish/jni/stockfish/evaluate.h @@ -28,12 +28,13 @@ class Position; namespace Eval { -const Value Tempo = Value(17); // Must be visible to search +const Value Tempo = Value(20); // Must be visible to search void init(); -Value evaluate(const Position& pos); std::string trace(const Position& pos); +template +Value evaluate(const Position& pos); } #endif // #ifndef EVALUATE_H_INCLUDED diff --git a/DroidFish/jni/stockfish/main.cpp b/DroidFish/jni/stockfish/main.cpp index 8cdf9e6..56af993 100644 --- a/DroidFish/jni/stockfish/main.cpp +++ b/DroidFish/jni/stockfish/main.cpp @@ -33,6 +33,7 @@ int main(int argc, char* argv[]) { std::cout << engine_info() << std::endl; UCI::init(Options); + PSQT::init(); Bitboards::init(); Position::init(); Bitbases::init(); @@ -46,4 +47,5 @@ int main(int argc, char* argv[]) { UCI::loop(argc, argv); Threads.exit(); + return 0; } diff --git a/DroidFish/jni/stockfish/material.cpp b/DroidFish/jni/stockfish/material.cpp index 094a13d..bf0d060 100644 --- a/DroidFish/jni/stockfish/material.cpp +++ b/DroidFish/jni/stockfish/material.cpp @@ -31,28 +31,28 @@ namespace { // Polynomial material imbalance parameters // pair pawn knight bishop rook queen - const int Linear[6] = { 1852, -162, -1122, -183, 249, -154 }; + const int Linear[6] = { 1667, -168, -1027, -166, 238, -138 }; const int QuadraticOurs[][PIECE_TYPE_NB] = { // OUR PIECES // pair pawn knight bishop rook queen { 0 }, // Bishop pair - { 39, 2 }, // Pawn - { 35, 271, -4 }, // Knight OUR PIECES - { 0, 105, 4, 0 }, // Bishop - { -27, -2, 46, 100, -141 }, // Rook - {-177, 25, 129, 142, -137, 0 } // Queen + { 40, 2 }, // Pawn + { 32, 255, -3 }, // Knight OUR PIECES + { 0, 104, 4, 0 }, // Bishop + { -26, -2, 47, 105, -149 }, // Rook + {-185, 24, 122, 137, -134, 0 } // Queen }; const int QuadraticTheirs[][PIECE_TYPE_NB] = { // THEIR PIECES // pair pawn knight bishop rook queen { 0 }, // Bishop pair - { 37, 0 }, // Pawn - { 10, 62, 0 }, // Knight OUR PIECES - { 57, 64, 39, 0 }, // Bishop - { 50, 40, 23, -22, 0 }, // Rook - { 98, 105, -39, 141, 274, 0 } // Queen + { 36, 0 }, // Pawn + { 9, 63, 0 }, // Knight OUR PIECES + { 59, 65, 42, 0 }, // Bishop + { 46, 39, 24, -24, 0 }, // Rook + { 101, 100, -37, 141, 268, 0 } // Queen }; // Endgame evaluation and scaling functions are accessed directly and not through @@ -64,31 +64,28 @@ namespace { Endgame ScaleKPsK[] = { Endgame(WHITE), Endgame(BLACK) }; Endgame ScaleKPKP[] = { Endgame(WHITE), Endgame(BLACK) }; - // Helper templates used to detect a given material distribution - template bool is_KXK(const Position& pos) { - const Color Them = (Us == WHITE ? BLACK : WHITE); - return !more_than_one(pos.pieces(Them)) - && pos.non_pawn_material(Us) >= RookValueMg; + // Helper used to detect a given material distribution + bool is_KXK(const Position& pos, Color us) { + return !more_than_one(pos.pieces(~us)) + && pos.non_pawn_material(us) >= RookValueMg; } - template bool is_KBPsKs(const Position& pos) { - return pos.non_pawn_material(Us) == BishopValueMg - && pos.count(Us) == 1 - && pos.count(Us) >= 1; + bool is_KBPsKs(const Position& pos, Color us) { + return pos.non_pawn_material(us) == BishopValueMg + && pos.count(us) == 1 + && pos.count(us) >= 1; } - template bool is_KQKRPs(const Position& pos) { - const Color Them = (Us == WHITE ? BLACK : WHITE); - return !pos.count(Us) - && pos.non_pawn_material(Us) == QueenValueMg - && pos.count(Us) == 1 - && pos.count(Them) == 1 - && pos.count(Them) >= 1; + bool is_KQKRPs(const Position& pos, Color us) { + return !pos.count(us) + && pos.non_pawn_material(us) == QueenValueMg + && pos.count(us) == 1 + && pos.count(~us) == 1 + && pos.count(~us) >= 1; } /// imbalance() calculates the imbalance by comparing the piece count of each /// piece type for both colors. - template int imbalance(const int pieceCount[][PIECE_TYPE_NB]) { @@ -139,26 +136,21 @@ Entry* probe(const Position& pos) { // Let's look if we have a specialized evaluation function for this particular // material configuration. Firstly we look for a fixed configuration one, then // for a generic one if the previous search failed. - if (pos.this_thread()->endgames.probe(key, e->evaluationFunction)) + if ((e->evaluationFunction = pos.this_thread()->endgames.probe(key)) != nullptr) return e; - if (is_KXK(pos)) - { - e->evaluationFunction = &EvaluateKXK[WHITE]; - return e; - } - - if (is_KXK(pos)) - { - e->evaluationFunction = &EvaluateKXK[BLACK]; - return e; - } + for (Color c = WHITE; c <= BLACK; ++c) + if (is_KXK(pos, c)) + { + e->evaluationFunction = &EvaluateKXK[c]; + return e; + } // OK, we didn't find any special evaluation function for the current material // configuration. Is there a suitable specialized scaling function? EndgameBase* sf; - if (pos.this_thread()->endgames.probe(key, sf)) + if ((sf = pos.this_thread()->endgames.probe(key)) != nullptr) { e->scalingFunction[sf->strong_side()] = sf; // Only strong color assigned return e; @@ -167,17 +159,14 @@ Entry* probe(const Position& pos) { // We didn't find any specialized scaling function, so fall back on generic // ones that refer to more than one material distribution. Note that in this // case we don't return after setting the function. - if (is_KBPsKs(pos)) - e->scalingFunction[WHITE] = &ScaleKBPsK[WHITE]; + for (Color c = WHITE; c <= BLACK; ++c) + { + if (is_KBPsKs(pos, c)) + e->scalingFunction[c] = &ScaleKBPsK[c]; - if (is_KBPsKs(pos)) - e->scalingFunction[BLACK] = &ScaleKBPsK[BLACK]; - - if (is_KQKRPs(pos)) - e->scalingFunction[WHITE] = &ScaleKQKRPs[WHITE]; - - else if (is_KQKRPs(pos)) - e->scalingFunction[BLACK] = &ScaleKQKRPs[BLACK]; + else if (is_KQKRPs(pos, c)) + e->scalingFunction[c] = &ScaleKQKRPs[c]; + } Value npm_w = pos.non_pawn_material(WHITE); Value npm_b = pos.non_pawn_material(BLACK); @@ -210,11 +199,11 @@ Entry* probe(const Position& pos) { // drawish scale factor for cases such as KRKBP and KmmKm (except for KBBKN). if (!pos.count(WHITE) && npm_w - npm_b <= BishopValueMg) e->factor[WHITE] = uint8_t(npm_w < RookValueMg ? SCALE_FACTOR_DRAW : - npm_b <= BishopValueMg ? 4 : 12); + npm_b <= BishopValueMg ? 4 : 14); if (!pos.count(BLACK) && npm_b - npm_w <= BishopValueMg) e->factor[BLACK] = uint8_t(npm_b < RookValueMg ? SCALE_FACTOR_DRAW : - npm_w <= BishopValueMg ? 4 : 12); + npm_w <= BishopValueMg ? 4 : 14); if (pos.count(WHITE) == 1 && npm_w - npm_b <= BishopValueMg) e->factor[WHITE] = (uint8_t) SCALE_FACTOR_ONEPAWN; diff --git a/DroidFish/jni/stockfish/material.h b/DroidFish/jni/stockfish/material.h index 0119caa..67d555a 100644 --- a/DroidFish/jni/stockfish/material.h +++ b/DroidFish/jni/stockfish/material.h @@ -40,7 +40,7 @@ struct Entry { Score imbalance() const { return make_score(value, value); } Phase game_phase() const { return gamePhase; } - bool specialized_eval_exists() const { return evaluationFunction != NULL; } + bool specialized_eval_exists() const { return evaluationFunction != nullptr; } Value evaluate(const Position& pos) const { return (*evaluationFunction)(pos); } // scale_factor takes a position and a color as input and returns a scale factor diff --git a/DroidFish/jni/stockfish/misc.cpp b/DroidFish/jni/stockfish/misc.cpp index 59511db..30b0427 100644 --- a/DroidFish/jni/stockfish/misc.cpp +++ b/DroidFish/jni/stockfish/misc.cpp @@ -31,43 +31,39 @@ namespace { /// Version number. If Version is left empty, then compile date in the format /// DD-MM-YY and show in engine_info. -const string Version = "6"; - -/// Debug counters -int64_t hits[2], means[2]; +const string Version = "231015"; /// Our fancy logging facility. The trick here is to replace cin.rdbuf() and /// cout.rdbuf() with two Tie objects that tie cin and cout to a file stream. We /// can toggle the logging of std::cout and std:cin at runtime whilst preserving -/// usual i/o functionality, all without changing a single line of code! +/// usual I/O functionality, all without changing a single line of code! /// Idea from http://groups.google.com/group/comp.lang.c++/msg/1d941c0f26ea0d81 struct Tie: public streambuf { // MSVC requires splitted streambuf for cin and cout - Tie(streambuf* b, ofstream* f) : buf(b), file(f) {} + Tie(streambuf* b, streambuf* l) : buf(b), logBuf(l) {} - int sync() { return file->rdbuf()->pubsync(), buf->pubsync(); } + int sync() { return logBuf->pubsync(), buf->pubsync(); } int overflow(int c) { return log(buf->sputc((char)c), "<< "); } int underflow() { return buf->sgetc(); } int uflow() { return log(buf->sbumpc(), ">> "); } - streambuf* buf; - ofstream* file; + streambuf *buf, *logBuf; int log(int c, const char* prefix) { - static int last = '\n'; + static int last = '\n'; // Single log file if (last == '\n') - file->rdbuf()->sputn(prefix, 3); + logBuf->sputn(prefix, 3); - return last = file->rdbuf()->sputc((char)c); + return last = logBuf->sputc((char)c); } }; class Logger { - Logger() : in(cin.rdbuf(), &file), out(cout.rdbuf(), &file) {} + Logger() : in(cin.rdbuf(), file.rdbuf()), out(cout.rdbuf(), file.rdbuf()) {} ~Logger() { start(false); } ofstream file; @@ -80,7 +76,7 @@ public: if (b && !l.file.is_open()) { - l.file.open("io_log.txt", ifstream::out | ifstream::app); + l.file.open("io_log.txt", ifstream::out); cin.rdbuf(&l.in); cout.rdbuf(&l.out); } @@ -117,16 +113,17 @@ const string engine_info(bool to_uci) { ss << (Is64Bit ? " 64" : "") << (HasPext ? " BMI2" : (HasPopCnt ? " POPCNT" : "")) << (to_uci ? "\nid author ": " by ") - << "Tord Romstad, Marco Costalba and Joona Kiiski"; + << "T. Romstad, M. Costalba, J. Kiiski, G. Linscott"; return ss.str(); } /// Debug functions used mainly to collect run-time statistics +static int64_t hits[2], means[2]; void dbg_hit_on(bool b) { ++hits[0]; if (b) ++hits[1]; } -void dbg_hit_on_c(bool c, bool b) { if (c) dbg_hit_on(b); } +void dbg_hit_on(bool c, bool b) { if (c) dbg_hit_on(b); } void dbg_mean_of(int v) { ++means[0]; means[1] += v; } void dbg_print() { @@ -162,35 +159,16 @@ std::ostream& operator<<(std::ostream& os, SyncCout sc) { void start_logger(bool b) { Logger::start(b); } -/// timed_wait() waits for msec milliseconds. It is mainly a helper to wrap -/// the conversion from milliseconds to struct timespec, as used by pthreads. - -void timed_wait(WaitCondition& sleepCond, Lock& sleepLock, int msec) { - -#ifdef _WIN32 - int tm = msec; -#else - timespec ts, *tm = &ts; - uint64_t ms = Time::now() + msec; - - ts.tv_sec = ms / 1000; - ts.tv_nsec = (ms % 1000) * 1000000LL; -#endif - - cond_timedwait(sleepCond, sleepLock, tm); -} - - /// prefetch() preloads the given address in L1/L2 cache. This is a non-blocking /// function that doesn't stall the CPU waiting for data to be loaded from memory, /// which can be quite slow. #ifdef NO_PREFETCH -void prefetch(char*) {} +void prefetch(void*) {} #else -void prefetch(char* addr) { +void prefetch(void* addr) { # if defined(__INTEL_COMPILER) // This hack prevents prefetches from being optimized away by @@ -199,7 +177,7 @@ void prefetch(char* addr) { # endif # if defined(__INTEL_COMPILER) || defined(_MSC_VER) - _mm_prefetch(addr, _MM_HINT_T0); + _mm_prefetch((char*)addr, _MM_HINT_T0); # else __builtin_prefetch(addr); # endif diff --git a/DroidFish/jni/stockfish/misc.h b/DroidFish/jni/stockfish/misc.h index 965a0ee..203aec8 100644 --- a/DroidFish/jni/stockfish/misc.h +++ b/DroidFish/jni/stockfish/misc.h @@ -21,36 +21,36 @@ #define MISC_H_INCLUDED #include +#include #include #include #include +#include #include "types.h" const std::string engine_info(bool to_uci = false); -void timed_wait(WaitCondition&, Lock&, int); -void prefetch(char* addr); +void prefetch(void* addr); void start_logger(bool b); void dbg_hit_on(bool b); -void dbg_hit_on_c(bool c, bool b); +void dbg_hit_on(bool c, bool b); void dbg_mean_of(int v); void dbg_print(); +typedef std::chrono::milliseconds::rep TimePoint; // A value in milliseconds -namespace Time { - typedef int64_t point; - inline point now() { return system_time_to_msec(); } +inline TimePoint now() { + return std::chrono::duration_cast + (std::chrono::steady_clock::now().time_since_epoch()).count(); } - template struct HashTable { - HashTable() : table(Size, Entry()) {} Entry* operator[](Key key) { return &table[(uint32_t)key & (Size - 1)]; } private: - std::vector table; + std::vector table = std::vector(Size); }; @@ -97,4 +97,17 @@ public: { return T(rand64() & rand64() & rand64()); } }; +inline int stoi(const std::string& s) { + std::stringstream ss(s); + int result = 0; + ss >> result; + return result; +} + +inline std::string to_string(int v) { + char buf[32]; + sprintf(buf, "%d", v); + return buf; +} + #endif // #ifndef MISC_H_INCLUDED diff --git a/DroidFish/jni/stockfish/movegen.cpp b/DroidFish/jni/stockfish/movegen.cpp index bfc8858..274412f 100644 --- a/DroidFish/jni/stockfish/movegen.cpp +++ b/DroidFish/jni/stockfish/movegen.cpp @@ -34,7 +34,7 @@ namespace { // After castling, the rook and king final positions are the same in Chess960 // as they would be in standard chess. - Square kfrom = pos.king_square(us); + Square kfrom = pos.square(us); Square rfrom = pos.castling_rook_square(Cr); Square kto = relative_square(us, KingSide ? SQ_G1 : SQ_C1); Bitboard enemies = pos.pieces(~us); @@ -58,30 +58,31 @@ namespace { if (Checks && !pos.gives_check(m, *ci)) return moveList; + else + (void)ci; // Silence a warning under MSVC - (moveList++)->move = m; - + *moveList++ = m; return moveList; } template - inline ExtMove* make_promotions(ExtMove* moveList, Square to, const CheckInfo* ci) { + ExtMove* make_promotions(ExtMove* moveList, Square to, const CheckInfo* ci) { if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS) - (moveList++)->move = make(to - Delta, to, QUEEN); + *moveList++ = make(to - Delta, to, QUEEN); if (Type == QUIETS || Type == EVASIONS || Type == NON_EVASIONS) { - (moveList++)->move = make(to - Delta, to, ROOK); - (moveList++)->move = make(to - Delta, to, BISHOP); - (moveList++)->move = make(to - Delta, to, KNIGHT); + *moveList++ = make(to - Delta, to, ROOK); + *moveList++ = make(to - Delta, to, BISHOP); + *moveList++ = make(to - Delta, to, KNIGHT); } // Knight promotion is the only promotion that can give a direct check // that's not already included in the queen promotion. if (Type == QUIET_CHECKS && (StepAttacksBB[W_KNIGHT][to] & ci->ksq)) - (moveList++)->move = make(to - Delta, to, KNIGHT); + *moveList++ = make(to - Delta, to, KNIGHT); else (void)ci; // Silence a warning under MSVC @@ -147,13 +148,13 @@ namespace { while (b1) { Square to = pop_lsb(&b1); - (moveList++)->move = make_move(to - Up, to); + *moveList++ = make_move(to - Up, to); } while (b2) { Square to = pop_lsb(&b2); - (moveList++)->move = make_move(to - Up - Up, to); + *moveList++ = make_move(to - Up - Up, to); } } @@ -189,13 +190,13 @@ namespace { while (b1) { Square to = pop_lsb(&b1); - (moveList++)->move = make_move(to - Right, to); + *moveList++ = make_move(to - Right, to); } while (b2) { Square to = pop_lsb(&b2); - (moveList++)->move = make_move(to - Left, to); + *moveList++ = make_move(to - Left, to); } if (pos.ep_square() != SQ_NONE) @@ -213,7 +214,7 @@ namespace { assert(b1); while (b1) - (moveList++)->move = make(pop_lsb(&b1), pos.ep_square()); + *moveList++ = make(pop_lsb(&b1), pos.ep_square()); } } @@ -221,20 +222,20 @@ namespace { } - template FORCE_INLINE + template ExtMove* generate_moves(const Position& pos, ExtMove* moveList, Color us, Bitboard target, const CheckInfo* ci) { assert(Pt != KING && Pt != PAWN); - const Square* pl = pos.list(us); + const Square* pl = pos.squares(us); for (Square from = *pl; from != SQ_NONE; from = *++pl) { if (Checks) { if ( (Pt == BISHOP || Pt == ROOK || Pt == QUEEN) - && !(PseudoAttacks[Pt][from] & target & ci->checkSq[Pt])) + && !(PseudoAttacks[Pt][from] & target & ci->checkSquares[Pt])) continue; if (ci->dcCandidates && (ci->dcCandidates & from)) @@ -244,19 +245,19 @@ namespace { Bitboard b = pos.attacks_from(from) & target; if (Checks) - b &= ci->checkSq[Pt]; + b &= ci->checkSquares[Pt]; while (b) - (moveList++)->move = make_move(from, pop_lsb(&b)); + *moveList++ = make_move(from, pop_lsb(&b)); } return moveList; } - template FORCE_INLINE + template ExtMove* generate_all(const Position& pos, ExtMove* moveList, Bitboard target, - const CheckInfo* ci = NULL) { + const CheckInfo* ci = nullptr) { const bool Checks = Type == QUIET_CHECKS; @@ -268,10 +269,10 @@ namespace { if (Type != QUIET_CHECKS && Type != EVASIONS) { - Square ksq = pos.king_square(Us); + Square ksq = pos.square(Us); Bitboard b = pos.attacks_from(ksq) & target; while (b) - (moveList++)->move = make_move(ksq, pop_lsb(&b)); + *moveList++ = make_move(ksq, pop_lsb(&b)); } if (Type != CAPTURES && Type != EVASIONS && pos.can_castle(Us)) @@ -350,7 +351,7 @@ ExtMove* generate(const Position& pos, ExtMove* moveList) { b &= ~PseudoAttacks[QUEEN][ci.ksq]; while (b) - (moveList++)->move = make_move(from, pop_lsb(&b)); + *moveList++ = make_move(from, pop_lsb(&b)); } return us == WHITE ? generate_all(pos, moveList, ~pos.pieces(), &ci) @@ -366,7 +367,7 @@ ExtMove* generate(const Position& pos, ExtMove* moveList) { assert(pos.checkers()); Color us = pos.side_to_move(); - Square ksq = pos.king_square(us); + Square ksq = pos.square(us); Bitboard sliderAttacks = 0; Bitboard sliders = pos.checkers() & ~pos.pieces(KNIGHT, PAWN); @@ -382,7 +383,7 @@ ExtMove* generate(const Position& pos, ExtMove* moveList) { // Generate evasions for king, capture and non capture moves Bitboard b = pos.attacks_from(ksq) & ~pos.pieces(us) & ~sliderAttacks; while (b) - (moveList++)->move = make_move(ksq, pop_lsb(&b)); + *moveList++ = make_move(ksq, pop_lsb(&b)); if (more_than_one(pos.checkers())) return moveList; // Double check, only a king move can save the day @@ -402,15 +403,15 @@ template<> ExtMove* generate(const Position& pos, ExtMove* moveList) { Bitboard pinned = pos.pinned_pieces(pos.side_to_move()); - Square ksq = pos.king_square(pos.side_to_move()); + Square ksq = pos.square(pos.side_to_move()); ExtMove* cur = moveList; moveList = pos.checkers() ? generate(pos, moveList) : generate(pos, moveList); while (cur != moveList) - if ( (pinned || from_sq(cur->move) == ksq || type_of(cur->move) == ENPASSANT) - && !pos.legal(cur->move, pinned)) - cur->move = (--moveList)->move; + if ( (pinned || from_sq(*cur) == ksq || type_of(*cur) == ENPASSANT) + && !pos.legal(*cur, pinned)) + *cur = (--moveList)->move; else ++cur; diff --git a/DroidFish/jni/stockfish/movegen.h b/DroidFish/jni/stockfish/movegen.h index 62a121d..6a7f7e3 100644 --- a/DroidFish/jni/stockfish/movegen.h +++ b/DroidFish/jni/stockfish/movegen.h @@ -36,6 +36,9 @@ enum GenType { struct ExtMove { Move move; Value value; + + operator Move() const { return move; } + void operator=(Move m) { move = m; } }; inline bool operator<(const ExtMove& f, const ExtMove& s) { @@ -50,18 +53,17 @@ ExtMove* generate(const Position& pos, ExtMove* moveList); template struct MoveList { - explicit MoveList(const Position& pos) : cur(moveList), last(generate(pos, moveList)) { last->move = MOVE_NONE; } - void operator++() { ++cur; } - Move operator*() const { return cur->move; } + explicit MoveList(const Position& pos) : last(generate(pos, moveList)) {} + const ExtMove* begin() const { return moveList; } + const ExtMove* end() const { return last; } size_t size() const { return last - moveList; } - bool contains(Move m) const { - for (const ExtMove* it(moveList); it != last; ++it) if (it->move == m) return true; + bool contains(Move move) const { + for (const auto& m : *this) if (m == move) return true; return false; } private: - ExtMove moveList[MAX_MOVES]; - ExtMove *cur, *last; + ExtMove moveList[MAX_MOVES], *last; }; #endif // #ifndef MOVEGEN_H_INCLUDED diff --git a/DroidFish/jni/stockfish/movepick.cpp b/DroidFish/jni/stockfish/movepick.cpp index edee817..ed7c380 100644 --- a/DroidFish/jni/stockfish/movepick.cpp +++ b/DroidFish/jni/stockfish/movepick.cpp @@ -26,16 +26,16 @@ namespace { enum Stages { - MAIN_SEARCH, CAPTURES_S1, KILLERS_S1, QUIETS_1_S1, QUIETS_2_S1, BAD_CAPTURES_S1, - EVASION, EVASIONS_S2, - QSEARCH_0, CAPTURES_S3, QUIET_CHECKS_S3, - QSEARCH_1, CAPTURES_S4, - PROBCUT, CAPTURES_S5, - RECAPTURE, CAPTURES_S6, + MAIN_SEARCH, GOOD_CAPTURES, KILLERS, GOOD_QUIETS, BAD_QUIETS, BAD_CAPTURES, + EVASION, ALL_EVASIONS, + QSEARCH_WITH_CHECKS, QCAPTURES_1, CHECKS, + QSEARCH_WITHOUT_CHECKS, QCAPTURES_2, + PROBCUT, PROBCUT_CAPTURES, + RECAPTURE, RECAPTURES, STOP }; - // Our insertion sort, which is guaranteed (and also needed) to be stable + // Our insertion sort, which is guaranteed to be stable, as it should be void insertion_sort(ExtMove* begin, ExtMove* end) { ExtMove tmp, *p, *q; @@ -49,18 +49,15 @@ namespace { } } - // Unary predicate used by std::partition to split positive values from remaining - // ones so as to sort the two sets separately, with the second sort delayed. - inline bool has_positive_value(const ExtMove& move) { return move.value > VALUE_ZERO; } - - // Picks the best move in the range (begin, end) and moves it to the front. - // It's faster than sorting all the moves in advance when there are few - // moves e.g. possible captures. - inline ExtMove* pick_best(ExtMove* begin, ExtMove* end) + // pick_best() finds the best move in the range (begin, end) and moves it to + // the front. It's faster than sorting all the moves in advance when there + // are few moves e.g. the possible captures. + Move pick_best(ExtMove* begin, ExtMove* end) { std::swap(*begin, *std::max_element(begin, end)); - return begin; + return *begin; } + } // namespace @@ -71,28 +68,19 @@ namespace { /// ordering is at the current node. MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats& h, - Move* cm, Move* fm, Search::Stack* s) : pos(p), history(h), depth(d) { + const CounterMovesHistoryStats& cmh, Move cm, Search::Stack* s) + : pos(p), history(h), counterMovesHistory(cmh), ss(s), countermove(cm), depth(d) { assert(d > DEPTH_ZERO); - cur = end = moves; - endBadCaptures = moves + MAX_MOVES - 1; - countermoves = cm; - followupmoves = fm; - ss = s; - - if (pos.checkers()) - stage = EVASION; - - else - stage = MAIN_SEARCH; - - ttMove = (ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE); - end += (ttMove != MOVE_NONE); + stage = pos.checkers() ? EVASION : MAIN_SEARCH; + ttMove = ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE; + endMoves += (ttMove != MOVE_NONE); } MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats& h, - Square s) : pos(p), history(h), cur(moves), end(moves) { + const CounterMovesHistoryStats& cmh, Square s) + : pos(p), history(h), counterMovesHistory(cmh) { assert(d <= DEPTH_ZERO); @@ -100,10 +88,10 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats& stage = EVASION; else if (d > DEPTH_QS_NO_CHECKS) - stage = QSEARCH_0; + stage = QSEARCH_WITH_CHECKS; else if (d > DEPTH_QS_RECAPTURES) - stage = QSEARCH_1; + stage = QSEARCH_WITHOUT_CHECKS; else { @@ -112,94 +100,71 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const HistoryStats& ttm = MOVE_NONE; } - ttMove = (ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE); - end += (ttMove != MOVE_NONE); + ttMove = ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE; + endMoves += (ttMove != MOVE_NONE); } -MovePicker::MovePicker(const Position& p, Move ttm, const HistoryStats& h, PieceType pt) - : pos(p), history(h), cur(moves), end(moves) { +MovePicker::MovePicker(const Position& p, Move ttm, const HistoryStats& h, + const CounterMovesHistoryStats& cmh, Value th) + : pos(p), history(h), counterMovesHistory(cmh), threshold(th) { assert(!pos.checkers()); stage = PROBCUT; - // In ProbCut we generate only captures that are better than the parent's - // captured piece. - captureThreshold = PieceValue[MG][pt]; - ttMove = (ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE); + // In ProbCut we generate captures with SEE higher than the given threshold + ttMove = ttm + && pos.pseudo_legal(ttm) + && pos.capture(ttm) + && pos.see(ttm) > threshold ? ttm : MOVE_NONE; - if (ttMove && (!pos.capture(ttMove) || pos.see(ttMove) <= captureThreshold)) - ttMove = MOVE_NONE; - - end += (ttMove != MOVE_NONE); + endMoves += (ttMove != MOVE_NONE); } -/// score() assign a numerical value to each move in a move list. The moves with +/// score() assigns a numerical value to each move in a move list. The moves with /// highest values will be picked first. template<> void MovePicker::score() { - // Winning and equal captures in the main search are ordered by MVV/LVA. - // Suprisingly, this appears to perform slightly better than SEE based - // move ordering. The reason is probably that in a position with a winning - // capture, capturing a more valuable (but sufficiently defended) piece - // first usually doesn't hurt. The opponent will have to recapture, and - // the hanging piece will still be hanging (except in the unusual cases - // where it is possible to recapture with the hanging piece). Exchanging - // big pieces before capturing a hanging piece probably helps to reduce - // the subtree size. + // Winning and equal captures in the main search are ordered by MVV, preferring + // captures near our home rank. Suprisingly, this appears to perform slightly + // better than SEE based move ordering: exchanging big pieces before capturing + // a hanging piece probably helps to reduce the subtree size. // In main search we want to push captures with negative SEE values to the // badCaptures[] array, but instead of doing it now we delay until the move - // has been picked up in pick_move_from_list(). This way we save some SEE - // calls in case we get a cutoff. - Move m; - - for (ExtMove* it = moves; it != end; ++it) - { - m = it->move; - it->value = PieceValue[MG][pos.piece_on(to_sq(m))] - - Value(type_of(pos.moved_piece(m))); - - if (type_of(m) == ENPASSANT) - it->value += PieceValue[MG][PAWN]; - - else if (type_of(m) == PROMOTION) - it->value += PieceValue[MG][promotion_type(m)] - PieceValue[MG][PAWN]; - } + // has been picked up, saving some SEE calls in case we get a cutoff. + for (auto& m : *this) + m.value = PieceValue[MG][pos.piece_on(to_sq(m))] + - Value(200 * relative_rank(pos.side_to_move(), to_sq(m))); } template<> void MovePicker::score() { - Move m; + Square prevSq = to_sq((ss-1)->currentMove); + const HistoryStats& cmh = counterMovesHistory[pos.piece_on(prevSq)][prevSq]; - for (ExtMove* it = moves; it != end; ++it) - { - m = it->move; - it->value = history[pos.moved_piece(m)][to_sq(m)]; - } + for (auto& m : *this) + m.value = history[pos.moved_piece(m)][to_sq(m)] + + cmh[pos.moved_piece(m)][to_sq(m)]; } template<> void MovePicker::score() { - // Try good captures ordered by MVV/LVA, then non-captures if destination square - // is not under attack, ordered by history value, then bad-captures and quiet - // moves with a negative SEE. This last group is ordered by the SEE value. - Move m; + // Try winning and equal captures captures ordered by MVV/LVA, then non-captures + // ordered by history value, then bad-captures and quiet moves with a negative + // SEE ordered by SEE value. Value see; - for (ExtMove* it = moves; it != end; ++it) - { - m = it->move; + for (auto& m : *this) if ((see = pos.see_sign(m)) < VALUE_ZERO) - it->value = see - HistoryStats::Max; // At the bottom + m.value = see - HistoryStats::Max; // At the bottom else if (pos.capture(m)) - it->value = PieceValue[MG][pos.piece_on(to_sq(m))] - - Value(type_of(pos.moved_piece(m))) + HistoryStats::Max; + m.value = PieceValue[MG][pos.piece_on(to_sq(m))] + - Value(type_of(pos.moved_piece(m))) + HistoryStats::Max; else - it->value = history[pos.moved_piece(m)][to_sq(m)]; - } + m.value = history[pos.moved_piece(m)][to_sq(m)]; } @@ -208,79 +173,60 @@ void MovePicker::score() { void MovePicker::generate_next_stage() { + assert(stage != STOP); + cur = moves; switch (++stage) { - case CAPTURES_S1: case CAPTURES_S3: case CAPTURES_S4: case CAPTURES_S5: case CAPTURES_S6: - end = generate(pos, moves); + case GOOD_CAPTURES: case QCAPTURES_1: case QCAPTURES_2: + case PROBCUT_CAPTURES: case RECAPTURES: + endMoves = generate(pos, moves); score(); - return; + break; - case KILLERS_S1: + case KILLERS: + killers[0] = ss->killers[0]; + killers[1] = ss->killers[1]; + killers[2] = countermove; cur = killers; - end = cur + 2; + endMoves = cur + 2 + (countermove != killers[0] && countermove != killers[1]); + break; - killers[0].move = ss->killers[0]; - killers[1].move = ss->killers[1]; - killers[2].move = killers[3].move = MOVE_NONE; - killers[4].move = killers[5].move = MOVE_NONE; - - // Please note that following code is racy and could yield to rare (less - // than 1 out of a million) duplicated entries in SMP case. This is harmless. - - // Be sure countermoves are different from killers - for (int i = 0; i < 2; ++i) - if ( countermoves[i] != (cur+0)->move - && countermoves[i] != (cur+1)->move) - (end++)->move = countermoves[i]; - - // Be sure followupmoves are different from killers and countermoves - for (int i = 0; i < 2; ++i) - if ( followupmoves[i] != (cur+0)->move - && followupmoves[i] != (cur+1)->move - && followupmoves[i] != (cur+2)->move - && followupmoves[i] != (cur+3)->move) - (end++)->move = followupmoves[i]; - return; - - case QUIETS_1_S1: - endQuiets = end = generate(pos, moves); + case GOOD_QUIETS: + endQuiets = endMoves = generate(pos, moves); score(); - end = std::partition(cur, end, has_positive_value); - insertion_sort(cur, end); - return; + endMoves = std::partition(cur, endMoves, [](const ExtMove& m) { return m.value > VALUE_ZERO; }); + insertion_sort(cur, endMoves); + break; - case QUIETS_2_S1: - cur = end; - end = endQuiets; + case BAD_QUIETS: + cur = endMoves; + endMoves = endQuiets; if (depth >= 3 * ONE_PLY) - insertion_sort(cur, end); - return; + insertion_sort(cur, endMoves); + break; - case BAD_CAPTURES_S1: - // Just pick them in reverse order to get MVV/LVA ordering + case BAD_CAPTURES: + // Just pick them in reverse order to get correct ordering cur = moves + MAX_MOVES - 1; - end = endBadCaptures; - return; + endMoves = endBadCaptures; + break; - case EVASIONS_S2: - end = generate(pos, moves); - if (end > moves + 1) + case ALL_EVASIONS: + endMoves = generate(pos, moves); + if (endMoves - moves > 1) score(); - return; + break; - case QUIET_CHECKS_S3: - end = generate(pos, moves); - return; + case CHECKS: + endMoves = generate(pos, moves); + break; - case EVASION: case QSEARCH_0: case QSEARCH_1: case PROBCUT: case RECAPTURE: + case EVASION: case QSEARCH_WITH_CHECKS: case QSEARCH_WITHOUT_CHECKS: + case PROBCUT: case RECAPTURE: case STOP: stage = STOP; - /* Fall through */ - - case STOP: - end = cur + 1; // Avoid another next_phase() call - return; + break; default: assert(false); @@ -292,36 +238,37 @@ void MovePicker::generate_next_stage() { /// a new pseudo legal move every time it is called, until there are no more moves /// left. It picks the move with the biggest value from a list of generated moves /// taking care not to return the ttMove if it has already been searched. -template<> -Move MovePicker::next_move() { + +Move MovePicker::next_move() { Move move; while (true) { - while (cur == end) + while (cur == endMoves && stage != STOP) generate_next_stage(); switch (stage) { - case MAIN_SEARCH: case EVASION: case QSEARCH_0: case QSEARCH_1: case PROBCUT: + case MAIN_SEARCH: case EVASION: case QSEARCH_WITH_CHECKS: + case QSEARCH_WITHOUT_CHECKS: case PROBCUT: ++cur; return ttMove; - case CAPTURES_S1: - move = pick_best(cur++, end)->move; + case GOOD_CAPTURES: + move = pick_best(cur++, endMoves); if (move != ttMove) { if (pos.see_sign(move) >= VALUE_ZERO) return move; // Losing capture, move it to the tail of the array - (endBadCaptures--)->move = move; + *endBadCaptures-- = move; } break; - case KILLERS_S1: - move = (cur++)->move; + case KILLERS: + move = *cur++; if ( move != MOVE_NONE && move != ttMove && pos.pseudo_legal(move) @@ -329,41 +276,38 @@ Move MovePicker::next_move() { return move; break; - case QUIETS_1_S1: case QUIETS_2_S1: - move = (cur++)->move; + case GOOD_QUIETS: case BAD_QUIETS: + move = *cur++; if ( move != ttMove - && move != killers[0].move - && move != killers[1].move - && move != killers[2].move - && move != killers[3].move - && move != killers[4].move - && move != killers[5].move) + && move != killers[0] + && move != killers[1] + && move != killers[2]) return move; break; - case BAD_CAPTURES_S1: - return (cur--)->move; + case BAD_CAPTURES: + return *cur--; - case EVASIONS_S2: case CAPTURES_S3: case CAPTURES_S4: - move = pick_best(cur++, end)->move; + case ALL_EVASIONS: case QCAPTURES_1: case QCAPTURES_2: + move = pick_best(cur++, endMoves); if (move != ttMove) return move; break; - case CAPTURES_S5: - move = pick_best(cur++, end)->move; - if (move != ttMove && pos.see(move) > captureThreshold) + case PROBCUT_CAPTURES: + move = pick_best(cur++, endMoves); + if (move != ttMove && pos.see(move) > threshold) return move; break; - case CAPTURES_S6: - move = pick_best(cur++, end)->move; + case RECAPTURES: + move = pick_best(cur++, endMoves); if (to_sq(move) == recaptureSquare) return move; break; - case QUIET_CHECKS_S3: - move = (cur++)->move; + case CHECKS: + move = *cur++; if (move != ttMove) return move; break; @@ -376,10 +320,3 @@ Move MovePicker::next_move() { } } } - - -/// Version of next_move() to use at split point nodes where the move is grabbed -/// from the split point's shared MovePicker object. This function is not thread -/// safe so must be lock protected by the caller. -template<> -Move MovePicker::next_move() { return ss->splitPoint->movePicker->next_move(); } diff --git a/DroidFish/jni/stockfish/movepick.h b/DroidFish/jni/stockfish/movepick.h index a7b25a9..d3bca28 100644 --- a/DroidFish/jni/stockfish/movepick.h +++ b/DroidFish/jni/stockfish/movepick.h @@ -30,46 +30,50 @@ /// The Stats struct stores moves statistics. According to the template parameter -/// the class can store History, Gains and Countermoves. History records how often +/// the class can store History and Countermoves. History records how often /// different moves have been successful or unsuccessful during the current search -/// and is used for reduction and move ordering decisions. Gains records the move's -/// best evaluation gain from one ply to the next and is used for pruning decisions. +/// and is used for reduction and move ordering decisions. /// Countermoves store the move that refute a previous one. Entries are stored /// using only the moving piece and destination square, hence two moves with /// different origin but same destination and piece will be considered identical. -template +template struct Stats { - static const Value Max = Value(250); + static const Value Max = Value(1<<28); const T* operator[](Piece pc) const { return table[pc]; } + T* operator[](Piece pc) { return table[pc]; } void clear() { std::memset(table, 0, sizeof(table)); } void update(Piece pc, Square to, Move m) { - if (m == table[pc][to].first) - return; - - table[pc][to].second = table[pc][to].first; - table[pc][to].first = m; + if (m != table[pc][to]) + table[pc][to] = m; } - void update(Piece pc, Square to, Value v) { + void updateH(Piece pc, Square to, Value v) { - if (Gain) - table[pc][to] = std::max(v, table[pc][to] - 1); + if (abs(int(v)) >= 324) + return; + table[pc][to] -= table[pc][to] * abs(int(v)) / 324; + table[pc][to] += int(v) * 32; + } - else if (abs(table[pc][to] + v) < Max) - table[pc][to] += v; + void updateCMH(Piece pc, Square to, Value v) { + + if (abs(int(v)) >= 324) + return; + table[pc][to] -= table[pc][to] * abs(int(v)) / 512; + table[pc][to] += int(v) * 64; } private: T table[PIECE_NB][SQUARE_NB]; }; -typedef Stats< true, Value> GainsStats; -typedef Stats HistoryStats; -typedef Stats > MovesStats; +typedef Stats HistoryStats; +typedef Stats MovesStats; +typedef Stats CounterMovesHistoryStats; /// MovePicker class is used to pick one pseudo legal move at a time from the @@ -80,33 +84,35 @@ typedef Stats > MovesStats; /// to get a cut-off first. class MovePicker { - - MovePicker& operator=(const MovePicker&); // Silence a warning under MSVC - public: - MovePicker(const Position&, Move, Depth, const HistoryStats&, Square); - MovePicker(const Position&, Move, const HistoryStats&, PieceType); - MovePicker(const Position&, Move, Depth, const HistoryStats&, Move*, Move*, Search::Stack*); + MovePicker(const MovePicker&) = delete; + MovePicker& operator=(const MovePicker&) = delete; - template Move next_move(); + MovePicker(const Position&, Move, Depth, const HistoryStats&, const CounterMovesHistoryStats&, Square); + MovePicker(const Position&, Move, const HistoryStats&, const CounterMovesHistoryStats&, Value); + MovePicker(const Position&, Move, Depth, const HistoryStats&, const CounterMovesHistoryStats&, Move, Search::Stack*); + + Move next_move(); private: template void score(); void generate_next_stage(); + ExtMove* begin() { return moves; } + ExtMove* end() { return endMoves; } const Position& pos; const HistoryStats& history; + const CounterMovesHistoryStats& counterMovesHistory; Search::Stack* ss; - Move* countermoves; - Move* followupmoves; + Move countermove; Depth depth; Move ttMove; - ExtMove killers[6]; + ExtMove killers[3]; Square recaptureSquare; - Value captureThreshold; + Value threshold; int stage; - ExtMove *cur, *end, *endQuiets, *endBadCaptures; - ExtMove moves[MAX_MOVES]; + ExtMove *endQuiets, *endBadCaptures = moves + MAX_MOVES - 1; + ExtMove moves[MAX_MOVES], *cur = moves, *endMoves = moves; }; #endif // #ifndef MOVEPICK_H_INCLUDED diff --git a/DroidFish/jni/stockfish/pawns.cpp b/DroidFish/jni/stockfish/pawns.cpp index 336638e..e2fcfc7 100644 --- a/DroidFish/jni/stockfish/pawns.cpp +++ b/DroidFish/jni/stockfish/pawns.cpp @@ -43,15 +43,11 @@ namespace { { S(25, 30), S(36, 35), S(40, 35), S(40, 35), S(40, 35), S(40, 35), S(36, 35), S(25, 30) } }; - // Backward pawn penalty by opposed flag and file - const Score Backward[2][FILE_NB] = { - { S(30, 42), S(43, 46), S(49, 46), S(49, 46), - S(49, 46), S(49, 46), S(43, 46), S(30, 42) }, - { S(20, 28), S(29, 31), S(33, 31), S(33, 31), - S(33, 31), S(33, 31), S(29, 31), S(20, 28) } }; + // Backward pawn penalty by opposed flag + const Score Backward[2] = { S(67, 42), S(49, 24) }; - // Connected pawn bonus by opposed, phalanx flags and rank - Score Connected[2][2][RANK_NB]; + // Connected pawn bonus by opposed, phalanx, twice supported and rank + Score Connected[2][2][2][RANK_NB]; // Levers bonus by rank const Score Lever[RANK_NB] = { @@ -61,35 +57,43 @@ namespace { // Unsupported pawn penalty const Score UnsupportedPawnPenalty = S(20, 10); + // Center bind bonus: Two pawns controlling the same central square + const Bitboard CenterBindMask[COLOR_NB] = { + (FileDBB | FileEBB) & (Rank5BB | Rank6BB | Rank7BB), + (FileDBB | FileEBB) & (Rank4BB | Rank3BB | Rank2BB) + }; + + const Score CenterBind = S(16, 0); + // Weakness of our pawn shelter in front of the king by [distance from edge][rank] const Value ShelterWeakness[][RANK_NB] = { - { V(100), V(13), V(24), V(64), V(89), V( 93), V(104) }, - { V(110), V( 1), V(29), V(75), V(96), V(102), V(107) }, - { V(102), V( 0), V(39), V(74), V(88), V(101), V( 98) }, - { V( 88), V( 4), V(33), V(67), V(92), V( 94), V(107) } }; + { V( 97), V(21), V(26), V(51), V(87), V( 89), V( 99) }, + { V(120), V( 0), V(28), V(76), V(88), V(103), V(104) }, + { V(101), V( 7), V(54), V(78), V(77), V( 92), V(101) }, + { V( 80), V(11), V(44), V(68), V(87), V( 90), V(119) } }; // Danger of enemy pawns moving toward our king by [type][distance from edge][rank] const Value StormDanger[][4][RANK_NB] = { - { { V( 0), V( 63), V( 128), V(43), V(27) }, - { V( 0), V( 62), V( 131), V(44), V(26) }, - { V( 0), V( 59), V( 121), V(50), V(28) }, - { V( 0), V( 62), V( 127), V(54), V(28) } }, - { { V(24), V( 40), V( 93), V(42), V(22) }, - { V(24), V( 28), V( 101), V(38), V(20) }, - { V(24), V( 32), V( 95), V(36), V(23) }, - { V(27), V( 24), V( 99), V(36), V(24) } }, - { { V( 0), V( 0), V( 81), V(16), V( 6) }, - { V( 0), V( 0), V( 165), V(29), V( 9) }, - { V( 0), V( 0), V( 163), V(23), V(12) }, - { V( 0), V( 0), V( 161), V(28), V(13) } }, - { { V( 0), V(-296), V(-299), V(55), V(25) }, - { V( 0), V( 67), V( 131), V(46), V(21) }, - { V( 0), V( 65), V( 135), V(50), V(31) }, - { V( 0), V( 62), V( 128), V(51), V(24) } } }; + { { V( 0), V( 67), V( 134), V(38), V(32) }, + { V( 0), V( 57), V( 139), V(37), V(22) }, + { V( 0), V( 43), V( 115), V(43), V(27) }, + { V( 0), V( 68), V( 124), V(57), V(32) } }, + { { V(20), V( 43), V( 100), V(56), V(20) }, + { V(23), V( 20), V( 98), V(40), V(15) }, + { V(23), V( 39), V( 103), V(36), V(18) }, + { V(28), V( 19), V( 108), V(42), V(26) } }, + { { V( 0), V( 0), V( 75), V(14), V( 2) }, + { V( 0), V( 0), V( 150), V(30), V( 4) }, + { V( 0), V( 0), V( 160), V(22), V( 5) }, + { V( 0), V( 0), V( 166), V(24), V(13) } }, + { { V( 0), V(-283), V(-281), V(57), V(31) }, + { V( 0), V( 58), V( 141), V(39), V(18) }, + { V( 0), V( 65), V( 142), V(48), V(32) }, + { V( 0), V( 60), V( 126), V(51), V(19) } } }; // Max bonus for king safety. Corresponds to start position with all the pawns // in front of the king and no enemy pawn on the horizon. - const Value MaxSafetyBonus = V(257); + const Value MaxSafetyBonus = V(258); #undef S #undef V @@ -102,11 +106,11 @@ namespace { const Square Right = (Us == WHITE ? DELTA_NE : DELTA_SW); const Square Left = (Us == WHITE ? DELTA_NW : DELTA_SE); - Bitboard b, p, doubled, connected; + Bitboard b, neighbours, doubled, supported, phalanx; Square s; - bool passed, isolated, opposed, phalanx, backward, unsupported, lever; + bool passed, isolated, opposed, backward, lever, connected; Score score = SCORE_ZERO; - const Square* pl = pos.list(Us); + const Square* pl = pos.squares(Us); const Bitboard* pawnAttacksBB = StepAttacksBB[make_piece(Us, PAWN)]; Bitboard ourPawns = pos.pieces(Us , PAWN); @@ -129,31 +133,28 @@ namespace { // This file cannot be semi-open e->semiopenFiles[Us] &= ~(1 << f); - // Previous rank - p = rank_bb(s - pawn_push(Us)); - - // Flag the pawn as passed, isolated, doubled, - // unsupported or connected (but not the backward one). - connected = ourPawns & adjacent_files_bb(f) & (rank_bb(s) | p); - phalanx = connected & rank_bb(s); - unsupported = !(ourPawns & adjacent_files_bb(f) & p); - isolated = !(ourPawns & adjacent_files_bb(f)); + // Flag the pawn + neighbours = ourPawns & adjacent_files_bb(f); doubled = ourPawns & forward_bb(Us, s); opposed = theirPawns & forward_bb(Us, s); passed = !(theirPawns & passed_pawn_mask(Us, s)); lever = theirPawns & pawnAttacksBB[s]; + phalanx = neighbours & rank_bb(s); + supported = neighbours & rank_bb(s - Up); + connected = supported | phalanx; + isolated = !neighbours; // Test for backward pawn. - // If the pawn is passed, isolated, or connected it cannot be + // If the pawn is passed, isolated, lever or connected it cannot be // backward. If there are friendly pawns behind on adjacent files - // or if it can capture an enemy pawn it cannot be backward either. - if ( (passed | isolated | connected) + // or if it is sufficiently advanced, it cannot be backward either. + if ( (passed | isolated | lever | connected) || (ourPawns & pawn_attack_span(Them, s)) - || (pos.attacks_from(s, Us) & theirPawns)) + || (relative_rank(Us, s) >= RANK_5)) backward = false; else { - // We now know that there are no friendly pawns beside or behind this + // We now know there are no friendly pawns beside or behind this // pawn on adjacent files. We now check whether the pawn is // backward by looking in the forward direction on the adjacent // files, and picking the closest pawn there. @@ -177,18 +178,18 @@ namespace { if (isolated) score -= Isolated[opposed][f]; - if (unsupported && !isolated) + else if (backward) + score -= Backward[opposed]; + + else if (!supported) score -= UnsupportedPawnPenalty; + if (connected) + score += Connected[opposed][!!phalanx][more_than_one(supported)][relative_rank(Us, s)]; + if (doubled) score -= Doubled[f] / distance(s, frontmost_sq(Us, doubled)); - if (backward) - score -= Backward[opposed][f]; - - if (connected) - score += Connected[opposed][phalanx][relative_rank(Us, s)]; - if (lever) score += Lever[relative_rank(Us, s)]; } @@ -196,6 +197,10 @@ namespace { b = e->semiopenFiles[Us] ^ 0xFF; e->pawnSpan[Us] = b ? int(msb(b) - lsb(b)) : 0; + // Center binds: Two pawns controlling the same central square + b = shift_bb(ourPawns) & shift_bb(ourPawns) & CenterBindMask[Us]; + score += popcount(b) * CenterBind; + return score; } @@ -213,11 +218,13 @@ void init() for (int opposed = 0; opposed <= 1; ++opposed) for (int phalanx = 0; phalanx <= 1; ++phalanx) - for (Rank r = RANK_2; r < RANK_8; ++r) - { - int bonus = Seed[r] + (phalanx ? (Seed[r + 1] - Seed[r]) / 2 : 0); - Connected[opposed][phalanx][r] = make_score(bonus / 2, bonus >> opposed); - } + for (int apex = 0; apex <= 1; ++apex) + for (Rank r = RANK_2; r < RANK_8; ++r) + { + int v = (Seed[r] + (phalanx ? (Seed[r + 1] - Seed[r]) / 2 : 0)) >> opposed; + v += (apex ? v / 2 : 0); + Connected[opposed][phalanx][apex][r] = make_score(3 * v / 2, v); + } } @@ -236,6 +243,7 @@ Entry* probe(const Position& pos) { e->key = key; e->score = evaluate(pos, e) - evaluate(pos, e); + e->asymmetry = popcount( e->semiopenFiles[WHITE] ^ e->semiopenFiles[BLACK] ); return e; } @@ -284,14 +292,14 @@ Score Entry::do_king_safety(const Position& pos, Square ksq) { kingSquares[Us] = ksq; castlingRights[Us] = pos.can_castle(Us); - minKingPawnDistance[Us] = 0; + int minKingPawnDistance = 0; Bitboard pawns = pos.pieces(Us, PAWN); if (pawns) - while (!(DistanceRingBB[ksq][minKingPawnDistance[Us]++] & pawns)) {} + while (!(DistanceRingBB[ksq][minKingPawnDistance++] & pawns)) {} if (relative_rank(Us, ksq) > RANK_4) - return make_score(0, -16 * minKingPawnDistance[Us]); + return make_score(0, -16 * minKingPawnDistance); Value bonus = shelter_storm(pos, ksq); @@ -302,7 +310,7 @@ Score Entry::do_king_safety(const Position& pos, Square ksq) { if (pos.can_castle(MakeCastling::right)) bonus = std::max(bonus, shelter_storm(pos, relative_square(Us, SQ_C1))); - return make_score(bonus, -16 * minKingPawnDistance[Us]); + return make_score(bonus, -16 * minKingPawnDistance); } // Explicit template instantiation diff --git a/DroidFish/jni/stockfish/pawns.h b/DroidFish/jni/stockfish/pawns.h index df38d55..2b978ba 100644 --- a/DroidFish/jni/stockfish/pawns.h +++ b/DroidFish/jni/stockfish/pawns.h @@ -36,6 +36,7 @@ struct Entry { Bitboard pawn_attacks(Color c) const { return pawnAttacks[c]; } Bitboard passed_pawns(Color c) const { return passedPawns[c]; } int pawn_span(Color c) const { return pawnSpan[c]; } + int pawn_asymmetry() const { return asymmetry; } int semiopen_file(Color c, File f) const { return semiopenFiles[c] & (1 << f); @@ -67,11 +68,11 @@ struct Entry { Bitboard pawnAttacks[COLOR_NB]; Square kingSquares[COLOR_NB]; Score kingSafety[COLOR_NB]; - int minKingPawnDistance[COLOR_NB]; int castlingRights[COLOR_NB]; int semiopenFiles[COLOR_NB]; int pawnSpan[COLOR_NB]; int pawnsOnSquares[COLOR_NB][COLOR_NB]; // [color][light/dark squares] + int asymmetry; }; typedef HashTable Table; diff --git a/DroidFish/jni/stockfish/platform.h b/DroidFish/jni/stockfish/platform.h deleted file mode 100644 index 47c0b11..0000000 --- a/DroidFish/jni/stockfish/platform.h +++ /dev/null @@ -1,116 +0,0 @@ -/* - Stockfish, a UCI chess playing engine derived from Glaurung 2.1 - Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2015 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 - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - 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 . -*/ - -#ifndef PLATFORM_H_INCLUDED -#define PLATFORM_H_INCLUDED - -#ifdef _MSC_VER - -// Disable some silly and noisy warnings from MSVC compiler -#pragma warning(disable: 4127) // Conditional expression is constant -#pragma warning(disable: 4146) // Unary minus operator applied to unsigned type -#pragma warning(disable: 4800) // Forcing value to bool 'true' or 'false' -#pragma warning(disable: 4996) // Function _ftime() may be unsafe - -// MSVC does not support -typedef signed __int8 int8_t; -typedef unsigned __int8 uint8_t; -typedef signed __int16 int16_t; -typedef unsigned __int16 uint16_t; -typedef signed __int32 int32_t; -typedef unsigned __int32 uint32_t; -typedef signed __int64 int64_t; -typedef unsigned __int64 uint64_t; - -#else -# include -#endif - -#ifndef _WIN32 // Linux - Unix - -# include - -inline int64_t system_time_to_msec() { - timeval t; - gettimeofday(&t, NULL); - return t.tv_sec * 1000LL + t.tv_usec / 1000; -} - -# include -typedef pthread_mutex_t Lock; -typedef pthread_cond_t WaitCondition; -typedef pthread_t NativeHandle; -typedef void*(*pt_start_fn)(void*); - -# define lock_init(x) pthread_mutex_init(&(x), NULL) -# define lock_grab(x) pthread_mutex_lock(&(x)) -# define lock_release(x) pthread_mutex_unlock(&(x)) -# define lock_destroy(x) pthread_mutex_destroy(&(x)) -# define cond_destroy(x) pthread_cond_destroy(&(x)) -# define cond_init(x) pthread_cond_init(&(x), NULL) -# define cond_signal(x) pthread_cond_signal(&(x)) -# define cond_wait(x,y) pthread_cond_wait(&(x),&(y)) -# define cond_timedwait(x,y,z) pthread_cond_timedwait(&(x),&(y),z) -# define thread_create(x,f,t) pthread_create(&(x),NULL,(pt_start_fn)f,t) -# define thread_join(x) pthread_join(x, NULL) - -#else // Windows and MinGW - -# include - -inline int64_t system_time_to_msec() { - _timeb t; - _ftime(&t); - return t.time * 1000LL + t.millitm; -} - -#ifndef NOMINMAX -# define NOMINMAX // disable macros min() and max() -#endif - -#define WIN32_LEAN_AND_MEAN -#include -#undef WIN32_LEAN_AND_MEAN -#undef NOMINMAX - -// We use critical sections on Windows to support Windows XP and older versions. -// Unfortunately, cond_wait() is racy between lock_release() and WaitForSingleObject() -// but apart from this they have the same speed performance of SRW locks. -typedef CRITICAL_SECTION Lock; -typedef HANDLE WaitCondition; -typedef HANDLE NativeHandle; - -// On Windows 95 and 98 parameter lpThreadId may not be null -inline DWORD* dwWin9xKludge() { static DWORD dw; return &dw; } - -# define lock_init(x) InitializeCriticalSection(&(x)) -# define lock_grab(x) EnterCriticalSection(&(x)) -# define lock_release(x) LeaveCriticalSection(&(x)) -# define lock_destroy(x) DeleteCriticalSection(&(x)) -# define cond_init(x) { x = CreateEvent(0, FALSE, FALSE, 0); } -# define cond_destroy(x) CloseHandle(x) -# define cond_signal(x) SetEvent(x) -# define cond_wait(x,y) { lock_release(y); WaitForSingleObject(x, INFINITE); lock_grab(y); } -# define cond_timedwait(x,y,z) { lock_release(y); WaitForSingleObject(x,z); lock_grab(y); } -# define thread_create(x,f,t) (x = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)f,t,0,dwWin9xKludge())) -# define thread_join(x) { WaitForSingleObject(x, INFINITE); CloseHandle(x); } - -#endif - -#endif // #ifndef PLATFORM_H_INCLUDED diff --git a/DroidFish/jni/stockfish/position.cpp b/DroidFish/jni/stockfish/position.cpp index 994e1c7..c221c74 100644 --- a/DroidFish/jni/stockfish/position.cpp +++ b/DroidFish/jni/stockfish/position.cpp @@ -19,7 +19,7 @@ #include #include -#include // For std::memset +#include // For std::memset, std::memcmp #include #include @@ -27,7 +27,6 @@ #include "misc.h" #include "movegen.h" #include "position.h" -#include "psqtab.h" #include "thread.h" #include "tt.h" #include "uci.h" @@ -47,19 +46,18 @@ namespace Zobrist { Key exclusion; } -Key Position::exclusion_key() const { return st->key ^ Zobrist::exclusion;} +Key Position::exclusion_key() const { return st->key ^ Zobrist::exclusion; } namespace { const string PieceToChar(" PNBRQK pnbrqk"); -Score psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; // min_attacker() is a helper function used by see() to locate the least // valuable attacker for the side to move, remove the attacker we just found // from the bitboards and scan for new X-ray attacks behind it. -template FORCE_INLINE -PieceType min_attacker(const Bitboard* bb, const Square& to, const Bitboard& stmAttackers, +template +PieceType min_attacker(const Bitboard* bb, Square to, Bitboard stmAttackers, Bitboard& occupied, Bitboard& attackers) { Bitboard b = stmAttackers & bb[Pt]; @@ -78,8 +76,8 @@ PieceType min_attacker(const Bitboard* bb, const Square& to, const Bitboard& stm return (PieceType)Pt; } -template<> FORCE_INLINE -PieceType min_attacker(const Bitboard*, const Square&, const Bitboard&, Bitboard&, Bitboard&) { +template<> +PieceType min_attacker(const Bitboard*, Square, Bitboard, Bitboard&, Bitboard&) { return KING; // No need to update bitboards: it is the last cycle } @@ -91,17 +89,17 @@ PieceType min_attacker(const Bitboard*, const Square&, const Bitboard&, Bi CheckInfo::CheckInfo(const Position& pos) { Color them = ~pos.side_to_move(); - ksq = pos.king_square(them); + ksq = pos.square(them); pinned = pos.pinned_pieces(pos.side_to_move()); dcCandidates = pos.discovered_check_candidates(); - checkSq[PAWN] = pos.attacks_from(ksq, them); - checkSq[KNIGHT] = pos.attacks_from(ksq); - checkSq[BISHOP] = pos.attacks_from(ksq); - checkSq[ROOK] = pos.attacks_from(ksq); - checkSq[QUEEN] = checkSq[BISHOP] | checkSq[ROOK]; - checkSq[KING] = 0; + checkSquares[PAWN] = pos.attacks_from(ksq, them); + checkSquares[KNIGHT] = pos.attacks_from(ksq); + checkSquares[BISHOP] = pos.attacks_from(ksq); + checkSquares[ROOK] = pos.attacks_from(ksq); + checkSquares[QUEEN] = checkSquares[BISHOP] | checkSquares[ROOK]; + checkSquares[KING] = 0; } @@ -130,10 +128,7 @@ std::ostream& operator<<(std::ostream& os, const Position& pos) { /// Position::init() initializes at startup the various arrays used to compute -/// hash keys and the piece square tables. The latter is a two-step operation: -/// Firstly, the white halves of the tables are copied from PSQT[] tables. -/// Secondly, the black halves of the tables are initialized by flipping and -/// changing the sign of the white scores. +/// hash keys. void Position::init() { @@ -149,6 +144,7 @@ void Position::init() { for (int cr = NO_CASTLING; cr <= ANY_CASTLING; ++cr) { + Zobrist::castling[cr] = 0; Bitboard b = cr; while (b) { @@ -159,20 +155,6 @@ void Position::init() { Zobrist::side = rng.rand(); Zobrist::exclusion = rng.rand(); - - for (PieceType pt = PAWN; pt <= KING; ++pt) - { - PieceValue[MG][make_piece(BLACK, pt)] = PieceValue[MG][pt]; - PieceValue[EG][make_piece(BLACK, pt)] = PieceValue[EG][pt]; - - Score v = make_score(PieceValue[MG][pt], PieceValue[EG][pt]); - - for (Square s = SQ_A1; s <= SQ_H8; ++s) - { - psq[WHITE][pt][ s] = (v + PSQT[pt][s]); - psq[BLACK][pt][~s] = -(v + PSQT[pt][s]); - } - } } @@ -182,7 +164,7 @@ void Position::init() { Position& Position::operator=(const Position& pos) { std::memcpy(this, &pos, sizeof(Position)); - startState = *st; + std::memcpy(&startState, st, sizeof(StateInfo)); st = &startState; nodes = 0; @@ -265,7 +247,7 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { else if ((idx = PieceToChar.find(token)) != string::npos) { - put_piece(sq, color_of(Piece(idx)), type_of(Piece(idx))); + put_piece(color_of(Piece(idx)), type_of(Piece(idx)), sq); ++sq; } } @@ -284,14 +266,15 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { { Square rsq; Color c = islower(token) ? BLACK : WHITE; + Piece rook = make_piece(c, ROOK); token = char(toupper(token)); if (token == 'K') - for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; --rsq) {} + for (rsq = relative_square(c, SQ_H1); piece_on(rsq) != rook; --rsq) {} else if (token == 'Q') - for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; ++rsq) {} + for (rsq = relative_square(c, SQ_A1); piece_on(rsq) != rook; ++rsq) {} else if (token >= 'A' && token <= 'H') rsq = make_square(File(token - 'A'), relative_rank(c, RANK_1)); @@ -332,7 +315,7 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { void Position::set_castling_right(Color c, Square rfrom) { - Square kfrom = king_square(c); + Square kfrom = square(c); CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE; CastlingRight cr = (c | cs); @@ -365,23 +348,23 @@ void Position::set_state(StateInfo* si) const { si->nonPawnMaterial[WHITE] = si->nonPawnMaterial[BLACK] = VALUE_ZERO; si->psq = SCORE_ZERO; - si->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove); + si->checkersBB = attackers_to(square(sideToMove)) & pieces(~sideToMove); for (Bitboard b = pieces(); b; ) { Square s = pop_lsb(&b); Piece pc = piece_on(s); si->key ^= Zobrist::psq[color_of(pc)][type_of(pc)][s]; - si->psq += psq[color_of(pc)][type_of(pc)][s]; + si->psq += PSQT::psq[color_of(pc)][type_of(pc)][s]; } - if (ep_square() != SQ_NONE) - si->key ^= Zobrist::enpassant[file_of(ep_square())]; + if (si->epSquare != SQ_NONE) + si->key ^= Zobrist::enpassant[file_of(si->epSquare)]; if (sideToMove == BLACK) si->key ^= Zobrist::side; - si->key ^= Zobrist::castling[st->castlingRights]; + si->key ^= Zobrist::castling[si->castlingRights]; for (Bitboard b = pieces(PAWN); b; ) { @@ -473,7 +456,7 @@ Phase Position::game_phase() const { Bitboard Position::check_blockers(Color c, Color kingColor) const { Bitboard b, pinners, result = 0; - Square ksq = king_square(kingColor); + Square ksq = square(kingColor); // Pinners are sliders that give check when a pinned piece is removed pinners = ( (pieces( ROOK, QUEEN) & PseudoAttacks[ROOK ][ksq]) @@ -498,7 +481,7 @@ Bitboard Position::attackers_to(Square s, Bitboard occupied) const { return (attacks_from(s, BLACK) & pieces(WHITE, PAWN)) | (attacks_from(s, WHITE) & pieces(BLACK, PAWN)) | (attacks_from(s) & pieces(KNIGHT)) - | (attacks_bb(s, occupied) & pieces(ROOK, QUEEN)) + | (attacks_bb(s, occupied) & pieces(ROOK, QUEEN)) | (attacks_bb(s, occupied) & pieces(BISHOP, QUEEN)) | (attacks_from(s) & pieces(KING)); } @@ -515,14 +498,14 @@ bool Position::legal(Move m, Bitboard pinned) const { Square from = from_sq(m); assert(color_of(moved_piece(m)) == us); - assert(piece_on(king_square(us)) == make_piece(us, KING)); + assert(piece_on(square(us)) == make_piece(us, KING)); // En passant captures are a tricky special case. Because they are rather // uncommon, we do it simply by testing whether the king is attacked after // the move is made. if (type_of(m) == ENPASSANT) { - Square ksq = king_square(us); + Square ksq = square(us); Square to = to_sq(m); Square capsq = to - pawn_push(us); Bitboard occupied = (pieces() ^ from ^ capsq) | to; @@ -546,7 +529,7 @@ bool Position::legal(Move m, Bitboard pinned) const { // is moving along the ray towards or away from the king. return !pinned || !(pinned & from) - || aligned(from, to_sq(m), king_square(us)); + || aligned(from, to_sq(m), square(us)); } @@ -566,7 +549,7 @@ bool Position::pseudo_legal(const Move m) const { return MoveList(*this).contains(m); // Is not a promotion, so promotion piece must be empty - if (promotion_type(m) - 2 != NO_PIECE_TYPE) + if (promotion_type(m) - KNIGHT != NO_PIECE_TYPE) return false; // If the 'from' square is not occupied by a piece belonging to the side to @@ -587,9 +570,7 @@ bool Position::pseudo_legal(const Move m) const { return false; if ( !(attacks_from(from, us) & pieces(~us) & to) // Not a capture - && !((from + pawn_push(us) == to) && empty(to)) // Not a single push - && !( (from + 2 * pawn_push(us) == to) // Not a double push && (rank_of(from) == relative_rank(us, RANK_2)) && empty(to) @@ -611,7 +592,7 @@ bool Position::pseudo_legal(const Move m) const { return false; // Our move must be a blocking evasion or a capture of the checking piece - if (!((between_bb(lsb(checkers()), king_square(us)) | checkers()) & to)) + if (!((between_bb(lsb(checkers()), square(us)) | checkers()) & to)) return false; } // In case of king moves under check we have to remove king so as to catch @@ -634,10 +615,9 @@ bool Position::gives_check(Move m, const CheckInfo& ci) const { Square from = from_sq(m); Square to = to_sq(m); - PieceType pt = type_of(piece_on(from)); // Is there a direct check? - if (ci.checkSq[pt] & to) + if (ci.checkSquares[type_of(piece_on(from))] & to) return true; // Is there a discovered check? @@ -687,31 +667,21 @@ bool Position::gives_check(Move m, const CheckInfo& ci) const { /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal /// moves should be filtered out before this function is called. -void Position::do_move(Move m, StateInfo& newSt) { - - CheckInfo ci(*this); - do_move(m, newSt, ci, gives_check(m, ci)); -} - -void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveIsCheck) { +void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) { assert(is_ok(m)); assert(&newSt != st); ++nodes; - Key k = st->key; + Key k = st->key ^ Zobrist::side; // Copy some fields of the old state to our new StateInfo object except the // ones which are going to be recalculated from scratch anyway and then switch // our state pointer to point to the new (ready to be updated) state. - std::memcpy(&newSt, st, StateCopySize64 * sizeof(uint64_t)); - + std::memcpy(&newSt, st, offsetof(StateInfo, key)); newSt.previous = st; st = &newSt; - // Update side to move - k ^= Zobrist::side; - // Increment ply counters. In particular, rule50 will be reset to zero later on // in case of a capture or a pawn move. ++gamePly; @@ -722,23 +692,22 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI Color them = ~us; Square from = from_sq(m); Square to = to_sq(m); - Piece pc = piece_on(from); - PieceType pt = type_of(pc); + PieceType pt = type_of(piece_on(from)); PieceType captured = type_of(m) == ENPASSANT ? PAWN : type_of(piece_on(to)); - assert(color_of(pc) == us); - assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == them || type_of(m) == CASTLING); + assert(color_of(piece_on(from)) == us); + assert(piece_on(to) == NO_PIECE || color_of(piece_on(to)) == (type_of(m) != CASTLING ? them : us)); assert(captured != KING); if (type_of(m) == CASTLING) { - assert(pc == make_piece(us, KING)); + assert(pt == KING); Square rfrom, rto; - do_castling(from, to, rfrom, rto); + do_castling(us, from, to, rfrom, rto); captured = NO_PIECE_TYPE; - st->psq += psq[us][ROOK][rto] - psq[us][ROOK][rfrom]; + st->psq += PSQT::psq[us][ROOK][rto] - PSQT::psq[us][ROOK][rfrom]; k ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto]; } @@ -752,7 +721,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI { if (type_of(m) == ENPASSANT) { - capsq += pawn_push(them); + capsq -= pawn_push(us); assert(pt == PAWN); assert(to == st->epSquare); @@ -760,7 +729,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI assert(piece_on(to) == NO_PIECE); assert(piece_on(capsq) == make_piece(them, PAWN)); - board[capsq] = NO_PIECE; + board[capsq] = NO_PIECE; // Not done by remove_piece() } st->pawnKey ^= Zobrist::psq[them][PAWN][capsq]; @@ -769,15 +738,15 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI st->nonPawnMaterial[them] -= PieceValue[MG][captured]; // Update board and piece lists - remove_piece(capsq, them, captured); + remove_piece(them, captured, capsq); // Update material hash key and prefetch access to materialTable k ^= Zobrist::psq[them][captured][capsq]; st->materialKey ^= Zobrist::psq[them][captured][pieceCount[them][captured]]; - prefetch((char*)thisThread->materialTable[st->materialKey]); + prefetch(thisThread->materialTable[st->materialKey]); // Update incremental scores - st->psq -= psq[them][captured][capsq]; + st->psq -= PSQT::psq[them][captured][capsq]; // Reset rule 50 counter st->rule50 = 0; @@ -803,16 +772,16 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI // Move the piece. The tricky Chess960 castling is handled earlier if (type_of(m) != CASTLING) - move_piece(from, to, us, pt); + move_piece(us, pt, from, to); // If the moving piece is a pawn do some special extra work if (pt == PAWN) { // Set en-passant square if the moved pawn can be captured if ( (int(to) ^ int(from)) == 16 - && (attacks_from(from + pawn_push(us), us) & pieces(them, PAWN))) + && (attacks_from(to - pawn_push(us), us) & pieces(them, PAWN))) { - st->epSquare = Square((from + to) / 2); + st->epSquare = (from + to) / 2; k ^= Zobrist::enpassant[file_of(st->epSquare)]; } @@ -823,8 +792,8 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI assert(relative_rank(us, to) == RANK_8); assert(promotion >= KNIGHT && promotion <= QUEEN); - remove_piece(to, us, PAWN); - put_piece(to, us, promotion); + remove_piece(us, PAWN, to); + put_piece(us, promotion, to); // Update hash keys k ^= Zobrist::psq[us][PAWN][to] ^ Zobrist::psq[us][promotion][to]; @@ -833,7 +802,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI ^ Zobrist::psq[us][PAWN][pieceCount[us][PAWN]]; // Update incremental score - st->psq += psq[us][promotion][to] - psq[us][PAWN][to]; + st->psq += PSQT::psq[us][promotion][to] - PSQT::psq[us][PAWN][to]; // Update material st->nonPawnMaterial[us] += PieceValue[MG][promotion]; @@ -841,14 +810,14 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI // Update pawn hash key and prefetch access to pawnsTable st->pawnKey ^= Zobrist::psq[us][PAWN][from] ^ Zobrist::psq[us][PAWN][to]; - prefetch((char*)thisThread->pawnsTable[st->pawnKey]); + prefetch(thisThread->pawnsTable[st->pawnKey]); // Reset rule 50 draw counter st->rule50 = 0; } // Update incremental scores - st->psq += psq[us][pt][to] - psq[us][pt][from]; + st->psq += PSQT::psq[us][pt][to] - PSQT::psq[us][pt][from]; // Set capture piece st->capturedType = captured; @@ -856,30 +825,8 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI // Update the key with the final value st->key = k; - // Update checkers bitboard: piece must be already moved due to attacks_from() - st->checkersBB = 0; - - if (moveIsCheck) - { - if (type_of(m) != NORMAL) - st->checkersBB = attackers_to(king_square(them)) & pieces(us); - else - { - // Direct checks - if (ci.checkSq[pt] & to) - st->checkersBB |= to; - - // Discovered checks - if (ci.dcCandidates && (ci.dcCandidates & from)) - { - if (pt != ROOK) - st->checkersBB |= attacks_from(king_square(them)) & pieces(us, QUEEN, ROOK); - - if (pt != BISHOP) - st->checkersBB |= attacks_from(king_square(them)) & pieces(us, QUEEN, BISHOP); - } - } - } + // Calculate checkers bitboard (if move gives check) + st->checkersBB = givesCheck ? attackers_to(square(them)) & pieces(us) : 0; sideToMove = ~sideToMove; @@ -906,23 +853,23 @@ void Position::undo_move(Move m) { if (type_of(m) == PROMOTION) { - assert(pt == promotion_type(m)); assert(relative_rank(us, to) == RANK_8); - assert(promotion_type(m) >= KNIGHT && promotion_type(m) <= QUEEN); + assert(pt == promotion_type(m)); + assert(pt >= KNIGHT && pt <= QUEEN); - remove_piece(to, us, promotion_type(m)); - put_piece(to, us, PAWN); + remove_piece(us, pt, to); + put_piece(us, PAWN, to); pt = PAWN; } if (type_of(m) == CASTLING) { Square rfrom, rto; - do_castling(from, to, rfrom, rto); + do_castling(us, from, to, rfrom, rto); } else { - move_piece(to, from, us, pt); // Put the piece back at the source square + move_piece(us, pt, to, from); // Put the piece back at the source square if (st->capturedType) { @@ -936,9 +883,10 @@ void Position::undo_move(Move m) { assert(to == st->previous->epSquare); assert(relative_rank(us, to) == RANK_6); assert(piece_on(capsq) == NO_PIECE); + assert(st->capturedType == PAWN); } - put_piece(capsq, ~us, st->capturedType); // Restore the captured piece + put_piece(~us, st->capturedType, capsq); // Restore the captured piece } } @@ -953,19 +901,19 @@ void Position::undo_move(Move m) { /// Position::do_castling() is a helper used to do/undo a castling move. This /// is a bit tricky, especially in Chess960. template -void Position::do_castling(Square from, Square& to, Square& rfrom, Square& rto) { +void Position::do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto) { bool kingSide = to > from; rfrom = to; // Castling is encoded as "king captures friendly rook" - rto = relative_square(sideToMove, kingSide ? SQ_F1 : SQ_D1); - to = relative_square(sideToMove, kingSide ? SQ_G1 : SQ_C1); + rto = relative_square(us, kingSide ? SQ_F1 : SQ_D1); + to = relative_square(us, kingSide ? SQ_G1 : SQ_C1); // Remove both pieces first since squares could overlap in Chess960 - remove_piece(Do ? from : to, sideToMove, KING); - remove_piece(Do ? rfrom : rto, sideToMove, ROOK); + remove_piece(us, KING, Do ? from : to); + remove_piece(us, ROOK, Do ? rfrom : rto); board[Do ? from : to] = board[Do ? rfrom : rto] = NO_PIECE; // Since remove_piece doesn't do it for us - put_piece(Do ? to : from, sideToMove, KING); - put_piece(Do ? rto : rfrom, sideToMove, ROOK); + put_piece(us, KING, Do ? to : from); + put_piece(us, ROOK, Do ? rto : rfrom); } @@ -975,9 +923,9 @@ void Position::do_castling(Square from, Square& to, Square& rfrom, Square& rto) void Position::do_null_move(StateInfo& newSt) { assert(!checkers()); + assert(&newSt != st); - std::memcpy(&newSt, st, sizeof(StateInfo)); // Fully copy here - + std::memcpy(&newSt, st, sizeof(StateInfo)); newSt.previous = st; st = &newSt; @@ -988,7 +936,7 @@ void Position::do_null_move(StateInfo& newSt) { } st->key ^= Zobrist::side; - prefetch((char*)TT.first_entry(st->key)); + prefetch(TT.first_entry(st->key)); ++st->rule50; st->pliesFromNull = 0; @@ -1060,8 +1008,8 @@ Value Position::see(Move m) const { stm = color_of(piece_on(from)); occupied = pieces() ^ from; - // Castling moves are implemented as king capturing the rook so cannot be - // handled correctly. Simply return 0 that is always the correct value + // Castling moves are implemented as king capturing the rook so cannot + // be handled correctly. Simply return VALUE_ZERO that is always correct // unless in the rare case the rook ends up under attack. if (type_of(m) == CASTLING) return VALUE_ZERO; @@ -1098,21 +1046,11 @@ Value Position::see(Move m) const { // Locate and remove the next least valuable attacker captured = min_attacker(byTypeBB, to, stmAttackers, occupied, attackers); - - // Stop before processing a king capture - if (captured == KING) - { - if (stmAttackers == attackers) - ++slIndex; - - break; - } - stm = ~stm; stmAttackers = attackers & pieces(stm); ++slIndex; - } while (stmAttackers); + } while (stmAttackers && (captured != KING || (--slIndex, false))); // Stop before a king capture // Having built the swap list, we negamax through it to find the best // achievable score from the point of view of the side to move. @@ -1123,8 +1061,8 @@ Value Position::see(Move m) const { } -/// Position::is_draw() tests whether the position is drawn by material, 50 moves -/// rule or repetition. It does not detect stalemates. +/// Position::is_draw() tests whether the position is drawn by 50-move rule +/// or by repetition. It does not detect stalemates. bool Position::is_draw() const { @@ -1147,10 +1085,6 @@ bool Position::is_draw() const { /// Position::flip() flips position with the white and black sides reversed. This /// is only useful for debugging e.g. for finding evaluation symmetry bugs. -static char toggle_case(char c) { - return char(islower(c) ? toupper(c) : tolower(c)); -} - void Position::flip() { string f, token; @@ -1168,7 +1102,8 @@ void Position::flip() { ss >> token; // Castling availability f += token + " "; - std::transform(f.begin(), f.end(), f.begin(), toggle_case); + std::transform(f.begin(), f.end(), f.begin(), + [](char c) { return char(islower(c) ? toupper(c) : tolower(c)); }); ss >> token; // En passant square f += (token == "-" ? token : token.replace(1, 1, token[1] == '3' ? "6" : "3")); @@ -1185,96 +1120,77 @@ void Position::flip() { /// Position::pos_is_ok() performs some consistency checks for the position object. /// This is meant to be helpful when debugging. -bool Position::pos_is_ok(int* step) const { +bool Position::pos_is_ok(int* failedStep) const { - // Which parts of the position should be verified? - const bool all = false; + const bool Fast = true; // Quick (default) or full check? - const bool testBitboards = all || false; - const bool testState = all || false; - const bool testKingCount = all || false; - const bool testKingCapture = all || false; - const bool testPieceCounts = all || false; - const bool testPieceList = all || false; - const bool testCastlingSquares = all || false; + enum { Default, King, Bitboards, State, Lists, Castling }; - if (step) - *step = 1; - - if ( (sideToMove != WHITE && sideToMove != BLACK) - || piece_on(king_square(WHITE)) != W_KING - || piece_on(king_square(BLACK)) != B_KING - || ( ep_square() != SQ_NONE - && relative_rank(sideToMove, ep_square()) != RANK_6)) - return false; - - if (step && ++*step, testBitboards) + for (int step = Default; step <= (Fast ? Default : Castling); step++) { - // The intersection of the white and black pieces must be empty - if (pieces(WHITE) & pieces(BLACK)) - return false; + if (failedStep) + *failedStep = step; - // The union of the white and black pieces must be equal to all - // occupied squares - if ((pieces(WHITE) | pieces(BLACK)) != pieces()) - return false; + if (step == Default) + if ( (sideToMove != WHITE && sideToMove != BLACK) + || piece_on(square(WHITE)) != W_KING + || piece_on(square(BLACK)) != B_KING + || ( ep_square() != SQ_NONE + && relative_rank(sideToMove, ep_square()) != RANK_6)) + return false; - // Separate piece type bitboards must have empty intersections - for (PieceType p1 = PAWN; p1 <= KING; ++p1) - for (PieceType p2 = PAWN; p2 <= KING; ++p2) - if (p1 != p2 && (pieces(p1) & pieces(p2))) - return false; - } + if (step == King) + if ( std::count(board, board + SQUARE_NB, W_KING) != 1 + || std::count(board, board + SQUARE_NB, B_KING) != 1 + || attackers_to(square(~sideToMove)) & pieces(sideToMove)) + return false; - if (step && ++*step, testState) - { - StateInfo si; - set_state(&si); - if ( st->key != si.key - || st->pawnKey != si.pawnKey - || st->materialKey != si.materialKey - || st->nonPawnMaterial[WHITE] != si.nonPawnMaterial[WHITE] - || st->nonPawnMaterial[BLACK] != si.nonPawnMaterial[BLACK] - || st->psq != si.psq - || st->checkersBB != si.checkersBB) - return false; - } + if (step == Bitboards) + { + if ( (pieces(WHITE) & pieces(BLACK)) + ||(pieces(WHITE) | pieces(BLACK)) != pieces()) + return false; - if (step && ++*step, testKingCount) - if ( std::count(board, board + SQUARE_NB, W_KING) != 1 - || std::count(board, board + SQUARE_NB, B_KING) != 1) - return false; + for (PieceType p1 = PAWN; p1 <= KING; ++p1) + for (PieceType p2 = PAWN; p2 <= KING; ++p2) + if (p1 != p2 && (pieces(p1) & pieces(p2))) + return false; + } - if (step && ++*step, testKingCapture) - if (attackers_to(king_square(~sideToMove)) & pieces(sideToMove)) - return false; + if (step == State) + { + StateInfo si = *st; + set_state(&si); + if (std::memcmp(&si, st, sizeof(StateInfo))) + return false; + } - if (step && ++*step, testPieceCounts) - for (Color c = WHITE; c <= BLACK; ++c) - for (PieceType pt = PAWN; pt <= KING; ++pt) - if (pieceCount[c][pt] != popcount(pieces(c, pt))) - return false; - - if (step && ++*step, testPieceList) - for (Color c = WHITE; c <= BLACK; ++c) - for (PieceType pt = PAWN; pt <= KING; ++pt) - for (int i = 0; i < pieceCount[c][pt]; ++i) - if ( board[pieceList[c][pt][i]] != make_piece(c, pt) - || index[pieceList[c][pt][i]] != i) + if (step == Lists) + for (Color c = WHITE; c <= BLACK; ++c) + for (PieceType pt = PAWN; pt <= KING; ++pt) + { + if (pieceCount[c][pt] != popcount(pieces(c, pt))) return false; - if (step && ++*step, testCastlingSquares) - for (Color c = WHITE; c <= BLACK; ++c) - for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1)) - { - if (!can_castle(c | s)) - continue; + for (int i = 0; i < pieceCount[c][pt]; ++i) + if ( board[pieceList[c][pt][i]] != make_piece(c, pt) + || index[pieceList[c][pt][i]] != i) + return false; + } - if ( (castlingRightsMask[king_square(c)] & (c | s)) != (c | s) - || piece_on(castlingRookSquare[c | s]) != make_piece(c, ROOK) - || castlingRightsMask[castlingRookSquare[c | s]] != (c | s)) - return false; - } + if (step == Castling) + for (Color c = WHITE; c <= BLACK; ++c) + for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1)) + { + if (!can_castle(c | s)) + continue; + + if ( piece_on(castlingRookSquare[c | s]) != make_piece(c, ROOK) + || castlingRightsMask[castlingRookSquare[c | s]] != (c | s) + ||(castlingRightsMask[square(c)] & (c | s)) != (c | s)) + return false; + } + } return true; } diff --git a/DroidFish/jni/stockfish/position.h b/DroidFish/jni/stockfish/position.h index 447872a..0b2a0cc 100644 --- a/DroidFish/jni/stockfish/position.h +++ b/DroidFish/jni/stockfish/position.h @@ -30,6 +30,13 @@ class Position; struct Thread; +namespace PSQT { + + extern Score psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; + + void init(); +} + /// CheckInfo struct is initialized at c'tor time and keeps info used to detect /// if a move gives check. @@ -39,7 +46,7 @@ struct CheckInfo { Bitboard dcCandidates; Bitboard pinned; - Bitboard checkSq[PIECE_TYPE_NB]; + Bitboard checkSquares[PIECE_TYPE_NB]; Square ksq; }; @@ -68,11 +75,6 @@ struct StateInfo { }; -/// When making a move the current StateInfo up to 'key' excluded is copied to -/// the new one. Here we calculate the quad words (64 bit) needed to be copied. -const size_t StateCopySize64 = offsetof(StateInfo, key) / sizeof(uint64_t) + 1; - - /// Position class stores information regarding the board representation as /// pieces, side to move, hash keys, castling info, etc. Important methods are /// do_move() and undo_move(), used by the search to update node info when @@ -82,12 +84,11 @@ class Position { friend std::ostream& operator<<(std::ostream&, const Position&); - Position(const Position&); // Disable the default copy constructor - public: static void init(); - Position() {} // To define the global object RootPos + Position() = default; // To define the global object RootPos + Position(const Position&) = delete; Position(const Position& pos, Thread* th) { *this = pos; thisThread = th; } Position(const std::string& f, bool c960, Thread* th) { set(f, c960, th); } Position& operator=(const Position&); // To assign RootPos from UCI @@ -104,11 +105,11 @@ public: Bitboard pieces(Color c, PieceType pt) const; Bitboard pieces(Color c, PieceType pt1, PieceType pt2) const; Piece piece_on(Square s) const; - Square king_square(Color c) const; Square ep_square() const; bool empty(Square s) const; template int count(Color c) const; - template const Square* list(Color c) const; + template const Square* squares(Color c) const; + template Square square(Color c) const; // Castling int can_castle(Color c) const; @@ -140,12 +141,10 @@ public: // Piece specific bool pawn_passed(Color c, Square s) const; - bool pawn_on_7th(Color c) const; bool opposite_bishops() const; // Doing and undoing moves - void do_move(Move m, StateInfo& st); - void do_move(Move m, StateInfo& st, const CheckInfo& ci, bool moveIsCheck); + void do_move(Move m, StateInfo& st, bool givesCheck); void undo_move(Move m); void do_null_move(StateInfo& st); void undo_null_move(); @@ -175,7 +174,7 @@ public: Value non_pawn_material(Color c) const; // Position consistency check, for debugging - bool pos_is_ok(int* step = NULL) const; + bool pos_is_ok(int* failedStep = nullptr) const; void flip(); private: @@ -186,11 +185,11 @@ private: // Other helpers Bitboard check_blockers(Color c, Color kingColor) const; - void put_piece(Square s, Color c, PieceType pt); - void remove_piece(Square s, Color c, PieceType pt); - void move_piece(Square from, Square to, Color c, PieceType pt); + void put_piece(Color c, PieceType pt, Square s); + void remove_piece(Color c, PieceType pt, Square s); + void move_piece(Color c, PieceType pt, Square from, Square to); template - void do_castling(Square from, Square& to, Square& rfrom, Square& rto); + void do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto); // Data members Piece board[SQUARE_NB]; @@ -255,12 +254,13 @@ template inline int Position::count(Color c) const { return pieceCount[c][Pt]; } -template inline const Square* Position::list(Color c) const { +template inline const Square* Position::squares(Color c) const { return pieceList[c][Pt]; } -inline Square Position::king_square(Color c) const { - return pieceList[c][KING][0]; +template inline Square Position::square(Color c) const { + assert(pieceCount[c][Pt] == 1); + return pieceList[c][Pt][0]; } inline Square Position::ep_square() const { @@ -363,11 +363,7 @@ inline void Position::set_nodes_searched(uint64_t n) { inline bool Position::opposite_bishops() const { return pieceCount[WHITE][BISHOP] == 1 && pieceCount[BLACK][BISHOP] == 1 - && opposite_colors(pieceList[WHITE][BISHOP][0], pieceList[BLACK][BISHOP][0]); -} - -inline bool Position::pawn_on_7th(Color c) const { - return pieces(c, PAWN) & rank_bb(relative_rank(c, RANK_7)); + && opposite_colors(square(WHITE), square(BLACK)); } inline bool Position::is_chess960() const { @@ -395,7 +391,7 @@ inline Thread* Position::this_thread() const { return thisThread; } -inline void Position::put_piece(Square s, Color c, PieceType pt) { +inline void Position::put_piece(Color c, PieceType pt, Square s) { board[s] = make_piece(c, pt); byTypeBB[ALL_PIECES] |= s; @@ -406,21 +402,7 @@ inline void Position::put_piece(Square s, Color c, PieceType pt) { pieceCount[c][ALL_PIECES]++; } -inline void Position::move_piece(Square from, Square to, Color c, PieceType pt) { - - // index[from] is not updated and becomes stale. This works as long as index[] - // is accessed just by known occupied squares. - Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to]; - byTypeBB[ALL_PIECES] ^= from_to_bb; - byTypeBB[pt] ^= from_to_bb; - byColorBB[c] ^= from_to_bb; - board[from] = NO_PIECE; - board[to] = make_piece(c, pt); - index[to] = index[from]; - pieceList[c][pt][index[to]] = to; -} - -inline void Position::remove_piece(Square s, Color c, PieceType pt) { +inline void Position::remove_piece(Color c, PieceType pt, Square s) { // WARNING: This is not a reversible operation. If we remove a piece in // do_move() and then replace it in undo_move() we will put it at the end of @@ -437,4 +419,18 @@ inline void Position::remove_piece(Square s, Color c, PieceType pt) { pieceCount[c][ALL_PIECES]--; } +inline void Position::move_piece(Color c, PieceType pt, Square from, Square to) { + + // index[from] is not updated and becomes stale. This works as long as index[] + // is accessed just by known occupied squares. + Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to]; + byTypeBB[ALL_PIECES] ^= from_to_bb; + byTypeBB[pt] ^= from_to_bb; + byColorBB[c] ^= from_to_bb; + board[from] = NO_PIECE; + board[to] = make_piece(c, pt); + index[to] = index[from]; + pieceList[c][pt][index[to]] = to; +} + #endif // #ifndef POSITION_H_INCLUDED diff --git a/DroidFish/jni/stockfish/psqt.cpp b/DroidFish/jni/stockfish/psqt.cpp new file mode 100644 index 0000000..2fd7d1c --- /dev/null +++ b/DroidFish/jni/stockfish/psqt.cpp @@ -0,0 +1,118 @@ +/* + Stockfish, a UCI chess playing engine derived from Glaurung 2.1 + Copyright (C) 2004-2008 Tord Romstad (Glaurung author) + Copyright (C) 2008-2015 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 + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + 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 . +*/ + +#include "types.h" + +namespace PSQT { + +#define S(mg, eg) make_score(mg, eg) + +// Bonus[PieceType][Square / 2] contains Piece-Square scores. For each piece +// type on a given square a (middlegame, endgame) score pair is assigned. Table +// is defined for files A..D and white side: it is symmetric for black side and +// second half of the files. +const Score Bonus[][RANK_NB][int(FILE_NB) / 2] = { + { }, + { // Pawn + { S( 0, 0), S( 0, 0), S( 0, 0), S( 0, 0) }, + { S(-19, 5), S( 1,-4), S( 7, 8), S( 3,-2) }, + { S(-26,-6), S( -7,-5), S( 19, 5), S(24, 4) }, + { S(-25, 1), S(-14, 3), S( 16,-8), S(31,-3) }, + { S(-14, 6), S( 0, 9), S( -1, 7), S(17,-6) }, + { S(-14, 6), S(-13,-5), S(-10, 2), S(-6, 4) }, + { S(-12, 1), S( 15,-9), S( -8, 1), S(-4,18) }, + { S( 0, 0), S( 0, 0), S( 0, 0), S( 0, 0) } + }, + { // Knight + { S(-143, -97), S(-96,-82), S(-80,-46), S(-73,-14) }, + { S( -83, -69), S(-43,-55), S(-21,-17), S(-10, 9) }, + { S( -71, -50), S(-22,-39), S( 0, -8), S( 9, 28) }, + { S( -25, -41), S( 18,-25), S( 43, 7), S( 47, 38) }, + { S( -26, -46), S( 16,-25), S( 38, 2), S( 50, 41) }, + { S( -11, -55), S( 37,-38), S( 56, -8), S( 71, 27) }, + { S( -62, -64), S(-17,-50), S( 5,-24), S( 14, 13) }, + { S(-195,-110), S(-66,-90), S(-42,-50), S(-29,-13) } + }, + { // Bishop + { S(-54,-68), S(-23,-40), S(-35,-46), S(-44,-28) }, + { S(-30,-43), S( 10,-17), S( 2,-23), S( -9, -5) }, + { S(-19,-32), S( 17, -9), S( 11,-13), S( 1, 8) }, + { S(-21,-36), S( 18,-13), S( 11,-15), S( 0, 7) }, + { S(-21,-36), S( 14,-14), S( 6,-17), S( -1, 3) }, + { S(-27,-35), S( 6,-13), S( 2,-10), S( -8, 1) }, + { S(-33,-44), S( 7,-21), S( -4,-22), S(-12, -4) }, + { S(-45,-65), S(-21,-42), S(-29,-46), S(-39,-27) } + }, + { // Rook + { S(-25, 0), S(-16, 0), S(-16, 0), S(-9, 0) }, + { S(-21, 0), S( -8, 0), S( -3, 0), S( 0, 0) }, + { S(-21, 0), S( -9, 0), S( -4, 0), S( 2, 0) }, + { S(-22, 0), S( -6, 0), S( -1, 0), S( 2, 0) }, + { S(-22, 0), S( -7, 0), S( 0, 0), S( 1, 0) }, + { S(-21, 0), S( -7, 0), S( 0, 0), S( 2, 0) }, + { S(-12, 0), S( 4, 0), S( 8, 0), S(12, 0) }, + { S(-23, 0), S(-15, 0), S(-11, 0), S(-5, 0) } + }, + { // Queen + { S( 0,-70), S(-3,-57), S(-4,-41), S(-1,-29) }, + { S(-4,-58), S( 6,-30), S( 9,-21), S( 8, -4) }, + { S(-2,-39), S( 6,-17), S( 9, -7), S( 9, 5) }, + { S(-1,-29), S( 8, -5), S(10, 9), S( 7, 17) }, + { S(-3,-27), S( 9, -5), S( 8, 10), S( 7, 23) }, + { S(-2,-40), S( 6,-16), S( 8,-11), S(10, 3) }, + { S(-2,-54), S( 7,-30), S( 7,-21), S( 6, -7) }, + { S(-1,-75), S(-4,-54), S(-1,-44), S( 0,-30) } + }, + { // King + { S(291, 28), S(344, 76), S(294,103), S(219,112) }, + { S(289, 70), S(329,119), S(263,170), S(205,159) }, + { S(226,109), S(271,164), S(202,195), S(136,191) }, + { S(204,131), S(212,194), S(175,194), S(137,204) }, + { S(177,132), S(205,187), S(143,224), S( 94,227) }, + { S(147,118), S(188,178), S(113,199), S( 70,197) }, + { S(116, 72), S(158,121), S( 93,142), S( 48,161) }, + { S( 94, 30), S(120, 76), S( 78,101), S( 31,111) } + } +}; + +#undef S + +Score psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; + +// init() initializes piece square tables: the white halves of the tables are +// copied from Bonus[] adding the piece value, then the black halves of the +// tables are initialized by flipping and changing the sign of the white scores. +void init() { + + for (PieceType pt = PAWN; pt <= KING; ++pt) + { + PieceValue[MG][make_piece(BLACK, pt)] = PieceValue[MG][pt]; + PieceValue[EG][make_piece(BLACK, pt)] = PieceValue[EG][pt]; + + Score v = make_score(PieceValue[MG][pt], PieceValue[EG][pt]); + + for (Square s = SQ_A1; s <= SQ_H8; ++s) + { + int edgeDistance = file_of(s) < FILE_E ? file_of(s) : FILE_H - file_of(s); + psq[BLACK][pt][~s] = -(psq[WHITE][pt][s] = v + Bonus[pt][rank_of(s)][edgeDistance]); + } + } +} + +} // namespace PSQT diff --git a/DroidFish/jni/stockfish/psqtab.h b/DroidFish/jni/stockfish/psqtab.h deleted file mode 100644 index 351ae19..0000000 --- a/DroidFish/jni/stockfish/psqtab.h +++ /dev/null @@ -1,98 +0,0 @@ -/* - Stockfish, a UCI chess playing engine derived from Glaurung 2.1 - Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2015 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 - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - 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 . -*/ - -#ifndef PSQTAB_H_INCLUDED -#define PSQTAB_H_INCLUDED - -#include "types.h" - -#define S(mg, eg) make_score(mg, eg) - - -/// PSQT[PieceType][Square] contains Piece-Square scores. For each piece type on -/// a given square a (middlegame, endgame) score pair is assigned. PSQT is defined -/// for the white side and the tables are symmetric for the black side. - -static const Score PSQT[][SQUARE_NB] = { - { }, - { // Pawn - S( 0, 0), S( 0, 0), S( 0, 0), S( 0, 0), S(0, 0), S( 0, 0), S( 0, 0), S( 0, 0), - S(-20, 0), S( 0, 0), S( 0, 0), S( 0, 0), S(0, 0), S( 0, 0), S( 0, 0), S(-20, 0), - S(-20, 0), S( 0, 0), S(10, 0), S(20, 0), S(20, 0), S(10, 0), S( 0, 0), S(-20, 0), - S(-20, 0), S( 0, 0), S(20, 0), S(40, 0), S(40, 0), S(20, 0), S( 0, 0), S(-20, 0), - S(-20, 0), S( 0, 0), S(10, 0), S(20, 0), S(20, 0), S(10, 0), S( 0, 0), S(-20, 0), - S(-20, 0), S( 0, 0), S( 0, 0), S( 0, 0), S(0, 0), S( 0, 0), S( 0, 0), S(-20, 0), - S(-20, 0), S( 0, 0), S( 0, 0), S( 0, 0), S(0, 0), S( 0, 0), S( 0, 0), S(-20, 0), - S( 0, 0), S( 0, 0), S( 0, 0), S( 0, 0), S(0, 0), S( 0, 0), S( 0, 0), S( 0, 0) - }, - { // Knight - S(-144,-98), S(-109,-83), S(-85,-51), S(-73,-16), S(-73,-16), S(-85,-51), S(-109,-83), S(-144,-98), - S( -88,-68), S( -43,-53), S(-19,-21), S( -7, 14), S( -7, 14), S(-19,-21), S( -43,-53), S( -88,-68), - S( -69,-53), S( -24,-38), S( 0, -6), S( 12, 29), S( 12, 29), S( 0, -6), S( -24,-38), S( -69,-53), - S( -28,-42), S( 17,-27), S( 41, 5), S( 53, 40), S( 53, 40), S( 41, 5), S( 17,-27), S( -28,-42), - S( -30,-42), S( 15,-27), S( 39, 5), S( 51, 40), S( 51, 40), S( 39, 5), S( 15,-27), S( -30,-42), - S( -10,-53), S( 35,-38), S( 59, -6), S( 71, 29), S( 71, 29), S( 59, -6), S( 35,-38), S( -10,-53), - S( -64,-68), S( -19,-53), S( 5,-21), S( 17, 14), S( 17, 14), S( 5,-21), S( -19,-53), S( -64,-68), - S(-200,-98), S( -65,-83), S(-41,-51), S(-29,-16), S(-29,-16), S(-41,-51), S( -65,-83), S(-200,-98) - }, - { // Bishop - S(-54,-65), S(-27,-42), S(-34,-44), S(-43,-26), S(-43,-26), S(-34,-44), S(-27,-42), S(-54,-65), - S(-29,-43), S( 8,-20), S( 1,-22), S( -8, -4), S( -8, -4), S( 1,-22), S( 8,-20), S(-29,-43), - S(-20,-33), S( 17,-10), S( 10,-12), S( 1, 6), S( 1, 6), S( 10,-12), S( 17,-10), S(-20,-33), - S(-19,-35), S( 18,-12), S( 11,-14), S( 2, 4), S( 2, 4), S( 11,-14), S( 18,-12), S(-19,-35), - S(-22,-35), S( 15,-12), S( 8,-14), S( -1, 4), S( -1, 4), S( 8,-14), S( 15,-12), S(-22,-35), - S(-28,-33), S( 9,-10), S( 2,-12), S( -7, 6), S( -7, 6), S( 2,-12), S( 9,-10), S(-28,-33), - S(-32,-43), S( 5,-20), S( -2,-22), S(-11, -4), S(-11, -4), S( -2,-22), S( 5,-20), S(-32,-43), - S(-49,-65), S(-22,-42), S(-29,-44), S(-38,-26), S(-38,-26), S(-29,-44), S(-22,-42), S(-49,-65) - }, - { // Rook - S(-22, 3), S(-17, 3), S(-12, 3), S(-8, 3), S(-8, 3), S(-12, 3), S(-17, 3), S(-22, 3), - S(-22, 3), S( -7, 3), S( -2, 3), S( 2, 3), S( 2, 3), S( -2, 3), S( -7, 3), S(-22, 3), - S(-22, 3), S( -7, 3), S( -2, 3), S( 2, 3), S( 2, 3), S( -2, 3), S( -7, 3), S(-22, 3), - S(-22, 3), S( -7, 3), S( -2, 3), S( 2, 3), S( 2, 3), S( -2, 3), S( -7, 3), S(-22, 3), - S(-22, 3), S( -7, 3), S( -2, 3), S( 2, 3), S( 2, 3), S( -2, 3), S( -7, 3), S(-22, 3), - S(-22, 3), S( -7, 3), S( -2, 3), S( 2, 3), S( 2, 3), S( -2, 3), S( -7, 3), S(-22, 3), - S(-11, 3), S( 4, 3), S( 9, 3), S(13, 3), S(13, 3), S( 9, 3), S( 4, 3), S(-11, 3), - S(-22, 3), S(-17, 3), S(-12, 3), S(-8, 3), S(-8, 3), S(-12, 3), S(-17, 3), S(-22, 3) - }, - { // Queen - S(-2,-80), S(-2,-54), S(-2,-42), S(-2,-30), S(-2,-30), S(-2,-42), S(-2,-54), S(-2,-80), - S(-2,-54), S( 8,-30), S( 8,-18), S( 8, -6), S( 8, -6), S( 8,-18), S( 8,-30), S(-2,-54), - S(-2,-42), S( 8,-18), S( 8, -6), S( 8, 6), S( 8, 6), S( 8, -6), S( 8,-18), S(-2,-42), - S(-2,-30), S( 8, -6), S( 8, 6), S( 8, 18), S( 8, 18), S( 8, 6), S( 8, -6), S(-2,-30), - S(-2,-30), S( 8, -6), S( 8, 6), S( 8, 18), S( 8, 18), S( 8, 6), S( 8, -6), S(-2,-30), - S(-2,-42), S( 8,-18), S( 8, -6), S( 8, 6), S( 8, 6), S( 8, -6), S( 8,-18), S(-2,-42), - S(-2,-54), S( 8,-30), S( 8,-18), S( 8, -6), S( 8, -6), S( 8,-18), S( 8,-30), S(-2,-54), - S(-2,-80), S(-2,-54), S(-2,-42), S(-2,-30), S(-2,-30), S(-2,-42), S(-2,-54), S(-2,-80) - }, - { // King - S(298, 27), S(332, 81), S(273,108), S(225,116), S(225,116), S(273,108), S(332, 81), S(298, 27), - S(287, 74), S(321,128), S(262,155), S(214,163), S(214,163), S(262,155), S(321,128), S(287, 74), - S(224,111), S(258,165), S(199,192), S(151,200), S(151,200), S(199,192), S(258,165), S(224,111), - S(196,135), S(230,189), S(171,216), S(123,224), S(123,224), S(171,216), S(230,189), S(196,135), - S(173,135), S(207,189), S(148,216), S(100,224), S(100,224), S(148,216), S(207,189), S(173,135), - S(146,111), S(180,165), S(121,192), S( 73,200), S( 73,200), S(121,192), S(180,165), S(146,111), - S(119, 74), S(153,128), S( 94,155), S( 46,163), S( 46,163), S( 94,155), S(153,128), S(119, 74), - S( 98, 27), S(132, 81), S( 73,108), S( 25,116), S( 25,116), S( 73,108), S(132, 81), S( 98, 27) - } -}; - -#undef S - -#endif // #ifndef PSQTAB_H_INCLUDED diff --git a/DroidFish/jni/stockfish/search.cpp b/DroidFish/jni/stockfish/search.cpp index 0ce836f..33ab6b5 100644 --- a/DroidFish/jni/stockfish/search.cpp +++ b/DroidFish/jni/stockfish/search.cpp @@ -39,9 +39,6 @@ namespace Search { volatile SignalsType Signals; LimitsType Limits; - RootMoveVector RootMoves; - Position RootPos; - Time::point SearchTime; StateStackPtr SetupStates; } @@ -66,62 +63,84 @@ namespace { // Different node types, used as template parameter enum NodeType { Root, PV, NonPV }; - // Dynamic razoring margin based on depth - inline Value razor_margin(Depth d) { return Value(512 + 32 * d); } + // Razoring and futility margin based on depth + int razor_margin[4] = {483, 570, 603, 554}; + Value futility_margin(Depth d) { return Value(200 * d); } - // Futility lookup tables (initialized at startup) and their access functions - int FutilityMoveCounts[2][16]; // [improving][depth] + // Futility and reductions lookup tables, initialized at startup + int FutilityMoveCounts[2][16]; // [improving][depth] + Depth Reductions[2][2][64][64]; // [pv][improving][depth][moveNumber] - inline Value futility_margin(Depth d) { - return Value(200 * d); + template Depth reduction(bool i, Depth d, int mn) { + return Reductions[PvNode][i][std::min(d, 63 * ONE_PLY)][std::min(mn, 63)]; } - // Reduction lookup tables (initialized at startup) and their access function - int8_t Reductions[2][2][64][64]; // [pv][improving][depth][moveNumber] + // Skill struct is used to implement strength limiting + struct Skill { + Skill(int l) : level(l) {} + bool enabled() const { return level < 20; } + bool time_to_pick(Depth depth) const { return depth / ONE_PLY == 1 + level; } + Move best_move(size_t multiPV) { return best ? best : pick_best(multiPV); } + Move pick_best(size_t multiPV); - template inline Depth reduction(bool i, Depth d, int mn) { - return (Depth) Reductions[PvNode][i][std::min(int(d), 63)][std::min(mn, 63)]; - } + int level; + Move best = MOVE_NONE; + }; - size_t PVIdx; - TimeManager TimeMgr; + // EasyMoveManager struct is used to detect a so called 'easy move'; when PV is + // stable across multiple search iterations we can fast return the best move. + struct EasyMoveManager { + + void clear() { + stableCnt = 0; + expectedPosKey = 0; + pv[0] = pv[1] = pv[2] = MOVE_NONE; + } + + Move get(Key key) const { + return expectedPosKey == key ? pv[2] : MOVE_NONE; + } + + void update(Position& pos, const std::vector& newPv) { + + assert(newPv.size() >= 3); + + // Keep track of how many times in a row 3rd ply remains stable + stableCnt = (newPv[2] == pv[2]) ? stableCnt + 1 : 0; + + if (!std::equal(newPv.begin(), newPv.begin() + 3, pv)) + { + std::copy(newPv.begin(), newPv.begin() + 3, pv); + + StateInfo st[2]; + pos.do_move(newPv[0], st[0], pos.gives_check(newPv[0], CheckInfo(pos))); + pos.do_move(newPv[1], st[1], pos.gives_check(newPv[1], CheckInfo(pos))); + expectedPosKey = pos.key(); + pos.undo_move(newPv[1]); + pos.undo_move(newPv[0]); + } + } + + int stableCnt; + Key expectedPosKey; + Move pv[3]; + }; + + EasyMoveManager EasyMove; double BestMoveChanges; Value DrawValue[COLOR_NB]; - HistoryStats History; - GainsStats Gains; - MovesStats Countermoves, Followupmoves; + CounterMovesHistoryStats CounterMovesHistory; - template + template Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth, bool cutNode); template Value qsearch(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth); - void id_loop(Position& pos); Value value_to_tt(Value v, int ply); Value value_from_tt(Value v, int ply); void update_pv(Move* pv, Move move, Move* childPv); void update_stats(const Position& pos, Stack* ss, Move move, Depth depth, Move* quiets, int quietsCnt); - string uci_pv(const Position& pos, Depth depth, Value alpha, Value beta); - - struct Skill { - Skill(int l, size_t rootSize) : level(l), - candidates(l < 20 ? std::min(4, (int)rootSize) : 0), - best(MOVE_NONE) {} - ~Skill() { - if (candidates) // Swap best PV line with the sub-optimal one - std::swap(RootMoves[0], *std::find(RootMoves.begin(), - RootMoves.end(), best ? best : pick_move())); - } - - size_t candidates_size() const { return candidates; } - bool time_to_pick(Depth depth) const { return depth / ONE_PLY == 1 + level; } - Move pick_move(); - - int level; - size_t candidates; - Move best; - }; } // namespace @@ -130,25 +149,23 @@ namespace { void Search::init() { - // Init reductions array - for (int d = 1; d < 64; ++d) - for (int mc = 1; mc < 64; ++mc) - { - double pvRed = 0.00 + log(double(d)) * log(double(mc)) / 3.00; - double nonPVRed = 0.33 + log(double(d)) * log(double(mc)) / 2.25; + const double K[][2] = {{ 0.799, 2.281 }, { 0.484, 3.023 }}; - Reductions[1][1][d][mc] = int8_t( pvRed >= 1.0 ? pvRed + 0.5: 0); - Reductions[0][1][d][mc] = int8_t(nonPVRed >= 1.0 ? nonPVRed + 0.5: 0); + for (int pv = 0; pv <= 1; ++pv) + for (int imp = 0; imp <= 1; ++imp) + for (int d = 1; d < 64; ++d) + for (int mc = 1; mc < 64; ++mc) + { + double r = K[pv][0] + log(d) * log(mc) / K[pv][1]; - Reductions[1][0][d][mc] = Reductions[1][1][d][mc]; - Reductions[0][0][d][mc] = Reductions[0][1][d][mc]; + if (r >= 1.5) + Reductions[pv][imp][d][mc] = int(r) * ONE_PLY; - // Increase reduction when eval is not improving - if (Reductions[0][0][d][mc] >= 2) - Reductions[0][0][d][mc] += 1; - } + // Increase reduction when eval is not improving + if (!pv && !imp && Reductions[pv][imp][d][mc] >= 2 * ONE_PLY) + Reductions[pv][imp][d][mc] += ONE_PLY; + } - // Init futility move count array for (int d = 0; d < 16; ++d) { FutilityMoveCounts[0][d] = int(2.4 + 0.773 * pow(d + 0.00, 1.8)); @@ -157,6 +174,21 @@ void Search::init() { } +/// Search::reset() clears all search memory, to obtain reproducible search results + +void Search::reset () { + + TT.clear(); + CounterMovesHistory.clear(); + + for (Thread* th : Threads) + { + th->History.clear(); + th->Countermoves.clear(); + } +} + + /// Search::perft() is our utility to verify move generation. All the leaf nodes /// up to the given depth are generated and counted and the sum returned. template @@ -167,19 +199,19 @@ uint64_t Search::perft(Position& pos, Depth depth) { CheckInfo ci(pos); const bool leaf = (depth == 2 * ONE_PLY); - for (MoveList it(pos); *it; ++it) + for (const auto& m : MoveList(pos)) { if (Root && depth <= ONE_PLY) cnt = 1, nodes++; else { - pos.do_move(*it, st, ci, pos.gives_check(*it, ci)); + pos.do_move(m, st, pos.gives_check(m, ci)); cnt = leaf ? MoveList(pos).size() : perft(pos, depth - ONE_PLY); nodes += cnt; - pos.undo_move(*it); + pos.undo_move(m); } if (Root) - sync_cout << UCI::move(*it, pos.is_chess960()) << ": " << cnt << sync_endl; + sync_cout << UCI::move(m, pos.is_chess960()) << ": " << cnt << sync_endl; } return nodes; } @@ -187,17 +219,18 @@ uint64_t Search::perft(Position& pos, Depth depth) { template uint64_t Search::perft(Position& pos, Depth depth); -/// Search::think() is the external interface to Stockfish's search, and is -/// called by the main thread when the program receives the UCI 'go' command. It -/// searches from RootPos and at the end prints the "bestmove" to output. +/// MainThread::think() is called by the main thread when the program receives +/// the UCI 'go' command. It searches from root position and at the end prints +/// the "bestmove" to output. -void Search::think() { +void MainThread::think() { - TimeMgr.init(Limits, RootPos.side_to_move(), RootPos.game_ply()); + Color us = rootPos.side_to_move(); + Time.init(Limits, us, rootPos.game_ply()); int contempt = Options["Contempt"] * PawnValueEg / 100; // From centipawns - DrawValue[ RootPos.side_to_move()] = VALUE_DRAW - Value(contempt); - DrawValue[~RootPos.side_to_move()] = VALUE_DRAW + Value(contempt); + DrawValue[ us] = VALUE_DRAW - Value(contempt); + DrawValue[~us] = VALUE_DRAW + Value(contempt); TB::Hits = 0; TB::RootInTB = false; @@ -212,21 +245,21 @@ void Search::think() { TB::ProbeDepth = DEPTH_ZERO; } - if (RootMoves.empty()) + if (rootMoves.empty()) { - RootMoves.push_back(MOVE_NONE); + rootMoves.push_back(RootMove(MOVE_NONE)); sync_cout << "info depth 0 score " - << UCI::value(RootPos.checkers() ? -VALUE_MATE : VALUE_DRAW) + << UCI::value(rootPos.checkers() ? -VALUE_MATE : VALUE_DRAW) << sync_endl; } else { - if (TB::Cardinality >= RootPos.count(WHITE) - + RootPos.count(BLACK)) + if (TB::Cardinality >= rootPos.count(WHITE) + + rootPos.count(BLACK)) { // If the current root position is in the tablebases then RootMoves // contains only moves that preserve the draw or win. - TB::RootInTB = Tablebases::root_probe(RootPos, RootMoves, TB::Score); + TB::RootInTB = Tablebases::root_probe(rootPos, rootMoves, TB::Score); if (TB::RootInTB) TB::Cardinality = 0; // Do not probe tablebases during the search @@ -234,7 +267,7 @@ void Search::think() { else // If DTZ tables are missing, use WDL tables as a fallback { // Filter out moves that do not preserve a draw or win - TB::RootInTB = Tablebases::root_probe_wdl(RootPos, RootMoves, TB::Score); + TB::RootInTB = Tablebases::root_probe_wdl(rootPos, rootMoves, TB::Score); // Only probe during search if winning if (TB::Score <= VALUE_DRAW) @@ -243,7 +276,7 @@ void Search::think() { if (TB::RootInTB) { - TB::Hits = RootMoves.size(); + TB::Hits = rootMoves.size(); if (!TB::UseRule50) TB::Score = TB::Score > VALUE_DRAW ? VALUE_MATE - MAX_PLY - 1 @@ -252,17 +285,39 @@ void Search::think() { } } - for (size_t i = 0; i < Threads.size(); ++i) - Threads[i]->maxPly = 0; + for (Thread* th : Threads) + { + th->maxPly = 0; + th->depth = DEPTH_ZERO; + th->searching = true; + if (th != this) + { + th->rootPos = Position(rootPos, th); + th->rootMoves = rootMoves; + th->notify_one(); // Wake up the thread and start searching + } + } Threads.timer->run = true; - Threads.timer->notify_one(); // Wake up the recurring timer + Threads.timer->notify_one(); // Start the recurring timer - id_loop(RootPos); // Let's start searching ! + search(true); // Let's start searching! + // Stop the threads and the timer + Signals.stop = true; Threads.timer->run = false; + + // Wait until all threads have finished + for (Thread* th : Threads) + if (th != this) + th->wait_while(th->searching); } + // When playing in 'nodes as time' mode, subtract the searched nodes from + // the available ones before to exit. + if (Limits.npmsec) + Time.availableNodes += Limits.inc[us] - Threads.nodes_searched(); + // When we reach the maximum depth, we can arrive here without a raise of // Signals.stop. However, if we are pondering or in an infinite search, // the UCI protocol states that we shouldn't print the best move before the @@ -271,173 +326,218 @@ void Search::think() { if (!Signals.stop && (Limits.ponder || Limits.infinite)) { Signals.stopOnPonderhit = true; - RootPos.this_thread()->wait_for(Signals.stop); + wait(Signals.stop); } - sync_cout << "bestmove " << UCI::move(RootMoves[0].pv[0], RootPos.is_chess960()); + sync_cout << "bestmove " << UCI::move(rootMoves[0].pv[0], rootPos.is_chess960()); - if (RootMoves[0].pv.size() > 1 || RootMoves[0].extract_ponder_from_tt(RootPos)) - std::cout << " ponder " << UCI::move(RootMoves[0].pv[1], RootPos.is_chess960()); + if (rootMoves[0].pv.size() > 1 || rootMoves[0].extract_ponder_from_tt(rootPos)) + std::cout << " ponder " << UCI::move(rootMoves[0].pv[1], rootPos.is_chess960()); std::cout << sync_endl; } -namespace { +// Thread::search() is the main iterative deepening loop. It calls search() +// repeatedly with increasing depth until the allocated thinking time has been +// consumed, user stops the search, or the maximum search depth is reached. - // id_loop() is the main iterative deepening loop. It calls search() repeatedly - // with increasing depth until the allocated thinking time has been consumed, - // user stops the search, or the maximum search depth is reached. +void Thread::search(bool isMainThread) { - void id_loop(Position& pos) { + Stack* ss = stack + 2; // To allow referencing (ss-2) and (ss+2) + Value bestValue, alpha, beta, delta; + Move easyMove = MOVE_NONE; - Stack stack[MAX_PLY+4], *ss = stack+2; // To allow referencing (ss-2) and (ss+2) - Depth depth; - Value bestValue, alpha, beta, delta; + std::memset(ss-2, 0, 5 * sizeof(Stack)); - std::memset(ss-2, 0, 5 * sizeof(Stack)); + bestValue = delta = alpha = -VALUE_INFINITE; + beta = VALUE_INFINITE; - depth = DEPTH_ZERO; - BestMoveChanges = 0; - bestValue = delta = alpha = -VALUE_INFINITE; - beta = VALUE_INFINITE; - - TT.new_search(); - History.clear(); - Gains.clear(); - Countermoves.clear(); - Followupmoves.clear(); - - size_t multiPV = Options["MultiPV"]; - Skill skill(Options["Skill Level"], RootMoves.size()); - - // Do we have to play with skill handicap? In this case enable MultiPV search - // that we will use behind the scenes to retrieve a set of possible moves. - multiPV = std::max(multiPV, skill.candidates_size()); - - // Iterative deepening loop until requested to stop or target depth reached - while (++depth < DEPTH_MAX && !Signals.stop && (!Limits.depth || depth <= Limits.depth)) - { - // Age out PV variability metric - BestMoveChanges *= 0.5; - - // Save the last iteration's scores before first PV line is searched and - // all the move scores except the (new) PV are set to -VALUE_INFINITE. - for (size_t i = 0; i < RootMoves.size(); ++i) - RootMoves[i].previousScore = RootMoves[i].score; - - // MultiPV loop. We perform a full root search for each PV line - for (PVIdx = 0; PVIdx < std::min(multiPV, RootMoves.size()) && !Signals.stop; ++PVIdx) - { - // Reset aspiration window starting size - if (depth >= 5 * ONE_PLY) - { - delta = Value(16); - alpha = std::max(RootMoves[PVIdx].previousScore - delta,-VALUE_INFINITE); - beta = std::min(RootMoves[PVIdx].previousScore + delta, VALUE_INFINITE); - } - - // Start with a small aspiration window and, in the case of a fail - // high/low, re-search with a bigger window until we're not failing - // high/low anymore. - while (true) - { - bestValue = search(pos, ss, alpha, beta, depth, false); - - // Bring the best move to the front. It is critical that sorting - // is done with a stable algorithm because all the values but the - // first and eventually the new best one are set to -VALUE_INFINITE - // and we want to keep the same order for all the moves except the - // new PV that goes to the front. Note that in case of MultiPV - // search the already searched PV lines are preserved. - std::stable_sort(RootMoves.begin() + PVIdx, RootMoves.end()); - - // Write PV back to transposition table in case the relevant - // entries have been overwritten during the search. - for (size_t i = 0; i <= PVIdx; ++i) - RootMoves[i].insert_pv_in_tt(pos); - - // If search has been stopped break immediately. Sorting and - // writing PV back to TT is safe because RootMoves is still - // valid, although it refers to previous iteration. - if (Signals.stop) - break; - - // When failing high/low give some update (without cluttering - // the UI) before a re-search. - if ( multiPV == 1 - && (bestValue <= alpha || bestValue >= beta) - && Time::now() - SearchTime > 3000) - sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl; - - // In case of failing low/high increase aspiration window and - // re-search, otherwise exit the loop. - if (bestValue <= alpha) - { - beta = (alpha + beta) / 2; - alpha = std::max(bestValue - delta, -VALUE_INFINITE); - - Signals.failedLowAtRoot = true; - Signals.stopOnPonderhit = false; - } - else if (bestValue >= beta) - { - alpha = (alpha + beta) / 2; - beta = std::min(bestValue + delta, VALUE_INFINITE); - } - else - break; - - delta += delta / 2; - - assert(alpha >= -VALUE_INFINITE && beta <= VALUE_INFINITE); - } - - // Sort the PV lines searched so far and update the GUI - std::stable_sort(RootMoves.begin(), RootMoves.begin() + PVIdx + 1); - - if (Signals.stop) - sync_cout << "info nodes " << RootPos.nodes_searched() - << " time " << Time::now() - SearchTime << sync_endl; - - else if ( PVIdx + 1 == std::min(multiPV, RootMoves.size()) - || Time::now() - SearchTime > 3000) - sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl; - } - - // If skill levels are enabled and time is up, pick a sub-optimal best move - if (skill.candidates_size() && skill.time_to_pick(depth)) - skill.pick_move(); - - // Have we found a "mate in x"? - if ( Limits.mate - && bestValue >= VALUE_MATE_IN_MAX_PLY - && VALUE_MATE - bestValue <= 2 * Limits.mate) - Signals.stop = true; - - // Do we have time for the next iteration? Can we stop searching now? - if (Limits.use_time_management() && !Signals.stop && !Signals.stopOnPonderhit) - { - // Take some extra time if the best move has changed - if (depth > 4 * ONE_PLY && multiPV == 1) - TimeMgr.pv_instability(BestMoveChanges); - - // Stop the search if only one legal move is available or all - // of the available time has been used. - if ( RootMoves.size() == 1 - || Time::now() - SearchTime > TimeMgr.available_time()) - { - // If we are allowed to ponder do not stop the search now but - // keep pondering until the GUI sends "ponderhit" or "stop". - if (Limits.ponder) - Signals.stopOnPonderhit = true; - else - Signals.stop = true; - } - } - } + if (isMainThread) + { + easyMove = EasyMove.get(rootPos.key()); + EasyMove.clear(); + BestMoveChanges = 0; + TT.new_search(); } + size_t multiPV = Options["MultiPV"]; + Skill skill(Options["Skill Level"]); + + // When playing with strength handicap enable MultiPV search that we will + // use behind the scenes to retrieve a set of possible moves. + if (skill.enabled()) + multiPV = std::max(multiPV, (size_t)4); + + multiPV = std::min(multiPV, rootMoves.size()); + + // Iterative deepening loop until requested to stop or target depth reached + while (++depth < DEPTH_MAX && !Signals.stop && (!Limits.depth || depth <= Limits.depth)) + { + // Set up the new depth for the helper threads + if (!isMainThread) + depth = Threads.main()->depth + Depth(int(3 * log(1 + this->idx))); + + // Age out PV variability metric + if (isMainThread) + BestMoveChanges *= 0.5; + + // Save the last iteration's scores before first PV line is searched and + // all the move scores except the (new) PV are set to -VALUE_INFINITE. + for (RootMove& rm : rootMoves) + rm.previousScore = rm.score; + + // MultiPV loop. We perform a full root search for each PV line + for (PVIdx = 0; PVIdx < multiPV && !Signals.stop; ++PVIdx) + { + // Reset aspiration window starting size + if (depth >= 5 * ONE_PLY) + { + delta = Value(18); + alpha = std::max(rootMoves[PVIdx].previousScore - delta,-VALUE_INFINITE); + beta = std::min(rootMoves[PVIdx].previousScore + delta, VALUE_INFINITE); + } + + // Start with a small aspiration window and, in the case of a fail + // high/low, re-search with a bigger window until we're not failing + // high/low anymore. + while (true) + { + bestValue = ::search(rootPos, ss, alpha, beta, depth, false); + + // Bring the best move to the front. It is critical that sorting + // is done with a stable algorithm because all the values but the + // first and eventually the new best one are set to -VALUE_INFINITE + // and we want to keep the same order for all the moves except the + // new PV that goes to the front. Note that in case of MultiPV + // search the already searched PV lines are preserved. + std::stable_sort(rootMoves.begin() + PVIdx, rootMoves.end()); + + // Write PV back to transposition table in case the relevant + // entries have been overwritten during the search. + for (size_t i = 0; i <= PVIdx; ++i) + rootMoves[i].insert_pv_in_tt(rootPos); + + // If search has been stopped break immediately. Sorting and + // writing PV back to TT is safe because RootMoves is still + // valid, although it refers to previous iteration. + if (Signals.stop) + break; + + // When failing high/low give some update (without cluttering + // the UI) before a re-search. + if ( isMainThread + && multiPV == 1 + && (bestValue <= alpha || bestValue >= beta) + && Time.elapsed() > 3000) + sync_cout << UCI::pv(rootPos, depth, alpha, beta) << sync_endl; + + // In case of failing low/high increase aspiration window and + // re-search, otherwise exit the loop. + if (bestValue <= alpha) + { + beta = (alpha + beta) / 2; + alpha = std::max(bestValue - delta, -VALUE_INFINITE); + + if (isMainThread) + { + Signals.failedLowAtRoot = true; + Signals.stopOnPonderhit = false; + } + } + else if (bestValue >= beta) + { + alpha = (alpha + beta) / 2; + beta = std::min(bestValue + delta, VALUE_INFINITE); + } + else + break; + + delta += delta / 4 + 5; + + assert(alpha >= -VALUE_INFINITE && beta <= VALUE_INFINITE); + } + + // Sort the PV lines searched so far and update the GUI + std::stable_sort(rootMoves.begin(), rootMoves.begin() + PVIdx + 1); + + if (!isMainThread) + break; + + if (Signals.stop) + sync_cout << "info nodes " << Threads.nodes_searched() + << " time " << Time.elapsed() << sync_endl; + + else if (PVIdx + 1 == multiPV || Time.elapsed() > 3000) + sync_cout << UCI::pv(rootPos, depth, alpha, beta) << sync_endl; + } + + if (!isMainThread) + continue; + + // If skill level is enabled and time is up, pick a sub-optimal best move + if (skill.enabled() && skill.time_to_pick(depth)) + skill.pick_best(multiPV); + + // Have we found a "mate in x"? + if ( Limits.mate + && bestValue >= VALUE_MATE_IN_MAX_PLY + && VALUE_MATE - bestValue <= 2 * Limits.mate) + Signals.stop = true; + + // Do we have time for the next iteration? Can we stop searching now? + if (Limits.use_time_management()) + { + if (!Signals.stop && !Signals.stopOnPonderhit) + { + // Take some extra time if the best move has changed + if (depth > 4 * ONE_PLY && multiPV == 1) + Time.pv_instability(BestMoveChanges); + + // Stop the search if only one legal move is available or all + // of the available time has been used or we matched an easyMove + // from the previous search and just did a fast verification. + if ( rootMoves.size() == 1 + || Time.elapsed() > Time.available() + || ( rootMoves[0].pv[0] == easyMove + && BestMoveChanges < 0.03 + && Time.elapsed() > Time.available() / 10)) + { + // If we are allowed to ponder do not stop the search now but + // keep pondering until the GUI sends "ponderhit" or "stop". + if (Limits.ponder) + Signals.stopOnPonderhit = true; + else + Signals.stop = true; + } + } + + if (rootMoves[0].pv.size() >= 3) + EasyMove.update(rootPos, rootMoves[0].pv); + else + EasyMove.clear(); + } + } + + searching = false; + notify_one(); // Wake up main thread if is sleeping waiting for us + + if (!isMainThread) + return; + + // Clear any candidate easy move that wasn't stable for the last search + // iterations; the second condition prevents consecutive fast moves. + if (EasyMove.stableCnt < 6 || Time.elapsed() < Time.available()) + EasyMove.clear(); + + // If skill level is enabled, swap best PV line with the sub-optimal one + if (skill.enabled()) + std::swap(rootMoves[0], *std::find(rootMoves.begin(), + rootMoves.end(), skill.best_move(multiPV))); +} + + +namespace { // search<>() is the main search function for both PV and non-PV nodes and for // normal and SplitPoint nodes. When called just after a split point the search @@ -446,7 +546,7 @@ namespace { // repeat all this work again. We also don't need to store anything to the hash // table here: This is taken care of after we return from the split point. - template + template Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth, bool cutNode) { const bool RootNode = NT == Root; @@ -459,35 +559,18 @@ namespace { Move pv[MAX_PLY+1], quietsSearched[64]; StateInfo st; TTEntry* tte; - SplitPoint* splitPoint; Key posKey; Move ttMove, move, excludedMove, bestMove; Depth extension, newDepth, predictedDepth; Value bestValue, value, ttValue, eval, nullValue, futilityValue; bool ttHit, inCheck, givesCheck, singularExtensionNode, improving; - bool captureOrPromotion, dangerous, doFullDepthSearch; + bool captureOrPromotion, doFullDepthSearch; int moveCount, quietCount; // Step 1. Initialize node Thread* thisThread = pos.this_thread(); inCheck = pos.checkers(); - - if (SpNode) - { - splitPoint = ss->splitPoint; - bestMove = splitPoint->bestMove; - bestValue = splitPoint->bestValue; - tte = NULL; - ttHit = false; - ttMove = excludedMove = MOVE_NONE; - ttValue = VALUE_NONE; - - assert(splitPoint->bestValue > -VALUE_INFINITE && splitPoint->moveCount > 0); - - goto moves_loop; - } - - moveCount = quietCount = 0; + moveCount = quietCount = ss->moveCount = 0; bestValue = -VALUE_INFINITE; ss->ply = (ss-1)->ply + 1; @@ -525,10 +608,10 @@ namespace { excludedMove = ss->excludedMove; posKey = excludedMove ? pos.exclusion_key() : pos.key(); tte = TT.probe(posKey, ttHit); - ss->ttMove = ttMove = RootNode ? RootMoves[PVIdx].pv[0] : ttHit ? tte->move() : MOVE_NONE; + ss->ttMove = ttMove = RootNode ? thisThread->rootMoves[thisThread->PVIdx].pv[0] : ttHit ? tte->move() : MOVE_NONE; ttValue = ttHit ? value_from_tt(tte->value(), ss->ply) : VALUE_NONE; - // At non-PV nodes we check for a fail high/low. We don't probe at PV nodes + // At non-PV nodes we check for a fail high/low. We don't prune at PV nodes if ( !PvNode && ttHit && tte->depth() >= depth @@ -538,9 +621,9 @@ namespace { { ss->currentMove = ttMove; // Can be MOVE_NONE - // If ttMove is quiet, update killers, history, counter move and followup move on TT hit - if (ttValue >= beta && ttMove && !pos.capture_or_promotion(ttMove) && !inCheck) - update_stats(pos, ss, ttMove, depth, NULL, 0); + // If ttMove is quiet, update killers, history, counter move on TT hit + if (ttValue >= beta && ttMove && !pos.capture_or_promotion(ttMove)) + update_stats(pos, ss, ttMove, depth, nullptr, 0); return ttValue; } @@ -575,7 +658,7 @@ namespace { } } - // Step 5. Evaluate the position statically and update parent's gain statistics + // Step 5. Evaluate the position statically if (inCheck) { ss->staticEval = eval = VALUE_NONE; @@ -604,29 +687,17 @@ namespace { if (ss->skipEarlyPruning) goto moves_loop; - if ( !pos.captured_piece_type() - && ss->staticEval != VALUE_NONE - && (ss-1)->staticEval != VALUE_NONE - && (move = (ss-1)->currentMove) != MOVE_NULL - && move != MOVE_NONE - && type_of(move) == NORMAL) - { - Square to = to_sq(move); - Gains.update(pos.piece_on(to), to, -(ss-1)->staticEval - ss->staticEval); - } - // Step 6. Razoring (skipped when in check) if ( !PvNode && depth < 4 * ONE_PLY - && eval + razor_margin(depth) <= alpha - && ttMove == MOVE_NONE - && !pos.pawn_on_7th(pos.side_to_move())) + && eval + razor_margin[depth] <= alpha + && ttMove == MOVE_NONE) { if ( depth <= ONE_PLY - && eval + razor_margin(3 * ONE_PLY) <= alpha) + && eval + razor_margin[3 * ONE_PLY] <= alpha) return qsearch(pos, ss, alpha, beta, DEPTH_ZERO); - Value ralpha = alpha - razor_margin(depth); + Value ralpha = alpha - razor_margin[depth]; Value v = qsearch(pos, ss, ralpha, ralpha+1, DEPTH_ZERO); if (v <= ralpha) return v; @@ -656,7 +727,7 @@ namespace { pos.do_null_move(st); (ss+1)->skipEarlyPruning = true; nullValue = depth-R < ONE_PLY ? -qsearch(pos, ss+1, -beta, -beta+1, DEPTH_ZERO) - : - search(pos, ss+1, -beta, -beta+1, depth-R, !cutNode); + : - search(pos, ss+1, -beta, -beta+1, depth-R, !cutNode); (ss+1)->skipEarlyPruning = false; pos.undo_null_move(); @@ -672,7 +743,7 @@ namespace { // Do verification search at high depths ss->skipEarlyPruning = true; Value v = depth-R < ONE_PLY ? qsearch(pos, ss, beta-1, beta, DEPTH_ZERO) - : search(pos, ss, beta-1, beta, depth-R, false); + : search(pos, ss, beta-1, beta, depth-R, false); ss->skipEarlyPruning = false; if (v >= beta) @@ -695,15 +766,15 @@ namespace { assert((ss-1)->currentMove != MOVE_NONE); assert((ss-1)->currentMove != MOVE_NULL); - MovePicker mp(pos, ttMove, History, pos.captured_piece_type()); + MovePicker mp(pos, ttMove, thisThread->History, CounterMovesHistory, PieceValue[MG][pos.captured_piece_type()]); CheckInfo ci(pos); - while ((move = mp.next_move()) != MOVE_NONE) + while ((move = mp.next_move()) != MOVE_NONE) if (pos.legal(move, ci.pinned)) { ss->currentMove = move; - pos.do_move(move, st, ci, pos.gives_check(move, ci)); - value = -search(pos, ss+1, -rbeta, -rbeta+1, rdepth, !cutNode); + pos.do_move(move, st, pos.gives_check(move, ci)); + value = -search(pos, ss+1, -rbeta, -rbeta+1, rdepth, !cutNode); pos.undo_move(move); if (value >= rbeta) return value; @@ -715,26 +786,21 @@ namespace { && !ttMove && (PvNode || ss->staticEval + 256 >= beta)) { - Depth d = 2 * (depth - 2 * ONE_PLY) - (PvNode ? DEPTH_ZERO : depth / 2); + Depth d = depth - 2 * ONE_PLY - (PvNode ? DEPTH_ZERO : depth / 4); ss->skipEarlyPruning = true; - search(pos, ss, alpha, beta, d / 2, true); + search(pos, ss, alpha, beta, d, true); ss->skipEarlyPruning = false; tte = TT.probe(posKey, ttHit); ttMove = ttHit ? tte->move() : MOVE_NONE; } -moves_loop: // When in check and at SpNode search starts from here +moves_loop: // When in check search starts from here Square prevMoveSq = to_sq((ss-1)->currentMove); - Move countermoves[] = { Countermoves[pos.piece_on(prevMoveSq)][prevMoveSq].first, - Countermoves[pos.piece_on(prevMoveSq)][prevMoveSq].second }; + Move countermove = thisThread->Countermoves[pos.piece_on(prevMoveSq)][prevMoveSq]; - Square prevOwnMoveSq = to_sq((ss-2)->currentMove); - Move followupmoves[] = { Followupmoves[pos.piece_on(prevOwnMoveSq)][prevOwnMoveSq].first, - Followupmoves[pos.piece_on(prevOwnMoveSq)][prevOwnMoveSq].second }; - - MovePicker mp(pos, ttMove, depth, History, countermoves, followupmoves, ss); + MovePicker mp(pos, ttMove, depth, thisThread->History, CounterMovesHistory, countermove, ss); CheckInfo ci(pos); value = bestValue; // Workaround a bogus 'uninitialized' warning under gcc improving = ss->staticEval >= (ss-2)->staticEval @@ -742,7 +808,6 @@ moves_loop: // When in check and at SpNode search starts from here ||(ss-2)->staticEval == VALUE_NONE; singularExtensionNode = !RootNode - && !SpNode && depth >= 8 * ONE_PLY && ttMove != MOVE_NONE /* && ttValue != VALUE_NONE Already implicit in the next condition */ @@ -753,7 +818,7 @@ moves_loop: // When in check and at SpNode search starts from here // Step 11. Loop through moves // Loop through all pseudo-legal moves until no moves remain or a beta cutoff occurs - while ((move = mp.next_move()) != MOVE_NONE) + while ((move = mp.next_move()) != MOVE_NONE) { assert(is_ok(move)); @@ -763,45 +828,31 @@ moves_loop: // When in check and at SpNode search starts from here // At root obey the "searchmoves" option and skip moves not listed in Root // Move List. As a consequence any illegal move is also skipped. In MultiPV // mode we also skip PV moves which have been already searched. - if (RootNode && !std::count(RootMoves.begin() + PVIdx, RootMoves.end(), move)) + if (RootNode && !std::count(thisThread->rootMoves.begin() + thisThread->PVIdx, thisThread->rootMoves.end(), move)) continue; - if (SpNode) - { - // Shared counter cannot be decremented later if the move turns out to be illegal - if (!pos.legal(move, ci.pinned)) - continue; + ss->moveCount = ++moveCount; - moveCount = ++splitPoint->moveCount; - splitPoint->mutex.unlock(); - } - else - ++moveCount; - - if (RootNode) + if (RootNode && thisThread == Threads.main()) { Signals.firstRootMove = (moveCount == 1); - if (thisThread == Threads.main() && Time::now() - SearchTime > 3000) + if (Time.elapsed() > 3000) sync_cout << "info depth " << depth / ONE_PLY << " currmove " << UCI::move(move, pos.is_chess960()) - << " currmovenumber " << moveCount + PVIdx << sync_endl; + << " currmovenumber " << moveCount + thisThread->PVIdx << sync_endl; } if (PvNode) - (ss+1)->pv = NULL; + (ss+1)->pv = nullptr; extension = DEPTH_ZERO; captureOrPromotion = pos.capture_or_promotion(move); givesCheck = type_of(move) == NORMAL && !ci.dcCandidates - ? ci.checkSq[type_of(pos.piece_on(from_sq(move)))] & to_sq(move) + ? ci.checkSquares[type_of(pos.piece_on(from_sq(move)))] & to_sq(move) : pos.gives_check(move, ci); - dangerous = givesCheck - || type_of(move) != NORMAL - || pos.advanced_pawn_push(move); - // Step 12. Extend checks if (givesCheck && pos.see_sign(move) >= VALUE_ZERO) extension = ONE_PLY; @@ -819,7 +870,7 @@ moves_loop: // When in check and at SpNode search starts from here Value rBeta = ttValue - 2 * depth / ONE_PLY; ss->excludedMove = move; ss->skipEarlyPruning = true; - value = search(pos, ss, rBeta - 1, rBeta, depth / 2, cutNode); + value = search(pos, ss, rBeta - 1, rBeta, depth / 2, cutNode); ss->skipEarlyPruning = false; ss->excludedMove = MOVE_NONE; @@ -834,67 +885,48 @@ moves_loop: // When in check and at SpNode search starts from here if ( !RootNode && !captureOrPromotion && !inCheck - && !dangerous + && !givesCheck + && !pos.advanced_pawn_push(move) && bestValue > VALUE_MATED_IN_MAX_PLY) { // Move count based pruning if ( depth < 16 * ONE_PLY && moveCount >= FutilityMoveCounts[improving][depth]) - { - if (SpNode) - splitPoint->mutex.lock(); - continue; - } predictedDepth = newDepth - reduction(improving, depth, moveCount); // Futility pruning: parent node if (predictedDepth < 7 * ONE_PLY) { - futilityValue = ss->staticEval + futility_margin(predictedDepth) - + 128 + Gains[pos.moved_piece(move)][to_sq(move)]; + futilityValue = ss->staticEval + futility_margin(predictedDepth) + 256; if (futilityValue <= alpha) { bestValue = std::max(bestValue, futilityValue); - - if (SpNode) - { - splitPoint->mutex.lock(); - if (bestValue > splitPoint->bestValue) - splitPoint->bestValue = bestValue; - } continue; } } // Prune moves with negative SEE at low depths if (predictedDepth < 4 * ONE_PLY && pos.see_sign(move) < VALUE_ZERO) - { - if (SpNode) - splitPoint->mutex.lock(); - continue; - } } // Speculative prefetch as early as possible - prefetch((char*)TT.first_entry(pos.key_after(move))); + prefetch(TT.first_entry(pos.key_after(move))); // Check for legality just before making the move - if (!RootNode && !SpNode && !pos.legal(move, ci.pinned)) + if (!RootNode && !pos.legal(move, ci.pinned)) { - moveCount--; + ss->moveCount = --moveCount; continue; } ss->currentMove = move; - if (!SpNode && !captureOrPromotion && quietCount < 64) - quietsSearched[quietCount++] = move; // Step 14. Make the move - pos.do_move(move, st, ci, givesCheck); + pos.do_move(move, st, givesCheck); // Step 15. Reduced depth search (LMR). If the move fails high it will be // re-searched at full depth. @@ -907,10 +939,14 @@ moves_loop: // When in check and at SpNode search starts from here ss->reduction = reduction(improving, depth, moveCount); if ( (!PvNode && cutNode) - || History[pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO) + || ( thisThread->History[pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO + && CounterMovesHistory[pos.piece_on(prevMoveSq)][prevMoveSq] + [pos.piece_on(to_sq(move))][to_sq(move)] <= VALUE_ZERO)) ss->reduction += ONE_PLY; - if (move == countermoves[0] || move == countermoves[1]) + if ( thisThread->History[pos.piece_on(to_sq(move))][to_sq(move)] > VALUE_ZERO + && CounterMovesHistory[pos.piece_on(prevMoveSq)][prevMoveSq] + [pos.piece_on(to_sq(move))][to_sq(move)] > VALUE_ZERO) ss->reduction = std::max(DEPTH_ZERO, ss->reduction - ONE_PLY); // Decrease reduction for moves that escape a capture @@ -921,17 +957,8 @@ moves_loop: // When in check and at SpNode search starts from here ss->reduction = std::max(DEPTH_ZERO, ss->reduction - ONE_PLY); Depth d = std::max(newDepth - ss->reduction, ONE_PLY); - if (SpNode) - alpha = splitPoint->alpha; - value = -search(pos, ss+1, -(alpha+1), -alpha, d, true); - - // Re-search at intermediate depth if reduction is very high - if (value > alpha && ss->reduction >= 4 * ONE_PLY) - { - Depth d2 = std::max(newDepth - 2 * ONE_PLY, ONE_PLY); - value = -search(pos, ss+1, -(alpha+1), -alpha, d2, true); - } + value = -search(pos, ss+1, -(alpha+1), -alpha, d, true); doFullDepthSearch = (value > alpha && ss->reduction != DEPTH_ZERO); ss->reduction = DEPTH_ZERO; @@ -941,15 +968,10 @@ moves_loop: // When in check and at SpNode search starts from here // Step 16. Full depth search, when LMR is skipped or fails high if (doFullDepthSearch) - { - if (SpNode) - alpha = splitPoint->alpha; - value = newDepth < ONE_PLY ? givesCheck ? -qsearch(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO) : -qsearch(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO) - : - search(pos, ss+1, -(alpha+1), -alpha, newDepth, !cutNode); - } + : - search(pos, ss+1, -(alpha+1), -alpha, newDepth, !cutNode); // For PV nodes only, do a full PV search on the first move or after a fail // high (in the latter case search only if value < beta), otherwise let the @@ -962,7 +984,7 @@ moves_loop: // When in check and at SpNode search starts from here value = newDepth < ONE_PLY ? givesCheck ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO) : -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO) - : - search(pos, ss+1, -beta, -alpha, newDepth, false); + : - search(pos, ss+1, -beta, -alpha, newDepth, false); } // Step 17. Undo move @@ -971,22 +993,15 @@ moves_loop: // When in check and at SpNode search starts from here assert(value > -VALUE_INFINITE && value < VALUE_INFINITE); // Step 18. Check for new best move - if (SpNode) - { - splitPoint->mutex.lock(); - bestValue = splitPoint->bestValue; - alpha = splitPoint->alpha; - } - - // Finished searching the move. If a stop or a cutoff occurred, the return - // value of the search cannot be trusted, and we return immediately without + // Finished searching the move. If a stop occurred, the return value of + // the search cannot be trusted, and we return immediately without // updating best move, PV and TT. - if (Signals.stop || thisThread->cutoff_occurred()) + if (Signals.stop) return VALUE_ZERO; if (RootNode) { - RootMove& rm = *std::find(RootMoves.begin(), RootMoves.end(), move); + RootMove& rm = *std::find(thisThread->rootMoves.begin(), thisThread->rootMoves.end(), move); // PV move or new best move ? if (moveCount == 1 || value > alpha) @@ -1002,7 +1017,7 @@ moves_loop: // When in check and at SpNode search starts from here // We record how often the best move has been changed in each // iteration. This information is used for time management: When // the best move changes frequently, we allocate some more time. - if (moveCount > 1) + if (moveCount > 1 && thisThread == Threads.main()) ++BestMoveChanges; } else @@ -1014,58 +1029,41 @@ moves_loop: // When in check and at SpNode search starts from here if (value > bestValue) { - bestValue = SpNode ? splitPoint->bestValue = value : value; + bestValue = value; if (value > alpha) { - bestMove = SpNode ? splitPoint->bestMove = move : move; + // If there is an easy move for this position, clear it if unstable + if ( PvNode + && thisThread == Threads.main() + && EasyMove.get(pos.key()) + && (move != EasyMove.get(pos.key()) || moveCount > 1)) + EasyMove.clear(); + + bestMove = move; if (PvNode && !RootNode) // Update pv even in fail-high case - update_pv(SpNode ? splitPoint->ss->pv : ss->pv, move, (ss+1)->pv); + update_pv(ss->pv, move, (ss+1)->pv); if (PvNode && value < beta) // Update alpha! Always alpha < beta - alpha = SpNode ? splitPoint->alpha = value : value; + alpha = value; else { assert(value >= beta); // Fail high - - if (SpNode) - splitPoint->cutoff = true; - break; } } } - // Step 19. Check for splitting the search - if ( !SpNode - && Threads.size() >= 2 - && depth >= Threads.minimumSplitDepth - && ( !thisThread->activeSplitPoint - || !thisThread->activeSplitPoint->allSlavesSearching) - && thisThread->splitPointsSize < MAX_SPLITPOINTS_PER_THREAD) - { - assert(bestValue > -VALUE_INFINITE && bestValue < beta); - - thisThread->split(pos, ss, alpha, beta, &bestValue, &bestMove, - depth, moveCount, &mp, NT, cutNode); - - if (Signals.stop || thisThread->cutoff_occurred()) - return VALUE_ZERO; - - if (bestValue >= beta) - break; - } + if (!captureOrPromotion && move != bestMove && quietCount < 64) + quietsSearched[quietCount++] = move; } - if (SpNode) - return bestValue; - - // Following condition would detect a stop or a cutoff set only after move - // loop has been completed. But in this case bestValue is valid because we - // have fully searched our subtree, and we can anyhow save the result in TT. + // Following condition would detect a stop only after move loop has been + // completed. But in this case bestValue is valid because we have fully + // searched our subtree, and we can anyhow save the result in TT. /* - if (Signals.stop || thisThread->cutoff_occurred()) + if (Signals.stop) return VALUE_DRAW; */ @@ -1077,9 +1075,22 @@ moves_loop: // When in check and at SpNode search starts from here bestValue = excludedMove ? alpha : inCheck ? mated_in(ss->ply) : DrawValue[pos.side_to_move()]; - // Quiet best move: update killers, history, countermoves and followupmoves - else if (bestValue >= beta && !pos.capture_or_promotion(bestMove) && !inCheck) - update_stats(pos, ss, bestMove, depth, quietsSearched, quietCount - 1); + // Quiet best move: update killers, history and countermoves + else if (bestMove && !pos.capture_or_promotion(bestMove)) + update_stats(pos, ss, bestMove, depth, quietsSearched, quietCount); + + // Bonus for prior countermove that caused the fail low + else if (!bestMove) + { + if (is_ok((ss - 2)->currentMove) && is_ok((ss - 1)->currentMove) && !pos.captured_piece_type() && !inCheck && depth>=3*ONE_PLY) + { + Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY)); + Square prevSq = to_sq((ss - 1)->currentMove); + Square prevPrevSq = to_sq((ss - 2)->currentMove); + HistoryStats& flMoveCmh = CounterMovesHistory[pos.piece_on(prevPrevSq)][prevPrevSq]; + flMoveCmh.updateCMH(pos.piece_on(prevSq), prevSq, bonus); + } + } tte->save(posKey, value_to_tt(bestValue, ss->ply), bestValue >= beta ? BOUND_LOWER : @@ -1198,16 +1209,16 @@ moves_loop: // When in check and at SpNode search starts from here // to search the moves. Because the depth is <= 0 here, only captures, // queen promotions and checks (only if depth >= DEPTH_QS_CHECKS) will // be generated. - MovePicker mp(pos, ttMove, depth, History, to_sq((ss-1)->currentMove)); + MovePicker mp(pos, ttMove, depth, pos.this_thread()->History, CounterMovesHistory, to_sq((ss-1)->currentMove)); CheckInfo ci(pos); // Loop through the moves until no moves remain or a beta cutoff occurs - while ((move = mp.next_move()) != MOVE_NONE) + while ((move = mp.next_move()) != MOVE_NONE) { assert(is_ok(move)); givesCheck = type_of(move) == NORMAL && !ci.dcCandidates - ? ci.checkSq[type_of(pos.piece_on(from_sq(move)))] & to_sq(move) + ? ci.checkSquares[type_of(pos.piece_on(from_sq(move)))] & to_sq(move) : pos.gives_check(move, ci); // Futility pruning @@ -1236,8 +1247,7 @@ moves_loop: // When in check and at SpNode search starts from here // Detect non-capture evasions that are candidates to be pruned evasionPrunable = InCheck && bestValue > VALUE_MATED_IN_MAX_PLY - && !pos.capture(move) - && !pos.can_castle(pos.side_to_move()); + && !pos.capture(move); // Don't search moves with negative SEE values if ( (!InCheck || evasionPrunable) @@ -1246,7 +1256,7 @@ moves_loop: // When in check and at SpNode search starts from here continue; // Speculative prefetch as early as possible - prefetch((char*)TT.first_entry(pos.key_after(move))); + prefetch(TT.first_entry(pos.key_after(move))); // Check for legality just before making the move if (!pos.legal(move, ci.pinned)) @@ -1255,7 +1265,7 @@ moves_loop: // When in check and at SpNode search starts from here ss->currentMove = move; // Make and search the move - pos.do_move(move, st, ci, givesCheck); + pos.do_move(move, st, givesCheck); value = givesCheck ? -qsearch(pos, ss+1, -beta, -alpha, depth - ONE_PLY) : -qsearch(pos, ss+1, -beta, -alpha, depth - ONE_PLY); pos.undo_move(move); @@ -1337,10 +1347,12 @@ moves_loop: // When in check and at SpNode search starts from here *pv = MOVE_NONE; } - // update_stats() updates killers, history, countermoves and followupmoves stats after a fail-high - // of a quiet move. - void update_stats(const Position& pos, Stack* ss, Move move, Depth depth, Move* quiets, int quietsCnt) { + // update_stats() updates killers, history, countermove history and + // countermoves stats for a quiet best move. + + void update_stats(const Position& pos, Stack* ss, Move move, + Depth depth, Move* quiets, int quietsCnt) { if (ss->killers[0] != move) { @@ -1348,122 +1360,127 @@ moves_loop: // When in check and at SpNode search starts from here ss->killers[0] = move; } - // Increase history value of the cut-off move and decrease all the other - // played quiet moves. Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY)); - History.update(pos.moved_piece(move), to_sq(move), bonus); - for (int i = 0; i < quietsCnt; ++i) - { - Move m = quiets[i]; - History.update(pos.moved_piece(m), to_sq(m), -bonus); - } + + Square prevSq = to_sq((ss-1)->currentMove); + HistoryStats& cmh = CounterMovesHistory[pos.piece_on(prevSq)][prevSq]; + Thread* thisThread = pos.this_thread(); + + thisThread->History.updateH(pos.moved_piece(move), to_sq(move), bonus); if (is_ok((ss-1)->currentMove)) { - Square prevMoveSq = to_sq((ss-1)->currentMove); - Countermoves.update(pos.piece_on(prevMoveSq), prevMoveSq, move); + thisThread->Countermoves.update(pos.piece_on(prevSq), prevSq, move); + cmh.updateCMH(pos.moved_piece(move), to_sq(move), bonus); } - if (is_ok((ss-2)->currentMove) && (ss-1)->currentMove == (ss-1)->ttMove) + // Decrease all the other played quiet moves + for (int i = 0; i < quietsCnt; ++i) { - Square prevOwnMoveSq = to_sq((ss-2)->currentMove); - Followupmoves.update(pos.piece_on(prevOwnMoveSq), prevOwnMoveSq, move); + thisThread->History.updateH(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus); + + if (is_ok((ss-1)->currentMove)) + cmh.updateCMH(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus); + } + + // Extra penalty for PV move in previous ply when it gets refuted + if (is_ok((ss-2)->currentMove) && (ss-1)->moveCount == 1 && !pos.captured_piece_type()) + { + Square prevPrevSq = to_sq((ss-2)->currentMove); + HistoryStats& ttMoveCmh = CounterMovesHistory[pos.piece_on(prevPrevSq)][prevPrevSq]; + ttMoveCmh.updateCMH(pos.piece_on(prevSq), prevSq, -bonus - 2 * depth / ONE_PLY - 1); } } - // When playing with a strength handicap, choose best move among the first 'candidates' - // RootMoves using a statistical rule dependent on 'level'. Idea by Heinz van Saanen. + // When playing with strength handicap, choose best move among a set of RootMoves + // using a statistical rule dependent on 'level'. Idea by Heinz van Saanen. - Move Skill::pick_move() { + Move Skill::pick_best(size_t multiPV) { // PRNG sequence should be non-deterministic, so we seed it with the time at init - static PRNG rng(Time::now()); + const Search::RootMoveVector& rootMoves = Threads.main()->rootMoves; + static PRNG rng(now()); // RootMoves are already sorted by score in descending order - int variance = std::min(RootMoves[0].score - RootMoves[candidates - 1].score, PawnValueMg); + int variance = std::min(rootMoves[0].score - rootMoves[multiPV - 1].score, PawnValueMg); int weakness = 120 - 2 * level; int maxScore = -VALUE_INFINITE; - best = MOVE_NONE; // Choose best move. For each move score we add two terms both dependent on - // weakness. One deterministic and bigger for weaker moves, and one random, + // weakness. One deterministic and bigger for weaker levels, and one random, // then we choose the move with the resulting highest score. - for (size_t i = 0; i < candidates; ++i) + for (size_t i = 0; i < multiPV; ++i) { - int score = RootMoves[i].score; - - // Don't allow crazy blunders even at very low skills - if (i > 0 && RootMoves[i - 1].score > score + 2 * PawnValueMg) - break; - // This is our magic formula - score += ( weakness * int(RootMoves[0].score - score) - + variance * (rng.rand() % weakness)) / 128; + int push = ( weakness * int(rootMoves[0].score - rootMoves[i].score) + + variance * (rng.rand() % weakness)) / 128; - if (score > maxScore) + if (rootMoves[i].score + push > maxScore) { - maxScore = score; - best = RootMoves[i].pv[0]; + maxScore = rootMoves[i].score + push; + best = rootMoves[i].pv[0]; } } return best; } +} // namespace - // uci_pv() formats PV information according to the UCI protocol. UCI - // requires that all (if any) unsearched PV lines are sent using a previous - // search score. - string uci_pv(const Position& pos, Depth depth, Value alpha, Value beta) { +/// UCI::pv() formats PV information according to the UCI protocol. UCI requires +/// that all (if any) unsearched PV lines are sent using a previous search score. - std::stringstream ss; - Time::point elapsed = Time::now() - SearchTime + 1; - size_t uciPVSize = std::min((size_t)Options["MultiPV"], RootMoves.size()); - int selDepth = 0; +string UCI::pv(const Position& pos, Depth depth, Value alpha, Value beta) { - for (size_t i = 0; i < Threads.size(); ++i) - if (Threads[i]->maxPly > selDepth) - selDepth = Threads[i]->maxPly; + std::stringstream ss; + int elapsed = Time.elapsed() + 1; + const Search::RootMoveVector& rootMoves = pos.this_thread()->rootMoves; + size_t PVIdx = pos.this_thread()->PVIdx; + size_t multiPV = std::min((size_t)Options["MultiPV"], rootMoves.size()); + uint64_t nodes_searched = Threads.nodes_searched(); - for (size_t i = 0; i < uciPVSize; ++i) - { - bool updated = (i <= PVIdx); + for (size_t i = 0; i < multiPV; ++i) + { + bool updated = (i <= PVIdx); - if (depth == ONE_PLY && !updated) - continue; + if (depth == ONE_PLY && !updated) + continue; - Depth d = updated ? depth : depth - ONE_PLY; - Value v = updated ? RootMoves[i].score : RootMoves[i].previousScore; + Depth d = updated ? depth : depth - ONE_PLY; + Value v = updated ? rootMoves[i].score : rootMoves[i].previousScore; - bool tb = TB::RootInTB && abs(v) < VALUE_MATE - MAX_PLY; - v = tb ? TB::Score : v; + bool tb = TB::RootInTB && abs(v) < VALUE_MATE - MAX_PLY; + v = tb ? TB::Score : v; - if (ss.rdbuf()->in_avail()) // Not at first line - ss << "\n"; + if (ss.rdbuf()->in_avail()) // Not at first line + ss << "\n"; - ss << "info depth " << d / ONE_PLY - << " seldepth " << selDepth - << " multipv " << i + 1 - << " score " << UCI::value(v); + ss << "info" + << " depth " << d / ONE_PLY + << " seldepth " << pos.this_thread()->maxPly + << " multipv " << i + 1 + << " score " << UCI::value(v); - if (!tb && i == PVIdx) - ss << (v >= beta ? " lowerbound" : v <= alpha ? " upperbound" : ""); + if (!tb && i == PVIdx) + ss << (v >= beta ? " lowerbound" : v <= alpha ? " upperbound" : ""); - ss << " nodes " << pos.nodes_searched() - << " nps " << pos.nodes_searched() * 1000 / elapsed - << " tbhits " << TB::Hits - << " time " << elapsed - << " pv"; + ss << " nodes " << nodes_searched + << " nps " << nodes_searched * 1000 / elapsed; - for (size_t j = 0; j < RootMoves[i].pv.size(); ++j) - ss << " " << UCI::move(RootMoves[i].pv[j], pos.is_chess960()); - } + if (elapsed > 1000) // Earlier makes little sense + ss << " hashfull " << TT.hashfull(); - return ss.str(); + ss << " tbhits " << TB::Hits + << " time " << elapsed + << " pv"; + + for (Move m : rootMoves[i].pv) + ss << " " << UCI::move(m, pos.is_chess960()); } -} // namespace + return ss.str(); +} /// RootMove::insert_pv_in_tt() is called at the end of a search iteration, and @@ -1473,22 +1490,22 @@ moves_loop: // When in check and at SpNode search starts from here void RootMove::insert_pv_in_tt(Position& pos) { StateInfo state[MAX_PLY], *st = state; - size_t idx = 0; + bool ttHit; - for ( ; idx < pv.size(); ++idx) + for (Move m : pv) { - bool ttHit; + assert(MoveList(pos).contains(m)); + TTEntry* tte = TT.probe(pos.key(), ttHit); - if (!ttHit || tte->move() != pv[idx]) // Don't overwrite correct entries - tte->save(pos.key(), VALUE_NONE, BOUND_NONE, DEPTH_NONE, pv[idx], VALUE_NONE, TT.generation()); + if (!ttHit || tte->move() != m) // Don't overwrite correct entries + tte->save(pos.key(), VALUE_NONE, BOUND_NONE, DEPTH_NONE, m, VALUE_NONE, TT.generation()); - assert(MoveList(pos).contains(pv[idx])); - - pos.do_move(pv[idx], *st++); + pos.do_move(m, *st++, pos.gives_check(m, CheckInfo(pos))); } - while (idx) pos.undo_move(pv[--idx]); + for (size_t i = pv.size(); i > 0; ) + pos.undo_move(pv[--i]); } @@ -1497,143 +1514,25 @@ void RootMove::insert_pv_in_tt(Position& pos) { /// root. We try hard to have a ponder move to return to the GUI, otherwise in case of /// 'ponder on' we have nothing to think on. -Move RootMove::extract_ponder_from_tt(Position& pos) +bool RootMove::extract_ponder_from_tt(Position& pos) { StateInfo st; - bool found; + bool ttHit; assert(pv.size() == 1); - pos.do_move(pv[0], st); - TTEntry* tte = TT.probe(pos.key(), found); - Move m = found ? tte->move() : MOVE_NONE; - if (!MoveList(pos).contains(m)) - m = MOVE_NONE; - + pos.do_move(pv[0], st, pos.gives_check(pv[0], CheckInfo(pos))); + TTEntry* tte = TT.probe(pos.key(), ttHit); pos.undo_move(pv[0]); - pv.push_back(m); - return m; -} + if (ttHit) + { + Move m = tte->move(); // Local copy to be SMP safe + if (MoveList(pos).contains(m)) + return pv.push_back(m), true; + } -/// Thread::idle_loop() is where the thread is parked when it has no work to do - -void Thread::idle_loop() { - - // Pointer 'this_sp' is not null only if we are called from split(), and not - // at the thread creation. This means we are the split point's master. - SplitPoint* this_sp = splitPointsSize ? activeSplitPoint : NULL; - - assert(!this_sp || (this_sp->masterThread == this && searching)); - - while (!exit) - { - // If this thread has been assigned work, launch a search - while (searching) - { - Threads.mutex.lock(); - - assert(activeSplitPoint); - SplitPoint* sp = activeSplitPoint; - - Threads.mutex.unlock(); - - Stack stack[MAX_PLY+4], *ss = stack+2; // To allow referencing (ss-2) and (ss+2) - Position pos(*sp->pos, this); - - std::memcpy(ss-2, sp->ss-2, 5 * sizeof(Stack)); - ss->splitPoint = sp; - - sp->mutex.lock(); - - assert(activePosition == NULL); - - activePosition = &pos; - - if (sp->nodeType == NonPV) - search(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode); - - else if (sp->nodeType == PV) - search(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode); - - else if (sp->nodeType == Root) - search(pos, ss, sp->alpha, sp->beta, sp->depth, sp->cutNode); - - else - assert(false); - - assert(searching); - - searching = false; - activePosition = NULL; - sp->slavesMask.reset(idx); - sp->allSlavesSearching = false; - sp->nodes += pos.nodes_searched(); - - // Wake up the master thread so to allow it to return from the idle - // loop in case we are the last slave of the split point. - if ( this != sp->masterThread - && sp->slavesMask.none()) - { - assert(!sp->masterThread->searching); - sp->masterThread->notify_one(); - } - - // After releasing the lock we can't access any SplitPoint related data - // in a safe way because it could have been released under our feet by - // the sp master. - sp->mutex.unlock(); - - // Try to late join to another split point if none of its slaves has - // already finished. - if (Threads.size() > 2) - for (size_t i = 0; i < Threads.size(); ++i) - { - const int size = Threads[i]->splitPointsSize; // Local copy - sp = size ? &Threads[i]->splitPoints[size - 1] : NULL; - - if ( sp - && sp->allSlavesSearching - && available_to(Threads[i])) - { - // Recheck the conditions under lock protection - Threads.mutex.lock(); - sp->mutex.lock(); - - if ( sp->allSlavesSearching - && available_to(Threads[i])) - { - sp->slavesMask.set(idx); - activeSplitPoint = sp; - searching = true; - } - - sp->mutex.unlock(); - Threads.mutex.unlock(); - - break; // Just a single attempt - } - } - } - - // Grab the lock to avoid races with Thread::notify_one() - mutex.lock(); - - // If we are master and all slaves have finished then exit idle_loop - if (this_sp && this_sp->slavesMask.none()) - { - assert(!searching); - mutex.unlock(); - break; - } - - // If we are not searching, wait for a condition to be signaled instead of - // wasting CPU time polling for work. - if (!searching && !exit) - sleepCondition.wait(mutex); - - mutex.unlock(); - } + return false; } @@ -1643,12 +1542,12 @@ void Thread::idle_loop() { void check_time() { - static Time::point lastInfoTime = Time::now(); - Time::point elapsed = Time::now() - SearchTime; + static TimePoint lastInfoTime = now(); + int elapsed = Time.elapsed(); - if (Time::now() - lastInfoTime >= 1000) + if (now() - lastInfoTime >= 1000) { - lastInfoTime = Time::now(); + lastInfoTime = now(); dbg_print(); } @@ -1660,42 +1559,15 @@ void check_time() { { bool stillAtFirstMove = Signals.firstRootMove && !Signals.failedLowAtRoot - && elapsed > TimeMgr.available_time() * 75 / 100; + && elapsed > Time.available() * 75 / 100; if ( stillAtFirstMove - || elapsed > TimeMgr.maximum_time() - 2 * TimerThread::Resolution) + || elapsed > Time.maximum() - 2 * TimerThread::Resolution) Signals.stop = true; } else if (Limits.movetime && elapsed >= Limits.movetime) Signals.stop = true; - else if (Limits.nodes) - { - Threads.mutex.lock(); - - int64_t nodes = RootPos.nodes_searched(); - - // Loop across all split points and sum accumulated SplitPoint nodes plus - // all the currently active positions nodes. - for (size_t i = 0; i < Threads.size(); ++i) - for (int j = 0; j < Threads[i]->splitPointsSize; ++j) - { - SplitPoint& sp = Threads[i]->splitPoints[j]; - - sp.mutex.lock(); - - nodes += sp.nodes; - - for (size_t idx = 0; idx < Threads.size(); ++idx) - if (sp.slavesMask.test(idx) && Threads[idx]->activePosition) - nodes += Threads[idx]->activePosition->nodes_searched(); - - sp.mutex.unlock(); - } - - Threads.mutex.unlock(); - - if (nodes >= Limits.nodes) + else if (Limits.nodes && Threads.nodes_searched() >= Limits.nodes) Signals.stop = true; - } } diff --git a/DroidFish/jni/stockfish/search.h b/DroidFish/jni/stockfish/search.h index 5a0ad5d..c7abb9d 100644 --- a/DroidFish/jni/stockfish/search.h +++ b/DroidFish/jni/stockfish/search.h @@ -47,6 +47,7 @@ struct Stack { Depth reduction; Value staticEval; bool skipEarlyPruning; + int moveCount; }; /// RootMove struct is used for moves at the root of the tree. For each root move @@ -55,15 +56,15 @@ struct Stack { struct RootMove { - RootMove(Move m) : score(-VALUE_INFINITE), previousScore(-VALUE_INFINITE), pv(1, m) {} + explicit RootMove(Move m) : pv(1, m) {} bool operator<(const RootMove& m) const { return score > m.score; } // Ascending sort bool operator==(const Move& m) const { return pv[0] == m; } void insert_pv_in_tt(Position& pos); - Move extract_ponder_from_tt(Position& pos); + bool extract_ponder_from_tt(Position& pos); - Value score; - Value previousScore; + Value score = -VALUE_INFINITE; + Value previousScore = -VALUE_INFINITE; std::vector pv; }; @@ -76,7 +77,7 @@ typedef std::vector RootMoveVector; struct LimitsType { LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC - nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] = movestogo = + nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] = npmsec = movestogo = depth = movetime = mate = infinite = ponder = 0; } @@ -85,8 +86,9 @@ struct LimitsType { } std::vector searchmoves; - int time[COLOR_NB], inc[COLOR_NB], movestogo, depth, movetime, mate, infinite, ponder; + int time[COLOR_NB], inc[COLOR_NB], npmsec, movestogo, depth, movetime, mate, infinite, ponder; int64_t nodes; + TimePoint startTime; }; /// The SignalsType struct stores volatile flags updated during the search @@ -96,17 +98,14 @@ struct SignalsType { bool stop, stopOnPonderhit, firstRootMove, failedLowAtRoot; }; -typedef std::auto_ptr > StateStackPtr; +typedef std::unique_ptr> StateStackPtr; extern volatile SignalsType Signals; extern LimitsType Limits; -extern RootMoveVector RootMoves; -extern Position RootPos; -extern Time::point SearchTime; extern StateStackPtr SetupStates; void init(); -void think(); +void reset(); template uint64_t perft(Position& pos, Depth depth); } // namespace Search diff --git a/DroidFish/jni/stockfish/syzygy/tbprobe.cpp b/DroidFish/jni/stockfish/syzygy/tbprobe.cpp index 0abd2b2..7bce67e 100644 --- a/DroidFish/jni/stockfish/syzygy/tbprobe.cpp +++ b/DroidFish/jni/stockfish/syzygy/tbprobe.cpp @@ -7,6 +7,8 @@ this code to other chess engines. */ +#define NOMINMAX + #include #include "../position.h" @@ -367,7 +369,7 @@ static int probe_ab(Position& pos, int alpha, int beta, int *success) if (!pos.capture(capture) || type_of(capture) == ENPASSANT || !pos.legal(capture, ci.pinned)) continue; - pos.do_move(capture, st, ci, pos.gives_check(capture, ci)); + pos.do_move(capture, st, pos.gives_check(capture, ci)); v = -probe_ab(pos, -beta, -alpha, success); pos.undo_move(capture); if (*success == 0) return 0; @@ -430,7 +432,7 @@ int Tablebases::probe_wdl(Position& pos, int *success) if (type_of(capture) != ENPASSANT || !pos.legal(capture, ci.pinned)) continue; - pos.do_move(capture, st, ci, pos.gives_check(capture, ci)); + pos.do_move(capture, st, pos.gives_check(capture, ci)); int v0 = -probe_ab(pos, -2, 2, success); pos.undo_move(capture); if (*success == 0) return 0; @@ -493,7 +495,7 @@ static int probe_dtz_no_ep(Position& pos, int *success) if (type_of(pos.moved_piece(move)) != PAWN || pos.capture(move) || !pos.legal(move, ci.pinned)) continue; - pos.do_move(move, st, ci, pos.gives_check(move, ci)); + pos.do_move(move, st, pos.gives_check(move, ci)); int v = -probe_ab(pos, -2, -wdl + 1, success); pos.undo_move(move); if (*success == 0) return 0; @@ -515,7 +517,7 @@ static int probe_dtz_no_ep(Position& pos, int *success) if (pos.capture(move) || type_of(pos.moved_piece(move)) == PAWN || !pos.legal(move, ci.pinned)) continue; - pos.do_move(move, st, ci, pos.gives_check(move, ci)); + pos.do_move(move, st, pos.gives_check(move, ci)); int v = -Tablebases::probe_dtz(pos, success); pos.undo_move(move); if (*success == 0) return 0; @@ -534,7 +536,7 @@ static int probe_dtz_no_ep(Position& pos, int *success) Move move = moves->move; if (!pos.legal(move, ci.pinned)) continue; - pos.do_move(move, st, ci, pos.gives_check(move, ci)); + pos.do_move(move, st, pos.gives_check(move, ci)); if (st.rule50 == 0) { if (wdl == -2) v = -1; else { @@ -610,7 +612,7 @@ int Tablebases::probe_dtz(Position& pos, int *success) if (type_of(capture) != ENPASSANT || !pos.legal(capture, ci.pinned)) continue; - pos.do_move(capture, st, ci, pos.gives_check(capture, ci)); + pos.do_move(capture, st, pos.gives_check(capture, ci)); int v0 = -probe_ab(pos, -2, 2, success); pos.undo_move(capture); if (*success == 0) return 0; @@ -622,7 +624,7 @@ int Tablebases::probe_dtz(Position& pos, int *success) if (v1 >= 0) v = v1; } else if (v < 0) { - if (v1 >= 0 || v1 < 100) + if (v1 >= 0 || v1 < -100) v = v1; } else if (v > 100) { if (v1 > 0) @@ -700,7 +702,7 @@ bool Tablebases::root_probe(Position& pos, Search::RootMoveVector& rootMoves, Va // Probe each move. for (size_t i = 0; i < rootMoves.size(); i++) { Move move = rootMoves[i].pv[0]; - pos.do_move(move, st, ci, pos.gives_check(move, ci)); + pos.do_move(move, st, pos.gives_check(move, ci)); int v = 0; if (pos.checkers() && dtz > 0) { ExtMove s[192]; @@ -810,7 +812,7 @@ bool Tablebases::root_probe_wdl(Position& pos, Search::RootMoveVector& rootMoves // Probe each move. for (size_t i = 0; i < rootMoves.size(); i++) { Move move = rootMoves[i].pv[0]; - pos.do_move(move, st, ci, pos.gives_check(move, ci)); + pos.do_move(move, st, pos.gives_check(move, ci)); int v = -Tablebases::probe_wdl(pos, &success); pos.undo_move(move); if (!success) return false; diff --git a/DroidFish/jni/stockfish/thread.cpp b/DroidFish/jni/stockfish/thread.cpp index b8571dc..88b4592 100644 --- a/DroidFish/jni/stockfish/thread.cpp +++ b/DroidFish/jni/stockfish/thread.cpp @@ -33,20 +33,14 @@ extern void check_time(); namespace { - // start_routine() is the C function which is called when a new thread - // is launched. It is a wrapper to the virtual function idle_loop(). - - extern "C" { long start_routine(ThreadBase* th) { th->idle_loop(); return 0; } } - - // Helpers to launch a thread after creation and joining before delete. Must be // outside Thread c'tor and d'tor because the object must be fully initialized // when start_routine (and hence virtual idle_loop) is called and when joining. template T* new_thread() { - T* th = new T(); - thread_create(th->handle, start_routine, th); // Will go to sleep - return th; + std::thread* th = new T; + *th = std::thread(&T::idle_loop, (T*)th); // Will go to sleep + return (T*)th; } void delete_thread(ThreadBase* th) { @@ -56,7 +50,7 @@ namespace { th->mutex.unlock(); th->notify_one(); - thread_join(th->handle); // Wait for thread termination + th->join(); // Wait for thread termination delete th; } @@ -67,19 +61,26 @@ namespace { void ThreadBase::notify_one() { - mutex.lock(); + std::unique_lock lk(mutex); sleepCondition.notify_one(); - mutex.unlock(); } -// ThreadBase::wait_for() set the thread to sleep until 'condition' turns true +// ThreadBase::wait() set the thread to sleep until 'condition' turns true -void ThreadBase::wait_for(volatile const bool& condition) { +void ThreadBase::wait(volatile const bool& condition) { - mutex.lock(); - while (!condition) sleepCondition.wait(mutex); - mutex.unlock(); + std::unique_lock lk(mutex); + sleepCondition.wait(lk, [&]{ return condition; }); +} + + +// ThreadBase::wait_while() set the thread to sleep until 'condition' turns false + +void ThreadBase::wait_while(volatile const bool& condition) { + + std::unique_lock lk(mutex); + sleepCondition.wait(lk, [&]{ return !condition; }); } @@ -89,141 +90,11 @@ void ThreadBase::wait_for(volatile const bool& condition) { Thread::Thread() /* : splitPoints() */ { // Initialization of non POD broken in MSVC searching = false; - maxPly = splitPointsSize = 0; - activeSplitPoint = NULL; - activePosition = NULL; + maxPly = 0; idx = Threads.size(); // Starts from 0 } -// Thread::cutoff_occurred() checks whether a beta cutoff has occurred in the -// current active split point, or in some ancestor of the split point. - -bool Thread::cutoff_occurred() const { - - for (SplitPoint* sp = activeSplitPoint; sp; sp = sp->parentSplitPoint) - if (sp->cutoff) - return true; - - return false; -} - - -// Thread::available_to() checks whether the thread is available to help the -// thread 'master' at a split point. An obvious requirement is that thread must -// be idle. With more than two threads, this is not sufficient: If the thread is -// the master of some split point, it is only available as a slave to the slaves -// which are busy searching the split point at the top of slave's split point -// stack (the "helpful master concept" in YBWC terminology). - -bool Thread::available_to(const Thread* master) const { - - if (searching) - return false; - - // Make a local copy to be sure it doesn't become zero under our feet while - // testing next condition and so leading to an out of bounds access. - const int size = splitPointsSize; - - // No split points means that the thread is available as a slave for any - // other thread otherwise apply the "helpful master" concept if possible. - return !size || splitPoints[size - 1].slavesMask.test(master->idx); -} - - -// Thread::split() does the actual work of distributing the work at a node between -// several available threads. If it does not succeed in splitting the node -// (because no idle threads are available), the function immediately returns. -// If splitting is possible, a SplitPoint object is initialized with all the -// data that must be copied to the helper threads and then helper threads are -// informed that they have been assigned work. This will cause them to instantly -// leave their idle loops and call search(). When all threads have returned from -// search() then split() returns. - -void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bestValue, - Move* bestMove, Depth depth, int moveCount, - MovePicker* movePicker, int nodeType, bool cutNode) { - - assert(searching); - assert(-VALUE_INFINITE < *bestValue && *bestValue <= alpha && alpha < beta && beta <= VALUE_INFINITE); - assert(depth >= Threads.minimumSplitDepth); - assert(splitPointsSize < MAX_SPLITPOINTS_PER_THREAD); - - // Pick and init the next available split point - SplitPoint& sp = splitPoints[splitPointsSize]; - - sp.masterThread = this; - sp.parentSplitPoint = activeSplitPoint; - sp.slavesMask = 0, sp.slavesMask.set(idx); - sp.depth = depth; - sp.bestValue = *bestValue; - sp.bestMove = *bestMove; - sp.alpha = alpha; - sp.beta = beta; - sp.nodeType = nodeType; - sp.cutNode = cutNode; - sp.movePicker = movePicker; - sp.moveCount = moveCount; - sp.pos = &pos; - sp.nodes = 0; - sp.cutoff = false; - sp.ss = ss; - - // Try to allocate available threads and ask them to start searching setting - // 'searching' flag. This must be done under lock protection to avoid concurrent - // allocation of the same slave by another master. - Threads.mutex.lock(); - sp.mutex.lock(); - - sp.allSlavesSearching = true; // Must be set under lock protection - ++splitPointsSize; - activeSplitPoint = &sp; - activePosition = NULL; - - Thread* slave; - - while ((slave = Threads.available_slave(this)) != NULL) - { - sp.slavesMask.set(slave->idx); - slave->activeSplitPoint = &sp; - slave->searching = true; // Slave leaves idle_loop() - slave->notify_one(); // Could be sleeping - } - - // Everything is set up. The master thread enters the idle loop, from which - // it will instantly launch a search, because its 'searching' flag is set. - // The thread will return from the idle loop when all slaves have finished - // their work at this split point. - sp.mutex.unlock(); - Threads.mutex.unlock(); - - Thread::idle_loop(); // Force a call to base class idle_loop() - - // In the helpful master concept, a master can help only a sub-tree of its - // split point and because everything is finished here, it's not possible - // for the master to be booked. - assert(!searching); - assert(!activePosition); - - // We have returned from the idle loop, which means that all threads are - // finished. Note that setting 'searching' and decreasing splitPointsSize must - // be done under lock protection to avoid a race with Thread::available_to(). - Threads.mutex.lock(); - sp.mutex.lock(); - - searching = true; - --splitPointsSize; - activeSplitPoint = sp.parentSplitPoint; - activePosition = &pos; - pos.set_nodes_searched(pos.nodes_searched() + sp.nodes); - *bestMove = sp.bestMove; - *bestValue = sp.bestValue; - - sp.mutex.unlock(); - Threads.mutex.unlock(); -} - - // TimerThread::idle_loop() is where the timer thread waits Resolution milliseconds // and then calls check_time(). When not searching, thread sleeps until it's woken up. @@ -231,19 +102,38 @@ void TimerThread::idle_loop() { while (!exit) { - mutex.lock(); + std::unique_lock lk(mutex); if (!exit) - sleepCondition.wait_for(mutex, run ? Resolution : INT_MAX); + sleepCondition.wait_for(lk, std::chrono::milliseconds(run ? Resolution : INT_MAX)); - mutex.unlock(); + lk.unlock(); - if (run) + if (!exit && run) check_time(); } } +// Thread::idle_loop() is where the thread is parked when it has no work to do + +void Thread::idle_loop() { + + while (!exit) + { + std::unique_lock lk(mutex); + + while (!searching && !exit) + sleepCondition.wait(lk); + + lk.unlock(); + + if (!exit && searching) + search(); + } +} + + // MainThread::idle_loop() is where the main thread is parked waiting to be started // when there is a new search. The main thread will launch all the slave threads. @@ -251,32 +141,33 @@ void MainThread::idle_loop() { while (!exit) { - mutex.lock(); + std::unique_lock lk(mutex); thinking = false; while (!thinking && !exit) { - Threads.sleepCondition.notify_one(); // Wake up the UI thread if needed - sleepCondition.wait(mutex); + sleepCondition.notify_one(); // Wake up the UI thread if needed + sleepCondition.wait(lk); } - mutex.unlock(); + lk.unlock(); if (!exit) - { - searching = true; - - Search::think(); - - assert(searching); - - searching = false; - } + think(); } } +// MainThread::join() waits for main thread to finish thinking + +void MainThread::join() { + + std::unique_lock lk(mutex); + sleepCondition.wait(lk, [&]{ return !thinking; }); +} + + // ThreadPool::init() is called at startup to create and launch requested threads, // that will go immediately to sleep. We cannot use a c'tor because Threads is a // static object and we need a fully initialized engine at this point due to @@ -296,9 +187,12 @@ void ThreadPool::init() { void ThreadPool::exit() { delete_thread(timer); // As first because check_time() accesses threads data + timer = nullptr; - for (iterator it = begin(); it != end(); ++it) - delete_thread(*it); + for (Thread* th : *this) + delete_thread(th); + + clear(); // Get rid of stale pointers } @@ -310,15 +204,10 @@ void ThreadPool::exit() { void ThreadPool::read_uci_options() { - minimumSplitDepth = Options["Min Split Depth"] * ONE_PLY; size_t requested = Options["Threads"]; assert(requested > 0); - // If zero (default) then set best minimum split depth automatically - if (!minimumSplitDepth) - minimumSplitDepth = requested < 8 ? 4 * ONE_PLY : 7 * ONE_PLY; - while (size() < requested) push_back(new_thread()); @@ -330,27 +219,14 @@ void ThreadPool::read_uci_options() { } -// ThreadPool::available_slave() tries to find an idle thread which is available -// as a slave for the thread 'master'. +// ThreadPool::nodes_searched() returns the number of nodes searched -Thread* ThreadPool::available_slave(const Thread* master) const { +int64_t ThreadPool::nodes_searched() { - for (const_iterator it = begin(); it != end(); ++it) - if ((*it)->available_to(master)) - return *it; - - return NULL; -} - - -// ThreadPool::wait_for_think_finished() waits for main thread to finish the search - -void ThreadPool::wait_for_think_finished() { - - MainThread* th = main(); - th->mutex.lock(); - while (th->thinking) sleepCondition.wait(th->mutex); - th->mutex.unlock(); + int64_t nodes = 0; + for (Thread *th : *this) + nodes += th->rootPos.nodes_searched(); + return nodes; } @@ -359,27 +235,25 @@ void ThreadPool::wait_for_think_finished() { void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits, StateStackPtr& states) { - wait_for_think_finished(); - - SearchTime = Time::now(); // As early as possible + main()->join(); Signals.stopOnPonderhit = Signals.firstRootMove = false; Signals.stop = Signals.failedLowAtRoot = false; - RootMoves.clear(); - RootPos = pos; + main()->rootMoves.clear(); + main()->rootPos = pos; Limits = limits; if (states.get()) // If we don't set a new position, preserve current state { - SetupStates = states; // Ownership transfer here + SetupStates = std::move(states); // Ownership transfer here assert(!states.get()); } - for (MoveList it(pos); *it; ++it) + for (const auto& m : MoveList(pos)) if ( limits.searchmoves.empty() - || std::count(limits.searchmoves.begin(), limits.searchmoves.end(), *it)) - RootMoves.push_back(RootMove(*it)); + || std::count(limits.searchmoves.begin(), limits.searchmoves.end(), m)) + main()->rootMoves.push_back(RootMove(m)); main()->thinking = true; - main()->notify_one(); // Starts main thread + main()->notify_one(); // Wake up main thread: 'thinking' must be already set } diff --git a/DroidFish/jni/stockfish/thread.h b/DroidFish/jni/stockfish/thread.h index 9750ed7..97ed219 100644 --- a/DroidFish/jni/stockfish/thread.h +++ b/DroidFish/jni/stockfish/thread.h @@ -20,7 +20,11 @@ #ifndef THREAD_H_INCLUDED #define THREAD_H_INCLUDED +#include #include +#include +#include +#include #include #include "material.h" @@ -28,87 +32,27 @@ #include "pawns.h" #include "position.h" #include "search.h" +#include "thread_win32.h" struct Thread; -const int MAX_THREADS = 128; -const int MAX_SPLITPOINTS_PER_THREAD = 8; - -/// Mutex and ConditionVariable struct are wrappers of the low level locking -/// machinery and are modeled after the corresponding C++11 classes. - -struct Mutex { - Mutex() { lock_init(l); } - ~Mutex() { lock_destroy(l); } - - void lock() { lock_grab(l); } - void unlock() { lock_release(l); } - -private: - friend struct ConditionVariable; - - Lock l; -}; - -struct ConditionVariable { - ConditionVariable() { cond_init(c); } - ~ConditionVariable() { cond_destroy(c); } - - void wait(Mutex& m) { cond_wait(c, m.l); } - void wait_for(Mutex& m, int ms) { timed_wait(c, m.l, ms); } - void notify_one() { cond_signal(c); } - -private: - WaitCondition c; -}; - - -/// SplitPoint struct stores information shared by the threads searching in -/// parallel below the same split point. It is populated at splitting time. - -struct SplitPoint { - - // Const data after split point has been setup - const Position* pos; - Search::Stack* ss; - Thread* masterThread; - Depth depth; - Value beta; - int nodeType; - bool cutNode; - - // Const pointers to shared data - MovePicker* movePicker; - SplitPoint* parentSplitPoint; - - // Shared variable data - Mutex mutex; - std::bitset slavesMask; - volatile bool allSlavesSearching; - volatile uint64_t nodes; - volatile Value alpha; - volatile Value bestValue; - volatile Move bestMove; - volatile int moveCount; - volatile bool cutoff; -}; +const size_t MAX_THREADS = 128; /// ThreadBase struct is the base of the hierarchy from where we derive all the /// specialized thread classes. -struct ThreadBase { +struct ThreadBase : public std::thread { - ThreadBase() : handle(NativeHandle()), exit(false) {} - virtual ~ThreadBase() {} + virtual ~ThreadBase() = default; virtual void idle_loop() = 0; void notify_one(); - void wait_for(volatile const bool& b); + void wait(volatile const bool& b); + void wait_while(volatile const bool& b); Mutex mutex; ConditionVariable sleepCondition; - NativeHandle handle; - volatile bool exit; + volatile bool exit = false; }; @@ -121,22 +65,21 @@ struct Thread : public ThreadBase { Thread(); virtual void idle_loop(); - bool cutoff_occurred() const; - bool available_to(const Thread* master) const; + void search(bool isMainThread = false); - void split(Position& pos, Search::Stack* ss, Value alpha, Value beta, Value* bestValue, Move* bestMove, - Depth depth, int moveCount, MovePicker* movePicker, int nodeType, bool cutNode); - - SplitPoint splitPoints[MAX_SPLITPOINTS_PER_THREAD]; Pawns::Table pawnsTable; Material::Table materialTable; Endgames endgames; - Position* activePosition; - size_t idx; + size_t idx, PVIdx; int maxPly; - SplitPoint* volatile activeSplitPoint; - volatile int splitPointsSize; volatile bool searching; + + Position rootPos; + Search::RootMoveVector rootMoves; + Search::Stack stack[MAX_PLY+4]; + HistoryStats History; + MovesStats Countermoves; + Depth depth; }; @@ -144,19 +87,19 @@ struct Thread : public ThreadBase { /// special threads: the main one and the recurring timer. struct MainThread : public Thread { - MainThread() : thinking(true) {} // Avoid a race with start_thinking() virtual void idle_loop(); - volatile bool thinking; + void join(); + void think(); + volatile bool thinking = true; // Avoid a race with start_thinking() }; struct TimerThread : public ThreadBase { static const int Resolution = 5; // Millisec between two check_time() calls - TimerThread() : run(false) {} virtual void idle_loop(); - bool run; + bool run = false; }; @@ -171,13 +114,8 @@ struct ThreadPool : public std::vector { MainThread* main() { return static_cast(at(0)); } void read_uci_options(); - Thread* available_slave(const Thread* master) const; - void wait_for_think_finished(); void start_thinking(const Position&, const Search::LimitsType&, Search::StateStackPtr&); - - Depth minimumSplitDepth; - Mutex mutex; - ConditionVariable sleepCondition; + int64_t nodes_searched(); TimerThread* timer; }; diff --git a/DroidFish/jni/stockfish/thread_win32.h b/DroidFish/jni/stockfish/thread_win32.h new file mode 100644 index 0000000..28c899d --- /dev/null +++ b/DroidFish/jni/stockfish/thread_win32.h @@ -0,0 +1,69 @@ +/* + Stockfish, a UCI chess playing engine derived from Glaurung 2.1 + Copyright (C) 2004-2008 Tord Romstad (Glaurung author) + Copyright (C) 2008-2015 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 + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + 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 . +*/ + +#ifndef THREAD_WIN32_H_INCLUDED +#define THREAD_WIN32_H_INCLUDED + +/// STL thread library used by mingw and gcc when cross compiling for Windows +/// relies on libwinpthread. Currently libwinpthread implements mutexes directly +/// on top of Windows semaphores. Semaphores, being kernel objects, require kernel +/// mode transition in order to lock or unlock, which is very slow compared to +/// interlocked operations (about 30% slower on bench test). To workaround this +/// issue, we define our wrappers to the low level Win32 calls. We use critical +/// sections to support Windows XP and older versions. Unfortunately, cond_wait() +/// is racy between unlock() and WaitForSingleObject() but they have the same +/// speed performance of SRW locks. + +#include +#include + +#if defined(_WIN32) && !defined(_MSC_VER) + +#ifndef NOMINMAX +# define NOMINMAX // Disable macros min() and max() +#endif + +#define WIN32_LEAN_AND_MEAN +#include +#undef WIN32_LEAN_AND_MEAN +#undef NOMINMAX + +/// Mutex and ConditionVariable struct are wrappers of the low level locking +/// machinery and are modeled after the corresponding C++11 classes. + +struct Mutex { + Mutex() { InitializeCriticalSection(&cs); } + ~Mutex() { DeleteCriticalSection(&cs); } + void lock() { EnterCriticalSection(&cs); } + void unlock() { LeaveCriticalSection(&cs); } + +private: + CRITICAL_SECTION cs; +}; + +typedef std::condition_variable_any ConditionVariable; + +#else // Default case: use STL classes + +typedef std::mutex Mutex; +typedef std::condition_variable ConditionVariable; + +#endif + +#endif // #ifndef THREAD_WIN32_H_INCLUDED diff --git a/DroidFish/jni/stockfish/timeman.cpp b/DroidFish/jni/stockfish/timeman.cpp index 04730ab..3a4e157 100644 --- a/DroidFish/jni/stockfish/timeman.cpp +++ b/DroidFish/jni/stockfish/timeman.cpp @@ -25,6 +25,8 @@ #include "timeman.h" #include "uci.h" +TimeManagement Time; // Our global time management object + namespace { enum TimeType { OptimumTime, MaxTime }; @@ -78,15 +80,31 @@ namespace { /// inc > 0 && movestogo == 0 means: x basetime + z increment /// inc > 0 && movestogo != 0 means: x moves in y minutes + z increment -void TimeManager::init(const Search::LimitsType& limits, Color us, int ply) +void TimeManagement::init(Search::LimitsType& limits, Color us, int ply) { int minThinkingTime = Options["Minimum Thinking Time"]; int moveOverhead = Options["Move Overhead"]; int slowMover = Options["Slow Mover"]; + int npmsec = Options["nodestime"]; - // Initialize unstablePvFactor to 1 and search times to maximum values + // If we have to play in 'nodes as time' mode, then convert from time + // to nodes, and use resulting values in time management formulas. + // WARNING: Given npms (nodes per millisecond) must be much lower then + // real engine speed to avoid time losses. + if (npmsec) + { + if (!availableNodes) // Only once at game start + availableNodes = npmsec * limits.time[us]; // Time is in msec + + // Convert from millisecs to nodes + limits.time[us] = (int)availableNodes; + limits.inc[us] *= npmsec; + limits.npmsec = npmsec; + } + + startTime = limits.startTime; unstablePvFactor = 1; - optimumSearchTime = maximumSearchTime = std::max(limits.time[us], minThinkingTime); + optimumTime = maximumTime = std::max(limits.time[us], minThinkingTime); const int MaxMTG = limits.movestogo ? std::min(limits.movestogo, MoveHorizon) : MoveHorizon; @@ -105,12 +123,12 @@ void TimeManager::init(const Search::LimitsType& limits, Color us, int ply) int t1 = minThinkingTime + remaining(hypMyTime, hypMTG, ply, slowMover); int t2 = minThinkingTime + remaining(hypMyTime, hypMTG, ply, slowMover); - optimumSearchTime = std::min(t1, optimumSearchTime); - maximumSearchTime = std::min(t2, maximumSearchTime); + optimumTime = std::min(t1, optimumTime); + maximumTime = std::min(t2, maximumTime); } if (Options["Ponder"]) - optimumSearchTime += optimumSearchTime / 4; + optimumTime += optimumTime / 4; - optimumSearchTime = std::min(optimumSearchTime, maximumSearchTime); + optimumTime = std::min(optimumTime, maximumTime); } diff --git a/DroidFish/jni/stockfish/timeman.h b/DroidFish/jni/stockfish/timeman.h index b904e1c..b6eb348 100644 --- a/DroidFish/jni/stockfish/timeman.h +++ b/DroidFish/jni/stockfish/timeman.h @@ -20,20 +20,30 @@ #ifndef TIMEMAN_H_INCLUDED #define TIMEMAN_H_INCLUDED -/// The TimeManager class computes the optimal time to think depending on the -/// maximum available time, the game move number and other parameters. +#include "misc.h" +#include "search.h" +#include "thread.h" -class TimeManager { +/// The TimeManagement class computes the optimal time to think depending on +/// the maximum available time, the game move number and other parameters. + +class TimeManagement { public: - void init(const Search::LimitsType& limits, Color us, int ply); + void init(Search::LimitsType& limits, Color us, int ply); void pv_instability(double bestMoveChanges) { unstablePvFactor = 1 + bestMoveChanges; } - int available_time() const { return int(optimumSearchTime * unstablePvFactor * 0.71); } - int maximum_time() const { return maximumSearchTime; } + int available() const { return int(optimumTime * unstablePvFactor * 0.76); } + int maximum() const { return maximumTime; } + int elapsed() const { return int(Search::Limits.npmsec ? Threads.nodes_searched() : now() - startTime); } + + int64_t availableNodes; // When in 'nodes as time' mode private: - int optimumSearchTime; - int maximumSearchTime; + TimePoint startTime; + int optimumTime; + int maximumTime; double unstablePvFactor; }; +extern TimeManagement Time; + #endif // #ifndef TIMEMAN_H_INCLUDED diff --git a/DroidFish/jni/stockfish/tt.cpp b/DroidFish/jni/stockfish/tt.cpp index 66113ee..0c77d6b 100644 --- a/DroidFish/jni/stockfish/tt.cpp +++ b/DroidFish/jni/stockfish/tt.cpp @@ -32,8 +32,6 @@ TranspositionTable TT; // Our global transposition table void TranspositionTable::resize(size_t mbSize) { - assert(sizeof(Cluster) == CacheLineSize / 2); - size_t newClusterCount = size_t(1) << msb((mbSize * 1024 * 1024) / sizeof(Cluster)); if (newClusterCount == clusterCount) @@ -68,9 +66,9 @@ void TranspositionTable::clear() { /// TranspositionTable::probe() looks up the current position in the transposition /// table. It returns true and a pointer to the TTEntry if the position is found. /// Otherwise, it returns false and a pointer to an empty or least valuable TTEntry -/// to be replaced later. A TTEntry t1 is considered to be more valuable than a -/// TTEntry t2 if t1 is from the current search and t2 is from a previous search, -/// or if the depth of t1 is bigger than the depth of t2. +/// to be replaced later. The replace value of an entry is calculated as its depth +/// minus 8 times its relative age. TTEntry t1 is considered more valuable than +/// TTEntry t2 if its replace value is greater than that of t2. TTEntry* TranspositionTable::probe(const Key key, bool& found) const { @@ -80,7 +78,7 @@ TTEntry* TranspositionTable::probe(const Key key, bool& found) const { for (int i = 0; i < ClusterSize; ++i) if (!tte[i].key16 || tte[i].key16 == key16) { - if (tte[i].key16) + if ((tte[i].genBound8 & 0xFC) != generation8 && tte[i].key16) tte[i].genBound8 = uint8_t(generation8 | tte[i].bound()); // Refresh return found = (bool)tte[i].key16, &tte[i]; @@ -89,10 +87,30 @@ TTEntry* TranspositionTable::probe(const Key key, bool& found) const { // Find an entry to be replaced according to the replacement strategy TTEntry* replace = tte; for (int i = 1; i < ClusterSize; ++i) - if ( (( tte[i].genBound8 & 0xFC) == generation8 || tte[i].bound() == BOUND_EXACT) - - ((replace->genBound8 & 0xFC) == generation8) - - (tte[i].depth8 < replace->depth8) < 0) + // Due to our packed storage format for generation and its cyclic + // nature we add 259 (256 is the modulus plus 3 to keep the lowest + // two bound bits from affecting the result) to calculate the entry + // age correctly even after generation8 overflows into the next cycle. + if ( replace->depth8 - ((259 + generation8 - replace->genBound8) & 0xFC) * 2 * ONE_PLY + > tte[i].depth8 - ((259 + generation8 - tte[i].genBound8) & 0xFC) * 2 * ONE_PLY) replace = &tte[i]; return found = false, replace; } + + +/// Returns an approximation of the hashtable occupation during a search. The +/// hash is x permill full, as per UCI protocol. + +int TranspositionTable::hashfull() const +{ + int cnt = 0; + for (int i = 0; i < 1000 / ClusterSize; i++) + { + const TTEntry* tte = &table[i].entry[0]; + for (int j = 0; j < ClusterSize; j++) + if ((tte[j].genBound8 & 0xFC) == generation8) + cnt++; + } + return cnt; +} diff --git a/DroidFish/jni/stockfish/tt.h b/DroidFish/jni/stockfish/tt.h index 4df015c..a983805 100644 --- a/DroidFish/jni/stockfish/tt.h +++ b/DroidFish/jni/stockfish/tt.h @@ -43,14 +43,22 @@ struct TTEntry { void save(Key k, Value v, Bound b, Depth d, Move m, Value ev, uint8_t g) { - if (m || (k >> 48) != key16) // Preserve any existing move for the same position + // Preserve any existing move for the same position + if (m || (k >> 48) != key16) move16 = (uint16_t)m; - key16 = (uint16_t)(k >> 48); - value16 = (int16_t)v; - eval16 = (int16_t)ev; - genBound8 = (uint8_t)(g | b); - depth8 = (int8_t)d; + // Don't overwrite more valuable entries + if ( (k >> 48) != key16 + || d > depth8 - 2 + /* || g != (genBound8 & 0xFC) // Matching non-zero keys are already refreshed by probe() */ + || b == BOUND_EXACT) + { + key16 = (uint16_t)(k >> 48); + value16 = (int16_t)v; + eval16 = (int16_t)ev; + genBound8 = (uint8_t)(g | b); + depth8 = (int8_t)d; + } } private: @@ -81,11 +89,14 @@ class TranspositionTable { char padding[2]; // Align to the cache line size }; + static_assert(sizeof(Cluster) == CacheLineSize / 2, "Cluster size incorrect"); + public: ~TranspositionTable() { free(mem); } void new_search() { generation8 += 4; } // Lower 2 bits are used by Bound uint8_t generation() const { return generation8; } TTEntry* probe(const Key key, bool& found) const; + int hashfull() const; void resize(size_t mbSize); void clear(); diff --git a/DroidFish/jni/stockfish/types.h b/DroidFish/jni/stockfish/types.h index 7c5776a..772f0ec 100644 --- a/DroidFish/jni/stockfish/types.h +++ b/DroidFish/jni/stockfish/types.h @@ -33,13 +33,22 @@ /// /// -DUSE_POPCNT | Add runtime support for use of popcnt asm-instruction. Works /// | only in 64-bit mode and requires hardware with popcnt support. +/// +/// -DUSE_PEXT | Add runtime support for use of pext asm-instruction. Works +/// | only in 64-bit mode and requires hardware with pext support. #include #include #include +#include #include -#include "platform.h" +#if defined(_MSC_VER) +// Disable some silly and noisy warning from MSVC compiler +#pragma warning(disable: 4127) // Conditional expression is constant +#pragma warning(disable: 4146) // Unary minus operator applied to unsigned type +#pragma warning(disable: 4800) // Forcing value to bool 'true' or 'false' +#endif /// Predefined macros hell: /// @@ -49,7 +58,7 @@ /// _WIN32 Building on Windows (any) /// _WIN64 Building on Windows 64 bit -#if defined(_WIN64) && !defined(IS_64BIT) // Last condition means Makefile is not used +#if defined(_WIN64) && defined(_MSC_VER) // No Makefile used # include // MSVC popcnt and bsfq instrinsics # define IS_64BIT # define USE_BSFQ @@ -70,14 +79,6 @@ # define pext(b, m) (0) #endif -#ifdef _MSC_VER -# define FORCE_INLINE __forceinline -#elif defined(__GNUC__) -# define FORCE_INLINE inline __attribute__((always_inline)) -#else -# define FORCE_INLINE inline -#endif - #ifdef USE_POPCNT const bool HasPopCnt = true; #else @@ -171,7 +172,7 @@ enum Bound { BOUND_EXACT = BOUND_UPPER | BOUND_LOWER }; -enum Value { +enum Value : int { VALUE_ZERO = 0, VALUE_DRAW = 0, VALUE_KNOWN_WIN = 10000, @@ -182,13 +183,10 @@ enum Value { VALUE_MATE_IN_MAX_PLY = VALUE_MATE - 2 * MAX_PLY, VALUE_MATED_IN_MAX_PLY = -VALUE_MATE + 2 * MAX_PLY, - VALUE_ENSURE_INTEGER_SIZE_P = INT_MAX, - VALUE_ENSURE_INTEGER_SIZE_N = INT_MIN, - PawnValueMg = 198, PawnValueEg = 258, KnightValueMg = 817, KnightValueEg = 846, BishopValueMg = 836, BishopValueEg = 857, - RookValueMg = 1270, RookValueEg = 1278, + RookValueMg = 1270, RookValueEg = 1281, QueenValueMg = 2521, QueenValueEg = 2558, MidgameLimit = 15581, EndgameLimit = 3998 @@ -255,16 +253,10 @@ enum Rank { }; -/// Score enum stores a middlegame and an endgame value in a single integer. -/// The least significant 16 bits are used to store the endgame value and -/// the upper 16 bits are used to store the middlegame value. The compiler -/// is free to choose the enum type as long as it can store the data, so we -/// ensure that Score is an integer type by assigning some big int values. -enum Score { - SCORE_ZERO, - SCORE_ENSURE_INTEGER_SIZE_P = INT_MAX, - SCORE_ENSURE_INTEGER_SIZE_N = INT_MIN -}; +/// Score enum stores a middlegame and an endgame value in a single integer +/// (enum). The least significant 16 bits are used to store the endgame value +/// and the upper 16 bits are used to store the middlegame value. +enum Score : int { SCORE_ZERO }; inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); @@ -417,7 +409,7 @@ inline MoveType type_of(Move m) { } inline PieceType promotion_type(Move m) { - return PieceType(((m >> 12) & 3) + 2); + return PieceType(((m >> 12) & 3) + KNIGHT); } inline Move make_move(Square from, Square to) { diff --git a/DroidFish/jni/stockfish/uci.cpp b/DroidFish/jni/stockfish/uci.cpp index 1b91b45..c5dbafa 100644 --- a/DroidFish/jni/stockfish/uci.cpp +++ b/DroidFish/jni/stockfish/uci.cpp @@ -26,7 +26,7 @@ #include "position.h" #include "search.h" #include "thread.h" -#include "tt.h" +#include "timeman.h" #include "uci.h" using namespace std; @@ -68,13 +68,13 @@ namespace { return; pos.set(fen, Options["UCI_Chess960"], Threads.main()); - SetupStates = Search::StateStackPtr(new std::stack()); + SetupStates = Search::StateStackPtr(new std::stack); // Parse move list (if any) while (is >> token && (m = UCI::to_move(pos, token)) != MOVE_NONE) { SetupStates->push(StateInfo()); - pos.do_move(m, SetupStates->top()); + pos.do_move(m, SetupStates->top(), pos.gives_check(m, CheckInfo(pos))); } } @@ -90,11 +90,11 @@ namespace { // Read option name (can contain spaces) while (is >> token && token != "value") - name += string(" ", !name.empty()) + token; + name += string(" ", name.empty() ? 0 : 1) + token; // Read option value (can contain spaces) while (is >> token) - value += string(" ", !value.empty()) + token; + value += string(" ", value.empty() ? 0 : 1) + token; if (Options.count(name)) Options[name] = value; @@ -112,6 +112,8 @@ namespace { Search::LimitsType limits; string token; + limits.startTime = now(); // As early as possible! + while (is >> token) if (token == "searchmoves") while (is >> token) @@ -126,8 +128,8 @@ namespace { else if (token == "nodes") is >> limits.nodes; else if (token == "movetime") is >> limits.movetime; else if (token == "mate") is >> limits.mate; - else if (token == "infinite") limits.infinite = true; - else if (token == "ponder") limits.ponder = true; + else if (token == "infinite") limits.infinite = 1; + else if (token == "ponder") limits.ponder = 1; Threads.start_thinking(pos, limits, SetupStates); } @@ -171,15 +173,19 @@ void UCI::loop(int argc, char* argv[]) { Threads.main()->notify_one(); // Could be sleeping } else if (token == "ponderhit") - Search::Limits.ponder = false; // Switch to normal search + Search::Limits.ponder = 0; // Switch to normal search else if (token == "uci") sync_cout << "id name " << engine_info(true) << "\n" << Options << "\nuciok" << sync_endl; + else if (token == "ucinewgame") + { + Search::reset(); + Time.availableNodes = 0; + } else if (token == "isready") sync_cout << "readyok" << sync_endl; - else if (token == "ucinewgame") TT.clear(); else if (token == "go") go(pos, is); else if (token == "position") position(pos, is); else if (token == "setoption") setoption(is); @@ -205,7 +211,7 @@ void UCI::loop(int argc, char* argv[]) { } while (token != "quit" && argc == 1); // Passed args have one-shot behaviour - Threads.wait_for_think_finished(); // Cannot quit whilst the search is running + Threads.main()->join(); // Cannot quit whilst the search is running } @@ -232,9 +238,7 @@ string UCI::value(Value v) { /// UCI::square() converts a Square to a string in algebraic notation (g1, a7, etc.) std::string UCI::square(Square s) { - - char sq[] = { char('a' + file_of(s)), char('1' + rank_of(s)), 0 }; // NULL terminated - return sq; + return std::string{ char('a' + file_of(s)), char('1' + rank_of(s)) }; } @@ -274,9 +278,9 @@ Move UCI::to_move(const Position& pos, string& str) { if (str.length() == 5) // Junior could send promotion piece in uppercase str[4] = char(tolower(str[4])); - for (MoveList it(pos); *it; ++it) - if (str == UCI::move(*it, pos.is_chess960())) - return *it; + for (const auto& m : MoveList(pos)) + if (str == UCI::move(m, pos.is_chess960())) + return m; return MOVE_NONE; } diff --git a/DroidFish/jni/stockfish/uci.h b/DroidFish/jni/stockfish/uci.h index b928e8a..eb0353a 100644 --- a/DroidFish/jni/stockfish/uci.h +++ b/DroidFish/jni/stockfish/uci.h @@ -17,8 +17,8 @@ along with this program. If not, see . */ -#ifndef UCIOPTION_H_INCLUDED -#define UCIOPTION_H_INCLUDED +#ifndef UCI_H_INCLUDED +#define UCI_H_INCLUDED #include #include @@ -45,10 +45,10 @@ class Option { typedef void (*OnChange)(const Option&); public: - Option(OnChange = NULL); - Option(bool v, OnChange = NULL); - Option(const char* v, OnChange = NULL); - Option(int v, int min, int max, OnChange = NULL); + Option(OnChange = nullptr); + Option(bool v, OnChange = nullptr); + Option(const char* v, OnChange = nullptr); + Option(int v, int min, int max, OnChange = nullptr); Option& operator=(const std::string&); void operator<<(const Option&); @@ -69,10 +69,11 @@ void loop(int argc, char* argv[]); std::string value(Value v); std::string square(Square s); std::string move(Move m, bool chess960); +std::string pv(const Position& pos, Depth depth, Value alpha, Value beta); Move to_move(const Position& pos, std::string& str); } // namespace UCI extern UCI::OptionsMap Options; -#endif // #ifndef UCIOPTION_H_INCLUDED +#endif // #ifndef UCI_H_INCLUDED diff --git a/DroidFish/jni/stockfish/ucioption.cpp b/DroidFish/jni/stockfish/ucioption.cpp index 1778c71..f35cea4 100644 --- a/DroidFish/jni/stockfish/ucioption.cpp +++ b/DroidFish/jni/stockfish/ucioption.cpp @@ -19,10 +19,10 @@ #include #include -#include -#include +#include #include "misc.h" +#include "search.h" #include "thread.h" #include "tt.h" #include "uci.h" @@ -35,7 +35,7 @@ UCI::OptionsMap Options; // Global object namespace UCI { /// 'On change' actions, triggered by an option's value change -void on_clear_hash(const Option&) { TT.clear(); } +void on_clear_hash(const Option&) { Search::reset(); } void on_hash_size(const Option& o) { TT.resize(o); } void on_logger(const Option& o) { start_logger(o); } void on_threads(const Option&) { Threads.read_uci_options(); } @@ -43,10 +43,10 @@ void on_tb_path(const Option& o) { Tablebases::init(o); } /// Our case insensitive less() function as required by UCI protocol -bool ci_less(char c1, char c2) { return tolower(c1) < tolower(c2); } - bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const { - return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(), ci_less); + + return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(), + [](char c1, char c2) { return tolower(c1) < tolower(c2); }); } @@ -58,7 +58,7 @@ void init(OptionsMap& o) { o["Write Debug Log"] << Option(false, on_logger); o["Contempt"] << Option(0, -100, 100); - o["Min Split Depth"] << Option(0, 0, 12, on_threads); + o["Min Split Depth"] << Option(5, 0, 12, on_threads); o["Threads"] << Option(1, 1, MAX_THREADS, on_threads); o["Hash"] << Option(16, 1, MaxHashMB, on_hash_size); o["Clear Hash"] << Option(on_clear_hash); @@ -68,6 +68,7 @@ void init(OptionsMap& o) { o["Move Overhead"] << Option(30, 0, 5000); o["Minimum Thinking Time"] << Option(20, 0, 5000); o["Slow Mover"] << Option(80, 10, 1000); + o["nodestime"] << Option(0, 0, 10000); o["UCI_Chess960"] << Option(false); o["SyzygyPath"] << Option("", on_tb_path); o["SyzygyProbeDepth"] << Option(1, 1, 100); @@ -82,11 +83,11 @@ void init(OptionsMap& o) { std::ostream& operator<<(std::ostream& os, const OptionsMap& om) { for (size_t idx = 0; idx < om.size(); ++idx) - for (OptionsMap::const_iterator it = om.begin(); it != om.end(); ++it) - if (it->second.idx == idx) + for (const auto& it : om) + if (it.second.idx == idx) { - const Option& o = it->second; - os << "\noption name " << it->first << " type " << o.type; + const Option& o = it.second; + os << "\noption name " << it.first << " type " << o.type; if (o.type != "button") os << " default " << o.defaultValue; @@ -96,6 +97,7 @@ std::ostream& operator<<(std::ostream& os, const OptionsMap& om) { break; } + return os; } @@ -112,12 +114,11 @@ Option::Option(OnChange f) : type("button"), min(0), max(0), on_change(f) {} Option::Option(int v, int minv, int maxv, OnChange f) : type("spin"), min(minv), max(maxv), on_change(f) -{ std::ostringstream ss; ss << v; defaultValue = currentValue = ss.str(); } - +{ defaultValue = currentValue = to_string(v); } Option::operator int() const { assert(type == "check" || type == "spin"); - return (type == "spin" ? atoi(currentValue.c_str()) : currentValue == "true"); + return (type == "spin" ? stoi(currentValue) : currentValue == "true"); } Option::operator std::string() const { @@ -147,7 +148,7 @@ Option& Option::operator=(const string& v) { if ( (type != "button" && v.empty()) || (type == "check" && v != "true" && v != "false") - || (type == "spin" && (atoi(v.c_str()) < min || atoi(v.c_str()) > max))) + || (type == "spin" && (stoi(v) < min || stoi(v) > max))) return *this; if (type != "button")