// Razor and futility margins
constexpr int RazorMargin = 661;
Value futility_margin(Depth d, bool improving) {
- return Value((168 - 51 * improving) * d / ONE_PLY);
+ return Value(198 * (d / ONE_PLY - improving));
}
// Reductions lookup table, initialized at startup
Move best = MOVE_NONE;
};
- // Breadcrumbs are used to mark nodes as being searched by a given thread.
+ // Breadcrumbs are used to mark nodes as being searched by a given thread
struct Breadcrumb {
std::atomic<Thread*> thread;
std::atomic<Key> key;
};
std::array<Breadcrumb, 1024> breadcrumbs;
- // ThreadHolding keeps track of which thread left breadcrumbs at the given node for potential reductions.
- // A free node will be marked upon entering the moves loop, and unmarked upon leaving that loop, by the ctor/dtor of this struct.
+ // ThreadHolding structure keeps track of which thread left breadcrumbs at the given
+ // node for potential reductions. A free node will be marked upon entering the moves
+ // loop by the constructor, and unmarked upon leaving that loop by the destructor.
struct ThreadHolding {
explicit ThreadHolding(Thread* thisThread, Key posKey, int ply) {
location = ply < 8 ? &breadcrumbs[posKey & (breadcrumbs.size() - 1)] : nullptr;
owning = false;
if (location)
{
- // see if another already marked this location, if not, mark it ourselves.
+ // See if another already marked this location, if not, mark it ourselves
Thread* tmp = (*location).thread.load(std::memory_order_relaxed);
if (tmp == nullptr)
{
}
~ThreadHolding() {
- if (owning) // free the marked location.
+ if (owning) // Free the marked location
(*location).thread.store(nullptr, std::memory_order_relaxed);
}
bestValue = delta = alpha = -VALUE_INFINITE;
beta = VALUE_INFINITE;
- multiPV = Options["MultiPV"];
+ size_t multiPV = Options["MultiPV"];
// Pick integer skill levels, but non-deterministically round up or down
// such that the average integer skill corresponds to the input floating point one.
++failedHighCnt;
}
else
+ {
+ ++rootMoves[pvIdx].bestMoveCount;
break;
+ }
delta += delta / 4 + 5;
// statScore of the previous grandchild. This influences the reduction rules in
// LMR which are based on the statScore of parent position.
if (rootNode)
- (ss + 4)->statScore = 0;
+ (ss+4)->statScore = 0;
else
- (ss + 2)->statScore = 0;
+ (ss+2)->statScore = 0;
// Step 4. Transposition table lookup. We don't want the score of a partial
// search to overwrite a previous full search TT value, so we use a different
// Extra penalty for early quiet moves of the previous ply
if ((ss-1)->moveCount <= 2 && !pos.captured_piece())
- update_continuation_histories(ss-1, pos.piece_on(prevSq), prevSq, -stat_bonus(depth + ONE_PLY));
+ update_continuation_histories(ss-1, pos.piece_on(prevSq), prevSq, -stat_bonus(depth + ONE_PLY));
}
// Penalty for a quiet ttMove that fails low
else if (!pos.capture_or_promotion(ttMove))
if (eval == VALUE_NONE)
ss->staticEval = eval = evaluate(pos);
+ if (eval == VALUE_DRAW)
+ eval = value_draw(depth, thisThread);
+
// Can ttValue be used as a better position evaluation?
if ( ttValue != VALUE_NONE
&& (tte->bound() & (ttValue > eval ? BOUND_LOWER : BOUND_UPPER)))
&& (ss-1)->currentMove != MOVE_NULL
&& (ss-1)->statScore < 22661
&& eval >= beta
- && ss->staticEval >= beta - 33 * depth / ONE_PLY + 299
+ && eval >= ss->staticEval
+ && ss->staticEval >= beta - 33 * depth / ONE_PLY + 299 - improving * 30
&& !excludedMove
&& pos.non_pawn_material(us)
&& (ss->ply >= thisThread->nmpMinPly || us != thisThread->nmpColor))
moveCountPruning = false;
ttCapture = ttMove && pos.capture_or_promotion(ttMove);
- // Mark this node as being searched.
+ // Mark this node as being searched
ThreadHolding th(thisThread, posKey, ss->ply);
// Step 12. Loop through all pseudo-legal moves until no moves remain
sync_cout << "info depth " << depth / ONE_PLY
<< " currmove " << UCI::move(move, pos.is_chess960())
<< " currmovenumber " << moveCount + thisThread->pvIdx << sync_endl;
-
- // In MultiPV mode also skip moves which will be searched later as PV moves
- if (rootNode && std::count(thisThread->rootMoves.begin() + thisThread->pvIdx + 1,
- thisThread->rootMoves.begin() + thisThread->multiPV, move))
- continue;
-
if (PvNode)
(ss+1)->pv = nullptr;
if (!pos.see_ge(move, Value(-(31 - std::min(lmrDepth, 18)) * lmrDepth * lmrDepth)))
continue;
}
- else if ( (!givesCheck || !extension)
+ else if ( !(givesCheck && extension)
&& !pos.see_ge(move, Value(-199) * (depth / ONE_PLY))) // (~20 Elo)
continue;
}
// Step 16. Reduced depth search (LMR). If the move fails high it will be
// re-searched at full depth.
if ( depth >= 3 * ONE_PLY
- && moveCount > 1 + 3 * rootNode
+ && moveCount > 1 + 2 * rootNode
+ && (!rootNode || thisThread->best_move_count(move) == 0)
&& ( !captureOrPromotion
|| moveCountPruning
- || ss->staticEval + PieceValue[EG][pos.captured_piece()] <= alpha))
+ || ss->staticEval + PieceValue[EG][pos.captured_piece()] <= alpha
+ || cutNode))
{
Depth r = reduction(improving, depth, moveCount);
if ((ss-1)->moveCount > 15)
r -= ONE_PLY;
- // Decrease reduction if move has been singularly extended
+ // Decrease reduction if ttMove has been singularly extended
r -= singularLMR * ONE_PLY;
if (!captureOrPromotion)
// castling moves, because they are coded as "king captures rook" and
// hence break make_move(). (~5 Elo)
else if ( type_of(move) == NORMAL
- && !pos.see_ge(make_move(to_sq(move), from_sq(move))))
+ && !pos.see_ge(reverse_move(move)))
r -= 2 * ONE_PLY;
ss->statScore = thisThread->mainHistory[us][from_to(move)]
thisThread->mainHistory[us][from_to(move)] << bonus;
update_continuation_histories(ss, pos.moved_piece(move), to_sq(move), bonus);
+ if (type_of(pos.moved_piece(move)) != PAWN)
+ thisThread->mainHistory[us][from_to(reverse_move(move))] << -bonus;
+
if (is_ok((ss-1)->currentMove))
{
Square prevSq = to_sq((ss-1)->currentMove);