Cache evaluation score in qsearch
[stockfish] / src / search.cpp
index c583e7b647af3d83a3c4389c33ebc08d2c761ae2..3617853e5f23d2f3589b7af48da9decbf48e4593 100644 (file)
@@ -121,13 +121,13 @@ namespace {
   // Depth limit for selective search:
   Depth SelectiveDepth = 7*OnePly;
 
+  // Use dynamic LMR?
+  const bool UseDynamicLMR = false;
+
   // Use internal iterative deepening?
   const bool UseIIDAtPVNodes = true;
   const bool UseIIDAtNonPVNodes = false;
 
-  // Use null move driven internal iterative deepening?
-  bool UseNullDrivenIID = false;
-
   // Internal iterative deepening margin.  At Non-PV moves, when
   // UseIIDAtNonPVNodes is true, we do an internal iterative deepening search
   // when the static evaluation is at most IIDMargin below beta.
@@ -162,15 +162,14 @@ namespace {
   bool UseQSearchFutilityPruning = true;
   bool UseFutilityPruning = true;
 
-  // Margins for futility pruning in the quiescence search, at frontier
-  // nodes, and at pre-frontier nodes
-  Value FutilityMargin0 = Value(0x80);
-  Value FutilityMargin1 = Value(0x100);
-  Value FutilityMargin2 = Value(0x200);
-  const Value FutilityMargins[6] = { Value(0x120), Value(0x220), Value(0x250),
-                                     Value(0x280), Value(0x320), Value(0x360) };
+  // Margins for futility pruning in the quiescence search, and at frontier
+  // and near frontier nodes
+  Value FutilityMarginQS = Value(0x80);
+  Value FutilityMargins[6] = { Value(0x100), Value(0x200), Value(0x250),
+                               Value(0x2A0), Value(0x340), Value(0x3A0) };
 
   // Razoring
+  const bool RazorAtDepthOne = false;
   Depth RazorDepth = 4*OnePly;
   Value RazorMargin = Value(0x300);
 
@@ -197,7 +196,6 @@ namespace {
 
   // Iteration counters
   int Iteration;
-  bool LastIterations;
   BetaCounterType BetaCounter;
 
   // Scores and number of times the best move changed for each iteration:
@@ -211,7 +209,7 @@ namespace {
   int SearchStartTime;
   int MaxNodes, MaxDepth;
   int MaxSearchTime, AbsoluteMaxSearchTime, ExtraSearchTime;
-  Move BestRootMove, PonderMove, EasyMove;
+  Move EasyMove;
   int RootMoveNumber;
   bool InfiniteSearch;
   bool PonderSearch;
@@ -260,15 +258,13 @@ namespace {
                 Depth depth, int ply, int threadID);
   void sp_search(SplitPoint *sp, int threadID);
   void sp_search_pv(SplitPoint *sp, int threadID);
-  void init_search_stack(SearchStack& ss);
-  void init_search_stack(SearchStack ss[]);
   void init_node(const Position &pos, SearchStack ss[], int ply, int threadID);
   void update_pv(SearchStack ss[], int ply);
   void sp_update_pv(SearchStack *pss, SearchStack ss[], int ply);
   bool connected_moves(const Position &pos, Move m1, Move m2);
   bool value_is_mate(Value value);
   bool move_is_killer(Move m, const SearchStack& ss);
-  Depth extension(const Position &pos, Move m, bool pvNode, bool check, bool singleReply, bool mateThreat, bool* dangerous);
+  Depth extension(const Position &pos, Move m, bool pvNode, bool capture, bool check, bool singleReply, bool mateThreat, bool* dangerous);
   bool ok_to_do_nullmove(const Position &pos);
   bool ok_to_prune(const Position &pos, Move m, Move threat, Depth d);
   bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply);
@@ -291,9 +287,8 @@ namespace {
   bool thread_is_available(int slave, int master);
   bool idle_thread_exists(int master);
   bool split(const Position &pos, SearchStack *ss, int ply,
-             Value *alpha, Value *beta, Value *bestValue, Depth depth,
-             int *moves, MovePicker *mp, Bitboard dcCandidates, int master,
-             bool pvNode);
+             Value *alpha, Value *beta, Value *bestValue, Depth depth, int *moves,
+             MovePicker *mp, Bitboard dcCandidates, int master, bool pvNode);
   void wake_sleeping_threads();
 
 #if !defined(_MSC_VER)
@@ -326,6 +321,24 @@ History H;  // Should be made local?
 SearchStack EmptySearchStack;
 
 
+// SearchStack::init() initializes a search stack. Used at the beginning of a
+// new search from the root.
+void SearchStack::init(int ply) {
+
+  pv[ply] = pv[ply + 1] = MOVE_NONE;
+  currentMove = threatMove = MOVE_NONE;
+  reduction = Depth(0);
+  currentMoveCaptureValue = Value(0);
+}
+
+void SearchStack::initKillers() {
+
+  mateKiller = MOVE_NONE;
+  for (int i = 0; i < KILLER_MAX; i++)
+      killers[i] = MOVE_NONE;
+}
+
+
 ////
 //// Functions
 ////
@@ -358,8 +371,6 @@ void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
   // Initialize global search variables
   Idle = false;
   SearchStartTime = get_system_time();
-  BestRootMove = MOVE_NONE;
-  PonderMove = MOVE_NONE;
   EasyMove = MOVE_NONE;
   for (int i = 0; i < THREAD_MAX; i++)
   {
@@ -413,13 +424,13 @@ void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
   if (UseLogFile)
       LogFile.open(get_option_value_string("Search Log Filename").c_str(), std::ios::out | std::ios::app);
 
-  UseNullDrivenIID = get_option_value_bool("Null driven IID");
   UseQSearchFutilityPruning = get_option_value_bool("Futility Pruning (Quiescence Search)");
   UseFutilityPruning = get_option_value_bool("Futility Pruning (Main Search)");
 
-  FutilityMargin0 = value_from_centipawns(get_option_value_int("Futility Margin 0"));
-  FutilityMargin1 = value_from_centipawns(get_option_value_int("Futility Margin 1"));
-  FutilityMargin2 = value_from_centipawns(get_option_value_int("Futility Margin 2"));
+  FutilityMarginQS = value_from_centipawns(get_option_value_int("Futility Margin (Quiescence Search)"));
+  int fmScale = get_option_value_int("Futility Margin Scale Factor (Main Search)");
+  for (int i = 0; i < 6; i++)
+      FutilityMargins[i] = (FutilityMargins[i] * fmScale) / 100;
 
   RazorDepth = (get_option_value_int("Maximum Razoring Depth") + 1) * OnePly;
   RazorMargin = value_from_centipawns(get_option_value_int("Razoring Margin"));
@@ -449,7 +460,6 @@ void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
   // Set thinking time:
   int myTime = time[side_to_move];
   int myIncrement = increment[side_to_move];
-  int oppTime = time[1 - side_to_move];
 
   if (!movesToGo) // Sudden death time control
   {
@@ -590,7 +600,8 @@ void init_threads() {
   }
 
   // Init also the empty search stack
-  init_search_stack(EmptySearchStack);
+  EmptySearchStack.init(0);
+  EmptySearchStack.initKillers();
 }
 
 
@@ -642,12 +653,14 @@ namespace {
     // Initialize
     TT.new_search();
     H.clear();
-    init_search_stack(ss);
-
+    for (int i = 0; i < 3; i++)
+    {
+        ss[i].init(i);
+        ss[i].initKillers();
+    }
     ValueByIteration[0] = Value(0);
     ValueByIteration[1] = rml.get_move_score(0);
     Iteration = 1;
-    LastIterations = false;
 
     EasyMove = rml.scan_for_easy_move();
 
@@ -702,9 +715,6 @@ namespace {
                 ExtraSearchTime = BestMoveChangesByIteration[Iteration]   * (MaxSearchTime / 2)
                                 + BestMoveChangesByIteration[Iteration-1] * (MaxSearchTime / 3);
 
-            // Try to guess if the current iteration is the last one or the last two
-            LastIterations = (current_search_time() > ((MaxSearchTime + ExtraSearchTime)*58) / 128);
-
             // Stop search if most of MaxSearchTime is consumed at the end of the
             // iteration.  We probably don't have enough time to search the first
             // move at the next iteration anyway.
@@ -741,6 +751,11 @@ namespace {
                   << " hashfull " << TT.full() << std::endl;
 
     // Print the best move and the ponder move to the standard output
+    if (ss[0].pv[0] == MOVE_NONE)
+    {
+        ss[0].pv[0] = rml.get_move(0);
+        ss[0].pv[1] = MOVE_NONE;
+    }
     std::cout << "bestmove " << ss[0].pv[0];
     if (ss[0].pv[1] != MOVE_NONE)
         std::cout << " ponder " << ss[0].pv[1];
@@ -755,12 +770,12 @@ namespace {
         if (dbg_show_hit_rate)
             dbg_print_hit_rate(LogFile);
 
-        UndoInfo u;
+        StateInfo st;
         LogFile << "Nodes: " << nodes_searched() << std::endl
                 << "Nodes/second: " << nps() << std::endl
                 << "Best move: " << move_to_san(p, ss[0].pv[0]) << std::endl;
 
-        p.do_move(ss[0].pv[0], u);
+        p.do_move(ss[0].pv[0], st);
         LogFile << "Ponder move: " << move_to_san(p, ss[0].pv[1])
                 << std::endl << std::endl;
     }
@@ -784,7 +799,7 @@ namespace {
     {
         int64_t nodes;
         Move move;
-        UndoInfo u;
+        StateInfo st;
         Depth ext, newDepth;
 
         RootMoveNumber = i + 1;
@@ -806,11 +821,11 @@ namespace {
 
         // Decide search depth for this move
         bool dangerous;
-        ext = extension(pos, move, true, pos.move_is_check(move), false, false, &dangerous);
+        ext = extension(pos, move, true, pos.move_is_capture(move), pos.move_is_check(move), false, false, &dangerous);
         newDepth = (Iteration - 2) * OnePly + ext + InitialDepth;
 
         // Make the move, and search it
-        pos.do_move(move, u, dcCandidates);
+        pos.do_move(move, st, dcCandidates);
 
         if (i < MultiPV)
         {
@@ -838,7 +853,7 @@ namespace {
             }
         }
 
-        pos.undo_move(move, u);
+        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
@@ -985,8 +1000,9 @@ namespace {
     int moveCount = 0;
     Value value, bestValue = -VALUE_INFINITE;
     Bitboard dcCandidates = mp.discovered_check_candidates();
+    Color us = pos.side_to_move();
     bool isCheck = pos.is_check();
-    bool mateThreat = pos.has_mate_threat(opposite_color(pos.side_to_move()));
+    bool mateThreat = pos.has_mate_threat(opposite_color(us));
 
     // Loop through all legal moves until no moves remain or a beta cutoff
     // occurs.
@@ -1010,12 +1026,12 @@ namespace {
 
       // Decide the new search depth
       bool dangerous;
-      Depth ext = extension(pos, move, true, moveIsCheck, singleReply, mateThreat, &dangerous);
+      Depth ext = extension(pos, move, true, moveIsCapture, moveIsCheck, singleReply, mateThreat, &dangerous);
       Depth newDepth = depth - OnePly + ext;
 
       // Make and search the move
-      UndoInfo u;
-      pos.do_move(move, u, dcCandidates);
+      StateInfo st;
+      pos.do_move(move, st, dcCandidates);
 
       if (moveCount == 1) // The first move in list is the PV
           value = -search_pv(pos, ss, -beta, -alpha, newDepth, ply+1, threadID);
@@ -1057,7 +1073,7 @@ namespace {
           }
         }
       }
-      pos.undo_move(move, u);
+      pos.undo_move(move);
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
@@ -1172,7 +1188,6 @@ namespace {
 
     Value approximateEval = quick_evaluate(pos);
     bool mateThreat = false;
-    bool nullDrivenIID = false;
     bool isCheck = pos.is_check();
 
     // Null move search
@@ -1185,26 +1200,13 @@ namespace {
     {
         ss[ply].currentMove = MOVE_NULL;
 
-        UndoInfo u;
-        pos.do_null_move(u);
+        StateInfo st;
+        pos.do_null_move(st);
         int R = (depth >= 4 * OnePly ? 4 : 3); // Null move dynamic reduction
 
         Value nullValue = -search(pos, ss, -(beta-1), depth-R*OnePly, ply+1, false, threadID);
 
-        // Check for a null capture artifact, if the value without the null capture
-        // is above beta then mark the node as a suspicious failed low. We will verify
-        // later if we are really under threat.
-        if (   UseNullDrivenIID
-            && nullValue < beta
-            && depth > 6 * OnePly
-            &&!value_is_mate(nullValue)
-            && ttMove == MOVE_NONE
-            && ss[ply + 1].currentMove != MOVE_NONE
-            && pos.move_is_capture(ss[ply + 1].currentMove)
-            && pos.see(ss[ply + 1].currentMove) + nullValue >= beta)
-            nullDrivenIID = true;
-
-        pos.undo_null_move(u);
+        pos.undo_null_move();
 
         if (value_is_mate(nullValue))
         {
@@ -1227,10 +1229,8 @@ namespace {
             // low score (which will cause the reduced move to fail high in the
             // parent node, which will trigger a re-search with full depth).
             if (nullValue == value_mated_in(ply + 2))
-            {
                 mateThreat = true;
-                nullDrivenIID = false;
-            }
+
             ss[ply].threatMove = ss[ply + 1].currentMove;
             if (   depth < ThreatDepth
                 && ss[ply - 1].reduction
@@ -1242,12 +1242,14 @@ namespace {
     else if (   !value_is_mate(beta)
              && approximateEval < beta - RazorMargin
              && depth < RazorDepth
-             && depth > OnePly
+             && (RazorAtDepthOne || depth > OnePly)
              && ttMove == MOVE_NONE
              && !pos.has_pawn_on_7th(pos.side_to_move()))
     {
         Value v = qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID);
-        if (v < beta - RazorMargin / 2 - int(depth - OnePly) * RazorMargin / 8)
+        if (   (v < beta - RazorMargin - RazorMargin / 4)
+            || (depth <= 2*OnePly && v < beta - RazorMargin)
+            || (depth <=   OnePly && v < beta - RazorMargin / 2))
             return v;
     }
 
@@ -1258,22 +1260,6 @@ namespace {
         search(pos, ss, beta, Min(depth/2, depth-2*OnePly), ply, false, threadID);
         ttMove = ss[ply].pv[ply];
     }
-    else if (nullDrivenIID)
-    {
-        // The null move failed low due to a suspicious capture. Perhaps we
-        // are facing a null capture artifact due to the side to move change
-        // and this position should fail high. So do a normal search with a
-        // reduced depth to get a good ttMove to use in the following full
-        // depth search.
-        Move tm = ss[ply].threatMove;
-
-        assert(tm != MOVE_NONE);
-        assert(ttMove == MOVE_NONE);
-
-        search(pos, ss, beta, depth/2, ply, false, threadID);
-        ttMove = ss[ply].pv[ply];
-        ss[ply].threatMove = tm;
-    }
 
     // Initialize a MovePicker object for the current position, and prepare
     // to search all moves:
@@ -1304,7 +1290,7 @@ namespace {
 
       // Decide the new search depth
       bool dangerous;
-      Depth ext = extension(pos, move, false, moveIsCheck, singleReply, mateThreat, &dangerous);
+      Depth ext = extension(pos, move, false, moveIsCapture, moveIsCheck, singleReply, mateThreat, &dangerous);
       Depth newDepth = depth - OnePly + ext;
 
       // Futility pruning
@@ -1336,8 +1322,8 @@ namespace {
       }
 
       // Make and search the move
-      UndoInfo u;
-      pos.do_move(move, u, dcCandidates);
+      StateInfo st;
+      pos.do_move(move, st, dcCandidates);
 
       // 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.
@@ -1349,8 +1335,13 @@ namespace {
           && !move_is_castle(move)
           && !move_is_killer(move, ss[ply]))
       {
-          ss[ply].reduction = OnePly;
-          value = -search(pos, ss, -(beta-1), newDepth-OnePly, ply+1, true, threadID);
+          // LMR dynamic reduction
+          Depth R =    UseDynamicLMR
+                    && moveCount >= 2 * LMRNonPVMoves
+                    && depth > 7*OnePly ? 2*OnePly : OnePly;
+
+          ss[ply].reduction = R;
+          value = -search(pos, ss, -(beta-1), newDepth-R, ply+1, true, threadID);
       }
       else
         value = beta; // Just to trigger next condition
@@ -1360,7 +1351,7 @@ namespace {
           ss[ply].reduction = Depth(0);
           value = -search(pos, ss, -(beta-1), newDepth, ply+1, true, threadID);
       }
-      pos.undo_move(move, u);
+      pos.undo_move(move);
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
@@ -1411,6 +1402,9 @@ namespace {
         }
         TT.store(pos, value_to_tt(bestValue, ply), depth, m, VALUE_TYPE_LOWER);
     }
+
+    assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
+
     return bestValue;
   }
 
@@ -1439,15 +1433,39 @@ namespace {
     if (pos.is_draw())
         return VALUE_DRAW;
 
-    // Transposition table lookup
-    const TTEntry* tte = TT.retrieve(pos);
-    if (tte && ok_to_use_TT(tte, depth, beta, ply))
-        return value_from_tt(tte->value(), ply);
+    // Transposition table lookup, only when not in PV
+    TTEntry* tte = NULL;
+    bool pvNode = (beta - alpha != 1);
+    if (!pvNode)
+    {
+        tte = TT.retrieve(pos);
+        if (tte && ok_to_use_TT(tte, depth, beta, ply))
+        {
+            assert(tte->type() != VALUE_TYPE_EVAL);
+
+            return value_from_tt(tte->value(), ply);
+        }
+    }
 
     // Evaluate the position statically
     EvalInfo ei;
+    Value staticValue;
     bool isCheck = pos.is_check();
-    Value staticValue = (isCheck ? -VALUE_INFINITE : evaluate(pos, ei, threadID));
+
+    if (isCheck)
+        staticValue = -VALUE_INFINITE;
+
+    else if (tte && tte->type() == VALUE_TYPE_EVAL)
+    {
+        // Use the cached evaluation score if possible
+        assert(tte->value() == evaluate(pos, ei, threadID));
+        assert(ei.futilityMargin == Value(0));
+
+        staticValue = tte->value();
+        ei.futilityMargin = Value(0); // manually initialize futilityMargin
+    }
+    else
+        staticValue = evaluate(pos, ei, threadID);
 
     if (ply == PLY_MAX - 1)
         return evaluate(pos, ei, threadID);
@@ -1457,7 +1475,16 @@ namespace {
     Value bestValue = staticValue;
 
     if (bestValue >= beta)
+    {
+        // Update transposition table before to leave
+        TT.store(pos, value_to_tt(bestValue, ply), depth, MOVE_NONE, VALUE_TYPE_EXACT);
         return bestValue;
+    }
+    else if (!isCheck && !tte && ei.futilityMargin == 0)
+    {
+        // Store the score to avoid a future costly evaluation() call
+        TT.store(pos, value_to_tt(bestValue, ply), Depth(-127*OnePly), MOVE_NONE, VALUE_TYPE_EVAL);
+    }
 
     if (bestValue > alpha)
         alpha = bestValue;
@@ -1465,12 +1492,12 @@ namespace {
     // Initialize a MovePicker object for the current position, and prepare
     // to search the moves.  Because the depth is <= 0 here, only captures,
     // queen promotions and checks (only if depth == 0) will be generated.
-    bool pvNode = (beta - alpha != 1);
-    MovePicker mp = MovePicker(pos, pvNode, MOVE_NONE, EmptySearchStack, depth, isCheck ? NULL : &ei);
+    MovePicker mp = MovePicker(pos, pvNode, MOVE_NONE, EmptySearchStack, depth);
     Move move;
     int moveCount = 0;
     Bitboard dcCandidates = mp.discovered_check_candidates();
-    bool enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
+    Color us = pos.side_to_move();
+    bool enoughMaterial = pos.non_pawn_material(us) > RookValueMidgame;
 
     // Loop through the moves until no moves remain or a beta cutoff
     // occurs.
@@ -1495,7 +1522,7 @@ namespace {
                               + Max(pos.midgame_value_of_piece_on(move_to(move)),
                                     pos.endgame_value_of_piece_on(move_to(move)))
                               + (move_is_ep(move) ? PawnValueEndgame : Value(0))
-                              + FutilityMargin0
+                              + FutilityMarginQS
                               + ei.futilityMargin;
 
           if (futilityValue < alpha)
@@ -1515,10 +1542,10 @@ namespace {
           continue;
 
       // Make and search the move.
-      UndoInfo u;
-      pos.do_move(move, u, dcCandidates);
+      StateInfo st;
+      pos.do_move(move, st, dcCandidates);
       Value value = -qsearch(pos, ss, -beta, -alpha, depth-OnePly, ply+1, threadID);
-      pos.undo_move(move, u);
+      pos.undo_move(move);
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
@@ -1541,9 +1568,6 @@ namespace {
 
     assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
 
-    // Update transposition table
-    TT.store(pos, value_to_tt(bestValue, ply), depth, MOVE_NONE, VALUE_TYPE_EXACT);
-
     // Update killers only for good check moves
     Move m = ss[ply].currentMove;
     if (alpha >= beta && ok_to_history(pos, m)) // Only non capture moves are considered
@@ -1594,7 +1618,7 @@ namespace {
 
       // Decide the new search depth.
       bool dangerous;
-      Depth ext = extension(pos, move, false, moveIsCheck, false, false, &dangerous);
+      Depth ext = extension(pos, move, false, moveIsCapture, moveIsCheck, false, false, &dangerous);
       Depth newDepth = sp->depth - OnePly + ext;
 
       // Prune?
@@ -1607,8 +1631,8 @@ namespace {
         continue;
 
       // Make and search the move.
-      UndoInfo u;
-      pos.do_move(move, u, sp->dcCandidates);
+      StateInfo st;
+      pos.do_move(move, st, sp->dcCandidates);
 
       // 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.
@@ -1630,7 +1654,7 @@ namespace {
           ss[sp->ply].reduction = Depth(0);
           value = -search(pos, ss, -(sp->beta - 1), newDepth, sp->ply+1, true, threadID);
       }
-      pos.undo_move(move, u);
+      pos.undo_move(move);
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
@@ -1712,12 +1736,12 @@ namespace {
 
       // Decide the new search depth.
       bool dangerous;
-      Depth ext = extension(pos, move, true, moveIsCheck, false, false, &dangerous);
+      Depth ext = extension(pos, move, true, moveIsCapture, moveIsCheck, false, false, &dangerous);
       Depth newDepth = sp->depth - OnePly + ext;
 
       // Make and search the move.
-      UndoInfo u;
-      pos.do_move(move, u, sp->dcCandidates);
+      StateInfo st;
+      pos.do_move(move, st, sp->dcCandidates);
 
       // 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.
@@ -1753,7 +1777,7 @@ namespace {
               Threads[threadID].failHighPly1 = false;
         }
       }
-      pos.undo_move(move, u);
+      pos.undo_move(move);
 
       assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
 
@@ -1878,15 +1902,15 @@ namespace {
         if (includeMove)
         {
             // Find a quick score for the move
-            UndoInfo u;
+            StateInfo st;
             SearchStack ss[PLY_MAX_PLUS_2];
 
             moves[count].move = mlist[i].move;
             moves[count].nodes = 0ULL;
-            pos.do_move(moves[count].move, u);
+            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, u);
+            pos.undo_move(moves[count].move);
             moves[count].pv[0] = moves[i].move;
             moves[count].pv[1] = MOVE_NONE; // FIXME
             count++;
@@ -1988,34 +2012,6 @@ namespace {
   }
 
 
-  // init_search_stack() initializes a search stack at the beginning of a
-  // new search from the root.
-  void init_search_stack(SearchStack& ss) {
-
-    ss.pv[0] = MOVE_NONE;
-    ss.pv[1] = MOVE_NONE;
-    ss.currentMove = MOVE_NONE;
-    ss.threatMove = MOVE_NONE;
-    ss.reduction = Depth(0);
-    for (int j = 0; j < KILLER_MAX; j++)
-        ss.killers[j] = MOVE_NONE;
-  }
-
-  void init_search_stack(SearchStack ss[]) {
-
-    for (int i = 0; i < 3; i++)
-    {
-        ss[i].pv[i] = MOVE_NONE;
-        ss[i].pv[i+1] = MOVE_NONE;
-        ss[i].currentMove = MOVE_NONE;
-        ss[i].threatMove = MOVE_NONE;
-        ss[i].reduction = Depth(0);
-        for (int j = 0; j < KILLER_MAX; j++)
-            ss[i].killers[j] = MOVE_NONE;
-    }
-  }
-
-
   // init_node() is called at the beginning of all the search functions
   // (search(), search_pv(), qsearch(), and so on) and initializes the search
   // stack object corresponding to the current node.  Once every
@@ -2035,13 +2031,9 @@ namespace {
         NodesSincePoll = 0;
       }
     }
-    ss[ply].pv[ply] = ss[ply].pv[ply+1] = ss[ply].currentMove = MOVE_NONE;
-    ss[ply+2].mateKiller = MOVE_NONE;
-    ss[ply].threatMove = MOVE_NONE;
-    ss[ply].reduction = Depth(0);
-    ss[ply].currentMoveCaptureValue = Value(0);
-    for (int j = 0; j < KILLER_MAX; j++)
-        ss[ply+2].killers[j] = MOVE_NONE;
+
+    ss[ply].init(ply);
+    ss[ply+2].initKillers();
 
     if(Threads[threadID].printCurrentLine)
       print_current_line(ss, ply, threadID);
@@ -2112,7 +2104,7 @@ namespace {
 
     // Case 4: The destination square for m2 is attacked by the moving piece
     // in m1:
-    if(pos.piece_attacks_square(t1, t2))
+    if(pos.piece_attacks_square(pos.piece_on(t1), t1, t2))
       return true;
 
     // Case 5: Discovered check, checking piece is the piece moved in m1:
@@ -2177,7 +2169,7 @@ namespace {
   // extended, as example because the corresponding UCI option is set to zero,
   // the move is marked as 'dangerous' so, at least, we avoid to prune it.
 
-  Depth extension(const Position &pos, Move m, bool pvNode, bool check,
+  Depth extension(const Position& pos, Move m, bool pvNode, bool capture, bool check,
                   bool singleReply, bool mateThreat, bool* dangerous) {
 
     assert(m != MOVE_NONE);
@@ -2194,18 +2186,21 @@ namespace {
     if (mateThreat)
         result += MateThreatExtension[pvNode];
 
-    if (pos.move_is_pawn_push_to_7th(m))
+    if (pos.type_of_piece_on(move_from(m)) == PAWN)
     {
-        result += PawnPushTo7thExtension[pvNode];
-        *dangerous = true;
-    }
-    if (pos.move_is_passed_pawn_push(m))
-    {
-        result += PassedPawnExtension[pvNode];
-        *dangerous = true;
+        if (pos.move_is_pawn_push_to_7th(m))
+        {
+            result += PawnPushTo7thExtension[pvNode];
+            *dangerous = true;
+        }
+        if (pos.move_is_passed_pawn_push(m))
+        {
+            result += PassedPawnExtension[pvNode];
+            *dangerous = true;
+        }
     }
 
-    if (   pos.move_is_capture(m)
+    if (   capture
         && pos.type_of_piece_on(move_to(m)) != PAWN
         && (  pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
             - pos.midgame_value_of_piece_on(move_to(m)) == Value(0))
@@ -2217,7 +2212,7 @@ namespace {
     }
 
     if (   pvNode
-        && pos.move_is_capture(m)
+        && capture
         && pos.type_of_piece_on(move_to(m)) != PAWN
         && pos.see(m) >= 0)
     {
@@ -2448,7 +2443,7 @@ namespace {
                      || (  !FailHigh && !fail_high_ply_1() && !Problem
                          && t > 6*(MaxSearchTime + ExtraSearchTime));
 
-    if (   (Iteration >= 2 && (!InfiniteSearch && overTime))
+    if (   (Iteration >= 3 && (!InfiniteSearch && overTime))
         || (ExactMaxTime && t >= ExactMaxTime)
         || (Iteration >= 3 && MaxNodes && nodes_searched() >= MaxNodes))
         AbortSearch = true;
@@ -2462,7 +2457,7 @@ namespace {
   void ponderhit() {
     int t = current_search_time();
     PonderSearch = false;
-    if(Iteration >= 2 &&
+    if(Iteration >= 3 &&
        (!InfiniteSearch && (StopOnPonderhit ||
                             t > AbsoluteMaxSearchTime ||
                             (RootMoveNumber == 1 &&
@@ -2670,9 +2665,9 @@ namespace {
   // splitPoint->cpus becomes 0), split() returns true.
 
   bool split(const Position &p, SearchStack *sstck, int ply,
-             Value *alpha, Value *beta, Value *bestValue,
-             Depth depth, int *moves,
+             Value *alpha, Value *beta, Value *bestValue, Depth depth, int *moves,
              MovePicker *mp, Bitboard dcCandidates, int master, bool pvNode) {
+
     assert(p.is_ok());
     assert(sstck != NULL);
     assert(ply >= 0 && ply < PLY_MAX);