- sp->bestValue = value;
- if (sp->bestValue >= sp->beta)
- {
- sp_update_pv(sp->parentSstack, ss, sp->ply);
- for (int i = 0; i < ActiveThreads; i++)
- if (i != threadID && (i == sp->master || sp->slaves[i]))
- Threads[i].stop = true;
-
- sp->finished = true;
- }
- }
- lock_release(&(sp->lock));
- }
- }
-
- lock_grab(&(sp->lock));
-
- // If this is the master thread and we have been asked to stop because of
- // a beta cutoff higher up in the tree, stop all slave threads.
- if (sp->master == threadID && thread_should_stop(threadID))
- for (int i = 0; i < ActiveThreads; i++)
- if (sp->slaves[i])
- Threads[i].stop = true;
-
- sp->cpus--;
- sp->slaves[threadID] = 0;
-
- 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 < ActiveThreads);
- assert(ActiveThreads > 1);
-
- Position pos(*sp->pos);
- CheckInfo ci(pos);
- SearchStack* ss = sp->sstack[threadID];
- Value value = -VALUE_INFINITE;
- Move move;
-
- while ( sp->alpha < sp->beta
- && !thread_should_stop(threadID)
- && (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE)
- {
- bool moveIsCheck = pos.move_is_check(move, ci);
- bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
-
- assert(move_is_ok(move));
-
- lock_grab(&(sp->lock));
- int moveCount = ++sp->moves;
- lock_release(&(sp->lock));
-
- ss[sp->ply].currentMove = move;
-
- // Decide the new search depth.
- bool dangerous;
- Depth ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
- Depth newDepth = sp->depth - OnePly + ext;
-
- // Make and search the move.
- StateInfo st;
- pos.do_move(move, st, ci, moveIsCheck);
-
- // Try to reduce non-pv search depth by one ply if move seems not problematic,
- // 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]))
- {
- double red = 0.5 + ln(moveCount) * ln(sp->depth / 2) / 6.0;
- if (red >= 1.0)
- {
- Value localAlpha = sp->alpha;
- ss[sp->ply].reduction = Depth(int(floor(red * int(OnePly))));
- value = -search(pos, ss, -localAlpha, newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
- doFullDepthSearch = (value > localAlpha);
- }
- }
-
- if (doFullDepthSearch) // Go with full depth non-pv search
- {
- Value localAlpha = sp->alpha;
- ss[sp->ply].reduction = Depth(0);
- value = -search(pos, ss, -localAlpha, newDepth, sp->ply+1, true, threadID);
-
- if (value > localAlpha && value < sp->beta)
- {
- // When the search fails high at ply 1 while searching the first
- // move at the root, set the flag failHighPly1. This is used for
- // time managment: We don't want to stop the search early in
- // such cases, because resolving the fail high at ply 1 could
- // result in a big drop in score at the root.
- if (sp->ply == 1 && RootMoveNumber == 1)
- Threads[threadID].failHighPly1 = true;
-
- // 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(thread_should_stop(threadID));
-
- Threads[threadID].failHighPly1 = false;
- }
- }
- pos.undo_move(move);
-
- assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
-
- if (thread_should_stop(threadID))
- break;
-
- // New best move?
- if (value > sp->bestValue) // Less then 2% of cases
- {
- lock_grab(&(sp->lock));
- if (value > sp->bestValue && !thread_should_stop(threadID))
- {
- sp->bestValue = value;
- if (value > sp->alpha)
- {
- // Ask threads to stop before to modify sp->alpha
- if (value >= sp->beta)
- {
- for (int i = 0; i < ActiveThreads; i++)
- if (i != threadID && (i == sp->master || sp->slaves[i]))
- Threads[i].stop = true;
-
- sp->finished = true;
- }