X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fsearch.cpp;h=ebd004d39c541d5632163ffe8817f113a6891f74;hb=77bb9a94aed2a78d98e04399207f51ed92d531d3;hp=738955f990f3e43de6d15d96a01d4b17df1910af;hpb=27c74c5245f5f5ba1453438dc66a0c951fbbb411;p=stockfish diff --git a/src/search.cpp b/src/search.cpp index 738955f9..ebd004d3 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -84,7 +84,7 @@ namespace { void wake_sleeping_threads(); void put_threads_to_sleep(); void idle_loop(int threadID, SplitPoint* waitSp); - bool split(const Position& pos, SearchStack* ss, int ply, Value* alpha, Value* beta, Value* bestValue, + 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); private: @@ -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]; @@ -1210,7 +1207,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, VALUE_NONE, depth, &moveCount, &mp, threadID, true)) break; } @@ -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)) @@ -1524,7 +1522,7 @@ namespace { && TM.available_thread_exists(threadID) && !AbortSearch && !TM.thread_should_stop(threadID) - && TM.split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, //FIXME: SMP & futilityValue + && TM.split(pos, ss, ply, NULL, beta, &bestValue, futilityValue, //FIXME: SMP & futilityValue depth, &moveCount, &mp, threadID, false)) break; } @@ -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; @@ -2815,15 +2814,17 @@ namespace { // splitPoint->cpus becomes 0), split() returns true. bool ThreadsManager::split(const Position& p, SearchStack* sstck, int ply, - Value* alpha, Value* beta, Value* bestValue, const Value futilityValue, + Value* alpha, const Value beta, Value* bestValue, const Value futilityValue, Depth depth, int* moves, MovePicker* mp, int master, bool pvNode) { assert(p.is_ok()); assert(sstck != NULL); assert(ply >= 0 && ply < PLY_MAX); - assert(*bestValue >= -VALUE_INFINITE && *bestValue <= *alpha); - assert(!pvNode || *alpha < *beta); - assert(*beta <= VALUE_INFINITE); + assert(*bestValue >= -VALUE_INFINITE); + assert( ( pvNode && *bestValue <= *alpha) + || (!pvNode && *bestValue < beta )); + assert(!pvNode || *alpha < beta); + assert(beta <= VALUE_INFINITE); assert(depth > Depth(0)); assert(master >= 0 && master < ActiveThreads); assert(ActiveThreads > 1); @@ -2849,8 +2850,8 @@ namespace { splitPoint->stopRequest = false; splitPoint->ply = ply; splitPoint->depth = depth; - splitPoint->alpha = pvNode ? *alpha : (*beta - 1); - splitPoint->beta = *beta; + splitPoint->alpha = pvNode ? *alpha : beta - 1; + splitPoint->beta = beta; splitPoint->pvNode = pvNode; splitPoint->bestValue = *bestValue; splitPoint->futilityValue = futilityValue; @@ -2911,7 +2912,6 @@ namespace { if (pvNode) *alpha = splitPoint->alpha; - *beta = splitPoint->beta; *bestValue = splitPoint->bestValue; threads[master].activeSplitPoints--; threads[master].splitPoint = splitPoint->parent; @@ -2935,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); @@ -2964,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; }