}
-/// Search::clear() resets search state to zero, to obtain reproducible results
+/// Search::clear() resets search state to its initial value, to obtain reproducible results
void Search::clear() {
for (Thread* th : Threads)
{
- th->counterMoves.clear();
- th->history.clear();
- th->counterMoveHistory.clear();
th->resetCalls = true;
- CounterMoveStats& cm = th->counterMoveHistory[NO_PIECE][0];
- int* t = &cm[NO_PIECE][0];
- std::fill(t, t + sizeof(cm), CounterMovePruneThreshold - 1);
+ th->counterMoves.fill(MOVE_NONE);
+ th->history.fill(0);
+
+ for (auto& to : th->counterMoveHistory)
+ for (auto& h : to)
+ h.fill(0);
+
+ th->counterMoveHistory[NO_PIECE][0].fill(CounterMovePruneThreshold - 1);
}
Threads.main()->previousScore = VALUE_INFINITE;
Color us = rootPos.side_to_move();
Time.init(Limits, us, rootPos.game_ply());
+ TT.new_search();
int contempt = Options["Contempt"] * PawnValueEg / 100; // From centipawns
DrawValue[ us] = VALUE_DRAW - Value(contempt);
std::memset(ss-4, 0, 7 * sizeof(Stack));
for(int i = 4; i > 0; i--)
- (ss-i)->counterMoves = &this->counterMoveHistory[NO_PIECE][0]; // Use as sentinel
+ (ss-i)->history = &this->counterMoveHistory[NO_PIECE][0]; // Use as sentinel
bestValue = delta = alpha = -VALUE_INFINITE;
beta = VALUE_INFINITE;
EasyMove.clear();
mainThread->easyMovePlayed = mainThread->failedLow = false;
mainThread->bestMoveChanges = 0;
- TT.new_search();
}
size_t multiPV = Options["MultiPV"];
// Step 1. Initialize node
Thread* thisThread = pos.this_thread();
inCheck = pos.checkers();
- moveCount = quietCount = ss->moveCount = 0;
- ss->history = 0;
+ moveCount = quietCount = ss->moveCount = 0;
+ ss->statScore = 0;
bestValue = -VALUE_INFINITE;
ss->ply = (ss-1)->ply + 1;
assert(0 <= ss->ply && ss->ply < MAX_PLY);
ss->currentMove = (ss+1)->excludedMove = bestMove = MOVE_NONE;
- ss->counterMoves = &thisThread->counterMoveHistory[NO_PIECE][0];
+ ss->history = &thisThread->counterMoveHistory[NO_PIECE][0];
(ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
Square prevSq = to_sq((ss-1)->currentMove);
Depth R = ((823 + 67 * depth / ONE_PLY) / 256 + std::min((eval - beta) / PawnValueMg, 3)) * ONE_PLY;
ss->currentMove = MOVE_NULL;
- ss->counterMoves = &thisThread->counterMoveHistory[NO_PIECE][0];
+ ss->history = &thisThread->counterMoveHistory[NO_PIECE][0];
pos.do_null_move(st);
Value nullValue = depth-R < ONE_PLY ? -qsearch<NonPV, false>(pos, ss+1, -beta, -beta+1)
if (pos.legal(move))
{
ss->currentMove = move;
- ss->counterMoves = &thisThread->counterMoveHistory[pos.moved_piece(move)][to_sq(move)];
+ ss->history = &thisThread->counterMoveHistory[pos.moved_piece(move)][to_sq(move)];
pos.do_move(move, st);
value = -search<NonPV>(pos, ss+1, -rbeta, -rbeta+1, rdepth, !cutNode, false);
moves_loop: // When in check search starts from here
- const CounterMoveStats& cmh = *(ss-1)->counterMoves;
- const CounterMoveStats& fmh = *(ss-2)->counterMoves;
- const CounterMoveStats& fm2 = *(ss-4)->counterMoves;
+ const PieceToHistory& cmh = *(ss-1)->history;
+ const PieceToHistory& fmh = *(ss-2)->history;
+ const PieceToHistory& fm2 = *(ss-4)->history;
MovePicker mp(pos, ttMove, depth, ss);
value = bestValue; // Workaround a bogus 'uninitialized' warning under gcc
// (alpha-s, beta-s), and just one fails high on (alpha, beta), then that move
// is singular and should be extended. To verify this we do a reduced search
// on all the other moves but the ttMove and if the result is lower than
- // ttValue minus a margin then we extend the ttMove.
+ // ttValue minus a margin then we will extend the ttMove.
if ( singularExtensionNode
&& move == ttMove
&& pos.legal(move))
}
else if ( givesCheck
&& !moveCountPruning
- && pos.see_ge(move, VALUE_ZERO))
+ && pos.see_ge(move))
extension = ONE_PLY;
// Calculate new depth for this move
// Update the current move (this must be done after singular extension search)
ss->currentMove = move;
- ss->counterMoves = &thisThread->counterMoveHistory[moved_piece][to_sq(move)];
+ ss->history = &thisThread->counterMoveHistory[moved_piece][to_sq(move)];
// Step 14. Make the move
pos.do_move(move, st, givesCheck);
// 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().
- else if ( type_of(move) == NORMAL
- && !pos.see_ge(make_move(to_sq(move), from_sq(move)), VALUE_ZERO))
+ else if ( type_of(move) == NORMAL
+ && !pos.see_ge(make_move(to_sq(move), from_sq(move))))
r -= 2 * ONE_PLY;
- ss->history = cmh[moved_piece][to_sq(move)]
- + fmh[moved_piece][to_sq(move)]
- + fm2[moved_piece][to_sq(move)]
- + thisThread->history.get(~pos.side_to_move(), move)
- - 4000; // Correction factor
+ ss->statScore = cmh[moved_piece][to_sq(move)]
+ + fmh[moved_piece][to_sq(move)]
+ + fm2[moved_piece][to_sq(move)]
+ + thisThread->history[~pos.side_to_move()][from_to(move)]
+ - 4000; // Correction factor
// Decrease/increase reduction by comparing opponent's stat score
- if (ss->history > 0 && (ss-1)->history < 0)
+ if (ss->statScore > 0 && (ss-1)->statScore < 0)
r -= ONE_PLY;
- else if (ss->history < 0 && (ss-1)->history > 0)
+ else if (ss->statScore < 0 && (ss-1)->statScore > 0)
r += ONE_PLY;
// Decrease/increase reduction for moves with a good/bad history
- r = std::max(DEPTH_ZERO, (r / ONE_PLY - ss->history / 20000) * ONE_PLY);
+ r = std::max(DEPTH_ZERO, (r / ONE_PLY - ss->statScore / 20000) * ONE_PLY);
}
Depth d = std::max(newDepth - r, ONE_PLY);
: inCheck ? mated_in(ss->ply) : DrawValue[pos.side_to_move()];
else if (bestMove)
{
-
// Quiet best move: update move sorting heuristics
if (!pos.capture_or_promotion(bestMove))
update_stats(pos, ss, bestMove, quietsSearched, quietCount, stat_bonus(depth));
Value bestValue, value, ttValue, futilityValue, futilityBase, oldAlpha;
bool ttHit, givesCheck, evasionPrunable;
Depth ttDepth;
+ int moveCount;
if (PvNode)
{
ss->currentMove = bestMove = MOVE_NONE;
ss->ply = (ss-1)->ply + 1;
+ moveCount = 0;
// Check for an instant draw or if the maximum ply has been reached
if (pos.is_draw(ss->ply) || ss->ply >= MAX_PLY)
? pos.check_squares(type_of(pos.piece_on(from_sq(move)))) & to_sq(move)
: pos.gives_check(move);
+ moveCount++;
+
// Futility pruning
if ( !InCheck
&& !givesCheck
// Detect non-capture evasions that are candidates to be pruned
evasionPrunable = InCheck
+ && (depth != DEPTH_ZERO || moveCount > 2)
&& bestValue > VALUE_MATED_IN_MAX_PLY
&& !pos.capture(move);
// Don't search moves with negative SEE values
if ( (!InCheck || evasionPrunable)
&& type_of(move) != PROMOTION
- && !pos.see_ge(move, VALUE_ZERO))
+ && !pos.see_ge(move))
continue;
// Speculative prefetch as early as possible
// Check for legality just before making the move
if (!pos.legal(move))
+ {
+ moveCount--;
continue;
+ }
ss->currentMove = move;
for (int i : {1, 2, 4})
if (is_ok((ss-i)->currentMove))
- (ss-i)->counterMoves->update(pc, s, bonus);
+ (ss-i)->history->update(pc, s, bonus);
}
if (is_ok((ss-1)->currentMove))
{
Square prevSq = to_sq((ss-1)->currentMove);
- thisThread->counterMoves.update(pos.piece_on(prevSq), prevSq, move);
+ thisThread->counterMoves[pos.piece_on(prevSq)][prevSq]=move;
}
// Decrease all the other played quiet moves
for (size_t i = 0; i < multiPV; ++i)
{
- bool updated = (i <= PVIdx);
+ bool updated = (i <= PVIdx && rootMoves[i].score != -VALUE_INFINITE);
if (depth == ONE_PLY && !updated)
continue;