guard against fixed tt insertion race

If insert fails due to the hash already being present, an effort is made to
use the cached one instead.

Author: borg323

src/search/dag_classic/search.cc

@@ -2239,17 +2239,23 @@ void SearchWorker::DoBackupUpdateSingleNode(
   if (node_to_process.nn_queried) {
 #ifdef FIX_TT
     auto entry = search_->tt_->LookupAndPin(node_to_process.hash);
+    if (!entry) {
+      bool insert_ok = search_->tt_->Insert(
+          node_to_process.hash, std::make_unique<std::weak_ptr<LowNode>>(
+                                    node_to_process.tt_low_node));
+      if (!insert_ok) {
+        // The insert may fail if another thread added the same hash.
+        // In the unlikely case it fails, the search will still work OK.
+        entry = search_->tt_->LookupAndPin(node_to_process.hash);
+      }
+    }
     bool is_tt_miss = !entry;
 #else
     auto [tt_iter, is_tt_miss] = search_->tt_->try_emplace(
         node_to_process.hash, node_to_process.tt_low_node);
 #endif
     if (is_tt_miss) {
-#ifdef FIX_TT
-      search_->tt_->Insert(node_to_process.hash,
-                           std::make_unique<std::weak_ptr<LowNode>>(
-                               node_to_process.tt_low_node));
-#else
+#ifndef FIX_TT
       assert(!tt_iter->second.expired());
 #endif
       node_to_process.node->SetLowNode(node_to_process.tt_low_node);

src/utils/cache.h

@@ -63,8 +63,9 @@ class HashKeyedCache {
 
   // Inserts the element under key @key with value @val. Unless the key is
   // already in the cache.
-  void Insert(uint64_t key, std::unique_ptr<V> val) {
-    if (capacity_.load(std::memory_order_relaxed) == 0) return;
+  // Returns false if the hash is found in the cache, blocking insertion.
+  bool Insert(uint64_t key, std::unique_ptr<V> val) {
+    if (capacity_.load(std::memory_order_relaxed) == 0) return true;
 
     SpinMutex::Lock lock(mutex_);
 
@@ -73,7 +74,7 @@ class HashKeyedCache {
       if (!hash_[idx].in_use) break;
       if (hash_[idx].key == key) {
         // Already exists.
-        return;
+        return false;
       }
       ++idx;
       if (idx >= hash_.size()) idx -= hash_.size();
@@ -87,6 +88,7 @@ class HashKeyedCache {
     ++allocated_;
 
     EvictToCapacity(capacity_);
+    return true;
   }
 
   // Checks whether a key exists. Doesn't pin. Of course the next moment the