// Depth limit for use of dynamic threat detection
Depth ThreatDepth; // heavy SMP read access
- // Last seconds noise filtering (LSN)
- bool UseLSNFiltering;
- bool looseOnTime = false;
- int LSNTime; // In milliseconds
- Value LSNValue;
-
// Extensions. Array index 0 is used at non-PV nodes, index 1 at PV nodes.
// There is heavy SMP read access on these arrays
Depth CheckExtension[2], SingleReplyExtension[2], PawnPushTo7thExtension[2];
// 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;
+ // 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;
if (button_was_pressed("Clear Hash"))
TT.clear();
- 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"));
+ bool UseLSNFiltering = get_option_value_bool("LSN filtering");
+ int LSNTime = get_option_value_int("LSN Time Margin (sec)") * 1000;
+ Value 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
+ static bool looseOnTime = false;
+
+ // FIXME we really need to cleanup all this LSN ugliness
if (!looseOnTime)
{
Value v = id_loop(pos, searchMoves);
// 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)
// 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);
// 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)
+ && !move_is_promotion(move)
&& (pos.midgame_value_of_piece_on(move_from(move)) >
pos.midgame_value_of_piece_on(move_to(move)))
&& pos.see(move) < 0)
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];
// 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));
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