#include "book.h"
#include "evaluate.h"
#include "history.h"
-#include "misc.h"
#include "movegen.h"
#include "movepick.h"
#include "search.h"
LimitsType Limits;
std::vector<RootMove> RootMoves;
Position RootPosition;
+ Time SearchTime;
}
using std::string;
using std::cout;
using std::endl;
+using Eval::evaluate;
using namespace Search;
+// For some reason argument-dependent lookup (ADL) doesn't work for Android's
+// STLPort, so explicitly qualify following functions.
+using std::count;
+using std::find;
+
namespace {
// Set to true to force running with one thread. Used for debugging
const Depth RazorDepth = 4 * ONE_PLY;
// Dynamic razoring margin based on depth
- inline Value razor_margin(Depth d) { return Value(0x200 + 0x10 * int(d)); }
+ inline Value razor_margin(Depth d) { return Value(512 + 16 * int(d)); }
// Maximum depth for use of dynamic threat detection when null move fails low
const Depth ThreatDepth = 5 * ONE_PLY;
// At Non-PV nodes we do an internal iterative deepening search
// when the static evaluation is bigger then beta - IIDMargin.
- const Value IIDMargin = Value(0x100);
+ const Value IIDMargin = Value(256);
// Minimum depth for use of singular extension
const Depth SingularExtensionDepth[] = { 8 * ONE_PLY, 6 * ONE_PLY };
// Futility margin for quiescence search
- const Value FutilityMarginQS = Value(0x80);
+ const Value FutilityMarginQS = Value(128);
// Futility lookup tables (initialized at startup) and their access functions
Value FutilityMargins[16][64]; // [depth][moveNumber]
Value qsearch(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth);
void id_loop(Position& pos);
- bool check_is_dangerous(Position &pos, Move move, Value futilityBase, Value beta, Value *bValue);
+ bool check_is_dangerous(Position &pos, Move move, Value futilityBase, Value beta);
bool connected_moves(const Position& pos, Move m1, Move m2);
Value value_to_tt(Value v, int ply);
Value value_from_tt(Value v, int ply);
- bool can_return_tt(const TTEntry* tte, Depth depth, Value beta, int ply);
+ bool can_return_tt(const TTEntry* tte, Depth depth, Value ttValue, Value beta);
bool connected_threat(const Position& pos, Move m, Move threat);
- Value refine_eval(const TTEntry* tte, Value defaultEval, int ply);
+ Value refine_eval(const TTEntry* tte, Value ttValue, Value defaultEval);
Move do_skill_level();
- int elapsed_time(bool reset = false);
string score_to_uci(Value v, Value alpha = -VALUE_INFINITE, Value beta = VALUE_INFINITE);
void pv_info_to_log(Position& pos, int depth, Value score, int time, Move pv[]);
void pv_info_to_uci(const Position& pos, int depth, Value alpha, Value beta);
}
// Test for a capture that triggers a pawn endgame
- if ( captureOrPromotion
- && type_of(pos.piece_on(to_sq(m))) != PAWN
+ if ( captureOrPromotion
+ && type_of(pos.piece_on(to_sq(m))) != PAWN
+ && !is_special(m)
&& ( pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
- - PieceValueMidgame[pos.piece_on(to_sq(m))] == VALUE_ZERO)
- && !is_special(m))
+ - PieceValueMidgame[pos.piece_on(to_sq(m))] == VALUE_ZERO))
return true;
return false;
Position& pos = RootPosition;
Chess960 = pos.is_chess960();
- elapsed_time(true);
- TimeMgr.init(Limits, pos.startpos_ply_counter());
+ Eval::RootColor = pos.side_to_move();
+ TimeMgr.init(Limits, pos.startpos_ply_counter(), pos.side_to_move());
TT.new_search();
H.clear();
goto finalize;
}
- if (Options["OwnBook"])
+ if (Options["OwnBook"] && !Limits.infinite)
{
Move bookMove = book.probe(pos, Options["Book File"], Options["Best Book Move"]);
}
}
- // Read UCI options: GUI could change UCI parameters during the game
- read_evaluation_uci_options(pos.side_to_move());
- Threads.read_uci_options();
-
- TT.set_size(Options["Hash"]);
- if (Options["Clear Hash"])
- {
- Options["Clear Hash"] = false;
- TT.clear();
- }
-
UCIMultiPV = Options["MultiPV"];
SkillLevel = Options["Skill Level"];
log << "\nSearching: " << pos.to_fen()
<< "\ninfinite: " << Limits.infinite
<< " ponder: " << Limits.ponder
- << " time: " << Limits.time
- << " increment: " << Limits.increment
- << " moves to go: " << Limits.movesToGo
+ << " time: " << Limits.time[pos.side_to_move()]
+ << " increment: " << Limits.inc[pos.side_to_move()]
+ << " moves to go: " << Limits.movestogo
<< endl;
}
- for (int i = 0; i < Threads.size(); i++)
- {
- Threads[i].maxPly = 0;
- Threads[i].wake_up();
- }
+ Threads.wake_up();
// Set best timer interval to avoid lagging under time pressure. Timer is
// used to check for remaining available thinking time.
// We're ready to start searching. Call the iterative deepening loop function
id_loop(pos);
- // Stop timer and send all the slaves to sleep, if not already sleeping
- Threads.set_timer(0);
- Threads.set_size(1);
+ Threads.set_timer(0); // Stop timer
+ Threads.sleep();
if (Options["Use Search Log"])
{
- int e = elapsed_time();
+ int e = SearchTime.elapsed();
Log log(Options["Search Log Filename"]);
log << "Nodes: " << pos.nodes_searched()
// but if we are pondering or in infinite search, we shouldn't print the best
// move before we are told to do so.
if (!Signals.stop && (Limits.ponder || Limits.infinite))
- Threads.wait_for_stop_or_ponderhit();
+ pos.this_thread()->wait_for_stop_or_ponderhit();
// Best move could be MOVE_NONE when searching on a stalemate position
cout << "bestmove " << move_to_uci(RootMoves[0].pv[0], Chess960)
ss->currentMove = MOVE_NULL; // Hack to skip update gains
// Iterative deepening loop until requested to stop or target depth reached
- while (!Signals.stop && ++depth <= MAX_PLY && (!Limits.maxDepth || depth <= Limits.maxDepth))
+ while (!Signals.stop && ++depth <= MAX_PLY && (!Limits.depth || depth <= Limits.depth))
{
// Save last iteration's scores before first PV line is searched and all
// the move scores but the (new) PV are set to -VALUE_INFINITE.
// Send full PV info to GUI if we are going to leave the loop or
// if we have a fail high/low and we are deep in the search.
- if ((bestValue > alpha && bestValue < beta) || elapsed_time() > 2000)
+ if ((bestValue > alpha && bestValue < beta) || SearchTime.elapsed() > 2000)
pv_info_to_uci(pos, depth, alpha, beta);
// In case of failing high/low increase aspiration window and
if (SkillLevelEnabled && depth == 1 + SkillLevel)
skillBest = do_skill_level();
- if (Options["Use Search Log"])
- pv_info_to_log(pos, depth, bestValue, elapsed_time(), &RootMoves[0].pv[0]);
+ if (!Signals.stop && Options["Use Search Log"])
+ pv_info_to_log(pos, depth, bestValue, SearchTime.elapsed(), &RootMoves[0].pv[0]);
// Filter out startup noise when monitoring best move stability
if (depth > 2 && BestMoveChanges)
// Stop search if most of available time is already consumed. We
// probably don't have enough time to search the first move at the
// next iteration anyway.
- if (elapsed_time() > (TimeMgr.available_time() * 62) / 100)
+ if (SearchTime.elapsed() > (TimeMgr.available_time() * 62) / 100)
stop = true;
// Stop search early if one move seems to be much better than others
if ( depth >= 12
&& !stop
&& ( (bestMoveNeverChanged && pos.captured_piece_type())
- || elapsed_time() > (TimeMgr.available_time() * 40) / 100))
+ || SearchTime.elapsed() > (TimeMgr.available_time() * 40) / 100))
{
Value rBeta = bestValue - EasyMoveMargin;
(ss+1)->excludedMove = RootMoves[0].pv[0];
assert(alpha >= -VALUE_INFINITE && alpha < beta && beta <= VALUE_INFINITE);
assert((alpha == beta - 1) || PvNode);
assert(depth > DEPTH_ZERO);
- assert(pos.thread() >= 0 && pos.thread() < Threads.size());
- Move movesSearched[MAX_MOVES];
+ Move movesSearched[64];
StateInfo st;
const TTEntry *tte;
Key posKey;
- Move ttMove, move, excludedMove, threatMove;
+ Move ttMove, move, excludedMove, bestMove, threatMove;
Depth ext, newDepth;
Bound bt;
- Value bestValue, value, oldAlpha;
+ Value bestValue, value, oldAlpha, ttValue;
Value refinedValue, nullValue, futilityBase, futilityValue;
bool isPvMove, inCheck, singularExtensionNode, givesCheck;
bool captureOrPromotion, dangerous, doFullDepthSearch;
int moveCount = 0, playedMoveCount = 0;
- Thread& thread = Threads[pos.thread()];
+ Thread* thisThread = pos.this_thread();
SplitPoint* sp = NULL;
refinedValue = bestValue = value = -VALUE_INFINITE;
ss->ply = (ss-1)->ply + 1;
// Used to send selDepth info to GUI
- if (PvNode && thread.maxPly < ss->ply)
- thread.maxPly = ss->ply;
+ if (PvNode && thisThread->maxPly < ss->ply)
+ thisThread->maxPly = ss->ply;
// Step 1. Initialize node
if (SpNode)
{
tte = NULL;
ttMove = excludedMove = MOVE_NONE;
+ ttValue = VALUE_ZERO;
sp = ss->sp;
+ bestMove = sp->bestMove;
threatMove = sp->threatMove;
bestValue = sp->bestValue;
moveCount = sp->moveCount; // Lock must be held here
}
else
{
- ss->currentMove = ss->bestMove = threatMove = (ss+1)->excludedMove = MOVE_NONE;
+ ss->currentMove = threatMove = (ss+1)->excludedMove = bestMove = MOVE_NONE;
(ss+1)->skipNullMove = false; (ss+1)->reduction = DEPTH_ZERO;
(ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
// Step 2. Check for aborted search and immediate draw
// Enforce node limit here. FIXME: This only works with 1 search thread.
- if (Limits.maxNodes && pos.nodes_searched() >= Limits.maxNodes)
+ if (Limits.nodes && pos.nodes_searched() >= Limits.nodes)
Signals.stop = true;
if (( Signals.stop
posKey = excludedMove ? pos.exclusion_key() : pos.key();
tte = TT.probe(posKey);
ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tte ? tte->move() : MOVE_NONE;
+ ttValue = tte ? value_from_tt(tte->value(), ss->ply) : VALUE_ZERO;
// At PV nodes we check for exact scores, while at non-PV nodes we check for
// a fail high/low. Biggest advantage at probing at PV nodes is to have a
// smooth experience in analysis mode. We don't probe at Root nodes otherwise
// we should also update RootMoveList to avoid bogus output.
if (!RootNode && tte && (PvNode ? tte->depth() >= depth && tte->type() == BOUND_EXACT
- : can_return_tt(tte, depth, beta, ss->ply)))
+ : can_return_tt(tte, depth, ttValue, beta)))
{
TT.refresh(tte);
- ss->bestMove = move = ttMove; // Can be MOVE_NONE
- value = value_from_tt(tte->value(), ss->ply);
+ ss->currentMove = ttMove; // Can be MOVE_NONE
- if ( value >= beta
- && move
- && !pos.is_capture_or_promotion(move)
- && move != ss->killers[0])
+ if ( ttValue >= beta
+ && ttMove
+ && !pos.is_capture_or_promotion(ttMove)
+ && ttMove != ss->killers[0])
{
ss->killers[1] = ss->killers[0];
- ss->killers[0] = move;
+ ss->killers[0] = ttMove;
}
- return value;
+ return ttValue;
}
// Step 5. Evaluate the position statically and update parent's gain statistics
ss->eval = tte->static_value();
ss->evalMargin = tte->static_value_margin();
- refinedValue = refine_eval(tte, ss->eval, ss->ply);
+ refinedValue = refine_eval(tte, ttValue, ss->eval);
}
else
{
// Update gain for the parent non-capture move given the static position
// evaluation before and after the move.
- if ( (move = (ss-1)->currentMove) != MOVE_NULL
- && (ss-1)->eval != VALUE_NONE
- && ss->eval != VALUE_NONE
+ if ( (move = (ss-1)->currentMove) != MOVE_NULL
+ && (ss-1)->eval != VALUE_NONE
+ && ss->eval != VALUE_NONE
&& !pos.captured_piece_type()
&& !is_special(move))
{
&& refinedValue + razor_margin(depth) < beta
&& ttMove == MOVE_NONE
&& abs(beta) < VALUE_MATE_IN_MAX_PLY
- && !pos.has_pawn_on_7th(pos.side_to_move()))
+ && !pos.pawn_on_7th(pos.side_to_move()))
{
Value rbeta = beta - razor_margin(depth);
Value v = qsearch<NonPV>(pos, ss, rbeta-1, rbeta, DEPTH_ZERO);
// move which was reduced. If a connection is found, return a fail
// low score (which will cause the reduced move to fail high in the
// parent node, which will trigger a re-search with full depth).
- threatMove = (ss+1)->bestMove;
+ threatMove = (ss+1)->currentMove;
if ( depth < ThreatDepth
&& (ss-1)->reduction
assert(rdepth >= ONE_PLY);
assert((ss-1)->currentMove != MOVE_NONE);
+ assert((ss-1)->currentMove != MOVE_NULL);
MovePicker mp(pos, ttMove, H, pos.captured_piece_type());
CheckInfo ci(pos);
MovePickerExt<SpNode> mp(pos, ttMove, depth, H, ss, PvNode ? -VALUE_INFINITE : beta);
CheckInfo ci(pos);
- ss->bestMove = MOVE_NONE;
futilityBase = ss->eval + ss->evalMargin;
singularExtensionNode = !RootNode
&& !SpNode
- && depth >= SingularExtensionDepth[PvNode]
- && ttMove != MOVE_NONE
+ && depth >= SingularExtensionDepth[PvNode]
+ && ttMove != MOVE_NONE
&& !excludedMove // Recursive singular search is not allowed
&& (tte->type() & BOUND_LOWER)
- && tte->depth() >= depth - 3 * ONE_PLY;
+ && tte->depth() >= depth - 3 * ONE_PLY;
// Step 11. Loop through moves
// Loop through all pseudo-legal moves until no moves remain or a beta cutoff occurs
- while ( bestValue < beta
+ while ( bestValue < beta
&& (move = mp.next_move()) != MOVE_NONE
- && !thread.cutoff_occurred()
+ && !thisThread->cutoff_occurred()
&& !Signals.stop)
{
assert(is_ok(move));
{
Signals.firstRootMove = (moveCount == 1);
- if (pos.thread() == 0 && elapsed_time() > 2000)
+ if (thisThread == Threads.main_thread() && SearchTime.elapsed() > 2000)
cout << "info depth " << depth / ONE_PLY
<< " currmove " << move_to_uci(move, Chess960)
<< " currmovenumber " << moveCount + PVIdx << endl;
ext = ONE_PLY;
else if (givesCheck && pos.see_sign(move) >= 0)
- ext = PvNode ? ONE_PLY : ONE_PLY / 2;
+ ext = ONE_PLY / 2;
// Singular extension search. If all moves but one fail low on a search of
// (alpha-s, beta-s), and just one fails high on (alpha, beta), then that move
// is singular and should be extended. To verify this we do a reduced search
// on all the other moves but the ttMove, if result is lower than ttValue minus
// a margin then we extend ttMove.
- if ( singularExtensionNode
+ if ( singularExtensionNode
&& !ext
- && move == ttMove
- && pos.pl_move_is_legal(move, ci.pinned))
+ && move == ttMove
+ && pos.pl_move_is_legal(move, ci.pinned))
{
- Value ttValue = value_from_tt(tte->value(), ss->ply);
-
if (abs(ttValue) < VALUE_KNOWN_WIN)
{
Value rBeta = ttValue - int(depth);
value = search<NonPV>(pos, ss, rBeta - 1, rBeta, depth / 2);
ss->skipNullMove = false;
ss->excludedMove = MOVE_NONE;
- ss->bestMove = MOVE_NONE;
if (value < rBeta)
ext = ONE_PLY;
}
}
ss->currentMove = move;
- if (!SpNode && !captureOrPromotion)
+ if (!SpNode && !captureOrPromotion && playedMoveCount < 64)
movesSearched[playedMoveCount++] = move;
// Step 14. Make the move
// Step 15. Reduced depth search (LMR). If the move fails high will be
// re-searched at full depth.
- if ( depth > 3 * ONE_PLY
+ if ( depth > 3 * ONE_PLY
&& !isPvMove
&& !captureOrPromotion
&& !dangerous
if (value > bestValue)
{
bestValue = value;
- ss->bestMove = move;
+ bestMove = move;
if ( PvNode
&& value > alpha
&& value < beta) // We want always alpha < beta
alpha = value;
- if (SpNode && !thread.cutoff_occurred())
+ if (SpNode && !thisThread->cutoff_occurred())
{
sp->bestValue = value;
- sp->ss->bestMove = move;
+ sp->bestMove = move;
sp->alpha = alpha;
- sp->is_betaCutoff = (value >= beta);
+
+ if (value >= beta)
+ sp->cutoff = true;
}
}
// Step 19. Check for split
if ( !SpNode
- && depth >= Threads.min_split_depth()
- && bestValue < beta
- && Threads.available_slave_exists(pos.thread())
+ && depth >= Threads.min_split_depth()
+ && depth - reduction<PvNode>(depth, moveCount) >= Threads.min_split_depth()
+ && bestValue < beta
+ && Threads.available_slave_exists(thisThread)
&& !Signals.stop
- && !thread.cutoff_occurred())
- bestValue = Threads.split<FakeSplit>(pos, ss, alpha, beta, bestValue, depth,
- threatMove, moveCount, &mp, NT);
+ && !thisThread->cutoff_occurred())
+ bestValue = Threads.split<FakeSplit>(pos, ss, alpha, beta, bestValue, &bestMove,
+ depth, threatMove, moveCount, &mp, NT);
}
// Step 20. Check for mate and stalemate
{
assert(!playedMoveCount);
- bestValue = alpha;
+ bestValue = oldAlpha;
}
// Step 21. Update tables
// Update transposition table entry, killers and history
- if (!SpNode && !Signals.stop && !thread.cutoff_occurred())
+ if (!SpNode && !Signals.stop && !thisThread->cutoff_occurred())
{
- move = bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove;
+ move = bestValue <= oldAlpha ? MOVE_NONE : bestMove;
bt = bestValue <= oldAlpha ? BOUND_UPPER
: bestValue >= beta ? BOUND_LOWER : BOUND_EXACT;
assert(alpha >= -VALUE_INFINITE && alpha < beta && beta <= VALUE_INFINITE);
assert((alpha == beta - 1) || PvNode);
assert(depth <= DEPTH_ZERO);
- assert(pos.thread() >= 0 && pos.thread() < Threads.size());
StateInfo st;
- Move ttMove, move;
- Value bestValue, value, evalMargin, futilityValue, futilityBase;
+ Move ttMove, move, bestMove;
+ Value ttValue, bestValue, value, evalMargin, futilityValue, futilityBase;
bool inCheck, enoughMaterial, givesCheck, evasionPrunable;
const TTEntry* tte;
Depth ttDepth;
Bound bt;
Value oldAlpha = alpha;
- ss->bestMove = ss->currentMove = MOVE_NONE;
+ ss->currentMove = bestMove = MOVE_NONE;
ss->ply = (ss-1)->ply + 1;
// Check for an instant draw or maximum ply reached
// pruning, but only for move ordering.
tte = TT.probe(pos.key());
ttMove = (tte ? tte->move() : MOVE_NONE);
+ ttValue = tte ? value_from_tt(tte->value(),ss->ply) : VALUE_ZERO;
- if (!PvNode && tte && can_return_tt(tte, ttDepth, beta, ss->ply))
+ if (!PvNode && tte && can_return_tt(tte, ttDepth, ttValue, beta))
{
- ss->bestMove = ttMove; // Can be MOVE_NONE
- return value_from_tt(tte->value(), ss->ply);
+ ss->currentMove = ttMove; // Can be MOVE_NONE
+ return ttValue;
}
// Evaluate the position statically
// Detect non-capture evasions that are candidate to be pruned
evasionPrunable = !PvNode
- && inCheck
- && bestValue > VALUE_MATED_IN_MAX_PLY
+ && inCheck
+ && bestValue > VALUE_MATED_IN_MAX_PLY
&& !pos.is_capture(move)
&& !pos.can_castle(pos.side_to_move());
&& move != ttMove
&& !pos.is_capture_or_promotion(move)
&& ss->eval + PawnValueMidgame / 4 < beta
- && !check_is_dangerous(pos, move, futilityBase, beta, &bestValue))
- {
- if (ss->eval + PawnValueMidgame / 4 > bestValue)
- bestValue = ss->eval + PawnValueMidgame / 4;
-
+ && !check_is_dangerous(pos, move, futilityBase, beta))
continue;
- }
// Check for legality only before to do the move
if (!pos.pl_move_is_legal(move, ci.pinned))
if (value > bestValue)
{
bestValue = value;
- ss->bestMove = move;
+ bestMove = move;
if ( PvNode
&& value > alpha
return mated_in(ss->ply); // Plies to mate from the root
// Update transposition table
- move = bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove;
+ move = bestValue <= oldAlpha ? MOVE_NONE : bestMove;
bt = bestValue <= oldAlpha ? BOUND_UPPER
: bestValue >= beta ? BOUND_LOWER : BOUND_EXACT;
// bestValue is updated only when returning false because in that case move
// will be pruned.
- bool check_is_dangerous(Position &pos, Move move, Value futilityBase, Value beta, Value *bestValue)
+ bool check_is_dangerous(Position &pos, Move move, Value futilityBase, Value beta)
{
Bitboard b, occ, oldAtt, newAtt, kingAtt;
- Square from, to, ksq, victimSq;
+ Square from, to, ksq;
Piece pc;
Color them;
- Value futilityValue, bv = *bestValue;
from = from_sq(move);
to = to_sq(move);
them = ~pos.side_to_move();
ksq = pos.king_square(them);
kingAtt = pos.attacks_from<KING>(ksq);
- pc = pos.piece_on(from);
+ pc = pos.piece_moved(move);
- occ = pos.occupied_squares() & ~(1ULL << from) & ~(1ULL << ksq);
+ occ = pos.pieces() ^ from ^ ksq;
oldAtt = pos.attacks_from(pc, from, occ);
newAtt = pos.attacks_from(pc, to, occ);
// Rule 1. Checks which give opponent's king at most one escape square are dangerous
b = kingAtt & ~pos.pieces(them) & ~newAtt & ~(1ULL << to);
- if (!(b && (b & (b - 1))))
+ if (!more_than_one(b))
return true;
// Rule 2. Queen contact check is very dangerous
- if ( type_of(pc) == QUEEN
- && bit_is_set(kingAtt, to))
+ if (type_of(pc) == QUEEN && (kingAtt & to))
return true;
// Rule 3. Creating new double threats with checks
b = pos.pieces(them) & newAtt & ~oldAtt & ~(1ULL << ksq);
-
while (b)
{
- victimSq = pop_1st_bit(&b);
- futilityValue = futilityBase + PieceValueEndgame[pos.piece_on(victimSq)];
-
// Note that here we generate illegal "double move"!
- if ( futilityValue >= beta
- && pos.see_sign(make_move(from, victimSq)) >= 0)
+ if (futilityBase + PieceValueEndgame[pos.piece_on(pop_1st_bit(&b))] >= beta)
return true;
-
- if (futilityValue > bv)
- bv = futilityValue;
}
- // Update bestValue only if check is not dangerous (because we will prune the move)
- *bestValue = bv;
return false;
}
// Case 3: Moving through the vacated square
p2 = pos.piece_on(f2);
- if ( piece_is_slider(p2)
- && bit_is_set(squares_between(f2, t2), f1))
+ if (piece_is_slider(p2) && (between_bb(f2, t2) & f1))
return true;
// Case 4: The destination square for m2 is defended by the moving piece in m1
p1 = pos.piece_on(t1);
- if (bit_is_set(pos.attacks_from(p1, t1), t2))
+ if (pos.attacks_from(p1, t1) & t2)
return true;
// Case 5: Discovered check, checking piece is the piece moved in m1
ksq = pos.king_square(pos.side_to_move());
if ( piece_is_slider(p1)
- && bit_is_set(squares_between(t1, ksq), f2))
- {
- Bitboard occ = pos.occupied_squares();
- xor_bit(&occ, f2);
- if (bit_is_set(pos.attacks_from(p1, t1, occ), ksq))
- return true;
- }
+ && (between_bb(t1, ksq) & f2)
+ && (pos.attacks_from(p1, t1, pos.pieces() ^ f2) & ksq))
+ return true;
+
return false;
}
// Case 3: If the moving piece in the threatened move is a slider, don't
// prune safe moves which block its ray.
- if ( piece_is_slider(pos.piece_on(tfrom))
- && bit_is_set(squares_between(tfrom, tto), mto)
- && pos.see_sign(m) >= 0)
+ if ( piece_is_slider(pos.piece_on(tfrom))
+ && (between_bb(tfrom, tto) & mto)
+ && pos.see_sign(m) >= 0)
return true;
return false;
// can_return_tt() returns true if a transposition table score can be used to
// cut-off at a given point in search.
- bool can_return_tt(const TTEntry* tte, Depth depth, Value beta, int ply) {
-
- Value v = value_from_tt(tte->value(), ply);
+ bool can_return_tt(const TTEntry* tte, Depth depth, Value v, Value beta) {
return ( tte->depth() >= depth
|| v >= std::max(VALUE_MATE_IN_MAX_PLY, beta)
// refine_eval() returns the transposition table score if possible, otherwise
// falls back on static position evaluation.
- Value refine_eval(const TTEntry* tte, Value defaultEval, int ply) {
+ Value refine_eval(const TTEntry* tte, Value v, Value defaultEval) {
assert(tte);
- Value v = value_from_tt(tte->value(), ply);
-
if ( ((tte->type() & BOUND_LOWER) && v >= defaultEval)
|| ((tte->type() & BOUND_UPPER) && v < defaultEval))
return v;
}
- // current_search_time() returns the number of milliseconds which have passed
- // since the beginning of the current search.
-
- int elapsed_time(bool reset) {
-
- static int searchStartTime;
-
- if (reset)
- searchStartTime = system_time();
-
- return system_time() - searchStartTime;
- }
-
-
// score_to_uci() converts a value to a string suitable for use with the UCI
// protocol specifications:
//
void pv_info_to_uci(const Position& pos, int depth, Value alpha, Value beta) {
- int t = elapsed_time();
+ int t = SearchTime.elapsed();
int selDepth = 0;
for (int i = 0; i < Threads.size(); i++)
static RKISS rk;
// PRNG sequence should be not deterministic
- for (int i = abs(system_time() % 50); i > 0; i--)
+ for (int i = Time::current_time().msec() % 50; i > 0; i--)
rk.rand<unsigned>();
// RootMoves are already sorted by score in descending order
pos.do_move(m, *st++);
while ( (tte = TT.probe(pos.key())) != NULL
- && tte->move() != MOVE_NONE
- && pos.is_pseudo_legal(tte->move())
- && pos.pl_move_is_legal(tte->move(), pos.pinned_pieces())
+ && (m = tte->move()) != MOVE_NONE // Local copy, TT entry could change
+ && pos.is_pseudo_legal(m)
+ && pos.pl_move_is_legal(m, pos.pinned_pieces())
&& ply < MAX_PLY
&& (!pos.is_draw<false>() || ply < 2))
{
- pv.push_back(tte->move());
- pos.do_move(tte->move(), *st++);
+ pv.push_back(m);
+ pos.do_move(m, *st++);
ply++;
}
pv.push_back(MOVE_NONE);
{
assert(!do_sleep && !do_exit);
- // Copy split point position and search stack and call search()
+ lock_grab(Threads.splitLock);
+
+ assert(is_searching);
+ SplitPoint* sp = curSplitPoint;
+
+ lock_release(Threads.splitLock);
+
Stack ss[MAX_PLY_PLUS_2];
- SplitPoint* sp = splitPoint;
- Position pos(*sp->pos, threadID);
+ Position pos(*sp->pos, this);
memcpy(ss, sp->ss - 1, 4 * sizeof(Stack));
(ss+1)->sp = sp;
assert(is_searching);
- // We return from search with lock held
- sp->slavesMask &= ~(1ULL << threadID);
- sp->nodes += pos.nodes_searched();
- lock_release(sp->lock);
-
is_searching = false;
+ sp->slavesMask &= ~(1ULL << idx);
+ sp->nodes += pos.nodes_searched();
// Wake up master thread so to allow it to return from the idle loop in
// case we are the last slave of the split point.
- if ( Threads.use_sleeping_threads()
- && threadID != sp->master
- && !Threads[sp->master].is_searching)
- Threads[sp->master].wake_up();
+ if ( Threads.use_sleeping_threads()
+ && this != sp->master
+ && !sp->master->is_searching)
+ sp->master->wake_up();
+
+ // After releasing the lock we cannot access anymore any SplitPoint
+ // related data in a safe way becuase it could have been released under
+ // our feet by the sp master. Also accessing other Thread objects is
+ // unsafe because if we are exiting there is a chance are already freed.
+ lock_release(sp->lock);
}
}
}
void check_time() {
- static int lastInfoTime;
- int e = elapsed_time();
+ static Time lastInfoTime = Time::current_time();
- if (system_time() - lastInfoTime >= 1000 || !lastInfoTime)
+ if (lastInfoTime.elapsed() >= 1000)
{
- lastInfoTime = system_time();
+ lastInfoTime.restart();
dbg_print();
}
if (Limits.ponder)
return;
+ int e = SearchTime.elapsed();
bool stillAtFirstMove = Signals.firstRootMove
&& !Signals.failedLowAtRoot
&& e > TimeMgr.available_time();
|| stillAtFirstMove;
if ( (Limits.use_time_management() && noMoreTime)
- || (Limits.maxTime && e >= Limits.maxTime))
+ || (Limits.movetime && e >= Limits.movetime))
Signals.stop = true;
}
projects / stockfish / blobdiff