// Remaining depth: 1 ply 1.5 ply 2 ply 2.5 ply 3 ply 3.5 ply
const Value RazorApprMargins[6] = { Value(0x520), Value(0x300), Value(0x300), Value(0x300), Value(0x300), Value(0x300) };
+ // The main transposition table
+ TranspositionTable TT;
+
/// Variables initialized by UCI options
Depth ThreatDepth; // heavy SMP read access
// Last seconds noise filtering (LSN)
- bool UseLSNFiltering;
- bool looseOnTime = false;
- int LSNTime; // In milliseconds
- Value LSNValue;
+ const bool UseLSNFiltering = true;
+ const int LSNTime = 4000; // In milliseconds
+ const Value LSNValue = value_from_centipawns(200);
+ bool loseOnTime = false;
// Extensions. Array index 0 is used at non-PV nodes, index 1 at PV nodes.
// There is heavy SMP read access on these arrays
// Time managment variables
int SearchStartTime;
int MaxNodes, MaxDepth;
- int MaxSearchTime, AbsoluteMaxSearchTime, ExtraSearchTime;
- Move EasyMove;
+ int MaxSearchTime, AbsoluteMaxSearchTime, ExtraSearchTime, ExactMaxTime;
int RootMoveNumber;
bool InfiniteSearch;
bool PonderSearch;
bool FailHigh;
bool FailLow;
bool Problem;
- bool PonderingEnabled;
- int ExactMaxTime;
// Show current line?
bool ShowCurrentLine;
int NodesSincePoll;
int NodesBetweenPolls = 30000;
- // The main transposition table
- TranspositionTable TT;
+ // History table
+ History H;
/// Functions
bool move_is_killer(Move m, const SearchStack& ss);
Depth extension(const Position& pos, Move m, bool pvNode, bool capture, bool check, bool singleReply, bool mateThreat, bool* dangerous);
bool ok_to_do_nullmove(const Position& pos);
- bool ok_to_prune(const Position& pos, Move m, Move threat, Depth d, const History& H);
+ bool ok_to_prune(const Position& pos, Move m, Move threat, Depth d);
bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply);
bool ok_to_history(const Position& pos, Move m);
- void update_history(const Position& pos, Move m, Depth depth, History& H, Move movesSearched[], int moveCount);
+ void update_history(const Position& pos, Move m, Depth depth, Move movesSearched[], int moveCount);
void update_killers(Move m, SearchStack& ss);
bool fail_high_ply_1();
// Initialize global search variables
Idle = false;
SearchStartTime = get_system_time();
- EasyMove = MOVE_NONE;
for (int i = 0; i < THREAD_MAX; i++)
{
Threads[i].nodes = 0ULL;
// Read UCI option values
TT.set_size(get_option_value_int("Hash"));
if (button_was_pressed("Clear Hash"))
+ {
TT.clear();
+ loseOnTime = false; // reset at the beginning of a new game
+ }
- PonderingEnabled = get_option_value_bool("Ponder");
+ bool PonderingEnabled = get_option_value_bool("Ponder");
MultiPV = get_option_value_int("MultiPV");
CheckExtension[1] = Depth(get_option_value_int("Check Extension (PV nodes)"));
if (UseLogFile)
LogFile.open(get_option_value_string("Search Log Filename").c_str(), std::ios::out | std::ios::app);
- UseLSNFiltering = get_option_value_bool("LSN filtering");
- LSNTime = get_option_value_int("LSN Time Margin (sec)") * 1000;
- LSNValue = value_from_centipawns(get_option_value_int("LSN Value Margin"));
-
MinimumSplitDepth = get_option_value_int("Minimum Split Depth") * OnePly;
MaxThreadsPerSplitPoint = get_option_value_int("Maximum Number of Threads per Split Point");
// We're ready to start thinking. Call the iterative deepening loop function
- if (!looseOnTime)
+ //
+ // FIXME we really need to cleanup all this LSN ugliness
+ if (!loseOnTime)
{
Value v = id_loop(pos, searchMoves);
- looseOnTime = ( UseLSNFiltering
+ loseOnTime = ( UseLSNFiltering
&& myTime < LSNTime
&& myIncrement == 0
&& v < -LSNValue);
}
else
{
- looseOnTime = false; // reset for next match
+ loseOnTime = false; // reset for next match
while (SearchStartTime + myTime + 1000 > get_system_time())
; // wait here
id_loop(pos, searchMoves); // to fail gracefully
// Initialize
TT.new_search();
- for (int i = 0; i < THREAD_MAX; i++)
- Threads[i].H.clear();
-
+ H.clear();
for (int i = 0; i < 3; i++)
{
ss[i].init(i);
IterationInfo[1] = IterationInfoType(rml.get_move_score(0), rml.get_move_score(0));
Iteration = 1;
- EasyMove = rml.scan_for_easy_move();
+ Move EasyMove = rml.scan_for_easy_move();
// Iterative deepening loop
while (Iteration < PLY_MAX)
// Calculate dynamic search window based on previous iterations
Value alpha, beta;
- if (MultiPV == 1 && Iteration >= 6)
+ if (MultiPV == 1 && Iteration >= 6 && abs(IterationInfo[Iteration - 1].value) < VALUE_KNOWN_WIN)
{
int prevDelta1 = IterationInfo[Iteration - 1].speculatedValue - IterationInfo[Iteration - 2].speculatedValue;
int prevDelta2 = IterationInfo[Iteration - 2].speculatedValue - IterationInfo[Iteration - 3].speculatedValue;
// Initialize a MovePicker object for the current position, and prepare
// to search all moves
- MovePicker mp = MovePicker(pos, ttMove, depth, Threads[threadID].H, &ss[ply]);
+ MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
Move move, movesSearched[256];
int moveCount = 0;
&& moveCount >= LMRPVMoves
&& !dangerous
&& !moveIsCapture
- && !move_promotion(move)
+ && !move_is_promotion(move)
&& !move_is_castle(move)
&& !move_is_killer(move, ss[ply]))
{
Move m = ss[ply].pv[ply];
if (ok_to_history(pos, m)) // Only non capture moves are considered
{
- update_history(pos, m, depth, Threads[threadID].H, movesSearched, moveCount);
+ update_history(pos, m, depth, movesSearched, moveCount);
update_killers(m, ss[ply]);
}
TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, depth, m);
// Initialize a MovePicker object for the current position, and prepare
// to search all moves.
- MovePicker mp = MovePicker(pos, ttMove, depth, Threads[threadID].H, &ss[ply]);
+ MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
Move move, movesSearched[256];
int moveCount = 0;
if ( useFutilityPruning
&& !dangerous
&& !moveIsCapture
- && !move_promotion(move))
+ && !move_is_promotion(move))
{
// History pruning. See ok_to_prune() definition
if ( moveCount >= 2 + int(depth)
- && ok_to_prune(pos, move, ss[ply].threatMove, depth, Threads[threadID].H))
+ && ok_to_prune(pos, move, ss[ply].threatMove, depth))
continue;
// Value based pruning
&& moveCount >= LMRNonPVMoves
&& !dangerous
&& !moveIsCapture
- && !move_promotion(move)
+ && !move_is_promotion(move)
&& !move_is_castle(move)
&& !move_is_killer(move, ss[ply]))
{
Move m = ss[ply].pv[ply];
if (ok_to_history(pos, m)) // Only non capture moves are considered
{
- update_history(pos, m, depth, Threads[threadID].H, movesSearched, moveCount);
+ update_history(pos, m, depth, movesSearched, moveCount);
update_killers(m, ss[ply]);
}
TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, depth, m);
else if (tte && tte->type() == VALUE_TYPE_EVAL)
{
// Use the cached evaluation score if possible
- assert(tte->value() == evaluate(pos, ei, threadID));
assert(ei.futilityMargin == Value(0));
staticValue = tte->value();
// Initialize a MovePicker object for the current position, and prepare
// to search the moves. Because the depth is <= 0 here, only captures,
// queen promotions and checks (only if depth == 0) will be generated.
- MovePicker mp = MovePicker(pos, ttMove, depth, Threads[threadID].H);
+ MovePicker mp = MovePicker(pos, ttMove, depth, H);
Move move;
int moveCount = 0;
Bitboard dcCandidates = mp.discovered_check_candidates();
if ( enoughMaterial
&& !isCheck
&& !pvNode
- && !move_promotion(move)
+ && !move_is_promotion(move)
&& !pos.move_is_check(move, dcCandidates)
&& !pos.move_is_passed_pawn_push(move))
{
// Don't search captures and checks with negative SEE values
if ( !isCheck
- && !move_promotion(move)
- && (pos.midgame_value_of_piece_on(move_from(move)) >
- pos.midgame_value_of_piece_on(move_to(move)))
- && pos.see(move) < 0)
+ && !move_is_promotion(move)
+ && pos.see_sign(move) < 0)
continue;
// Make and search the move.
if ( useFutilityPruning
&& !dangerous
&& !moveIsCapture
- && !move_promotion(move)
+ && !move_is_promotion(move)
&& moveCount >= 2 + int(sp->depth)
- && ok_to_prune(pos, move, ss[sp->ply].threatMove, sp->depth, Threads[threadID].H))
+ && ok_to_prune(pos, move, ss[sp->ply].threatMove, sp->depth))
continue;
// Make and search the move.
if ( !dangerous
&& moveCount >= LMRNonPVMoves
&& !moveIsCapture
- && !move_promotion(move)
+ && !move_is_promotion(move)
&& !move_is_castle(move)
&& !move_is_killer(move, ss[sp->ply]))
{
if ( !dangerous
&& moveCount >= LMRPVMoves
&& !moveIsCapture
- && !move_promotion(move)
+ && !move_is_promotion(move)
&& !move_is_castle(move)
&& !move_is_killer(move, ss[sp->ply]))
{
&& pos.type_of_piece_on(move_to(m)) != PAWN
&& ( pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
- pos.midgame_value_of_piece_on(move_to(m)) == Value(0))
- && !move_promotion(m)
+ && !move_is_promotion(m)
&& !move_is_ep(m))
{
result += PawnEndgameExtension[pvNode];
if ( pvNode
&& capture
&& pos.type_of_piece_on(move_to(m)) != PAWN
- && pos.see(m) >= 0)
+ && pos.see_sign(m) >= 0)
{
result += OnePly/2;
*dangerous = true;
// non-tactical moves late in the move list close to the leaves are
// candidates for pruning.
- bool ok_to_prune(const Position& pos, Move m, Move threat, Depth d, const History& H) {
+ bool ok_to_prune(const Position& pos, Move m, Move threat, Depth d) {
assert(move_is_ok(m));
assert(threat == MOVE_NONE || move_is_ok(threat));
- assert(!move_promotion(m));
+ assert(!move_is_promotion(m));
assert(!pos.move_is_check(m));
assert(!pos.move_is_capture(m));
assert(!pos.move_is_passed_pawn_push(m));
&& threat != MOVE_NONE
&& piece_is_slider(pos.piece_on(tfrom))
&& bit_is_set(squares_between(tfrom, tto), mto)
- && pos.see(m) >= 0)
+ && pos.see_sign(m) >= 0)
return false;
return true;
bool ok_to_history(const Position& pos, Move m) {
- return !pos.move_is_capture(m) && !move_promotion(m);
+ return !pos.move_is_capture(m) && !move_is_promotion(m);
}
// update_history() registers a good move that produced a beta-cutoff
// in history and marks as failures all the other moves of that ply.
- void update_history(const Position& pos, Move m, Depth depth, History& H,
+ void update_history(const Position& pos, Move m, Depth depth,
Move movesSearched[], int moveCount) {
H.success(pos.piece_on(move_from(m)), move_to(m), depth);
projects / stockfish / blobdiff