bool available_thread_exists(int master) const;
bool thread_is_available(int slave, int master) const;
bool thread_should_stop(int threadID) const;
- void wake_sleeping_threads();
+ void wake_sleeping_thread(int threadID);
void put_threads_to_sleep();
void idle_loop(int threadID, SplitPoint* sp);
Lock MPLock, WaitLock;
#if !defined(_MSC_VER)
- pthread_cond_t WaitCond;
+ pthread_cond_t WaitCond[MAX_THREADS];
#else
HANDLE SitIdleEvent[MAX_THREADS];
#endif
Value id_loop(const Position& pos, Move searchMoves[]);
Value root_search(Position& pos, SearchStack* ss, Move* pv, RootMoveList& rml, Value* alphaPtr, Value* betaPtr);
- template <NodeType PvNode, bool SplitPoint>
+ template <NodeType PvNode, bool SpNode>
Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply);
template <NodeType PvNode>
bool value_is_mate(Value value);
Value value_to_tt(Value v, int ply);
Value value_from_tt(Value v, int ply);
- bool move_is_killer(Move m, SearchStack* ss);
bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply);
bool connected_threat(const Position& pos, Move m, Move threat);
Value refine_eval(const TTEntry* tte, Value defaultEval, int ply);
init_eval(ThreadsMgr.active_threads());
}
- // Wake up sleeping threads
- ThreadsMgr.wake_sleeping_threads();
+ // Wake up needed threads
+ for (int i = 1; i < newActiveThreads; i++)
+ ThreadsMgr.wake_sleeping_thread(i);
// Set thinking time
int myTime = time[pos.side_to_move()];
// all this work again. We also don't need to store anything to the hash table
// here: This is taken care of after we return from the split point.
- template <NodeType PvNode, bool SplitPoint>
+ template <NodeType PvNode, bool SpNode>
Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) {
assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE);
bool mateThreat = false;
int moveCount = 0;
int threadID = pos.thread();
+ SplitPoint* sp = NULL;
refinedValue = bestValue = value = -VALUE_INFINITE;
oldAlpha = alpha;
isCheck = pos.is_check();
- if (SplitPoint)
+ if (SpNode)
{
+ sp = ss->sp;
tte = NULL;
ttMove = excludedMove = MOVE_NONE;
- threatMove = ss->sp->threatMove;
- mateThreat = ss->sp->mateThreat;
+ threatMove = sp->threatMove;
+ mateThreat = sp->mateThreat;
goto split_point_start;
}
// Initialize a MovePicker object for the current position
// FIXME currently MovePicker() c'tor is needless called also in SplitPoint
MovePicker mpBase = MovePicker(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta));
- MovePicker& mp = SplitPoint ? *ss->sp->mp : mpBase;
+ MovePicker& mp = SpNode ? *sp->mp : mpBase;
CheckInfo ci(pos);
ss->bestMove = MOVE_NONE;
- singleEvasion = !SplitPoint && isCheck && mp.number_of_evasions() == 1;
+ singleEvasion = !SpNode && isCheck && mp.number_of_evasions() == 1;
futilityBase = ss->eval + ss->evalMargin;
- singularExtensionNode = !SplitPoint
+ singularExtensionNode = !SpNode
&& depth >= SingularExtensionDepth[PvNode]
&& tte
&& tte->move()
&& !excludedMove // Do not allow recursive singular extension search
&& (tte->type() & VALUE_TYPE_LOWER)
&& tte->depth() >= depth - 3 * ONE_PLY;
-
- // Step 10. Loop through moves
- // Loop through all legal moves until no moves remain or a beta cutoff occurs
- if (SplitPoint)
+ if (SpNode)
{
- lock_grab(&(ss->sp->lock));
- bestValue = ss->sp->bestValue;
+ lock_grab(&(sp->lock));
+ bestValue = sp->bestValue;
}
+ // Step 10. Loop through moves
+ // Loop through all legal moves until no moves remain or a beta cutoff occurs
while ( bestValue < beta
&& (move = mp.get_next_move()) != MOVE_NONE
&& !ThreadsMgr.thread_should_stop(threadID))
{
- if (SplitPoint)
+ if (SpNode)
{
- moveCount = ++ss->sp->moveCount;
- lock_release(&(ss->sp->lock));
+ moveCount = ++sp->moveCount;
+ lock_release(&(sp->lock));
}
assert(move_is_ok(move));
&& !(threatMove && connected_threat(pos, move, threatMove))
&& bestValue > value_mated_in(PLY_MAX)) // FIXME bestValue is racy
{
- if (SplitPoint)
- lock_grab(&(ss->sp->lock));
+ if (SpNode)
+ lock_grab(&(sp->lock));
+
continue;
}
if (futilityValueScaled < beta)
{
- if (SplitPoint)
+ if (SpNode)
{
- lock_grab(&(ss->sp->lock));
- if (futilityValueScaled > ss->sp->bestValue)
- ss->sp->bestValue = bestValue = futilityValueScaled;
+ lock_grab(&(sp->lock));
+ if (futilityValueScaled > sp->bestValue)
+ sp->bestValue = bestValue = futilityValueScaled;
}
else if (futilityValueScaled > bestValue)
bestValue = futilityValueScaled;
+
continue;
}
}
// Step extra. pv search (only in PV nodes)
// The first move in list is the expected PV
- if (!SplitPoint && PvNode && moveCount == 1)
+ if (!SpNode && PvNode && moveCount == 1)
value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1)
: - search<PV>(pos, ss+1, -beta, -alpha, newDepth, ply+1);
else
&& !captureOrPromotion
&& !dangerous
&& !move_is_castle(move)
- && !move_is_killer(move, ss))
+ && !(ss->killers[0] == move || ss->killers[1] == move))
{
ss->reduction = reduction<PvNode>(depth, moveCount);
if (ss->reduction)
{
- alpha = SplitPoint ? ss->sp->alpha : alpha;
+ alpha = SpNode ? sp->alpha : alpha;
Depth d = newDepth - ss->reduction;
value = d < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1)
: - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, ply+1);
assert(newDepth - ONE_PLY >= ONE_PLY);
ss->reduction = ONE_PLY;
- alpha = SplitPoint ? ss->sp->alpha : alpha;
+ alpha = SpNode ? sp->alpha : alpha;
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, ply+1);
doFullDepthSearch = (value > alpha);
}
// Step 15. Full depth search
if (doFullDepthSearch)
{
- alpha = SplitPoint ? ss->sp->alpha : alpha;
+ alpha = SpNode ? sp->alpha : alpha;
value = newDepth < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1)
: - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth, ply+1);
assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
// Step 17. Check for new best move
- if (SplitPoint)
+ if (SpNode)
{
- lock_grab(&(ss->sp->lock));
- bestValue = ss->sp->bestValue;
- alpha = ss->sp->alpha;
+ lock_grab(&(sp->lock));
+ bestValue = sp->bestValue;
+ alpha = sp->alpha;
}
- if (value > bestValue && !(SplitPoint && ThreadsMgr.thread_should_stop(threadID)))
+ if (value > bestValue && !(SpNode && ThreadsMgr.thread_should_stop(threadID)))
{
bestValue = value;
if (value > alpha)
{
- if (SplitPoint && (!PvNode || value >= beta))
- ss->sp->stopRequest = true;
+ if (SpNode && (!PvNode || value >= beta))
+ sp->stopRequest = true;
if (PvNode && value < beta) // We want always alpha < beta
alpha = value;
ss->bestMove = move;
}
- if (SplitPoint)
+ if (SpNode)
{
- ss->sp->bestValue = bestValue;
- ss->sp->alpha = alpha;
- ss->sp->parentSstack->bestMove = ss->bestMove;
+ sp->bestValue = bestValue;
+ sp->alpha = alpha;
+ sp->parentSstack->bestMove = ss->bestMove;
}
}
// Step 18. Check for split
- if ( !SplitPoint
+ if ( !SpNode
&& depth >= MinimumSplitDepth
&& ThreadsMgr.active_threads() > 1
&& bestValue < beta
threatMove, mateThreat, moveCount, &mp, PvNode);
}
- if (SplitPoint)
+ if (SpNode)
{
/* Here we have the lock still grabbed */
- ss->sp->slaves[threadID] = 0;
- lock_release(&(ss->sp->lock));
+ sp->slaves[threadID] = 0;
+ lock_release(&(sp->lock));
return bestValue;
}
}
- // move_is_killer() checks if the given move is among the killer moves
-
- bool move_is_killer(Move m, SearchStack* ss) {
-
- if (ss->killers[0] == m || ss->killers[1] == m)
- return true;
-
- return false;
- }
-
-
// extension() decides whether a move should be searched with normal depth,
// or with extended depth. Certain classes of moves (checking moves, in
// particular) are searched with bigger depth than ordinary moves and in
void update_history(const Position& pos, Move move, Depth depth,
Move movesSearched[], int moveCount) {
-
Move m;
H.success(pos.piece_on(move_from(move)), move_to(move), depth);
#if !defined(_MSC_VER)
lock_grab(&WaitLock);
if (AllThreadsShouldSleep || threadID >= ActiveThreads)
- pthread_cond_wait(&WaitCond, &WaitLock);
+ pthread_cond_wait(&WaitCond[threadID], &WaitLock);
lock_release(&WaitLock);
#else
WaitForSingleObject(SitIdleEvent[threadID], INFINITE);
threads[threadID].state = THREAD_SEARCHING;
// Here we call search() with SplitPoint template parameter set to true
- SplitPoint* sp = threads[threadID].splitPoint;
- Position pos(*sp->pos, threadID);
- SearchStack* ss = sp->sstack[threadID] + 1;
- ss->sp = sp;
+ SplitPoint* tsp = threads[threadID].splitPoint;
+ Position pos(*tsp->pos, threadID);
+ SearchStack* ss = tsp->sstack[threadID] + 1;
+ ss->sp = tsp;
- if (sp->pvNode)
- search<PV, true>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->ply);
+ if (tsp->pvNode)
+ search<PV, true>(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply);
else
- search<NonPV, true>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->ply);
+ search<NonPV, true>(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply);
assert(threads[threadID].state == THREAD_SEARCHING);
lock_init(&MPLock);
lock_init(&WaitLock);
+ for (i = 0; i < MAX_THREADS; i++)
#if !defined(_MSC_VER)
- pthread_cond_init(&WaitCond, NULL);
+ pthread_cond_init(&WaitCond[i], NULL);
#else
- for (i = 0; i < MAX_THREADS; i++)
SitIdleEvent[i] = CreateEvent(0, FALSE, FALSE, 0);
#endif
void ThreadsManager::exit_threads() {
- ActiveThreads = MAX_THREADS; // Wake up all the threads
- AllThreadsShouldExit = true; // Let the woken up threads to exit idle_loop()
- AllThreadsShouldSleep = true; // Avoid an assert in wake_sleeping_threads()
- wake_sleeping_threads();
+ AllThreadsShouldExit = true; // Let the woken up threads to exit idle_loop()
+ ActiveThreads = MAX_THREADS; // Avoid any woken up thread comes back to sleep
- // Wait for thread termination
+ // Wake up all the threads and waits for termination
for (int i = 1; i < MAX_THREADS; i++)
+ {
+ wake_sleeping_thread(i);
while (threads[i].state != THREAD_TERMINATED) {}
+ }
// Now we can safely destroy the locks
for (int i = 0; i < MAX_THREADS; i++)
}
- // wake_sleeping_threads() wakes up all sleeping threads when it is time
+ // wake_sleeping_thread() wakes up all sleeping threads when it is time
// to start a new search from the root.
- void ThreadsManager::wake_sleeping_threads() {
-
- assert(AllThreadsShouldSleep);
- assert(ActiveThreads > 0);
+ void ThreadsManager::wake_sleeping_thread(int threadID) {
- AllThreadsShouldSleep = false;
+ assert(threadID > 0);
+ assert(threads[threadID].state == THREAD_SLEEPING);
- if (ActiveThreads == 1)
- return;
+ AllThreadsShouldSleep = false; // Avoid the woken up thread comes back to sleep
#if !defined(_MSC_VER)
- pthread_mutex_lock(&WaitLock);
- pthread_cond_broadcast(&WaitCond);
- pthread_mutex_unlock(&WaitLock);
+ pthread_mutex_lock(&WaitLock);
+ pthread_cond_signal(&WaitCond[threadID]);
+ pthread_mutex_unlock(&WaitLock);
#else
- for (int i = 1; i < MAX_THREADS; i++)
- SetEvent(SitIdleEvent[i]);
+ SetEvent(SitIdleEvent[threadID]);
#endif
-
}
void ThreadsManager::put_threads_to_sleep() {
- assert(!AllThreadsShouldSleep);
+ assert(!AllThreadsShouldSleep || ActiveThreads == 1);
// This makes the threads to go to sleep
AllThreadsShouldSleep = true;
projects / stockfish / blobdiff