void wake_sleeping_threads();
void put_threads_to_sleep();
void idle_loop(int threadID, SplitPoint* waitSp);
- bool split(const Position& pos, SearchStack* ss, int ply, Value* alpha, Value* beta, Value* bestValue,
+ bool split(const Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue,
const Value futilityValue, Depth depth, int* moves, MovePicker* mp, int master, bool pvNode);
private:
&& TM.available_thread_exists(threadID)
&& !AbortSearch
&& !TM.thread_should_stop(threadID)
- && TM.split(pos, ss, ply, &alpha, &beta, &bestValue, VALUE_NONE,
+ && TM.split(pos, ss, ply, &alpha, beta, &bestValue, VALUE_NONE,
depth, &moveCount, &mp, threadID, true))
break;
}
&& TM.available_thread_exists(threadID)
&& !AbortSearch
&& !TM.thread_should_stop(threadID)
- && TM.split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, //FIXME: SMP & futilityValue
+ && TM.split(pos, ss, ply, NULL, beta, &bestValue, futilityValue, //FIXME: SMP & futilityValue
depth, &moveCount, &mp, threadID, false))
break;
}
assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
- if (TM.thread_should_stop(threadID))
- {
- lock_grab(&(sp->lock));
- break;
- }
-
// New best move?
if (value > sp->bestValue) // Less then 2% of cases
{
- // Recursive locking, lock current split point and its ancestors to
- // guarantee thread_should_stop() and sp_update_pv() are race free.
- SplitPoint* spChain[MAX_THREADS * ACTIVE_SPLIT_POINTS_MAX];
- int cnt = 0;
- for (spChain[cnt] = sp; spChain[cnt]; )
- {
- lock_grab(&(spChain[cnt++]->lock));
- spChain[cnt] = spChain[cnt - 1]->parent;
- }
-
+ lock_grab(&(sp->lock));
if (value > sp->bestValue && !TM.thread_should_stop(threadID))
{
sp->bestValue = value;
sp_update_pv(sp->parentSstack, ss, sp->ply);
}
}
-
- // Release locks in reverse order
- while (cnt > 0)
- lock_release(&(spChain[--cnt]->lock));
+ lock_release(&(sp->lock));
}
}
assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
- if (TM.thread_should_stop(threadID))
- {
- lock_grab(&(sp->lock));
- break;
- }
-
// New best move?
if (value > sp->bestValue) // Less then 2% of cases
{
- // Recursive locking, lock current split point and its ancestors to
- // guarantee thread_should_stop() and sp_update_pv() are race free.
- SplitPoint* spChain[MAX_THREADS * ACTIVE_SPLIT_POINTS_MAX];
- int cnt = 0;
- for (spChain[cnt] = sp; spChain[cnt]; )
- {
- lock_grab(&(spChain[cnt++]->lock));
- spChain[cnt] = spChain[cnt - 1]->parent;
- }
-
+ lock_grab(&(sp->lock));
if (value > sp->bestValue && !TM.thread_should_stop(threadID))
{
sp->bestValue = value;
ss[sp->ply].mateKiller = move;
}
}
-
- // Release locks in reverse order
- while (cnt > 0)
- lock_release(&(spChain[--cnt]->lock));
+ lock_release(&(sp->lock));
}
}
lock_init(&IOLock, NULL);
// Initialize SplitPointStack locks
- for (int i = 0; i < MAX_THREADS; i++)
+ for (i = 0; i < MAX_THREADS; i++)
for (int j = 0; j < ACTIVE_SPLIT_POINTS_MAX; j++)
{
SplitPointStack[i][j].parent = NULL;
// splitPoint->cpus becomes 0), split() returns true.
bool ThreadsManager::split(const Position& p, SearchStack* sstck, int ply,
- Value* alpha, Value* beta, Value* bestValue, const Value futilityValue,
+ Value* alpha, const Value beta, Value* bestValue, const Value futilityValue,
Depth depth, int* moves, MovePicker* mp, int master, bool pvNode) {
assert(p.is_ok());
}
// Pick the next available split point object from the split point stack
- splitPoint = SplitPointStack[master] + threads[master].activeSplitPoints;
- threads[master].activeSplitPoints++;
+ splitPoint = &SplitPointStack[master][threads[master].activeSplitPoints];
// Initialize the split point object
splitPoint->parent = threads[master].splitPoint;
splitPoint->stopRequest = false;
splitPoint->ply = ply;
splitPoint->depth = depth;
- splitPoint->alpha = pvNode ? *alpha : (*beta - 1);
- splitPoint->beta = *beta;
+ splitPoint->alpha = pvNode ? *alpha : beta - 1;
+ splitPoint->beta = beta;
splitPoint->pvNode = pvNode;
splitPoint->bestValue = *bestValue;
splitPoint->futilityValue = futilityValue;
splitPoint->slaves[i] = 0;
threads[master].splitPoint = splitPoint;
+ threads[master].activeSplitPoints++;
// If we are here it means we are not available
assert(threads[master].state != THREAD_AVAILABLE);
if (pvNode)
*alpha = splitPoint->alpha;
- *beta = splitPoint->beta;
*bestValue = splitPoint->bestValue;
threads[master].activeSplitPoints--;
threads[master].splitPoint = splitPoint->parent;