Increase PV LMR to SF 1.8 levels

[stockfish] / src / search.cpp

diff --git a/src/search.cpp b/src/search.cpp
index 59c717caa9700e5412b9de78101d791dcd42c6d5..12481d4083bae3fc6d48cfb733938ec91acd595b 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -59,6 +59,10 @@ namespace {
   // Used for debugging SMP code.
   const bool FakeSplit = false;
 
+  // Fast lookup table of sliding pieces indexed by Piece
+  const bool Slidings[18] = { 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1 };
+  inline bool piece_is_slider(Piece p) { return Slidings[p]; }
+
   // ThreadsManager class is used to handle all the threads related stuff in search,
   // init, starting, parking and, the most important, launching a slave thread at a
   // split point are what this class does. All the access to shared thread data is
@@ -90,7 +94,7 @@ namespace {
     int ActiveThreads;
     volatile bool AllThreadsShouldExit;
     Thread threads[MAX_THREADS];
-    Lock MPLock;
+    Lock MPLock, WaitLock;
     WaitCondition WaitCond[MAX_THREADS];
   };
 
@@ -343,7 +347,7 @@ void init_search() {
   // Init reductions array
   for (hd = 1; hd < 64; hd++) for (mc = 1; mc < 64; mc++)
   {
-      double    pvRed = 0.33 + log(double(hd)) * log(double(mc)) / 4.5;
+      double    pvRed = log(double(hd)) * log(double(mc)) / 3.0;
       double nonPVRed = 0.33 + log(double(hd)) * log(double(mc)) / 2.25;
       ReductionMatrix[PV][hd][mc]    = (int8_t) (   pvRed >= 1.0 ? floor(   pvRed * int(ONE_PLY)) : 0);
       ReductionMatrix[NonPV][hd][mc] = (int8_t) (nonPVRed >= 1.0 ? floor(nonPVRed * int(ONE_PLY)) : 0);
@@ -465,6 +469,10 @@ bool think(Position& pos, bool infinite, bool ponder, int time[], int increment[
       init_eval(ThreadsMgr.active_threads());
   }
 
+  // Wake up needed threads
+  for (int i = 1; i < newActiveThreads; i++)
+      ThreadsMgr.wake_sleeping_thread(i);
+
   // Set thinking time
   int myTime = time[pos.side_to_move()];
   int myIncrement = increment[pos.side_to_move()];
@@ -497,6 +505,9 @@ bool think(Position& pos, bool infinite, bool ponder, int time[], int increment[
   if (UseLogFile)
       LogFile.close();
 
+  // This makes all the threads to go to sleep
+  ThreadsMgr.set_active_threads(1);
+
   return !Quit;
 }
 
@@ -650,7 +661,7 @@ namespace {
              << " time " << current_search_time() << endl;
 
     // Print the best move and the ponder move to the standard output
-    if (pv[0] == MOVE_NONE)
+    if (pv[0] == MOVE_NONE || MultiPV > 1)
     {
         pv[0] = rml.move(0);
         pv[1] = MOVE_NONE;
@@ -1059,7 +1070,6 @@ namespace {
         && !isCheck
         &&  refinedValue < beta - razor_margin(depth)
         &&  ttMove == MOVE_NONE
-        &&  (ss-1)->currentMove != MOVE_NULL
         && !value_is_mate(beta)
         && !pos.has_pawn_on_7th(pos.side_to_move()))
     {
@@ -1276,6 +1286,17 @@ split_point_start: // At split points actual search starts from here
 
               continue;
           }
+
+          // Prune neg. see moves at low depths
+          if (   predictedDepth < 2 * ONE_PLY
+              && bestValue > value_mated_in(PLY_MAX)
+              && pos.see_sign(move) < 0)
+          {
+              if (SpNode)
+                  lock_grab(&(sp->lock));
+
+              continue;
+          }
       }
 
       // Step 13. Make the move
@@ -1930,7 +1951,7 @@ split_point_start: // At split points actual search starts from here
     int t = current_search_time();
 
     //  Poll for input
-    if (Bioskey())
+    if (data_available())
     {
         // We are line oriented, don't read single chars
         std::string command;
@@ -2191,9 +2212,7 @@ split_point_start: // At split points actual search starts from here
 
         // If we are not thinking, wait for a condition to be signaled
         // instead of wasting CPU time polling for work.
-        while (   threadID >= ActiveThreads
-               || threads[threadID].state == THREAD_INITIALIZING
-               || (!sp && threads[threadID].state == THREAD_AVAILABLE))
+        while (threadID >= ActiveThreads || threads[threadID].state == THREAD_INITIALIZING)
         {
             assert(!sp);
             assert(threadID != 0);
@@ -2201,21 +2220,14 @@ split_point_start: // At split points actual search starts from here
             if (AllThreadsShouldExit)
                 break;
 
-            lock_grab(&MPLock);
+            threads[threadID].state = THREAD_AVAILABLE;
 
-            // Retest condition under lock protection
-            if (!(   threadID >= ActiveThreads
-                  || threads[threadID].state == THREAD_INITIALIZING
-                  || (!sp && threads[threadID].state == THREAD_AVAILABLE)))
-            {
-                lock_release(&MPLock);
-                continue;
-            }
+            lock_grab(&WaitLock);
 
-            // Put thread to sleep
-            threads[threadID].state = THREAD_AVAILABLE;
-            cond_wait(&WaitCond[threadID], &MPLock);
-            lock_release(&MPLock);
+            if (threadID >= ActiveThreads || threads[threadID].state == THREAD_INITIALIZING)
+                cond_wait(&WaitCond[threadID], &WaitLock);
+
+            lock_release(&WaitLock);
         }
 
         // If this thread has been assigned work, launch a search
@@ -2275,6 +2287,7 @@ split_point_start: // At split points actual search starts from here
 
     // Initialize global locks
     lock_init(&MPLock);
+    lock_init(&WaitLock);
 
     for (i = 0; i < MAX_THREADS; i++)
         cond_init(&WaitCond[i]);
@@ -2310,7 +2323,7 @@ split_point_start: // At split points actual search starts from here
         if (!ok)
         {
             cout << "Failed to create thread number " << i << endl;
-            Application::exit_with_failure();
+            exit(EXIT_FAILURE);
         }
 
         // Wait until the thread has finished launching and is gone to sleep
@@ -2338,6 +2351,7 @@ split_point_start: // At split points actual search starts from here
         for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
             lock_destroy(&(threads[i].splitPoints[j].lock));
 
+    lock_destroy(&WaitLock);
     lock_destroy(&MPLock);
 
     // Now we can safely destroy the wait conditions
@@ -2503,8 +2517,6 @@ split_point_start: // At split points actual search starts from here
             assert(i == master || threads[i].state == THREAD_BOOKED);
 
             threads[i].state = THREAD_WORKISWAITING; // This makes the slave to exit from idle_loop()
-            if (i != master)
-                wake_sleeping_thread(i);
         }
 
     // Everything is set up. The master thread enters the idle loop, from
@@ -2533,9 +2545,9 @@ split_point_start: // At split points actual search starts from here
 
   void ThreadsManager::wake_sleeping_thread(int threadID) {
 
-     lock_grab(&MPLock);
+     lock_grab(&WaitLock);
      cond_signal(&WaitCond[threadID]);
-     lock_release(&MPLock);
+     lock_release(&WaitLock);
   }