DrawValue[ us] = VALUE_DRAW - Value(contempt);
DrawValue[~us] = VALUE_DRAW + Value(contempt);
- TB::Hits = 0;
- TB::RootInTB = false;
- TB::UseRule50 = Options["Syzygy50MoveRule"];
- TB::ProbeDepth = Options["SyzygyProbeDepth"] * ONE_PLY;
- TB::Cardinality = Options["SyzygyProbeLimit"];
-
- // Skip TB probing when no TB found: !TBLargest -> !TB::Cardinality
- if (TB::Cardinality > TB::MaxCardinality)
- {
- TB::Cardinality = TB::MaxCardinality;
- TB::ProbeDepth = DEPTH_ZERO;
- }
-
if (rootMoves.empty())
{
rootMoves.push_back(RootMove(MOVE_NONE));
}
else
{
- if ( TB::Cardinality >= rootPos.count<ALL_PIECES>(WHITE)
- + rootPos.count<ALL_PIECES>(BLACK)
- && !rootPos.can_castle(ANY_CASTLING))
- {
- // If the current root position is in the tablebases, then RootMoves
- // contains only moves that preserve the draw or the win.
- TB::RootInTB = Tablebases::root_probe(rootPos, rootMoves, TB::Score);
-
- if (TB::RootInTB)
- TB::Cardinality = 0; // Do not probe tablebases during the search
-
- else // If DTZ tables are missing, use WDL tables as a fallback
- {
- // Filter out moves that do not preserve the draw or the win.
- TB::RootInTB = Tablebases::root_probe_wdl(rootPos, rootMoves, TB::Score);
-
- // Only probe during search if winning
- if (TB::Score <= VALUE_DRAW)
- TB::Cardinality = 0;
- }
-
- if (TB::RootInTB)
- {
- TB::Hits = rootMoves.size();
-
- if (!TB::UseRule50)
- TB::Score = TB::Score > VALUE_DRAW ? VALUE_MATE - MAX_PLY - 1
- : TB::Score < VALUE_DRAW ? -VALUE_MATE + MAX_PLY + 1
- : VALUE_DRAW;
- }
- }
-
for (Thread* th : Threads)
if (th != this)
th->start_searching();
// search the already searched PV lines are preserved.
std::stable_sort(rootMoves.begin() + PVIdx, rootMoves.end());
- // Write PV back to the transposition table in case the relevant
- // entries have been overwritten during the search.
- for (size_t i = 0; i <= PVIdx; ++i)
- rootMoves[i].insert_pv_in_tt(rootPos);
-
// If search has been stopped, break immediately. Sorting and
// writing PV back to TT is safe because RootMoves is still
// valid, although it refers to the previous iteration.
Depth extension, newDepth, predictedDepth;
Value bestValue, value, ttValue, eval, nullValue;
bool ttHit, inCheck, givesCheck, singularExtensionNode, improving;
- bool captureOrPromotion, doFullDepthSearch;
+ bool captureOrPromotion, doFullDepthSearch, moveCountPruning;
Piece moved_piece;
int moveCount, quietCount;
? ci.checkSquares[type_of(pos.piece_on(from_sq(move)))] & to_sq(move)
: pos.gives_check(move, ci);
+ moveCountPruning = depth < 16 * ONE_PLY
+ && moveCount >= FutilityMoveCounts[improving][depth];
+
// Step 12. Extend checks
- if (givesCheck && pos.see_sign(move) >= VALUE_ZERO)
+ if ( givesCheck
+ && ( moveCount == 1
+ || (!moveCountPruning && pos.see_sign(move) >= VALUE_ZERO)))
extension = ONE_PLY;
// Singular extension search. If all moves but one fail low on a search of
&& bestValue > VALUE_MATED_IN_MAX_PLY)
{
// Move count based pruning
- if ( depth < 16 * ONE_PLY
- && moveCount >= FutilityMoveCounts[improving][depth])
+ if (moveCountPruning)
continue;
// Countermoves based pruning
// Increase reduction for cut nodes
if (!PvNode && cutNode)
- r += ONE_PLY;
+ r += 2 * ONE_PLY;
// Decrease reduction for moves that escape a capture. Filter out
// castling moves, because they are coded as "king captures rook" and
else if ( type_of(move) == NORMAL
&& type_of(pos.piece_on(to_sq(move))) != PAWN
&& pos.see(make_move(to_sq(move), from_sq(move))) < VALUE_ZERO)
- r -= ONE_PLY;
+ r -= 2 * ONE_PLY;
// Decrease/increase reduction for moves with a good/bad history
int rHist = (val - 10000) / 20000;
&& !pos.captured_piece_type()
&& is_ok((ss-1)->currentMove))
{
- Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + depth / ONE_PLY - 1);
+ Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + 2 * depth / ONE_PLY - 2);
if ((ss-2)->counterMoves)
(ss-2)->counterMoves->update(pos.piece_on(prevSq), prevSq, bonus);
ss->killers[0] = move;
}
- Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + depth / ONE_PLY - 1);
+ Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + 2 * depth / ONE_PLY - 2);
Square prevSq = to_sq((ss-1)->currentMove);
CounterMoveStats* cmh = (ss-1)->counterMoves;
if ((ss-1)->moveCount == 1 && !pos.captured_piece_type())
{
if ((ss-2)->counterMoves)
- (ss-2)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY);
+ (ss-2)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
if ((ss-3)->counterMoves)
- (ss-3)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY);
+ (ss-3)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
if ((ss-5)->counterMoves)
- (ss-5)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY);
+ (ss-5)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
}
}
}
-/// RootMove::insert_pv_in_tt() is called at the end of a search iteration, and
-/// inserts the PV back into the TT. This makes sure the old PV moves are searched
-/// first, even if the old TT entries have been overwritten.
-
-void RootMove::insert_pv_in_tt(Position& pos) {
-
- StateInfo state[MAX_PLY], *st = state;
- bool ttHit;
-
- for (Move m : pv)
- {
- assert(MoveList<LEGAL>(pos).contains(m));
-
- TTEntry* tte = TT.probe(pos.key(), ttHit);
-
- if (!ttHit || tte->move() != m) // Don't overwrite correct entries
- tte->save(pos.key(), VALUE_NONE, BOUND_NONE, DEPTH_NONE,
- m, VALUE_NONE, TT.generation());
-
- pos.do_move(m, *st++, pos.gives_check(m, CheckInfo(pos)));
- }
-
- for (size_t i = pv.size(); i > 0; )
- pos.undo_move(pv[--i]);
-}
-
-
/// RootMove::extract_ponder_from_tt() is called in case we have no ponder move
/// before exiting the search, for instance, in case we stop the search during a
/// fail high at root. We try hard to have a ponder move to return to the GUI,
return false;
}
+
+void Tablebases::filter_root_moves(Position& pos, Search::RootMoves& rootMoves) {
+
+ Hits = 0;
+ RootInTB = false;
+ UseRule50 = Options["Syzygy50MoveRule"];
+ ProbeDepth = Options["SyzygyProbeDepth"] * ONE_PLY;
+ Cardinality = Options["SyzygyProbeLimit"];
+
+ // Skip TB probing when no TB found: !TBLargest -> !TB::Cardinality
+ if (Cardinality > MaxCardinality)
+ {
+ Cardinality = MaxCardinality;
+ ProbeDepth = DEPTH_ZERO;
+ }
+
+ if (Cardinality < popcount(pos.pieces()) || pos.can_castle(ANY_CASTLING))
+ return;
+
+ // If the current root position is in the tablebases, then RootMoves
+ // contains only moves that preserve the draw or the win.
+ RootInTB = root_probe(pos, rootMoves, TB::Score);
+
+ if (RootInTB)
+ Cardinality = 0; // Do not probe tablebases during the search
+
+ else // If DTZ tables are missing, use WDL tables as a fallback
+ {
+ // Filter out moves that do not preserve the draw or the win.
+ RootInTB = root_probe_wdl(pos, rootMoves, TB::Score);
+
+ // Only probe during search if winning
+ if (TB::Score <= VALUE_DRAW)
+ Cardinality = 0;
+ }
+
+ if (RootInTB)
+ {
+ Hits = rootMoves.size();
+
+ if (!UseRule50)
+ TB::Score = TB::Score > VALUE_DRAW ? VALUE_MATE - MAX_PLY - 1
+ : TB::Score < VALUE_DRAW ? -VALUE_MATE + MAX_PLY + 1
+ : VALUE_DRAW;
+ }
+}
projects / stockfish / blobdiff