X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fsearch.cpp;h=ebd004d39c541d5632163ffe8817f113a6891f74;hb=77bb9a94aed2a78d98e04399207f51ed92d531d3;hp=6bb1924f972967957b4504d2d9c0a8c2dbb6be2d;hpb=85e60bfc8e9457b2865069c6effe0d7c0991c641;p=stockfish diff --git a/src/search.cpp b/src/search.cpp index 6bb1924f..ebd004d3 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -442,9 +442,6 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move, // Wake up sleeping threads TM.wake_sleeping_threads(); - for (int i = 1; i < TM.active_threads(); i++) - assert(TM.thread_is_available(i, 0)); - // Set thinking time int myTime = time[side_to_move]; int myIncrement = increment[side_to_move]; @@ -1270,29 +1267,30 @@ namespace { if (depth < OnePly) return qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID); - // Initialize, and make an early exit in case of an aborted search, - // an instant draw, maximum ply reached, etc. + // Step 1. Initialize node and poll + // Polling can abort search. init_node(ss, ply, threadID); - // After init_node() that calls poll() + // Step 2. Check for aborted search and immediate draw if (AbortSearch || TM.thread_should_stop(threadID)) return Value(0); if (pos.is_draw() || ply >= PLY_MAX - 1) return VALUE_DRAW; - // Mate distance pruning + // Step 3. Mate distance pruning if (value_mated_in(ply) >= beta) return beta; if (value_mate_in(ply + 1) < beta) return beta - 1; + // 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. Key posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key(); - // Transposition table lookup tte = TT.retrieve(posKey); ttMove = (tte ? tte->move() : MOVE_NONE); @@ -1302,9 +1300,9 @@ namespace { return value_from_tt(tte->value(), ply); } + // Step 5. Evaluate the position statically isCheck = pos.is_check(); - // Evaluate the position statically if (!isCheck) { if (tte && (tte->type() & VALUE_TYPE_EVAL)) @@ -1838,7 +1836,7 @@ namespace { if (ss[sp->ply].reduction) { value = -search(pos, ss, -(sp->beta-1), newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID); - doFullDepthSearch = (value >= sp->beta); + doFullDepthSearch = (value >= sp->beta && !TM.thread_should_stop(threadID)); } } @@ -1935,7 +1933,7 @@ namespace { { Value localAlpha = sp->alpha; value = -search(pos, ss, -localAlpha, newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID); - doFullDepthSearch = (value > localAlpha); + doFullDepthSearch = (value > localAlpha && !TM.thread_should_stop(threadID)); } } @@ -1945,16 +1943,14 @@ namespace { ss[sp->ply].reduction = Depth(0); value = -search(pos, ss, -localAlpha, newDepth, sp->ply+1, true, threadID); - if (value > localAlpha && value < sp->beta) + 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_pv(pos, ss, -sp->beta, -localAlpha, newDepth, sp->ply+1, threadID); - else - assert(TM.thread_should_stop(threadID)); - } + } } pos.undo_move(move); @@ -2586,35 +2582,39 @@ namespace { { // Slave threads can exit as soon as AllThreadsShouldExit raises, // master should exit as last one. - if (AllThreadsShouldExit && !waitSp) + if (AllThreadsShouldExit) { + assert(!waitSp); threads[threadID].state = THREAD_TERMINATED; return; } // If we are not thinking, wait for a condition to be signaled // instead of wasting CPU time polling for work. - while ( threadID != 0 - && !AllThreadsShouldExit - && (AllThreadsShouldSleep || threadID >= ActiveThreads)) + while (AllThreadsShouldSleep || threadID >= ActiveThreads) { + assert(!waitSp); + assert(threadID != 0); threads[threadID].state = THREAD_SLEEPING; #if !defined(_MSC_VER) pthread_mutex_lock(&WaitLock); - pthread_cond_wait(&WaitCond, &WaitLock); + if (AllThreadsShouldSleep || threadID >= ActiveThreads) + pthread_cond_wait(&WaitCond, &WaitLock); pthread_mutex_unlock(&WaitLock); #else WaitForSingleObject(SitIdleEvent[threadID], INFINITE); #endif - // State is already changed by wake_sleeping_threads() - assert(threads[threadID].state == THREAD_AVAILABLE || threadID >= ActiveThreads); } + // If thread has just woken up, mark it as available + if (threads[threadID].state == THREAD_SLEEPING) + threads[threadID].state = THREAD_AVAILABLE; + // If this thread has been assigned work, launch a search if (threads[threadID].state == THREAD_WORKISWAITING) { - assert(!AllThreadsShouldExit); + assert(!AllThreadsShouldExit && !AllThreadsShouldSleep); threads[threadID].state = THREAD_SEARCHING; @@ -2632,8 +2632,7 @@ namespace { // finished their work at this split point, return from the idle loop. if (waitSp != NULL && waitSp->cpus == 0) { - assert( threads[threadID].state == THREAD_AVAILABLE - || threads[threadID].state == THREAD_SEARCHING); + assert(threads[threadID].state == THREAD_AVAILABLE); threads[threadID].state = THREAD_SEARCHING; return; @@ -2821,7 +2820,9 @@ namespace { assert(p.is_ok()); assert(sstck != NULL); assert(ply >= 0 && ply < PLY_MAX); - assert(*bestValue >= -VALUE_INFINITE && *bestValue <= *alpha); + assert(*bestValue >= -VALUE_INFINITE); + assert( ( pvNode && *bestValue <= *alpha) + || (!pvNode && *bestValue < beta )); assert(!pvNode || *alpha < beta); assert(beta <= VALUE_INFINITE); assert(depth > Depth(0)); @@ -2934,12 +2935,8 @@ namespace { return; for (int i = 1; i < ActiveThreads; i++) - { assert(threads[i].state == THREAD_SLEEPING); - threads[i].state = THREAD_AVAILABLE; - } - #if !defined(_MSC_VER) pthread_mutex_lock(&WaitLock); pthread_cond_broadcast(&WaitCond); @@ -2963,12 +2960,9 @@ namespace { // This makes the threads to go to sleep AllThreadsShouldSleep = true; - // Wait for the threads to be all sleeping and reset flags - // to a known state. + // Reset flags to a known state. for (int i = 1; i < ActiveThreads; i++) { - while (threads[i].state != THREAD_SLEEPING); - // This flag can be in a random state threads[i].printCurrentLineRequest = false; }