Do not pass threadID as argument of search() and evaluate()

Get it from the position instead.

A good semplification of function calling and a speedup too.

No functional change also with faked split.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index 64760d4da5d206f7efc4ac6535fb0b0266cf261a..b9f9ff505098acc04f7c221fb46779af34bcd5a1 100644 (file)
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -240,7 +240,7 @@ namespace {
 
   // Function prototypes
   template<bool HasPopCnt>
 
   // Function prototypes
   template<bool HasPopCnt>

-  Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID);
+  Value do_evaluate(const Position& pos, EvalInfo& ei);

 
   template<Color Us, bool HasPopCnt>
   void init_attack_tables(const Position& pos, EvalInfo& ei);
 
   template<Color Us, bool HasPopCnt>
   void init_attack_tables(const Position& pos, EvalInfo& ei);


@@ -277,21 +277,21 @@ namespace {
 /// evaluate() is the main evaluation function. It always computes two
 /// values, an endgame score and a middle game score, and interpolates
 /// between them based on the remaining material.
 /// evaluate() is the main evaluation function. It always computes two
 /// values, an endgame score and a middle game score, and interpolates
 /// between them based on the remaining material.

-Value evaluate(const Position& pos, EvalInfo& ei, int threadID) {
+Value evaluate(const Position& pos, EvalInfo& ei) {

 
 

-    return CpuHasPOPCNT ? do_evaluate<true>(pos, ei, threadID)
-                        : do_evaluate<false>(pos, ei, threadID);
+    return CpuHasPOPCNT ? do_evaluate<true>(pos, ei)
+                        : do_evaluate<false>(pos, ei);

 }
 
 namespace {
 
 template<bool HasPopCnt>
 }
 
 namespace {
 
 template<bool HasPopCnt>

-Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
+Value do_evaluate(const Position& pos, EvalInfo& ei) {

 
   ScaleFactor factor[2];
 
   assert(pos.is_ok());
 
   ScaleFactor factor[2];
 
   assert(pos.is_ok());

-  assert(threadID >= 0 && threadID < MAX_THREADS);
+  assert(pos.thread() >= 0 && pos.thread() < MAX_THREADS);

   assert(!pos.is_check());
 
   memset(&ei, 0, sizeof(EvalInfo));
   assert(!pos.is_check());
 
   memset(&ei, 0, sizeof(EvalInfo));


@@ -301,7 +301,7 @@ Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
   ei.value = pos.value();
 
   // Probe the material hash table
   ei.value = pos.value();
 
   // Probe the material hash table

-  ei.mi = MaterialTable[threadID]->get_material_info(pos);
+  ei.mi = MaterialTable[pos.thread()]->get_material_info(pos);

   ei.value += ei.mi->material_value();
 
   // If we have a specialized evaluation function for the current material
   ei.value += ei.mi->material_value();
 
   // If we have a specialized evaluation function for the current material


@@ -314,7 +314,7 @@ Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
   factor[BLACK] = ei.mi->scale_factor(pos, BLACK);
 
   // Probe the pawn hash table
   factor[BLACK] = ei.mi->scale_factor(pos, BLACK);
 
   // Probe the pawn hash table

-  ei.pi = PawnTable[threadID]->get_pawn_info(pos);
+  ei.pi = PawnTable[pos.thread()]->get_pawn_info(pos);

   ei.value += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
 
   // Initialize attack bitboards with pawns evaluation
   ei.value += apply_weight(ei.pi->pawns_value(), Weights[PawnStructure]);
 
   // Initialize attack bitboards with pawns evaluation

diff --git a/src/evaluate.h b/src/evaluate.h
index dcfa74e8f08638bd6a31c589465ca4b2a56e631f..754d52f618621131867fcd04ec967fb33412b386 100644 (file)
--- a/src/evaluate.h
+++ b/src/evaluate.h
@@ -101,7 +101,7 @@ struct EvalInfo {
 //// Prototypes
 ////
 
 //// Prototypes
 ////
 

-extern Value evaluate(const Position& pos, EvalInfo& ei, int threadID);
+extern Value evaluate(const Position& pos, EvalInfo& ei);

 extern void init_eval(int threads);
 extern void quit_eval();
 extern void read_weights(Color sideToMove);
 extern void init_eval(int threads);
 extern void quit_eval();
 extern void read_weights(Color sideToMove);

diff --git a/src/search.cpp b/src/search.cpp
index f7595eeb2ced963358a6d73ba1815707e2b52283..8fa1a37928399d45da5d8bf4173e7bbe20f7d08a 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -90,7 +90,7 @@ namespace {
 
     template <bool Fake>
     void split(const Position& pos, SearchStack* ss, Value* alpha, const Value beta, Value* bestValue,
 
     template <bool Fake>
     void split(const Position& pos, SearchStack* ss, Value* alpha, const Value beta, Value* bestValue,

-               Depth depth, bool mateThreat, int* moveCount, MovePicker* mp, int master, bool pvNode);
+               Depth depth, bool mateThreat, int* moveCount, MovePicker* mp, bool pvNode);

 
   private:
     friend void poll();
 
   private:
     friend void poll();


@@ -285,10 +285,10 @@ namespace {
   Value root_search(Position& pos, SearchStack* ss, RootMoveList& rml, Value* alphaPtr, Value* betaPtr);
 
   template <NodeType PvNode>
   Value root_search(Position& pos, SearchStack* ss, RootMoveList& rml, Value* alphaPtr, Value* betaPtr);
 
   template <NodeType PvNode>

-  Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int threadID);
+  Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth);

 
   template <NodeType PvNode>
 
   template <NodeType PvNode>

-  Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int threadID);
+  Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth);

 
   template <NodeType PvNode>
   void sp_search(SplitPoint* sp, int threadID);
 
   template <NodeType PvNode>
   void sp_search(SplitPoint* sp, int threadID);


@@ -811,7 +811,7 @@ namespace {
     // Step 5. Evaluate the position statically
     // At root we do this only to get reference value for child nodes
     if (!isCheck)
     // Step 5. Evaluate the position statically
     // At root we do this only to get reference value for child nodes
     if (!isCheck)

-        ss->eval = evaluate(pos, ei, 0);
+        ss->eval = evaluate(pos, ei);

 
     // Step 6. Razoring (omitted at root)
     // Step 7. Static null move pruning (omitted at root)
 
     // Step 6. Razoring (omitted at root)
     // Step 7. Static null move pruning (omitted at root)


@@ -876,7 +876,7 @@ namespace {
                         alpha = -VALUE_INFINITE;
 
                     // Full depth PV search, done on first move or after a fail high
                         alpha = -VALUE_INFINITE;
 
                     // Full depth PV search, done on first move or after a fail high

-                    value = -search<PV>(pos, ss+1, -beta, -alpha, newDepth, 0);
+                    value = -search<PV>(pos, ss+1, -beta, -alpha, newDepth);

                 }
                 else
                 {
                 }
                 else
                 {


@@ -893,7 +893,7 @@ namespace {
                         if (ss->reduction)
                         {
                             // Reduced depth non-pv search using alpha as upperbound
                         if (ss->reduction)
                         {
                             // Reduced depth non-pv search using alpha as upperbound

-                            value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 0);
+                            value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction);

                             doFullDepthSearch = (value > alpha);
                         }
                     }
                             doFullDepthSearch = (value > alpha);
                         }
                     }


@@ -903,12 +903,12 @@ namespace {
                     {
                         // Full depth non-pv search using alpha as upperbound
                         ss->reduction = Depth(0);
                     {
                         // Full depth non-pv search using alpha as upperbound
                         ss->reduction = Depth(0);

-                        value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth, 0);
+                        value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth);

 
                         // If we are above alpha then research at same depth but as PV
                         // to get a correct score or eventually a fail high above beta.
                         if (value > alpha)
 
                         // If we are above alpha then research at same depth but as PV
                         // to get a correct score or eventually a fail high above beta.
                         if (value > alpha)

-                            value = -search<PV>(pos, ss+1, -beta, -alpha, newDepth, 0);
+                            value = -search<PV>(pos, ss+1, -beta, -alpha, newDepth);

                     }
                 }
 
                     }
                 }
 


