Fix last leak detected by Valgrind

[stockfish] / src / search.cpp

diff --git a/src/search.cpp b/src/search.cpp
index 13a0175aae57a728c0f8d3635da1be34ba1d795d..6b943b53793ffc0ac9eefaf0e097a05a1af608da 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -700,7 +700,7 @@ namespace {
     int64_t nodes;
     Move move;
     Depth depth, ext, newDepth;
-    Value value, evalMargin, alpha, beta;
+    Value value, alpha, beta;
     bool isCheck, moveIsCheck, captureOrPromotion, dangerous;
     int researchCountFH, researchCountFL;
 
@@ -719,7 +719,8 @@ namespace {
 
     // Step 5. Evaluate the position statically
     // At root we do this only to get reference value for child nodes
-    ss->eval = isCheck ? VALUE_NONE : evaluate(pos, evalMargin);
+    ss->evalMargin = VALUE_NONE;
+    ss->eval = isCheck ? VALUE_NONE : evaluate(pos, ss->evalMargin);
 
     // Step 6. Razoring (omitted at root)
     // Step 7. Static null move pruning (omitted at root)
@@ -965,7 +966,7 @@ namespace {
     Key posKey;
     Move ttMove, move, excludedMove, threatMove;
     Depth ext, newDepth;
-    Value bestValue, value, evalMargin, oldAlpha;
+    Value bestValue, value, oldAlpha;
     Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific
     bool isCheck, singleEvasion, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous;
     bool mateThreat = false;
@@ -980,7 +981,6 @@ namespace {
     {
         sp = ss->sp;
         tte = NULL;
-        evalMargin = VALUE_ZERO;
         ttMove = excludedMove = MOVE_NONE;
         threatMove = sp->threatMove;
         mateThreat = sp->mateThreat;
@@ -1041,19 +1041,19 @@ namespace {
     // Step 5. Evaluate the position statically and
     // update gain statistics of parent move.
     if (isCheck)
-        ss->eval = evalMargin = VALUE_NONE;
+        ss->eval = ss->evalMargin = VALUE_NONE;
     else if (tte)
     {
         assert(tte->static_value() != VALUE_NONE);
 
         ss->eval = tte->static_value();
-        evalMargin = tte->static_value_margin();
+        ss->evalMargin = tte->static_value_margin();
         refinedValue = refine_eval(tte, ss->eval, ply);
     }
     else
     {
-        refinedValue = ss->eval = evaluate(pos, evalMargin);
-        TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
+        refinedValue = ss->eval = evaluate(pos, ss->evalMargin);
+        TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin);
     }
 
     // Save gain for the parent non-capture move
@@ -1174,12 +1174,12 @@ split_point_start: // At split points actual search starts from here
 
     // Initialize a MovePicker object for the current position
     // FIXME currently MovePicker() c'tor is needless called also in SplitPoint
-    MovePicker mpBase = MovePicker(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta));
+    MovePicker mpBase(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta));
     MovePicker& mp = SpNode ? *sp->mp : mpBase;
     CheckInfo ci(pos);
     ss->bestMove = MOVE_NONE;
     singleEvasion = !SpNode && isCheck && mp.number_of_evasions() == 1;
-    futilityBase = ss->eval + evalMargin;
+    futilityBase = ss->eval + ss->evalMargin;
     singularExtensionNode =  !SpNode
                            && depth >= SingularExtensionDepth[PvNode]
                            && tte
@@ -1243,7 +1243,10 @@ split_point_start: // At split points actual search starts from here
       newDepth = depth - ONE_PLY + ext;
 
       // Update current move (this must be done after singular extension search)
-      movesSearched[moveCount++] = ss->currentMove = move;
+      movesSearched[moveCount] = ss->currentMove = move;
+
+      if (!SpNode)
+          moveCount++;
 
       // Step 12. Futility pruning (is omitted in PV nodes)
       if (   !PvNode
@@ -1364,24 +1367,29 @@ split_point_start: // At split points actual search starts from here
       if (value > bestValue && !(SpNode && ThreadsMgr.thread_should_stop(threadID)))
       {
           bestValue = value;
+
+          if (SpNode)
+              sp->bestValue = value;
+
           if (value > alpha)
           {
               if (SpNode && (!PvNode || value >= beta))
                   sp->stopRequest = true;
 
               if (PvNode && value < beta) // We want always alpha < beta
+              {
                   alpha = value;
+                  if (SpNode)
+                      sp->alpha = value;
+              }
 
               if (value == value_mate_in(ply + 1))
                   ss->mateKiller = move;
 
               ss->bestMove = move;
-          }
-          if (SpNode)
-          {
-              sp->bestValue = bestValue;
-              sp->alpha = alpha;
-              sp->parentSstack->bestMove = ss->bestMove;
+
+              if (SpNode)
+                  sp->parentSstack->bestMove = move;
           }
       }
 
@@ -1421,7 +1429,7 @@ split_point_start: // At split points actual search starts from here
 
     ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT);
     move = (bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove);
-    TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, evalMargin);
+    TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, ss->evalMargin);
 
     // Update killers and history only for non capture moves that fails high
     if (    bestValue >= beta
@@ -2259,9 +2267,9 @@ split_point_start: // At split points actual search starts from here
 
             if (tsp->pvNode)
                 search<PV, true>(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply);
-            else
+            else {
                 search<NonPV, true>(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply);
-
+            }
             assert(threads[threadID].state == THREAD_SEARCHING);
 
             threads[threadID].state = THREAD_AVAILABLE;
@@ -2328,6 +2336,7 @@ split_point_start: // At split points actual search starts from here
 #if !defined(_MSC_VER)
         pthread_t pthread[1];
         ok = (pthread_create(pthread, NULL, init_thread, (void*)(&i)) == 0);
+        pthread_detach(pthread[0]);
 #else
         ok = (CreateThread(NULL, 0, init_thread, (LPVOID)(&i), 0, NULL) != NULL);
 #endif
@@ -2443,9 +2452,8 @@ split_point_start: // At split points actual search starts from here
   // split point objects), the function immediately returns. If splitting is
   // possible, a SplitPoint object is initialized with all the data that must be
   // copied to the helper threads and we tell our helper threads that they have
-  // been assigned work. This will cause them to instantly leave their idle loops
-  // and call sp_search(). When all threads have returned from sp_search() then
-  // split() returns.
+  // been assigned work. This will cause them to instantly leave their idle loops and
+  // call search().When all threads have returned from search() then split() returns.
 
   template <bool Fake>
   void ThreadsManager::split(const Position& p, SearchStack* ss, int ply, Value* alpha,
@@ -2576,7 +2584,7 @@ split_point_start: // At split points actual search starts from here
 
     // Initialize search stack
     init_ss_array(ss, PLY_MAX_PLUS_2);
-    ss[0].eval = VALUE_NONE;
+    ss[0].eval = ss[0].evalMargin = VALUE_NONE;
     count = 0;
 
     // Generate all legal moves