#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;
namespace {
size_t MultiPV, UCIMultiPV, PVIdx;
TimeManager TimeMgr;
- Time SearchTime;
int BestMoveChanges;
int SkillLevel;
bool SkillLevelEnabled, Chess960;
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();
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[]);
Position& pos = RootPosition;
Chess960 = pos.is_chess960();
- SearchTime.restart();
- 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();
}
}
- // Read UCI options: GUI could change UCI parameters during the game
- read_evaluation_uci_options(pos.side_to_move());
-
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;
}
- Threads.set_size(Options["Threads"]);
+ 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"])
{
// 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[pos.thread()].wait_for_stop_or_ponderhit();
+ Threads.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.
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];
StateInfo st;
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 = Threads.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;
// 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->currentMove = ttMove; // Can be MOVE_NONE
- value = value_from_tt(tte->value(), ss->ply);
- if ( value >= beta
+ if ( ttValue >= beta
&& ttMove
&& !pos.is_capture_or_promotion(ttMove)
&& ttMove != ss->killers[0])
ss->killers[1] = ss->killers[0];
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
{
&& 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);
// Loop through all pseudo-legal moves until no moves remain or a beta cutoff occurs
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 && SearchTime.elapsed() > 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;
&& 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 < beta) // We want always alpha < beta
alpha = value;
- if (SpNode && !thread.cutoff_occurred())
+ if (SpNode && !thisThread->cutoff_occurred())
{
sp->bestValue = value;
sp->bestMove = move;
if ( !SpNode
&& depth >= Threads.min_split_depth()
&& bestValue < beta
- && Threads.available_slave_exists(pos.thread())
+ && Threads.available_slave_exists(thisThread)
&& !Signals.stop
- && !thread.cutoff_occurred())
+ && !thisThread->cutoff_occurred())
bestValue = Threads.split<FakeSplit>(pos, ss, alpha, beta, bestValue, &bestMove,
depth, threatMove, moveCount, &mp, NT);
}
// 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 : bestMove;
bt = bestValue <= oldAlpha ? BOUND_UPPER
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, bestMove;
- Value bestValue, value, evalMargin, futilityValue, futilityBase;
+ Value ttValue, bestValue, value, evalMargin, futilityValue, futilityBase;
bool inCheck, enoughMaterial, givesCheck, evasionPrunable;
const TTEntry* tte;
Depth ttDepth;
// 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->currentMove = ttMove; // Can be MOVE_NONE
- return value_from_tt(tte->value(), ss->ply);
+ return ttValue;
}
// Evaluate the position statically
kingAtt = pos.attacks_from<KING>(ksq);
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);
ksq = pos.king_square(pos.side_to_move());
if ( piece_is_slider(p1)
&& (squares_between(t1, ksq) & f2)
- && (pos.attacks_from(p1, t1, pos.occupied_squares() ^ f2) & ksq))
+ && (pos.attacks_from(p1, t1, pos.pieces() ^ f2) & ksq))
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;
lock_release(Threads.splitLock);
Stack ss[MAX_PLY_PLUS_2];
- Position pos(*sp->pos, threadID);
- int master = sp->master;
+ Position pos(*sp->pos);
memcpy(ss, sp->ss - 1, 4 * sizeof(Stack));
(ss+1)->sp = sp;
assert(is_searching);
is_searching = false;
- sp->slavesMask &= ~(1ULL << threadID);
+ sp->slavesMask &= ~(1ULL << idx);
sp->nodes += pos.nodes_searched();
- // After releasing the lock we cannot access anymore any SplitPoint
- // related data in a reliably way becuase it could have been released
- // under our feet by the sp master.
- lock_release(sp->lock);
-
// 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 != master
- && !Threads[master].is_searching)
- Threads[master].wake_up();
+ && 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);
}
}
}
|| stillAtFirstMove;
if ( (Limits.use_time_management() && noMoreTime)
- || (Limits.maxTime && e >= Limits.maxTime))
+ || (Limits.movetime && e >= Limits.movetime))
Signals.stop = true;
}
projects / stockfish / blobdiff