From: Marco Costalba <mcostalba@gmail.com>
Date: Sun, 30 Nov 2014 07:38:46 +0000 (+0100)
Subject: Refactor syzygy code in search
X-Git-Url: https://git.sesse.net/?p=stockfish;a=commitdiff_plain;h=c30eb4c9c9f875a8302056ddd9612003bc21c023

Refactor syzygy code in search

Move to SF coding style.

Also skip calculating piece count in search()
when TB are not found (!TBCardinality)

No functional change.
---

diff --git a/src/search.cpp b/src/search.cpp
index 0130e85f..5c22e512 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -188,13 +188,24 @@ template uint64_t Search::perft<true>(Position& pos, Depth depth);
 void Search::think() {
 
   TimeMgr.init(Limits, RootPos.game_ply(), RootPos.side_to_move());
-  TBHits = TBCardinality = 0;
-  RootInTB = false;
 
   int cf = Options["Contempt"] * PawnValueEg / 100; // From centipawns
   DrawValue[ RootPos.side_to_move()] = VALUE_DRAW - Value(cf);
   DrawValue[~RootPos.side_to_move()] = VALUE_DRAW + Value(cf);
 
+  TBHits = 0;
+  RootInTB = false;
+  TBProbeDepth  = Options["SyzygyProbeDepth"] * ONE_PLY;
+  TB50MoveRule  = Options["Syzygy50MoveRule"];
+  TBCardinality = Options["SyzygyProbeLimit"];
+
+  // Skip TB probing when no TB found: !TBLargest -> !TBCardinality
+  if (TBCardinality > Tablebases::TBLargest)
+  {
+      TBCardinality = Tablebases::TBLargest;
+      TBProbeDepth = DEPTH_ZERO;
+  }
+
   if (RootMoves.empty())
   {
       RootMoves.push_back(MOVE_NONE);
@@ -204,36 +215,16 @@ void Search::think() {
   }
   else
   {
-      // Check Tablebases at root
-      int piecesCnt = RootPos.count<ALL_PIECES>(WHITE) + RootPos.count<ALL_PIECES>(BLACK);
-      TBCardinality = Options["SyzygyProbeLimit"];
-      TBProbeDepth = Options["SyzygyProbeDepth"] * ONE_PLY;
-      if (TBCardinality > Tablebases::TBLargest)
+      if (TBCardinality >=  RootPos.count<ALL_PIECES>(WHITE)
+                          + RootPos.count<ALL_PIECES>(BLACK))
       {
-          TBCardinality = Tablebases::TBLargest;
-          TBProbeDepth = 0 * ONE_PLY;
-      }
-      TB50MoveRule = Options["Syzygy50MoveRule"];
-
-      if (piecesCnt <= TBCardinality)
-      {
-          TBHits = RootMoves.size();
-
           // If the current root position is in the tablebases then RootMoves
           // contains only moves that preserve the draw or win.
           RootInTB = Tablebases::root_probe(RootPos, TBScore);
 
           if (RootInTB)
-          {
               TBCardinality = 0; // Do not probe tablebases during the search
 
-              // It might be a good idea to mangle the hash key (xor it
-              // with a fixed value) in order to "clear" the hash table of
-              // the results of previous probes. However, that would have to
-              // be done from within the Position class, so we skip it for now.
-
-              // Optional: decrease target time.
-          }
           else // If DTZ tables are missing, use WDL tables as a fallback
           {
               // Filter out moves that do not preserve a draw or win
@@ -244,15 +235,14 @@ void Search::think() {
                   TBCardinality = 0;
           }
 
-          if (!RootInTB)
-          {
-              TBHits = 0;
-          }
-          else if (!TB50MoveRule)
+          if (RootInTB)
           {
-              TBScore = TBScore > VALUE_DRAW ? VALUE_MATE - MAX_PLY - 1
-                      : TBScore < VALUE_DRAW ? -VALUE_MATE + MAX_PLY + 1
-                      : TBScore;
+              TBHits = RootMoves.size();
+
+              if (!TB50MoveRule)
+                  TBScore =  TBScore > VALUE_DRAW ?  VALUE_MATE - MAX_PLY - 1
+                           : TBScore < VALUE_DRAW ? -VALUE_MATE + MAX_PLY + 1
+                                                  :  VALUE_DRAW;
           }
       }
 
@@ -470,7 +460,6 @@ namespace {
     bool inCheck, givesCheck, singularExtensionNode, improving;
     bool captureOrPromotion, dangerous, doFullDepthSearch;
     int moveCount, quietCount;
-    int piecesCnt;
 
     // Step 1. Initialize node
     Thread* thisThread = pos.this_thread();
@@ -549,35 +538,37 @@ namespace {
     }
 
     // Step 4a. Tablebase probe
-    piecesCnt = pos.count<ALL_PIECES>(WHITE) + pos.count<ALL_PIECES>(BLACK);
-
-    if (   !RootNode
-        &&  piecesCnt <= TBCardinality
-        && (piecesCnt < TBCardinality || depth >= TBProbeDepth)
-        &&  pos.rule50_count() == 0)
+    if (!RootNode && TBCardinality)
     {
-        int found, v = Tablebases::probe_wdl(pos, &found);
+        int piecesCnt = pos.count<ALL_PIECES>(WHITE) + pos.count<ALL_PIECES>(BLACK);
 
-        if (found)
+        if (    piecesCnt <= TBCardinality
+            && (piecesCnt < TBCardinality || depth >= TBProbeDepth)
+            &&  pos.rule50_count() == 0)
         {
-            TBHits++;
+            int found, v = Tablebases::probe_wdl(pos, &found);
 
-            if (TB50MoveRule) {
-                value = v < -1 ? -VALUE_MATE + MAX_PLY + ss->ply
-                      : v >  1 ?  VALUE_MATE - MAX_PLY - ss->ply
-                      : VALUE_DRAW + 2 * v;
-            }
-            else
+            if (found)
             {
-                value = v < 0 ? -VALUE_MATE + MAX_PLY + ss->ply
-                      : v > 0 ?  VALUE_MATE - MAX_PLY - ss->ply
-                      : VALUE_DRAW;
-            }
+                TBHits++;
 
-            TT.store(posKey, value_to_tt(value, ss->ply), BOUND_EXACT,
-                     std::min(DEPTH_MAX - ONE_PLY, depth + 6 * ONE_PLY), MOVE_NONE, VALUE_NONE);
+                if (TB50MoveRule) {
+                    value = v < -1 ? -VALUE_MATE + MAX_PLY + ss->ply
+                                   : v >  1 ?  VALUE_MATE - MAX_PLY - ss->ply
+                                             : VALUE_DRAW + 2 * v;
+                }
+                else
+                {
+                    value = v < 0 ? -VALUE_MATE + MAX_PLY + ss->ply
+                                  : v > 0 ?  VALUE_MATE - MAX_PLY - ss->ply
+                                           : VALUE_DRAW;
+                }
+
+                TT.store(posKey, value_to_tt(value, ss->ply), BOUND_EXACT,
+                         std::min(DEPTH_MAX - ONE_PLY, depth + 6 * ONE_PLY), MOVE_NONE, VALUE_NONE);
 
-            return value;
+                return value;
+            }
         }
     }