From 4f906a25897467ba8fc7c31aa634cefc1ec0dba9 Mon Sep 17 00:00:00 2001
From: Marco Costalba <mcostalba@gmail.com>
Date: Thu, 19 Feb 2015 09:51:17 +0100
Subject: [PATCH 1/1] 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.
---
 src/search.cpp | 81 ++++++++++++++++++++++++--------------------------
 1 file changed, 39 insertions(+), 42 deletions(-)

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();
           }
       }
 
-- 
2.39.2