}
// Reduction lookup tables (initialized at startup) and their access function
- int8_t Reductions[2][64][64]; // [pv][depth][moveNumber]
+ int8_t Reductions[2][2][64][64]; // [pv][improving][depth][moveNumber]
- template <bool PvNode> inline Depth reduction(Depth d, int mn) {
+ template <bool PvNode> inline Depth reduction(bool i, Depth d, int mn) {
- return (Depth) Reductions[PvNode][std::min(int(d) / ONE_PLY, 63)][std::min(mn, 63)];
+ return (Depth) Reductions[PvNode][i][std::min(int(d) / ONE_PLY, 63)][std::min(mn, 63)];
}
size_t PVSize, PVIdx;
TimeManager TimeMgr;
- int BestMoveChanges;
+ float BestMoveChanges;
Value DrawValue[COLOR_NB];
HistoryStats History;
GainsStats Gains;
{
double pvRed = log(double(hd)) * log(double(mc)) / 3.0;
double nonPVRed = 0.33 + log(double(hd)) * log(double(mc)) / 2.25;
- Reductions[1][hd][mc] = (int8_t) ( pvRed >= 1.0 ? floor( pvRed * int(ONE_PLY)) : 0);
- Reductions[0][hd][mc] = (int8_t) (nonPVRed >= 1.0 ? floor(nonPVRed * int(ONE_PLY)) : 0);
+ Reductions[1][1][hd][mc] = (int8_t) ( pvRed >= 1.0 ? floor( pvRed * int(ONE_PLY)) : 0);
+ Reductions[0][1][hd][mc] = (int8_t) (nonPVRed >= 1.0 ? floor(nonPVRed * int(ONE_PLY)) : 0);
+
+ Reductions[1][0][hd][mc] = Reductions[1][1][hd][mc];
+ Reductions[0][0][hd][mc] = Reductions[0][1][hd][mc];
+
+ if (Reductions[0][0][hd][mc] > 2 * ONE_PLY)
+ Reductions[0][0][hd][mc] += ONE_PLY;
}
// Init futility margins array
// Init futility move count array
for (d = 0; d < 32; d++)
{
- FutilityMoveCounts[1][d] = int(3.001 + 0.3 * pow(double(d), 1.8));
- FutilityMoveCounts[0][d] = d < 5 ? FutilityMoveCounts[1][d]
- : 3 * FutilityMoveCounts[1][d] / 4;
+ FutilityMoveCounts[0][d] = int(3.001 + 0.3 * pow(double(d ), 1.8)) * (d < 5 ? 4 : 3) / 4;
+ FutilityMoveCounts[1][d] = int(3.001 + 0.3 * pow(double(d + 0.98), 1.8));
}
}
void id_loop(Position& pos) {
- Stack stack[MAX_PLY_PLUS_3], *ss = stack+2; // To allow referencing (ss-2)
- int depth, prevBestMoveChanges;
+ Stack stack[MAX_PLY_PLUS_6], *ss = stack+2; // To allow referencing (ss-2)
+ int depth;
Value bestValue, alpha, beta, delta;
std::memset(ss-2, 0, 5 * sizeof(Stack));
(ss-1)->currentMove = MOVE_NULL; // Hack to skip update gains
- depth = BestMoveChanges = 0;
+ depth = 0;
+ BestMoveChanges = 0;
bestValue = delta = alpha = -VALUE_INFINITE;
beta = VALUE_INFINITE;
// Iterative deepening loop until requested to stop or target depth reached
while (++depth <= MAX_PLY && !Signals.stop && (!Limits.depth || depth <= Limits.depth))
{
+ // Age out PV variability metric
+ BestMoveChanges *= 0.8;
+
// Save last iteration's scores before first PV line is searched and all
// the move scores but the (new) PV are set to -VALUE_INFINITE.
for (size_t i = 0; i < RootMoves.size(); i++)
RootMoves[i].prevScore = RootMoves[i].score;
- prevBestMoveChanges = BestMoveChanges; // Only sensible when PVSize == 1
- BestMoveChanges = 0;
-
// MultiPV loop. We perform a full root search for each PV line
for (PVIdx = 0; PVIdx < PVSize; PVIdx++)
{
// Take in account some extra time if the best move has changed
if (depth > 4 && depth < 50 && PVSize == 1)
- TimeMgr.pv_instability(BestMoveChanges, prevBestMoveChanges);
+ TimeMgr.pv_instability(BestMoveChanges);
// Stop search if most of available time is already consumed. We
// probably don't have enough time to search the first move at the
// Step 8. Null move search with verification search (is omitted in PV nodes)
if ( !PvNode
&& !ss->skipNullMove
- && depth > ONE_PLY
+ && depth >= 2 * ONE_PLY
&& eval >= beta
&& abs(beta) < VALUE_MATE_IN_MAX_PLY
&& pos.non_pawn_material(pos.side_to_move()))
MovePicker mp(pos, ttMove, depth, History, countermoves, ss);
CheckInfo ci(pos);
value = bestValue; // Workaround a bogus 'uninitialized' warning under gcc
- improving = ss->staticEval >= (ss-2)->staticEval;
+ improving = ss->staticEval >= (ss-2)->staticEval
+ || ss->staticEval == VALUE_NONE
+ ||(ss-2)->staticEval == VALUE_NONE;
+
singularExtensionNode = !RootNode
&& !SpNode
&& depth >= (PvNode ? 6 * ONE_PLY : 8 * ONE_PLY)
{
Signals.firstRootMove = (moveCount == 1);
- if (thisThread == Threads.main_thread() && Time::now() - SearchTime > 3000)
+ if (thisThread == Threads.main() && Time::now() - SearchTime > 3000)
sync_cout << "info depth " << depth / ONE_PLY
<< " currmove " << move_to_uci(move, pos.is_chess960())
<< " currmovenumber " << moveCount + PVIdx << sync_endl;
// Value based pruning
// We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth,
// but fixing this made program slightly weaker.
- Depth predictedDepth = newDepth - reduction<PvNode>(depth, moveCount);
+ Depth predictedDepth = newDepth - reduction<PvNode>(improving, depth, moveCount);
futilityValue = ss->staticEval + ss->evalMargin + futility_margin(predictedDepth, moveCount)
+ Gains[pos.piece_moved(move)][to_sq(move)];
if ( depth > 3 * ONE_PLY
&& !pvMove
&& !captureOrPromotion
- && !dangerous
&& move != ttMove
&& move != ss->killers[0]
&& move != ss->killers[1])
{
- ss->reduction = reduction<PvNode>(depth, moveCount);
+ ss->reduction = reduction<PvNode>(improving, depth, moveCount);
if (!PvNode && cutNode)
ss->reduction += ONE_PLY;
&& !givesCheck
&& move != ttMove
&& type_of(move) != PROMOTION
+ && futilityBase > -VALUE_KNOWN_WIN
&& !pos.is_passed_pawn_push(move))
{
futilityValue = futilityBase
void RootMove::extract_pv_from_tt(Position& pos) {
- StateInfo state[MAX_PLY_PLUS_3], *st = state;
+ StateInfo state[MAX_PLY_PLUS_6], *st = state;
const TTEntry* tte;
int ply = 0;
Move m = pv[0];
void RootMove::insert_pv_in_tt(Position& pos) {
- StateInfo state[MAX_PLY_PLUS_3], *st = state;
+ StateInfo state[MAX_PLY_PLUS_6], *st = state;
const TTEntry* tte;
int ply = 0;
Threads.mutex.unlock();
- Stack stack[MAX_PLY_PLUS_3], *ss = stack+2; // To allow referencing (ss-2)
+ Stack stack[MAX_PLY_PLUS_6], *ss = stack+2; // To allow referencing (ss-2)
Position pos(*sp->pos, this);
std::memcpy(ss-2, sp->ss-2, 5 * sizeof(Stack));
projects / stockfish / blobdiff