Use ArrayStorage for boundary nodes to optimize MLD

For the MLD algorithm we can partition the NodeID range into boundary
and non-boundary nodes. Since there are only we boundary nodes we can
use the ArrayStorage for those yielding much faster query times.

include/util/query_heap.hpp

@@ -20,7 +20,7 @@ template <typename NodeID, typename Key> class GenerationArrayStorage
     using GenerationCounter = std::uint16_t;
 
   public:
-    explicit GenerationArrayStorage(std::size_t size)
+    explicit GenerationArrayStorage(std::size_t size, std::size_t)
         : positions(size, 0), generation(1), generations(size, 0)
     {
     }
@@ -60,7 +60,7 @@ template <typename NodeID, typename Key> class GenerationArrayStorage
 template <typename NodeID, typename Key> class ArrayStorage
 {
   public:
-    explicit ArrayStorage(std::size_t size) : positions(size, 0) {}
+    explicit ArrayStorage(std::size_t size, std::size_t) : positions(size, 0) {}
 
     ~ArrayStorage() {}
 
@@ -77,7 +77,7 @@ template <typename NodeID, typename Key> class ArrayStorage
 template <typename NodeID, typename Key> class MapStorage
 {
   public:
-    explicit MapStorage(std::size_t) {}
+    explicit MapStorage(std::size_t, std::size_t) {}
 
     Key &operator[](NodeID node) { return nodes[node]; }
 
@@ -100,7 +100,7 @@ template <typename NodeID, typename Key> class MapStorage
 template <typename NodeID, typename Key> class UnorderedMapStorage
 {
   public:
-    explicit UnorderedMapStorage(std::size_t) { nodes.rehash(1000); }
+    explicit UnorderedMapStorage(std::size_t, std::size_t) { nodes.rehash(1000); }
 
     Key &operator[](const NodeID node) { return nodes[node]; }
 
@@ -126,6 +126,67 @@ template <typename NodeID, typename Key> class UnorderedMapStorage
     std::unordered_map<NodeID, Key> nodes;
 };
 
+template <typename NodeID,
+          typename Key,
+          template <typename N, typename K> class BaseIndexStorage = UnorderedMapStorage,
+          template <typename N, typename K> class OverlayIndexStorage = ArrayStorage>
+class TwoLevelStorage
+{
+  public:
+    explicit TwoLevelStorage(std::size_t number_of_nodes, std::size_t number_of_overlay_nodes)
+        : number_of_overlay_nodes(number_of_overlay_nodes), base(number_of_nodes, number_of_nodes),
+          overlay(number_of_overlay_nodes, number_of_overlay_nodes)
+    {
+    }
+
+    Key &operator[](const NodeID node)
+    {
+        if (node < number_of_overlay_nodes)
+        {
+            return overlay[node];
+        }
+        else
+        {
+            return base[node];
+        }
+    }
+
+    Key peek_index(const NodeID node) const
+    {
+        if (node < number_of_overlay_nodes)
+        {
+            return overlay.peek_index(node);
+        }
+        else
+        {
+            return base.peek_index(node);
+        }
+    }
+
+    Key const &operator[](const NodeID node) const
+    {
+        if (node < number_of_overlay_nodes)
+        {
+            return overlay[node];
+        }
+        else
+        {
+            return base[node];
+        }
+    }
+
+    void Clear()
+    {
+        base.Clear();
+        overlay.Clear();
+    }
+
+  private:
+    const std::size_t number_of_overlay_nodes;
+    BaseIndexStorage<NodeID, Key> base;
+    OverlayIndexStorage<NodeID, Key> overlay;
+};
+
 template <typename NodeID,
           typename Key,
           typename Weight,
@@ -137,7 +198,16 @@ class QueryHeap
     using WeightType = Weight;
     using DataType = Data;
 
-    explicit QueryHeap(std::size_t maxID) : node_index(maxID) { Clear(); }
+    explicit QueryHeap(std::size_t number_of_elements, std::size_t number_of_overlay_nodes)
+        : node_index(number_of_elements, number_of_overlay_nodes)
+    {
+        Clear();
+    }
+
+    explicit QueryHeap(std::size_t number_of_elements)
+        : QueryHeap(number_of_elements, number_of_elements)
+    {
+    }
 
     void Clear()
     {

include/util/xor_fast_hash_storage.hpp

@@ -31,7 +31,9 @@ class XORFastHashStorage
         void operator=(const Key key_to_insert) { key = key_to_insert; }
     };
 
-    explicit XORFastHashStorage(size_t) : positions(MaxNumElements), current_timestamp{0u} {}
+    explicit XORFastHashStorage(size_t, size_t) : positions(MaxNumElements), current_timestamp{0u}
+    {
+    }
 
     HashCell &operator[](const NodeID node)
     {