return Reductions[PvNode][i][std::min(d / ONE_PLY, 63)][std::min(mn, 63)] * ONE_PLY;
}
+ // History and stats update bonus, based on depth
+ Value stat_bonus(Depth depth) {
+ int d = depth / ONE_PLY ;
+ return Value(d * d + 2 * d - 2);
+ }
+
// Skill structure is used to implement strength limit
struct Skill {
Skill(int l) : level(l) {}
Move pv[3];
};
- // Set of rows with half bits set to 1 and half to 0. It is used to allocate
- // the search depths across the threads.
- typedef std::vector<int> Row;
-
- const Row HalfDensity[] = {
- {0, 1},
- {1, 0},
- {0, 0, 1, 1},
- {0, 1, 1, 0},
- {1, 1, 0, 0},
- {1, 0, 0, 1},
- {0, 0, 0, 1, 1, 1},
- {0, 0, 1, 1, 1, 0},
- {0, 1, 1, 1, 0, 0},
- {1, 1, 1, 0, 0, 0},
- {1, 1, 0, 0, 0, 1},
- {1, 0, 0, 0, 1, 1},
- {0, 0, 0, 0, 1, 1, 1, 1},
- {0, 0, 0, 1, 1, 1, 1, 0},
- {0, 0, 1, 1, 1, 1, 0 ,0},
- {0, 1, 1, 1, 1, 0, 0 ,0},
- {1, 1, 1, 1, 0, 0, 0 ,0},
- {1, 1, 1, 0, 0, 0, 0 ,1},
- {1, 1, 0, 0, 0, 0, 1 ,1},
- {1, 0, 0, 0, 0, 1, 1 ,1},
- };
-
- const size_t HalfDensitySize = std::extent<decltype(HalfDensity)>::value;
-
- Value bonus(Depth depth) { int d = depth / ONE_PLY ; return Value(d * d + 2 * d - 2); }
- Value penalty(Depth depth) { int d = depth / ONE_PLY ; return -Value(d * d + 4 * d + 1); }
-
EasyMoveManager EasyMove;
Value DrawValue[COLOR_NB];
std::cout << sync_endl;
}
+// Sizes and phases of the skip-blocks, used for distributing search depths across the threads.
+static int skipsize[20] = {1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4};
+static int phase [20] = {0, 1, 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 7};
// Thread::search() is the main iterative deepening loop. It calls search()
// repeatedly with increasing depth until the allocated thinking time has been
multiPV = std::min(multiPV, rootMoves.size());
+ int hIdx = (idx - 1) % 20; // helper index, cycle after 20 threads
+
// Iterative deepening loop until requested to stop or the target depth is reached
while ( (rootDepth += ONE_PLY) < DEPTH_MAX
&& !Signals.stop
&& (!Limits.depth || Threads.main()->rootDepth / ONE_PLY <= Limits.depth))
{
- // Set up the new depths for the helper threads skipping on average every
- // 2nd ply (using a half-density matrix).
- if (!mainThread)
- {
- const Row& row = HalfDensity[(idx - 1) % HalfDensitySize];
- if (row[(rootDepth / ONE_PLY + rootPos.game_ply()) % row.size()])
- continue;
- }
+ // skip half of the plies in blocks depending on game ply and helper index.
+ if (idx && ((rootDepth / ONE_PLY + rootPos.game_ply() + phase[hIdx]) / skipsize[hIdx]) % 2)
+ continue;
// Age out PV variability metric
if (mainThread)
// search the already searched PV lines are preserved.
std::stable_sort(rootMoves.begin() + PVIdx, rootMoves.end());
- // If search has been stopped, break immediately. Sorting and
+ // If search has been stopped, we break immediately. Sorting and
// writing PV back to TT is safe because RootMoves is still
// valid, although it refers to the previous iteration.
if (Signals.stop)
bool doEasyMove = rootMoves[0].pv[0] == easyMove
&& mainThread->bestMoveChanges < 0.03
- && Time.elapsed() > Time.optimum() * 5 / 42;
+ && Time.elapsed() > Time.optimum() * 5 / 44;
if ( rootMoves.size() == 1
|| Time.elapsed() > Time.optimum() * unstablePvFactor * improvingFactor / 628
Key posKey;
Move ttMove, move, excludedMove, bestMove;
Depth extension, newDepth;
- Value bestValue, value, ttValue, eval, nullValue;
+ Value bestValue, value, ttValue, eval;
bool ttHit, inCheck, givesCheck, singularExtensionNode, improving;
bool captureOrPromotion, doFullDepthSearch, moveCountPruning;
Piece moved_piece;
: (tte->bound() & BOUND_UPPER)))
{
// If ttMove is quiet, update move sorting heuristics on TT hit
- if (ttValue >= beta && ttMove)
+ if (ttMove)
{
- if (!pos.capture_or_promotion(ttMove))
- update_stats(pos, ss, ttMove, nullptr, 0, bonus(depth));
+ if (ttValue >= beta)
+ {
+ if (!pos.capture_or_promotion(ttMove))
+ update_stats(pos, ss, ttMove, nullptr, 0, stat_bonus(depth));
- // Extra penalty for a quiet TT move in previous ply when it gets refuted
- if ((ss-1)->moveCount == 1 && !pos.captured_piece())
- update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, penalty(depth));
+ // Extra penalty for a quiet TT move in previous ply when it gets refuted
+ if ((ss-1)->moveCount == 1 && !pos.captured_piece())
+ update_cm_stats(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))
+ {
+ Value penalty = -stat_bonus(depth + ONE_PLY);
+ thisThread->history.update(pos.side_to_move(), ttMove, penalty);
+ update_cm_stats(ss, pos.moved_piece(ttMove), to_sq(ttMove), penalty);
+ }
}
return ttValue;
}
// Step 6. Razoring (skipped when in check)
if ( !PvNode
&& depth < 4 * ONE_PLY
- && ttMove == MOVE_NONE
&& eval + razor_margin[depth / ONE_PLY] <= alpha)
{
if (depth <= ONE_PLY)
Depth R = ((823 + 67 * depth / ONE_PLY) / 256 + std::min((eval - beta) / PawnValueMg, 3)) * ONE_PLY;
pos.do_null_move(st);
- nullValue = depth-R < ONE_PLY ? -qsearch<NonPV, false>(pos, ss+1, -beta, -beta+1)
- : - search<NonPV>(pos, ss+1, -beta, -beta+1, depth-R, !cutNode, true);
+ Value nullValue = depth-R < ONE_PLY ? -qsearch<NonPV, false>(pos, ss+1, -beta, -beta+1)
+ : - search<NonPV>(pos, ss+1, -beta, -beta+1, depth-R, !cutNode, true);
pos.undo_null_move();
if (nullValue >= beta)
{
if ( !captureOrPromotion
&& !givesCheck
- && !pos.advanced_pawn_push(move))
+ && (!pos.advanced_pawn_push(move) || pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >= 5000))
{
// Move count based pruning
if (moveCountPruning)
+ (fmh ? (*fmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
+ (fmh2 ? (*fmh2)[moved_piece][to_sq(move)] : VALUE_ZERO)
+ thisThread->history.get(~pos.side_to_move(), move)
- - 8000; // Correction factor
+ - 4000; // Correction factor
// Decrease/increase reduction by comparing opponent's stat score
if (ss->history > VALUE_ZERO && (ss-1)->history < VALUE_ZERO)
// Quiet best move: update move sorting heuristics
if (!pos.capture_or_promotion(bestMove))
- update_stats(pos, ss, bestMove, quietsSearched, quietCount, bonus(depth));
+ update_stats(pos, ss, bestMove, quietsSearched, quietCount, stat_bonus(depth));
// Extra penalty for a quiet TT move in previous ply when it gets refuted
if ((ss-1)->moveCount == 1 && !pos.captured_piece())
- update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, penalty(depth));
+ update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, -stat_bonus(depth + ONE_PLY));
}
// Bonus for prior countermove that caused the fail low
else if ( depth >= 3 * ONE_PLY
&& !pos.captured_piece()
&& is_ok((ss-1)->currentMove))
- update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, bonus(depth));
+ update_cm_stats(ss-1, pos.piece_on(prevSq), prevSq, stat_bonus(depth));
tte->save(posKey, value_to_tt(bestValue, ss->ply),
bestValue >= beta ? BOUND_LOWER :