template <bool Fake>
void split(const Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue,
- Depth depth, Move threatMove, bool mateThreat, int* moveCount, MovePicker* mp, bool pvNode);
+ Depth depth, Move threatMove, bool mateThreat, int moveCount, MovePicker* mp, bool pvNode);
private:
friend void poll();
Value id_loop(const Position& pos, Move searchMoves[]);
Value root_search(Position& pos, SearchStack* ss, Move* pv, RootMoveList& rml, Value* alphaPtr, Value* betaPtr);
- template <NodeType PvNode>
+ template <NodeType PvNode, bool SplitPoint>
Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply);
+ template <NodeType PvNode>
+ inline Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) {
+ return search<PvNode, false>(pos, ss, alpha, beta, depth, ply);
+ }
+
template <NodeType PvNode>
Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply);
template <NodeType PvNode>
- void sp_search(SplitPoint* sp, int threadID);
+ void do_sp_search(SplitPoint* sp, int threadID);
template <NodeType PvNode>
Depth extension(const Position& pos, Move m, bool captureOrPromotion, bool moveIsCheck, bool singleEvasion, bool mateThreat, bool* dangerous);
// search<>() is the main search function for both PV and non-PV nodes
- template <NodeType PvNode>
+ template <NodeType PvNode, bool SplitPoint>
Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) {
assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE);
int threadID = pos.thread();
refinedValue = bestValue = value = -VALUE_INFINITE;
oldAlpha = alpha;
+ isCheck = pos.is_check();
+
+ if (SplitPoint)
+ {
+ tte = NULL;
+ ttMove = excludedMove = MOVE_NONE;
+ threatMove = ss->sp->threatMove;
+ mateThreat = ss->sp->mateThreat;
+ goto split_start;
+ }
// Step 1. Initialize node and poll. Polling can abort search
ThreadsMgr.incrementNodeCounter(threadID);
// Step 5. Evaluate the position statically and
// update gain statistics of parent move.
- isCheck = pos.is_check();
if (isCheck)
ss->eval = evalMargin = VALUE_NONE;
else if (tte)
if (PvNode)
mateThreat = pos.has_mate_threat();
+split_start:
+
// Initialize a MovePicker object for the current position
- MovePicker mp = MovePicker(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta));
+ // FIXME currently MovePicker() c'tor is needless called also in SplitPoint
+ MovePicker mpBase = MovePicker(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta));
+ MovePicker& mp = SplitPoint ? *ss->sp->mp : mpBase;
CheckInfo ci(pos);
ss->bestMove = MOVE_NONE;
- singleEvasion = isCheck && mp.number_of_evasions() == 1;
- futilityBase = ss->eval + evalMargin;
- singularExtensionNode = depth >= SingularExtensionDepth[PvNode]
+ singleEvasion = SplitPoint ? false : isCheck && mp.number_of_evasions() == 1;
+ futilityBase = SplitPoint ? ss->eval : ss->eval + evalMargin;
+ singularExtensionNode = !SplitPoint
+ && depth >= SingularExtensionDepth[PvNode]
&& tte
&& tte->move()
&& !excludedMove // Do not allow recursive singular extension search
// Step 10. Loop through moves
// Loop through all legal moves until no moves remain or a beta cutoff occurs
+ if (SplitPoint)
+ {
+ lock_grab(&(ss->sp->lock));
+ bestValue = ss->sp->bestValue;
+ }
+
while ( bestValue < beta
&& (move = mp.get_next_move()) != MOVE_NONE
&& !ThreadsMgr.thread_should_stop(threadID))
{
+ if (SplitPoint)
+ {
+ moveCount = ++ss->sp->moveCount;
+ lock_release(&(ss->sp->lock));
+ }
+
assert(move_is_ok(move));
if (move == excludedMove)
// Move count based pruning
if ( moveCount >= futility_move_count(depth)
&& !(threatMove && connected_threat(pos, move, threatMove))
- && bestValue > value_mated_in(PLY_MAX))
+ && bestValue > value_mated_in(PLY_MAX)) // FIXME bestValue is racy
+ {
+ if (SplitPoint)
+ lock_grab(&(ss->sp->lock));
continue;
+ }
// Value based pruning
// We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth,
if (futilityValueScaled < beta)
{
- if (futilityValueScaled > bestValue)
+ if (SplitPoint)
+ {
+ lock_grab(&(ss->sp->lock));
+ if (futilityValueScaled > ss->sp->bestValue)
+ ss->sp->bestValue = bestValue = futilityValueScaled;
+ }
+ else if (futilityValueScaled > bestValue)
bestValue = futilityValueScaled;
continue;
}
// Step extra. pv search (only in PV nodes)
// The first move in list is the expected PV
- if (PvNode && moveCount == 1)
+ if (!SplitPoint && PvNode && moveCount == 1)
value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1)
: - search<PV>(pos, ss+1, -beta, -alpha, newDepth, ply+1);
else
ss->reduction = reduction<PvNode>(depth, moveCount);
if (ss->reduction)
{
+ alpha = SplitPoint ? ss->sp->alpha : alpha;
Depth d = newDepth - ss->reduction;
value = d < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1)
: - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, ply+1);
assert(newDepth - ONE_PLY >= ONE_PLY);
ss->reduction = ONE_PLY;
+ alpha = SplitPoint ? ss->sp->alpha : alpha;
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, ply+1);
doFullDepthSearch = (value > alpha);
}
// Step 15. Full depth search
if (doFullDepthSearch)
{
+ alpha = SplitPoint ? ss->sp->alpha : alpha;
value = newDepth < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1)
: - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth, ply+1);
assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
// Step 17. Check for new best move
- if (value > bestValue)
+ if (SplitPoint)
+ {
+ lock_grab(&(ss->sp->lock));
+ bestValue = ss->sp->bestValue;
+ alpha = ss->sp->alpha;
+ }
+
+ if (value > bestValue && !(SplitPoint && ThreadsMgr.thread_should_stop(threadID)))
{
bestValue = value;
if (value > alpha)
{
+ if (SplitPoint && (!PvNode || value >= beta))
+ ss->sp->stopRequest = true;
+
if (PvNode && value < beta) // We want always alpha < beta
alpha = value;
ss->bestMove = move;
}
+ if (SplitPoint)
+ {
+ ss->sp->bestValue = bestValue;
+ ss->sp->alpha = alpha;
+ ss->sp->parentSstack->bestMove = ss->bestMove;
+ }
}
// Step 18. Check for split
- if ( depth >= MinimumSplitDepth
+ if ( !SplitPoint
+ && depth >= MinimumSplitDepth
&& ThreadsMgr.active_threads() > 1
&& bestValue < beta
&& ThreadsMgr.available_thread_exists(threadID)
&& !ThreadsMgr.thread_should_stop(threadID)
&& Iteration <= 99)
ThreadsMgr.split<FakeSplit>(pos, ss, ply, &alpha, beta, &bestValue, depth,
- threatMove, mateThreat, &moveCount, &mp, PvNode);
+ threatMove, mateThreat, moveCount, &mp, PvNode);
+ }
+
+ if (SplitPoint)
+ {
+ /* Here we have the lock still grabbed */
+ ss->sp->slaves[threadID] = 0;
+ lock_release(&(ss->sp->lock));
+ return bestValue;
}
// Step 19. Check for mate and stalemate
// care of after we return from the split point.
template <NodeType PvNode>
- void sp_search(SplitPoint* sp, int threadID) {
+ void do_sp_search(SplitPoint* sp, int threadID) {
assert(threadID >= 0 && threadID < ThreadsMgr.active_threads());
assert(ThreadsMgr.active_threads() > 1);
- StateInfo st;
- Move move;
- Depth ext, newDepth;
- Value value;
- Value futilityValueScaled; // NonPV specific
- bool isCheck, moveIsCheck, captureOrPromotion, dangerous;
- int moveCount;
- value = -VALUE_INFINITE;
-
Position pos(*sp->pos, threadID);
- CheckInfo ci(pos);
SearchStack* ss = sp->sstack[threadID] + 1;
- isCheck = pos.is_check();
+ ss->sp = sp;
- // 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->bestValue < sp->beta
- && (move = sp->mp->get_next_move()) != MOVE_NONE
- && !ThreadsMgr.thread_should_stop(threadID))
- {
- moveCount = ++sp->moveCount;
- 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<PvNode>(pos, move, captureOrPromotion, moveIsCheck, false, sp->mateThreat, &dangerous);
- newDepth = sp->depth - ONE_PLY + ext;
-
- // Update current move
- ss->currentMove = move;
-
- // Step 12. Futility pruning (is omitted in PV nodes)
- if ( !PvNode
- && !captureOrPromotion
- && !isCheck
- && !dangerous
- && !move_is_castle(move))
- {
- // Move count based pruning
- if ( moveCount >= futility_move_count(sp->depth)
- && !(sp->threatMove && connected_threat(pos, move, sp->threatMove))
- && sp->bestValue > value_mated_in(PLY_MAX))
- {
- lock_grab(&(sp->lock));
- continue;
- }
-
- // Value based pruning
- Depth predictedDepth = newDepth - reduction<NonPV>(sp->depth, moveCount);
- futilityValueScaled = ss->eval + futility_margin(predictedDepth, moveCount)
- + H.gain(pos.piece_on(move_from(move)), move_to(move));
-
- if (futilityValueScaled < sp->beta)
- {
- lock_grab(&(sp->lock));
-
- if (futilityValueScaled > sp->bestValue)
- sp->bestValue = futilityValueScaled;
- continue;
- }
- }
-
- // 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 ( !captureOrPromotion
- && !dangerous
- && !move_is_castle(move)
- && !move_is_killer(move, ss))
- {
- ss->reduction = reduction<PvNode>(sp->depth, moveCount);
- if (ss->reduction)
- {
- Value localAlpha = sp->alpha;
- Depth d = newDepth - ss->reduction;
- value = d < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, sp->ply+1)
- : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, d, sp->ply+1);
-
- doFullDepthSearch = (value > localAlpha);
- }
-
- // The move failed high, but if reduction is very big we could
- // face a false positive, retry with a less aggressive reduction,
- // if the move fails high again then go with full depth search.
- if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY)
- {
- assert(newDepth - ONE_PLY >= ONE_PLY);
-
- ss->reduction = ONE_PLY;
- Value localAlpha = sp->alpha;
- value = -search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, sp->ply+1);
- doFullDepthSearch = (value > localAlpha);
- }
- ss->reduction = DEPTH_ZERO; // Restore original reduction
- }
-
- // Step 15. Full depth search
- if (doFullDepthSearch)
- {
- Value localAlpha = sp->alpha;
- value = newDepth < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, sp->ply+1)
- : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth, sp->ply+1);
-
- // Step extra. pv search (only in PV nodes)
- // Search only for possible new PV nodes, if instead value >= beta then
- // parent node fails low with value <= alpha and tries another move.
- if (PvNode && value > localAlpha && value < sp->beta)
- value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -sp->beta, -sp->alpha, DEPTH_ZERO, sp->ply+1)
- : - search<PV>(pos, ss+1, -sp->beta, -sp->alpha, newDepth, sp->ply+1);
- }
-
- // 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 && !ThreadsMgr.thread_should_stop(threadID))
- {
- sp->bestValue = value;
-
- if (sp->bestValue > sp->alpha)
- {
- if (!PvNode || value >= sp->beta)
- sp->stopRequest = true;
-
- if (PvNode && value < sp->beta) // This guarantees that always: sp->alpha < sp->beta
- sp->alpha = value;
-
- sp->parentSstack->bestMove = ss->bestMove = move;
- }
- }
- }
-
- /* Here we have the lock still grabbed */
-
- sp->slaves[threadID] = 0;
-
- lock_release(&(sp->lock));
+ search<PvNode, true>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->ply);
}
ss->excludedMove = MOVE_NONE;
ss->skipNullMove = false;
ss->reduction = DEPTH_ZERO;
+ ss->sp = NULL;
if (i < 3)
ss->killers[0] = ss->killers[1] = ss->mateKiller = MOVE_NONE;
threads[threadID].state = THREAD_SEARCHING;
if (threads[threadID].splitPoint->pvNode)
- sp_search<PV>(threads[threadID].splitPoint, threadID);
+ do_sp_search<PV>(threads[threadID].splitPoint, threadID);
else
- sp_search<NonPV>(threads[threadID].splitPoint, threadID);
+ do_sp_search<NonPV>(threads[threadID].splitPoint, threadID);
assert(threads[threadID].state == THREAD_SEARCHING);
lock_grab(&(sp->lock));
lock_release(&(sp->lock));
+ // In helpful master concept a master can help only a sub-tree, and
+ // because here is all finished is not possible master is booked.
assert(threads[threadID].state == THREAD_AVAILABLE);
threads[threadID].state = THREAD_SEARCHING;
void ThreadsManager::exit_threads() {
- ActiveThreads = MAX_THREADS; // HACK
- AllThreadsShouldSleep = true; // HACK
+ ActiveThreads = MAX_THREADS; // Wake up all the threads
+ AllThreadsShouldExit = true; // Let the woken up threads to exit idle_loop()
+ AllThreadsShouldSleep = true; // Avoid an assert in wake_sleeping_threads()
wake_sleeping_threads();
- // This makes the threads to exit idle_loop()
- AllThreadsShouldExit = true;
-
// Wait for thread termination
for (int i = 1; i < MAX_THREADS; i++)
while (threads[i].state != THREAD_TERMINATED) {}
assert(threadID >= 0 && threadID < ActiveThreads);
- SplitPoint* sp;
+ SplitPoint* sp = threads[threadID].splitPoint;
- for (sp = threads[threadID].splitPoint; sp && !sp->stopRequest; sp = sp->parent) {}
+ for ( ; sp && !sp->stopRequest; sp = sp->parent) {}
return sp != NULL;
}
// Make a local copy to be sure doesn't change under our feet
int localActiveSplitPoints = threads[slave].activeSplitPoints;
- if (localActiveSplitPoints == 0)
- // No active split points means that the thread is available as
- // a slave for any other thread.
- return true;
-
- if (ActiveThreads == 2)
+ // No active split points means that the thread is available as
+ // a slave for any other thread.
+ if (localActiveSplitPoints == 0 || ActiveThreads == 2)
return true;
// Apply the "helpful master" concept if possible. Use localActiveSplitPoints
template <bool Fake>
void ThreadsManager::split(const Position& p, SearchStack* ss, int ply, Value* alpha,
const Value beta, Value* bestValue, Depth depth, Move threatMove,
- bool mateThreat, int* moveCount, MovePicker* mp, bool pvNode) {
+ bool mateThreat, int moveCount, MovePicker* mp, bool pvNode) {
assert(p.is_ok());
assert(ply > 0 && ply < PLY_MAX);
assert(*bestValue >= -VALUE_INFINITE);
splitPoint.pvNode = pvNode;
splitPoint.bestValue = *bestValue;
splitPoint.mp = mp;
- splitPoint.moveCount = *moveCount;
+ splitPoint.moveCount = moveCount;
splitPoint.pos = &p;
splitPoint.parentSstack = ss;
for (i = 0; i < ActiveThreads; i++)