X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=121575f554525c6a2b13b52140a7d4d6fa2f86b6;hp=46dd53ebd1e7919bb937699d649f1996b7553939;hb=efeb37c33f15a903dbe5706529a7a26511e9ca58;hpb=13d8231746686118f0175111c769b55f48a6592e diff --git a/src/search.cpp b/src/search.cpp index 46dd53eb..121575f5 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -59,6 +59,10 @@ namespace { // Used for debugging SMP code. const bool FakeSplit = false; + // Fast lookup table of sliding pieces indexed by Piece + const bool Slidings[18] = { 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1 }; + inline bool piece_is_slider(Piece p) { return Slidings[p]; } + // ThreadsManager class is used to handle all the threads related stuff in search, // init, starting, parking and, the most important, launching a slave thread at a // split point are what this class does. All the access to shared thread data is @@ -75,28 +79,22 @@ namespace { int active_threads() const { return ActiveThreads; } void set_active_threads(int newActiveThreads) { ActiveThreads = newActiveThreads; } - void incrementNodeCounter(int threadID) { threads[threadID].nodes++; } - void resetNodeCounters(); - int64_t nodes_searched() const; bool available_thread_exists(int master) const; bool thread_is_available(int slave, int master) const; bool thread_should_stop(int threadID) const; void wake_sleeping_thread(int threadID); - void put_threads_to_sleep(); void idle_loop(int threadID, SplitPoint* sp); template - void split(const Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue, + void split(Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue, Depth depth, Move threatMove, bool mateThreat, int moveCount, MovePicker* mp, bool pvNode); private: - friend void poll(); - int ActiveThreads; volatile bool AllThreadsShouldExit; Thread threads[MAX_THREADS]; - Lock MPLock, WaitLock; + Lock MPLock; WaitCondition WaitCond[MAX_THREADS]; }; @@ -234,7 +232,10 @@ namespace { const Value EasyMoveMargin = Value(0x200); - /// Global variables + /// Namespace variables + + // Book object + Book OpeningBook; // Iteration counter int Iteration; @@ -262,6 +263,7 @@ namespace { // Multi-threads related variables Depth MinimumSplitDepth; int MaxThreadsPerSplitPoint; + bool UseSleepingMaster; ThreadsManager ThreadsMgr; // Node counters, used only by thread[0] but try to keep in different cache @@ -274,19 +276,21 @@ namespace { /// Local functions - Value id_loop(const Position& pos, Move searchMoves[]); + Value id_loop(Position& pos, Move searchMoves[]); Value root_search(Position& pos, SearchStack* ss, Move* pv, RootMoveList& rml, Value* alphaPtr, Value* betaPtr); template Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply); template - inline Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) { - return search(pos, ss, alpha, beta, depth, ply); - } + Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply); template - Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply); + inline Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) { + + return depth < ONE_PLY ? qsearch(pos, ss, alpha, beta, DEPTH_ZERO, ply) + : search(pos, ss, alpha, beta, depth, ply); + } template Depth extension(const Position& pos, Move m, bool captureOrPromotion, bool moveIsCheck, bool singleEvasion, bool mateThreat, bool* dangerous); @@ -304,8 +308,8 @@ namespace { int current_search_time(); std::string value_to_uci(Value v); - int nps(); - void poll(); + int nps(const Position& pos); + void poll(const Position& pos); void ponderhit(); void wait_for_stop_or_ponderhit(); void init_ss_array(SearchStack* ss, int size); @@ -314,7 +318,7 @@ namespace { void extract_pv_from_tt(const Position& pos, Move bestMove, Move pv[]); #if !defined(_MSC_VER) - void *init_thread(void *threadID); + void* init_thread(void* threadID); #else DWORD WINAPI init_thread(LPVOID threadID); #endif @@ -331,7 +335,6 @@ namespace { void init_threads() { ThreadsMgr.init_threads(); } void exit_threads() { ThreadsMgr.exit_threads(); } -int64_t nodes_searched() { return ThreadsMgr.nodes_searched(); } /// init_search() is called during startup. It initializes various lookup tables @@ -397,13 +400,12 @@ int perft(Position& pos, Depth depth) /// search-related global variables, and calls root_search(). It returns false /// when a quit command is received during the search. -bool think(const Position& pos, bool infinite, bool ponder, int time[], int increment[], +bool think(Position& pos, bool infinite, bool ponder, int time[], int increment[], int movesToGo, int maxDepth, int maxNodes, int maxTime, Move searchMoves[]) { // Initialize global search variables StopOnPonderhit = AbortSearch = Quit = AspirationFailLow = false; NodesSincePoll = 0; - ThreadsMgr.resetNodeCounters(); SearchStartTime = get_system_time(); ExactMaxTime = maxTime; MaxDepth = maxDepth; @@ -413,12 +415,12 @@ bool think(const Position& pos, bool infinite, bool ponder, int time[], int incr UseTimeManagement = !ExactMaxTime && !MaxDepth && !MaxNodes && !InfiniteSearch; // Look for a book move, only during games, not tests - if (UseTimeManagement && get_option_value_bool("OwnBook")) + if (UseTimeManagement && Options["OwnBook"].value()) { - if (get_option_value_string("Book File") != OpeningBook.file_name()) - OpeningBook.open(get_option_value_string("Book File")); + if (Options["Book File"].value() != OpeningBook.file_name()) + OpeningBook.open(Options["Book File"].value()); - Move bookMove = OpeningBook.get_move(pos, get_option_value_bool("Best Book Move")); + Move bookMove = OpeningBook.get_move(pos, Options["Best Book Move"].value()); if (bookMove != MOVE_NONE) { if (PonderSearch) @@ -430,45 +432,45 @@ bool think(const Position& pos, bool infinite, bool ponder, int time[], int incr } // Read UCI option values - TT.set_size(get_option_value_int("Hash")); - if (button_was_pressed("Clear Hash")) + TT.set_size(Options["Hash"].value()); + if (Options["Clear Hash"].value()) + { + Options["Clear Hash"].set_value("false"); TT.clear(); + } - CheckExtension[1] = Depth(get_option_value_int("Check Extension (PV nodes)")); - CheckExtension[0] = Depth(get_option_value_int("Check Extension (non-PV nodes)")); - SingleEvasionExtension[1] = Depth(get_option_value_int("Single Evasion Extension (PV nodes)")); - SingleEvasionExtension[0] = Depth(get_option_value_int("Single Evasion Extension (non-PV nodes)")); - PawnPushTo7thExtension[1] = Depth(get_option_value_int("Pawn Push to 7th Extension (PV nodes)")); - PawnPushTo7thExtension[0] = Depth(get_option_value_int("Pawn Push to 7th Extension (non-PV nodes)")); - PassedPawnExtension[1] = Depth(get_option_value_int("Passed Pawn Extension (PV nodes)")); - PassedPawnExtension[0] = Depth(get_option_value_int("Passed Pawn Extension (non-PV nodes)")); - PawnEndgameExtension[1] = Depth(get_option_value_int("Pawn Endgame Extension (PV nodes)")); - PawnEndgameExtension[0] = Depth(get_option_value_int("Pawn Endgame Extension (non-PV nodes)")); - 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)")); - - MinimumSplitDepth = get_option_value_int("Minimum Split Depth") * ONE_PLY; - MaxThreadsPerSplitPoint = get_option_value_int("Maximum Number of Threads per Split Point"); - MultiPV = get_option_value_int("MultiPV"); - UseLogFile = get_option_value_bool("Use Search Log"); + CheckExtension[1] = Options["Check Extension (PV nodes)"].value(); + CheckExtension[0] = Options["Check Extension (non-PV nodes)"].value(); + SingleEvasionExtension[1] = Options["Single Evasion Extension (PV nodes)"].value(); + SingleEvasionExtension[0] = Options["Single Evasion Extension (non-PV nodes)"].value(); + PawnPushTo7thExtension[1] = Options["Pawn Push to 7th Extension (PV nodes)"].value(); + PawnPushTo7thExtension[0] = Options["Pawn Push to 7th Extension (non-PV nodes)"].value(); + PassedPawnExtension[1] = Options["Passed Pawn Extension (PV nodes)"].value(); + PassedPawnExtension[0] = Options["Passed Pawn Extension (non-PV nodes)"].value(); + PawnEndgameExtension[1] = Options["Pawn Endgame Extension (PV nodes)"].value(); + PawnEndgameExtension[0] = Options["Pawn Endgame Extension (non-PV nodes)"].value(); + MateThreatExtension[1] = Options["Mate Threat Extension (PV nodes)"].value(); + MateThreatExtension[0] = Options["Mate Threat Extension (non-PV nodes)"].value(); + + MinimumSplitDepth = Options["Minimum Split Depth"].value() * ONE_PLY; + MaxThreadsPerSplitPoint = Options["Maximum Number of Threads per Split Point"].value(); + MultiPV = Options["MultiPV"].value(); + UseLogFile = Options["Use Search Log"].value(); + UseSleepingMaster = Options["Use Sleeping Master"].value(); if (UseLogFile) - LogFile.open(get_option_value_string("Search Log Filename").c_str(), std::ios::out | std::ios::app); + LogFile.open(Options["Search Log Filename"].value().c_str(), std::ios::out | std::ios::app); read_weights(pos.side_to_move()); // Set the number of active threads - int newActiveThreads = get_option_value_int("Threads"); + int newActiveThreads = Options["Threads"].value(); if (newActiveThreads != ThreadsMgr.active_threads()) { ThreadsMgr.set_active_threads(newActiveThreads); init_eval(ThreadsMgr.active_threads()); } - // Wake up needed threads - for (int i = 1; i < newActiveThreads; i++) - ThreadsMgr.wake_sleeping_thread(i); - // Set thinking time int myTime = time[pos.side_to_move()]; int myIncrement = increment[pos.side_to_move()]; @@ -501,8 +503,6 @@ bool think(const Position& pos, bool infinite, bool ponder, int time[], int incr if (UseLogFile) LogFile.close(); - ThreadsMgr.put_threads_to_sleep(); - return !Quit; } @@ -514,16 +514,15 @@ namespace { // been consumed, the user stops the search, or the maximum search depth is // reached. - Value id_loop(const Position& pos, Move searchMoves[]) { + Value id_loop(Position& pos, Move searchMoves[]) { - Position p(pos, pos.thread()); SearchStack ss[PLY_MAX_PLUS_2]; Move pv[PLY_MAX_PLUS_2]; Move EasyMove = MOVE_NONE; Value value, alpha = -VALUE_INFINITE, beta = VALUE_INFINITE; // Moves to search are verified, copied, scored and sorted - RootMoveList rml(p, searchMoves); + RootMoveList rml(pos, searchMoves); // Handle special case of searching on a mate/stale position if (rml.move_count() == 0) @@ -536,13 +535,13 @@ namespace { // Print RootMoveList startup scoring to the standard output, // so to output information also for iteration 1. - cout << set960(p.is_chess960()) // Is enough to set once at the beginning + cout << set960(pos.is_chess960()) // Is enough to set once at the beginning << "info depth " << 1 << "\ninfo depth " << 1 << " score " << value_to_uci(rml.move_score(0)) << " time " << current_search_time() - << " nodes " << ThreadsMgr.nodes_searched() - << " nps " << nps() + << " nodes " << pos.nodes_searched() + << " nps " << nps(pos) << " pv " << rml.move(0) << "\n"; // Initialize @@ -581,11 +580,11 @@ namespace { } // Search to the current depth, rml is updated and sorted, alpha and beta could change - value = root_search(p, ss, pv, rml, &alpha, &beta); + value = root_search(pos, ss, pv, rml, &alpha, &beta); // Write PV to transposition table, in case the relevant entries have // been overwritten during the search. - insert_pv_in_tt(p, pv); + insert_pv_in_tt(pos, pv); if (AbortSearch) break; // Value cannot be trusted. Break out immediately! @@ -614,12 +613,11 @@ namespace { stopSearch = true; // Stop search early if one move seems to be much better than the others - int64_t nodes = ThreadsMgr.nodes_searched(); if ( Iteration >= 8 && EasyMove == pv[0] - && ( ( rml.move_nodes(0) > (nodes * 85) / 100 + && ( ( rml.move_nodes(0) > (pos.nodes_searched() * 85) / 100 && current_search_time() > TimeMgr.available_time() / 16) - ||( rml.move_nodes(0) > (nodes * 98) / 100 + ||( rml.move_nodes(0) > (pos.nodes_searched() * 98) / 100 && current_search_time() > TimeMgr.available_time() / 32))) stopSearch = true; @@ -653,8 +651,8 @@ namespace { wait_for_stop_or_ponderhit(); else // Print final search statistics - cout << "info nodes " << ThreadsMgr.nodes_searched() - << " nps " << nps() + cout << "info nodes " << pos.nodes_searched() + << " nps " << nps(pos) << " time " << current_search_time() << endl; // Print the best move and the ponder move to the standard output @@ -681,14 +679,14 @@ namespace { if (dbg_show_hit_rate) dbg_print_hit_rate(LogFile); - LogFile << "\nNodes: " << ThreadsMgr.nodes_searched() - << "\nNodes/second: " << nps() - << "\nBest move: " << move_to_san(p, pv[0]); + LogFile << "\nNodes: " << pos.nodes_searched() + << "\nNodes/second: " << nps(pos) + << "\nBest move: " << move_to_san(pos, pv[0]); StateInfo st; - p.do_move(pv[0], st); + pos.do_move(pv[0], st); LogFile << "\nPonder move: " - << move_to_san(p, pv[1]) // Works also with MOVE_NONE + << move_to_san(pos, pv[1]) // Works also with MOVE_NONE << endl; } return rml.move_score(0); @@ -750,7 +748,7 @@ namespace { FirstRootMove = (i == 0); // Save the current node count before the move is searched - nodes = ThreadsMgr.nodes_searched(); + nodes = pos.nodes_searched(); // Pick the next root move, and print the move and the move number to // the standard output. @@ -871,7 +869,7 @@ namespace { break; // Remember searched nodes counts for this move - rml.add_move_nodes(i, ThreadsMgr.nodes_searched() - nodes); + rml.add_move_nodes(i, pos.nodes_searched() - nodes); assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE); assert(value < beta); @@ -913,8 +911,8 @@ namespace { << " score " << value_to_uci(rml.move_score(j)) << " depth " << (j <= i ? Iteration : Iteration - 1) << " time " << current_search_time() - << " nodes " << ThreadsMgr.nodes_searched() - << " nps " << nps() + << " nodes " << pos.nodes_searched() + << " nps " << nps(pos) << " pv "; for (int k = 0; rml.move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++) @@ -973,6 +971,7 @@ namespace { Key posKey; Move ttMove, move, excludedMove, threatMove; Depth ext, newDepth; + ValueType vt; Value bestValue, value, oldAlpha; Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific bool isCheck, singleEvasion, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous; @@ -992,24 +991,21 @@ namespace { threatMove = sp->threatMove; mateThreat = sp->mateThreat; goto split_point_start; - } + } else {} // Hack to fix icc's "statement is unreachable" warning // Step 1. Initialize node and poll. Polling can abort search - ThreadsMgr.incrementNodeCounter(threadID); ss->currentMove = ss->bestMove = threatMove = MOVE_NONE; (ss+2)->killers[0] = (ss+2)->killers[1] = (ss+2)->mateKiller = MOVE_NONE; if (threadID == 0 && ++NodesSincePoll > NodesBetweenPolls) { NodesSincePoll = 0; - poll(); + poll(pos); } // Step 2. Check for aborted search and immediate draw - if (AbortSearch || ThreadsMgr.thread_should_stop(threadID)) - return VALUE_DRAW; - - if (pos.is_draw() || ply >= PLY_MAX - 1) + if ( AbortSearch || ThreadsMgr.thread_should_stop(threadID) + || pos.is_draw() || ply >= PLY_MAX - 1) return VALUE_DRAW; // Step 3. Mate distance pruning @@ -1026,7 +1022,7 @@ namespace { posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key(); tte = TT.retrieve(posKey); - ttMove = (tte ? tte->move() : MOVE_NONE); + ttMove = tte ? tte->move() : MOVE_NONE; // At PV nodes, we don't use the TT for pruning, but only for move ordering. // This is to avoid problems in the following areas: @@ -1035,12 +1031,9 @@ namespace { // * Fifty move rule detection // * Searching for a mate // * Printing of full PV line - if (!PvNode && tte && ok_to_use_TT(tte, depth, beta, ply)) { - // Refresh tte entry to avoid aging - TT.store(posKey, tte->value(), tte->type(), tte->depth(), ttMove, tte->static_value(), tte->static_value_margin()); - + TT.refresh(tte); ss->bestMove = ttMove; // Can be MOVE_NONE return value_from_tt(tte->value(), ply); } @@ -1116,9 +1109,7 @@ namespace { pos.do_null_move(st); (ss+1)->skipNullMove = true; - - nullValue = depth-R*ONE_PLY < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1) - : - search(pos, ss+1, -beta, -alpha, depth-R*ONE_PLY, ply+1); + nullValue = -search(pos, ss+1, -beta, -alpha, depth-R*ONE_PLY, ply+1); (ss+1)->skipNullMove = false; pos.undo_null_move(); @@ -1181,7 +1172,7 @@ split_point_start: // At split points actual search starts from here // Initialize a MovePicker object for the current position // FIXME currently MovePicker() c'tor is needless called also in SplitPoint - MovePicker mpBase = MovePicker(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta)); + MovePicker mpBase(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta)); MovePicker& mp = SpNode ? *sp->mp : mpBase; CheckInfo ci(pos); ss->bestMove = MOVE_NONE; @@ -1206,16 +1197,17 @@ split_point_start: // At split points actual search starts from here && (move = mp.get_next_move()) != MOVE_NONE && !ThreadsMgr.thread_should_stop(threadID)) { + assert(move_is_ok(move)); + if (SpNode) { moveCount = ++sp->moveCount; lock_release(&(sp->lock)); } - - assert(move_is_ok(move)); - - if (move == excludedMove) + else if (move == excludedMove) continue; + else + movesSearched[moveCount++] = move; moveIsCheck = pos.move_is_check(move, ci); captureOrPromotion = pos.move_is_capture_or_promotion(move); @@ -1247,10 +1239,9 @@ split_point_start: // At split points actual search starts from here } } - newDepth = depth - ONE_PLY + ext; - // Update current move (this must be done after singular extension search) - movesSearched[moveCount++] = ss->currentMove = move; + ss->currentMove = move; + newDepth = depth - ONE_PLY + ext; // Step 12. Futility pruning (is omitted in PV nodes) if ( !PvNode @@ -1299,8 +1290,7 @@ split_point_start: // At split points actual search starts from here // Step extra. pv search (only in PV nodes) // The first move in list is the expected PV if (!SpNode && PvNode && moveCount == 1) - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1) - : - search(pos, ss+1, -beta, -alpha, newDepth, ply+1); + value = -search(pos, ss+1, -beta, -alpha, newDepth, ply+1); else { // Step 14. Reduced depth search @@ -1318,8 +1308,7 @@ split_point_start: // At split points actual search starts from here { alpha = SpNode ? sp->alpha : alpha; Depth d = newDepth - ss->reduction; - value = d < ONE_PLY ? -qsearch(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1) - : - search(pos, ss+1, -(alpha+1), -alpha, d, ply+1); + value = -search(pos, ss+1, -(alpha+1), -alpha, d, ply+1); doFullDepthSearch = (value > alpha); } @@ -1343,15 +1332,13 @@ split_point_start: // At split points actual search starts from here if (doFullDepthSearch) { alpha = SpNode ? sp->alpha : alpha; - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1) - : - search(pos, ss+1, -(alpha+1), -alpha, newDepth, ply+1); + value = -search(pos, ss+1, -(alpha+1), -alpha, newDepth, ply+1); // Step extra. pv search (only in PV nodes) // Search only for possible new PV nodes, if instead value >= beta then // parent node fails low with value <= alpha and tries another move. if (PvNode && value > alpha && value < beta) - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1) - : - search(pos, ss+1, -beta, -alpha, newDepth, ply+1); + value = -search(pos, ss+1, -beta, -alpha, newDepth, ply+1); } } @@ -1371,24 +1358,29 @@ split_point_start: // At split points actual search starts from here if (value > bestValue && !(SpNode && ThreadsMgr.thread_should_stop(threadID))) { bestValue = value; + + if (SpNode) + sp->bestValue = value; + if (value > alpha) { if (SpNode && (!PvNode || value >= beta)) sp->stopRequest = true; if (PvNode && value < beta) // We want always alpha < beta + { alpha = value; + if (SpNode) + sp->alpha = value; + } if (value == value_mate_in(ply + 1)) ss->mateKiller = move; ss->bestMove = move; - } - if (SpNode) - { - sp->bestValue = bestValue; - sp->alpha = alpha; - sp->parentSstack->bestMove = ss->bestMove; + + if (SpNode) + sp->parentSstack->bestMove = move; } } @@ -1405,37 +1397,39 @@ split_point_start: // At split points actual search starts from here threatMove, mateThreat, moveCount, &mp, PvNode); } - if (SpNode) - { - /* Here we have the lock still grabbed */ - sp->slaves[threadID] = 0; - lock_release(&(sp->lock)); - return bestValue; - } - // Step 19. Check for mate and stalemate // All legal moves have been searched and if there are // no legal moves, it must be mate or stalemate. // If one move was excluded return fail low score. - if (!moveCount) + if (!SpNode && !moveCount) return excludedMove ? oldAlpha : isCheck ? value_mated_in(ply) : VALUE_DRAW; // Step 20. Update tables // If the search is not aborted, update the transposition table, // history counters, and killer moves. - if (AbortSearch || ThreadsMgr.thread_should_stop(threadID)) - return bestValue; + if (!SpNode && !AbortSearch && !ThreadsMgr.thread_should_stop(threadID)) + { + move = bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove; + vt = bestValue <= oldAlpha ? VALUE_TYPE_UPPER + : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT; - ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT); - move = (bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove); - TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, ss->evalMargin); + TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, ss->evalMargin); - // Update killers and history only for non capture moves that fails high - if ( bestValue >= beta - && !pos.move_is_capture_or_promotion(move)) - { + // Update killers and history only for non capture moves that fails high + if ( bestValue >= beta + && !pos.move_is_capture_or_promotion(move)) + { update_history(pos, move, depth, movesSearched, moveCount); update_killers(move, ss); + } + } + + if (SpNode) + { + // Here we have the lock still grabbed + sp->slaves[threadID] = 0; + sp->nodes += pos.nodes_searched(); + lock_release(&(sp->lock)); } assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE); @@ -1465,7 +1459,6 @@ split_point_start: // At split points actual search starts from here const TTEntry* tte; Value oldAlpha = alpha; - ThreadsMgr.incrementNodeCounter(pos.thread()); ss->bestMove = ss->currentMove = MOVE_NONE; // Check for an instant draw or maximum ply reached @@ -1926,10 +1919,10 @@ split_point_start: // At split points actual search starts from here // nps() computes the current nodes/second count. - int nps() { + int nps(const Position& pos) { int t = current_search_time(); - return (t > 0 ? int((ThreadsMgr.nodes_searched() * 1000) / t) : 0); + return (t > 0 ? int((pos.nodes_searched() * 1000) / t) : 0); } @@ -1937,13 +1930,13 @@ split_point_start: // At split points actual search starts from here // looks at the time consumed so far and decides if it's time to abort the // search. - void poll() { + void poll(const Position& pos) { static int lastInfoTime; int t = current_search_time(); // Poll for input - if (Bioskey()) + if (data_available()) { // We are line oriented, don't read single chars std::string command; @@ -1986,7 +1979,7 @@ split_point_start: // At split points actual search starts from here if (dbg_show_hit_rate) dbg_print_hit_rate(); - cout << "info nodes " << ThreadsMgr.nodes_searched() << " nps " << nps() + cout << "info nodes " << pos.nodes_searched() << " nps " << nps(pos) << " time " << t << endl; } @@ -2003,7 +1996,7 @@ split_point_start: // At split points actual search starts from here if ( (Iteration >= 3 && UseTimeManagement && noMoreTime) || (ExactMaxTime && t >= ExactMaxTime) - || (Iteration >= 3 && MaxNodes && ThreadsMgr.nodes_searched() >= MaxNodes)) + || (Iteration >= 3 && MaxNodes && pos.nodes_searched() >= MaxNodes)) AbortSearch = true; } @@ -2083,8 +2076,8 @@ split_point_start: // At split points actual search starts from here << " score " << value_to_uci(value) << (value >= beta ? " lowerbound" : value <= alpha ? " upperbound" : "") << " time " << current_search_time() - << " nodes " << ThreadsMgr.nodes_searched() - << " nps " << nps() + << " nodes " << pos.nodes_searched() + << " nps " << nps(pos) << " pv "; for (Move* m = pv; *m != MOVE_NONE; m++) @@ -2097,8 +2090,7 @@ split_point_start: // At split points actual search starts from here ValueType t = value >= beta ? VALUE_TYPE_LOWER : value <= alpha ? VALUE_TYPE_UPPER : VALUE_TYPE_EXACT; - LogFile << pretty_pv(pos, current_search_time(), Iteration, - ThreadsMgr.nodes_searched(), value, t, pv) << endl; + LogFile << pretty_pv(pos, current_search_time(), Iteration, value, t, pv) << endl; } } @@ -2164,7 +2156,7 @@ split_point_start: // At split points actual search starts from here #if !defined(_MSC_VER) - void* init_thread(void *threadID) { + void* init_thread(void* threadID) { ThreadsMgr.idle_loop(*(int*)threadID, NULL); return NULL; @@ -2183,25 +2175,6 @@ split_point_start: // At split points actual search starts from here /// The ThreadsManager class - // resetNodeCounters(), resetBetaCounters(), searched_nodes() and - // get_beta_counters() are getters/setters for the per thread - // counters used to sort the moves at root. - - void ThreadsManager::resetNodeCounters() { - - for (int i = 0; i < MAX_THREADS; i++) - threads[i].nodes = 0ULL; - } - - int64_t ThreadsManager::nodes_searched() const { - - int64_t result = 0ULL; - for (int i = 0; i < ActiveThreads; i++) - result += threads[i].nodes; - - return result; - } - // 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 @@ -2211,6 +2184,9 @@ split_point_start: // At split points actual search starts from here assert(threadID >= 0 && threadID < MAX_THREADS); + int i; + bool allFinished = false; + while (true) { // Slave threads can exit as soon as AllThreadsShouldExit raises, @@ -2225,24 +2201,30 @@ split_point_start: // At split points actual search starts from here // If we are not thinking, wait for a condition to be signaled // instead of wasting CPU time polling for work. while ( threadID >= ActiveThreads - || threads[threadID].state == THREAD_INITIALIZING) + || threads[threadID].state == THREAD_INITIALIZING + || (threads[threadID].state == THREAD_AVAILABLE && (!sp || UseSleepingMaster))) { - assert(!sp); - assert(threadID != 0); - - if (AllThreadsShouldExit) + lock_grab(&MPLock); + + // Test with lock held to avoid races with wake_sleeping_thread() + for (i = 0; sp && i < ActiveThreads && !sp->slaves[i]; i++) {} + allFinished = (i == ActiveThreads); + + // Retest sleep conditions under lock protection + if ( AllThreadsShouldExit + || allFinished + || !( threadID >= ActiveThreads + || threads[threadID].state == THREAD_INITIALIZING + || (threads[threadID].state == THREAD_AVAILABLE && (!sp || UseSleepingMaster)))) + { + lock_release(&MPLock); break; + } + // Put thread to sleep threads[threadID].state = THREAD_AVAILABLE; - -#if !defined(_MSC_VER) - lock_grab(&WaitLock); - if (threadID >= ActiveThreads) - pthread_cond_wait(&WaitCond[threadID], &WaitLock); - lock_release(&WaitLock); -#else - WaitForSingleObject(WaitCond[threadID], INFINITE); -#endif + cond_wait(&WaitCond[threadID], &MPLock); + lock_release(&MPLock); } // If this thread has been assigned work, launch a search @@ -2260,20 +2242,25 @@ split_point_start: // At split points actual search starts from here if (tsp->pvNode) search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); - else + else { search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); - + } assert(threads[threadID].state == THREAD_SEARCHING); threads[threadID].state = THREAD_AVAILABLE; + + // 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 (UseSleepingMaster && threadID != tsp->master && threads[tsp->master].state == THREAD_AVAILABLE) + wake_sleeping_thread(tsp->master); } // 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. - int i = 0; - for ( ; sp && i < ActiveThreads && !sp->slaves[i]; i++) {} + for (i = 0; sp && i < ActiveThreads && !sp->slaves[i]; i++) {} + allFinished = (i == ActiveThreads); - if (i == ActiveThreads) + if (allFinished) { // Because sp->slaves[] is reset under lock protection, // be sure sp->lock has been released before to return. @@ -2297,19 +2284,14 @@ split_point_start: // At split points actual search starts from here void ThreadsManager::init_threads() { - volatile int i; + int i, arg[MAX_THREADS]; bool ok; // Initialize global locks lock_init(&MPLock); - lock_init(&WaitLock); for (i = 0; i < MAX_THREADS; i++) -#if !defined(_MSC_VER) - pthread_cond_init(&WaitCond[i], NULL); -#else - WaitCond[i] = CreateEvent(0, FALSE, FALSE, 0); -#endif + cond_init(&WaitCond[i]); // Initialize splitPoints[] locks for (i = 0; i < MAX_THREADS; i++) @@ -2330,18 +2312,19 @@ split_point_start: // At split points actual search starts from here // Launch the helper threads for (i = 1; i < MAX_THREADS; i++) { + arg[i] = i; #if !defined(_MSC_VER) pthread_t pthread[1]; - ok = (pthread_create(pthread, NULL, init_thread, (void*)(&i)) == 0); + ok = (pthread_create(pthread, NULL, init_thread, (void*)(&arg[i])) == 0); + pthread_detach(pthread[0]); #else - ok = (CreateThread(NULL, 0, init_thread, (LPVOID)(&i), 0, NULL) != NULL); + ok = (CreateThread(NULL, 0, init_thread, (LPVOID)(&arg[i]), 0, NULL) != NULL); #endif - if (!ok) { cout << "Failed to create thread number " << i << endl; - Application::exit_with_failure(); + exit(EXIT_FAILURE); } // Wait until the thread has finished launching and is gone to sleep @@ -2369,7 +2352,6 @@ split_point_start: // At split points actual search starts from here for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++) lock_destroy(&(threads[i].splitPoints[j].lock)); - lock_destroy(&WaitLock); lock_destroy(&MPLock); // Now we can safely destroy the wait conditions @@ -2450,25 +2432,24 @@ split_point_start: // At split points actual search starts from here // split point objects), 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 we tell our helper threads that they have - // been assigned work. This will cause them to instantly leave their idle loops - // and call sp_search(). When all threads have returned from sp_search() then - // split() returns. + // 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. template - void ThreadsManager::split(const Position& p, SearchStack* ss, int ply, Value* alpha, + void ThreadsManager::split(Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue, Depth depth, Move threatMove, bool mateThreat, int moveCount, MovePicker* mp, bool pvNode) { - assert(p.is_ok()); + assert(pos.is_ok()); assert(ply > 0 && ply < PLY_MAX); assert(*bestValue >= -VALUE_INFINITE); assert(*bestValue <= *alpha); assert(*alpha < beta); assert(beta <= VALUE_INFINITE); assert(depth > DEPTH_ZERO); - assert(p.thread() >= 0 && p.thread() < ActiveThreads); + assert(pos.thread() >= 0 && pos.thread() < ActiveThreads); assert(ActiveThreads > 1); - int i, master = p.thread(); + int i, master = pos.thread(); Thread& masterThread = threads[master]; lock_grab(&MPLock); @@ -2487,6 +2468,7 @@ split_point_start: // At split points actual search starts from here // Initialize the split point object splitPoint.parent = masterThread.splitPoint; + splitPoint.master = master; splitPoint.stopRequest = false; splitPoint.ply = ply; splitPoint.depth = depth; @@ -2498,7 +2480,8 @@ split_point_start: // At split points actual search starts from here splitPoint.bestValue = *bestValue; splitPoint.mp = mp; splitPoint.moveCount = moveCount; - splitPoint.pos = &p; + splitPoint.pos = &pos; + splitPoint.nodes = 0; splitPoint.parentSstack = ss; for (i = 0; i < ActiveThreads; i++) splitPoint.slaves[i] = 0; @@ -2535,6 +2518,8 @@ split_point_start: // At split points actual search starts from here assert(i == master || threads[i].state == THREAD_BOOKED); threads[i].state = THREAD_WORKISWAITING; // This makes the slave to exit from idle_loop() + if (i != master) + wake_sleeping_thread(i); } // Everything is set up. The master thread enters the idle loop, from @@ -2552,6 +2537,7 @@ split_point_start: // At split points actual search starts from here *bestValue = splitPoint.bestValue; masterThread.activeSplitPoints--; masterThread.splitPoint = splitPoint.parent; + pos.set_nodes_searched(pos.nodes_searched() + splitPoint.nodes); lock_release(&MPLock); } @@ -2562,29 +2548,12 @@ split_point_start: // At split points actual search starts from here void ThreadsManager::wake_sleeping_thread(int threadID) { - assert(threadID > 0); - assert(threads[threadID].state == THREAD_AVAILABLE); - -#if !defined(_MSC_VER) - pthread_mutex_lock(&WaitLock); - pthread_cond_signal(&WaitCond[threadID]); - pthread_mutex_unlock(&WaitLock); -#else - SetEvent(WaitCond[threadID]); -#endif + lock_grab(&MPLock); + cond_signal(&WaitCond[threadID]); + lock_release(&MPLock); } - // put_threads_to_sleep() makes all the threads go to sleep just before - // to leave think(), at the end of the search. Threads should have already - // finished the job and should be idle. - - void ThreadsManager::put_threads_to_sleep() { - - // This makes the threads to go to sleep - ActiveThreads = 1; - } - /// The RootMoveList class // RootMoveList c'tor