]> git.sesse.net Git - stockfish/blobdiff - src/search.cpp
Implement futility move count array
[stockfish] / src / search.cpp
index d54c7ebd91fbcc5379974d7556bf14a86fff2f8a..e1ac91c3f58e6a3a22f07477ed62b3c893bb9f9d 100644 (file)
@@ -53,26 +53,6 @@ namespace {
 
   /// Types
 
-  // IterationInfoType stores search results for each iteration
-  //
-  // Because we use relatively small (dynamic) aspiration window,
-  // there happens many fail highs and fail lows in root. And
-  // because we don't do researches in those cases, "value" stored
-  // here is not necessarily exact. Instead in case of fail high/low
-  // we guess what the right value might be and store our guess
-  // as a "speculated value" and then move on. Speculated values are
-  // used just to calculate aspiration window width, so also if are
-  // not exact is not big a problem.
-
-  struct IterationInfoType {
-
-    IterationInfoType(Value v = Value(0), Value sv = Value(0))
-    : value(v), speculatedValue(sv) {}
-
-    Value value, speculatedValue;
-  };
-
-
   // The BetaCounterType class is used to order moves at ply one.
   // Apart for the first one that has its score, following moves
   // normally have score -VALUE_INFINITE, so are ordered according
@@ -146,9 +126,6 @@ namespace {
   // Search depth at iteration 1
   const Depth InitialDepth = OnePly;
 
-  // Depth limit for selective search
-  const Depth SelectiveDepth = 7 * OnePly;
-
   // Use internal iterative deepening?
   const bool UseIIDAtPVNodes = true;
   const bool UseIIDAtNonPVNodes = true;
@@ -162,17 +139,6 @@ namespace {
   // better than the second best move.
   const Value EasyMoveMargin = Value(0x200);
 
-  // Problem margin. If the score of the first move at iteration N+1 has
-  // dropped by more than this since iteration N, the boolean variable
-  // "Problem" is set to true, which will make the program spend some extra
-  // time looking for a better move.
-  const Value ProblemMargin = Value(0x28);
-
-  // No problem margin. If the boolean "Problem" is true, and a new move
-  // is found at the root which is less than NoProblemMargin worse than the
-  // best move from the previous iteration, Problem is set back to false.
-  const Value NoProblemMargin = Value(0x14);
-
   // Null move margin. A null move search will not be done if the static
   // evaluation of the position is more than NullMoveMargin below beta.
   const Value NullMoveMargin = Value(0x200);
@@ -181,13 +147,6 @@ namespace {
   // remaining ones we will extend it.
   const Value SingleReplyMargin = Value(0x20);
 
-  // Margins for futility pruning in the quiescence search, and at frontier
-  // and near frontier nodes.
-  const Value FutilityMarginQS = Value(0x80);
-
-  // Each move futility margin is decreased
-  const Value IncrementalFutilityMargin = Value(0x8);
-
   // Depth limit for razoring
   const Depth RazorDepth = 4 * OnePly;
 
@@ -211,9 +170,12 @@ namespace {
   BetaCounterType BetaCounter;
 
   // Scores and number of times the best move changed for each iteration
-  IterationInfoType IterationInfo[PLY_MAX_PLUS_2];
+  Value ValueByIteration[PLY_MAX_PLUS_2];
   int BestMoveChangesByIteration[PLY_MAX_PLUS_2];
 
+  // Search window management
+  int AspirationDelta;
+
   // MultiPV mode
   int MultiPV;
 
@@ -224,7 +186,7 @@ namespace {
   int MaxSearchTime, AbsoluteMaxSearchTime, ExtraSearchTime, ExactMaxTime;
   bool UseTimeManagement, InfiniteSearch, PonderSearch, StopOnPonderhit;
   bool AbortSearch, Quit;
-  bool FailHigh, FailLow, Problem;
+  bool AspirationFailLow;
 
   // Show current line?
   bool ShowCurrentLine;
@@ -233,9 +195,21 @@ namespace {
   bool UseLogFile;
   std::ofstream LogFile;
 
-  // Natural logarithmic lookup table and its getter function
-  double lnArray[512];
-  inline double ln(int i) { return lnArray[i]; }
+  // 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;
@@ -263,11 +237,10 @@ namespace {
   // History table
   History H;
 
-
   /// Functions
 
   Value id_loop(const Position& pos, Move searchMoves[]);
-  Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value alpha, Value beta);
+  Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value& oldAlpha, Value& beta);
   Value search_pv(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID);
   Value search(Position& pos, SearchStack ss[], Value beta, Depth depth, int ply, bool allowNullmove, int threadID, Move excludedMove = MOVE_NONE);
   Value qsearch(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID);
@@ -286,8 +259,8 @@ namespace {
   Value refine_eval(const TTEntry* tte, Value defaultEval, int ply);
   void update_history(const Position& pos, Move move, Depth depth, Move movesSearched[], int moveCount);
   void update_killers(Move m, SearchStack& ss);
+  void update_gains(const Position& pos, Move move, Value before, Value after);
 
-  bool fail_high_ply_1();
   int current_search_time();
   int nps();
   void poll();
@@ -363,7 +336,7 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
 
   // Initialize global search variables
   Idle = StopOnPonderhit = AbortSearch = Quit = false;
-  FailHigh = FailLow = Problem = false;
+  AspirationFailLow = false;
   NodesSincePoll = 0;
   SearchStartTime = get_system_time();
   ExactMaxTime = maxTime;
@@ -374,7 +347,7 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
   UseTimeManagement = !ExactMaxTime && !MaxDepth && !MaxNodes && !InfiniteSearch;
 
   // Look for a book move, only during games, not tests
-  if (UseTimeManagement && !ponder && get_option_value_bool("OwnBook"))
+  if (UseTimeManagement && get_option_value_bool("OwnBook"))
   {
       Move bookMove;
       if (get_option_value_string("Book File") != OpeningBook.file_name())
@@ -383,6 +356,9 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
       bookMove = OpeningBook.get_move(pos);
       if (bookMove != MOVE_NONE)
       {
+          if (PonderSearch)
+              wait_for_stop_or_ponderhit();
+
           cout << "bestmove " << bookMove << endl;
           return true;
       }
@@ -391,7 +367,6 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
   for (int i = 0; i < THREAD_MAX; i++)
   {
       Threads[i].nodes = 0ULL;
-      Threads[i].failHighPly1 = false;
   }
 
   if (button_was_pressed("New Game"))
@@ -524,7 +499,6 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
   // We're ready to start thinking. Call the iterative deepening loop function
   Value v = id_loop(pos, searchMoves);
 
-
   if (UseLSNFiltering)
   {
       // Step 1. If this is sudden death game and our position is hopeless,
@@ -565,9 +539,26 @@ void init_threads() {
   pthread_t pthread[1];
 #endif
 
-  // Init our logarithmic lookup table
-  for (i = 0; i < 512; i++)
-      lnArray[i] = log(double(i)); // log() returns base-e logarithm
+  // Init our reduction lookup tables
+  for (i = 1; i < 64; i++) // i == depth
+      for (int j = 1; j < 64; j++) // j == moveNumber
+      {
+          double    pvRed = 0.5 + log(double(i)) * log(double(j)) / 6.0;
+          double nonPVRed = 0.5 + log(double(i)) * log(double(j)) / 3.0;
+          PVReductionMatrix[i][j]    = (int8_t) (   pvRed >= 1.0 ? floor(   pvRed * int(OnePly)) : 0);
+          NonPVReductionMatrix[i][j] = (int8_t) (nonPVRed >= 1.0 ? floor(nonPVRed * int(OnePly)) : 0);
+      }
+
+  // Init futility margins array
+  for (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)
+      FutilityMoveCountArray[i] = 3 + (1 << (3 * i / 8));
 
   for (i = 0; i < THREAD_MAX; i++)
       Threads[i].activeSplitPoints = 0;
@@ -680,6 +671,7 @@ namespace {
     // searchMoves are verified, copied, scored and sorted
     RootMoveList rml(p, searchMoves);
 
+    // Handle special case of searching on a mate/stale position
     if (rml.move_count() == 0)
     {
         if (PonderSearch)
@@ -701,7 +693,7 @@ namespace {
     TT.new_search();
     H.clear();
     init_ss_array(ss);
-    IterationInfo[1] = IterationInfoType(rml.get_move_score(0), rml.get_move_score(0));
+    ValueByIteration[1] = rml.get_move_score(0);
     Iteration = 1;
 
     // Is one move significantly better than others after initial scoring ?
@@ -725,15 +717,16 @@ namespace {
         // Calculate dynamic search window based on previous iterations
         Value alpha, beta;
 
-        if (MultiPV == 1 && Iteration >= 6 && abs(IterationInfo[Iteration - 1].value) < VALUE_KNOWN_WIN)
+        if (MultiPV == 1 && Iteration >= 6 && abs(ValueByIteration[Iteration - 1]) < VALUE_KNOWN_WIN)
         {
-            int prevDelta1 = IterationInfo[Iteration - 1].speculatedValue - IterationInfo[Iteration - 2].speculatedValue;
-            int prevDelta2 = IterationInfo[Iteration - 2].speculatedValue - IterationInfo[Iteration - 3].speculatedValue;
+            int prevDelta1 = ValueByIteration[Iteration - 1] - ValueByIteration[Iteration - 2];
+            int prevDelta2 = ValueByIteration[Iteration - 2] - ValueByIteration[Iteration - 3];
 
-            int delta = Max(2 * abs(prevDelta1) + abs(prevDelta2), ProblemMargin);
+            AspirationDelta = Max(abs(prevDelta1) + abs(prevDelta2) / 2, 16);
+            AspirationDelta = (AspirationDelta + 7) / 8 * 8; // Round to match grainSize
 
-            alpha = Max(IterationInfo[Iteration - 1].value - delta, -VALUE_INFINITE);
-            beta  = Min(IterationInfo[Iteration - 1].value + delta,  VALUE_INFINITE);
+            alpha = Max(ValueByIteration[Iteration - 1] - AspirationDelta, -VALUE_INFINITE);
+            beta  = Min(ValueByIteration[Iteration - 1] + AspirationDelta,  VALUE_INFINITE);
         }
         else
         {
@@ -752,39 +745,12 @@ namespace {
             break; // Value cannot be trusted. Break out immediately!
 
         //Save info about search result
-        Value speculatedValue;
-        bool fHigh = false;
-        bool fLow = false;
-        Value delta = value - IterationInfo[Iteration - 1].value;
-
-        if (value >= beta)
-        {
-            assert(delta > 0);
-
-            fHigh = true;
-            speculatedValue = value + delta;
-            BestMoveChangesByIteration[Iteration] += 2; // Allocate more time
-        }
-        else if (value <= alpha)
-        {
-            assert(value == alpha);
-            assert(delta < 0);
-
-            fLow = true;
-            speculatedValue = value + delta;
-            BestMoveChangesByIteration[Iteration] += 3; // Allocate more time
-        } else
-            speculatedValue = value;
-
-        speculatedValue = Min(Max(speculatedValue, -VALUE_INFINITE), VALUE_INFINITE);
-        IterationInfo[Iteration] = IterationInfoType(value, speculatedValue);
+        ValueByIteration[Iteration] = value;
 
         // Drop the easy move if it differs from the new best move
         if (ss[0].pv[0] != EasyMove)
             EasyMove = MOVE_NONE;
 
-        Problem = false;
-
         if (UseTimeManagement)
         {
             // Time to stop?
@@ -797,15 +763,13 @@ namespace {
 
             // Stop search early when the last two iterations returned a mate score
             if (  Iteration >= 6
-                && abs(IterationInfo[Iteration].value) >= abs(VALUE_MATE) - 100
-                && abs(IterationInfo[Iteration-1].value) >= abs(VALUE_MATE) - 100)
+                && abs(ValueByIteration[Iteration]) >= abs(VALUE_MATE) - 100
+                && abs(ValueByIteration[Iteration-1]) >= abs(VALUE_MATE) - 100)
                 stopSearch = true;
 
             // Stop search early if one move seems to be much better than the rest
             int64_t nodes = nodes_searched();
             if (   Iteration >= 8
-                && !fLow
-                && !fHigh
                 && EasyMove == ss[0].pv[0]
                 && (  (   rml.get_move_cumulative_nodes(0) > (nodes * 85) / 100
                        && current_search_time() > MaxSearchTime / 16)
@@ -841,7 +805,7 @@ namespace {
 
     // If we are pondering or in infinite search, we shouldn't print the
     // best move before we are told to do so.
-    if (!AbortSearch && !ExactMaxTime && (PonderSearch || InfiniteSearch))
+    if (!AbortSearch && (PonderSearch || InfiniteSearch))
         wait_for_stop_or_ponderhit();
     else
         // Print final search statistics
@@ -886,148 +850,118 @@ namespace {
   // similar to search_pv except that it uses a different move ordering
   // scheme and prints some information to the standard output.
 
-  Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value alpha, Value beta) {
+  Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value& oldAlpha, Value& beta) {
 
-    Value oldAlpha = alpha;
-    Value value = -VALUE_INFINITE;
+    int64_t nodes;
+    Move move;
+    StateInfo st;
+    Depth depth, ext, newDepth;
+    Value value;
     CheckInfo ci(pos);
+    int researchCount = 0;
+    bool moveIsCheck, captureOrPromotion, dangerous;
+    Value alpha = oldAlpha;
+    bool isCheck = pos.is_check();
 
-    // Loop through all the moves in the root move list
-    for (int i = 0; i <  rml.move_count() && !AbortSearch; i++)
-    {
-        if (alpha >= beta)
-        {
-            // We failed high, invalidate and skip next moves, leave node-counters
-            // and beta-counters as they are and quickly return, we will try to do
-            // a research at the next iteration with a bigger aspiration window.
-            rml.set_move_score(i, -VALUE_INFINITE);
-            continue;
-        }
-        int64_t nodes;
-        Move move;
-        StateInfo st;
-        Depth depth, ext, newDepth;
-
-        RootMoveNumber = i + 1;
-        FailHigh = false;
+    // Evaluate the position statically
+    EvalInfo ei;
+    ss[0].eval = !isCheck ? evaluate(pos, ei, 0) : VALUE_NONE;
 
-        // Save the current node count before the move is searched
-        nodes = nodes_searched();
+    while (1) // Fail low loop
+    {
 
-        // Reset beta cut-off counters
-        BetaCounter.clear();
+        // Loop through all the moves in the root move list
+        for (int i = 0; i <  rml.move_count() && !AbortSearch; i++)
+        {
+            if (alpha >= beta)
+            {
+                // We failed high, invalidate and skip next moves, leave node-counters
+                // and beta-counters as they are and quickly return, we will try to do
+                // a research at the next iteration with a bigger aspiration window.
+                rml.set_move_score(i, -VALUE_INFINITE);
+                continue;
+            }
 
-        // Pick the next root move, and print the move and the move number to
-        // the standard output.
-        move = ss[0].currentMove = rml.get_move(i);
+            RootMoveNumber = i + 1;
 
-        if (current_search_time() >= 1000)
-            cout << "info currmove " << move
-                 << " currmovenumber " << RootMoveNumber << endl;
+            // Save the current node count before the move is searched
+            nodes = nodes_searched();
 
-        // Decide search depth for this move
-        bool moveIsCheck = pos.move_is_check(move);
-        bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
-        bool dangerous;
-        depth =  (Iteration - 2) * OnePly + InitialDepth;
-        ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
-        newDepth = depth + ext;
+            // Reset beta cut-off counters
+            BetaCounter.clear();
 
-        // Make the move, and search it
-        pos.do_move(move, st, ci, moveIsCheck);
+            // Pick the next root move, and print the move and the move number to
+            // the standard output.
+            move = ss[0].currentMove = rml.get_move(i);
 
-        if (i < MultiPV)
-        {
-            // Aspiration window is disabled in multi-pv case
-            if (MultiPV > 1)
-                alpha = -VALUE_INFINITE;
+            if (current_search_time() >= 1000)
+                cout << "info currmove " << move
+                     << " currmovenumber " << RootMoveNumber << endl;
 
-            value = -search_pv(pos, ss, -beta, -alpha, newDepth, 1, 0);
+            // Decide search depth for this move
+            moveIsCheck = pos.move_is_check(move);
+            captureOrPromotion = pos.move_is_capture_or_promotion(move);
+            depth = (Iteration - 2) * OnePly + InitialDepth;
+            ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
+            newDepth = depth + ext;
 
-            // If the value has dropped a lot compared to the last iteration,
-            // set the boolean variable Problem to true. This variable is used
-            // for time managment: When Problem is true, we try to complete the
-            // current iteration before playing a move.
-            Problem = (   Iteration >= 2
-                       && value <= IterationInfo[Iteration - 1].value - ProblemMargin);
+            value = - VALUE_INFINITE;
 
-            if (Problem && StopOnPonderhit)
-                StopOnPonderhit = false;
-        }
-        else
-        {
-            // Try to reduce non-pv search depth by one ply if move seems not problematic,
-            // if the move fails high will be re-searched at full depth.
-            bool doFullDepthSearch = true;
-
-            if (   depth >= 3*OnePly // FIXME was newDepth
-                && !dangerous
-                && !captureOrPromotion
-                && !move_is_castle(move))
+            while (1) // Fail high loop
             {
-                double red = 0.5 + ln(RootMoveNumber - MultiPV + 1) * ln(depth / 2) / 6.0;
-                if (red >= 1.0)
-                {
-                    ss[0].reduction = Depth(int(floor(red * int(OnePly))));
-                    value = -search(pos, ss, -alpha, newDepth-ss[0].reduction, 1, true, 0);
-                    doFullDepthSearch = (value > alpha);
-                }
-            }
 
-            if (doFullDepthSearch)
-            {
-                value = -search(pos, ss, -alpha, newDepth, 1, true, 0);
+                // Make the move, and search it
+                pos.do_move(move, st, ci, moveIsCheck);
 
-                if (value > alpha)
+                if (i < MultiPV || value > alpha)
                 {
-                    // Fail high! Set the boolean variable FailHigh to true, and
-                    // re-search the move using a PV search. The variable FailHigh
-                    // is used for time managment: We try to avoid aborting the
-                    // search prematurely during a fail high research.
-                    FailHigh = true;
+                    // Aspiration window is disabled in multi-pv case
+                    if (MultiPV > 1)
+                        alpha = -VALUE_INFINITE;
+
                     value = -search_pv(pos, ss, -beta, -alpha, newDepth, 1, 0);
                 }
-            }
-        }
-
-        pos.undo_move(move);
-
-        // Finished searching the move. If AbortSearch is true, the search
-        // was aborted because the user interrupted the search or because we
-        // ran out of time. In this case, the return value of the search cannot
-        // be trusted, and we break out of the loop without updating the best
-        // move and/or PV.
-        if (AbortSearch)
-            break;
-
-        // Remember beta-cutoff and searched nodes counts for this move. The
-        // info is used to sort the root moves at the next iteration.
-        int64_t our, their;
-        BetaCounter.read(pos.side_to_move(), our, their);
-        rml.set_beta_counters(i, our, their);
-        rml.set_move_nodes(i, nodes_searched() - nodes);
-
-        assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE);
+                else
+                {
+                    // Try to reduce non-pv search depth by one ply if move seems not problematic,
+                    // if the move fails high will be re-searched at full depth.
+                    bool doFullDepthSearch = true;
+
+                    if (   depth >= 3*OnePly // FIXME was newDepth
+                        && !dangerous
+                        && !captureOrPromotion
+                        && !move_is_castle(move))
+                    {
+                        ss[0].reduction = pv_reduction(depth, RootMoveNumber - MultiPV + 1);
+                        if (ss[0].reduction)
+                        {
+                            value = -search(pos, ss, -alpha, newDepth-ss[0].reduction, 1, true, 0);
+                            doFullDepthSearch = (value > alpha);
+                        }
+                    }
+
+                    if (doFullDepthSearch)
+                    {
+                        ss[0].reduction = Depth(0);
+                        value = -search(pos, ss, -alpha, newDepth, 1, true, 0);
+
+                        if (value > alpha)
+                            value = -search_pv(pos, ss, -beta, -alpha, newDepth, 1, 0);
+                    }
+                }
 
-        if (value <= alpha && i >= MultiPV)
-            rml.set_move_score(i, -VALUE_INFINITE);
-        else
-        {
-            // PV move or new best move!
+                pos.undo_move(move);
 
-            // Update PV
-            rml.set_move_score(i, value);
-            update_pv(ss, 0);
-            TT.extract_pv(pos, ss[0].pv, PLY_MAX);
-            rml.set_move_pv(i, ss[0].pv);
+                // Can we exit fail high loop ?
+                if (AbortSearch || value < beta)
+                    break;
 
-            if (MultiPV == 1)
-            {
-                // We record how often the best move has been changed in each
-                // iteration. This information is used for time managment: When
-                // the best move changes frequently, we allocate some more time.
-                if (i > 0)
-                    BestMoveChangesByIteration[Iteration]++;
+                // We are failing high and going to do a research. It's important to update score
+                // before research in case we run out of time while researching.
+                rml.set_move_score(i, value);
+                update_pv(ss, 0);
+                TT.extract_pv(pos, ss[0].pv, PLY_MAX);
+                rml.set_move_pv(i, ss[0].pv);
 
                 // Print search information to the standard output
                 cout << "info depth " << Iteration
@@ -1052,40 +986,117 @@ namespace {
                     LogFile << pretty_pv(pos, current_search_time(), Iteration,
                                          nodes_searched(), value, type, ss[0].pv) << endl;
                 }
-                if (value > alpha)
-                    alpha = value;
 
-                // Reset the global variable Problem to false if the value isn't too
-                // far below the final value from the last iteration.
-                if (value > IterationInfo[Iteration - 1].value - NoProblemMargin)
-                    Problem = false;
-            }
-            else // MultiPV > 1
+                // Prepare for a research after a fail high, each time with a wider window
+                researchCount++;
+                beta = Min(beta + AspirationDelta * (1 << researchCount), VALUE_INFINITE);
+
+            } // End of fail high loop
+
+            // Finished searching the move. If AbortSearch is true, the search
+            // was aborted because the user interrupted the search or because we
+            // ran out of time. In this case, the return value of the search cannot
+            // be trusted, and we break out of the loop without updating the best
+            // move and/or PV.
+            if (AbortSearch)
+                break;
+
+            // Remember beta-cutoff and searched nodes counts for this move. The
+            // info is used to sort the root moves at the next iteration.
+            int64_t our, their;
+            BetaCounter.read(pos.side_to_move(), our, their);
+            rml.set_beta_counters(i, our, their);
+            rml.set_move_nodes(i, nodes_searched() - nodes);
+
+            assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE);
+
+            if (value <= alpha && i >= MultiPV)
+                rml.set_move_score(i, -VALUE_INFINITE);
+            else
             {
-                rml.sort_multipv(i);
-                for (int j = 0; j < Min(MultiPV, rml.move_count()); j++)
+                // PV move or new best move!
+
+                // Update PV
+                rml.set_move_score(i, value);
+                update_pv(ss, 0);
+                TT.extract_pv(pos, ss[0].pv, PLY_MAX);
+                rml.set_move_pv(i, ss[0].pv);
+
+                if (MultiPV == 1)
                 {
-                    cout << "info multipv " << j + 1
-                         << " score " << value_to_string(rml.get_move_score(j))
-                         << " depth " << ((j <= i)? Iteration : Iteration - 1)
-                         << " time " << current_search_time()
+                    // We record how often the best move has been changed in each
+                    // iteration. This information is used for time managment: When
+                    // the best move changes frequently, we allocate some more time.
+                    if (i > 0)
+                        BestMoveChangesByIteration[Iteration]++;
+
+                    // Print search information to the standard output
+                    cout << "info depth " << Iteration
+                         << " score " << value_to_string(value)
+                         << ((value >= beta) ? " lowerbound" :
+                            ((value <= alpha)? " upperbound" : ""))
+                         << " time "  << current_search_time()
                          << " nodes " << nodes_searched()
-                         << " nps " << nps()
+                         << " nps "   << nps()
                          << " pv ";
 
-                    for (int k = 0; rml.get_move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++)
-                        cout << rml.get_move_pv(j, k) << " ";
+                    for (int j = 0; ss[0].pv[j] != MOVE_NONE && j < PLY_MAX; j++)
+                        cout << ss[0].pv[j] << " ";
 
                     cout << endl;
+
+                    if (UseLogFile)
+                    {
+                        ValueType type =  (value >= beta  ? VALUE_TYPE_LOWER
+                                        : (value <= alpha ? VALUE_TYPE_UPPER : VALUE_TYPE_EXACT));
+
+                        LogFile << pretty_pv(pos, current_search_time(), Iteration,
+                                             nodes_searched(), value, type, ss[0].pv) << endl;
+                    }
+                    if (value > alpha)
+                        alpha = value;
                 }
-                alpha = rml.get_move_score(Min(i, MultiPV-1));
-            }
-        } // PV move or new best move
+                else // MultiPV > 1
+                {
+                    rml.sort_multipv(i);
+                    for (int j = 0; j < Min(MultiPV, rml.move_count()); j++)
+                    {
+                        cout << "info multipv " << j + 1
+                             << " score " << value_to_string(rml.get_move_score(j))
+                             << " depth " << ((j <= i)? Iteration : Iteration - 1)
+                             << " time " << current_search_time()
+                             << " nodes " << nodes_searched()
+                             << " nps " << nps()
+                             << " pv ";
+
+                        for (int k = 0; rml.get_move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++)
+                            cout << rml.get_move_pv(j, k) << " ";
+
+                        cout << endl;
+                    }
+                    alpha = rml.get_move_score(Min(i, MultiPV-1));
+                }
+            } // PV move or new best move
 
-        assert(alpha >= oldAlpha);
+            assert(alpha >= oldAlpha);
+
+            AspirationFailLow = (alpha == oldAlpha);
+
+            if (AspirationFailLow && StopOnPonderhit)
+                StopOnPonderhit = false;
+        }
+
+        // Can we exit fail low loop ?
+        if (AbortSearch || alpha > oldAlpha)
+            break;
+
+        // Prepare for a research after a fail low, each time with a wider window
+        researchCount++;
+        alpha = Max(alpha - AspirationDelta * (1 << researchCount), -VALUE_INFINITE);
+        oldAlpha = alpha;
+
+    } // Fail low loop
 
-        FailLow = (alpha == oldAlpha);
-    }
     return alpha;
   }
 
@@ -1153,9 +1164,18 @@ namespace {
         tte = TT.retrieve(pos.get_key());
     }
 
+    isCheck = pos.is_check();
+    if (!isCheck)
+    {
+        // Update gain statistics of the previous move that lead
+        // us in this position.
+        EvalInfo ei;
+        ss[ply].eval = evaluate(pos, ei, threadID);
+        update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval);
+    }
+
     // Initialize a MovePicker object for the current position, and prepare
     // to search all moves
-    isCheck = pos.is_check();
     mateThreat = pos.has_mate_threat(opposite_color(pos.side_to_move()));
     CheckInfo ci(pos);
     MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
@@ -1218,13 +1238,12 @@ namespace {
             && !move_is_castle(move)
             && !move_is_killer(move, ss[ply]))
         {
-          double red = 0.5 + ln(moveCount) * ln(depth / 2) / 6.0;
-          if (red >= 1.0)
-          {
-              ss[ply].reduction = Depth(int(floor(red * int(OnePly))));
-              value = -search(pos, ss, -alpha, newDepth-ss[ply].reduction, ply+1, true, threadID);
-              doFullDepthSearch = (value > alpha);
-          }
+            ss[ply].reduction = pv_reduction(depth, moveCount);
+            if (ss[ply].reduction)
+            {
+                value = -search(pos, ss, -alpha, newDepth-ss[ply].reduction, ply+1, true, threadID);
+                doFullDepthSearch = (value > alpha);
+            }
         }
 
         if (doFullDepthSearch) // Go with full depth non-pv search
@@ -1232,19 +1251,7 @@ namespace {
             ss[ply].reduction = Depth(0);
             value = -search(pos, ss, -alpha, newDepth, ply+1, true, threadID);
             if (value > alpha && value < beta)
-            {
-                // When the search fails high at ply 1 while searching the first
-                // move at the root, set the flag failHighPly1. This is used for
-                // time managment:  We don't want to stop the search early in
-                // such cases, because resolving the fail high at ply 1 could
-                // result in a big drop in score at the root.
-                if (ply == 1 && RootMoveNumber == 1)
-                    Threads[threadID].failHighPly1 = true;
-
-                // A fail high occurred. Re-search at full window (pv search)
                 value = -search_pv(pos, ss, -beta, -alpha, newDepth, ply+1, threadID);
-                Threads[threadID].failHighPly1 = false;
-          }
         }
       }
       pos.undo_move(move);
@@ -1262,13 +1269,6 @@ namespace {
               if (value == value_mate_in(ply + 1))
                   ss[ply].mateKiller = move;
           }
-          // If we are at ply 1, and we are searching the first root move at
-          // ply 0, set the 'Problem' variable if the score has dropped a lot
-          // (from the computer's point of view) since the previous iteration.
-          if (   ply == 1
-              && Iteration >= 2
-              && -value <= IterationInfo[Iteration-1].value - ProblemMargin)
-              Problem = true;
       }
 
       // Split?
@@ -1331,7 +1331,7 @@ namespace {
     Move ttMove, move;
     Depth ext, newDepth;
     Value bestValue, staticValue, nullValue, value, futilityValue, futilityValueScaled;
-    bool isCheck, useFutilityPruning, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
+    bool isCheck, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
     bool mateThreat = false;
     int moveCount = 0;
     futilityValue = staticValue = bestValue = value = -VALUE_INFINITE;
@@ -1373,10 +1373,6 @@ namespace {
 
     isCheck = pos.is_check();
 
-    // Calculate depth dependant futility pruning parameters
-    const int FutilityMoveCountMargin = 3 + (1 << (3 * int(depth) / 8));
-    const int FutilityValueMargin = 112 * bitScanReverse32(int(depth) * int(depth) / 2);
-
     // Evaluate the position statically
     if (!isCheck)
     {
@@ -1389,10 +1385,20 @@ namespace {
         }
 
         ss[ply].eval = staticValue;
-        futilityValue = staticValue + FutilityValueMargin;
+        futilityValue = staticValue + futility_margin(depth, 0); //FIXME: Remove me, only for split
         staticValue = refine_eval(tte, staticValue, ply); // Enhance accuracy with TT value if possible
+        update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval);
     }
 
+    // Static null move pruning. We're betting that the opponent doesn't have
+    // a move that will reduce the score by more than FutilityMargins[int(depth)]
+    // if we do a null move.
+    if (  !isCheck
+        && allowNullmove
+        && depth < RazorDepth
+        && staticValue - futility_margin(depth, 0) >= beta)
+        return staticValue - futility_margin(depth, 0);
+
     // Null move search
     if (    allowNullmove
         &&  depth > OnePly
@@ -1463,14 +1469,13 @@ namespace {
     {
         search(pos, ss, beta, Min(depth/2, depth-2*OnePly), ply, false, threadID);
         ttMove = ss[ply].pv[ply];
-        tte = TT.retrieve(pos.get_key());
+        tte = TT.retrieve(posKey);
     }
 
     // Initialize a MovePicker object for the current position, and prepare
     // to search all moves.
     MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
     CheckInfo ci(pos);
-    useFutilityPruning = depth < SelectiveDepth && !isCheck;
 
     // Loop through all legal moves until no moves remain or a beta cutoff occurs
     while (   bestValue < beta
@@ -1517,19 +1522,21 @@ namespace {
       movesSearched[moveCount++] = ss[ply].currentMove = move;
 
       // Futility pruning
-      if (    useFutilityPruning
+      if (   !isCheck
           && !dangerous
           && !captureOrPromotion
+          && !move_is_castle(move)
           &&  move != ttMove)
       {
           // Move count based pruning
-          if (   moveCount >= FutilityMoveCountMargin
+          if (   moveCount >= futility_move_count(depth)
               && ok_to_prune(pos, move, ss[ply].threatMove)
               && bestValue > value_mated_in(PLY_MAX))
               continue;
 
           // Value based pruning
-          futilityValueScaled = futilityValue - moveCount * IncrementalFutilityMargin;
+          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;
 
           if (futilityValueScaled < beta)
           {
@@ -1550,13 +1557,11 @@ namespace {
           && !dangerous
           && !captureOrPromotion
           && !move_is_castle(move)
-          && !move_is_killer(move, ss[ply])
-          /* && move != ttMove*/)
+          && !move_is_killer(move, ss[ply]))
       {
-          double red = 0.5 + ln(moveCount) * ln(depth / 2) / 3.0;
-          if (red >= 1.0)
+          ss[ply].reduction = nonpv_reduction(depth, moveCount);
+          if (ss[ply].reduction)
           {
-              ss[ply].reduction = Depth(int(floor(red * int(OnePly))));
               value = -search(pos, ss, -(beta-1), newDepth-ss[ply].reduction, ply+1, true, threadID);
               doFullDepthSearch = (value >= beta);
           }
@@ -1590,7 +1595,7 @@ namespace {
           && idle_thread_exists(threadID)
           && !AbortSearch
           && !thread_should_stop(threadID)
-          && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue,
+          && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, //FIXME: SMP & futilityValue
                    depth, &moveCount, &mp, threadID, false))
           break;
     }
@@ -1647,6 +1652,7 @@ namespace {
     const TTEntry* tte = NULL;
     int moveCount = 0;
     bool pvNode = (beta - alpha != 1);
+    Value oldAlpha = alpha;
 
     // Initialize, and make an early exit in case of an aborted search,
     // an instant draw, maximum ply reached, etc.
@@ -1682,6 +1688,12 @@ namespace {
     else
         staticValue = evaluate(pos, ei, threadID);
 
+    if (!isCheck)
+    {
+        ss[ply].eval = staticValue;
+        update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval);
+    }
+
     // Initialize "stand pat score", and return it immediately if it is
     // at least beta.
     bestValue = staticValue;
@@ -1689,7 +1701,7 @@ namespace {
     if (bestValue >= beta)
     {
         // Store the score to avoid a future costly evaluation() call
-        if (!isCheck && !tte && ei.futilityMargin == 0)
+        if (!isCheck && !tte && ei.futilityMargin[pos.side_to_move()] == 0)
             TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_EV_LO, Depth(-127*OnePly), MOVE_NONE);
 
         return bestValue;
@@ -1708,7 +1720,7 @@ namespace {
     MovePicker mp = MovePicker(pos, ttMove, deepChecks ? Depth(0) : depth, H);
     CheckInfo ci(pos);
     enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
-    futilityBase = staticValue + FutilityMarginQS + ei.futilityMargin;
+    futilityBase = staticValue + FutilityMarginQS + ei.futilityMargin[pos.side_to_move()];
 
     // Loop through the moves until no moves remain or a beta cutoff
     // occurs.
@@ -1784,14 +1796,14 @@ namespace {
 
     // Update transposition table
     Depth d = (depth == Depth(0) ? Depth(0) : Depth(-1));
-    if (bestValue < beta)
+    if (bestValue <= oldAlpha)
     {
         // If bestValue isn't changed it means it is still the static evaluation
         // of the node, so keep this info to avoid a future evaluation() call.
-        ValueType type = (bestValue == staticValue && !ei.futilityMargin ? VALUE_TYPE_EV_UP : VALUE_TYPE_UPPER);
+        ValueType type = (bestValue == staticValue && !ei.futilityMargin[pos.side_to_move()] ? VALUE_TYPE_EV_UP : VALUE_TYPE_UPPER);
         TT.store(pos.get_key(), value_to_tt(bestValue, ply), type, d, MOVE_NONE);
     }
-    else
+    else if (bestValue >= beta)
     {
         move = ss[ply].pv[ply];
         TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, d, move);
@@ -1800,6 +1812,8 @@ namespace {
         if (!pos.move_is_capture_or_promotion(move))
             update_killers(move, ss[ply]);
     }
+    else
+        TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_EXACT, d, ss[ply].pv[ply]);
 
     assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
 
@@ -1825,28 +1839,27 @@ namespace {
     SearchStack* ss = sp->sstack[threadID];
     Value value = -VALUE_INFINITE;
     Move move;
+    int moveCount;
     bool isCheck = pos.is_check();
-    bool useFutilityPruning =     sp->depth < SelectiveDepth
+    bool useFutilityPruning =     sp->depth < 7 * OnePly //FIXME: sync with search
                               && !isCheck;
 
-    const int FutilityMoveCountMargin = 3 + (1 << (3 * int(sp->depth) / 8));
-
-    while (    sp->bestValue < sp->beta
+    while (    lock_grab_bool(&(sp->lock))
+           &&  sp->bestValue < sp->beta
            && !thread_should_stop(threadID)
-           && (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE)
+           && (move = sp->mp->get_next_move()) != MOVE_NONE)
     {
+      moveCount = ++sp->moves;
+      lock_release(&(sp->lock));
+
       assert(move_is_ok(move));
 
       bool moveIsCheck = pos.move_is_check(move, ci);
       bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
 
-      lock_grab(&(sp->lock));
-      int moveCount = ++sp->moves;
-      lock_release(&(sp->lock));
-
       ss[sp->ply].currentMove = move;
 
-      // Decide the new search depth.
+      // Decide the new search depth
       bool dangerous;
       Depth ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, false, &dangerous);
       Depth newDepth = sp->depth - OnePly + ext;
@@ -1857,13 +1870,13 @@ namespace {
           && !captureOrPromotion)
       {
           // Move count based pruning
-          if (   moveCount >= FutilityMoveCountMargin
+          if (   moveCount >= futility_move_count(sp->depth)
               && ok_to_prune(pos, move, ss[sp->ply].threatMove)
               && sp->bestValue > value_mated_in(PLY_MAX))
               continue;
 
           // Value based pruning
-          Value futilityValueScaled = sp->futilityValue - moveCount * IncrementalFutilityMargin;
+          Value futilityValueScaled = sp->futilityValue - moveCount * 8; //FIXME: sync with search
 
           if (futilityValueScaled < sp->beta)
           {
@@ -1891,10 +1904,9 @@ namespace {
           && !move_is_castle(move)
           && !move_is_killer(move, ss[sp->ply]))
       {
-          double red = 0.5 + ln(moveCount) * ln(sp->depth / 2) / 3.0;
-          if (red >= 1.0)
+          ss[sp->ply].reduction = nonpv_reduction(sp->depth, moveCount);
+          if (ss[sp->ply].reduction)
           {
-              ss[sp->ply].reduction = Depth(int(floor(red * int(OnePly))));
               value = -search(pos, ss, -(sp->beta-1), newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
               doFullDepthSearch = (value >= sp->beta);
           }
@@ -1910,7 +1922,10 @@ namespace {
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
       if (thread_should_stop(threadID))
+      {
+          lock_grab(&(sp->lock));
           break;
+      }
 
       // New best move?
       if (value > sp->bestValue) // Less then 2% of cases
@@ -1933,7 +1948,7 @@ namespace {
       }
     }
 
-    lock_grab(&(sp->lock));
+    /* Here we have the lock still grabbed */
 
     // If this is the master thread and we have been asked to stop because of
     // a beta cutoff higher up in the tree, stop all slave threads.
@@ -1966,24 +1981,25 @@ namespace {
     CheckInfo ci(pos);
     SearchStack* ss = sp->sstack[threadID];
     Value value = -VALUE_INFINITE;
+    int moveCount;
     Move move;
 
-    while (    sp->alpha < sp->beta
+    while (    lock_grab_bool(&(sp->lock))
+           &&  sp->alpha < sp->beta
            && !thread_should_stop(threadID)
-           && (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE)
+           && (move = sp->mp->get_next_move()) != MOVE_NONE)
     {
-      bool moveIsCheck = pos.move_is_check(move, ci);
-      bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
+      moveCount = ++sp->moves;
+      lock_release(&(sp->lock));
 
       assert(move_is_ok(move));
 
-      lock_grab(&(sp->lock));
-      int moveCount = ++sp->moves;
-      lock_release(&(sp->lock));
+      bool moveIsCheck = pos.move_is_check(move, ci);
+      bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
 
       ss[sp->ply].currentMove = move;
 
-      // Decide the new search depth.
+      // Decide the new search depth
       bool dangerous;
       Depth ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
       Depth newDepth = sp->depth - OnePly + ext;
@@ -2001,11 +2017,10 @@ namespace {
           && !move_is_castle(move)
           && !move_is_killer(move, ss[sp->ply]))
       {
-          double red = 0.5 + ln(moveCount) * ln(sp->depth / 2) / 6.0;
-          if (red >= 1.0)
+          ss[sp->ply].reduction = pv_reduction(sp->depth, moveCount);
+          if (ss[sp->ply].reduction)
           {
               Value localAlpha = sp->alpha;
-              ss[sp->ply].reduction = Depth(int(floor(red * int(OnePly))));
               value = -search(pos, ss, -localAlpha, newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
               doFullDepthSearch = (value > localAlpha);
           }
@@ -2019,14 +2034,6 @@ namespace {
 
           if (value > localAlpha && value < sp->beta)
           {
-              // When the search fails high at ply 1 while searching the first
-              // move at the root, set the flag failHighPly1. This is used for
-              // time managment: We don't want to stop the search early in
-              // such cases, because resolving the fail high at ply 1 could
-              // result in a big drop in score at the root.
-              if (sp->ply == 1 && RootMoveNumber == 1)
-                  Threads[threadID].failHighPly1 = true;
-
               // If another thread has failed high then sp->alpha has been increased
               // to be higher or equal then beta, if so, avoid to start a PV search.
               localAlpha = sp->alpha;
@@ -2034,8 +2041,6 @@ namespace {
                   value = -search_pv(pos, ss, -sp->beta, -localAlpha, newDepth, sp->ply+1, threadID);
               else
                   assert(thread_should_stop(threadID));
-
-              Threads[threadID].failHighPly1 = false;
         }
       }
       pos.undo_move(move);
@@ -2043,43 +2048,42 @@ namespace {
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
       if (thread_should_stop(threadID))
+      {
+          lock_grab(&(sp->lock));
           break;
+      }
 
       // New best move?
-      lock_grab(&(sp->lock));
-      if (value > sp->bestValue && !thread_should_stop(threadID))
+      if (value > sp->bestValue) // Less then 2% of cases
       {
-          sp->bestValue = value;
-          if (value > sp->alpha)
+          lock_grab(&(sp->lock));
+          if (value > sp->bestValue && !thread_should_stop(threadID))
           {
-              // Ask threads to stop before to modify sp->alpha
-              if (value >= sp->beta)
+              sp->bestValue = value;
+              if (value > sp->alpha)
               {
-                  for (int i = 0; i < ActiveThreads; i++)
-                      if (i != threadID && (i == sp->master || sp->slaves[i]))
-                          Threads[i].stop = true;
+                  // Ask threads to stop before to modify sp->alpha
+                  if (value >= sp->beta)
+                  {
+                      for (int i = 0; i < ActiveThreads; i++)
+                          if (i != threadID && (i == sp->master || sp->slaves[i]))
+                              Threads[i].stop = true;
 
-                  sp->finished = true;
-              }
+                      sp->finished = true;
+                  }
 
-              sp->alpha = value;
+                  sp->alpha = value;
 
-              sp_update_pv(sp->parentSstack, ss, sp->ply);
-              if (value == value_mate_in(sp->ply + 1))
-                  ss[sp->ply].mateKiller = move;
-        }
-        // If we are at ply 1, and we are searching the first root move at
-        // ply 0, set the 'Problem' variable if the score has dropped a lot
-        // (from the computer's point of view) since the previous iteration.
-        if (   sp->ply == 1
-            && Iteration >= 2
-            && -value <= IterationInfo[Iteration-1].value - ProblemMargin)
-            Problem = true;
+                  sp_update_pv(sp->parentSstack, ss, sp->ply);
+                  if (value == value_mate_in(sp->ply + 1))
+                      ss[sp->ply].mateKiller = move;
+              }
+          }
+          lock_release(&(sp->lock));
       }
-      lock_release(&(sp->lock));
     }
 
-    lock_grab(&(sp->lock));
+    /* Here we have the lock still grabbed */
 
     // If this is the master thread and we have been asked to stop because of
     // a beta cutoff higher up in the tree, stop all slave threads.
@@ -2127,7 +2131,9 @@ namespace {
 
   RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) : count(0) {
 
+    SearchStack ss[PLY_MAX_PLUS_2];
     MoveStack mlist[MaxRootMoves];
+    StateInfo st;
     bool includeAllMoves = (searchMoves[0] == MOVE_NONE);
 
     // Generate all legal moves
@@ -2145,16 +2151,13 @@ namespace {
             continue;
 
         // Find a quick score for the move
-        StateInfo st;
-        SearchStack ss[PLY_MAX_PLUS_2];
         init_ss_array(ss);
-
+        pos.do_move(cur->move, st);
         moves[count].move = cur->move;
-        pos.do_move(moves[count].move, st);
         moves[count].score = -qsearch(pos, ss, -VALUE_INFINITE, VALUE_INFINITE, Depth(0), 1, 0);
-        pos.undo_move(moves[count].move);
-        moves[count].pv[0] = moves[count].move;
+        moves[count].pv[0] = cur->move;
         moves[count].pv[1] = MOVE_NONE;
+        pos.undo_move(cur->move);
         count++;
     }
     sort();
@@ -2458,9 +2461,8 @@ namespace {
 
     Square mfrom, mto, tfrom, tto;
 
-    // Prune if there isn't any threat move and
-    // is not a castling move (common case).
-    if (threat == MOVE_NONE && !move_is_castle(m))
+    // Prune if there isn't any threat move
+    if (threat == MOVE_NONE)
         return true;
 
     mfrom = move_from(m);
@@ -2468,15 +2470,11 @@ namespace {
     tfrom = move_from(threat);
     tto = move_to(threat);
 
-    // Case 1: Castling moves are never pruned
-    if (move_is_castle(m))
-        return false;
-
-    // Case 2: Don't prune moves which move the threatened piece
+    // Case 1: Don't prune moves which move the threatened piece
     if (mfrom == tto)
         return false;
 
-    // Case 3: If the threatened piece has value less than or equal to the
+    // Case 2: If the threatened piece has value less than or equal to the
     // value of the threatening piece, don't prune move which defend it.
     if (   pos.move_is_capture(threat)
         && (   pos.midgame_value_of_piece_on(tfrom) >= pos.midgame_value_of_piece_on(tto)
@@ -2484,7 +2482,7 @@ namespace {
         && pos.move_attacks_square(m, tto))
         return false;
 
-    // Case 4: If the moving piece in the threatened move is a slider, don't
+    // Case 3: If the moving piece in the threatened move is a slider, don't
     // prune safe moves which block its ray.
     if (   piece_is_slider(pos.piece_on(tfrom))
         && bit_is_set(squares_between(tfrom, tto), mto)
@@ -2528,6 +2526,7 @@ namespace {
       return defaultEval;
   }
 
+
   // update_history() registers a good move that produced a beta-cutoff
   // in history and marks as failures all the other moves of that ply.
 
@@ -2565,17 +2564,18 @@ namespace {
   }
 
 
-  // fail_high_ply_1() checks if some thread is currently resolving a fail
-  // high at ply 1 at the node below the first root node.  This information
-  // is used for time management.
+  // update_gains() updates the gains table of a non-capture move given
+  // the static position evaluation before and after the move.
 
-  bool fail_high_ply_1() {
-
-    for (int i = 0; i < ActiveThreads; i++)
-        if (Threads[i].failHighPly1)
-            return true;
+  void update_gains(const Position& pos, Move m, Value before, Value after) {
 
-    return false;
+    if (   m != MOVE_NULL
+        && before != VALUE_NONE
+        && after != VALUE_NONE
+        && pos.captured_piece() == NO_PIECE_TYPE
+        && !move_is_castle(m)
+        && !move_is_promotion(m))
+        H.set_gain(pos.piece_on(move_to(m)), move_to(m), -(before + after));
   }
 
 
@@ -2665,18 +2665,11 @@ namespace {
         return;
 
     bool stillAtFirstMove =    RootMoveNumber == 1
-                           && !FailLow
+                           && !AspirationFailLow
                            &&  t > MaxSearchTime + ExtraSearchTime;
 
-    bool noProblemFound =   !FailHigh
-                         && !FailLow
-                         && !fail_high_ply_1()
-                         && !Problem
-                         &&  t > 6 * (MaxSearchTime + ExtraSearchTime);
-
     bool noMoreTime =   t > AbsoluteMaxSearchTime
-                     || stillAtFirstMove //FIXME: We are not checking any problem flags, BUG?
-                     || noProblemFound;
+                     || stillAtFirstMove;
 
     if (   (Iteration >= 3 && UseTimeManagement && noMoreTime)
         || (ExactMaxTime && t >= ExactMaxTime)
@@ -2695,18 +2688,11 @@ namespace {
     PonderSearch = false;
 
     bool stillAtFirstMove =    RootMoveNumber == 1
-                           && !FailLow
+                           && !AspirationFailLow
                            &&  t > MaxSearchTime + ExtraSearchTime;
 
-    bool noProblemFound =   !FailHigh
-                         && !FailLow
-                         && !fail_high_ply_1()
-                         && !Problem
-                         &&  t > 6 * (MaxSearchTime + ExtraSearchTime);
-
     bool noMoreTime =   t > AbsoluteMaxSearchTime
-                     || stillAtFirstMove
-                     || noProblemFound;
+                     || stillAtFirstMove;
 
     if (Iteration >= 3 && UseTimeManagement && (noMoreTime || StopOnPonderhit))
         AbortSearch = true;
@@ -2898,7 +2884,10 @@ namespace {
     if (!Threads[slave].idle || slave == master)
         return false;
 
-    if (Threads[slave].activeSplitPoints == 0)
+    // Make a local copy to be sure doesn't change under our feet
+    int localActiveSplitPoints = Threads[slave].activeSplitPoints;
+
+    if (localActiveSplitPoints == 0)
         // No active split points means that the thread is available as
         // a slave for any other thread.
         return true;
@@ -2906,8 +2895,10 @@ namespace {
     if (ActiveThreads == 2)
         return true;
 
-    // Apply the "helpful master" concept if possible
-    if (SplitPointStack[slave][Threads[slave].activeSplitPoints - 1].slaves[master])
+    // Apply the "helpful master" concept if possible. Use localActiveSplitPoints
+    // that is known to be > 0, instead of Threads[slave].activeSplitPoints that
+    // could have been set to 0 by another thread leading to an out of bound access.
+    if (SplitPointStack[slave][localActiveSplitPoints - 1].slaves[master])
         return true;
 
     return false;
@@ -3017,7 +3008,7 @@ namespace {
     for (int i = 0; i < ActiveThreads; i++)
         if (i == master || splitPoint->slaves[i])
         {
-            memcpy(splitPoint->sstack[i] + ply - 1, sstck + ply - 1, 3 * sizeof(SearchStack));
+            memcpy(splitPoint->sstack[i] + ply - 1, sstck + ply - 1, 4 * sizeof(SearchStack));
             Threads[i].workIsWaiting = true; // This makes the slave to exit from idle_loop()
         }