@@ -1031,13 +1031,13 @@ namespace {
   // search<>() is the main search function for both PV and non-PV nodes
 
   template <NodeType PvNode>
   // search<>() is the main search function for both PV and non-PV nodes
 
   template <NodeType PvNode>

-  Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int threadID) {
+  Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth) {

 
     assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE);
     assert(beta > alpha && beta <= VALUE_INFINITE);
     assert(PvNode || alpha == beta - 1);
     assert(pos.ply() > 0 && pos.ply() < PLY_MAX);
 
     assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE);
     assert(beta > alpha && beta <= VALUE_INFINITE);
     assert(PvNode || alpha == beta - 1);
     assert(pos.ply() > 0 && pos.ply() < PLY_MAX);

-    assert(threadID >= 0 && threadID < TM.active_threads());
+    assert(pos.thread() >= 0 && pos.thread() < TM.active_threads());

 
     Move movesSearched[256];
     EvalInfo ei;
 
     Move movesSearched[256];
     EvalInfo ei;


@@ -1051,6 +1051,7 @@ namespace {
     bool isCheck, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
     bool mateThreat = false;
     int moveCount = 0;
     bool isCheck, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
     bool mateThreat = false;
     int moveCount = 0;

+    int threadID = pos.thread();

     int ply = pos.ply();
     refinedValue = bestValue = value = -VALUE_INFINITE;
     oldAlpha = alpha;
     int ply = pos.ply();
     refinedValue = bestValue = value = -VALUE_INFINITE;
     oldAlpha = alpha;


@@ -1117,7 +1118,7 @@ namespace {
             ei.kingDanger[pos.side_to_move()] = tte->king_danger();
         }
         else
             ei.kingDanger[pos.side_to_move()] = tte->king_danger();
         }
         else

