bool thread_should_stop(int threadID) const;
void wake_sleeping_threads();
void put_threads_to_sleep();
- void idle_loop(int threadID, SplitPoint* waitSp);
+ void idle_loop(int threadID, SplitPoint* sp);
bool split(const Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue,
Depth depth, bool mateThreat, int* moves, MovePicker* mp, int master, bool pvNode);
for (int i = 1; i < 64; i++) // i == depth (OnePly = 1)
for (int j = 1; j < 64; j++) // j == moveNumber
{
- double pvRed = 0.5 + log(double(i)) * log(double(j)) / 6.0;
- double nonPVRed = 0.5 + log(double(i)) * log(double(j)) / 3.0;
+ double pvRed = log(double(i)) * log(double(j)) / 3.0;
+ double nonPVRed = log(double(i)) * log(double(j)) / 1.5;
PVReductionMatrix[i][j] = (int8_t) ( pvRed >= 1.0 ? floor( pvRed * int(OnePly)) : 0);
NonPVReductionMatrix[i][j] = (int8_t) (nonPVRed >= 1.0 ? floor(nonPVRed * int(OnePly)) : 0);
}
if (tte && ok_to_use_TT(tte, depth, beta, ply))
{
+ // Refresh tte entry to avoid aging
+ TT.store(posKey, tte->value(), tte->type(), tte->depth(), ttMove);
+
ss[ply].currentMove = ttMove; // Can be MOVE_NONE
return value_from_tt(tte->value(), ply);
}
if (bestValue >= beta)
{
// Store the score to avoid a future costly evaluation() call
- if (!isCheck && !tte && ei.futilityMargin[pos.side_to_move()] == 0)
+ if (!isCheck && !tte && ei.kingDanger[pos.side_to_move()] == 0)
TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_EV_LO, Depth(-127*OnePly), MOVE_NONE);
return bestValue;
MovePicker mp = MovePicker(pos, ttMove, deepChecks ? Depth(0) : depth, H);
CheckInfo ci(pos);
enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
- futilityBase = staticValue + FutilityMarginQS + ei.futilityMargin[pos.side_to_move()];
+ futilityBase = staticValue + FutilityMarginQS + ei.kingDanger[pos.side_to_move()];
// Loop through the moves until no moves remain or a beta cutoff occurs
while ( alpha < beta
{
// If bestValue isn't changed it means it is still the static evaluation
// of the node, so keep this info to avoid a future evaluation() call.
- ValueType type = (bestValue == staticValue && !ei.futilityMargin[pos.side_to_move()] ? VALUE_TYPE_EV_UP : VALUE_TYPE_UPPER);
+ ValueType type = (bestValue == staticValue && !ei.kingDanger[pos.side_to_move()] ? VALUE_TYPE_EV_UP : VALUE_TYPE_UPPER);
TT.store(pos.get_key(), value_to_tt(bestValue, ply), type, d, MOVE_NONE);
}
else if (bestValue >= beta)
// idle_loop() is where the threads are parked when they have no work to do.
- // The parameter "waitSp", if non-NULL, is a pointer to an active SplitPoint
+ // The parameter 'sp', if non-NULL, is a pointer to an active SplitPoint
// object for which the current thread is the master.
- void ThreadsManager::idle_loop(int threadID, SplitPoint* waitSp) {
+ void ThreadsManager::idle_loop(int threadID, SplitPoint* sp) {
assert(threadID >= 0 && threadID < MAX_THREADS);
// master should exit as last one.
if (AllThreadsShouldExit)
{
- assert(!waitSp);
+ assert(!sp);
threads[threadID].state = THREAD_TERMINATED;
return;
}
// instead of wasting CPU time polling for work.
while (AllThreadsShouldSleep || threadID >= ActiveThreads)
{
- assert(!waitSp);
+ assert(!sp);
assert(threadID != 0);
threads[threadID].state = THREAD_SLEEPING;
// If this thread is the master of a split point and all threads have
// finished their work at this split point, return from the idle loop.
- if (waitSp != NULL && waitSp->cpus == 0)
+ if (sp && sp->cpus == 0)
{
+ // Because sp->cpus is decremented under lock protection,
+ // be sure sp->lock has been released before to proceed.
+ lock_grab(&(sp->lock));
+ lock_release(&(sp->lock));
+
assert(threads[threadID].state == THREAD_AVAILABLE);
threads[threadID].state = THREAD_SEARCHING;