Delay costly SEE call during captures ordering in MovePicker

When ordering moves we push all captures with negative SEE values
to badCaptures[] array during the scoring phase.

This patch delays the costly SEE call up to when the move has been
picked up in pick_move_from_list(), this way we save some SEE calls
in case we get a cutoff.

It seems we have a speed gain of about 1-1.5 % in terms of nodes/sec
and profiling seems to confirm the small but real speed increase.

Idea from Pablo Vazquez on talkchess.com
http://www.talkchess.com/forum/viewtopic.php?t=29018&start=20

It would be a no functional change but actually it is not because
now sorting set is different and so std::sort(), that is not a
stable sort, does not guarantees the order of same scored moves to
remain the same as before.

After 952 games at 1+0 we are below error bar, almost equal just
6 games of difference (+2 ELO)

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

diff --git a/src/movepick.cpp b/src/movepick.cpp
index 25cbdefd0b10a1b23e9674a35b09776c6bebe98e..af530c5c3e6159b5b24da0ba633bc9fc770ef6d0 100644 (file)
--- a/src/movepick.cpp
+++ b/src/movepick.cpp
@@ -141,12 +141,10 @@ Move MovePicker::get_next_move() {
         score_captures();
         std::sort(moves, moves + numOfMoves);
         movesPicked = 0;
         score_captures();
         std::sort(moves, moves + numOfMoves);
         movesPicked = 0;

-        checkLegal = true;

         break;
 
     case PH_KILLERS:
         movesPicked = numOfMoves = 0;
         break;
 
     case PH_KILLERS:
         movesPicked = numOfMoves = 0;

-        checkLegal = false;

         if (killer1 != MOVE_NONE && move_is_legal(pos, killer1, pinned) && !pos.move_is_capture(killer1))
             moves[numOfMoves++].move = killer1;
         if (killer2 != MOVE_NONE && move_is_legal(pos, killer2, pinned) && !pos.move_is_capture(killer2) )
         if (killer1 != MOVE_NONE && move_is_legal(pos, killer1, pinned) && !pos.move_is_capture(killer1))
             moves[numOfMoves++].move = killer1;
         if (killer2 != MOVE_NONE && move_is_legal(pos, killer2, pinned) && !pos.move_is_capture(killer2) )


@@ -155,16 +153,16 @@ Move MovePicker::get_next_move() {
 
     case PH_NONCAPTURES:
         checkKillers = (numOfMoves != 0); // previous phase is PH_KILLERS
 
     case PH_NONCAPTURES:
         checkKillers = (numOfMoves != 0); // previous phase is PH_KILLERS

+        checkLegal = true;

         numOfMoves = generate_noncaptures(pos, moves);
         score_noncaptures();
         std::sort(moves, moves + numOfMoves);
         movesPicked = 0;
         numOfMoves = generate_noncaptures(pos, moves);
         score_noncaptures();
         std::sort(moves, moves + numOfMoves);
         movesPicked = 0;

-        checkLegal = true;

         break;
 
     case PH_BAD_CAPTURES:
         break;
 
     case PH_BAD_CAPTURES:

-        // Bad captures SEE value is already calculated by score_captures()
-        // so just sort them to get SEE move ordering.
+        // Bad captures SEE value is already calculated so just sort them
+        // to get SEE move ordering.

         std::sort(badCaptures, badCaptures + numOfBadCaptures);
         movesPicked = 0;
         break;
         std::sort(badCaptures, badCaptures + numOfBadCaptures);
         movesPicked = 0;
         break;


@@ -179,7 +177,7 @@ Move MovePicker::get_next_move() {
 
     case PH_QCAPTURES:
         numOfMoves = generate_captures(pos, moves);
 
     case PH_QCAPTURES:
         numOfMoves = generate_captures(pos, moves);

-        score_qcaptures();
+        score_captures();

         std::sort(moves, moves + numOfMoves);
         movesPicked = 0;
         break;
         std::sort(moves, moves + numOfMoves);
         movesPicked = 0;
         break;


@@ -229,38 +227,28 @@ Move MovePicker::get_next_move(Lock &lock) {
 void MovePicker::score_captures() {
   // Winning and equal captures in the main search are ordered by MVV/LVA.
   // Suprisingly, this appears to perform slightly better than SEE based
 void MovePicker::score_captures() {
   // Winning and equal captures in the main search are ordered by MVV/LVA.
   // Suprisingly, this appears to perform slightly better than SEE based

-  // move ordering.  The reason is probably that in a position with a winning
+  // move ordering. The reason is probably that in a position with a winning

   // capture, capturing a more valuable (but sufficiently defended) piece
   // capture, capturing a more valuable (but sufficiently defended) piece

-  // first usually doesn't hurt.  The opponent will have to recapture, and
+  // first usually doesn't hurt. The opponent will have to recapture, and

   // the hanging piece will still be hanging (except in the unusual cases
   // where it is possible to recapture with the hanging piece). Exchanging
   // big pieces before capturing a hanging piece probably helps to reduce
   // the subtree size.
   // the hanging piece will still be hanging (except in the unusual cases
   // where it is possible to recapture with the hanging piece). Exchanging
   // big pieces before capturing a hanging piece probably helps to reduce
   // the subtree size.

-  // While scoring captures it moves all captures with negative SEE values
-  // to the badCaptures[] array.
+  // In main search we want to push captures with negative SEE values to
+  // badCaptures[] array, but instead of doing it now we delay till when
+  // the move has been picked up in pick_move_from_list(), this way we save
+  // some SEE calls in case we get a cutoff (idea from Pablo Vazquez).

   Move m;
   Move m;

-  int seeValue;

 
 

+  // Use MVV/LVA ordering

   for (int i = 0; i < numOfMoves; i++)
   {
       m = moves[i].move;
   for (int i = 0; i < numOfMoves; i++)
   {
       m = moves[i].move;

-      seeValue = pos.see_sign(m);
-      if (seeValue >= 0)
-      {
-          if (move_is_promotion(m))
-              moves[i].score = QueenValueMidgame;
-          else
-              moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
-                              -int(pos.type_of_piece_on(move_from(m)));
-      }
+      if (move_is_promotion(m))
+          moves[i].score = QueenValueMidgame;

       else
       else

-      {
-          // Losing capture, move it to the badCaptures[] array
-          assert(numOfBadCaptures < 63);
-          moves[i].score = seeValue;
-          badCaptures[numOfBadCaptures++] = moves[i];
-          moves[i--] = moves[--numOfMoves];
-      }
+          moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
+                          -int(pos.type_of_piece_on(move_from(m)));

   }
 }
 
   }
 }
 


@@ -304,20 +292,6 @@ void MovePicker::score_evasions() {
   }
 }
 
   }
 }
 

-void MovePicker::score_qcaptures() {
-
-  // Use MVV/LVA ordering
-  for (int i = 0; i < numOfMoves; i++)
-  {
-      Move m = moves[i].move;
-      if (move_is_promotion(m))
-          moves[i].score = QueenValueMidgame;
-      else
-          moves[i].score = int(pos.midgame_value_of_piece_on(move_to(m)))
-                          -int(pos.type_of_piece_on(move_from(m)));
-  }
-}
-

 
 /// MovePicker::pick_move_from_list() picks the move with the biggest score
 /// from a list of generated moves (moves[] or badCaptures[], depending on
 
 /// MovePicker::pick_move_from_list() picks the move with the biggest score
 /// from a list of generated moves (moves[] or badCaptures[], depending on


@@ -333,6 +307,26 @@ Move MovePicker::pick_move_from_list() {
   switch (PhaseTable[phaseIndex]) {
 
   case PH_GOOD_CAPTURES:
   switch (PhaseTable[phaseIndex]) {
 
   case PH_GOOD_CAPTURES:

+      while (movesPicked < numOfMoves)
+      {
+          Move move = moves[movesPicked++].move;
+          if (   move != ttMove
+              && move != mateKiller
+              && pos.pl_move_is_legal(move, pinned))
+          {
+              // Check for a non negative SEE now
+              int seeValue = pos.see_sign(move);
+              if (seeValue >= 0)
+                  return move;
+
+              // Losing capture, move it to the badCaptures[] array, note
+              // that move has now been already checked for legality.
+              assert(numOfBadCaptures < 63);
+              badCaptures[numOfBadCaptures].move = move;
+              badCaptures[numOfBadCaptures++].score = seeValue;
+          }
+      }
+      break;

   case PH_KILLERS:
   case PH_NONCAPTURES:
       while (movesPicked < numOfMoves)
   case PH_KILLERS:
   case PH_NONCAPTURES:
       while (movesPicked < numOfMoves)


@@ -349,18 +343,11 @@ Move MovePicker::pick_move_from_list() {
   case PH_EVASIONS:
       if (movesPicked < numOfMoves)
           return moves[movesPicked++].move;
   case PH_EVASIONS:
       if (movesPicked < numOfMoves)
           return moves[movesPicked++].move;

-

       break;
 
   case PH_BAD_CAPTURES:
       break;
 
   case PH_BAD_CAPTURES:

-      while (movesPicked < numOfBadCaptures)
-      {
-          Move move = badCaptures[movesPicked++].move;
-          if (   move != ttMove
-              && move != mateKiller
-              && pos.pl_move_is_legal(move, pinned))
-              return move;
-      }
+      if (movesPicked < numOfBadCaptures)
+          return badCaptures[movesPicked++].move;

       break;
 
   case PH_QCAPTURES:
       break;
 
   case PH_QCAPTURES:

diff --git a/src/movepick.h b/src/movepick.h
index bcd5eb14e1b57cb77d92d81cd3bd5a8640920bb8..920a97573029fedb093e0ba981e5c188b620df36 100644 (file)
--- a/src/movepick.h
+++ b/src/movepick.h
@@ -77,7 +77,6 @@ private:
   void score_captures();
   void score_noncaptures();
   void score_evasions();
   void score_captures();
   void score_noncaptures();
   void score_evasions();

-  void score_qcaptures();

   Move pick_move_from_list();
 
   const Position& pos;
   Move pick_move_from_list();
 
   const Position& pos;