Implement killer move heuristic.

If a move from ttable is available, regardless of depth
requirement, we search this first in the hopes that this will
cause more cutoffs.

Makes a _huge_ impact on bench score. Very slightly lower nodes/second,
but speed is reduced by ~50%.

Average of 3 bench results on MacBook Air 2015:

v1.6.0:
===========================
Total time (ms) : 11530
Nodes searched  : 11924519
Nodes/second    : 1034217

v1.5.1:
===========================
Total time (ms) : 21660
Nodes searched  : 23289650
Nodes/second    : 1075221

Author: bsamseth

Diff for: CMakeLists.txt

@@ -10,7 +10,7 @@
 cmake_minimum_required(VERSION 3.0)
 
 # Set project name here.
-project(Goldfish VERSION 1.5.1 LANGUAGES CXX)
+project(Goldfish VERSION 1.6.0 LANGUAGES CXX)
 
 
 # Include stuff. No change needed.

Diff for: include/movelist.hpp

@@ -26,6 +26,8 @@ class MoveList {
     void sort();
 
     void rate_from_Mvvlva();
+
+    void add_killer(Move m);
 };
 
 class MoveVariation {

Diff for: src/movelist.cpp

@@ -1,3 +1,5 @@
+#include <algorithm>
+#include <cassert>
 #include "movelist.hpp"
 
 namespace goldfish {
@@ -27,6 +29,23 @@ void MoveList<T>::sort() {
     }
 }
 
+/**
+ * Move the given move to the front of the array, keeping
+ * all others in the same order.
+ */
+template<class T>
+void MoveList<T>::add_killer(Move m) {
+    for (auto killer = entries.rbegin(); killer != entries.rend(); ++killer) {
+        if ((*killer)->move == m) {
+            // Right shift the subarray [begin, entry] by one shift.
+            std::rotate(killer, killer + 1, entries.rend());
+            return;
+        }
+    }
+    // The move should always be in the list.
+    assert(false);
+}
+
 /**
  * Rates the moves in the list according to "Most Valuable Victim - Least Valuable Aggressor".
  */

Diff for: src/search.cpp

@@ -393,48 +393,45 @@ void Search::search_root(Depth depth, int alpha, int beta) {
 int Search::search(Depth depth, int alpha, int beta, int ply) {
     // Check TTable before anything else is done.
     auto entry = ttable.probe(position.zobrist_key);
-    if (entry != nullptr) {
-        if (entry->depth() >= depth) {
-
-            switch (entry->bound()) {
-
-                case Bound::EXACT:
-                    // In the case of exact scores, we can always return
-                    // right away. Just update best move if we exceed alpha.
-                    if (entry->value() > alpha)
-                        save_pv(entry->move(), pv[ply + 1], pv[ply]);
-                    update_search(ply);
-                    return entry->value();
-
-                case Bound::LOWER:
-                    // With a lower bound we check if we should update alpha.
-                    // After all this we
-                    if (entry->value() > alpha) {
-                        save_pv(entry->move(), pv[ply + 1], pv[ply]);
-                        alpha = entry->value();
-
-                        // Check for zero-size search window.
-                        if (entry->value() >= beta) {
-                            update_search(ply);
-                            return entry->value();
-                        }
-                    }
-                    break;
-
-                case Bound::UPPER:
-                    // For upper bounds, we can stop if the bound
-                    // is leq than alpha because no move will improve alpha.
-                    // If alpha < bound we have no usefull info, as the
-                    // exact value could still be less than alpha, so we
-                    // cannot update alpha and pv yet.
-                    if (entry->value() <= alpha) {
+    if (entry != nullptr and entry->depth() >= depth) {
+        switch (entry->bound()) {
+
+            case Bound::EXACT:
+                // In the case of exact scores, we can always return
+                // right away. Just update best move if we exceed alpha.
+                if (entry->value() > alpha)
+                    save_pv(entry->move(), pv[ply + 1], pv[ply]);
+                update_search(ply);
+                return entry->value();
+
+            case Bound::LOWER:
+                // With a lower bound we check if we should update alpha.
+                // After all this we
+                if (entry->value() > alpha) {
+                    save_pv(entry->move(), pv[ply + 1], pv[ply]);
+                    alpha = entry->value();
+
+                    // Check for zero-size search window.
+                    if (entry->value() >= beta) {
                         update_search(ply);
                         return entry->value();
                     }
-                    break;
-                default:
-                    throw std::exception();
-            }
+                }
+                break;
+
+            case Bound::UPPER:
+                // For upper bounds, we can stop if the bound
+                // is leq than alpha because no move will improve alpha.
+                // If alpha < bound we have no usefull info, as the
+                // exact value could still be less than alpha, so we
+                // cannot update alpha and pv yet.
+                if (entry->value() <= alpha) {
+                    update_search(ply);
+                    return entry->value();
+                }
+                break;
+            default:
+                throw std::exception();
         }
     }
 
@@ -500,6 +497,15 @@ int Search::search(Depth depth, int alpha, int beta, int ply) {
     }
 
     MoveList<MoveEntry> &moves = move_generators[ply].get_moves(position, depth, is_check);
+
+    // Killer Move Heuristic:
+    // If lookup didn't cause a cutoff, including if we don't have the required depth to use
+    // the table entry, lets use the stored move as a killer move,
+    // searching it first in the hopes that it will lead to more cutoffs.
+    if (entry != nullptr and entry->move() != Move::NO_MOVE) {
+        moves.add_killer(entry->move());
+    }
+
     for (int i = 0; i < moves.size; i++) {
         Move move = moves.entries[i]->move;
         int value = best_value;