fix(mem usage): XORFastHash lost lines (#7456)

Author: MarcelloPerathoner

include/contractor/contractor_search.hpp

@@ -11,6 +11,29 @@
 namespace osrm::contractor
 {
 
+/**
+ * Stop search after this many settled nodes during contraction simulation.
+ */
+constexpr std::size_t SIMULATION_SEARCH_SPACE_SIZE = 1000;
+/**
+ * Stop search after this many settled nodes during contraction. Tuning parameter:
+ * Bigger search space is slower but may produce smaller contracted graph.
+ */
+constexpr std::size_t FULL_SEARCH_SPACE_SIZE = 2000;
+/**
+ * Size of the contractor heap storage. Bigger heap storage is faster but increases
+ * memory consumption. Must be a power of two.
+ */
+constexpr std::size_t HASH_MAP_CAPACITY = 1u << 13;
+
+static_assert((HASH_MAP_CAPACITY & (HASH_MAP_CAPACITY - 1)) == 0,
+              "HASH_MAP_CAPACITY must be a power of two");
+/**
+ * Stop search after this many relaxed nodes during contraction. Protection against heap
+ * storage overflow. Must be less than HASH_MAP_CAPACITY. Should be 50-75% of HASH_MAP_CAPACITY.
+ */
+constexpr std::size_t RELAXED_NODE_LIMIT = HASH_MAP_CAPACITY * 0.75;
+
 void search(ContractorHeap &heap,
             const ContractorGraph &graph,
             const std::vector<bool> &contractable,

include/util/linear_hash_storage.hpp

@@ -2,10 +2,13 @@
 #define LINEAR_HASH_STORAGE
 
 #include <concepts>
+#include <cstddef>
 #include <cstdlib>
 #include <limits>
 #include <vector>
 
+#include <boost/assert.hpp>
+
 namespace osrm::util
 {
 
@@ -45,25 +48,13 @@ class LinearHashStorage
     };
 
     std::vector<HashCell> cells;
-    unsigned current_timestamp;
+    unsigned current_timestamp{0u};
     std::size_t mask;
 
   public:
-    explicit LinearHashStorage(std::size_t size) : current_timestamp{0u}
+    explicit LinearHashStorage(std::size_t size) : cells(size), mask{size - 1}
     {
-        // round up to the next power of two
-        // See: Figure 3.3 in Warren Henry S., Hacker's Delight, 2nd ed., Pearson 2013
-        --size;
-        size = size | (size >> 1);
-        size = size | (size >> 2);
-        size = size | (size >> 4);
-        size = size | (size >> 8);
-        size = size | (size >> 16);
-        size = size | (size >> 32);
-        mask = size;
-        ++size;
-
-        cells.resize(size);
+        BOOST_ASSERT_MSG((size & mask) == 0, "size must be a power of 2");
     }
 
     ValueType &operator[](const KeyType key)

include/util/query_heap.hpp

@@ -6,8 +6,8 @@
 
 #include "d_ary_heap.hpp"
 #include <algorithm>
+#include <cstddef>
 #include <limits>
-#include <optional>
 #include <unordered_map>
 #include <vector>
 
@@ -168,10 +168,15 @@ class QueryHeap
         heap.clear();
         inserted_nodes.clear();
         node_index.Clear();
+        occupancy = 0;
     }
 
+    /** Returns the number of nodes currently in the heap. */
     std::size_t Size() const { return heap.size(); }
 
+    /** Returns the total number of nodes inserted into the heap storage. */
+    std::size_t Occupancy() const { return occupancy; }
+
     bool Empty() const { return 0 == Size(); }
 
     void Insert(NodeID node, Weight weight, const Data &data)
@@ -186,6 +191,7 @@ class QueryHeap
                      [this](const auto &heapData, auto new_handle)
                      { inserted_nodes[heapData.index].handle = new_handle; });
         node_index[node] = index;
+        ++occupancy;
 
         checkInvariants();
     }
@@ -337,6 +343,7 @@ class QueryHeap
     std::vector<HeapNode> inserted_nodes;
     HeapContainer heap;
     IndexStorage node_index;
+    std::size_t occupancy{0};
 };
 
 } // namespace osrm::util

src/contractor/contractor_search.cpp

