Fix a couple of new MSVC 2010 warnings

[stockfish] / src / search.cpp

diff --git a/src/search.cpp b/src/search.cpp
index e1ac91c3f58e6a3a22f07477ed62b3c893bb9f9d..387c92b01acc2021b2103aaa9b78bfafff281108 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -150,6 +150,23 @@ namespace {
   // Depth limit for razoring
   const Depth RazorDepth = 4 * OnePly;
 
+  /// Lookup tables initialized at startup
+
+  // Reduction lookup tables and their getter functions
+  int8_t    PVReductionMatrix[64][64]; // [depth][moveNumber]
+  int8_t NonPVReductionMatrix[64][64]; // [depth][moveNumber]
+
+  inline Depth    pv_reduction(Depth d, int mn) { return (Depth)    PVReductionMatrix[Min(d / 2, 63)][Min(mn, 63)]; }
+  inline Depth nonpv_reduction(Depth d, int mn) { return (Depth) NonPVReductionMatrix[Min(d / 2, 63)][Min(mn, 63)]; }
+
+  // Futility lookup tables and their getter functions
+  const Value FutilityMarginQS = Value(0x80);
+  int32_t FutilityMarginsMatrix[14][64]; // [depth][moveNumber]
+  int FutilityMoveCountArray[32]; // [depth]
+
+  inline Value futility_margin(Depth d, int mn) { return Value(d < 7*OnePly ? FutilityMarginsMatrix[Max(d, 0)][Min(mn, 63)] : 2 * VALUE_INFINITE); }
+  inline int futility_move_count(Depth d) { return d < 16*OnePly ? FutilityMoveCountArray[d] : 512; }
+
   /// Variables initialized by UCI options
 
   // Depth limit for use of dynamic threat detection
@@ -195,22 +212,6 @@ namespace {
   bool UseLogFile;
   std::ofstream LogFile;
 
-  // Futility lookup tables and their getter functions
-  const Value FutilityMarginQS = Value(0x80);
-  int32_t FutilityMarginsMatrix[14][64]; // [depth][moveNumber]
-  int FutilityMoveCountArray[32]; // [depth]
-
-  inline Value futility_margin(Depth d, int mn) { return (Value) (d < 14? FutilityMarginsMatrix[Max(d, 0)][Min(mn, 63)] : 2*VALUE_INFINITE); }
-  inline int futility_move_count(Depth d) { return (d < 32? FutilityMoveCountArray[d] : 512); }
-
-  // Reduction lookup tables and their getter functions
-  // Initialized at startup
-  int8_t    PVReductionMatrix[64][64]; // [depth][moveNumber]
-  int8_t NonPVReductionMatrix[64][64]; // [depth][moveNumber]
-
-  inline Depth    pv_reduction(Depth d, int mn) { return (Depth)    PVReductionMatrix[Min(d / 2, 63)][Min(mn, 63)]; }
-  inline Depth nonpv_reduction(Depth d, int mn) { return (Depth) NonPVReductionMatrix[Min(d / 2, 63)][Min(mn, 63)]; }
-
   // MP related variables
   int ActiveThreads = 1;
   Depth MinimumSplitDepth;
@@ -526,21 +527,12 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
 }
 
 
-/// init_threads() is called during startup. It launches all helper threads,
-/// and initializes the split point stack and the global locks and condition
-/// objects.
-
-void init_threads() {
-
-  volatile int i;
-  bool ok;
+/// init_search() is called during startup. It initializes various lookup tables
 
-#if !defined(_MSC_VER)
-  pthread_t pthread[1];
-#endif
+void init_search() {
 
   // Init our reduction lookup tables
-  for (i = 1; i < 64; i++) // i == depth
+  for (int i = 1; i < 64; i++) // i == depth (OnePly = 1)
       for (int j = 1; j < 64; j++) // j == moveNumber
       {
           double    pvRed = 0.5 + log(double(i)) * log(double(j)) / 6.0;
@@ -550,15 +542,30 @@ void init_threads() {
       }
 
   // Init futility margins array
-  for (i = 0; i < 14; i++) // i == depth (OnePly = 2)
+  for (int i = 0; i < 14; i++) // i == depth (OnePly = 2)
       for (int j = 0; j < 64; j++) // j == moveNumber
       {
           FutilityMarginsMatrix[i][j] = (i < 2 ? 0 : 112 * bitScanReverse32(i * i / 2)) - 8 * j; // FIXME: test using log instead of BSR
       }
 
   // Init futility move count array
-  for (i = 0; i < 32; i++) // i == depth (OnePly = 2)
+  for (int i = 0; i < 32; i++) // i == depth (OnePly = 2)
       FutilityMoveCountArray[i] = 3 + (1 << (3 * i / 8));
+}
+
+
+/// init_threads() is called during startup. It launches all helper threads,
+/// and initializes the split point stack and the global locks and condition
+/// objects.
+
+void init_threads() {
+
+  volatile int i;
+  bool ok;
+
+#if !defined(_MSC_VER)
+  pthread_t pthread[1];
+#endif
 
   for (i = 0; i < THREAD_MAX; i++)
       Threads[i].activeSplitPoints = 0;
@@ -646,7 +653,6 @@ void SearchStack::init(int ply) {
   currentMove = threatMove = MOVE_NONE;
   reduction = Depth(0);
   eval = VALUE_NONE;
-  evalInfo = NULL;
 }
 
 void SearchStack::initKillers() {
@@ -1379,10 +1385,7 @@ namespace {
         if (tte && (tte->type() & VALUE_TYPE_EVAL))
             staticValue = value_from_tt(tte->value(), ply);
         else
-        {
             staticValue = evaluate(pos, ei, threadID);
-            ss[ply].evalInfo = &ei;
-        }
 
         ss[ply].eval = staticValue;
         futilityValue = staticValue + futility_margin(depth, 0); //FIXME: Remove me, only for split
@@ -1536,7 +1539,8 @@ namespace {
 
           // Value based pruning
           Depth predictedDepth = newDepth - nonpv_reduction(depth, moveCount); //FIXME: We are ignoring condition: depth >= 3*OnePly, BUG??
-          futilityValueScaled = ss[ply].eval + futility_margin(predictedDepth, moveCount) + H.gain(pos.piece_on(move_from(move)), move_to(move)) + 45;
+          futilityValueScaled =  ss[ply].eval + futility_margin(predictedDepth, moveCount)
+                               + H.gain(pos.piece_on(move_from(move)), move_to(move)) + 45;
 
           if (futilityValueScaled < beta)
           {