X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=c369bac3a98d0f64c2336f3cab725e380bc384ed;hp=eddf4ea93813e24d89312cc7549bef3f6fb3dc66;hb=14dbeb22dd04f0954322a58c26833506fb4532a9;hpb=1a03f0b0d369637081e29a235afd0bce4241b6dd diff --git a/src/search.cpp b/src/search.cpp index eddf4ea9..c369bac3 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -72,7 +72,6 @@ namespace { void set_active_threads(int newActiveThreads) { ActiveThreads = newActiveThreads; } void incrementNodeCounter(int threadID) { threads[threadID].nodes++; } void incrementBetaCounter(Color us, Depth d, int threadID) { threads[threadID].betaCutOffs[us] += unsigned(d); } - void print_current_line(SearchStack ss[], int ply, int threadID); void resetNodeCounters(); void resetBetaCounters(); @@ -85,17 +84,17 @@ namespace { void put_threads_to_sleep(); void idle_loop(int threadID, SplitPoint* waitSp); bool split(const Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue, - const Value futilityValue, Depth depth, int* moves, MovePicker* mp, int master, bool pvNode); + Depth depth, int* moves, MovePicker* mp, int master, bool pvNode); private: - friend void poll(); + friend void poll(SearchStack ss[], int ply); int ActiveThreads; volatile bool AllThreadsShouldExit, AllThreadsShouldSleep; Thread threads[MAX_THREADS]; SplitPoint SplitPointStack[MAX_THREADS][ACTIVE_SPLIT_POINTS_MAX]; - Lock MPLock, IOLock; + Lock MPLock; #if !defined(_MSC_VER) pthread_cond_t WaitCond; @@ -159,56 +158,80 @@ namespace { }; - /// Constants + /// Adjustments - // Search depth at iteration 1 - const Depth InitialDepth = OnePly; + // Step 6. Razoring - // Use internal iterative deepening? - const bool UseIIDAtPVNodes = true; - const bool UseIIDAtNonPVNodes = true; + // Maximum depth for razoring + const Depth RazorDepth = 4 * OnePly; - // Internal iterative deepening margin. At Non-PV moves, when - // UseIIDAtNonPVNodes is true, we do an internal iterative deepening - // search when the static evaluation is at most IIDMargin below beta. - const Value IIDMargin = Value(0x100); + // Dynamic razoring margin based on depth + inline Value razor_margin(Depth d) { return Value(0x200 + 0x10 * d); } - // Easy move margin. An easy move candidate must be at least this much - // better than the second best move. - const Value EasyMoveMargin = Value(0x200); + // Step 8. Null move search with verification search // Null move margin. A null move search will not be done if the static // evaluation of the position is more than NullMoveMargin below beta. const Value NullMoveMargin = Value(0x200); - // If the TT move is at least SingleReplyMargin better then the - // remaining ones we will extend it. - const Value SingleReplyMargin = Value(0x20); + // Maximum depth for use of dynamic threat detection when null move fails low + const Depth ThreatDepth = 5 * OnePly; - // Depth limit for razoring - const Depth RazorDepth = 4 * OnePly; + // Step 9. Internal iterative deepening - /// Lookup tables initialized at startup + // Minimum depth for use of internal iterative deepening + const Depth IIDDepthAtPVNodes = 5 * OnePly; + const Depth IIDDepthAtNonPVNodes = 8 * OnePly; - // Reduction lookup tables and their getter functions - int8_t PVReductionMatrix[64][64]; // [depth][moveNumber] - int8_t NonPVReductionMatrix[64][64]; // [depth][moveNumber] + // Internal iterative deepening margin. At Non-PV nodes + // we do an internal iterative deepening + // search when the static evaluation is at most IIDMargin below beta. + const Value IIDMargin = Value(0x100); - inline Depth pv_reduction(Depth d, int mn) { return (Depth) PVReductionMatrix[Min(d / 2, 63)][Min(mn, 63)]; } - inline Depth nonpv_reduction(Depth d, int mn) { return (Depth) NonPVReductionMatrix[Min(d / 2, 63)][Min(mn, 63)]; } + // Step 11. Decide the new search depth + + // Extensions. Configurable UCI options. + // Array index 0 is used at non-PV nodes, index 1 at PV nodes. + Depth CheckExtension[2], SingleEvasionExtension[2], PawnPushTo7thExtension[2]; + Depth PassedPawnExtension[2], PawnEndgameExtension[2], MateThreatExtension[2]; + + // Minimum depth for use of singular extension + const Depth SingularExtensionDepthAtPVNodes = 6 * OnePly; + const Depth SingularExtensionDepthAtNonPVNodes = 8 * OnePly; - // Futility lookup tables and their getter functions + // If the TT move is at least SingularExtensionMargin better then the + // remaining ones we will extend it. + const Value SingularExtensionMargin = Value(0x20); + + // Step 12. Futility pruning + + // Futility margin for quiescence search const Value FutilityMarginQS = Value(0x80); + + // Futility lookup tables (initialized at startup) and their getter functions int32_t FutilityMarginsMatrix[14][64]; // [depth][moveNumber] int FutilityMoveCountArray[32]; // [depth] inline Value futility_margin(Depth d, int mn) { return Value(d < 7*OnePly ? FutilityMarginsMatrix[Max(d, 0)][Min(mn, 63)] : 2 * VALUE_INFINITE); } inline int futility_move_count(Depth d) { return d < 16*OnePly ? FutilityMoveCountArray[d] : 512; } - /// Variables initialized by UCI options + // Step 14. Reduced search - // Depth limit for use of dynamic threat detection - Depth ThreatDepth; + // Reduction lookup tables (initialized at startup) and their getter functions + int8_t PVReductionMatrix[64][64]; // [depth][moveNumber] + int8_t NonPVReductionMatrix[64][64]; // [depth][moveNumber] + + inline Depth pv_reduction(Depth d, int mn) { return (Depth) PVReductionMatrix[Min(d / 2, 63)][Min(mn, 63)]; } + inline Depth nonpv_reduction(Depth d, int mn) { return (Depth) NonPVReductionMatrix[Min(d / 2, 63)][Min(mn, 63)]; } + + // Step. Common adjustments + + // Search depth at iteration 1 + const Depth InitialDepth = OnePly; + + // Easy move margin. An easy move candidate must be at least this much + // better than the second best move. + const Value EasyMoveMargin = Value(0x200); // Last seconds noise filtering (LSN) const bool UseLSNFiltering = true; @@ -216,9 +239,8 @@ namespace { const Value LSNValue = value_from_centipawns(200); bool loseOnTime = false; - // Extensions. Array index 0 is used at non-PV nodes, index 1 at PV nodes. - Depth CheckExtension[2], SingleEvasionExtension[2], PawnPushTo7thExtension[2]; - Depth PassedPawnExtension[2], PawnEndgameExtension[2], MateThreatExtension[2]; + + /// Global variables // Iteration counters int Iteration; @@ -288,7 +310,7 @@ namespace { int current_search_time(); int nps(); - void poll(); + void poll(SearchStack ss[], int ply); void ponderhit(); void wait_for_stop_or_ponderhit(); void init_ss_array(SearchStack ss[]); @@ -414,8 +436,6 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move, MateThreatExtension[1] = Depth(get_option_value_int("Mate Threat Extension (PV nodes)")); MateThreatExtension[0] = Depth(get_option_value_int("Mate Threat Extension (non-PV nodes)")); - ThreatDepth = get_option_value_int("Threat Depth") * OnePly; - Chess960 = get_option_value_bool("UCI_Chess960"); ShowCurrentLine = get_option_value_bool("UCI_ShowCurrLine"); UseLogFile = get_option_value_bool("Use Search Log"); @@ -1040,14 +1060,16 @@ namespace { assert(threadID >= 0 && threadID < TM.active_threads()); Move movesSearched[256]; + EvalInfo ei; StateInfo st; const TTEntry* tte; Move ttMove, move; Depth ext, newDepth; - Value oldAlpha, value; - bool isCheck, mateThreat, singleEvasion, moveIsCheck, captureOrPromotion, dangerous; + Value bestValue, value, oldAlpha; + bool isCheck, singleEvasion, moveIsCheck, captureOrPromotion, dangerous; + bool mateThreat = false; int moveCount = 0; - Value bestValue = value = -VALUE_INFINITE; + bestValue = value = -VALUE_INFINITE; if (depth < OnePly) return qsearch(pos, ss, alpha, beta, Depth(0), ply, threadID); @@ -1086,7 +1108,6 @@ namespace { isCheck = pos.is_check(); if (!isCheck) { - EvalInfo ei; ss[ply].eval = evaluate(pos, ei, threadID); update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval); } @@ -1096,8 +1117,7 @@ namespace { // Step 8. Null move search with verification search (is omitted in PV nodes) // Step 9. Internal iterative deepening - if ( UseIIDAtPVNodes - && depth >= 5*OnePly + if ( depth >= IIDDepthAtPVNodes && ttMove == MOVE_NONE) { search_pv(pos, ss, alpha, beta, depth-2*OnePly, ply, threadID); @@ -1129,7 +1149,7 @@ namespace { // Singular extension search. We extend the TT move if its value is much better than // its siblings. To verify this we do a reduced search on all the other moves but the // ttMove, if result is lower then ttValue minus a margin then we extend ttMove. - if ( depth >= 6 * OnePly + if ( depth >= SingularExtensionDepthAtPVNodes && tte && move == tte->move() && ext < OnePly @@ -1140,9 +1160,9 @@ namespace { if (abs(ttValue) < VALUE_KNOWN_WIN) { - Value excValue = search(pos, ss, ttValue - SingleReplyMargin, depth / 2, ply, false, threadID, move); + Value excValue = search(pos, ss, ttValue - SingularExtensionMargin, depth / 2, ply, false, threadID, move); - if (excValue < ttValue - SingleReplyMargin) + if (excValue < ttValue - SingularExtensionMargin) ext = OnePly; } } @@ -1219,7 +1239,7 @@ namespace { && TM.available_thread_exists(threadID) && !AbortSearch && !TM.thread_should_stop(threadID) - && TM.split(pos, ss, ply, &alpha, beta, &bestValue, VALUE_NONE, + && TM.split(pos, ss, ply, &alpha, beta, &bestValue, depth, &moveCount, &mp, threadID, true)) break; } @@ -1272,11 +1292,11 @@ namespace { const TTEntry* tte; Move ttMove, move; Depth ext, newDepth; - Value bestValue, staticValue, nullValue, value, futilityValue, futilityValueScaled; + Value bestValue, refinedValue, nullValue, value, futilityValueScaled; bool isCheck, singleEvasion, moveIsCheck, captureOrPromotion, dangerous; bool mateThreat = false; int moveCount = 0; - futilityValue = staticValue = bestValue = value = -VALUE_INFINITE; + refinedValue = bestValue = value = -VALUE_INFINITE; if (depth < OnePly) return qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID); @@ -1302,7 +1322,7 @@ namespace { // Step 4. Transposition table lookup // We don't want the score of a partial search to overwrite a previous full search - // TT value, so we use a different position key in case of an excluded move exsists. + // TT value, so we use a different position key in case of an excluded move exists. Key posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key(); tte = TT.retrieve(posKey); @@ -1320,13 +1340,11 @@ namespace { if (!isCheck) { if (tte && (tte->type() & VALUE_TYPE_EVAL)) - staticValue = value_from_tt(tte->value(), ply); + ss[ply].eval = value_from_tt(tte->value(), ply); else - staticValue = evaluate(pos, ei, threadID); + ss[ply].eval = evaluate(pos, ei, threadID); - ss[ply].eval = staticValue; - futilityValue = staticValue + futility_margin(depth, 0); //FIXME: Remove me, only for split - staticValue = refine_eval(tte, staticValue, ply); // Enhance accuracy with TT value if possible + refinedValue = refine_eval(tte, ss[ply].eval, ply); // Enhance accuracy with TT value if possible update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval); } @@ -1334,15 +1352,15 @@ namespace { if ( !value_is_mate(beta) && !isCheck && depth < RazorDepth - && staticValue < beta - (0x200 + 16 * depth) + && refinedValue < beta - razor_margin(depth) && ss[ply - 1].currentMove != MOVE_NULL && ttMove == MOVE_NONE && !pos.has_pawn_on_7th(pos.side_to_move())) { - Value rbeta = beta - (0x200 + 16 * depth); + Value rbeta = beta - razor_margin(depth); Value v = qsearch(pos, ss, rbeta-1, rbeta, Depth(0), ply, threadID); if (v < rbeta) - return v; //FIXME: Logically should be: return (v + 0x200 + 16 * depth); + return v; //FIXME: Logically should be: return (v + razor_margin(depth)); } // Step 7. Static null move pruning @@ -1351,8 +1369,8 @@ namespace { if ( !isCheck && allowNullmove && depth < RazorDepth - && staticValue - futility_margin(depth, 0) >= beta) - return staticValue - futility_margin(depth, 0); + && refinedValue - futility_margin(depth, 0) >= beta) + return refinedValue - futility_margin(depth, 0); // Step 8. Null move search with verification search // When we jump directly to qsearch() we do a null move only if static value is @@ -1363,7 +1381,7 @@ namespace { && !isCheck && !value_is_mate(beta) && ok_to_do_nullmove(pos) - && staticValue >= beta - (depth >= 4 * OnePly ? NullMoveMargin : 0)) + && refinedValue >= beta - (depth >= 4 * OnePly ? NullMoveMargin : 0)) { ss[ply].currentMove = MOVE_NULL; @@ -1373,7 +1391,7 @@ namespace { int R = 3 + (depth >= 5 * OnePly ? depth / 8 : 0); // Null move dynamic reduction based on value - if (staticValue - beta > PawnValueMidgame) + if (refinedValue - beta > PawnValueMidgame) R++; nullValue = -search(pos, ss, -(beta-1), depth-R*OnePly, ply+1, false, threadID); @@ -1408,8 +1426,10 @@ namespace { } // Step 9. Internal iterative deepening - if (UseIIDAtNonPVNodes && ttMove == MOVE_NONE && depth >= 8*OnePly && - !isCheck && ss[ply].eval >= beta - IIDMargin) + if ( depth >= IIDDepthAtNonPVNodes + && ttMove == MOVE_NONE + && !isCheck + && ss[ply].eval >= beta - IIDMargin) { search(pos, ss, beta, depth/2, ply, false, threadID); ttMove = ss[ply].pv[ply]; @@ -1420,7 +1440,7 @@ namespace { // Loop through all legal moves until no moves remain or a beta cutoff occurs // Initialize a MovePicker object for the current position - MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]); + MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply], beta); CheckInfo ci(pos); while ( bestValue < beta @@ -1442,7 +1462,7 @@ namespace { // Singular extension search. We extend the TT move if its value is much better than // its siblings. To verify this we do a reduced search on all the other moves but the // ttMove, if result is lower then ttValue minus a margin then we extend ttMove. - if ( depth >= 8 * OnePly + if ( depth >= SingularExtensionDepthAtNonPVNodes && tte && move == tte->move() && !excludedMove // Do not allow recursive single-reply search @@ -1454,9 +1474,9 @@ namespace { if (abs(ttValue) < VALUE_KNOWN_WIN) { - Value excValue = search(pos, ss, ttValue - SingleReplyMargin, depth / 2, ply, false, threadID, move); + Value excValue = search(pos, ss, ttValue - SingularExtensionMargin, depth / 2, ply, false, threadID, move); - if (excValue < ttValue - SingleReplyMargin) + if (excValue < ttValue - SingularExtensionMargin) ext = OnePly; } } @@ -1480,7 +1500,7 @@ namespace { continue; // Value based pruning - Depth predictedDepth = newDepth - nonpv_reduction(depth, moveCount); //FIXME: We are ignoring condition: depth >= 3*OnePly, BUG?? + Depth predictedDepth = newDepth - nonpv_reduction(depth, moveCount); // We illogically ignore reduction condition depth >= 3*OnePly futilityValueScaled = ss[ply].eval + futility_margin(predictedDepth, moveCount) + H.gain(pos.piece_on(move_from(move)), move_to(move)) + 45; @@ -1544,7 +1564,7 @@ namespace { && TM.available_thread_exists(threadID) && !AbortSearch && !TM.thread_should_stop(threadID) - && TM.split(pos, ss, ply, NULL, beta, &bestValue, futilityValue, //FIXME: SMP & futilityValue + && TM.split(pos, ss, ply, NULL, beta, &bestValue, depth, &moveCount, &mp, threadID, false)) break; } @@ -1781,23 +1801,28 @@ namespace { // splitting, we don't have to repeat all this work in sp_search(). 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. + // FIXME: We are currently ignoring mateThreat flag here void sp_search(SplitPoint* sp, int threadID) { assert(threadID >= 0 && threadID < TM.active_threads()); assert(TM.active_threads() > 1); - Position pos(*sp->pos); - CheckInfo ci(pos); - SearchStack* ss = sp->sstack[threadID]; StateInfo st; - Value value = -VALUE_INFINITE; Move move; + Depth ext, newDepth; + Value value, futilityValueScaled; + bool isCheck, moveIsCheck, captureOrPromotion, dangerous; int moveCount; - bool isCheck = pos.is_check(); - bool useFutilityPruning = sp->depth < 7 * OnePly //FIXME: sync with search - && !isCheck; + value = -VALUE_INFINITE; + + Position pos(*sp->pos); + CheckInfo ci(pos); + SearchStack* ss = sp->sstack[threadID]; + isCheck = pos.is_check(); + // Step 10. Loop through moves + // Loop through all legal moves until no moves remain or a beta cutoff occurs lock_grab(&(sp->lock)); while ( sp->bestValue < sp->beta @@ -1809,20 +1834,21 @@ namespace { assert(move_is_ok(move)); - bool moveIsCheck = pos.move_is_check(move, ci); - bool captureOrPromotion = pos.move_is_capture_or_promotion(move); + moveIsCheck = pos.move_is_check(move, ci); + captureOrPromotion = pos.move_is_capture_or_promotion(move); - ss[sp->ply].currentMove = move; + // Step 11. Decide the new search depth + ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, false, &dangerous); + newDepth = sp->depth - OnePly + ext; - // Decide the new search depth - bool dangerous; - Depth ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, false, &dangerous); - Depth newDepth = sp->depth - OnePly + ext; + // Update current move + ss[sp->ply].currentMove = move; - // Prune? - if ( useFutilityPruning + // Step 12. Futility pruning + if ( !isCheck && !dangerous - && !captureOrPromotion) + && !captureOrPromotion + && !move_is_castle(move)) { // Move count based pruning if ( moveCount >= futility_move_count(sp->depth) @@ -1834,7 +1860,9 @@ namespace { } // Value based pruning - Value futilityValueScaled = sp->futilityValue - moveCount * 8; //FIXME: sync with search + Depth predictedDepth = newDepth - nonpv_reduction(sp->depth, moveCount); + futilityValueScaled = ss[sp->ply].eval + futility_margin(predictedDepth, moveCount) + + H.gain(pos.piece_on(move_from(move)), move_to(move)) + 45; if (futilityValueScaled < sp->beta) { @@ -1908,19 +1936,24 @@ namespace { // don't have to repeat all this work in sp_search_pv(). 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. + // FIXME: We are ignoring mateThreat flag! void sp_search_pv(SplitPoint* sp, int threadID) { assert(threadID >= 0 && threadID < TM.active_threads()); assert(TM.active_threads() > 1); + StateInfo st; + Move move; + Depth ext, newDepth; + Value value; + bool moveIsCheck, captureOrPromotion, dangerous; + int moveCount; + value = -VALUE_INFINITE; + Position pos(*sp->pos); CheckInfo ci(pos); SearchStack* ss = sp->sstack[threadID]; - StateInfo st; - Value value = -VALUE_INFINITE; - int moveCount; - Move move; // Step 10. Loop through moves // Loop through all legal moves until no moves remain or a beta cutoff occurs @@ -1935,13 +1968,12 @@ namespace { assert(move_is_ok(move)); - bool moveIsCheck = pos.move_is_check(move, ci); - bool captureOrPromotion = pos.move_is_capture_or_promotion(move); + moveIsCheck = pos.move_is_check(move, ci); + captureOrPromotion = pos.move_is_capture_or_promotion(move); // Step 11. Decide the new search depth - bool dangerous; - Depth ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous); - Depth newDepth = sp->depth - OnePly + ext; + ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous); + newDepth = sp->depth - OnePly + ext; // Update current move ss[sp->ply].currentMove = move; @@ -2039,13 +2071,12 @@ namespace { NodesSincePoll++; if (NodesSincePoll >= NodesBetweenPolls) { - poll(); + poll(ss, ply); NodesSincePoll = 0; } } ss[ply].init(ply); ss[ply + 2].initKillers(); - TM.print_current_line(ss, ply, threadID); } @@ -2403,7 +2434,7 @@ namespace { // looks at the time consumed so far and decides if it's time to abort the // search. - void poll() { + void poll(SearchStack ss[], int ply) { static int lastInfoTime; int t = current_search_time(); @@ -2445,7 +2476,6 @@ namespace { else if (t - lastInfoTime >= 1000) { lastInfoTime = t; - lock_grab(&TM.IOLock); if (dbg_show_mean) dbg_print_mean(); @@ -2456,10 +2486,15 @@ namespace { cout << "info nodes " << TM.nodes_searched() << " nps " << nps() << " time " << t << " hashfull " << TT.full() << endl; - lock_release(&TM.IOLock); + // We only support current line printing in single thread mode + if (ShowCurrentLine && TM.active_threads() == 1) + { + cout << "info currline"; + for (int p = 0; p < ply; p++) + cout << " " << ss[p].currentMove; - if (ShowCurrentLine) - TM.threads[0].printCurrentLineRequest = true; + cout << endl; + } } // Should we stop the search? @@ -2688,7 +2723,6 @@ namespace { // Initialize global locks lock_init(&MPLock, NULL); - lock_init(&IOLock, NULL); // Initialize SplitPointStack locks for (i = 0; i < MAX_THREADS; i++) @@ -2846,7 +2880,7 @@ namespace { // splitPoint->cpus becomes 0), split() returns true. bool ThreadsManager::split(const Position& p, SearchStack* sstck, int ply, - Value* alpha, const Value beta, Value* bestValue, const Value futilityValue, + Value* alpha, const Value beta, Value* bestValue, Depth depth, int* moves, MovePicker* mp, int master, bool pvNode) { assert(p.is_ok()); @@ -2886,7 +2920,6 @@ namespace { splitPoint->beta = beta; splitPoint->pvNode = pvNode; splitPoint->bestValue = *bestValue; - splitPoint->futilityValue = futilityValue; splitPoint->master = master; splitPoint->mp = mp; splitPoint->moves = *moves; @@ -2966,9 +2999,6 @@ namespace { if (ActiveThreads == 1) return; - for (int i = 1; i < ActiveThreads; i++) - assert(threads[i].state == THREAD_SLEEPING); - #if !defined(_MSC_VER) pthread_mutex_lock(&WaitLock); pthread_cond_broadcast(&WaitCond); @@ -2991,47 +3021,8 @@ namespace { // This makes the threads to go to sleep AllThreadsShouldSleep = true; - - // Reset flags to a known state. - for (int i = 1; i < ActiveThreads; i++) - { - // This flag can be in a random state - threads[i].printCurrentLineRequest = false; - } } - // print_current_line() prints _once_ the current line of search for a - // given thread and then setup the print request for the next thread. - // Called when the UCI option UCI_ShowCurrLine is 'true'. - - void ThreadsManager::print_current_line(SearchStack ss[], int ply, int threadID) { - - assert(ply >= 0 && ply < PLY_MAX); - assert(threadID >= 0 && threadID < ActiveThreads); - - if (!threads[threadID].printCurrentLineRequest) - return; - - // One shot only - threads[threadID].printCurrentLineRequest = false; - - if (threads[threadID].state == THREAD_SEARCHING) - { - lock_grab(&IOLock); - cout << "info currline " << (threadID + 1); - for (int p = 0; p < ply; p++) - cout << " " << ss[p].currentMove; - - cout << endl; - lock_release(&IOLock); - } - - // Setup print request for the next thread ID - if (threadID + 1 < ActiveThreads) - threads[threadID + 1].printCurrentLineRequest = true; - } - - /// The RootMoveList class // RootMoveList c'tor