kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-07-11 19:49:14 +00:00
Code Issues Releases Wiki Activity

Remove useless condition in late join

Browse source 
In case of Threads.size() == 2 we have that sp->allSlavesSearching
is always false (because we have finished our search), bestSp is
always NULL and we never late join, so there is no need to special
case here.

Tested with dbg_hit_on(sp && sp->allSlavesSearching) and
verified it never fires.

No functional change.
This commit is contained in:
Marco Costalba 2015-02-19 09:51:17 +01:00
parent dccaa145d2
commit 4f906a2589
1 changed files with 40 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

83
src/search.cpp
View file

@ -1588,59 +1588,56 @@ void Thread::idle_loop() {
// Try to late join to another split point if none of its slaves has // Try to late join to another split point if none of its slaves has
// already finished. // already finished.
if (Threads.size() > 2) SplitPoint* bestSp = NULL;
int bestThread = 0;
int bestScore = INT_MAX;
for (size_t i = 0; i < Threads.size(); ++i)
{ {
SplitPoint *bestSp = NULL; const int size = Threads[i]->splitPointsSize; // Local copy
int bestThread = 0; sp = size ? &Threads[i]->splitPoints[size - 1] : NULL;
int bestScore = INT_MAX;
for (size_t i = 0; i < Threads.size(); ++i) if ( sp
&& sp->allSlavesSearching
&& sp->slavesCount < MAX_SLAVES_PER_SPLITPOINT
&& available_to(Threads[i]))
{ {
const int size = Threads[i]->splitPointsSize; // Local copy // Compute the recursive split points chain size
sp = size ? &Threads[i]->splitPoints[size - 1] : NULL; int level = -1;
for (SplitPoint* spp = Threads[i]->activeSplitPoint; spp; spp = spp->parentSplitPoint)
level++;
if ( sp int score = level * 256 * 256 + sp->slavesCount * 256 - sp->depth * 1;
&& sp->allSlavesSearching
&& sp->slavesCount < MAX_SLAVES_PER_SPLITPOINT if (score < bestScore)
&& available_to(Threads[i]))
{ {
// Compute the recursive split points chain size bestSp = sp;
int level = -1; bestThread = i;
for (SplitPoint* spp = Threads[i]->activeSplitPoint; spp; spp = spp->parentSplitPoint) bestScore = score;
level++;
int score = level * 256 * 256 + sp->slavesCount * 256 - sp->depth * 1;
if (score < bestScore)
{
bestSp = sp;
bestThread = i;
bestScore = score;
}
} }
} }
}
if (bestSp) if (bestSp)
{
sp = bestSp;
// Recheck the conditions under lock protection
Threads.mutex.lock();
sp->mutex.lock();
if ( sp->allSlavesSearching
&& sp->slavesCount < MAX_SLAVES_PER_SPLITPOINT
&& available_to(Threads[bestThread]))
{ {
sp = bestSp; sp->slavesMask.set(idx);
sp->slavesCount++;
// Recheck the conditions under lock protection activeSplitPoint = sp;
Threads.mutex.lock(); searching = true;
sp->mutex.lock();
if ( sp->allSlavesSearching
&& sp->slavesCount < MAX_SLAVES_PER_SPLITPOINT
&& available_to(Threads[bestThread]))
{
sp->slavesMask.set(idx);
sp->slavesCount++;
activeSplitPoint = sp;
searching = true;
}
sp->mutex.unlock();
Threads.mutex.unlock();
} }
sp->mutex.unlock();
Threads.mutex.unlock();
} }
} }