X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=a349fd6c7687c33002fbad2b5f6821a4785650b3;hp=1dd6940098f58464fc7a2ef786fb8d3d8506c0fa;hb=187451294f02c2b6424c9679a12c901e336a4180;hpb=c20a41c9cf15a2819a7b482ece15b67e1879ce18 diff --git a/src/search.cpp b/src/search.cpp index 1dd69400..a349fd6c 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -54,6 +54,10 @@ namespace { /// Types enum NodeType { NonPV, PV }; + // Set to true to force running with one thread. + // Used for debugging SMP code. + const bool FakeSplit = false; + // 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 @@ -83,8 +87,10 @@ namespace { void wake_sleeping_threads(); void put_threads_to_sleep(); void idle_loop(int threadID, SplitPoint* sp); - bool split(const Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue, - Depth depth, bool mateThreat, int* moves, MovePicker* mp, int master, bool pvNode); + + template + void split(const Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue, + Depth depth, bool mateThreat, int* moveCount, MovePicker* mp, int master, bool pvNode); private: friend void poll(); @@ -116,7 +122,7 @@ namespace { // RootMove::operator<() is the comparison function used when // sorting the moves. A move m1 is considered to be better // than a move m2 if it has a higher score, or if the moves - // have equal score but m1 has the higher node count. + // have equal score but m1 has the higher beta cut-off count. bool operator<(const RootMove& m) const { return score != m.score ? score < m.score : theirBeta <= m.theirBeta; @@ -228,6 +234,9 @@ namespace { // better than the second best move. const Value EasyMoveMargin = Value(0x200); + // Maximum number of moves to try before to split (strong YBWC) + const int MaximumSplitMove = 3; + // Last seconds noise filtering (LSN) const bool UseLSNFiltering = true; const int LSNTime = 4000; // In milliseconds @@ -284,11 +293,12 @@ namespace { template Value qsearch(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID); + template + void sp_search(SplitPoint* sp, int threadID); + template Depth extension(const Position& pos, Move m, bool captureOrPromotion, bool moveIsCheck, bool singleEvasion, bool mateThreat, bool* dangerous); - void sp_search(SplitPoint* sp, int threadID); - void sp_search_pv(SplitPoint* sp, int threadID); void init_node(SearchStack ss[], int ply, int threadID); void update_pv(SearchStack ss[], int ply); void sp_update_pv(SearchStack* pss, SearchStack ss[], int ply); @@ -797,8 +807,8 @@ namespace { beta = *betaPtr; isCheck = pos.is_check(); - // Step 1. Initialize node and poll (omitted at root, but I can see no good reason for this, FIXME) - // Step 2. Check for aborted search (omitted at root, because we do not initialize root node) + // Step 1. Initialize node and poll (omitted at root, init_ss_array() has already initialized root node) + // Step 2. Check for aborted search (omitted at root) // Step 3. Mate distance pruning (omitted at root) // Step 4. Transposition table lookup (omitted at root) @@ -806,8 +816,6 @@ namespace { // At root we do this only to get reference value for child nodes if (!isCheck) ss[0].eval = evaluate(pos, ei, 0); - else - ss[0].eval = VALUE_NONE; // HACK because we do not initialize root node // Step 6. Razoring (omitted at root) // Step 7. Static null move pruning (omitted at root) @@ -1278,7 +1286,9 @@ namespace { continue; // Value based pruning - Depth predictedDepth = newDepth - reduction(depth, moveCount); // FIXME We illogically ignore reduction condition depth >= 3*OnePly + // We illogically ignore reduction condition depth >= 3*OnePly for predicted depth, + // but fixing this made program slightly weaker. + Depth predictedDepth = newDepth - reduction(depth, moveCount); futilityValueScaled = ss[ply].eval + futility_margin(predictedDepth, moveCount) + H.gain(pos.piece_on(move_from(move)), move_to(move)); @@ -1342,8 +1352,11 @@ namespace { bestValue = value; if (value > alpha) { - alpha = value; + if (PvNode && value < beta) // This guarantees that always: alpha < beta + alpha = value; + update_pv(ss, ply); + if (value == value_mate_in(ply + 1)) ss[ply].mateKiller = move; } @@ -1353,13 +1366,13 @@ namespace { if ( TM.active_threads() > 1 && bestValue < beta && depth >= MinimumSplitDepth + && (PvNode || moveCount > MaximumSplitMove * MinimumSplitDepth / depth) && Iteration <= 99 && TM.available_thread_exists(threadID) && !AbortSearch - && !TM.thread_should_stop(threadID) - && TM.split(pos, ss, ply, &alpha, beta, &bestValue, - depth, mateThreat, &moveCount, &mp, threadID, PvNode)) - break; + && !TM.thread_should_stop(threadID)) + TM.split(pos, ss, ply, &alpha, beta, &bestValue, depth, + mateThreat, &moveCount, &mp, threadID, PvNode); } // Step 19. Check for mate and stalemate @@ -1597,6 +1610,7 @@ namespace { // 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(SplitPoint* sp, int threadID) { assert(threadID >= 0 && threadID < TM.active_threads()); @@ -1605,7 +1619,8 @@ namespace { StateInfo st; Move move; Depth ext, newDepth; - Value value, futilityValueScaled; + Value value; + Value futilityValueScaled; // NonPV specific bool isCheck, moveIsCheck, captureOrPromotion, dangerous; int moveCount; value = -VALUE_INFINITE; @@ -1620,10 +1635,10 @@ namespace { lock_grab(&(sp->lock)); while ( sp->bestValue < sp->beta - && !TM.thread_should_stop(threadID) - && (move = sp->mp->get_next_move()) != MOVE_NONE) + && (move = sp->mp->get_next_move()) != MOVE_NONE + && !TM.thread_should_stop(threadID)) { - moveCount = ++sp->moves; + moveCount = ++sp->moveCount; lock_release(&(sp->lock)); assert(move_is_ok(move)); @@ -1632,14 +1647,15 @@ namespace { 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); + ext = extension(pos, move, captureOrPromotion, moveIsCheck, false, sp->mateThreat, &dangerous); newDepth = sp->depth - OnePly + ext; // Update current move ss[sp->ply].currentMove = move; - // Step 12. Futility pruning - if ( !isCheck + // Step 12. Futility pruning (is omitted in PV nodes) + if ( !PvNode + && !isCheck && !dangerous && !captureOrPromotion && !move_is_castle(move)) @@ -1680,135 +1696,24 @@ namespace { && !move_is_castle(move) && !move_is_killer(move, ss[sp->ply])) { - ss[sp->ply].reduction = reduction(sp->depth, moveCount); - if (ss[sp->ply].reduction) - { - value = -search(pos, ss, -(sp->alpha+1), -(sp->alpha), newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID); - doFullDepthSearch = (value >= sp->beta && !TM.thread_should_stop(threadID)); - } - } - - // Step 15. Full depth search - if (doFullDepthSearch) - { - ss[sp->ply].reduction = Depth(0); - value = -search(pos, ss, -(sp->alpha+1), -(sp->alpha), newDepth, sp->ply+1, true, threadID); - } - - // 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 && !TM.thread_should_stop(threadID)) - { - sp->bestValue = value; - if (sp->bestValue >= sp->beta) - { - sp->stopRequest = true; - sp_update_pv(sp->parentSstack, ss, sp->ply); - } - } - } - - /* Here we have the lock still grabbed */ - - sp->slaves[threadID] = 0; - sp->cpus--; - - lock_release(&(sp->lock)); - } - - - // sp_search_pv() is used to search from a PV split point. This function - // is called by each thread working at the split point. It is similar to - // the normal search_pv() function, but simpler. Because we have already - // probed the hash table and searched the first move before splitting, we - // 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. - - 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]; - - // 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->alpha < sp->beta - && !TM.thread_should_stop(threadID) - && (move = sp->mp->get_next_move()) != MOVE_NONE) - { - moveCount = ++sp->moves; - 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 = sp->depth - OnePly + ext; - - // Update current move - ss[sp->ply].currentMove = move; - - // Step 12. Futility pruning (is omitted in PV nodes) - - // 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 ( !dangerous - && !captureOrPromotion - && !move_is_castle(move) - && !move_is_killer(move, ss[sp->ply])) - { - ss[sp->ply].reduction = reduction(sp->depth, moveCount); + ss[sp->ply].reduction = reduction(sp->depth, moveCount); if (ss[sp->ply].reduction) { Value localAlpha = sp->alpha; value = -search(pos, ss, -(localAlpha+1), -localAlpha, newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID); - doFullDepthSearch = (value > localAlpha && !TM.thread_should_stop(threadID)); + doFullDepthSearch = (value > localAlpha); } } // Step 15. Full depth search if (doFullDepthSearch) { - Value localAlpha = sp->alpha; ss[sp->ply].reduction = Depth(0); + Value localAlpha = sp->alpha; value = -search(pos, ss, -(localAlpha+1), -localAlpha, newDepth, sp->ply+1, true, threadID); - if (value > localAlpha && value < sp->beta && !TM.thread_should_stop(threadID)) - { - // If another thread has failed high then sp->alpha has been increased - // to be higher or equal then beta, if so, avoid to start a PV search. - localAlpha = sp->alpha; - if (localAlpha < sp->beta) - value = -search(pos, ss, -sp->beta, -localAlpha, newDepth, sp->ply+1, false, threadID); - } + if (PvNode && value > localAlpha && value < sp->beta) + value = -search(pos, ss, -sp->beta, -sp->alpha, newDepth, sp->ply+1, false, threadID); } // Step 16. Undo move @@ -1822,17 +1727,16 @@ namespace { if (value > sp->bestValue && !TM.thread_should_stop(threadID)) { sp->bestValue = value; - if (value > sp->alpha) + + if (sp->bestValue > sp->alpha) { - // Ask threads to stop before to modify sp->alpha - if (value >= sp->beta) + if (!PvNode || value >= sp->beta) sp->stopRequest = true; - sp->alpha = value; + if (PvNode && value < sp->beta) // This guarantees that always: sp->alpha < sp->beta + sp->alpha = value; sp_update_pv(sp->parentSstack, ss, sp->ply); - if (value == value_mate_in(sp->ply + 1)) - ss[sp->ply].mateKiller = move; } } } @@ -1840,12 +1744,10 @@ namespace { /* Here we have the lock still grabbed */ sp->slaves[threadID] = 0; - sp->cpus--; lock_release(&(sp->lock)); } - // init_node() is called at the beginning of all the search functions // (search() qsearch(), and so on) and initializes the // search stack object corresponding to the current node. Once every @@ -1872,7 +1774,6 @@ namespace { ss[ply + 2].initKillers(); } - // update_pv() is called whenever a search returns a value > alpha. // It updates the PV in the SearchStack object corresponding to the // current node. @@ -2499,21 +2400,24 @@ namespace { threads[threadID].state = THREAD_SEARCHING; if (threads[threadID].splitPoint->pvNode) - sp_search_pv(threads[threadID].splitPoint, threadID); + sp_search(threads[threadID].splitPoint, threadID); else - sp_search(threads[threadID].splitPoint, threadID); + sp_search(threads[threadID].splitPoint, threadID); assert(threads[threadID].state == THREAD_SEARCHING); threads[threadID].state = THREAD_AVAILABLE; } - // If this thread is the master of a split point and all threads have + // 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. - if (sp && sp->cpus == 0) + int i = 0; + for ( ; sp && i < ActiveThreads && !sp->slaves[i]; i++) {} + + if (i == ActiveThreads) { - // Because sp->cpus is decremented under lock protection, - // be sure sp->lock has been released before to proceed. + // Because sp->slaves[] is reset under lock protection, + // be sure sp->lock has been released before to return. lock_grab(&(sp->lock)); lock_release(&(sp->lock)); @@ -2688,35 +2592,30 @@ namespace { // split() does the actual work of distributing the work at a node between - // several threads at PV nodes. If it does not succeed in splitting the + // several available threads. If it does not succeed in splitting the // node (because no idle threads are available, or because we have no unused - // split point objects), the function immediately returns false. If - // splitting is possible, a SplitPoint object is initialized with all the - // data that must be copied to the helper threads (the current position and - // search stack, alpha, beta, the search depth, etc.), 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_pv(). When all - // threads have returned from sp_search_pv (or, equivalently, when - // splitPoint->cpus becomes 0), split() returns true. - - bool ThreadsManager::split(const Position& p, SearchStack* sstck, int ply, - Value* alpha, const Value beta, Value* bestValue, - Depth depth, bool mateThreat, int* moves, MovePicker* mp, int master, bool pvNode) { - + // 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. + + template + void ThreadsManager::split(const Position& p, SearchStack* sstck, int ply, Value* alpha, + const Value beta, Value* bestValue, Depth depth, bool mateThreat, + int* moveCount, MovePicker* mp, int master, bool pvNode) { assert(p.is_ok()); assert(sstck != NULL); assert(ply >= 0 && ply < PLY_MAX); assert(*bestValue >= -VALUE_INFINITE); - assert( ( pvNode && *bestValue <= *alpha) - || (!pvNode && *bestValue < beta )); - assert(!pvNode || *alpha < beta); + assert(*bestValue <= *alpha); + assert(*alpha < beta); assert(beta <= VALUE_INFINITE); assert(depth > Depth(0)); assert(master >= 0 && master < ActiveThreads); assert(ActiveThreads > 1); - SplitPoint* splitPoint; - lock_grab(&MPLock); // If no other thread is available to help us, or if we have too many @@ -2725,11 +2624,11 @@ namespace { || threads[master].activeSplitPoints >= ACTIVE_SPLIT_POINTS_MAX) { lock_release(&MPLock); - return false; + return; } // Pick the next available split point object from the split point stack - splitPoint = &SplitPointStack[master][threads[master].activeSplitPoints]; + SplitPoint* splitPoint = &SplitPointStack[master][threads[master].activeSplitPoints]; // Initialize the split point object splitPoint->parent = threads[master].splitPoint; @@ -2741,10 +2640,8 @@ namespace { splitPoint->beta = beta; splitPoint->pvNode = pvNode; splitPoint->bestValue = *bestValue; - splitPoint->master = master; splitPoint->mp = mp; - splitPoint->moves = *moves; - splitPoint->cpus = 1; + splitPoint->moveCount = *moveCount; splitPoint->pos = &p; splitPoint->parentSstack = sstck; for (int i = 0; i < ActiveThreads; i++) @@ -2756,17 +2653,19 @@ namespace { // If we are here it means we are not available assert(threads[master].state != THREAD_AVAILABLE); + int workersCnt = 1; // At least the master is included + // Allocate available threads setting state to THREAD_BOOKED - for (int i = 0; i < ActiveThreads && splitPoint->cpus < MaxThreadsPerSplitPoint; i++) + for (int i = 0; !Fake && i < ActiveThreads && workersCnt < MaxThreadsPerSplitPoint; i++) if (thread_is_available(i, master)) { threads[i].state = THREAD_BOOKED; threads[i].splitPoint = splitPoint; splitPoint->slaves[i] = 1; - splitPoint->cpus++; + workersCnt++; } - assert(splitPoint->cpus > 1); + assert(Fake || workersCnt > 1); // We can release the lock because slave threads are already booked and master is not available lock_release(&MPLock); @@ -2787,8 +2686,7 @@ namespace { // which it will instantly launch a search, because its state is // THREAD_WORKISWAITING. We send the split point as a second parameter to the // idle loop, which means that the main thread will return from the idle - // loop when all threads have finished their work at this split point - // (i.e. when splitPoint->cpus == 0). + // loop when all threads have finished their work at this split point. idle_loop(master, splitPoint); // We have returned from the idle loop, which means that all threads are @@ -2801,7 +2699,6 @@ namespace { threads[master].splitPoint = splitPoint->parent; lock_release(&MPLock); - return true; }