// Node counters, used only by thread[0] but try to keep in different cache
// lines (64 bytes each) from the heavy multi-thread read accessed variables.
- bool SendSearchedNodes;
int NodesSincePoll;
int NodesBetweenPolls = 30000;
if (moveIsCheck && pos.see_sign(m) >= 0)
result += CheckExtension[PvNode];
- if (piece_type(pos.piece_on(move_from(m))) == PAWN)
+ if (type_of(pos.piece_on(move_from(m))) == PAWN)
{
Color c = pos.side_to_move();
if (relative_rank(c, move_to(m)) == RANK_7)
}
if ( captureOrPromotion
- && piece_type(pos.piece_on(move_to(m))) != PAWN
+ && type_of(pos.piece_on(move_to(m))) != PAWN
&& ( pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
- piece_value_midgame(pos.piece_on(move_to(m))) == VALUE_ZERO)
- && !move_is_special(m))
+ && !is_special(m))
{
result += PawnEndgameExtension[PvNode];
*dangerous = true;
bool think(Position& pos, const SearchLimits& limits, Move searchMoves[]) {
- static Book book;
+ static Book book; // Define static to initialize the PRNG only once
// Initialize global search-related variables
- StopOnPonderhit = StopRequest = QuitRequest = AspirationFailLow = SendSearchedNodes = false;
+ StopOnPonderhit = StopRequest = QuitRequest = AspirationFailLow = false;
NodesSincePoll = 0;
current_search_time(get_system_time());
Limits = limits;
if (Options["Book File"].value<string>() != book.name())
book.open(Options["Book File"].value<string>());
- Move bookMove = book.get_move(pos, Options["Best Book Move"].value<bool>());
+ Move bookMove = book.probe(pos, Options["Best Book Move"].value<bool>());
if (bookMove != MOVE_NONE)
{
if (Limits.ponder)
read_evaluation_uci_options(pos.side_to_move());
Threads.read_uci_options();
- // If needed allocate pawn and material hash tables and adjust TT size
- Threads.init_hash_tables();
+ // Set a new TT size if changed
TT.set_size(Options["Hash"].value<int>());
if (Options["Clear Hash"].value<bool>())
: can_return_tt(tte, depth, beta, ss->ply)))
{
TT.refresh(tte);
- ss->bestMove = ttMove; // Can be MOVE_NONE
- return value_from_tt(tte->value(), ss->ply);
+ ss->bestMove = move = ttMove; // Can be MOVE_NONE
+ value = value_from_tt(tte->value(), ss->ply);
+
+ if ( value >= beta
+ && move
+ && !pos.is_capture_or_promotion(move)
+ && move != ss->killers[0])
+ {
+ ss->killers[1] = ss->killers[0];
+ ss->killers[0] = move;
+ }
+ return value;
}
// Step 5. Evaluate the position statically and update parent's gain statistics
&& (move = mp.get_next_move()) != MOVE_NONE
&& !thread.cutoff_occurred())
{
- assert(move_is_ok(move));
+ assert(is_ok(move));
if (move == excludedMove)
continue;
// Save the current node count before the move is searched
nodes = pos.nodes_searched();
- // If it's time to send nodes info, do it here where we have the
- // correct accumulated node counts searched by each thread.
- if (!SpNode && SendSearchedNodes)
- {
- SendSearchedNodes = false;
- cout << "info" << speed_to_uci(pos.nodes_searched()) << endl;
- }
-
// For long searches send current move info to GUI
if (pos.thread() == 0 && current_search_time() > 2000)
cout << "info" << depth_to_uci(depth)
// At Root and at first iteration do a PV search on all the moves to score root moves
isPvMove = (PvNode && moveCount <= (RootNode && depth <= ONE_PLY ? MAX_MOVES : 1));
givesCheck = pos.move_gives_check(move, ci);
- captureOrPromotion = pos.move_is_capture_or_promotion(move);
+ captureOrPromotion = pos.is_capture_or_promotion(move);
// Step 12. Decide the new search depth
ext = extension<PvNode>(pos, move, captureOrPromotion, givesCheck, &dangerous);
&& !inCheck
&& !dangerous
&& move != ttMove
- && !move_is_castle(move))
+ && !is_castle(move))
{
// Move count based pruning
if ( moveCount >= futility_move_count(depth)
if ( depth > 3 * ONE_PLY
&& !captureOrPromotion
&& !dangerous
- && !move_is_castle(move)
+ && !is_castle(move)
&& ss->killers[0] != move
&& ss->killers[1] != move
&& (ss->reduction = reduction<PvNode>(depth, moveCount)) != DEPTH_ZERO)
// Update killers and history only for non capture moves that fails high
if ( bestValue >= beta
- && !pos.move_is_capture_or_promotion(move))
+ && !pos.is_capture_or_promotion(move))
{
if (move != ss->killers[0])
{
while ( bestValue < beta
&& (move = mp.get_next_move()) != MOVE_NONE)
{
- assert(move_is_ok(move));
+ assert(is_ok(move));
givesCheck = pos.move_gives_check(move, ci);
&& !givesCheck
&& move != ttMove
&& enoughMaterial
- && !move_is_promotion(move)
- && !pos.move_is_passed_pawn_push(move))
+ && !is_promotion(move)
+ && !pos.is_passed_pawn_push(move))
{
futilityValue = futilityBase
+ piece_value_endgame(pos.piece_on(move_to(move)))
- + (move_is_ep(move) ? PawnValueEndgame : VALUE_ZERO);
+ + (is_enpassant(move) ? PawnValueEndgame : VALUE_ZERO);
if (futilityValue < beta)
{
evasionPrunable = !PvNode
&& inCheck
&& bestValue > VALUE_MATED_IN_PLY_MAX
- && !pos.move_is_capture(move)
+ && !pos.is_capture(move)
&& !pos.can_castle(pos.side_to_move());
// Don't search moves with negative SEE values
if ( !PvNode
&& (!inCheck || evasionPrunable)
&& move != ttMove
- && !move_is_promotion(move)
+ && !is_promotion(move)
&& pos.see_sign(move) < 0)
continue;
&& !inCheck
&& givesCheck
&& move != ttMove
- && !pos.move_is_capture_or_promotion(move)
+ && !pos.is_capture_or_promotion(move)
&& ss->eval + PawnValueMidgame / 4 < beta
&& !check_is_dangerous(pos, move, futilityBase, beta, &bestValue))
{
from = move_from(move);
to = move_to(move);
- them = opposite_color(pos.side_to_move());
+ them = flip(pos.side_to_move());
ksq = pos.king_square(them);
kingAtt = pos.attacks_from<KING>(ksq);
pc = pos.piece_on(from);
return true;
// Rule 2. Queen contact check is very dangerous
- if ( piece_type(pc) == QUEEN
+ if ( type_of(pc) == QUEEN
&& bit_is_set(kingAtt, to))
return true;
Piece p1, p2;
Square ksq;
- assert(m1 && move_is_ok(m1));
- assert(m2 && move_is_ok(m2));
+ assert(is_ok(m1));
+ assert(is_ok(m2));
// Case 1: The moving piece is the same in both moves
f2 = move_from(m2);
bool connected_threat(const Position& pos, Move m, Move threat) {
- assert(move_is_ok(m));
- assert(threat && move_is_ok(threat));
- assert(!pos.move_is_capture_or_promotion(m));
- assert(!pos.move_is_passed_pawn_push(m));
+ assert(is_ok(m));
+ assert(is_ok(threat));
+ assert(!pos.is_capture_or_promotion(m));
+ assert(!pos.is_passed_pawn_push(m));
Square mfrom, mto, tfrom, tto;
// Case 2: If the threatened piece has value less than or equal to the
// value of the threatening piece, don't prune moves which defend it.
- if ( pos.move_is_capture(threat)
+ if ( pos.is_capture(threat)
&& ( piece_value_midgame(pos.piece_on(tfrom)) >= piece_value_midgame(pos.piece_on(tto))
- || piece_type(pos.piece_on(tfrom)) == KING)
+ || type_of(pos.piece_on(tfrom)) == KING)
&& pos.move_attacks_square(m, tto))
return true;
&& before != VALUE_NONE
&& after != VALUE_NONE
&& pos.captured_piece_type() == PIECE_TYPE_NONE
- && !move_is_special(m))
+ && !is_special(m))
H.update_gain(pos.piece_on(move_to(m)), move_to(m), -(before + after));
}
dbg_print_mean();
dbg_print_hit_rate();
-
- // Send info on searched nodes as soon as we return to root
- SendSearchedNodes = true;
}
// Should we stop the search?
int ply = 1;
Move m = pv[0];
- assert(m != MOVE_NONE && pos.move_is_pl(m));
+ assert(m != MOVE_NONE && pos.is_pseudo_legal(m));
pv.clear();
pv.push_back(m);
while ( (tte = TT.probe(pos.get_key())) != NULL
&& tte->move() != MOVE_NONE
- && pos.move_is_pl(tte->move())
+ && pos.is_pseudo_legal(tte->move())
&& pos.pl_move_is_legal(tte->move(), pos.pinned_pieces())
&& ply < PLY_MAX
&& (!pos.is_draw<false>() || ply < 2))
Value v, m = VALUE_NONE;
int ply = 0;
- assert(pv[0] != MOVE_NONE && pos.move_is_pl(pv[0]));
+ assert(pv[0] != MOVE_NONE && pos.is_pseudo_legal(pv[0]));
do {
k = pos.get_key();
} // namespace
-// ThreadsManager::idle_loop() is where the threads are parked when they have no work
-// to do. The parameter 'sp', if non-NULL, is a pointer to an active SplitPoint
-// object for which the current thread is the master.
+// Little helper used by idle_loop() to check that all the slave threads of a
+// split point have finished searching.
+
+static bool all_slaves_finished(SplitPoint* sp) {
+
+ for (int i = 0; i < Threads.size(); i++)
+ if (sp->is_slave[i])
+ return false;
+
+ return true;
+}
-void ThreadsManager::idle_loop(int threadID, SplitPoint* sp) {
- assert(threadID >= 0 && threadID < MAX_THREADS);
+// Thread::idle_loop() is where the thread is parked when it has no work to do.
+// The parameter 'sp', if non-NULL, is a pointer to an active SplitPoint object
+// for which the thread is the master.
- int i;
- bool allFinished;
+void Thread::idle_loop(SplitPoint* sp) {
while (true)
{
- // Slave threads can exit as soon as AllThreadsShouldExit raises,
- // master should exit as last one.
- if (allThreadsShouldExit)
- {
- assert(!sp);
- threads[threadID].state = Thread::TERMINATED;
- return;
- }
-
- // If we are not thinking, wait for a condition to be signaled
+ // If we are not searching, wait for a condition to be signaled
// instead of wasting CPU time polling for work.
- while ( threadID >= activeThreads
- || threads[threadID].state == Thread::INITIALIZING
- || (useSleepingThreads && threads[threadID].state == Thread::AVAILABLE))
+ while ( do_sleep
+ || do_terminate
+ || (Threads.use_sleeping_threads() && !is_searching))
{
- assert(!sp || useSleepingThreads);
- assert(threadID != 0 || useSleepingThreads);
+ assert((!sp && threadID) || Threads.use_sleeping_threads());
- if (threads[threadID].state == Thread::INITIALIZING)
- threads[threadID].state = Thread::AVAILABLE;
+ // Slave thread should exit as soon as do_terminate flag raises
+ if (do_terminate)
+ {
+ assert(!sp);
+ return;
+ }
// Grab the lock to avoid races with Thread::wake_up()
- lock_grab(&threads[threadID].sleepLock);
-
- // If we are master and all slaves have finished do not go to sleep
- for (i = 0; sp && i < activeThreads && !sp->is_slave[i]; i++) {}
- allFinished = (i == activeThreads);
+ lock_grab(&sleepLock);
- if (allFinished || allThreadsShouldExit)
+ // If we are master and all slaves have finished don't go to sleep
+ if (sp && all_slaves_finished(sp))
{
- lock_release(&threads[threadID].sleepLock);
+ lock_release(&sleepLock);
break;
}
- // Do sleep here after retesting sleep conditions
- if (threadID >= activeThreads || threads[threadID].state == Thread::AVAILABLE)
- cond_wait(&threads[threadID].sleepCond, &threads[threadID].sleepLock);
+ // Do sleep after retesting sleep conditions under lock protection, in
+ // particular we need to avoid a deadlock in case a master thread has,
+ // in the meanwhile, allocated us and sent the wake_up() call before we
+ // had the chance to grab the lock.
+ if (do_sleep || !is_searching)
+ cond_wait(&sleepCond, &sleepLock);
- lock_release(&threads[threadID].sleepLock);
+ lock_release(&sleepLock);
}
// If this thread has been assigned work, launch a search
- if (threads[threadID].state == Thread::WORKISWAITING)
+ if (is_searching)
{
- assert(!allThreadsShouldExit);
-
- threads[threadID].state = Thread::SEARCHING;
+ assert(!do_terminate);
// Copy split point position and search stack and call search()
- // with SplitPoint template parameter set to true.
SearchStack ss[PLY_MAX_PLUS_2];
- SplitPoint* tsp = threads[threadID].splitPoint;
+ SplitPoint* tsp = splitPoint;
Position pos(*tsp->pos, threadID);
memcpy(ss, tsp->ss - 1, 4 * sizeof(SearchStack));
else
assert(false);
- assert(threads[threadID].state == Thread::SEARCHING);
+ assert(is_searching);
- threads[threadID].state = Thread::AVAILABLE;
+ is_searching = false;
// Wake up master thread so to allow it to return from the idle loop in
// case we are the last slave of the split point.
- if ( useSleepingThreads
+ if ( Threads.use_sleeping_threads()
&& threadID != tsp->master
- && threads[tsp->master].state == Thread::AVAILABLE)
- threads[tsp->master].wake_up();
+ && !Threads[tsp->master].is_searching)
+ Threads[tsp->master].wake_up();
}
// If this thread is the master of a split point and all slaves have
// finished their work at this split point, return from the idle loop.
- for (i = 0; sp && i < activeThreads && !sp->is_slave[i]; i++) {}
- allFinished = (i == activeThreads);
-
- if (allFinished)
+ if (sp && all_slaves_finished(sp))
{
- // Because sp->slaves[] is reset under lock protection,
+ // Because sp->is_slave[] is reset under lock protection,
// be sure sp->lock has been released before to return.
lock_grab(&(sp->lock));
lock_release(&(sp->lock));
-
- // In helpful master concept a master can help only a sub-tree, and
- // because here is all finished is not possible master is booked.
- assert(threads[threadID].state == Thread::AVAILABLE);
return;
}
}