-            ss->eval = evaluate(pos, ei, threadID);
+            ss->eval = evaluate(pos, ei);

 
         refinedValue = refine_eval(tte, ss->eval, ply); // Enhance accuracy with TT value if possible
         update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval);
 
         refinedValue = refine_eval(tte, ss->eval, ply); // Enhance accuracy with TT value if possible
         update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval);


@@ -1134,7 +1135,7 @@ namespace {
         && !pos.has_pawn_on_7th(pos.side_to_move()))
     {
         Value rbeta = beta - razor_margin(depth);
         && !pos.has_pawn_on_7th(pos.side_to_move()))
     {
         Value rbeta = beta - razor_margin(depth);

-        Value v = qsearch<NonPV>(pos, ss, rbeta-1, rbeta, Depth(0), threadID);
+        Value v = qsearch<NonPV>(pos, ss, rbeta-1, rbeta, Depth(0));

         if (v < rbeta)
             // Logically we should return (v + razor_margin(depth)), but
             // surprisingly this did slightly weaker in tests.
         if (v < rbeta)
             // Logically we should return (v + razor_margin(depth)), but
             // surprisingly this did slightly weaker in tests.


@@ -1175,14 +1176,11 @@ namespace {
             R++;
 
         pos.do_null_move(st);
             R++;
 
         pos.do_null_move(st);

-

         (ss+1)->skipNullMove = true;
 
         (ss+1)->skipNullMove = true;
 

-        nullValue = depth-R*OnePly < OnePly ? -qsearch<NonPV>(pos, ss+1, -beta, -alpha, Depth(0), threadID)
-                                            : - search<NonPV>(pos, ss+1, -beta, -alpha, depth-R*OnePly, threadID);
-
+        nullValue = depth-R*OnePly < OnePly ? -qsearch<NonPV>(pos, ss+1, -beta, -alpha, Depth(0))
+                                            : - search<NonPV>(pos, ss+1, -beta, -alpha, depth-R*OnePly);

         (ss+1)->skipNullMove = false;
         (ss+1)->skipNullMove = false;

-

         pos.undo_null_move();
 
         if (nullValue >= beta)
         pos.undo_null_move();
 
         if (nullValue >= beta)


@@ -1196,10 +1194,10 @@ namespace {
                 return nullValue;
 
             ss->skipNullMove = true;
                 return nullValue;
 
             ss->skipNullMove = true;

-            Value v = search<NonPV>(pos, ss, alpha, beta, depth-5*OnePly, threadID);
+            Value v = search<NonPV>(pos, ss, alpha, beta, depth-5*OnePly);

             ss->skipNullMove = false;
 
             ss->skipNullMove = false;
 

-            if (v  >= beta)
+            if (v >= beta)

                 return nullValue;
         }
         else
                 return nullValue;
         }
         else


@@ -1229,7 +1227,7 @@ namespace {
         Depth d = (PvNode ? depth - 2 * OnePly : depth / 2);
 
         ss->skipNullMove = true;
         Depth d = (PvNode ? depth - 2 * OnePly : depth / 2);
 
         ss->skipNullMove = true;

-        search<PvNode>(pos, ss, alpha, beta, d, threadID);
+        search<PvNode>(pos, ss, alpha, beta, d);

         ss->skipNullMove = false;
 
         ttMove = ss->pv[ply];
         ss->skipNullMove = false;
 
         ttMove = ss->pv[ply];


@@ -1281,7 +1279,7 @@ namespace {
               Value b = ttValue - SingularExtensionMargin;
               ss->excludedMove = move;
               ss->skipNullMove = true;
               Value b = ttValue - SingularExtensionMargin;
               ss->excludedMove = move;
               ss->skipNullMove = true;

-              Value v = search<NonPV>(pos, ss, b - 1, b, depth / 2, threadID);
+              Value v = search<NonPV>(pos, ss, b - 1, b, depth / 2);

               ss->skipNullMove = false;
               ss->excludedMove = MOVE_NONE;
 
               ss->skipNullMove = false;
               ss->excludedMove = MOVE_NONE;
 


@@ -1330,8 +1328,8 @@ namespace {
       // Step extra. pv search (only in PV nodes)
       // The first move in list is the expected PV
       if (PvNode && moveCount == 1)
       // Step extra. pv search (only in PV nodes)
       // The first move in list is the expected PV
       if (PvNode && moveCount == 1)

-          value = newDepth < OnePly ? -qsearch<PV>(pos, ss+1, -beta, -alpha, Depth(0), threadID)
-                                    : - search<PV>(pos, ss+1, -beta, -alpha, newDepth, threadID);
+          value = newDepth < OnePly ? -qsearch<PV>(pos, ss+1, -beta, -alpha, Depth(0))
+                                    : - search<PV>(pos, ss+1, -beta, -alpha, newDepth);

       else
       {
           // Step 14. Reduced depth search
       else
       {
           // Step 14. Reduced depth search


@@ -1348,8 +1346,8 @@ namespace {
               if (ss->reduction)
               {
                   Depth d = newDepth - ss->reduction;
               if (ss->reduction)
               {
                   Depth d = newDepth - ss->reduction;

-                  value = d < OnePly ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, Depth(0), threadID)
-                                     : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, threadID);
+                  value = d < OnePly ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, Depth(0))
+                                     : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d);

 
                   doFullDepthSearch = (value > alpha);
               }
 
                   doFullDepthSearch = (value > alpha);
               }


@@ -1362,7 +1360,7 @@ namespace {
                   assert(newDepth - OnePly >= OnePly);
 
                   ss->reduction = OnePly;
                   assert(newDepth - OnePly >= OnePly);
 
                   ss->reduction = OnePly;

-                  value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, threadID);
+                  value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction);

                   doFullDepthSearch = (value > alpha);
               }
               ss->reduction = Depth(0); // Restore original reduction
                   doFullDepthSearch = (value > alpha);
               }
               ss->reduction = Depth(0); // Restore original reduction


