guard against fixed tt insertion race

If insert fails due to the hash already being present, the cached one will
be used instead.

Author: borg323

src/search/dag_classic/search.cc

@@ -2246,13 +2246,18 @@ void SearchWorker::DoBackupUpdateSingleNode(
 #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));
+      // If Insert() fails due to the hash being present, it will return the
+      // cached value to be used instead.
+      node_to_process.node->SetLowNode(
+          search_->tt_
+              ->Insert(node_to_process.hash,
+                       std::make_unique<std::weak_ptr<LowNode>>(
+                           node_to_process.tt_low_node))
+              .lock());
 #else
       assert(!tt_iter->second.expired());
-#endif
       node_to_process.node->SetLowNode(node_to_process.tt_low_node);
+#endif
     } else {
 #ifdef FIX_TT
       auto tt_low_node = entry->lock();

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 a reference to the inserted element or the one blocking insertion.
+  const V& Insert(uint64_t key, std::unique_ptr<V> val) {
+    if (capacity_.load(std::memory_order_relaxed) == 0) return *val;
 
     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 *hash_[idx].value;
       }
       ++idx;
       if (idx >= hash_.size()) idx -= hash_.size();
@@ -87,6 +88,7 @@ class HashKeyedCache {
     ++allocated_;
 
     EvictToCapacity(capacity_);
+    return *hash_[idx].value;
   }
 
   // Checks whether a key exists. Doesn't pin. Of course the next moment the