Depth depth, bool mateThreat, int* moves, MovePicker* mp, int master, bool pvNode);
private:
- friend void poll(SearchStack ss[], int ply);
+ friend void poll();
int ActiveThreads;
volatile bool AllThreadsShouldExit, AllThreadsShouldSleep;
};
+ // FIXME: document me
+
+ enum NullStatus {
+ ALLOW_NULLMOVE,
+ FORBID_NULLMOVE,
+ VERIFY_NULLMOVE
+ };
// RootMove struct is used for moves at the root at the tree. For each
// root move, we store a score, a node count, and a PV (really a refutation
Value id_loop(const Position& pos, Move searchMoves[]);
Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value* alphaPtr, Value* betaPtr);
Value search_pv(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID);
- Value search(Position& pos, SearchStack ss[], Value beta, Depth depth, int ply, bool allowNullmove, int threadID, Move excludedMove = MOVE_NONE);
+ Value search(Position& pos, SearchStack ss[], Value beta, Depth depth, int ply, NullStatus nullStatus, int threadID, Move excludedMove = MOVE_NONE);
Value qsearch(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID);
void sp_search(SplitPoint* sp, int threadID);
void sp_search_pv(SplitPoint* sp, int threadID);
Depth extension(const Position&, Move, bool, bool, bool, bool, bool, bool*);
bool ok_to_do_nullmove(const Position& pos);
bool ok_to_prune(const Position& pos, Move m, Move threat);
- bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply);
+ bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply, bool allowNullmove);
Value refine_eval(const TTEntry* tte, Value defaultEval, int ply);
void update_history(const Position& pos, Move move, Depth depth, Move movesSearched[], int moveCount);
void update_killers(Move m, SearchStack& ss);
int current_search_time();
int nps();
- void poll(SearchStack ss[], int ply);
+ void poll();
void ponderhit();
void wait_for_stop_or_ponderhit();
void init_ss_array(SearchStack ss[]);
if (get_option_value_string("Book File") != OpeningBook.file_name())
OpeningBook.open(get_option_value_string("Book File"));
- Move bookMove = OpeningBook.get_move(pos);
+ Move bookMove = OpeningBook.get_move(pos, get_option_value_bool("Best Book Move"));
if (bookMove != MOVE_NONE)
{
if (PonderSearch)
if (ss[0].reduction)
{
// Reduced depth non-pv search using alpha as upperbound
- value = -search(pos, ss, -alpha, newDepth-ss[0].reduction, 1, true, 0);
+ value = -search(pos, ss, -alpha, newDepth-ss[0].reduction, 1, ALLOW_NULLMOVE, 0);
doFullDepthSearch = (value > alpha);
}
}
{
// Full depth non-pv search using alpha as upperbound
ss[0].reduction = Depth(0);
- value = -search(pos, ss, -alpha, newDepth, 1, true, 0);
+ value = -search(pos, ss, -alpha, newDepth, 1, ALLOW_NULLMOVE, 0);
// If we are above alpha then research at same depth but as PV
// to get a correct score or eventually a fail high above beta.
if (abs(ttValue) < VALUE_KNOWN_WIN)
{
- Value excValue = search(pos, ss, ttValue - SingularExtensionMargin, depth / 2, ply, false, threadID, move);
+ Value excValue = search(pos, ss, ttValue - SingularExtensionMargin, depth / 2, ply, FORBID_NULLMOVE, threadID, move);
if (excValue < ttValue - SingularExtensionMargin)
ext = OnePly;
ss[ply].reduction = pv_reduction(depth, moveCount);
if (ss[ply].reduction)
{
- value = -search(pos, ss, -alpha, newDepth-ss[ply].reduction, ply+1, true, threadID);
+ value = -search(pos, ss, -alpha, newDepth-ss[ply].reduction, ply+1, ALLOW_NULLMOVE, threadID);
doFullDepthSearch = (value > alpha);
}
}
if (doFullDepthSearch)
{
ss[ply].reduction = Depth(0);
- value = -search(pos, ss, -alpha, newDepth, ply+1, true, threadID);
+ value = -search(pos, ss, -alpha, newDepth, ply+1, ALLOW_NULLMOVE, threadID);
// Step extra. pv search (only in PV nodes)
if (value > alpha && value < beta)
// search() is the search function for zero-width nodes.
Value search(Position& pos, SearchStack ss[], Value beta, Depth depth,
- int ply, bool allowNullmove, int threadID, Move excludedMove) {
+ int ply, NullStatus nullStatus, int threadID, Move excludedMove) {
assert(beta >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
assert(ply >= 0 && ply < PLY_MAX);
tte = TT.retrieve(posKey);
ttMove = (tte ? tte->move() : MOVE_NONE);
- if (tte && ok_to_use_TT(tte, depth, beta, ply))
+ if (tte && ok_to_use_TT(tte, depth, beta, ply, nullStatus != VERIFY_NULLMOVE))
{
ss[ply].currentMove = ttMove; // Can be MOVE_NONE
return value_from_tt(tte->value(), ply);
// Step 7. Static null move pruning
// We're betting that the opponent doesn't have a move that will reduce
// the score by more than futility_margin(depth) if we do a null move.
- if ( allowNullmove
+ if ( nullStatus == ALLOW_NULLMOVE
&& depth < RazorDepth
&& !isCheck
&& !value_is_mate(beta)
// When we jump directly to qsearch() we do a null move only if static value is
// at least beta. Otherwise we do a null move if static value is not more than
// NullMoveMargin under beta.
- if ( allowNullmove
+ if ( nullStatus == ALLOW_NULLMOVE
&& depth > OnePly
&& !isCheck
&& !value_is_mate(beta)
pos.do_null_move(st);
- nullValue = -search(pos, ss, -(beta-1), depth-R*OnePly, ply+1, false, threadID);
+ nullValue = -search(pos, ss, -(beta-1), depth-R*OnePly, ply+1, FORBID_NULLMOVE, threadID);
pos.undo_null_move();
if (nullValue >= value_mate_in(PLY_MAX))
nullValue = beta;
- if (depth < 6 * OnePly)
- return nullValue;
+ // Do zugzwang verification search for high depths, don't store in TT
+ // if search was stopped.
+ if ( ( depth < 6 * OnePly
+ || search(pos, ss, beta, depth-5*OnePly, ply, VERIFY_NULLMOVE, threadID) >= beta)
+ && !AbortSearch
+ && !TM.thread_should_stop(threadID))
+ {
+ assert(value_to_tt(nullValue, ply) == nullValue);
+
+ if (!tte)
+ TT.store(posKey, nullValue, VALUE_TYPE_NS_LO, depth, MOVE_NONE);
- // Do zugzwang verification search
- Value v = search(pos, ss, beta, depth-5*OnePly, ply, false, threadID);
- if (v >= beta)
return nullValue;
+ }
} else {
// The null move failed low, which means that we may be faced with
// some kind of threat. If the previous move was reduced, check if
&& !isCheck
&& ss[ply].eval >= beta - IIDMargin)
{
- search(pos, ss, beta, depth/2, ply, false, threadID);
+ search(pos, ss, beta, depth/2, ply, FORBID_NULLMOVE, threadID);
ttMove = ss[ply].pv[ply];
tte = TT.retrieve(posKey);
}
if (abs(ttValue) < VALUE_KNOWN_WIN)
{
- Value excValue = search(pos, ss, ttValue - SingularExtensionMargin, depth / 2, ply, false, threadID, move);
+ Value excValue = search(pos, ss, ttValue - SingularExtensionMargin, depth / 2, ply, FORBID_NULLMOVE, threadID, move);
if (excValue < ttValue - SingularExtensionMargin)
ext = OnePly;
ss[ply].reduction = nonpv_reduction(depth, moveCount);
if (ss[ply].reduction)
{
- value = -search(pos, ss, -(beta-1), newDepth-ss[ply].reduction, ply+1, true, threadID);
+ value = -search(pos, ss, -(beta-1), newDepth-ss[ply].reduction, ply+1, ALLOW_NULLMOVE, threadID);
doFullDepthSearch = (value >= beta);
}
}
if (doFullDepthSearch)
{
ss[ply].reduction = Depth(0);
- value = -search(pos, ss, -(beta-1), newDepth, ply+1, true, threadID);
+ value = -search(pos, ss, -(beta-1), newDepth, ply+1, ALLOW_NULLMOVE, threadID);
}
// Step 16. Undo move
tte = TT.retrieve(pos.get_key());
ttMove = (tte ? tte->move() : MOVE_NONE);
- if (!pvNode && tte && ok_to_use_TT(tte, depth, beta, ply))
+ if (!pvNode && tte && ok_to_use_TT(tte, depth, beta, ply, true))
{
assert(tte->type() != VALUE_TYPE_EVAL);
alpha = bestValue;
// If we are near beta then try to get a cutoff pushing checks a bit further
- bool deepChecks = depth == -OnePly && staticValue >= beta - PawnValueMidgame / 8;
+ bool deepChecks = (depth == -OnePly && staticValue >= beta - PawnValueMidgame / 8);
// Initialize a MovePicker object for the current position, and prepare
// to search the moves. Because the depth is <= 0 here, only captures,
// Detect blocking evasions that are candidate to be pruned
evasionPrunable = isCheck
- && bestValue != -VALUE_INFINITE
+ && bestValue > value_mated_in(PLY_MAX)
&& !pos.move_is_capture(move)
&& pos.type_of_piece_on(move_from(move)) != KING
&& !pos.can_castle(pos.side_to_move());
ss[sp->ply].reduction = nonpv_reduction(sp->depth, moveCount);
if (ss[sp->ply].reduction)
{
- value = -search(pos, ss, -(sp->beta-1), newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
+ value = -search(pos, ss, -(sp->beta-1), newDepth-ss[sp->ply].reduction, sp->ply+1, ALLOW_NULLMOVE, threadID);
doFullDepthSearch = (value >= sp->beta && !TM.thread_should_stop(threadID));
}
}
if (doFullDepthSearch)
{
ss[sp->ply].reduction = Depth(0);
- value = -search(pos, ss, -(sp->beta - 1), newDepth, sp->ply+1, true, threadID);
+ value = -search(pos, ss, -(sp->beta - 1), newDepth, sp->ply+1, ALLOW_NULLMOVE, threadID);
}
// Step 16. Undo move
if (ss[sp->ply].reduction)
{
Value localAlpha = sp->alpha;
- value = -search(pos, ss, -localAlpha, newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
+ value = -search(pos, ss, -localAlpha, newDepth-ss[sp->ply].reduction, sp->ply+1, ALLOW_NULLMOVE, threadID);
doFullDepthSearch = (value > localAlpha && !TM.thread_should_stop(threadID));
}
}
{
Value localAlpha = sp->alpha;
ss[sp->ply].reduction = Depth(0);
- value = -search(pos, ss, -localAlpha, newDepth, sp->ply+1, true, threadID);
+ value = -search(pos, ss, -localAlpha, newDepth, sp->ply+1, ALLOW_NULLMOVE, threadID);
if (value > localAlpha && value < sp->beta && !TM.thread_should_stop(threadID))
{
NodesSincePoll++;
if (NodesSincePoll >= NodesBetweenPolls)
{
- poll(ss, ply);
+ poll();
NodesSincePoll = 0;
}
}
}
- // ok_to_use_TT() returns true if a transposition table score
- // can be used at a given point in search.
+ // ok_to_use_TT() returns true if a transposition table score can be used at a
+ // given point in search. To avoid zugzwang issues TT cutoffs at the root node
+ // of a null move verification search are not allowed if the TT value was found
+ // by a null search, this is implemented testing allowNullmove and TT entry type.
- bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply) {
+ bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply, bool allowNullmove) {
Value v = value_from_tt(tte->value(), ply);
- return ( tte->depth() >= depth
+ return (allowNullmove || !(tte->type() & VALUE_TYPE_NULL))
+
+ && ( tte->depth() >= depth
|| v >= Max(value_mate_in(PLY_MAX), beta)
|| v < Min(value_mated_in(PLY_MAX), beta))
// looks at the time consumed so far and decides if it's time to abort the
// search.
- void poll(SearchStack ss[], int ply) {
+ void poll() {
static int lastInfoTime;
int t = current_search_time();
}
// Wait until the thread has finished launching and is gone to sleep
- while (threads[i].state != THREAD_SLEEPING);
+ while (threads[i].state != THREAD_SLEEPING) {}
}
}
SplitPoint* sp;
- for (sp = threads[threadID].splitPoint; sp && !sp->stopRequest; sp = sp->parent);
+ for (sp = threads[threadID].splitPoint; sp && !sp->stopRequest; sp = sp->parent) {}
return sp != NULL;
}