@@ -1371,15 +1369,15 @@ namespace {
           // Step 15. Full depth search
           if (doFullDepthSearch)
           {
           // Step 15. Full depth search
           if (doFullDepthSearch)
           {

-              value = newDepth < OnePly ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, Depth(0), threadID)
-                                        : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth, threadID);
+              value = newDepth < OnePly ? -qsearch<NonPV>(pos, ss+1, -(alpha+1), -alpha, Depth(0))
+                                        : - search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth);

 
               // Step extra. pv search (only in PV nodes)
               // Search only for possible new PV nodes, if instead value >= beta then
               // parent node fails low with value <= alpha and tries another move.
               if (PvNode && value > alpha && value < beta)
 
               // Step extra. pv search (only in PV nodes)
               // Search only for possible new PV nodes, if instead value >= beta then
               // parent node fails low with value <= alpha and tries another move.
               if (PvNode && value > alpha && value < beta)

-                  value = newDepth < OnePly ? -qsearch<PV>(pos, ss+1, -beta, -alpha, Depth(0), threadID)
-                                            : - search<PV>(pos, ss+1, -beta, -alpha, newDepth, threadID);
+                  value = newDepth < OnePly ? -qsearch<PV>(pos, ss+1, -beta, -alpha, Depth(0))
+                                            : - search<PV>(pos, ss+1, -beta, -alpha, newDepth);

           }
       }
 
           }
       }
 


