namespace Stockfish {
-// setup_bench() builds a list of UCI commands to be run by bench. There
+// Builds a list of UCI commands to be run by bench. There
// are five parameters: TT size in MB, number of search threads that
// should be used, the limit value spent for each position, a file name
// where to look for positions in FEN format, and the type of the limit:
// bench 64 1 100000 default nodes : search default positions for 100K nodes each
// bench 64 4 5000 current movetime : search current position with 4 threads for 5 sec
// bench 16 1 5 blah perft : run a perft 5 on positions in file "blah"
-
std::vector<std::string> setup_bench(const Position& current, std::istream& is) {
std::vector<std::string> fens, list;
}
-// safe_destination() returns the bitboard of target square for the given step
+// Returns the bitboard of target square for the given step
// from the given square. If the step is off the board, returns empty bitboard.
-
inline Bitboard safe_destination(Square s, int step) {
Square to = Square(s + step);
return is_ok(to) && distance(s, to) <= 2 ? square_bb(to) : Bitboard(0);
}
-// Bitboards::pretty() returns an ASCII representation of a bitboard suitable
+// Returns an ASCII representation of a bitboard suitable
// to be printed to standard output. Useful for debugging.
-
std::string Bitboards::pretty(Bitboard b) {
std::string s = "+---+---+---+---+---+---+---+---+\n";
}
-// Bitboards::init() initializes various bitboard tables. It is called at
+// Initializes various bitboard tables. It is called at
// startup and relies on global objects to be already zero-initialized.
-
void Bitboards::init() {
for (unsigned i = 0; i < (1 << 16); ++i)
}
-// init_magics() computes all rook and bishop attacks at startup. Magic
+// Computes all rook and bishop attacks at startup. Magic
// bitboards are used to look up attacks of sliding pieces. As a reference see
// www.chessprogramming.org/Magic_Bitboards. In particular, here we use the so
// called "fancy" approach.
-
void init_magics(PieceType pt, Bitboard table[], Magic magics[]) {
// Optimal PRNG seeds to pick the correct magics in the shortest time
constexpr Bitboard file_bb(Square s) { return file_bb(file_of(s)); }
-// shift() moves a bitboard one or two steps as specified by the direction D
-
+// Moves a bitboard one or two steps as specified by the direction D
template<Direction D>
constexpr Bitboard shift(Bitboard b) {
return D == NORTH ? b << 8
}
-// pawn_attacks_bb() returns the squares attacked by pawns of the given color
+// Returns the squares attacked by pawns of the given color
// from the squares in the given bitboard.
-
template<Color C>
constexpr Bitboard pawn_attacks_bb(Bitboard b) {
return C == WHITE ? shift<NORTH_WEST>(b) | shift<NORTH_EAST>(b)
return PawnAttacks[c][s];
}
-// line_bb() returns a bitboard representing an entire line (from board edge
+// Returns a bitboard representing an entire line (from board edge
// to board edge) that intersects the two given squares. If the given squares
// are not on a same file/rank/diagonal, the function returns 0. For instance,
// line_bb(SQ_C4, SQ_F7) will return a bitboard with the A2-G8 diagonal.
-
inline Bitboard line_bb(Square s1, Square s2) {
assert(is_ok(s1) && is_ok(s2));
}
-// between_bb(s1, s2) returns a bitboard representing the squares in the semi-open
+// Returns a bitboard representing the squares in the semi-open
// segment between the squares s1 and s2 (excluding s1 but including s2). If the
// given squares are not on a same file/rank/diagonal, it returns s2. For instance,
// between_bb(SQ_C4, SQ_F7) will return a bitboard with squares D5, E6 and F7, but
// between_bb(SQ_E6, SQ_F8) will return a bitboard with the square F8. This trick
// allows to generate non-king evasion moves faster: the defending piece must either
// interpose itself to cover the check or capture the checking piece.
-
inline Bitboard between_bb(Square s1, Square s2) {
assert(is_ok(s1) && is_ok(s2));
return BetweenBB[s1][s2];
}
-// aligned() returns true if the squares s1, s2 and s3 are aligned either on a
+// Returns true if the squares s1, s2 and s3 are aligned either on a
// straight or on a diagonal line.
-
inline bool aligned(Square s1, Square s2, Square s3) { return line_bb(s1, s2) & s3; }
template<typename T1 = Square>
inline int distance(Square x, Square y);
+
template<>
inline int distance<File>(Square x, Square y) {
return std::abs(file_of(x) - file_of(y));
}
+
template<>
inline int distance<Rank>(Square x, Square y) {
return std::abs(rank_of(x) - rank_of(y));
}
+
template<>
inline int distance<Square>(Square x, Square y) {
return SquareDistance[x][y];
inline int edge_distance(File f) { return std::min(f, File(FILE_H - f)); }
-// attacks_bb(Square) returns the pseudo attacks of the given piece type
+// Returns the pseudo attacks of the given piece type
// assuming an empty board.
-
template<PieceType Pt>
inline Bitboard attacks_bb(Square s) {
}
-// attacks_bb(Square, Bitboard) returns the attacks by the given piece
+// Returns the attacks by the given piece
// assuming the board is occupied according to the passed Bitboard.
// Sliding piece attacks do not continue passed an occupied square.
-
template<PieceType Pt>
inline Bitboard attacks_bb(Square s, Bitboard occupied) {
}
}
+// Returns the attacks by the given piece
+// assuming the board is occupied according to the passed Bitboard.
+// Sliding piece attacks do not continue passed an occupied square.
inline Bitboard attacks_bb(PieceType pt, Square s, Bitboard occupied) {
assert((pt != PAWN) && (is_ok(s)));
}
-// popcount() counts the number of non-zero bits in a bitboard
-
+// Counts the number of non-zero bits in a bitboard.
inline int popcount(Bitboard b) {
#ifndef USE_POPCNT
#endif
}
-
-// lsb() and msb() return the least/most significant bit in a non-zero bitboard
-
-#if defined(__GNUC__) // GCC, Clang, ICX
-
+// Returns the least significant bit in a non-zero bitboard.
inline Square lsb(Bitboard b) {
assert(b);
- return Square(__builtin_ctzll(b));
-}
-inline Square msb(Bitboard b) {
- assert(b);
- return Square(63 ^ __builtin_clzll(b));
-}
+#if defined(__GNUC__) // GCC, Clang, ICX
-#elif defined(_MSC_VER) // MSVC
+ return Square(__builtin_ctzll(b));
+#elif defined(_MSC_VER)
#ifdef _WIN64 // MSVC, WIN64
-inline Square lsb(Bitboard b) {
- assert(b);
unsigned long idx;
_BitScanForward64(&idx, b);
return (Square) idx;
-}
-
-inline Square msb(Bitboard b) {
- assert(b);
- unsigned long idx;
- _BitScanReverse64(&idx, b);
- return (Square) idx;
-}
#else // MSVC, WIN32
-
-inline Square lsb(Bitboard b) {
- assert(b);
unsigned long idx;
if (b & 0xffffffff)
_BitScanForward(&idx, int32_t(b >> 32));
return Square(idx + 32);
}
+ #endif
+#else // Compiler is neither GCC nor MSVC compatible
+ #error "Compiler not supported."
+#endif
}
+// Returns the most significant bit in a non-zero bitboard.
inline Square msb(Bitboard b) {
assert(b);
+
+#if defined(__GNUC__) // GCC, Clang, ICX
+
+ return Square(63 ^ __builtin_clzll(b));
+
+#elif defined(_MSC_VER)
+ #ifdef _WIN64 // MSVC, WIN64
+
+ unsigned long idx;
+ _BitScanReverse64(&idx, b);
+ return (Square) idx;
+
+ #else // MSVC, WIN32
+
unsigned long idx;
if (b >> 32)
_BitScanReverse(&idx, int32_t(b));
return Square(idx);
}
-}
-
#endif
-
#else // Compiler is neither GCC nor MSVC compatible
-
#error "Compiler not supported."
-
#endif
+}
-// least_significant_square_bb() returns the bitboard of the least significant
+// Returns the bitboard of the least significant
// square of a non-zero bitboard. It is equivalent to square_bb(lsb(bb)).
-
inline Bitboard least_significant_square_bb(Bitboard b) {
assert(b);
return b & -b;
}
-// pop_lsb() finds and clears the least significant bit in a non-zero bitboard
-
+// Finds and clears the least significant bit in a non-zero bitboard.
inline Square pop_lsb(Bitboard& b) {
assert(b);
const Square s = lsb(b);
std::string currentEvalFileName = "None";
-// NNUE::init() tries to load a NNUE network at startup time, or when the engine
+// Tries to load a NNUE network at startup time, or when the engine
// receives a UCI command "setoption name EvalFile value nn-[a-z0-9]{12}.nnue"
// The name of the NNUE network is always retrieved from the EvalFile option.
// We search the given network in three locations: internally (the default
// network may be embedded in the binary), in the active working directory and
// in the engine directory. Distro packagers may define the DEFAULT_NNUE_DIRECTORY
// variable to have the engine search in a special directory in their distro.
-
void NNUE::init() {
std::string eval_file = std::string(Options["EvalFile"]);
}
}
-// NNUE::verify() verifies that the last net used was loaded successfully
+// Verifies that the last net used was loaded successfully
void NNUE::verify() {
std::string eval_file = std::string(Options["EvalFile"]);
}
-// simple_eval() returns a static, purely materialistic evaluation of the position
+// Returns a static, purely materialistic evaluation of the position
// from the point of view of the given color. It can be divided by PawnValue to get
// an approximation of the material advantage on the board in terms of pawns.
-
Value Eval::simple_eval(const Position& pos, Color c) {
return PawnValue * (pos.count<PAWN>(c) - pos.count<PAWN>(~c))
+ (pos.non_pawn_material(c) - pos.non_pawn_material(~c));
}
-// evaluate() is the evaluator for the outer world. It returns a static evaluation
+// Evaluate is the evaluator for the outer world. It returns a static evaluation
// of the position from the point of view of the side to move.
-
Value Eval::evaluate(const Position& pos) {
assert(!pos.checkers());
return v;
}
-// trace() is like evaluate(), but instead of returning a value, it returns
+// 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.
// Trace scores are from white's point of view
-
std::string Eval::trace(Position& pos) {
if (pos.checkers())
} // namespace
-// engine_info() returns the full name of the current Stockfish version.
+// Returns the full name of the current Stockfish version.
// For local dev compiles we try to append the commit sha and commit date
// from git if that fails only the local compilation date is set and "nogit" is specified:
// Stockfish dev-YYYYMMDD-SHA
//
// For releases (non-dev builds) we only include the version number:
// Stockfish version
-
std::string engine_info(bool to_uci) {
std::stringstream ss;
ss << "Stockfish " << version << std::setfill('0');
}
-// compiler_info() returns a string trying to describe the compiler we use
-
+// Returns a string trying to describe the compiler we use
std::string compiler_info() {
#define make_version_string(major, minor, patch) \
// Used to serialize access to std::cout to avoid multiple threads writing at
// the same time.
-
std::ostream& operator<<(std::ostream& os, SyncCout sc) {
static std::mutex m;
void start_logger(const std::string& fname) { Logger::start(fname); }
-// 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(void*) {}
#endif
-// std_aligned_alloc() is our wrapper for systems where the c++17 implementation
+// Wrapper for systems where the c++17 implementation
// does not guarantee the availability of aligned_alloc(). Memory allocated with
// std_aligned_alloc() must be freed with std_aligned_free().
-
void* std_aligned_alloc(size_t alignment, size_t size) {
#if defined(POSIXALIGNEDALLOC)
#else
-// best_node() retrieves logical processor information using Windows specific
+// Retrieves logical processor information using Windows specific
// API and returns the best node id for the thread with index idx. Original
// code from Texel by Peter Österlund.
-
static int best_node(size_t idx) {
int threads = 0;
}
-// bindThisThread() sets the group affinity of the current thread
-
+// Sets the group affinity of the current thread
void bindThisThread(size_t idx) {
// Use only local variables to be thread-safe
std::string engine_info(bool to_uci = false);
std::string compiler_info();
-void prefetch(void* addr);
-void start_logger(const std::string& fname);
-void* std_aligned_alloc(size_t alignment, size_t size);
-void std_aligned_free(void* ptr);
-void* aligned_large_pages_alloc(
- size_t size); // memory aligned by page size, min alignment: 4096 bytes
-void aligned_large_pages_free(void* mem); // nop if mem == nullptr
+
+// 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.
+void prefetch(void* addr);
+
+void start_logger(const std::string& fname);
+void* std_aligned_alloc(size_t alignment, size_t size);
+void std_aligned_free(void* ptr);
+// memory aligned by page size, min alignment: 4096 bytes
+void* aligned_large_pages_alloc(size_t size);
+// nop if mem == nullptr
+void aligned_large_pages_free(void* mem);
void dbg_hit_on(bool cond, int slot = 0);
void dbg_mean_of(int64_t value, int slot = 0);
#define sync_endl std::endl << IO_UNLOCK
-// align_ptr_up() : get the first aligned element of an array.
+// Get the first aligned element of an array.
// ptr must point to an array of size at least `sizeof(T) * N + alignment` bytes,
// where N is the number of elements in the array.
template<uintptr_t Alignment, typename T>
}
-// IsLittleEndian : true if and only if the binary is compiled on a little-endian machine
+// True if and only if the binary is compiled on a little-endian machine
static inline const union {
uint32_t i;
char c[4];
// cores. To overcome this, some special platform-specific API should be
// called to set group affinity for each thread. Original code from Texel by
// Peter Österlund.
-
namespace WinProcGroup {
void bindThisThread(size_t idx);
}
// except castling and promotions
//
// Returns a pointer to the end of the move list.
-
template<GenType Type>
ExtMove* generate(const Position& pos, ExtMove* moveList) {
QCHECK
};
-// partial_insertion_sort() sorts moves in descending order up to and including
+// Sort moves in descending order up to and including
// a given limit. The order of moves smaller than the limit is left unspecified.
void partial_insertion_sort(ExtMove* begin, ExtMove* end, int limit) {
stage = (pos.checkers() ? EVASION_TT : MAIN_TT) + !(ttm && pos.pseudo_legal(ttm));
}
-// MovePicker constructor for quiescence search
+// Constructor for quiescence search
MovePicker::MovePicker(const Position& p,
Move ttm,
Depth d,
stage = (pos.checkers() ? EVASION_TT : QSEARCH_TT) + !(ttm && pos.pseudo_legal(ttm));
}
-// MovePicker constructor for ProbCut: we generate captures with SEE greater
+// Constructor for ProbCut: we generate captures with SEE greater
// than or equal to the given threshold.
MovePicker::MovePicker(const Position& p, Move ttm, Value th, const CapturePieceToHistory* cph) :
pos(p),
+ !(ttm && pos.capture_stage(ttm) && pos.pseudo_legal(ttm) && pos.see_ge(ttm, threshold));
}
-// MovePicker::score() assigns a numerical value to each move in a list, used
+// Assigns a numerical value to each move in a list, used
// for sorting. Captures are ordered by Most Valuable Victim (MVV), preferring
// captures with a good history. Quiets moves are ordered using the history tables.
template<GenType Type>
}
}
-// MovePicker::select() returns the next move satisfying a predicate function.
+// Returns the next move satisfying a predicate function.
// It never returns the TT move.
template<MovePicker::PickType T, typename Pred>
Move MovePicker::select(Pred filter) {
return MOVE_NONE;
}
-// MovePicker::next_move() is the most important method of the MovePicker class. It
+// Most important method of the MovePicker class. It
// returns a new pseudo-legal move every time it is called until there are no more
// moves left, picking the move with the highest score from a list of generated moves.
Move MovePicker::next_move(bool skipQuiets) {
constexpr std::string_view PieceToChar(" PNBRQK pnbrqk");
-// format_cp_compact() converts a Value into (centi)pawns and writes it in a buffer.
+// Converts a Value into (centi)pawns and writes it in a buffer.
// The buffer must have capacity for at least 5 chars.
static void format_cp_compact(Value v, char* buffer) {
}
-// format_cp_aligned_dot() converts a Value into pawns, always keeping two decimals
+// Converts a Value into pawns, always keeping two decimals
static void format_cp_aligned_dot(Value v, std::stringstream& stream) {
const double pawns = std::abs(0.01 * UCI::to_cp(v));
}
-// trace() returns a string with the value of each piece on a board,
+// Returns a string with the value of each piece on a board,
// and a table for (PSQT, Layers) values bucket by bucket.
std::string trace(Position& pos) {
template void HalfKAv2_hm::append_active_indices<WHITE>(const Position& pos, IndexList& active);
template void HalfKAv2_hm::append_active_indices<BLACK>(const Position& pos, IndexList& active);
-// append_changed_indices() : get a list of indices for recently changed features
+// Get a list of indices for recently changed features
template<Color Perspective>
void HalfKAv2_hm::append_changed_indices(Square ksq,
const DirtyPiece& dp,
}
-// read_little_endian() is our utility to read an integer (signed or unsigned, any size)
+// Utility to read an integer (signed or unsigned, any size)
// from a stream in little-endian order. We swap the byte order after the read if
// necessary to return a result with the byte ordering of the compiling machine.
template<typename IntType>
}
-// write_little_endian() is our utility to write an integer (signed or unsigned, any size)
+// Utility to write an integer (signed or unsigned, any size)
// to a stream in little-endian order. We swap the byte order before the write if
// necessary to always write in little endian order, independently of the byte
// ordering of the compiling machine.
}
-// read_little_endian(s, out, N) : read integers in bulk from a little indian stream.
+// Read integers in bulk from a little indian stream.
// This reads N integers from stream s and put them in array out.
template<typename IntType>
inline void read_little_endian(std::istream& stream, IntType* out, std::size_t count) {
}
-// write_little_endian(s, values, N) : write integers in bulk to a little indian stream.
+// Write integers in bulk to a little indian stream.
// This takes N integers from array values and writes them on stream s.
template<typename IntType>
inline void write_little_endian(std::ostream& stream, const IntType* values, std::size_t count) {
}
-// read_leb_128(s, out, N) : read N signed integers from the stream s, putting them in
+// Read N signed integers from the stream s, putting them in
// the array out. The stream is assumed to be compressed using the signed LEB128 format.
// See https://en.wikipedia.org/wiki/LEB128 for a description of the compression scheme.
template<typename IntType>
}
-// write_leb_128(s, values, N) : write signed integers to a stream with LEB128 compression.
+// Write signed integers to a stream with LEB128 compression.
// This takes N integers from array values, compress them with the LEB128 algorithm and
// writes the result on the stream s.
// See https://en.wikipedia.org/wiki/LEB128 for a description of the compression scheme.
} // namespace
-// operator<<(Position) returns an ASCII representation of the position
-
+// Returns an ASCII representation of the position
std::ostream& operator<<(std::ostream& os, const Position& pos) {
os << "\n +---+---+---+---+---+---+---+---+\n";
Move cuckooMove[8192];
-// Position::init() initializes at startup the various arrays used to compute hash keys
-
+// Initializes at startup the various arrays used to compute hash keys
void Position::init() {
PRNG rng(1070372);
}
-// Position::set() initializes the position object with the given FEN string.
+// Initializes the position object with the given FEN string.
// This function is not very robust - make sure that input FENs are correct,
// this is assumed to be the responsibility of the GUI.
-
Position& Position::set(const string& fenStr, bool isChess960, StateInfo* si, Thread* th) {
/*
A FEN string defines a particular position using only the ASCII character set.
}
-// Position::set_castling_right() is a helper function used to set castling
+// Helper function used to set castling
// rights given the corresponding color and the rook starting square.
-
void Position::set_castling_right(Color c, Square rfrom) {
Square kfrom = square<KING>(c);
}
-// Position::set_check_info() sets king attacks to detect if a move gives check
-
+// Sets king attacks to detect if a move gives check
void Position::set_check_info() const {
update_slider_blockers(WHITE);
}
-// Position::set_state() computes the hash keys of the position, and other
+// Computes the hash keys of the position, and other
// data that once computed is updated incrementally as moves are made.
// The function is only used when a new position is set up
-
void Position::set_state() const {
st->key = st->materialKey = 0;
}
-// Position::set() is an overload to initialize the position object with
+// Overload to initialize the position object with
// the given endgame code string like "KBPKN". It is mainly a helper to
// get the material key out of an endgame code.
-
Position& Position::set(const string& code, Color c, StateInfo* si) {
assert(code[0] == 'K');
}
-// Position::fen() returns a FEN representation of the position. In case of
+// Returns a FEN representation of the position. In case of
// Chess960 the Shredder-FEN notation is used. This is mainly a debugging function.
-
string Position::fen() const {
int emptyCnt;
return ss.str();
}
-// update_slider_blockers() calculates st->blockersForKing[c] and st->pinners[~c],
+// Calculates st->blockersForKing[c] and st->pinners[~c],
// which store respectively the pieces preventing king of color c from being in check
// and the slider pieces of color ~c pinning pieces of color c to the king.
void Position::update_slider_blockers(Color c) const {
}
-// Position::attackers_to() computes a bitboard of all pieces which attack a
+// Computes a bitboard of all pieces which attack a
// given square. Slider attacks use the occupied bitboard to indicate occupancy.
-
Bitboard Position::attackers_to(Square s, Bitboard occupied) const {
return (pawn_attacks_bb(BLACK, s) & pieces(WHITE, PAWN))
}
-// Position::legal() tests whether a pseudo-legal move is legal
-
+// Tests whether a pseudo-legal move is legal
bool Position::legal(Move m) const {
assert(is_ok(m));
}
-// Position::pseudo_legal() takes a random move and tests whether the move is
+// Takes a random move and tests whether the move is
// pseudo-legal. It is used to validate moves from TT that can be corrupted
// due to SMP concurrent access or hash position key aliasing.
-
bool Position::pseudo_legal(const Move m) const {
Color us = sideToMove;
}
-// Position::gives_check() tests whether a pseudo-legal move gives a check
-
+// Tests whether a pseudo-legal move gives a check
bool Position::gives_check(Move m) const {
assert(is_ok(m));
}
-// Position::do_move() makes a move, and saves all information necessary
+// Makes a move, and saves all information necessary
// 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, bool givesCheck) {
assert(is_ok(m));
}
-// Position::undo_move() unmakes a move. When it returns, the position should
+// Unmakes a move. When it returns, the position should
// be restored to exactly the same state as before the move was made.
-
void Position::undo_move(Move m) {
assert(is_ok(m));
}
-// Position::do_castling() is a helper used to do/undo a castling move. This
+// Helper used to do/undo a castling move. This
// is a bit tricky in Chess960 where from/to squares can overlap.
template<bool Do>
void Position::do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto) {
}
-// Position::do_null_move() is used to do a "null move": it flips
+// Used to do a "null move": it flips
// the side to move without executing any move on the board.
-
void Position::do_null_move(StateInfo& newSt) {
assert(!checkers());
}
-// Position::undo_null_move() must be used to undo a "null move"
-
+// Must be used to undo a "null move"
void Position::undo_null_move() {
assert(!checkers());
}
-// Position::key_after() computes the new hash key after the given move. Needed
+// Computes the new hash key after the given move. Needed
// for speculative prefetch. It doesn't recognize special moves like castling,
// en passant and promotions.
-
Key Position::key_after(Move m) const {
Square from = from_sq(m);
}
-// Position::see_ge (Static Exchange Evaluation Greater or Equal) tests if the
-// SEE value of move is greater or equal to the given threshold. We'll use an
+// Tests if the SEE (Static Exchange Evaluation)
+// value of move is greater or equal to the given threshold. We'll use an
// algorithm similar to alpha-beta pruning with a null window.
-
bool Position::see_ge(Move m, Value threshold) const {
assert(is_ok(m));
return bool(res);
}
-// Position::is_draw() tests whether the position is drawn by 50-move rule
+// Tests whether the position is drawn by 50-move rule
// or by repetition. It does not detect stalemates.
-
bool Position::is_draw(int ply) const {
if (st->rule50 > 99 && (!checkers() || MoveList<LEGAL>(*this).size()))
}
-// Position::has_repeated() tests whether there has been at least one repetition
+// Tests whether there has been at least one repetition
// of positions since the last capture or pawn move.
-
bool Position::has_repeated() const {
StateInfo* stc = st;
}
-// Position::has_game_cycle() tests if the position has a move which draws by repetition,
+// Tests if the position has a move which draws by repetition,
// or an earlier position has a move that directly reaches the current position.
-
bool Position::has_game_cycle(int ply) const {
int j;
}
-// Position::flip() flips position with the white and black sides reversed. This
+// Flips position with the white and black sides reversed. This
// is only useful for debugging e.g. for finding evaluation symmetry bugs.
-
void Position::flip() {
string f, token;
}
-// Position::pos_is_ok() performs some consistency checks for the
+// Performs some consistency checks for the
// position object and raise an assert if something wrong is detected.
// This is meant to be helpful when debugging.
-
bool Position::pos_is_ok() const {
constexpr bool Fast = true; // Quick (default) or full check?
int captureCount,
Depth depth);
-// perft() is our utility to verify move generation. All the leaf nodes up
+// Utility to verify move generation. All the leaf nodes up
// to the given depth are generated and counted, and the sum is returned.
template<bool Root>
uint64_t perft(Position& pos, Depth depth) {
} // namespace
-// Search::init() is called at startup to initialize various lookup tables
-
+// Called at startup to initialize various lookup tables
void Search::init() {
for (int i = 1; i < MAX_MOVES; ++i)
}
-// Search::clear() resets search state to its initial value
-
+// Resets search state to its initial value
void Search::clear() {
Threads.main()->wait_for_search_finished();
}
-// MainThread::search() is started when the program receives the UCI 'go'
+// Called when the program receives the UCI 'go'
// command. It searches from the root position and outputs the "bestmove".
-
void MainThread::search() {
if (Limits.perft)
}
-// Thread::search() is the main iterative deepening loop. It calls search()
+// Main iterative deepening loop. It calls search()
// repeatedly with increasing depth until the allocated thinking time has been
// consumed, the user stops the search, or the maximum search depth is reached.
-
void Thread::search() {
// Allocate stack with extra size to allow access from (ss-7) to (ss+2):
namespace {
-// search<>() is the main search function for both PV and non-PV nodes
-
+// Main search function for both PV and non-PV nodes
template<NodeType nodeType>
Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth, bool cutNode) {
}
-// qsearch() is the quiescence search function, which is called by the main search
+// Quiescence search function, which is called by the main search
// function with zero depth, or recursively with further decreasing depth per call.
// (~155 Elo)
template<NodeType nodeType>
}
-// value_to_tt() adjusts a mate or TB score from "plies to mate from the root"
+// Adjusts a mate or TB score from "plies to mate from the root"
// to "plies to mate from the current position". Standard scores are unchanged.
// The function is called before storing a value in the transposition table.
-
Value value_to_tt(Value v, int ply) {
assert(v != VALUE_NONE);
}
-// value_from_tt() is the inverse of value_to_tt(): it adjusts a mate or TB score
+// Inverse of value_to_tt(): it adjusts a mate or TB score
// from the transposition table (which refers to the plies to mate/be mated from
// current position) to "plies to mate/be mated (TB win/loss) from the root".
// However, to avoid potentially false mate scores related to the 50 moves rule
// and the graph history interaction problem, we return an optimal TB score instead.
-
Value value_from_tt(Value v, int ply, int r50c) {
if (v == VALUE_NONE)
}
-// update_pv() adds current move and appends child pv[]
-
+// Adds current move and appends child pv[]
void update_pv(Move* pv, Move move, const Move* childPv) {
for (*pv++ = move; childPv && *childPv != MOVE_NONE;)
}
-// update_all_stats() updates stats at the end of search() when a bestMove is found
-
+// Updates stats at the end of search() when a bestMove is found
void update_all_stats(const Position& pos,
Stack* ss,
Move bestMove,
}
-// update_continuation_histories() updates histories of the move pairs formed
+// Updates histories of the move pairs formed
// by moves at ply -1, -2, -4, and -6 with current move.
-
void update_continuation_histories(Stack* ss, Piece pc, Square to, int bonus) {
for (int i : {1, 2, 3, 4, 6})
}
-// update_quiet_stats() updates move sorting heuristics
-
+// Updates move sorting heuristics
void update_quiet_stats(const Position& pos, Stack* ss, Move move, int bonus) {
// Update killers
// When playing with strength handicap, choose the best move among a set of RootMoves
// using a statistical rule dependent on 'level'. Idea by Heinz van Saanen.
-
Move Skill::pick_best(size_t multiPV) {
const RootMoves& rootMoves = Threads.main()->rootMoves;
} // namespace
-// MainThread::check_time() is used to print debug info and, more importantly,
+// Used to print debug info and, more importantly,
// to detect when we are out of available time and thus stop the search.
-
void MainThread::check_time() {
if (--callsCnt > 0)
}
-// UCI::pv() formats PV information according to the UCI protocol. UCI requires
+// 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) {
std::stringstream ss;
}
-// RootMove::extract_ponder_from_tt() is called in case we have no ponder move
+// Called in case we have no ponder move
// before exiting the search, for instance, in case we stop the search during a
// fail high at 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 about.
-
bool RootMove::extract_ponder_from_tt(Position& pos) {
StateInfo st;
// Stack struct keeps track of the information we need to remember from nodes
// shallower and deeper in the tree during the search. Each search thread has
// its own array of Stack objects, indexed by the current ply.
-
struct Stack {
Move* pv;
PieceToHistory* continuationHistory;
// RootMove struct is used for moves at the root of the tree. For each root move
// we store a score and a PV (really a refutation in the case of moves which
// fail low). Score is normally set at -VALUE_INFINITE for all non-pv moves.
-
struct RootMove {
explicit RootMove(Move m) :
pv(1, m) {}
bool extract_ponder_from_tt(Position& pos);
bool operator==(const Move& m) const { return pv[0] == m; }
- bool operator<(const RootMove& m) const { // Sort in descending order
+ // Sort in descending order
+ bool operator<(const RootMove& m) const {
return m.score != score ? m.score < score : m.previousScore < previousScore;
}
struct LimitsType {
- LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC
+ // Init explicitly due to broken value-initialization of non POD in MSVC
+ LimitsType() {
time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] = npmsec = movetime = TimePoint(0);
movestogo = depth = mate = perft = infinite = 0;
nodes = 0;
} // namespace
-// Tablebases::init() is called at startup and after every change to
+// Called at startup and after every change to
// "SyzygyPath" UCI option to (re)create the various tables. It is not thread
// safe, nor it needs to be.
void Tablebases::init(const std::string& paths) {
ThreadPool Threads; // Global object
-// Thread constructor launches the thread and waits until it goes to sleep
+// Constructor launches the thread and waits until it goes to sleep
// in idle_loop(). Note that 'searching' and 'exit' should be already set.
-
Thread::Thread(size_t n) :
idx(n),
stdThread(&Thread::idle_loop, this) {
}
-// Thread destructor wakes up the thread in idle_loop() and waits
+// Destructor wakes up the thread in idle_loop() and waits
// for its termination. Thread should be already waiting.
-
Thread::~Thread() {
assert(!searching);
}
-// Thread::clear() reset histories, usually before a new game
-
+// Reset histories, usually before a new game
void Thread::clear() {
counterMoves.fill(MOVE_NONE);
}
-// Thread::start_searching() wakes up the thread that will start the search
-
+// Wakes up the thread that will start the search
void Thread::start_searching() {
mutex.lock();
searching = true;
}
-// Thread::wait_for_search_finished() blocks on the condition variable
+// Blocks on the condition variable
// until the thread has finished searching.
-
void Thread::wait_for_search_finished() {
std::unique_lock<std::mutex> lk(mutex);
}
-// Thread::idle_loop() is where the thread is parked, blocked on the
+// Thread gets parked here, blocked on the
// condition variable, when it has no work to do.
void Thread::idle_loop() {
}
}
-// ThreadPool::set() creates/destroys threads to match the requested number.
+// Creates/destroys threads to match the requested number.
// Created and launched threads will immediately go to sleep in idle_loop.
// Upon resizing, threads are recreated to allow for binding if necessary.
-
void ThreadPool::set(size_t requested) {
if (threads.size() > 0) // destroy any existing thread(s)
}
-// ThreadPool::clear() sets threadPool data to initial values
-
+// Sets threadPool data to initial values
void ThreadPool::clear() {
for (Thread* th : threads)
}
-// ThreadPool::start_thinking() wakes up main thread waiting in idle_loop() and
+// Wakes up main thread waiting in idle_loop() and
// returns immediately. Main thread will wake up other threads and start the search.
-
void ThreadPool::start_thinking(Position& pos,
StateListPtr& states,
const Search::LimitsType& limits,
// per-thread pawn and material hash tables so that once we get a
// pointer to an entry its lifetime is unlimited and we don't have
// to care about someone changing the entry under our feet.
-
class Thread {
std::mutex mutex;
// MainThread is a derived class specific for main thread
-
struct MainThread: public Thread {
using Thread::Thread;
// ThreadPool struct handles all the threads-related stuff like init, starting,
// parking and, most importantly, launching a thread. All the access to threads
// is done through this class.
-
struct ThreadPool {
void start_thinking(Position&, StateListPtr&, const Search::LimitsType&, bool = false);
TimeManagement Time; // Our global time management object
-// TimeManagement::init() is called at the beginning of the search and calculates
+// Called at the beginning of the search and calculates
// the bounds of time allowed for the current game ply. We currently support:
// 1) x basetime (+ z increment)
// 2) x moves in y seconds (+ z increment)
-
void TimeManagement::init(Search::LimitsType& limits, Color us, int ply) {
// If we have no time, no need to initialize TM, except for the start time,
// 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(Search::LimitsType& limits, Color us, int ply);
TranspositionTable TT; // Our global transposition table
-// TTEntry::save() populates the TTEntry with a new node's data, possibly
+// Populates the TTEntry with a new node's data, possibly
// overwriting an old position. The update is not atomic and can be racy.
-
void TTEntry::save(Key k, Value v, bool pv, Bound b, Depth d, Move m, Value ev) {
// Preserve any existing move for the same position
}
-// TranspositionTable::resize() sets the size of the transposition table,
+// Sets the size of the transposition table,
// measured in megabytes. Transposition table consists of a power of 2 number
// of clusters and each cluster consists of ClusterSize number of TTEntry.
-
void TranspositionTable::resize(size_t mbSize) {
Threads.main()->wait_for_search_finished();
}
-// TranspositionTable::clear() initializes the entire transposition table to zero,
-// in a multi-threaded way.
-
+// Initializes the entire transposition table to zero,
+// in a multi-threaded way.
void TranspositionTable::clear() {
std::vector<std::thread> threads;
}
-// TranspositionTable::probe() looks up the current position in the transposition
+// 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. 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 {
TTEntry* const tte = first_entry(key);
}
-// TranspositionTable::hashfull() returns an approximation of the hashtable
+// Returns an approximation of the hashtable
// occupation during a search. The hash is x permill full, as per UCI protocol.
int TranspositionTable::hashfull() const {
// move 16 bit
// value 16 bit
// eval value 16 bit
-
struct TTEntry {
Move move() const { return Move(move16); }
// contains information on exactly one position. The size of a Cluster should
// divide the size of a cache line for best performance, as the cacheline is
// prefetched when possible.
-
class TranspositionTable {
static constexpr int ClusterSize = 3;
inline Square& operator+=(Square& s, Direction d) { return s = s + d; }
inline Square& operator-=(Square& s, Direction d) { return s = s - d; }
-constexpr Color operator~(Color c) {
- return Color(c ^ BLACK); // Toggle color
-}
+// Toggle color
+constexpr Color operator~(Color c) { return Color(c ^ BLACK); }
-constexpr Square flip_rank(Square s) { // Swap A1 <-> A8
- return Square(s ^ SQ_A8);
-}
+// Swap A1 <-> A8
+constexpr Square flip_rank(Square s) { return Square(s ^ SQ_A8); }
-constexpr Square flip_file(Square s) { // Swap A1 <-> H1
- return Square(s ^ SQ_H1);
-}
+// Swap A1 <-> H1
+constexpr Square flip_file(Square s) { return Square(s ^ SQ_H1); }
-constexpr Piece operator~(Piece pc) {
- return Piece(pc ^ 8); // Swap color of piece B_KNIGHT <-> W_KNIGHT
-}
+// Swap color of piece B_KNIGHT <-> W_KNIGHT
+constexpr Piece operator~(Piece pc) { return Piece(pc ^ 8); }
constexpr CastlingRights operator&(Color c, CastlingRights cr) {
return CastlingRights((c == WHITE ? WHITE_CASTLING : BLACK_CASTLING) & cr);
const char* StartFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
-// position() is called when the engine receives the "position" UCI command.
+// Called when the engine receives the "position" UCI command.
// It sets up the position that is described in the given FEN string ("fen") or
// the initial position ("startpos") and then makes the moves given in the following
// move list ("moves").
-
void position(Position& pos, std::istringstream& is, StateListPtr& states) {
Move m;
}
}
-// trace_eval() prints the evaluation of the current position, consistent with
+// Prints the evaluation of the current position, consistent with
// the UCI options set so far.
-
void trace_eval(Position& pos) {
StateListPtr states(new std::deque<StateInfo>(1));
}
-// setoption() is called when the engine receives the "setoption" UCI command.
+// Called when the engine receives the "setoption" UCI command.
// The function updates the UCI option ("name") to the given value ("value").
void setoption(std::istringstream& is) {
}
-// go() is called when the engine receives the "go" UCI command. The function
+// Called when the engine receives the "go" UCI command. The function
// sets the thinking time and other parameters from the input string, then starts
// with a search.
}
-// bench() is called when the engine receives the "bench" command.
+// Called when the engine receives the "bench" command.
// First, a list of UCI commands is set up according to the bench
// parameters, then it is run one by one, printing a summary at the end.
} // namespace
-// UCI::loop() waits for a command from the stdin, parses it, and then calls the appropriate
+// Waits for a command from the stdin, parses it, and then calls the appropriate
// function. It also intercepts an end-of-file (EOF) indication from the stdin to ensure a
// graceful exit if the GUI dies unexpectedly. When called with some command-line arguments,
// like running 'bench', the function returns immediately after the command is executed.
// In addition to the UCI ones, some additional debug commands are also supported.
-
void UCI::loop(int argc, char* argv[]) {
Position pos;
// without treatment of mate and similar special scores.
int UCI::to_cp(Value v) { return 100 * v / UCI::NormalizeToPawnValue; }
-// UCI::value() converts a Value to a string by adhering to the UCI protocol specification:
+// Converts a Value to a string by adhering to the UCI protocol specification:
//
// cp <x> The score from the engine's point of view in centipawns.
// mate <y> Mate in 'y' moves (not plies). If the engine is getting mated,
// uses negative values for 'y'.
-
std::string UCI::value(Value v) {
assert(-VALUE_INFINITE < v && v < VALUE_INFINITE);
}
-// UCI::wdl() reports the win-draw-loss (WDL) statistics given an evaluation
+// Reports the win-draw-loss (WDL) statistics given an evaluation
// and a game ply based on the data gathered for fishtest LTC games.
-
std::string UCI::wdl(Value v, int ply) {
std::stringstream ss;
}
-// UCI::square() converts a Square to a string in algebraic notation (g1, a7, etc.)
-
+// Converts a Square to a string in algebraic notation (g1, a7, etc.)
std::string UCI::square(Square s) {
return std::string{char('a' + file_of(s)), char('1' + rank_of(s))};
}
-// UCI::move() converts a Move to a string in coordinate notation (g1f3, a7a8q).
+// Converts a Move to a string in coordinate notation (g1f3, a7a8q).
// The only special case is castling where the e1g1 notation is printed in
// standard chess mode and in e1h1 notation it is printed in Chess960 mode.
// Internally, all castling moves are always encoded as 'king captures rook'.
-
std::string UCI::move(Move m, bool chess960) {
if (m == MOVE_NONE)
}
-// UCI::to_move() converts a string representing a move in coordinate notation
+// Converts a string representing a move in coordinate notation
// (g1f3, a7a8q) to the corresponding legal Move, if any.
-
Move UCI::to_move(const Position& pos, std::string& str) {
if (str.length() == 5)
}
-// UCI::init() initializes the UCI options to their hard-coded default values
-
+// Initializes the UCI options to their hard-coded default values
void init(OptionsMap& o) {
constexpr int MaxHashMB = Is64Bit ? 33554432 : 2048;
}
-// operator<<() is used to print all the options default values in chronological
+// Used to print all the options default values in chronological
// insertion order (the idx field) and in the format defined by the UCI protocol.
-
std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
for (size_t idx = 0; idx < om.size(); ++idx)
}
-// operator<<() inits options and assigns idx in the correct printing order
+// Inits options and assigns idx in the correct printing order
void Option::operator<<(const Option& o) {
}
-// operator=() updates currentValue and triggers on_change() action. It's up to
+// Updates currentValue and triggers on_change() action. It's up to
// the GUI to check for option's limits, but we could receive the new value
// from the user by console window, so let's check the bounds anyway.
-
Option& Option::operator=(const string& v) {
assert(!type.empty());
projects / stockfish / commitdiff