Rewrite messy LSN-code

[stockfish] / src / search.cpp

diff --git a/src/search.cpp b/src/search.cpp
index 4ea010728574e04c80f0112a388c610185845a46..24ae2f631227ee0c412a31e21c44a8151dd74f26 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -119,7 +119,6 @@ namespace {
     inline Move get_move_pv(int moveNum, int i) const;
     inline int64_t get_move_cumulative_nodes(int moveNum) const;
     inline int move_count() const;
-    Move scan_for_easy_move() const;
     inline void sort();
     void sort_multipv(int n);
 
@@ -527,23 +526,41 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
               << " moves to go: " << movesToGo << std::endl;
 
 
-  // We're ready to start thinking. Call the iterative deepening loop function
-  //
-  // FIXME we really need to cleanup all this LSN ugliness
-  if (!loseOnTime)
+  // LSN filtering. Used only for developing purpose. Disabled by default.
+  if (UseLSNFiltering)
   {
-      Value v = id_loop(pos, searchMoves);
-      loseOnTime = (   UseLSNFiltering
-                    && myTime < LSNTime
-                    && myIncrement == 0
-                    && v < -LSNValue);
+      // Step 2. If after last move we decided to lose on time, do it now!
+      if (   loseOnTime
+          && myTime < LSNTime // double check: catches some very rear false positives!
+          && myIncrement == 0
+          && movesToGo == 0)
+      {
+          while (SearchStartTime + myTime + 1000 > get_system_time())
+              ; // wait here
+      } else if (loseOnTime) // false positive, reset flag
+          loseOnTime = false;
   }
-  else
+
+  // We're ready to start thinking. Call the iterative deepening loop function
+  Value v = id_loop(pos, searchMoves);
+
+  // LSN filtering. Used only for developing purpose. Disabled by default.
+  if (UseLSNFiltering)
   {
-      loseOnTime = false; // reset for next match
-      while (SearchStartTime + myTime + 1000 > get_system_time())
-          ; // wait here
-      id_loop(pos, searchMoves); // to fail gracefully
+      // Step 1. If this is sudden death game and our position is hopeless, decide to lose on time.
+      if (   !loseOnTime // If we already lost on time, go to step 3.
+          && myTime < LSNTime
+          && myIncrement == 0
+          && movesToGo == 0
+          && v < -LSNValue)
+      {
+          loseOnTime = true;
+      }
+      else if (loseOnTime)
+      {
+          // Step 3. Now after stepping over the time limit, reset flag for next match.
+          loseOnTime = false;
+      }
   }
 
   if (UseLogFile)
@@ -685,7 +702,11 @@ namespace {
     IterationInfo[1] = IterationInfoType(rml.get_move_score(0), rml.get_move_score(0));
     Iteration = 1;
 
-    Move EasyMove = rml.scan_for_easy_move();
+    // Is one move significantly better than others after initial scoring ?
+    Move EasyMove = MOVE_NONE;
+    if (   rml.move_count() == 1
+        || rml.get_move_score(0) > rml.get_move_score(1) + EasyMoveMargin)
+        EasyMove = rml.get_move(0);
 
     // Iterative deepening loop
     while (Iteration < PLY_MAX)
@@ -2169,28 +2190,6 @@ namespace {
   }
 
 
-  // RootMoveList::scan_for_easy_move() is called at the end of the first
-  // iteration, and is used to detect an "easy move", i.e. a move which appears
-  // to be much bester than all the rest.  If an easy move is found, the move
-  // is returned, otherwise the function returns MOVE_NONE.  It is very
-  // important that this function is called at the right moment:  The code
-  // assumes that the first iteration has been completed and the moves have
-  // been sorted. This is done in RootMoveList c'tor.
-
-  Move RootMoveList::scan_for_easy_move() const {
-
-    assert(count);
-
-    if (count == 1)
-        return get_move(0);
-
-    // moves are sorted so just consider the best and the second one
-    if (get_move_score(0) > get_move_score(1) + EasyMoveMargin)
-        return get_move(0);
-
-    return MOVE_NONE;
-  }
-
   // RootMoveList::sort() sorts the root move list at the beginning of a new
   // iteration.