TT Loop Optimizations

[Britvich]

Optimizations to the loops in the TT have been shown to increase Elo by ~2 points (under heavy cache pressure):

Note: This patch is a boiled-down version of tt_sailfish that only includes the minimal changes necessary to perform these loop optimizations.

The loop in store that finds the best entry to replace has been optimized so the check for a better replacement candidate never takes place against the first entry of a given cluster. Since this line:

  tte = replace = first_entry(key);

...already sets replace to the first entry in a cluster, there is no need consider the first entry again as a better replacement candidate. This means the check:

  // Is the next entry a better candidate for replacement?
  if ((tte->gen() == generation || tte->bound() == BOUND_EXACT)
       - (replace->gen() == generation)
       - (tte->depth8 < replace->depth8) < 0)

...only needs to be executed a maximum of 2 times, instead of the current maximum of 3 times.

In addition, the probe loop has been unrolled, avoiding some unnecessary housekeeping instructions.

No functional change

[lucasart]

That's already a better pull request. But still not commitable as is. I ran test with only the loop unrolling of TranspositionTable::probe():

diff --git a/src/tt.cpp b/src/tt.cpp
index 46d891c..edbd77c 100644
--- a/src/tt.cpp
+++ b/src/tt.cpp
@@ -72,14 +72,11 @@ const TTEntry* TranspositionTable::probe(const Key key) const {
   TTEntry* tte = first_entry(key);
   uint16_t key16 = key >> 48;

-  for (unsigned i = 0; i < TTClusterSize; ++i, ++tte)
-      if (tte->key16 == key16)
-      {
-          tte->genBound8 = generation | tte->bound(); // Refresh
-          return tte;
-      }
+  if (tte->key16 != key16 && (++tte)->key16 != key16 && (++tte)->key16 != key16)
+    return NULL;

-  return NULL;
+  tte->genBound8 = generation | tte->bound(); // Refresh
+  return tte;
}

And the result is a slowdown on my machine. To measure it, I ran stockfish bench 4 50 times:

stat    unrolling    master    diff
average 2,477,087 2,500,060 −22,974
stdev       7,014     7,399  10,195

2.25 stdev is statistically significant (probability of slowdown is 98.8% based on these results).