bool UseFutilityPruning = true;
// Margins for futility pruning in the quiescence search, at frontier
- // nodes, and at pre-frontier nodes:
+ // nodes, and at pre-frontier nodes
Value FutilityMargin0 = Value(0x80);
Value FutilityMargin1 = Value(0x100);
Value FutilityMargin2 = Value(0x300);
Depth PawnEndgameExtension[2] = {OnePly, OnePly};
Depth MateThreatExtension[2] = {Depth(0), Depth(0)};
- // Search depth at iteration 1:
+ // Search depth at iteration 1
const Depth InitialDepth = OnePly /*+ OnePly/2*/;
// Node counters
int NodesSincePoll;
int NodesBetweenPolls = 30000;
- // Iteration counter:
+ // Iteration counter
int Iteration;
+ bool LastIterations;
// Scores and number of times the best move changed for each iteration:
Value ValueByIteration[PLY_MAX_PLUS_2];
int BestMoveChangesByIteration[PLY_MAX_PLUS_2];
- // MultiPV mode:
+ // MultiPV mode
int MultiPV = 1;
// Time managment variables
ValueByIteration[0] = Value(0);
ValueByIteration[1] = rml.get_move_score(0);
Iteration = 1;
+ LastIterations = false;
EasyMove = rml.scan_for_easy_move();
if (ExtraSearchTime > 0 && TimeAdvantage > 2 * MaxSearchTime)
ExtraSearchTime += MaxSearchTime / 2;
+ // Try to guess if the current iteration is the last one or the last two
+ LastIterations = (current_search_time() > ((MaxSearchTime + ExtraSearchTime)*58) / 128);
+
// Stop search if most of MaxSearchTime is consumed at the end of the
// iteration. We probably don't have enough time to search the first
// move at the next iteration anyway.
- if (current_search_time() > ((MaxSearchTime + ExtraSearchTime)*90) / 128)
+ if (current_search_time() > ((MaxSearchTime + ExtraSearchTime)*80) / 128)
stopSearch = true;
if (stopSearch)
assert(ply >= 0 && ply < PLY_MAX);
assert(threadID >= 0 && threadID < ActiveThreads);
- EvalInfo ei;
-
// Initialize, and make an early exit in case of an aborted search,
// an instant draw, maximum ply reached, etc.
- Value oldAlpha = alpha;
-
if (AbortSearch || thread_should_stop(threadID))
return Value(0);
if (pos.is_draw())
return VALUE_DRAW;
+ EvalInfo ei;
+
if (ply >= PLY_MAX - 1)
return evaluate(pos, ei, threadID);
// Mate distance pruning
+ Value oldAlpha = alpha;
alpha = Max(value_mated_in(ply), alpha);
beta = Min(value_mate_in(ply+1), beta);
if (alpha >= beta)
return alpha;
- // Transposition table lookup. At PV nodes, we don't use the TT for
+ // Transposition table lookup. At PV nodes, we don't use the TT for
// pruning, but only for move ordering.
const TTEntry* tte = TT.retrieve(pos);
-
Move ttMove = (tte ? tte->move() : MOVE_NONE);
// Go with internal iterative deepening if we don't have a TT move
}
// Initialize a MovePicker object for the current position, and prepare
- // to search all moves:
+ // to search all moves
MovePicker mp = MovePicker(pos, true, ttMove, ss[ply].mateKiller,
ss[ply].killer1, ss[ply].killer2, depth);
int moveCount = 0;
Value value, bestValue = -VALUE_INFINITE;
Bitboard dcCandidates = mp.discovered_check_candidates();
+ bool isCheck = pos.is_check();
bool mateThreat = MateThreatExtension[1] > Depth(0)
&& pos.has_mate_threat(opposite_color(pos.side_to_move()));
{
assert(move_is_ok(move));
- bool singleReply = (pos.is_check() && mp.number_of_moves() == 1);
+ bool singleReply = (isCheck && mp.number_of_moves() == 1);
bool moveIsCheck = pos.move_is_check(move, dcCandidates);
bool moveIsCapture = pos.move_is_capture(move);
bool moveIsPassedPawnPush = pos.move_is_passed_pawn_push(move);
movesSearched[moveCount++] = ss[ply].currentMove = move;
- ss[ply].currentMoveCaptureValue = move_is_ep(move) ?
- PawnValueMidgame : pos.midgame_value_of_piece_on(move_to(move));
+ if (moveIsCapture)
+ ss[ply].currentMoveCaptureValue = pos.midgame_value_of_piece_on(move_to(move));
+ else if (move_is_ep(move))
+ ss[ply].currentMoveCaptureValue = PawnValueMidgame;
+ else
+ ss[ply].currentMoveCaptureValue = Value(0);
// Decide the new search depth
Depth ext = extension(pos, move, true, moveIsCheck, singleReply, mateThreat);
// 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 (isCheck ? value_mated_in(ply) : VALUE_DRAW);
// If the search is not aborted, update the transposition table,
// history counters, and killer moves.
// Transposition table lookup
const TTEntry* tte = TT.retrieve(pos);
-
Move ttMove = (tte ? tte->move() : MOVE_NONE);
if (tte && ok_to_use_TT(tte, depth, beta, ply))
Value approximateEval = quick_evaluate(pos);
bool mateThreat = false;
+ bool isCheck = pos.is_check();
// Null move search
if ( allowNullmove
- && !pos.is_check()
+ && !isCheck
&& ok_to_do_nullmove(pos)
&& approximateEval >= beta - NullMoveMargin)
{
UndoInfo u;
pos.do_null_move(u);
- Value nullValue = -search(pos, ss, -(beta-1), depth-4*OnePly, ply+1, false, threadID);
+ int R = (depth > 7 ? 4 : 3);
+ Value nullValue = -search(pos, ss, -(beta-1), depth-R*OnePly, ply+1, false, threadID);
pos.undo_null_move(u);
if (nullValue >= beta)
Value value, bestValue = -VALUE_INFINITE;
Bitboard dcCandidates = mp.discovered_check_candidates();
Value futilityValue = VALUE_NONE;
- bool isCheck = pos.is_check();
bool useFutilityPruning = UseFutilityPruning
&& depth < SelectiveDepth
&& !isCheck;
}
// All legal moves have been searched. A special case: If there were
- // no legal moves, it must be mate or stalemate:
+ // no legal moves, it must be mate or stalemate.
if (moveCount == 0)
return (pos.is_check() ? value_mated_in(ply) : VALUE_DRAW);
if (tte && ok_to_use_TT(tte, depth, beta, ply))
return value_from_tt(tte->value(), ply);
- // Evaluate the position statically:
+ // Evaluate the position statically
Value staticValue = evaluate(pos, ei, threadID);
if (ply == PLY_MAX - 1)
// Update transposition table
TT.store(pos, value_to_tt(bestValue, ply), depth, MOVE_NONE, VALUE_TYPE_EXACT);
+ // Update killers only for good check moves
+ Move m = ss[ply].currentMove;
+ if (alpha >= beta && ok_to_history(pos, m)) // Only non capture moves are considered
+ {
+ // Wrong to update history when depth is <= 0
+
+ if (m != ss[ply].killer1)
+ {
+ ss[ply].killer2 = ss[ply].killer1;
+ ss[ply].killer1 = m;
+ }
+ }
return bestValue;
}
H.success(pos.piece_on(move_from(m)), m, depth);
for (int i = 0; i < moveCount - 1; i++)
- if (ok_to_history(pos, movesSearched[i]) && m != movesSearched[i])
+ {
+ assert(m != movesSearched[i]);
+ if (ok_to_history(pos, movesSearched[i]))
H.failure(pos.piece_on(move_from(movesSearched[i])), movesSearched[i]);
+ }
}
// fail_high_ply_1() checks if some thread is currently resolving a fail
bool overTime = t > AbsoluteMaxSearchTime
|| (RootMoveNumber == 1 && t > MaxSearchTime + ExtraSearchTime)
|| ( !FailHigh && !fail_high_ply_1() && !Problem
- && t > 10*(MaxSearchTime + ExtraSearchTime));
+ && t > 6*(MaxSearchTime + ExtraSearchTime));
if ( (Iteration >= 2 && (!InfiniteSearch && overTime))
|| (ExactMaxTime && t >= ExactMaxTime)
projects / stockfish / blobdiff