X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=163df7b4ec4b6f4f017fbe13318a0320a820c15e;hp=29dc00a996d2e97337c819b29a99681c49f9806f;hb=4c91dbc28e8bb6265f80240de26b8e02f7020a51;hpb=e5463eb3ae6c1a035fe1da717fb88568ee654237 diff --git a/src/search.cpp b/src/search.cpp index 29dc00a9..163df7b4 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -279,6 +279,8 @@ void Search::think() { // used to check for remaining available thinking time. if (Limits.use_time_management()) Threads.set_timer(std::min(100, std::max(TimeMgr.available_time() / 16, TimerResolution))); + else if (Limits.nodes) + Threads.set_timer(2 * TimerResolution); else Threads.set_timer(100); @@ -526,49 +528,42 @@ namespace { Key posKey; Move ttMove, move, excludedMove, bestMove, threatMove; Depth ext, newDepth; - Bound bt; Value bestValue, value, oldAlpha, ttValue; Value refinedValue, nullValue, futilityValue; bool pvMove, inCheck, singularExtensionNode, givesCheck; bool captureOrPromotion, dangerous, doFullDepthSearch; int moveCount, playedMoveCount; + // Step 1. Initialize node Thread* thisThread = pos.this_thread(); moveCount = playedMoveCount = 0; oldAlpha = alpha; inCheck = pos.in_check(); - ss->ply = (ss-1)->ply + 1; - - // Used to send selDepth info to GUI - if (PvNode && thisThread->maxPly < ss->ply) - thisThread->maxPly = ss->ply; - // Step 1. Initialize node if (SpNode) { + sp = ss->sp; + bestMove = sp->bestMove; + threatMove = sp->threatMove; + bestValue = sp->bestValue; tte = NULL; ttMove = excludedMove = MOVE_NONE; ttValue = VALUE_NONE; - sp = ss->sp; - bestMove = sp->bestMove; - threatMove = sp->threatMove; - bestValue = sp->bestValue; - assert(bestValue > -VALUE_INFINITE && sp->moveCount > 0); + assert(sp->bestValue > -VALUE_INFINITE && sp->moveCount > 0); goto split_point_start; } - else - { - bestValue = -VALUE_INFINITE; - ss->currentMove = threatMove = (ss+1)->excludedMove = bestMove = MOVE_NONE; - (ss+1)->skipNullMove = false; (ss+1)->reduction = DEPTH_ZERO; - (ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE; - } - // Enforce node limit here. FIXME: This only works with 1 search thread. - if (Limits.nodes && pos.nodes_searched() >= Limits.nodes) - Signals.stop = true; + bestValue = -VALUE_INFINITE; + ss->currentMove = threatMove = (ss+1)->excludedMove = bestMove = MOVE_NONE; + ss->ply = (ss-1)->ply + 1; + (ss+1)->skipNullMove = false; (ss+1)->reduction = DEPTH_ZERO; + (ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE; + + // Used to send selDepth info to GUI + if (PvNode && thisThread->maxPly < ss->ply) + thisThread->maxPly = ss->ply; if (!RootNode) { @@ -868,7 +863,7 @@ split_point_start: // At split points actual search starts from here ss->excludedMove = MOVE_NONE; if (value < rBeta) - ext = ONE_PLY; + ext = rBeta >= beta ? ONE_PLY + ONE_PLY / 2 : ONE_PLY; } // Update current move (this must be done after singular extension search) @@ -1007,7 +1002,6 @@ split_point_start: // At split points actual search starts from here // is not a problem when sorting becuase sort is stable and move // position in the list is preserved, just the PV is pushed up. rm.score = -VALUE_INFINITE; - } if (value > bestValue) @@ -1018,15 +1012,17 @@ split_point_start: // At split points actual search starts from here if ( PvNode && value > alpha && value < beta) // We want always alpha < beta - alpha = value; + { + alpha = bestValue; // Update alpha here! + } if (SpNode && !thisThread->cutoff_occurred()) { - sp->bestValue = value; - sp->bestMove = move; + sp->bestValue = bestValue; + sp->bestMove = bestMove; sp->alpha = alpha; - if (value >= beta) + if (bestValue >= beta) sp->cutoff = true; } } @@ -1039,7 +1035,7 @@ split_point_start: // At split points actual search starts from here && !Signals.stop && !thisThread->cutoff_occurred()) bestValue = Threads.split(pos, ss, alpha, beta, bestValue, &bestMove, - depth, threatMove, moveCount, &mp, NT); + depth, threatMove, moveCount, mp, NT); } // Step 20. Check for mate and stalemate @@ -1048,41 +1044,42 @@ split_point_start: // At split points actual search starts from here // case of Signals.stop or thread.cutoff_occurred() are set, but this is // harmless because return value is discarded anyhow in the parent nodes. // If we are in a singular extension search then return a fail low score. - if (!moveCount) - return excludedMove ? oldAlpha : inCheck ? mated_in(ss->ply) : VALUE_DRAW; + // A split node has at least one move, the one tried before to be splitted. + if (!SpNode && !moveCount) + return excludedMove ? alpha : inCheck ? mated_in(ss->ply) : VALUE_DRAW; // If we have pruned all the moves without searching return a fail-low score if (bestValue == -VALUE_INFINITE) { assert(!playedMoveCount); - bestValue = oldAlpha; + bestValue = alpha; } // Step 21. Update tables // Update transposition table entry, killers and history if (!SpNode && !Signals.stop && !thisThread->cutoff_occurred()) { - move = bestValue <= oldAlpha ? MOVE_NONE : bestMove; - bt = bestValue <= oldAlpha ? BOUND_UPPER - : bestValue >= beta ? BOUND_LOWER : BOUND_EXACT; + Move ttm = bestValue <= oldAlpha ? MOVE_NONE : bestMove; + Bound bt = bestValue <= oldAlpha ? BOUND_UPPER + : bestValue >= beta ? BOUND_LOWER : BOUND_EXACT; - TT.store(posKey, value_to_tt(bestValue, ss->ply), bt, depth, move, ss->eval, ss->evalMargin); + TT.store(posKey, value_to_tt(bestValue, ss->ply), bt, depth, ttm, ss->eval, ss->evalMargin); // Update killers and history for non capture cut-off moves if ( bestValue >= beta - && !pos.is_capture_or_promotion(move) + && !pos.is_capture_or_promotion(bestMove) && !inCheck) { - if (move != ss->killers[0]) + if (bestMove != ss->killers[0]) { ss->killers[1] = ss->killers[0]; - ss->killers[0] = move; + ss->killers[0] = bestMove; } // Increase history value of the cut-off move Value bonus = Value(int(depth) * int(depth)); - H.add(pos.piece_moved(move), to_sq(move), bonus); + H.add(pos.piece_moved(bestMove), to_sq(bestMove), bonus); // Decrease history of all the other played non-capture moves for (int i = 0; i < playedMoveCount - 1; i++) @@ -1712,6 +1709,10 @@ void Thread::idle_loop() { sp->mutex.lock(); + assert(sp->activePositions[idx] == NULL); + + sp->activePositions[idx] = &pos; + if (sp->nodeType == Root) search(pos, ss+1, sp->alpha, sp->beta, sp->depth); else if (sp->nodeType == PV) @@ -1724,6 +1725,7 @@ void Thread::idle_loop() { assert(is_searching); is_searching = false; + sp->activePositions[idx] = NULL; sp->slavesMask &= ~(1ULL << idx); sp->nodes += pos.nodes_searched(); @@ -1754,6 +1756,7 @@ void Thread::idle_loop() { void check_time() { static Time::point lastInfoTime = Time::now(); + int64_t nodes = 0; // Workaround silly 'uninitialized' gcc warning if (Time::now() - lastInfoTime >= 1000) { @@ -1764,6 +1767,35 @@ void check_time() { if (Limits.ponder) return; + if (Limits.nodes) + { + Threads.mutex.lock(); + + nodes = RootPosition.nodes_searched(); + + // Loop across all split points and sum accumulated SplitPoint nodes plus + // all the currently active slaves positions. + for (size_t i = 0; i < Threads.size(); i++) + for (int j = 0; j < Threads[i].splitPointsCnt; j++) + { + SplitPoint& sp = Threads[i].splitPoints[j]; + + sp.mutex.lock(); + + nodes += sp.nodes; + Bitboard sm = sp.slavesMask; + while (sm) + { + Position* pos = sp.activePositions[pop_lsb(&sm)]; + nodes += pos ? pos->nodes_searched() : 0; + } + + sp.mutex.unlock(); + } + + Threads.mutex.unlock(); + } + Time::point elapsed = Time::now() - SearchTime; bool stillAtFirstMove = Signals.firstRootMove && !Signals.failedLowAtRoot @@ -1773,6 +1805,7 @@ void check_time() { || stillAtFirstMove; if ( (Limits.use_time_management() && noMoreTime) - || (Limits.movetime && elapsed >= Limits.movetime)) + || (Limits.movetime && elapsed >= Limits.movetime) + || (Limits.nodes && nodes >= Limits.nodes)) Signals.stop = true; }