@@ -8,7 +8,7 @@ namespace osrm::contractor
 
 namespace
 {
-void relaxNode(ContractorHeap &heap,
+bool relaxNode(ContractorHeap &heap,
                const ContractorGraph &graph,
                const std::vector<bool> &contractable,
                const NodeID node,
@@ -39,6 +39,8 @@ void relaxNode(ContractorHeap &heap,
             {
                 continue;
             }
+            if (heap.Occupancy() >= RELAXED_NODE_LIMIT)
+                return true; // stop search
             heap.Insert(to, to_weight, ContractorHeapData{current_hop, false});
         }
         // Found a shorter Path -> Update weight
@@ -49,25 +51,26 @@ void relaxNode(ContractorHeap &heap,
             toHeapNode->data.hop = current_hop;
         }
     }
+    return false;
 }
 } // namespace
 
 void search(ContractorHeap &heap,
             const ContractorGraph &graph,
             const std::vector<bool> &contractable,
             const unsigned number_of_targets,
-            const int node_limit,
+            const int settled_node_limit,
             const EdgeWeight weight_limit,
             const NodeID forbidden_node)
 {
-    int nodes = 0;
+    int settled_nodes = 0;
     unsigned number_of_targets_found = 0;
     while (!heap.Empty())
     {
         const NodeID node = heap.DeleteMin();
         BOOST_ASSERT(node != SPECIAL_NODEID);
         const auto node_weight = heap.GetKey(node);
-        if (++nodes > node_limit)
+        if (++settled_nodes > settled_node_limit)
         {
             return;
         }
@@ -85,8 +88,8 @@ void search(ContractorHeap &heap,
                 return;
             }
         }
-
-        relaxNode(heap, graph, contractable, node, node_weight, forbidden_node);
+        if (relaxNode(heap, graph, contractable, node, node_weight, forbidden_node))
+            return;
     }
 }
 } // namespace osrm::contractor

src/contractor/graph_contractor.cpp

@@ -12,6 +12,7 @@
 
 #include <boost/assert.hpp>
 
+#include <cstddef>
 #include <tbb/blocked_range.h>
 #include <tbb/enumerable_thread_specific.h>
 #include <tbb/parallel_for.h>
@@ -33,6 +34,8 @@ struct ContractorThreadData
     std::vector<ContractorEdge> inserted_edges;
     std::vector<NodeID> neighbours;
     explicit ContractorThreadData(NodeID nodes) : heap(nodes) {}
+    /** Code instrumentation: the max. occupancy of the heap */
+    std::size_t max_heap_occupancy{0};
 };
 
 struct ContractorNodeData
@@ -98,21 +101,19 @@ struct RemainingNodeData
 
 struct ThreadDataContainer
 {
-    explicit ThreadDataContainer(int number_of_nodes) : number_of_nodes(number_of_nodes) {}
+    explicit ThreadDataContainer() {}
 
     inline ContractorThreadData *GetThreadData()
     {
         bool exists = false;
         auto &ref = data.local(exists);
         if (!exists)
         {
-            ref = std::make_shared<ContractorThreadData>(number_of_nodes);
+            ref = std::make_shared<ContractorThreadData>(HASH_MAP_CAPACITY);
         }
 
         return ref.get();
     }
-
-    int number_of_nodes;
     using EnumerableThreadData =
         tbb::enumerable_thread_specific<std::shared_ptr<ContractorThreadData>>;
     EnumerableThreadData data;
@@ -230,7 +231,6 @@ void ContractNode(ContractorThreadData *data,
 
         if (RUNSIMULATION)
         {
-            const int constexpr SIMULATION_SEARCH_SPACE_SIZE = 1000;
             search(heap,
                    graph,
                    contractable,
@@ -241,7 +241,6 @@ void ContractNode(ContractorThreadData *data,
         }
         else
         {
-            const int constexpr FULL_SEARCH_SPACE_SIZE = 2000;
             search(heap,
                    graph,
                    contractable,
@@ -298,6 +297,7 @@ void ContractNode(ContractorThreadData *data,
                 }
             }
         }
+        data->max_heap_occupancy = std::max(heap.Occupancy(), data->max_heap_occupancy);
     }
 
     // Check For One-Way Streets to decide on the creation of self-loops
@@ -567,7 +567,7 @@ std::vector<bool> contractGraph(ContractorGraph &graph,
 
     const NodeID number_of_nodes = graph.GetNumberOfNodes();
 
-    ThreadDataContainer thread_data_list(number_of_nodes);
+    ThreadDataContainer thread_data_list;
 
     NodeID number_of_contracted_nodes = 0;
     std::vector<NodeID> new_to_old_node_id(number_of_nodes);
@@ -757,6 +757,18 @@ std::vector<bool> contractGraph(ContractorGraph &graph,
     node_data.Renumber(new_to_old_node_id);
     RenumberGraph(graph, new_to_old_node_id);
 
+    std::size_t max_heap_occupancy = 0;
+    for (auto &data : thread_data_list.data.range())
+    {
+        max_heap_occupancy = std::max(max_heap_occupancy, data->max_heap_occupancy);
+    }
+    util::Log(logDEBUG) << "Max. heap occupancy = " << max_heap_occupancy;
+    if (max_heap_occupancy >= RELAXED_NODE_LIMIT)
+    {
+        util::Log(logWARNING) << "Heap size insufficient. Please increase HASH_MAP_CAPACITY and "
+                                 "recompile and/or open an issue on github.";
+    }
+
     return std::move(node_data.is_core);
 }