Remove useless condition in late join
authorMarco Costalba <mcostalba@gmail.com>
Thu, 19 Feb 2015 08:51:17 +0000 (09:51 +0100)
committerMarco Costalba <mcostalba@gmail.com>
Thu, 19 Feb 2015 08:53:39 +0000 (09:53 +0100)
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.

src/search.cpp

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