X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fsearch.cpp;h=00fa04dd44a8408258b3261a7b71402a6f4781a7;hb=65606bc49ed26f630bdd8ee1a460d80ee74e9330;hp=861eaacabef8c90f190b5ee96c9ba9a8db8fc50b;hpb=9440fb06daedbd4b88728c5d4ddc928fec654f70;p=stockfish diff --git a/src/search.cpp b/src/search.cpp index 861eaaca..00fa04dd 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -83,7 +83,6 @@ namespace { 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 @@ -96,7 +95,7 @@ namespace { int ActiveThreads; volatile bool AllThreadsShouldExit; Thread threads[MAX_THREADS]; - Lock MPLock, WaitLock; + Lock MPLock; WaitCondition WaitCond[MAX_THREADS]; }; @@ -285,6 +284,9 @@ namespace { return search(pos, ss, alpha, beta, depth, ply); } + template + void sp_search(Position& pos, SearchStack* ss, Value, Value beta, Depth depth, int ply); + template Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply); @@ -465,10 +467,6 @@ bool think(const Position& pos, bool infinite, bool ponder, int time[], int incr 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 +499,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; } @@ -707,7 +703,7 @@ namespace { int64_t nodes; Move move; Depth depth, ext, newDepth; - Value value, alpha, beta; + Value value, evalMargin, alpha, beta; bool isCheck, moveIsCheck, captureOrPromotion, dangerous; int researchCountFH, researchCountFL; @@ -726,8 +722,7 @@ namespace { // Step 5. Evaluate the position statically // At root we do this only to get reference value for child nodes - ss->evalMargin = VALUE_NONE; - ss->eval = isCheck ? VALUE_NONE : evaluate(pos, ss->evalMargin); + ss->eval = isCheck ? VALUE_NONE : evaluate(pos, evalMargin); // Step 6. Razoring (omitted at root) // Step 7. Static null move pruning (omitted at root) @@ -973,7 +968,7 @@ namespace { Key posKey; Move ttMove, move, excludedMove, threatMove; Depth ext, newDepth; - Value bestValue, value, oldAlpha; + Value bestValue, value, evalMargin, oldAlpha; Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific bool isCheck, singleEvasion, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous; bool mateThreat = false; @@ -988,6 +983,7 @@ namespace { { sp = ss->sp; tte = NULL; + evalMargin = VALUE_ZERO; ttMove = excludedMove = MOVE_NONE; threatMove = sp->threatMove; mateThreat = sp->mateThreat; @@ -1048,19 +1044,19 @@ namespace { // Step 5. Evaluate the position statically and // update gain statistics of parent move. if (isCheck) - ss->eval = ss->evalMargin = VALUE_NONE; + ss->eval = evalMargin = VALUE_NONE; else if (tte) { assert(tte->static_value() != VALUE_NONE); ss->eval = tte->static_value(); - ss->evalMargin = tte->static_value_margin(); + evalMargin = tte->static_value_margin(); refinedValue = refine_eval(tte, ss->eval, ply); } else { - refinedValue = ss->eval = evaluate(pos, ss->evalMargin); - TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin); + refinedValue = ss->eval = evaluate(pos, evalMargin); + TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin); } // Save gain for the parent non-capture move @@ -1186,7 +1182,7 @@ split_point_start: // At split points actual search starts from here CheckInfo ci(pos); ss->bestMove = MOVE_NONE; singleEvasion = !SpNode && isCheck && mp.number_of_evasions() == 1; - futilityBase = ss->eval + ss->evalMargin; + futilityBase = ss->eval + evalMargin; singularExtensionNode = !SpNode && depth >= SingularExtensionDepth[PvNode] && tte @@ -1371,24 +1367,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; } } @@ -1428,7 +1429,7 @@ split_point_start: // At split points actual search starts from here 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, evalMargin); // Update killers and history only for non capture moves that fails high if ( bestValue >= beta @@ -1614,6 +1615,172 @@ split_point_start: // At split points actual search starts from here } + // sp_search() is used to search from a split point. This function is called + // by each thread working at the split point. It is similar to the normal + // search() function, but simpler. Because we have already probed the hash + // table, done a null move search, and searched the first move before + // 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. + + template + void sp_search(Position& pos, SearchStack* ss, Value, Value beta, Depth depth, int ply) { + + StateInfo st; + Move move; + Depth ext, newDepth; + Value value; + Value futilityValueScaled; // NonPV specific + bool isCheck, moveIsCheck, captureOrPromotion, dangerous; + int moveCount; + value = -VALUE_INFINITE; + SplitPoint* sp = ss->sp; + Move threatMove = sp->threatMove; + MovePicker& mp = *sp->mp; + int threadID = pos.thread(); + + CheckInfo ci(pos); + 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 < beta + && (move = mp.get_next_move()) != MOVE_NONE + && !ThreadsMgr.thread_should_stop(threadID)) + { + moveCount = ++sp->moveCount; + lock_release(&(sp->lock)); + + assert(move_is_ok(move)); + + moveIsCheck = pos.move_is_check(move, ci); + captureOrPromotion = pos.move_is_capture_or_promotion(move); + + // Step 11. Decide the new search depth + ext = extension(pos, move, captureOrPromotion, moveIsCheck, false, sp->mateThreat, &dangerous); + newDepth = depth - ONE_PLY + ext; + + // Update current move + ss->currentMove = move; + + // Step 12. Futility pruning (is omitted in PV nodes) + if ( !PvNode + && !captureOrPromotion + && !isCheck + && !dangerous + && !move_is_castle(move)) + { + // Move count based pruning + if ( moveCount >= futility_move_count(depth) + && !(threatMove && connected_threat(pos, move, threatMove)) + && sp->bestValue > value_mated_in(PLY_MAX)) + { + lock_grab(&(sp->lock)); + continue; + } + + // Value based pruning + Depth predictedDepth = newDepth - reduction(depth, moveCount); + futilityValueScaled = ss->eval + futility_margin(predictedDepth, moveCount) + + H.gain(pos.piece_on(move_from(move)), move_to(move)); + + if (futilityValueScaled < beta) + { + lock_grab(&(sp->lock)); + + if (futilityValueScaled > sp->bestValue) + sp->bestValue = futilityValueScaled; + continue; + } + } + + // Step 13. Make the move + pos.do_move(move, st, ci, moveIsCheck); + + // Step 14. Reduced search + // If the move fails high will be re-searched at full depth. + bool doFullDepthSearch = true; + + if ( !captureOrPromotion + && !dangerous + && !move_is_castle(move) + && !(ss->killers[0] == move || ss->killers[1] == move)) + { + ss->reduction = reduction(depth, moveCount); + if (ss->reduction) + { + Value localAlpha = sp->alpha; + Depth d = newDepth - ss->reduction; + value = d < ONE_PLY ? -qsearch(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, ply+1) + : - search(pos, ss+1, -(localAlpha+1), -localAlpha, d, ply+1); + + doFullDepthSearch = (value > localAlpha); + } + + // The move failed high, but if reduction is very big we could + // face a false positive, retry with a less aggressive reduction, + // if the move fails high again then go with full depth search. + if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY) + { + assert(newDepth - ONE_PLY >= ONE_PLY); + + ss->reduction = ONE_PLY; + Value localAlpha = sp->alpha; + value = -search(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, ply+1); + doFullDepthSearch = (value > localAlpha); + } + ss->reduction = DEPTH_ZERO; // Restore original reduction + } + + // Step 15. Full depth search + if (doFullDepthSearch) + { + Value localAlpha = sp->alpha; + value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, ply+1) + : - search(pos, ss+1, -(localAlpha+1), -localAlpha, 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 > localAlpha && value < beta) + value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -beta, -sp->alpha, DEPTH_ZERO, ply+1) + : - search(pos, ss+1, -beta, -sp->alpha, newDepth, ply+1); + } + + // Step 16. Undo move + pos.undo_move(move); + + assert(value > -VALUE_INFINITE && value < VALUE_INFINITE); + + // Step 17. Check for new best move + lock_grab(&(sp->lock)); + + if (value > sp->bestValue && !ThreadsMgr.thread_should_stop(threadID)) + { + sp->bestValue = value; + if (value > sp->alpha) + { + if (!PvNode || value >= beta) + sp->stopRequest = true; + + if (PvNode && value < beta) // We want always sp->alpha < beta + sp->alpha = value; + + sp->parentSstack->bestMove = ss->bestMove = move; + } + } + } + + /* Here we have the lock still grabbed */ + + sp->slaves[threadID] = 0; + + lock_release(&(sp->lock)); + } + + // connected_moves() tests whether two moves are 'connected' in the sense // that the first move somehow made the second move possible (for instance // if the moving piece is the same in both moves). The first move is assumed @@ -2224,25 +2391,32 @@ 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) + while ( threadID >= ActiveThreads + || threads[threadID].state == THREAD_INITIALIZING + || (!sp && threads[threadID].state == THREAD_AVAILABLE)) { assert(!sp); assert(threadID != 0); - threads[threadID].state = THREAD_SLEEPING; -#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 - } + if (AllThreadsShouldExit) + break; + + lock_grab(&MPLock); - // If thread has just woken up, mark it as available - if (threads[threadID].state == THREAD_SLEEPING) + // Retest condition under lock protection + if (!( threadID >= ActiveThreads + || threads[threadID].state == THREAD_INITIALIZING + || (!sp && threads[threadID].state == THREAD_AVAILABLE))) + { + lock_release(&MPLock); + continue; + } + + // Put thread to sleep threads[threadID].state = THREAD_AVAILABLE; + cond_wait(&WaitCond[threadID], &MPLock); + lock_release(&MPLock); + } // If this thread has been assigned work, launch a search if (threads[threadID].state == THREAD_WORKISWAITING) @@ -2258,9 +2432,11 @@ split_point_start: // At split points actual search starts from here ss->sp = tsp; if (tsp->pvNode) - search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); + //search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); + sp_search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); else - search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); + //search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); + sp_search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); assert(threads[threadID].state == THREAD_SEARCHING); @@ -2301,14 +2477,9 @@ split_point_start: // At split points actual search starts from here // 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++) @@ -2318,13 +2489,13 @@ split_point_start: // At split points actual search starts from here // Will be set just before program exits to properly end the threads AllThreadsShouldExit = false; - // Threads will be put to sleep as soon as created + // Threads will be put all threads to sleep as soon as created ActiveThreads = 1; - // All threads except the main thread should be initialized to THREAD_AVAILABLE + // All threads except the main thread should be initialized to THREAD_INITIALIZING threads[0].state = THREAD_SEARCHING; for (i = 1; i < MAX_THREADS; i++) - threads[i].state = THREAD_AVAILABLE; + threads[i].state = THREAD_INITIALIZING; // Launch the helper threads for (i = 1; i < MAX_THREADS; i++) @@ -2344,7 +2515,7 @@ split_point_start: // At split points actual search starts from here } // Wait until the thread has finished launching and is gone to sleep - while (threads[i].state != THREAD_SLEEPING) {} + while (threads[i].state == THREAD_INITIALIZING) {} } } @@ -2355,7 +2526,6 @@ split_point_start: // At split points actual search starts from here void ThreadsManager::exit_threads() { AllThreadsShouldExit = true; // Let the woken up threads to exit idle_loop() - ActiveThreads = MAX_THREADS; // Avoid any woken up thread comes back to sleep // Wake up all the threads and waits for termination for (int i = 1; i < MAX_THREADS; i++) @@ -2369,7 +2539,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 @@ -2535,6 +2704,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 @@ -2562,29 +2733,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_SLEEPING); - -#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 @@ -2598,7 +2752,7 @@ split_point_start: // At split points actual search starts from here // Initialize search stack init_ss_array(ss, PLY_MAX_PLUS_2); - ss[0].eval = ss[0].evalMargin = VALUE_NONE; + ss[0].eval = VALUE_NONE; count = 0; // Generate all legal moves