////
#include <cassert>
+#include <cstring>
#include <fstream>
#include <iostream>
#include <sstream>
struct IterationInfoType {
- IterationInfoType(Value v = Value(0), Value sv = Value(0), bool fh = false, bool fl = false)
- : value(v), speculatedValue(sv), failHigh(fh), failLow(fl) {}
+ IterationInfoType(Value v = Value(0), Value sv = Value(0))
+ : value(v), speculatedValue(sv) {}
Value value, speculatedValue;
- bool failHigh, failLow;
};
};
- /// Constants and variables
+ /// Constants and variables initialized from UCI options
// Minimum number of full depth (i.e. non-reduced) moves at PV and non-PV
- // nodes:
- int LMRPVMoves = 15;
- int LMRNonPVMoves = 4;
+ // nodes
+ int LMRPVMoves, LMRNonPVMoves;
- // Depth limit for use of dynamic threat detection:
- Depth ThreatDepth = 5*OnePly;
+ // Depth limit for use of dynamic threat detection
+ Depth ThreatDepth;
- // Depth limit for selective search:
- Depth SelectiveDepth = 7*OnePly;
+ // Depth limit for selective search
+ Depth SelectiveDepth;
// Use internal iterative deepening?
const bool UseIIDAtPVNodes = true;
const bool PruneBlockingMoves = false;
// Use futility pruning?
- bool UseQSearchFutilityPruning = true;
- bool UseFutilityPruning = true;
+ bool UseQSearchFutilityPruning, UseFutilityPruning;
// Margins for futility pruning in the quiescence search, and at frontier
// and near frontier nodes
- Value FutilityMarginQS = Value(0x80);
+ Value FutilityMarginQS;
Value FutilityMargins[6] = { Value(0x100), Value(0x200), Value(0x250),
Value(0x2A0), Value(0x340), Value(0x3A0) };
// Razoring
const bool RazorAtDepthOne = false;
- Depth RazorDepth = 4*OnePly;
- Value RazorMargin = Value(0x300);
+ Depth RazorDepth;
+ Value RazorMargin;
// Last seconds noise filtering (LSN)
- bool UseLSNFiltering = false;
+ bool UseLSNFiltering;
bool looseOnTime = false;
- int LSNTime = 4 * 1000; // In milliseconds
- Value LSNValue = Value(0x200);
+ int LSNTime; // In milliseconds
+ Value LSNValue;
- // Extensions. Array index 0 is used at non-PV nodes, index 1 at PV nodes.
- Depth CheckExtension[2] = {OnePly, OnePly};
- Depth SingleReplyExtension[2] = {OnePly / 2, OnePly / 2};
- Depth PawnPushTo7thExtension[2] = {OnePly / 2, OnePly / 2};
- Depth PassedPawnExtension[2] = {Depth(0), Depth(0)};
- Depth PawnEndgameExtension[2] = {OnePly, OnePly};
- Depth MateThreatExtension[2] = {Depth(0), Depth(0)};
+ // Extensions. Array index 0 is used at non-PV nodes, index 1 at PV nodes.
+ Depth CheckExtension[2], SingleReplyExtension[2], PawnPushTo7thExtension[2];
+ Depth PassedPawnExtension[2], PawnEndgameExtension[2], MateThreatExtension[2];
// Search depth at iteration 1
const Depth InitialDepth = OnePly /*+ OnePly/2*/;
int BestMoveChangesByIteration[PLY_MAX_PLUS_2];
// MultiPV mode
- int MultiPV = 1;
+ int MultiPV;
// Time managment variables
int SearchStartTime;
int ExactMaxTime;
// Show current line?
- bool ShowCurrentLine = false;
+ bool ShowCurrentLine;
// Log file
- bool UseLogFile = false;
+ bool UseLogFile;
std::ofstream LogFile;
// MP related variables
- Depth MinimumSplitDepth = 4*OnePly;
- int MaxThreadsPerSplitPoint = 4;
+ Depth MinimumSplitDepth;
+ int MaxThreadsPerSplitPoint;
Thread Threads[THREAD_MAX];
Lock MPLock;
bool AllThreadsShouldExit = false;
// Search to the current depth
Value value = root_search(p, ss, rml, alpha, beta);
- if (AbortSearch)
- break; // Value cannot be trusted. Break out immediately!
// Write PV to transposition table, in case the relevant entries have
// been overwritten during the search.
TT.insert_pv(p, ss[0].pv);
+ if (AbortSearch)
+ break; // Value cannot be trusted. Break out immediately!
+
//Save info about search result
Value speculatedValue;
bool fHigh = false;
}
else if (value <= alpha)
{
+ assert(value == alpha);
assert(delta < 0);
fLow = true;
speculatedValue = value;
speculatedValue = Min(Max(speculatedValue, -VALUE_INFINITE), VALUE_INFINITE);
- IterationInfo[Iteration] = IterationInfoType(value, speculatedValue, fHigh, fLow);
+ IterationInfo[Iteration] = IterationInfoType(value, speculatedValue);
// Erase the easy move if it differs from the new best move
if (ss[0].pv[0] != EasyMove)
Value root_search(Position &pos, SearchStack ss[], RootMoveList &rml, Value alpha, Value beta) {
- //FIXME: Implement bestValue
Value oldAlpha = alpha;
Value value;
Bitboard dcCandidates = pos.discovered_check_candidates(pos.side_to_move());
{
if (alpha >= beta)
{
+ // We failed high, invalidate and skip next moves, leave node-counters
+ // and beta-counters as they are and quickly return, we will try to do
+ // a research at the next iteration with a bigger aspiration window.
rml.set_move_score(i, -VALUE_INFINITE);
- continue; // Leave node-counters and beta-counters as they are
+ continue;
}
int64_t nodes;
Move move;
rml.set_move_score(i, -VALUE_INFINITE);
else
{
- // New best move!
+ // PV move or new best move!
// Update PV
rml.set_move_score(i, value);
continue;
// Value based pruning
- if (depth < 7 * OnePly && approximateEval < beta)
+ if (approximateEval < beta)
{
if (futilityValue == VALUE_NONE)
futilityValue = evaluate(pos, ei, threadID)
return value_from_tt(tte->value(), ply);
}
}
+ Move ttMove = (tte ? tte->move() : MOVE_NONE);
// Evaluate the position statically
EvalInfo ei;
// 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, pvNode, MOVE_NONE, EmptySearchStack, depth);
+ MovePicker mp = MovePicker(pos, pvNode, ttMove, EmptySearchStack, depth);
Move move;
int moveCount = 0;
Bitboard dcCandidates = mp.discovered_check_candidates();
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
// Update transposition table
+ Move m = ss[ply].pv[ply];
if (!pvNode)
{
Depth d = (depth == Depth(0) ? Depth(0) : Depth(-1));
if (bestValue < beta)
TT.store(pos, value_to_tt(bestValue, ply), d, MOVE_NONE, VALUE_TYPE_UPPER);
else
- TT.store(pos, value_to_tt(bestValue, ply), d, MOVE_NONE, VALUE_TYPE_LOWER);
+ TT.store(pos, value_to_tt(bestValue, ply), d, m, VALUE_TYPE_LOWER);
}
// Update killers only for good check moves
- Move m = ss[ply].currentMove;
if (alpha >= beta && ok_to_history(pos, m)) // Only non capture moves are considered
- {
- // Wrong to update history when depth is <= 0
update_killers(m, ss[ply]);
- }
+
return bestValue;
}
return;
bool overTime = t > AbsoluteMaxSearchTime
- || (RootMoveNumber == 1 && t > MaxSearchTime + ExtraSearchTime && !FailLow) //FIXME: BUG??
+ || (RootMoveNumber == 1 && t > MaxSearchTime + ExtraSearchTime && !FailLow) //FIXME: We are not checking any problem flags, BUG?
|| ( !FailHigh && !FailLow && !fail_high_ply_1() && !Problem
&& t > 6*(MaxSearchTime + ExtraSearchTime));