namespace {
- // Maximum number of allowed moves per position
- const int MOVES_MAX = 256;
-
// Types
enum NodeType { NonPV, PV };
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();
// Dynamic razoring margin based on depth
inline Value razor_margin(Depth d) { return Value(0x200 + 0x10 * int(d)); }
- // Step 8. Null move search with verification search
-
- // Null move margin. A null move search will not be done if the static
- // evaluation of the position is more than NullMoveMargin below beta.
- const Value NullMoveMargin = Value(0x200);
-
// Maximum depth for use of dynamic threat detection when null move fails low
const Depth ThreatDepth = 5 * ONE_PLY;
template <NodeType PvNode>
Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply);
+ template <NodeType PvNode>
+ void sp_search(Position& pos, SearchStack* ss, Value dumy, Value beta, Depth depth, int 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);
// Init futility move count array
for (d = 0; d < 32; d++)
- FutilityMoveCountArray[d] = 3 + (1 << (3 * d / 8));
+ FutilityMoveCountArray[d] = int(3.001 + 0.25 * pow(d, 2.0));
}
// Add some extra time if the best move has changed during the last two iterations
if (Iteration > 5 && Iteration <= 50)
- TimeMgr.pv_unstability(BestMoveChangesByIteration[Iteration],
+ TimeMgr.pv_instability(BestMoveChangesByIteration[Iteration],
BestMoveChangesByIteration[Iteration-1]);
// Stop search if most of MaxSearchTime is consumed at the end of the
// Step 2. Check for aborted search and immediate draw
if (AbortSearch || ThreadsMgr.thread_should_stop(threadID))
- return VALUE_ZERO;
+ return VALUE_DRAW;
if (pos.is_draw() || ply >= PLY_MAX - 1)
return VALUE_DRAW;
return refinedValue - futility_margin(depth, 0);
// Step 8. Null move search with verification search (is omitted in PV nodes)
- // When we jump directly to qsearch() we do a null move only if static value is
- // at least beta. Otherwise we do a null move if static value is not more than
- // NullMoveMargin under beta.
if ( !PvNode
&& !ss->skipNullMove
&& depth > ONE_PLY
&& !isCheck
- && refinedValue >= beta - (depth >= 4 * ONE_PLY ? NullMoveMargin : 0)
+ && refinedValue >= beta
&& !value_is_mate(beta)
&& pos.non_pawn_material(pos.side_to_move()))
{
&& !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);
}
// Step 19. Check for mate and stalemate
assert(tte->static_value() != VALUE_NONE);
evalMargin = tte->static_value_margin();
- bestValue = tte->static_value();
+ ss->eval = bestValue = tte->static_value();
}
else
- bestValue = evaluate(pos, evalMargin);
+ ss->eval = bestValue = evaluate(pos, evalMargin);
- ss->eval = bestValue;
update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval);
// Stand pat. Return immediately if static value is at least beta
deepChecks = (depth == -ONE_PLY && bestValue >= beta - PawnValueMidgame / 8);
// Futility pruning parameters, not needed when in check
- futilityBase = bestValue + FutilityMarginQS + evalMargin;
+ futilityBase = ss->eval + evalMargin + FutilityMarginQS;
enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
}
}
}
- // Detect blocking evasions that are candidate to be pruned
+ // Detect non-capture evasions that are candidate to be pruned
evasionPrunable = isCheck
&& bestValue > value_mated_in(PLY_MAX)
&& !pos.move_is_capture(move)
- && pos.type_of_piece_on(move_from(move)) != KING
&& !pos.can_castle(pos.side_to_move());
// Don't search moves with negative SEE values
ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT);
TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, evalMargin);
- // Update killers only for checking moves that fails high
- if ( bestValue >= beta
- && !pos.move_is_capture_or_promotion(ss->bestMove))
- update_killers(ss->bestMove, ss);
-
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
return bestValue;
// 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);
+ Position pos(*sp->pos, threadID);
+ SearchStack* ss = sp->sstack[threadID] + 1;
+ ss->sp = sp;
+
+ sp_search<PvNode>(pos, ss, Value(threadID), sp->beta, sp->depth, sp->ply);
+ }
+
+ template <NodeType PvNode>
+ void sp_search(Position& pos, SearchStack* ss, Value, Value beta, Depth depth, int ply) {
+
StateInfo st;
Move move;
Depth ext, newDepth;
bool isCheck, moveIsCheck, captureOrPromotion, dangerous;
int moveCount;
value = -VALUE_INFINITE;
+ SplitPoint* sp = ss->sp;
+ Move threatMove = sp->threatMove;
+ MovePicker& mp = *sp->mp;
+ int threadID = pos.thread();
- Position pos(*sp->pos, threadID);
CheckInfo ci(pos);
- SearchStack* ss = sp->sstack[threadID] + 1;
isCheck = pos.is_check();
// 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
+ while ( sp->bestValue < beta
+ && (move = mp.get_next_move()) != MOVE_NONE
&& !ThreadsMgr.thread_should_stop(threadID))
{
moveCount = ++sp->moveCount;
// Step 11. Decide the new search depth
ext = extension<PvNode>(pos, move, captureOrPromotion, moveIsCheck, false, sp->mateThreat, &dangerous);
- newDepth = sp->depth - ONE_PLY + ext;
+ newDepth = depth - ONE_PLY + ext;
// Update current move
ss->currentMove = move;
&& !move_is_castle(move))
{
// Move count based pruning
- if ( moveCount >= futility_move_count(sp->depth)
- && !(sp->threatMove && connected_threat(pos, move, sp->threatMove))
+ if ( moveCount >= futility_move_count(depth)
+ && !(threatMove && connected_threat(pos, move, threatMove))
&& sp->bestValue > value_mated_in(PLY_MAX))
{
lock_grab(&(sp->lock));
}
// Value based pruning
- Depth predictedDepth = newDepth - reduction<NonPV>(sp->depth, moveCount);
+ Depth predictedDepth = newDepth - reduction<NonPV>(depth, moveCount);
futilityValueScaled = ss->eval + futility_margin(predictedDepth, moveCount)
+ H.gain(pos.piece_on(move_from(move)), move_to(move));
- if (futilityValueScaled < sp->beta)
+ if (futilityValueScaled < beta)
{
lock_grab(&(sp->lock));
&& !move_is_castle(move)
&& !move_is_killer(move, ss))
{
- ss->reduction = reduction<PvNode>(sp->depth, moveCount);
+ ss->reduction = reduction<PvNode>(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);
+ value = d < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, ply+1)
+ : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, d, ply+1);
doFullDepthSearch = (value > localAlpha);
}
ss->reduction = ONE_PLY;
Value localAlpha = sp->alpha;
- value = -search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, sp->ply+1);
+ value = -search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, ply+1);
doFullDepthSearch = (value > localAlpha);
}
ss->reduction = DEPTH_ZERO; // Restore original reduction
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);
+ value = newDepth < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, ply+1)
+ : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth, 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);
+ if (PvNode && value > localAlpha && value < beta)
+ value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -beta, -sp->alpha, DEPTH_ZERO, ply+1)
+ : - search<PV>(pos, ss+1, -beta, -sp->alpha, newDepth, ply+1);
}
// Step 16. Undo move
if (value > sp->bestValue && !ThreadsMgr.thread_should_stop(threadID))
{
sp->bestValue = value;
-
- if (sp->bestValue > sp->alpha)
+ if (value > sp->alpha)
{
- if (!PvNode || value >= sp->beta)
+ if (!PvNode || value >= beta)
sp->stopRequest = true;
- if (PvNode && value < sp->beta) // This guarantees that always: sp->alpha < sp->beta
+ if (PvNode && value < beta) // We want always sp->alpha < beta
sp->alpha = value;
sp->parentSstack->bestMove = ss->bestMove = move;
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++)
projects / stockfish / blobdiff