@@ -1413,7 +1411,7 @@ namespace {
           && !TM.thread_should_stop(threadID)
           && Iteration <= 99)
           TM.split<FakeSplit>(pos, ss, &alpha, beta, &bestValue, depth,
           && !TM.thread_should_stop(threadID)
           && Iteration <= 99)
           TM.split<FakeSplit>(pos, ss, &alpha, beta, &bestValue, depth,

-                              mateThreat, &moveCount, &mp, threadID, PvNode);
+                              mateThreat, &moveCount, &mp, PvNode);

     }
 
     // Step 19. Check for mate and stalemate
     }
 
     // Step 19. Check for mate and stalemate


@@ -1457,14 +1455,14 @@ namespace {
   // less than OnePly).
 
   template <NodeType PvNode>
   // less than OnePly).
 
   template <NodeType PvNode>

-  Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int threadID) {
+  Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth) {

 
     assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE);
     assert(beta >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
     assert(PvNode || alpha == beta - 1);
     assert(depth <= 0);
     assert(pos.ply() > 0 && pos.ply() < PLY_MAX);
 
     assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE);
     assert(beta >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
     assert(PvNode || alpha == beta - 1);
     assert(depth <= 0);
     assert(pos.ply() > 0 && pos.ply() < PLY_MAX);

-    assert(threadID >= 0 && threadID < TM.active_threads());
+    assert(pos.thread() >= 0 && pos.thread() < TM.active_threads());

 
     EvalInfo ei;
     StateInfo st;
 
     EvalInfo ei;
     StateInfo st;


@@ -1476,7 +1474,7 @@ namespace {
     int ply = pos.ply();
     Value oldAlpha = alpha;
 
     int ply = pos.ply();
     Value oldAlpha = alpha;
 

-    TM.incrementNodeCounter(threadID);
+    TM.incrementNodeCounter(pos.thread());

     ss->init(ply);
 
     // Check for an instant draw or maximum ply reached
     ss->init(ply);
 
     // Check for an instant draw or maximum ply reached


@@ -1505,7 +1503,7 @@ namespace {
         ei.kingDanger[pos.side_to_move()] = tte->king_danger();
     }
     else
         ei.kingDanger[pos.side_to_move()] = tte->king_danger();
     }
     else

-        staticValue = evaluate(pos, ei, threadID);
+        staticValue = evaluate(pos, ei);

 
     if (!isCheck)
     {
 
     if (!isCheck)
     {


@@ -1591,7 +1589,7 @@ namespace {
 
       // Make and search the move
       pos.do_move(move, st, ci, moveIsCheck);
 
       // Make and search the move
       pos.do_move(move, st, ci, moveIsCheck);

-      value = -qsearch<PvNode>(pos, ss+1, -beta, -alpha, depth-OnePly, threadID);
+      value = -qsearch<PvNode>(pos, ss+1, -beta, -alpha, depth-OnePly);

       pos.undo_move(move);
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
       pos.undo_move(move);
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);


@@ -1739,8 +1737,8 @@ namespace {
           {
               Value localAlpha = sp->alpha;
               Depth d = newDepth - ss->reduction;
           {
               Value localAlpha = sp->alpha;
               Depth d = newDepth - ss->reduction;

-              value = d < OnePly ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, Depth(0), threadID)
-                                 : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, d, threadID);
+              value = d < OnePly ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, Depth(0))
+                                 : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, d);

               doFullDepthSearch = (value > localAlpha);
           }
 
               doFullDepthSearch = (value > localAlpha);
           }
 


@@ -1753,7 +1751,7 @@ namespace {
 
               ss->reduction = OnePly;
               Value localAlpha = sp->alpha;
 
               ss->reduction = OnePly;
               Value localAlpha = sp->alpha;

-              value = -search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, threadID);
+              value = -search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction);

               doFullDepthSearch = (value > localAlpha);
           }
           ss->reduction = Depth(0); // Restore original reduction
               doFullDepthSearch = (value > localAlpha);
           }
           ss->reduction = Depth(0); // Restore original reduction


