// Razoring and futility margin based on depth
const int razor_margin[4] = { 483, 570, 603, 554 };
- Value futility_margin(Depth d) { return Value(200 * d); }
+ Value futility_margin(Depth d) { return Value(150 * d); }
// Futility and reductions lookup tables, initialized at startup
int FutilityMoveCounts[2][16]; // [improving][depth]
{
th->history.clear();
th->counterMoves.clear();
+ th->fromTo.clear();
}
Threads.main()->previousScore = VALUE_INFINITE;
assert(-VALUE_INFINITE <= alpha && alpha < beta && beta <= VALUE_INFINITE);
assert(PvNode || (alpha == beta - 1));
assert(DEPTH_ZERO < depth && depth < DEPTH_MAX);
+ assert(!(PvNode && cutNode));
Move pv[MAX_PLY+1], quietsSearched[64];
StateInfo st;
ss->currentMove = ttMove; // Can be MOVE_NONE
// If ttMove is quiet, update killers, history, counter move on TT hit
- if (ttValue >= beta && ttMove && !pos.capture_or_promotion(ttMove))
+ if (ttValue >= beta && ttMove)
update_stats(pos, ss, ttMove, depth, nullptr, 0);
return ttValue;
// Step 8. Null move search with verification search (is omitted in PV nodes)
if ( !PvNode
- && depth >= 2 * ONE_PLY
&& eval >= beta
+ && (ss->staticEval >= beta - 35 * (depth / ONE_PLY - 6) || depth >= 13 * ONE_PLY)
&& pos.non_pawn_material(pos.side_to_move()))
{
ss->currentMove = MOVE_NULL;
}
// Step 10. Internal iterative deepening (skipped when in check)
- if ( depth >= (PvNode ? 5 * ONE_PLY : 8 * ONE_PLY)
+ if ( depth >= 6 * ONE_PLY
&& !ttMove
&& (PvNode || ss->staticEval + 256 >= beta))
{
- Depth d = depth - 2 * ONE_PLY - (PvNode ? DEPTH_ZERO : depth / 4);
ss->skipEarlyPruning = true;
- search<NT>(pos, ss, alpha, beta, d, true);
+ search<NT>(pos, ss, alpha, beta, 3 * depth / 4 - 2 * ONE_PLY, cutNode);
ss->skipEarlyPruning = false;
tte = TT.probe(posKey, ttHit);
moves_loop: // When in check search starts from here
- Square prevSq = to_sq((ss-1)->currentMove);
const CounterMoveStats* cmh = (ss-1)->counterMoves;
const CounterMoveStats* fmh = (ss-2)->counterMoves;
const CounterMoveStats* fmh2 = (ss-4)->counterMoves;
CheckInfo ci(pos);
value = bestValue; // Workaround a bogus 'uninitialized' warning under gcc
improving = ss->staticEval >= (ss-2)->staticEval
- || ss->staticEval == VALUE_NONE
+ /* || ss->staticEval == VALUE_NONE Already implicit in the previous condition */
||(ss-2)->staticEval == VALUE_NONE;
singularExtensionNode = !rootNode
&& moveCount >= FutilityMoveCounts[improving][depth];
// Step 12. Extend checks
- if ( givesCheck
- && ( moveCount == 1
- || (!moveCountPruning && pos.see_sign(move) >= VALUE_ZERO)))
+ if ( givesCheck
+ && !moveCountPruning
+ && pos.see_sign(move) >= VALUE_ZERO)
extension = ONE_PLY;
// Singular extension search. If all moves but one fail low on a search of
if (moveCountPruning)
continue;
+ predictedDepth = std::max(newDepth - reduction<PvNode>(improving, depth, moveCount), DEPTH_ZERO);
+
// Countermoves based pruning
- if ( depth <= 4 * ONE_PLY
+ if ( predictedDepth < 3 * ONE_PLY
&& move != ss->killers[0]
&& (!cmh || (*cmh )[moved_piece][to_sq(move)] < VALUE_ZERO)
&& (!fmh || (*fmh )[moved_piece][to_sq(move)] < VALUE_ZERO)
&& (!fmh2 || (*fmh2)[moved_piece][to_sq(move)] < VALUE_ZERO || (cmh && fmh)))
continue;
- predictedDepth = std::max(newDepth - reduction<PvNode>(improving, depth, moveCount), DEPTH_ZERO);
-
// Futility pruning: parent node
if ( predictedDepth < 7 * ONE_PLY
- && ss->staticEval + futility_margin(predictedDepth) + 256 <= alpha)
+ && ss->staticEval + 256 + 200 * predictedDepth / ONE_PLY <= alpha)
continue;
- // Prune moves with negative SEE at low depths
- if (predictedDepth < 4 * ONE_PLY && pos.see_sign(move) < VALUE_ZERO)
- continue;
+ // Prune moves with negative SEE at low depths and below a decreasing
+ // threshold at higher depths.
+ if (predictedDepth < 8 * ONE_PLY)
+ {
+ Value see_v = predictedDepth < 4 * ONE_PLY ? VALUE_ZERO
+ : -PawnValueMg * 2 * int(predictedDepth - 3 * ONE_PLY);
+
+ if (pos.see_sign(move) < see_v)
+ continue;
+ }
}
// Speculative prefetch as early as possible
// re-searched at full depth.
if ( depth >= 3 * ONE_PLY
&& moveCount > 1
- && !captureOrPromotion)
+ && (!captureOrPromotion || moveCountPruning))
{
Depth r = reduction<PvNode>(improving, depth, moveCount);
- Value val = thisThread->history[moved_piece][to_sq(move)]
- + (cmh ? (*cmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
- + (fmh ? (*fmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
- + (fmh2 ? (*fmh2)[moved_piece][to_sq(move)] : VALUE_ZERO);
-
- // Increase reduction for cut nodes
- if (!PvNode && cutNode)
- r += 2 * ONE_PLY;
-
- // Decrease reduction for moves that escape a capture. Filter out
- // castling moves, because they are coded as "king captures rook" and
- // hence break make_move(). Also use see() instead of see_sign(),
- // because the destination square is empty.
- else if ( type_of(move) == NORMAL
- && type_of(pos.piece_on(to_sq(move))) != PAWN
- && pos.see(make_move(to_sq(move), from_sq(move))) < VALUE_ZERO)
- r -= 2 * ONE_PLY;
-
- // Decrease/increase reduction for moves with a good/bad history
- int rHist = (val - 10000) / 20000;
- r = std::max(DEPTH_ZERO, r - rHist * ONE_PLY);
+
+ if (captureOrPromotion)
+ r -= r ? ONE_PLY : DEPTH_ZERO;
+ else
+ {
+ Value val = thisThread->history[moved_piece][to_sq(move)]
+ + (cmh ? (*cmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
+ + (fmh ? (*fmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
+ + (fmh2 ? (*fmh2)[moved_piece][to_sq(move)] : VALUE_ZERO)
+ + thisThread->fromTo.get(~pos.side_to_move(), move);
+
+ // Increase reduction for cut nodes
+ if (cutNode)
+ r += 2 * ONE_PLY;
+
+ // Decrease reduction for moves that escape a capture. Filter out
+ // castling moves, because they are coded as "king captures rook" and
+ // hence break make_move(). Also use see() instead of see_sign(),
+ // because the destination square is empty.
+ else if ( type_of(move) == NORMAL
+ && type_of(pos.piece_on(to_sq(move))) != PAWN
+ && pos.see(make_move(to_sq(move), from_sq(move))) < VALUE_ZERO)
+ r -= 2 * ONE_PLY;
+
+ // Decrease/increase reduction for moves with a good/bad history
+ int rHist = (val - 8000) / 20000;
+ r = std::max(DEPTH_ZERO, r - rHist * ONE_PLY);
+ }
Depth d = std::max(newDepth - r, ONE_PLY);
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, true);
- doFullDepthSearch = (value > alpha && r != DEPTH_ZERO);
+ doFullDepthSearch = (value > alpha && d != newDepth);
}
else
doFullDepthSearch = !PvNode || moveCount > 1;
: inCheck ? mated_in(ss->ply) : DrawValue[pos.side_to_move()];
// Quiet best move: update killers, history and countermoves
- else if (bestMove && !pos.capture_or_promotion(bestMove))
+ else if (bestMove)
update_stats(pos, ss, bestMove, depth, quietsSearched, quietCount);
// Bonus for prior countermove that caused the fail low
else if ( depth >= 3 * ONE_PLY
- && !bestMove
- && !inCheck
&& !pos.captured_piece_type()
&& is_ok((ss-1)->currentMove))
{
+ Square prevSq = to_sq((ss-1)->currentMove);
Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + 2 * depth / ONE_PLY - 2);
if ((ss-2)->counterMoves)
(ss-2)->counterMoves->update(pos.piece_on(prevSq), prevSq, bonus);
void update_stats(const Position& pos, Stack* ss, Move move,
Depth depth, Move* quiets, int quietsCnt) {
+ Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + 2 * depth / ONE_PLY - 2);
+ Square prevSq = to_sq((ss-1)->currentMove);
+
+ // Extra penalty for a quiet TT move in previous ply when it gets refuted
+ if ((ss-1)->moveCount == 1 && !pos.captured_piece_type())
+ {
+ CounterMoveStats* fmh = (ss-2)->counterMoves;
+ CounterMoveStats* cmh2 = (ss-3)->counterMoves;
+ CounterMoveStats* cmh3 = (ss-5)->counterMoves;
+
+ if (fmh)
+ fmh->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
+
+ if (cmh2)
+ cmh2->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
+
+ if (cmh3)
+ cmh3->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
+ }
+
+ if (pos.capture_or_promotion(move))
+ return;
+
if (ss->killers[0] != move)
{
ss->killers[1] = ss->killers[0];
ss->killers[0] = move;
}
- Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + 2 * depth / ONE_PLY - 2);
-
- Square prevSq = to_sq((ss-1)->currentMove);
CounterMoveStats* cmh = (ss-1)->counterMoves;
CounterMoveStats* fmh = (ss-2)->counterMoves;
CounterMoveStats* fmh2 = (ss-4)->counterMoves;
+ Color c = pos.side_to_move();
Thread* thisThread = pos.this_thread();
thisThread->history.update(pos.moved_piece(move), to_sq(move), bonus);
+ thisThread->fromTo.update(c, move, bonus);
if (cmh)
{
for (int i = 0; i < quietsCnt; ++i)
{
thisThread->history.update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
+ thisThread->fromTo.update(c, quiets[i], -bonus);
if (cmh)
cmh->update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
if (fmh2)
fmh2->update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
}
-
- // Extra penalty for a quiet TT move in previous ply when it gets refuted
- if ((ss-1)->moveCount == 1 && !pos.captured_piece_type())
- {
- if ((ss-2)->counterMoves)
- (ss-2)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
-
- if ((ss-3)->counterMoves)
- (ss-3)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
-
- if ((ss-5)->counterMoves)
- (ss-5)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
- }
}
pos.do_move(pv[0], st, pos.gives_check(pv[0], CheckInfo(pos)));
TTEntry* tte = TT.probe(pos.key(), ttHit);
- pos.undo_move(pv[0]);
if (ttHit)
{
Move m = tte->move(); // Local copy to be SMP safe
if (MoveList<LEGAL>(pos).contains(m))
- return pv.push_back(m), true;
+ pv.push_back(m);
}
- return false;
+ pos.undo_move(pv[0]);
+ return pv.size() > 1;
}
void Tablebases::filter_root_moves(Position& pos, Search::RootMoves& rootMoves) {