const bool PruneDefendingMoves = false;
const bool PruneBlockingMoves = false;
+ // If the TT move is at least SingleReplyMargin better then the
+ // remaining ones we will extend it.
+ const Value SingleReplyMargin = Value(0x64);
+
// Margins for futility pruning in the quiescence search, and at frontier
// and near frontier nodes.
const Value FutilityMarginQS = Value(0x80);
+ // Each move futility margin is decreased
+ const Value IncrementalFutilityMargin = Value(0x8);
+
// Remaining depth: 1 ply 1.5 ply 2 ply 2.5 ply 3 ply 3.5 ply
const Value FutilityMargins[12] = { Value(0x100), Value(0x120), Value(0x200), Value(0x220), Value(0x250), Value(0x270),
// 4 ply 4.5 ply 5 ply 5.5 ply 6 ply 6.5 ply
Value id_loop(const Position& pos, Move searchMoves[]);
Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value alpha, Value beta);
Value search_pv(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID);
- Value search(Position& pos, SearchStack ss[], Value beta, Depth depth, int ply, bool allowNullmove, int threadID);
+ Value search(Position& pos, SearchStack ss[], Value beta, Depth depth, int ply, bool allowNullmove, int threadID, Move excludedMove = MOVE_NONE);
Value qsearch(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID);
void sp_search(SplitPoint* sp, int threadID);
void sp_search_pv(SplitPoint* sp, int threadID);
Value *alpha, Value *beta, Value *bestValue,
const Value futilityValue, const Value approximateValue,
Depth depth, int *moves,
- MovePicker *mp, Bitboard dcCandidates, int master, bool pvNode);
+ MovePicker *mp, int master, bool pvNode);
void wake_sleeping_threads();
#if !defined(_MSC_VER)
int perft(Position& pos, Depth depth)
{
Move move;
- MovePicker mp = MovePicker(pos, MOVE_NONE, depth, H);
- Bitboard dcCandidates = pos.discovered_check_candidates(pos.side_to_move());
int sum = 0;
+ MovePicker mp = MovePicker(pos, MOVE_NONE, depth, H);
// If we are at the last ply we don't need to do and undo
// the moves, just to count them.
if (depth <= OnePly) // Replace with '<' to test also qsearch
{
- while ((move = mp.get_next_move()) != MOVE_NONE) sum++;
+ while (mp.get_next_move()) sum++;
return sum;
}
// Loop through all legal moves
+ CheckInfo ci(pos);
while ((move = mp.get_next_move()) != MOVE_NONE)
{
- StateInfo st;
- pos.do_move(move, st, dcCandidates);
- sum += perft(pos, depth - OnePly);
- pos.undo_move(move);
+ StateInfo st;
+ pos.do_move(move, st, ci, pos.move_is_check(move, ci));
+ sum += perft(pos, depth - OnePly);
+ pos.undo_move(move);
}
return sum;
}
Value oldAlpha = alpha;
Value value;
- Bitboard dcCandidates = pos.discovered_check_candidates(pos.side_to_move());
+ CheckInfo ci(pos);
// Loop through all the moves in the root move list
for (int i = 0; i < rml.move_count() && !AbortSearch; i++)
<< " currmovenumber " << i + 1 << std::endl;
// Decide search depth for this move
+ bool moveIsCheck = pos.move_is_check(move);
bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
bool dangerous;
- ext = extension(pos, move, true, captureOrPromotion, pos.move_is_check(move), false, false, &dangerous);
+ ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
newDepth = (Iteration - 2) * OnePly + ext + InitialDepth;
// Make the move, and search it
- pos.do_move(move, st, dcCandidates);
+ pos.do_move(move, st, ci, moveIsCheck);
if (i < MultiPV)
{
Move movesSearched[256];
EvalInfo ei;
StateInfo st;
- Bitboard dcCandidates;
const TTEntry* tte;
Move ttMove, move;
Depth ext, newDepth;
isCheck = pos.is_check();
mateThreat = pos.has_mate_threat(opposite_color(pos.side_to_move()));
CheckInfo ci(pos);
- dcCandidates = ci.dcCandidates;
MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
// Loop through all legal moves until no moves remain or a beta cutoff
moveIsCheck = pos.move_is_check(move, ci);
captureOrPromotion = pos.move_is_capture_or_promotion(move);
- movesSearched[moveCount++] = ss[ply].currentMove = move;
-
// Decide the new search depth
ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, singleReply, mateThreat, &dangerous);
+
+ // We want to extend the TT move if it is much better then remaining ones.
+ // To verify this we do a reduced search on all the other moves but the ttMove,
+ // if result is lower then TT value minus a margin then we assume ttMove is the
+ // only one playable. It is a kind of relaxed single reply extension.
+ if ( depth >= 4 * OnePly
+ && move == ttMove
+ && ext < OnePly
+ && is_lower_bound(tte->type())
+ && tte->depth() >= depth - 3 * OnePly)
+ {
+ Value ttValue = value_from_tt(tte->value(), ply);
+
+ if (abs(ttValue) < VALUE_KNOWN_WIN)
+ {
+ Depth d = Max(Min(depth / 2, depth - 4 * OnePly), OnePly);
+ Value excValue = search(pos, ss, ttValue - SingleReplyMargin, d, ply, false, threadID, ttMove);
+
+ // If search result is well below the foreseen score of the ttMove then we
+ // assume ttMove is the only one realistically playable and we extend it.
+ if (excValue < ttValue - SingleReplyMargin)
+ ext = OnePly;
+ }
+ }
+
newDepth = depth - OnePly + ext;
+ // Update current move
+ movesSearched[moveCount++] = ss[ply].currentMove = move;
+
// Make and search the move
- pos.do_move(move, st, dcCandidates);
+ pos.do_move(move, st, ci, moveIsCheck);
if (moveCount == 1) // The first move in list is the PV
value = -search_pv(pos, ss, -beta, -alpha, newDepth, ply+1, threadID);
&& idle_thread_exists(threadID)
&& !AbortSearch
&& !thread_should_stop(threadID)
- && split(pos, ss, ply, &alpha, &beta, &bestValue, VALUE_NONE, VALUE_NONE, depth,
- &moveCount, &mp, dcCandidates, threadID, true))
+ && split(pos, ss, ply, &alpha, &beta, &bestValue, VALUE_NONE, VALUE_NONE,
+ depth, &moveCount, &mp, threadID, true))
break;
}
// search() is the search function for zero-width nodes.
Value search(Position& pos, SearchStack ss[], Value beta, Depth depth,
- int ply, bool allowNullmove, int threadID) {
+ int ply, bool allowNullmove, int threadID, Move excludedMove) {
assert(beta >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
assert(ply >= 0 && ply < PLY_MAX);
Move movesSearched[256];
EvalInfo ei;
StateInfo st;
- Bitboard dcCandidates;
const TTEntry* tte;
Move ttMove, move;
Depth ext, newDepth;
- Value approximateEval, nullValue, value, futilityValue;
+ Value approximateEval, nullValue, value, futilityValue, futilityValueScaled;
bool isCheck, useFutilityPruning, singleReply, moveIsCheck, captureOrPromotion, dangerous;
bool mateThreat = false;
int moveCount = 0;
if (value_mate_in(ply + 1) < beta)
return beta - 1;
+ // We don't want the score of a partial search to overwrite a previous full search
+ // TT value, so we use a different position key in case of an excluded move exsists.
+ Key posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key();
+
// Transposition table lookup
- tte = TT.retrieve(pos.get_key());
+ tte = TT.retrieve(posKey);
ttMove = (tte ? tte->move() : MOVE_NONE);
if (tte && ok_to_use_TT(tte, depth, beta, ply))
ss[ply].currentMove = MOVE_NULL;
pos.do_null_move(st);
- int R = (depth >= 5 * OnePly ? 4 : 3); // Null move dynamic reduction
+
+ // Null move dynamic reduction based on depth
+ int R = (depth >= 5 * OnePly ? 4 : 3);
+
+ // Null move dynamic reduction based on value
+ if (approximateEval - beta > PawnValueMidgame)
+ R++;
nullValue = -search(pos, ss, -(beta-1), depth-R*OnePly, ply+1, false, threadID);
&& ttMove == MOVE_NONE
&& !pos.has_pawn_on_7th(pos.side_to_move()))
{
- Value v = qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID);
- if (v < beta - RazorMargins[int(depth) - 2])
+ Value rbeta = beta - RazorMargins[int(depth) - 2];
+ Value v = qsearch(pos, ss, rbeta-1, rbeta, Depth(0), ply, threadID);
+ if (v < rbeta)
return v;
}
// to search all moves.
MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
CheckInfo ci(pos);
- dcCandidates = ci.dcCandidates;
futilityValue = VALUE_NONE;
useFutilityPruning = depth < SelectiveDepth && !isCheck;
if (tte && (tte->type() & VALUE_TYPE_EVAL))
futilityValue = value_from_tt(tte->value(), ply) + FutilityMargins[int(depth) - 2];
- // Loop through all legal moves until no moves remain or a beta cutoff
- // occurs.
+ // Move count pruning limit
+ const int MCLimit = 3 + (1 << (3*int(depth)/8));
+
+ // Loop through all legal moves until no moves remain or a beta cutoff occurs
while ( bestValue < beta
&& (move = mp.get_next_move()) != MOVE_NONE
&& !thread_should_stop(threadID))
{
assert(move_is_ok(move));
+ if (move == excludedMove)
+ continue;
+
singleReply = (isCheck && mp.number_of_evasions() == 1);
moveIsCheck = pos.move_is_check(move, ci);
captureOrPromotion = pos.move_is_capture_or_promotion(move);
- movesSearched[moveCount++] = ss[ply].currentMove = move;
-
// Decide the new search depth
ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, singleReply, mateThreat, &dangerous);
+
+ // We want to extend the TT move if it is much better then remaining ones.
+ // To verify this we do a reduced search on all the other moves but the ttMove,
+ // if result is lower then TT value minus a margin then we assume ttMove is the
+ // only one playable. It is a kind of relaxed single reply extension.
+ if ( depth >= 4 * OnePly
+ && !excludedMove // do not allow recursive single-reply search
+ && move == ttMove
+ && ext < OnePly
+ && is_lower_bound(tte->type())
+ && tte->depth() >= depth - 3 * OnePly)
+ {
+ Value ttValue = value_from_tt(tte->value(), ply);
+
+ if (abs(ttValue) < VALUE_KNOWN_WIN)
+ {
+ Depth d = Max(Min(depth / 2, depth - 4 * OnePly), OnePly);
+ Value excValue = search(pos, ss, ttValue - SingleReplyMargin, d, ply, false, threadID, ttMove);
+
+ // If search result is well below the foreseen score of the ttMove then we
+ // assume ttMove is the only one realistically playable and we extend it.
+ if (excValue < ttValue - SingleReplyMargin)
+ ext = (depth >= 8 * OnePly) ? OnePly : ext + OnePly / 2;
+ }
+ }
+
newDepth = depth - OnePly + ext;
+ // Update current move
+ movesSearched[moveCount++] = ss[ply].currentMove = move;
+
// Futility pruning
if ( useFutilityPruning
&& !dangerous
- && !captureOrPromotion)
+ && !captureOrPromotion
+ && move != ttMove)
{
// History pruning. See ok_to_prune() definition
- if ( moveCount >= 2 + int(depth)
+ if ( moveCount >= MCLimit
&& ok_to_prune(pos, move, ss[ply].threatMove, depth)
&& bestValue > value_mated_in(PLY_MAX))
continue;
{
if (futilityValue == VALUE_NONE)
futilityValue = evaluate(pos, ei, threadID)
- + FutilityMargins[int(depth) - 2];
+ + 64*(2+bitScanReverse32(int(depth) * int(depth)));
- if (futilityValue < beta)
+ futilityValueScaled = futilityValue - moveCount * IncrementalFutilityMargin;
+
+ if (futilityValueScaled < beta)
{
- if (futilityValue > bestValue)
- bestValue = futilityValue;
+ if (futilityValueScaled > bestValue)
+ bestValue = futilityValueScaled;
continue;
}
}
}
// Make and search the move
- pos.do_move(move, st, dcCandidates);
+ 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.
&& idle_thread_exists(threadID)
&& !AbortSearch
&& !thread_should_stop(threadID)
- && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, approximateEval, depth, &moveCount,
- &mp, dcCandidates, threadID, false))
+ && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, approximateEval,
+ depth, &moveCount, &mp, threadID, false))
break;
}
// All legal moves have been searched. A special case: If there were
// no legal moves, it must be mate or stalemate.
if (moveCount == 0)
- return (pos.is_check() ? value_mated_in(ply) : VALUE_DRAW);
+ return excludedMove ? beta - 1 : (pos.is_check() ? value_mated_in(ply) : VALUE_DRAW);
// If the search is not aborted, update the transposition table,
// history counters, and killer moves.
return bestValue;
if (bestValue < beta)
- TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_UPPER, depth, MOVE_NONE);
+ TT.store(posKey, value_to_tt(bestValue, ply), VALUE_TYPE_UPPER, depth, MOVE_NONE);
else
{
BetaCounter.add(pos.side_to_move(), depth, threadID);
update_history(pos, move, depth, movesSearched, moveCount);
update_killers(move, ss[ply]);
}
- TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, depth, move);
+ TT.store(posKey, value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, depth, move);
}
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
EvalInfo ei;
StateInfo st;
- Bitboard dcCandidates;
Move ttMove, move;
Value staticValue, bestValue, value, futilityValue;
- bool isCheck, enoughMaterial;
+ bool isCheck, enoughMaterial, moveIsCheck;
const TTEntry* tte = NULL;
int moveCount = 0;
bool pvNode = (beta - alpha != 1);
// queen promotions and checks (only if depth == 0) will be generated.
MovePicker mp = MovePicker(pos, ttMove, depth, H);
CheckInfo ci(pos);
- dcCandidates = ci.dcCandidates;
enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
// Loop through the moves until no moves remain or a beta cutoff
moveCount++;
ss[ply].currentMove = move;
+ moveIsCheck = pos.move_is_check(move, ci);
+
// Futility pruning
if ( enoughMaterial
&& !isCheck
&& !pvNode
+ && !moveIsCheck
+ && move != ttMove
&& !move_is_promotion(move)
- && !pos.move_is_check(move, ci)
&& !pos.move_is_passed_pawn_push(move))
{
futilityValue = staticValue
continue;
// Make and search the move
- pos.do_move(move, st, dcCandidates);
+ pos.do_move(move, st, ci, moveIsCheck);
value = -qsearch(pos, ss, -beta, -alpha, depth-OnePly, ply+1, threadID);
pos.undo_move(move);
// Make and search the move.
StateInfo st;
- pos.do_move(move, st, sp->dcCandidates);
+ 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.
// Make and search the move.
StateInfo st;
- pos.do_move(move, st, sp->dcCandidates);
+ 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 split(const Position& p, SearchStack* sstck, int ply,
Value* alpha, Value* beta, Value* bestValue, const Value futilityValue,
const Value approximateEval, Depth depth, int* moves,
- MovePicker* mp, Bitboard dcCandidates, int master, bool pvNode) {
+ MovePicker* mp, int master, bool pvNode) {
assert(p.is_ok());
assert(sstck != NULL);
splitPoint->alpha = pvNode? *alpha : (*beta - 1);
splitPoint->beta = *beta;
splitPoint->pvNode = pvNode;
- splitPoint->dcCandidates = dcCandidates;
splitPoint->bestValue = *bestValue;
splitPoint->futilityValue = futilityValue;
splitPoint->approximateEval = approximateEval;
projects / stockfish / blobdiff