inline Move get_move_pv(int moveNum, int i) const;
inline int64_t get_move_cumulative_nodes(int moveNum) const;
inline int move_count() const;
- Move scan_for_easy_move() const;
inline void sort();
void sort_multipv(int n);
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);
+ const Value IncrementalFutilityMargin = Value(0x4);
- // 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(0x2A0), Value(0x2C0), Value(0x340), Value(0x360), Value(0x3A0), Value(0x3C0) };
// Razoring
const Depth RazorDepth = 4*OnePly;
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);
<< " moves to go: " << movesToGo << std::endl;
- // We're ready to start thinking. Call the iterative deepening loop function
- //
- // FIXME we really need to cleanup all this LSN ugliness
- if (!loseOnTime)
+ // LSN filtering. Used only for developing purpose. Disabled by default.
+ if ( UseLSNFiltering
+ && loseOnTime)
{
- Value v = id_loop(pos, searchMoves);
- loseOnTime = ( UseLSNFiltering
- && myTime < LSNTime
- && myIncrement == 0
- && v < -LSNValue);
+ // Step 2. If after last move we decided to lose on time, do it now!
+ while (SearchStartTime + myTime + 1000 > get_system_time())
+ ; // wait here
}
- else
+
+ // We're ready to start thinking. Call the iterative deepening loop function
+ Value v = id_loop(pos, searchMoves);
+
+ // LSN filtering. Used only for developing purpose. Disabled by default.
+ if (UseLSNFiltering)
{
- loseOnTime = false; // reset for next match
- while (SearchStartTime + myTime + 1000 > get_system_time())
- ; // wait here
- id_loop(pos, searchMoves); // to fail gracefully
+ // Step 1. If this is sudden death game and our position is hopeless,
+ // decide to lose on time.
+ if ( !loseOnTime // If we already lost on time, go to step 3.
+ && myTime < LSNTime
+ && myIncrement == 0
+ && movesToGo == 0
+ && v < -LSNValue)
+ {
+ loseOnTime = true;
+ }
+ else if (loseOnTime)
+ {
+ // Step 3. Now after stepping over the time limit, reset flag for next match.
+ loseOnTime = false;
+ }
}
if (UseLogFile)
IterationInfo[1] = IterationInfoType(rml.get_move_score(0), rml.get_move_score(0));
Iteration = 1;
- Move EasyMove = rml.scan_for_easy_move();
+ // Is one move significantly better than others after initial scoring ?
+ Move EasyMove = MOVE_NONE;
+ if ( rml.move_count() == 1
+ || rml.get_move_score(0) > rml.get_move_score(1) + EasyMoveMargin)
+ EasyMove = rml.get_move(0);
// Iterative deepening loop
while (Iteration < PLY_MAX)
if (stopSearch)
{
- //FIXME: Implement fail-low emergency measures
if (!PonderSearch)
break;
else
return alpha;
// Transposition table lookup. At PV nodes, we don't use the TT for
- // pruning, but only for move ordering.
+ // pruning, but only for move ordering. This is to avoid problems in
+ // the following areas:
+ //
+ // * Repetition draw detection
+ // * Fifty move rule detection
+ // * Searching for a mate
+ // * Printing of full PV line
+ //
tte = TT.retrieve(pos.get_key());
ttMove = (tte ? tte->move() : MOVE_NONE);
{
search_pv(pos, ss, alpha, beta, depth-2*OnePly, ply, threadID);
ttMove = ss[ply].pv[ply];
+ tte = TT.retrieve(pos.get_key());
+
+ // If tte->move() != MOVE_NONE then it equals ttMove
+ assert(!(tte && tte->move()) || tte->move() == ttMove);
}
// Initialize a MovePicker object for the current position, and prepare
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 >= 6 * OnePly
+ && tte
+ && move == tte->move()
+ && 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)
+ {
+ Value excValue = search(pos, ss, ttValue - SingleReplyMargin, depth / 2, ply, false, threadID, move);
+
+ // 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, ci, moveIsCheck);
// 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);
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 = ttMove; // can be MOVE_NONE
+ ss[ply].currentMove = ttMove; // Can be MOVE_NONE
return value_from_tt(tte->value(), ply);
}
{
search(pos, ss, beta, Min(depth/2, depth-2*OnePly), ply, false, threadID);
ttMove = ss[ply].pv[ply];
+ tte = TT.retrieve(pos.get_key());
}
// Initialize a MovePicker object for the current position, and prepare
futilityValue = VALUE_NONE;
useFutilityPruning = depth < SelectiveDepth && !isCheck;
+ // Calculate depth dependant futility pruning parameters
+ const int FutilityMoveCountMargin = 3 + (1 << (3 * int(depth) / 8));
+ const int FutilityValueMargin = 112 * bitScanReverse32(int(depth) * int(depth) / 2);
+
// Avoid calling evaluate() if we already have the score in TT
if (tte && (tte->type() & VALUE_TYPE_EVAL))
- futilityValue = value_from_tt(tte->value(), ply) + FutilityMargins[int(depth) - 2];
+ futilityValue = value_from_tt(tte->value(), ply) + FutilityValueMargin;
- // 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.
+ // 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 >= 8 * OnePly
+ && tte
+ && move == tte->move()
+ && !excludedMove // Do not allow recursive single-reply search
+ && 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)
+ {
+ Value excValue = search(pos, ss, ttValue - SingleReplyMargin, depth / 2, ply, false, threadID, move);
+
+ // 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;
+
// Futility pruning
if ( useFutilityPruning
&& !dangerous
&& !captureOrPromotion
&& move != ttMove)
{
- //std::cout << std::endl;
- //for (int d = 2; d < 14; d++)
- // std::cout << d << ", " << 64*(1+bitScanReverse32(d*d)) << std::endl;
-
- //std::cout << std::endl;
-/*
- 64*(1+bitScanReverse32(d*d))
-
- 2 -> 256 - 256
- 3 -> 288 - 320
- 4 -> 512 - 384
- 5 -> 544 - 384
- 6 -> 592 - 448
- 7 -> 624 - 448
- 8 -> 672 - 512
- 9 -> 704 - 512
- 10 -> 832 - 512
- 11 -> 864 - 512
- 12 -> 928 - 576
- 13 -> 960 - 576
-
- 300 + 2*(1 << (3*d/4))
-
- 2 -> 256 - 304
- 3 -> 288 - 308
- 4 -> 512 - 316
- 5 -> 544 - 316
- 6 -> 592 - 332
- 7 -> 624 - 364
- 8 -> 672 - 428
- 9 -> 704 - 428
- 10 -> 832 - 556
- 11 -> 864 - 812
- 12 -> 928 - 1324
- 13 -> 960 - 1324
-
-
- 3 + (1 << (3*int(depth)/8))
-
- 1 * onePly - > moveCount >= 4
- 2 * onePly - > moveCount >= 5
- 3 * onePly - > moveCount >= 7
- 4 * onePly - > moveCount >= 11
- 5 * onePly - > moveCount >= 11
- 6 * onePly - > moveCount >= 19
- 7 * onePly - > moveCount >= 35
-*/
// History pruning. See ok_to_prune() definition
- if ( moveCount >= MCLimit
+ if ( moveCount >= FutilityMoveCountMargin
&& ok_to_prune(pos, move, ss[ply].threatMove, depth)
&& bestValue > value_mated_in(PLY_MAX))
continue;
if (approximateEval < beta)
{
if (futilityValue == VALUE_NONE)
- futilityValue = evaluate(pos, ei, threadID)
- + 64*(2+bitScanReverse32(int(depth) * int(depth)));
+ futilityValue = evaluate(pos, ei, threadID) + FutilityValueMargin;
futilityValueScaled = futilityValue - moveCount * IncrementalFutilityMargin;
value = -search(pos, ss, -(beta-1), newDepth-OnePly, ply+1, true, threadID);
}
else
- value = beta; // Just to trigger next condition
+ value = beta; // Just to trigger next condition
if (value >= beta) // Go with full depth non-pv search
{
// New best move?
if (value > bestValue)
{
- bestValue = value;
- if (value >= beta)
- update_pv(ss, ply);
+ bestValue = value;
+ if (value >= beta)
+ update_pv(ss, ply);
- if (value == value_mate_in(ply + 1))
- ss[ply].mateKiller = move;
+ if (value == value_mate_in(ply + 1))
+ ss[ply].mateKiller = move;
}
// Split?
&& !thread_should_stop(threadID)
&& split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, approximateEval,
depth, &moveCount, &mp, threadID, false))
- break;
+ 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);
}
ttMove = (tte ? tte->move() : MOVE_NONE);
- // Evaluate the position statically
isCheck = pos.is_check();
ei.futilityMargin = Value(0); // Manually initialize futilityMargin
+ // Evaluate the position statically
if (isCheck)
staticValue = -VALUE_INFINITE;
// Use the cached evaluation score if possible
assert(ei.futilityMargin == Value(0));
- staticValue = tte->value();
+ staticValue = value_from_tt(tte->value(), ply);
}
else
staticValue = evaluate(pos, ei, threadID);
bool useFutilityPruning = sp->depth < SelectiveDepth
&& !isCheck;
+ const int FutilityValueMargin = 112 * bitScanReverse32(int(sp->depth) * int(sp->depth) / 2);
+
while ( sp->bestValue < sp->beta
&& !thread_should_stop(threadID)
&& (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE)
if (sp->futilityValue == VALUE_NONE)
{
EvalInfo ei;
- sp->futilityValue = evaluate(pos, ei, threadID)
- + FutilityMargins[int(sp->depth) - 2];
+ sp->futilityValue = evaluate(pos, ei, threadID) + FutilityValueMargin;
}
if (sp->futilityValue < sp->beta)
moves[count].score = -qsearch(pos, ss, -VALUE_INFINITE, VALUE_INFINITE, Depth(0), 1, 0);
pos.undo_move(moves[count].move);
moves[count].pv[0] = moves[count].move;
- moves[count].pv[1] = MOVE_NONE; // FIXME
+ moves[count].pv[1] = MOVE_NONE;
count++;
}
sort();
}
- // RootMoveList::scan_for_easy_move() is called at the end of the first
- // iteration, and is used to detect an "easy move", i.e. a move which appears
- // to be much bester than all the rest. If an easy move is found, the move
- // is returned, otherwise the function returns MOVE_NONE. It is very
- // important that this function is called at the right moment: The code
- // assumes that the first iteration has been completed and the moves have
- // been sorted. This is done in RootMoveList c'tor.
-
- Move RootMoveList::scan_for_easy_move() const {
-
- assert(count);
-
- if (count == 1)
- return get_move(0);
-
- // moves are sorted so just consider the best and the second one
- if (get_move_score(0) > get_move_score(1) + EasyMoveMargin)
- return get_move(0);
-
- return MOVE_NONE;
- }
-
// RootMoveList::sort() sorts the root move list at the beginning of a new
// iteration.
projects / stockfish / blobdiff