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

Reparent to latest

Browse source 
Instead of reparenting to oldest split point, try to reparent
to latest. The nice thing here is that we can use the YBWC
helpful master condition to allow the reparenting of a split
point master as long as is reparented to one of its slaves.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2012-04-13 06:32:55 +01:00
parent c645aca199
commit 25a9b601b2
1 changed files with 32 additions and 33 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

65
src/search.cpp
View file

@ -1860,44 +1860,43 @@ void Thread::idle_loop(SplitPoint* sp_master) {
// unsafe because if we are exiting there is a chance are already freed. // unsafe because if we are exiting there is a chance are already freed.
lock_release(sp->lock); lock_release(sp->lock);
// Try to reparent to another split point. Only for slave threads // Try to reparent to another split point
// that are not master of any active split point. for (int i = 0; i < Threads.size(); i++)
if (!splitPointsCnt) {
for (int i = 0; i < Threads.size(); i++) Thread* th = &Threads[i];
int spCnt = th->splitPointsCnt;
SplitPoint* latest = &th->splitPoints[spCnt ? spCnt - 1 : 0];
// Find the first split point with still all slaves running
// where we are available as a possible slave.
if ( this->is_available_to(th)
&& spCnt > 0
&& !latest->cutoff
&& latest->slavesMask == latest->allSlavesMask
&& !single_bit(latest->allSlavesMask))
{ {
Thread* th = &Threads[i]; lock_grab(latest->lock);
SplitPoint* oldest = &th->splitPoints[0]; lock_grab(Threads.splitLock);
// Find the first split point with still all slaves running // Retest all under lock protection, we are in the middle
// where we are available as a possible slave. // of a race storm here !
if ( !is_searching if ( this->is_available_to(th)
&& th->splitPointsCnt && spCnt == th->splitPointsCnt
&& !oldest->cutoff && !latest->cutoff
&& oldest->slavesMask == oldest->allSlavesMask && latest->slavesMask == latest->allSlavesMask
&& !single_bit(oldest->allSlavesMask)) && !single_bit(latest->allSlavesMask))
{ {
lock_grab(oldest->lock); latest->slavesMask |= 1ULL << idx; // allSlavesMask is not updated
lock_grab(Threads.splitLock); curSplitPoint = latest;
is_searching = true;
// Retest all under lock protection, we are in the middle
// of a race storm here !
if ( !is_searching
&& th->splitPointsCnt
&& !oldest->cutoff
&& oldest->slavesMask == oldest->allSlavesMask
&& !single_bit(oldest->allSlavesMask))
{
oldest->slavesMask |= 1ULL << idx; // allSlavesMask is not updated
curSplitPoint = oldest;
is_searching = true;
}
lock_release(Threads.splitLock);
lock_release(oldest->lock);
break; // Exit anyhow, only one try (enough in 99% of cases)
} }
lock_release(Threads.splitLock);
lock_release(latest->lock);
break; // Exit anyhow, only one try (enough in 99% of cases)
} }
}
} }
} }
} }