@@ -1763,15 +1761,15 @@ namespace {
       if (doFullDepthSearch)
       {
           Value localAlpha = sp->alpha;
       if (doFullDepthSearch)
       {
           Value localAlpha = sp->alpha;

-          value = newDepth < OnePly ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, Depth(0), threadID)
-                                    : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth, threadID);
+          value = newDepth < OnePly ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, Depth(0))
+                                    : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth);

 
           // Step extra. pv search (only in PV nodes)
           // Search only for possible new PV nodes, if instead value >= beta then
           // parent node fails low with value <= alpha and tries another move.
           if (PvNode && value > localAlpha && value < sp->beta)
 
           // Step extra. pv search (only in PV nodes)
           // Search only for possible new PV nodes, if instead value >= beta then
           // parent node fails low with value <= alpha and tries another move.
           if (PvNode && value > localAlpha && value < sp->beta)

-              value = newDepth < OnePly ? -qsearch<PV>(pos, ss+1, -sp->beta, -sp->alpha, Depth(0), threadID)
-                                        : - search<PV>(pos, ss+1, -sp->beta, -sp->alpha, newDepth, threadID);
+              value = newDepth < OnePly ? -qsearch<PV>(pos, ss+1, -sp->beta, -sp->alpha, Depth(0))
+                                        : - search<PV>(pos, ss+1, -sp->beta, -sp->alpha, newDepth);

       }
 
       // Step 16. Undo move
       }
 
       // Step 16. Undo move


@@ -2621,16 +2619,18 @@ namespace {
   template <bool Fake>
   void ThreadsManager::split(const Position& p, SearchStack* ss, Value* alpha, const Value beta,
                              Value* bestValue, Depth depth, bool mateThreat, int* moveCount,
   template <bool Fake>
   void ThreadsManager::split(const Position& p, SearchStack* ss, Value* alpha, const Value beta,
                              Value* bestValue, Depth depth, bool mateThreat, int* moveCount,

-                             MovePicker* mp, int master, bool pvNode) {
+                             MovePicker* mp, bool pvNode) {

     assert(p.is_ok());
     assert(*bestValue >= -VALUE_INFINITE);
     assert(*bestValue <= *alpha);
     assert(*alpha < beta);
     assert(beta <= VALUE_INFINITE);
     assert(depth > Depth(0));
     assert(p.is_ok());
     assert(*bestValue >= -VALUE_INFINITE);
     assert(*bestValue <= *alpha);
     assert(*alpha < beta);
     assert(beta <= VALUE_INFINITE);
     assert(depth > Depth(0));

-    assert(master >= 0 && master < ActiveThreads);
+    assert(p.thread() >= 0 && p.thread() < ActiveThreads);

     assert(ActiveThreads > 1);
 
     assert(ActiveThreads > 1);
 

+    int master = p.thread();
+

     lock_grab(&MPLock);
 
     // If no other thread is available to help us, or if we have too many
     lock_grab(&MPLock);
 
     // If no other thread is available to help us, or if we have too many


@@ -2782,7 +2782,7 @@ namespace {
         init_ss_array(ss, PLY_MAX_PLUS_2);
         pos.do_move(cur->move, st);
         moves[count].move = cur->move;
         init_ss_array(ss, PLY_MAX_PLUS_2);
         pos.do_move(cur->move, st);
         moves[count].move = cur->move;

-        moves[count].score = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, Depth(0), 0);
+        moves[count].score = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, Depth(0));

         moves[count].pv[0] = cur->move;
         moves[count].pv[1] = MOVE_NONE;
         pos.undo_move(cur->move);
         moves[count].pv[0] = cur->move;
         moves[count].pv[1] = MOVE_NONE;
         pos.undo_move(cur->move);

diff --git a/src/uci.cpp b/src/uci.cpp
index 88c1229e320ea804c4ef277f29c7c0d4da95013c..fdc220014a44cadc7924f94490218e4d52614c13 100644 (file)
--- a/src/uci.cpp
+++ b/src/uci.cpp
@@ -151,7 +151,7 @@ namespace {
         EvalInfo ei;
         cout << "Incremental mg: " << mg_value(RootPosition.value())
              << "\nIncremental eg: " << eg_value(RootPosition.value())
         EvalInfo ei;
         cout << "Incremental mg: " << mg_value(RootPosition.value())
              << "\nIncremental eg: " << eg_value(RootPosition.value())

-             << "\nFull eval: " << evaluate(RootPosition, ei, 0) << endl;
+             << "\nFull eval: " << evaluate(RootPosition, ei) << endl;

     }
     else if (token == "key")
         cout << "key: " << hex << RootPosition.get_key()
     }
     else if (token == "key")
         cout << "key: " << hex << RootPosition.get_key()