Partial insertion sort

the order of elements returned by std::partition is implementation defined (since not stable) and could depend on the version of libstdc++ linked.
As std::stable_partition was tested to be too slow (http://tests.stockfishchess.org/tests/view/585cdfd00ebc5903140c6082).
Instead combine partition with our custom implementation of insert_sort, which fixes this issue.
Implementation based on a patch by mstembera (http://tests.stockfishchess.org/tests/view/58d4d3460ebc59035df3315c), which suggests some benefit by itself.
Higher depth moves are all sorted (INT_MIN version), as in current master.

STC:
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 33116 W: 6161 L: 6061 D: 20894

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 88703 W: 11572 L: 11540 D: 65591

Bench: 6256522

Closes #1058
Closes #1065

diff --git a/src/movepick.cpp b/src/movepick.cpp
index 2ea859a26fcf2b9ef4dadfe42d03c0806d082679..8a4a8b8f75642b7997f4574b6485f8877a54d721 100644 (file)
--- a/src/movepick.cpp
+++ b/src/movepick.cpp
@@ -34,18 +34,21 @@ namespace {
     QSEARCH_RECAPTURES, QRECAPTURES
   };
 
     QSEARCH_RECAPTURES, QRECAPTURES
   };
 

-  // Our insertion sort, which is guaranteed to be stable, as it should be
-  void insertion_sort(ExtMove* begin, ExtMove* end)
+  // An insertion sort, which sorts moves in descending order up to and including a given limit.
+  // The order of moves smaller than the limit is left unspecified.
+  // To keep the implementation simple, *begin is always included in the list of sorted moves.
+  void partial_insertion_sort(ExtMove* begin, ExtMove* end, Value limit)

   {
   {

-    ExtMove tmp, *p, *q;
-
-    for (p = begin + 1; p < end; ++p)
-    {
-        tmp = *p;
-        for (q = p; q != begin && *(q-1) < tmp; --q)
-            *q = *(q-1);
-        *q = tmp;
-    }
+    for (ExtMove *sortedEnd = begin + 1, *p = begin + 1; p < end; ++p)
+        if (p->value >= limit)
+        {
+            ExtMove tmp = *p, *q;
+            *p = *sortedEnd;
+            for (q = sortedEnd; q != begin && *(q-1) < tmp; --q)
+                *q = *(q-1);
+            *q = tmp;
+            ++sortedEnd;
+        }

   }
 
   // pick_best() finds the best move in the range (begin, end) and moves it to
   }
 
   // pick_best() finds the best move in the range (begin, end) and moves it to


@@ -238,13 +241,9 @@ Move MovePicker::next_move(bool skipQuiets) {
       cur = endBadCaptures;
       endMoves = generate<QUIETS>(pos, cur);
       score<QUIETS>();
       cur = endBadCaptures;
       endMoves = generate<QUIETS>(pos, cur);
       score<QUIETS>();

-      if (depth < 3 * ONE_PLY)
-      {
-          ExtMove* goodQuiet = std::partition(cur, endMoves, [](const ExtMove& m)
-                                             { return m.value > VALUE_ZERO; });
-          insertion_sort(cur, goodQuiet);
-      } else
-          insertion_sort(cur, endMoves);
+
+      partial_insertion_sort(cur, endMoves,
+                             depth < 3 * ONE_PLY ? VALUE_ZERO : Value(INT_MIN));

       ++stage;
 
   case QUIET:
       ++stage;
 
   case QUIET: