inline Value razor_margin(Depth d) { return Value(512 + 16 * int(d)); }
// Futility lookup tables (initialized at startup) and their access functions
- Value FutilityMargins[14][64]; // [depth][moveNumber]
int FutilityMoveCounts[2][32]; // [improving][depth]
- inline Value futility_margin(Depth d, int mn) {
- assert(DEPTH_ZERO <= d && d < 7 * ONE_PLY);
- return FutilityMargins[d][std::min(mn, 63)];
+ inline Value futility_margin(Depth d) {
+ return Value(100 * int(d));
}
// Reduction lookup tables (initialized at startup) and their access function
double BestMoveChanges;
Value DrawValue[COLOR_NB];
HistoryStats History;
+ GainsStats Gains;
CountermovesStats Countermoves;
template <NodeType NT>
Reductions[0][0][hd][mc] += ONE_PLY / 2;
}
- // Init futility margins array
- for (d = 0; d < 14; ++d) for (mc = 0; mc < 64; ++mc)
- FutilityMargins[d][mc] = Value(112 * int(2.9 * log(d >= 1 ? double(d) : 1.0)) - 8 * mc + 45);
-
// Init futility move count array
for (d = 0; d < 32; ++d)
{
Value bestValue, alpha, beta, delta;
std::memset(ss-2, 0, 5 * sizeof(Stack));
+ (ss-1)->currentMove = MOVE_NULL; // Hack to skip update gains
depth = 0;
BestMoveChanges = 0;
TT.new_search();
History.clear();
+ Gains.clear();
Countermoves.clear();
PVSize = Options["MultiPV"];
RootMoves[i].prevScore = RootMoves[i].score;
// MultiPV loop. We perform a full root search for each PV line
- for (PVIdx = 0; PVIdx < PVSize; ++PVIdx)
+ for (PVIdx = 0; PVIdx < PVSize && !Signals.stop; ++PVIdx)
{
// Reset aspiration window starting size
if (depth >= 5)
for (size_t i = 0; i <= PVIdx; ++i)
RootMoves[i].insert_pv_in_tt(pos);
- // If search has been stopped return immediately. Sorting and
+ // If search has been stopped break immediately. Sorting and
// writing PV back to TT is safe becuase RootMoves is still
// valid, although refers to previous iteration.
if (Signals.stop)
- return;
+ break;
// When failing high/low give some update (without cluttering
// the UI) before to research.
Signals.stop = true;
// Do we have time for the next iteration? Can we stop searching now?
- if (Limits.use_time_management() && !Signals.stopOnPonderhit)
+ if (Limits.use_time_management() && !Signals.stop && !Signals.stopOnPonderhit)
{
bool stop = false; // Local variable, not the volatile Signals.stop
assert(PvNode || (alpha == beta - 1));
assert(depth > DEPTH_ZERO);
- Move quietsSearched[64];
StateInfo st;
const TTEntry *tte;
SplitPoint* splitPoint;
Key posKey;
Move ttMove, move, excludedMove, bestMove, threatMove;
- Depth ext, newDepth;
- Value bestValue, value, ttValue;
- Value eval, nullValue;
+ Depth ext, newDepth, predictedDepth;
+ Value bestValue, value, ttValue, eval, nullValue, futilityValue;
bool inCheck, givesCheck, pvMove, singularExtensionNode, improving;
bool captureOrPromotion, dangerous, doFullDepthSearch;
- int moveCount, quietCount;
+ int moveCount;
// Step 1. Initialize node
Thread* thisThread = pos.this_thread();
goto moves_loop;
}
- moveCount = quietCount = 0;
+ moveCount = 0;
bestValue = -VALUE_INFINITE;
ss->currentMove = threatMove = (ss+1)->excludedMove = bestMove = MOVE_NONE;
ss->ply = (ss-1)->ply + 1;
- ss->futilityMoveCount = 0;
(ss+1)->skipNullMove = false; (ss+1)->reduction = DEPTH_ZERO;
(ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE, ss->staticEval);
}
+ if ( !pos.captured_piece_type()
+ && ss->staticEval != VALUE_NONE
+ && (ss-1)->staticEval != VALUE_NONE
+ && (move = (ss-1)->currentMove) != MOVE_NULL
+ && type_of(move) == NORMAL)
+ {
+ Square to = to_sq(move);
+ Gains.update(pos.piece_on(to), to, -(ss-1)->staticEval - ss->staticEval);
+ }
+
// Step 6. Razoring (skipped when in check)
if ( !PvNode
&& depth < 4 * ONE_PLY
return v;
}
- // Step 7. post-Futility pruning (skipped when in check)
+ // Step 7. Futility pruning: child node (skipped when in check)
if ( !PvNode
&& !ss->skipNullMove
&& depth < 7 * ONE_PLY
- && eval - futility_margin(depth, (ss-1)->futilityMoveCount) >= beta
+ && eval - futility_margin(depth) >= beta
&& abs(beta) < VALUE_MATE_IN_MAX_PLY
&& abs(eval) < VALUE_KNOWN_WIN
&& pos.non_pawn_material(pos.side_to_move()))
- return eval - futility_margin(depth, (ss-1)->futilityMoveCount);
+ return eval - futility_margin(depth);
// Step 8. Null move search with verification search (is omitted in PV nodes)
if ( !PvNode
// Update current move (this must be done after singular extension search)
newDepth = depth - ONE_PLY + ext;
- Depth predictedDepth = newDepth - reduction<PvNode>(improving, depth, moveCount);
- // Step 13. Futility pruning (is omitted in PV nodes)
+ // Step 13. Pruning at shallow depth (exclude PV nodes)
if ( !PvNode
&& !captureOrPromotion
&& !inCheck
&& !dangerous
+ /* && move != ttMove Already implicit in the next condition */
&& bestValue > VALUE_MATED_IN_MAX_PLY)
{
// Move count based pruning
continue;
}
+ predictedDepth = newDepth - reduction<PvNode>(improving, depth, moveCount);
+
+ // Futility pruning: parent node
+ if (predictedDepth < 7 * ONE_PLY)
+ {
+ futilityValue = ss->staticEval + futility_margin(predictedDepth)
+ + Value(128) + Gains[pos.moved_piece(move)][to_sq(move)];
+
+ if (futilityValue <= alpha)
+ {
+ bestValue = std::max(bestValue, futilityValue);
+
+ if (SpNode)
+ {
+ splitPoint->mutex.lock();
+ if (bestValue > splitPoint->bestValue)
+ splitPoint->bestValue = bestValue;
+ }
+ continue;
+ }
+ }
+
// Prune moves with negative SEE at low depths
- if ( predictedDepth < 4 * ONE_PLY
- && pos.see_sign(move) < 0)
+ if (predictedDepth < 4 * ONE_PLY && pos.see_sign(move) < 0)
{
if (SpNode)
splitPoint->mutex.lock();
continue;
}
- // We have not pruned the move that will be searched, but remember how
- // far in the move list we are to be more aggressive in the child node.
- ss->futilityMoveCount = moveCount;
}
- else
- ss->futilityMoveCount = 0;
// Check for legality only before to do the move
if (!RootNode && !SpNode && !pos.legal(move, ci.pinned))
{
- --moveCount;
+ moveCount--;
continue;
}
pvMove = PvNode && moveCount == 1;
ss->currentMove = move;
- if (!SpNode && !captureOrPromotion && quietCount < 64)
- quietsSearched[quietCount++] = move;
// Step 14. Make the move
pos.do_move(move, st, ci, givesCheck);
// played non-capture moves.
Value bonus = Value(int(depth) * int(depth));
History.update(pos.moved_piece(bestMove), to_sq(bestMove), bonus);
- for (int i = 0; i < quietCount - 1; ++i)
- {
- Move m = quietsSearched[i];
- History.update(pos.moved_piece(m), to_sq(m), -bonus);
- }
+
+ if (bestMove != ttMove)
+ for (const ExtMove* em = mp.stage_moves(); em->move != bestMove; ++em)
+ History.update(pos.moved_piece(em->move), to_sq(em->move), -bonus);
if (is_ok((ss-1)->currentMove))
Countermoves.update(pos.piece_on(prevMoveSq), prevMoveSq, bestMove);
// We exclude the trivial case where a sliding piece does in two moves what
// it could do in one move: eg. Ra1a2, Ra2a3.
if ( m2to == m1from
- || (m1to == m2from && !squares_aligned(m1from, m2from, m2to)))
+ || (m1to == m2from && !aligned(m1from, m2from, m2to)))
return true;
// Second one moves through the square vacated by first one
projects / stockfish / blobdiff