enum NodeType { Root, PV, NonPV };
// Razoring and futility margin based on depth
- inline Value razor_margin(Depth d) { return Value(512 + 32 * d); }
- inline Value futility_margin(Depth d) { return Value(200 * d); }
+ Value razor_margin(Depth d) { return Value(512 + 32 * d); }
+ Value futility_margin(Depth d) { return Value(200 * d); }
// Futility and reductions lookup tables, initialized at startup
int FutilityMoveCounts[2][16]; // [improving][depth]
Depth Reductions[2][2][64][64]; // [pv][improving][depth][moveNumber]
- template <bool PvNode> inline Depth reduction(bool i, Depth d, int mn) {
+ template <bool PvNode> Depth reduction(bool i, Depth d, int mn) {
return Reductions[PvNode][i][std::min(d, 63 * ONE_PLY)][std::min(mn, 63)];
}
Value DrawValue[COLOR_NB];
HistoryStats History;
CounterMovesHistoryStats CounterMovesHistory;
- GainsStats Gains;
MovesStats Countermoves;
template <NodeType NT, bool SpNode>
}
+/// Search::reset() clears all search memory, to obtain reproducible search results
+
+void Search::reset () {
+
+ TT.clear();
+ History.clear();
+ CounterMovesHistory.clear();
+ Countermoves.clear();
+}
+
+
/// Search::perft() is our utility to verify move generation. All the leaf nodes
/// up to the given depth are generated and counted and the sum returned.
template<bool Root>
beta = VALUE_INFINITE;
TT.new_search();
- History.clear();
- CounterMovesHistory.clear();
- Gains.clear();
- Countermoves.clear();
size_t multiPV = Options["MultiPV"];
Skill skill(Options["Skill Level"]);
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) && !inCheck)
+ if (ttValue >= beta && ttMove && !pos.capture_or_promotion(ttMove))
update_stats(pos, ss, ttMove, depth, nullptr, 0);
return ttValue;
}
}
- // Step 5. Evaluate the position statically and update parent's gain statistics
+ // Step 5. Evaluate the position statically
if (inCheck)
{
ss->staticEval = eval = VALUE_NONE;
if (ss->skipEarlyPruning)
goto moves_loop;
- if ( !pos.captured_piece_type()
- && ss->staticEval != VALUE_NONE
- && (ss-1)->staticEval != VALUE_NONE
- && (move = (ss-1)->currentMove) != MOVE_NULL
- && move != MOVE_NONE
- && type_of(move) == NORMAL)
- {
- Square to = to_sq(move);
- Gains.update(pos.piece_on(to), to, -(ss-1)->staticEval - ss->staticEval);
- }
-
// Step 6. Razoring (skipped when in check)
if ( !PvNode
&& depth < 4 * ONE_PLY
captureOrPromotion = pos.capture_or_promotion(move);
givesCheck = type_of(move) == NORMAL && !ci.dcCandidates
- ? ci.checkSq[type_of(pos.piece_on(from_sq(move)))] & to_sq(move)
+ ? ci.checkSquares[type_of(pos.piece_on(from_sq(move)))] & to_sq(move)
: pos.gives_check(move, ci);
dangerous = givesCheck
// Futility pruning: parent node
if (predictedDepth < 7 * ONE_PLY)
{
- futilityValue = ss->staticEval + futility_margin(predictedDepth)
- + 128 + Gains[pos.moved_piece(move)][to_sq(move)];
+ futilityValue = ss->staticEval + futility_margin(predictedDepth) + 256;
if (futilityValue <= alpha)
{
}
ss->currentMove = move;
- if (!SpNode && !captureOrPromotion && quietCount < 64)
- quietsSearched[quietCount++] = move;
// Step 14. Make the move
pos.do_move(move, st, givesCheck);
ss->reduction = reduction<PvNode>(improving, depth, moveCount);
if ( (!PvNode && cutNode)
- || History[pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO
- || ( History[pos.piece_on(to_sq(move))][to_sq(move)]
- + CounterMovesHistory[pos.piece_on(prevMoveSq)][prevMoveSq]
- [pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO))
+ || ( History[pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO
+ && CounterMovesHistory[pos.piece_on(prevMoveSq)][prevMoveSq]
+ [pos.piece_on(to_sq(move))][to_sq(move)] <= VALUE_ZERO))
ss->reduction += ONE_PLY;
- if (move == countermove)
+ if ( move == countermove
+ || ( History[pos.piece_on(to_sq(move))][to_sq(move)] > VALUE_ZERO
+ && CounterMovesHistory[pos.piece_on(prevMoveSq)][prevMoveSq]
+ [pos.piece_on(to_sq(move))][to_sq(move)] > VALUE_ZERO))
ss->reduction = std::max(DEPTH_ZERO, ss->reduction - ONE_PLY);
// Decrease reduction for moves that escape a capture
value = -search<NonPV, false>(pos, ss+1, -(alpha+1), -alpha, d, true);
- // Re-search at intermediate depth if reduction is very high
- if (value > alpha && ss->reduction >= 4 * ONE_PLY)
- {
- Depth d2 = std::max(newDepth - 2 * ONE_PLY, ONE_PLY);
- value = -search<NonPV, false>(pos, ss+1, -(alpha+1), -alpha, d2, true);
- }
-
doFullDepthSearch = (value > alpha && ss->reduction != DEPTH_ZERO);
ss->reduction = DEPTH_ZERO;
}
}
}
+ if (!SpNode && !captureOrPromotion && move != bestMove && quietCount < 64)
+ quietsSearched[quietCount++] = move;
+
// Step 19. Check for splitting the search
if ( !SpNode
&& Threads.size() >= 2
: inCheck ? mated_in(ss->ply) : DrawValue[pos.side_to_move()];
// Quiet best move: update killers, history and countermoves
- else if (bestValue >= beta && !pos.capture_or_promotion(bestMove) && !inCheck)
- update_stats(pos, ss, bestMove, depth, quietsSearched, quietCount - 1);
+ else if (bestMove && !pos.capture_or_promotion(bestMove))
+ update_stats(pos, ss, bestMove, depth, quietsSearched, quietCount);
tte->save(posKey, value_to_tt(bestValue, ss->ply),
bestValue >= beta ? BOUND_LOWER :
assert(is_ok(move));
givesCheck = type_of(move) == NORMAL && !ci.dcCandidates
- ? ci.checkSq[type_of(pos.piece_on(from_sq(move)))] & to_sq(move)
+ ? ci.checkSquares[type_of(pos.piece_on(from_sq(move)))] & to_sq(move)
: pos.gives_check(move, ci);
// Futility pruning
*pv = MOVE_NONE;
}
- // update_stats() updates killers, history and countermoves stats after a fail-high
- // of a quiet move.
- void update_stats(const Position& pos, Stack* ss, Move move, Depth depth, Move* quiets, int quietsCnt) {
+ // update_stats() updates killers, history, countermove history and
+ // countermoves stats for a quiet best move.
+
+ void update_stats(const Position& pos, Stack* ss, Move move,
+ Depth depth, Move* quiets, int quietsCnt) {
if (ss->killers[0] != move)
{
projects / stockfish / blobdiff