From: Marco Costalba <mcostalba@gmail.com>
Date: Thu, 19 Feb 2015 08:51:17 +0000 (+0100)
Subject: Remove useless condition in late join
X-Git-Url: https://git.sesse.net/?p=stockfish;a=commitdiff_plain;h=4f906a25897467ba8fc7c31aa634cefc1ec0dba9;hp=dccaa145d2b57999aa3e368c7c9203731b4e9685

Remove useless condition in late join

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.
---

diff --git a/src/search.cpp b/src/search.cpp
index dcb89d75..1062c920 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -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();
           }
       }