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/engine/datafacade/algorithm_datafacade.hpp

@@ -65,6 +65,8 @@ template <> class AlgorithmDataFacade<MLD>
     // search graph access
     virtual unsigned GetNumberOfNodes() const = 0;
 
+    virtual unsigned GetMaxBorderNodeID() const = 0;
+
     virtual unsigned GetNumberOfEdges() const = 0;
 
     virtual unsigned GetOutDegree(const NodeID n) const = 0;

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -675,6 +675,8 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
     // search graph access
     unsigned GetNumberOfNodes() const override final { return query_graph.GetNumberOfNodes(); }
 
+    unsigned GetMaxBorderNodeID() const override final { return query_graph.GetMaxBorderNodeID(); }
+
     unsigned GetNumberOfEdges() const override final { return query_graph.GetNumberOfEdges(); }
 
     unsigned GetOutDegree(const NodeID n) const override final

include/engine/routing_algorithms/shortest_path_impl.hpp

@@ -207,6 +207,25 @@ void unpackLegs(const DataFacade<Algorithm> &facade,
              phantom_nodes_vector[current_leg].target_phantom.forward_segment_id.id));
     }
 }
+
+template <typename Algorithm>
+inline void initializeHeap(SearchEngineData<Algorithm> &engine_working_data,
+                           const DataFacade<Algorithm> &facade)
+{
+
+    const auto nodes_number = facade.GetNumberOfNodes();
+    engine_working_data.InitializeOrClearFirstThreadLocalStorage(nodes_number);
+}
+
+template <>
+inline void initializeHeap<mld::Algorithm>(SearchEngineData<mld::Algorithm> &engine_working_data,
+                                           const DataFacade<mld::Algorithm> &facade)
+{
+
+    const auto nodes_number = facade.GetNumberOfNodes();
+    const auto border_nodes_number = facade.GetMaxBorderNodeID() + 1;
+    engine_working_data.InitializeOrClearFirstThreadLocalStorage(nodes_number, border_nodes_number);
+}
 }
 
 template <typename Algorithm>
@@ -221,7 +240,7 @@ InternalRouteResult shortestPathSearch(SearchEngineData<Algorithm> &engine_worki
         !(continue_straight_at_waypoint ? *continue_straight_at_waypoint
                                         : facade.GetContinueStraightDefault());
 
-    engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes());
+    initializeHeap(engine_working_data, facade);
 
     auto &forward_heap = *engine_working_data.forward_heap_1;
     auto &reverse_heap = *engine_working_data.reverse_heap_1;

include/engine/search_engine_data.hpp

@@ -91,13 +91,13 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
                                       NodeID,
                                       EdgeWeight,
                                       MultiLayerDijkstraHeapData,
-                                      util::UnorderedMapStorage<NodeID, int>>;
+                                      util::TwoLevelStorage<NodeID, int>>;
 
     using ManyToManyQueryHeap = util::QueryHeap<NodeID,
                                                 NodeID,
                                                 EdgeWeight,
                                                 ManyToManyMultiLayerDijkstraHeapData,
-                                                util::UnorderedMapStorage<NodeID, int>>;
+                                                util::TwoLevelStorage<NodeID, int>>;
 
     using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
     using ManyToManyHeapPtr = boost::thread_specific_ptr<ManyToManyQueryHeap>;
@@ -106,9 +106,11 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
     static SearchEngineHeapPtr reverse_heap_1;
     static ManyToManyHeapPtr many_to_many_heap;
 
-    void InitializeOrClearFirstThreadLocalStorage(unsigned number_of_nodes);
+    void InitializeOrClearFirstThreadLocalStorage(unsigned number_of_nodes,
+                                                  unsigned number_of_boundary_nodes);
 
-    void InitializeOrClearManyToManyThreadLocalStorage(unsigned number_of_nodes);
+    void InitializeOrClearManyToManyThreadLocalStorage(unsigned number_of_nodes,
+                                                       unsigned number_of_boundary_nodes);
 };
 }
 }

include/partitioner/multi_level_graph.hpp

@@ -138,6 +138,14 @@ class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
     // We save the level as sentinel at the end
     LevelID GetNumberOfLevels() const { return node_to_edge_offset.back(); }
 
+    NodeID GetMaxBorderNodeID() const
+    {
+        auto num_levels = GetNumberOfLevels();
+        BOOST_ASSERT((node_to_edge_offset.size() - 1) % num_levels == 0);
+        auto max_border_node_id = (node_to_edge_offset.size() - 1) / num_levels - 1;
+        return max_border_node_id;
+    }
+
   private:
     template <typename ContainerT>
     auto GetHighestBorderLevel(const MultiLevelPartition &mlp, const ContainerT &edges) const

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)
     {