X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fsearch.cpp;h=cb7b30b8f6f102a832f79c1ae835046f8aa83128;hb=58c9fbacc787cc3b654244c071169057e6895c91;hp=d86f249365f8ed318f70359541fff404862f8cf2;hpb=c465f4c4df1a8ad3d5c1e3759c6aa27b777b8a77;p=stockfish diff --git a/src/search.cpp b/src/search.cpp index d86f2493..cb7b30b8 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -534,7 +534,7 @@ namespace { if (!RootNode) { // Step 2. Check for aborted search and immediate draw - if (Signals.stop || pos.is_draw() || ss->ply > MAX_PLY) + if (Signals.stop || pos.is_draw() || ss->ply > MAX_PLY) return DrawValue[pos.side_to_move()]; // Step 3. Mate distance pruning. Even if we mate at the next move our score @@ -667,12 +667,12 @@ namespace { if (eval - PawnValueMg > beta) R += ONE_PLY; - pos.do_null_move(st); + pos.do_null_move(st); (ss+1)->skipNullMove = true; nullValue = depth-R < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO) : - search(pos, ss+1, -beta, -alpha, depth-R); (ss+1)->skipNullMove = false; - pos.do_null_move(st); + pos.undo_null_move(); if (nullValue >= beta) { @@ -835,7 +835,7 @@ split_point_start: // At split points actual search starts from here ss->excludedMove = MOVE_NONE; if (value < rBeta) - ext = rBeta >= beta ? ONE_PLY + ONE_PLY / 2 : ONE_PLY; + ext = ONE_PLY; } // Update current move (this must be done after singular extension search) @@ -1007,8 +1007,9 @@ split_point_start: // At split points actual search starts from here // Step 19. Check for splitting the search if ( !SpNode - && depth >= Threads.min_split_depth() - && Threads.available_slave_exists(thisThread)) + && depth >= Threads.minimumSplitDepth + && Threads.slave_available(thisThread) + && thisThread->splitPointsSize < MAX_SPLITPOINTS_PER_THREAD) { assert(bestValue < beta); @@ -1108,7 +1109,7 @@ split_point_start: // At split points actual search starts from here ss->ply = (ss-1)->ply + 1; // Check for an instant draw or maximum ply reached - if (pos.is_draw() || ss->ply > MAX_PLY) + if (pos.is_draw() || ss->ply > MAX_PLY) return DrawValue[pos.side_to_move()]; // Transposition table lookup. At PV nodes, we don't use the TT for @@ -1342,7 +1343,6 @@ split_point_start: // At split points actual search starts from here Bitboard b = (enemies ^ ksq) & newAtt & ~oldAtt; while (b) { - // Note that here we generate illegal "double move"! if (futilityBase + PieceValue[EG][pos.piece_on(pop_lsb(&b))] >= beta) return true; } @@ -1516,7 +1516,7 @@ void RootMove::extract_pv_from_tt(Position& pos) { && pos.is_pseudo_legal(m = tte->move()) // Local copy, TT could change && pos.pl_move_is_legal(m, pos.pinned_pieces()) && ply < MAX_PLY - && (!pos.is_draw() || ply < 2)); + && (!pos.is_draw() || ply < 2)); pv.push_back(MOVE_NONE); // Must be zero-terminating @@ -1554,31 +1554,31 @@ void RootMove::insert_pv_in_tt(Position& pos) { void Thread::idle_loop() { - // Pointer 'sp_master', if non-NULL, points to the active SplitPoint - // object for which the thread is the master. - const SplitPoint* sp_master = splitPointsCnt ? curSplitPoint : NULL; + // Pointer 'this_sp' is not null only if we are called from split(), and not + // at the thread creation. So it means we are the split point's master. + const SplitPoint* this_sp = splitPointsSize ? activeSplitPoint : NULL; - assert(!sp_master || (sp_master->master == this && is_searching)); + assert(!this_sp || (this_sp->master == this && searching)); - // 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. - while (!sp_master || sp_master->slavesMask) + // 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. + while (!this_sp || this_sp->slavesMask) { - // If we are not searching, wait for a condition to be signaled - // instead of wasting CPU time polling for work. - while (do_exit || (!is_searching && Threads.sleepWhileIdle)) + // If we are not searching, wait for a condition to be signaled instead of + // wasting CPU time polling for work. + while ((!searching && Threads.sleepWhileIdle) || exit) { - if (do_exit) + if (exit) { - assert(!sp_master); + assert(!this_sp); return; } - // Grab the lock to avoid races with Thread::wake_up() + // Grab the lock to avoid races with Thread::notify_one() mutex.lock(); - // If we are master and all slaves have finished don't go to sleep - if (sp_master && !sp_master->slavesMask) + // If we are master and all slaves have finished then exit idle_loop + if (this_sp && !this_sp->slavesMask) { mutex.unlock(); break; @@ -1586,23 +1586,23 @@ void Thread::idle_loop() { // Do sleep after retesting sleep conditions under lock protection, in // particular we need to avoid a deadlock in case a master thread has, - // in the meanwhile, allocated us and sent the wake_up() call before we - // had the chance to grab the lock. - if (!is_searching && !do_exit) + // in the meanwhile, allocated us and sent the notify_one() call before + // we had the chance to grab the lock. + if (!searching && !exit) sleepCondition.wait(mutex); mutex.unlock(); } // If this thread has been assigned work, launch a search - if (is_searching) + if (searching) { - assert(!do_exit); + assert(!exit); Threads.mutex.lock(); - assert(is_searching); - SplitPoint* sp = curSplitPoint; + assert(searching); + SplitPoint* sp = activeSplitPoint; Threads.mutex.unlock(); @@ -1614,33 +1614,38 @@ void Thread::idle_loop() { sp->mutex.lock(); - assert(sp->activePositions[idx] == NULL); + assert(sp->slavesPositions[idx] == NULL); - sp->activePositions[idx] = &pos; + sp->slavesPositions[idx] = &pos; - if (sp->nodeType == Root) + switch (sp->nodeType) { + case Root: search(pos, ss+1, sp->alpha, sp->beta, sp->depth); - else if (sp->nodeType == PV) + break; + case PV: search(pos, ss+1, sp->alpha, sp->beta, sp->depth); - else if (sp->nodeType == NonPV) + break; + case NonPV: search(pos, ss+1, sp->alpha, sp->beta, sp->depth); - else + break; + default: assert(false); + } - assert(is_searching); + assert(searching); - is_searching = false; - sp->activePositions[idx] = NULL; + searching = false; + sp->slavesPositions[idx] = NULL; sp->slavesMask &= ~(1ULL << idx); sp->nodes += pos.nodes_searched(); - // 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. + // 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 ( Threads.sleepWhileIdle && this != sp->master && !sp->slavesMask) { - assert(!sp->master->is_searching); + assert(!sp->master->searching); sp->master->notify_one(); } @@ -1681,7 +1686,7 @@ void check_time() { // Loop across all split points and sum accumulated SplitPoint nodes plus // all the currently active slaves positions. for (size_t i = 0; i < Threads.size(); i++) - for (int j = 0; j < Threads[i].splitPointsCnt; j++) + for (int j = 0; j < Threads[i].splitPointsSize; j++) { SplitPoint& sp = Threads[i].splitPoints[j]; @@ -1691,7 +1696,7 @@ void check_time() { Bitboard sm = sp.slavesMask; while (sm) { - Position* pos = sp.activePositions[pop_lsb(&sm)]; + Position* pos = sp.slavesPositions[pop_lsb(&sm)]; nodes += pos ? pos->nodes_searched() : 0; }