Add abstraction to change the data facade at compile time

src/engine/routing_algorithms/alternative_path_ch.cpp

@@ -50,7 +50,7 @@ struct RankedCandidateNode
 
 // todo: reorder parameters
 template <bool DIRECTION>
-void alternativeRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void alternativeRoutingStep(const DataFacade<Algorithm> &facade,
                             QueryHeap &heap1,
                             QueryHeap &heap2,
                             NodeID *middle_node,
@@ -153,14 +153,13 @@ void retrievePackedAlternatePath(const QueryHeap &forward_heap1,
 // compute and unpack <s,..,v> and <v,..,t> by exploring search spaces
 // from v and intersecting against queues. only half-searches have to be
 // done at this stage
-void computeWeightAndSharingOfViaPath(
-    SearchEngineData<Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-    const NodeID via_node,
-    EdgeWeight *real_weight_of_via_path,
-    EdgeWeight *sharing_of_via_path,
-    const std::vector<NodeID> &packed_shortest_path,
-    const EdgeWeight min_edge_offset)
+void computeWeightAndSharingOfViaPath(SearchEngineData<Algorithm> &engine_working_data,
+                                      const DataFacade<Algorithm> &facade,
+                                      const NodeID via_node,
+                                      EdgeWeight *real_weight_of_via_path,
+                                      EdgeWeight *sharing_of_via_path,
+                                      const std::vector<NodeID> &packed_shortest_path,
+                                      const EdgeWeight min_edge_offset)
 {
     engine_working_data.InitializeOrClearSecondThreadLocalStorage(facade.GetNumberOfNodes());
 
@@ -318,19 +317,18 @@ void computeWeightAndSharingOfViaPath(
 }
 
 // conduct T-Test
-bool viaNodeCandidatePassesTTest(
-    SearchEngineData<Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-    QueryHeap &existing_forward_heap,
-    QueryHeap &existing_reverse_heap,
-    QueryHeap &new_forward_heap,
-    QueryHeap &new_reverse_heap,
-    const RankedCandidateNode &candidate,
-    const EdgeWeight weight_of_shortest_path,
-    EdgeWeight *weight_of_via_path,
-    NodeID *s_v_middle,
-    NodeID *v_t_middle,
-    const EdgeWeight min_edge_offset)
+bool viaNodeCandidatePassesTTest(SearchEngineData<Algorithm> &engine_working_data,
+                                 const DataFacade<Algorithm> &facade,
+                                 QueryHeap &existing_forward_heap,
+                                 QueryHeap &existing_reverse_heap,
+                                 QueryHeap &new_forward_heap,
+                                 QueryHeap &new_reverse_heap,
+                                 const RankedCandidateNode &candidate,
+                                 const EdgeWeight weight_of_shortest_path,
+                                 EdgeWeight *weight_of_via_path,
+                                 NodeID *s_v_middle,
+                                 NodeID *v_t_middle,
+                                 const EdgeWeight min_edge_offset)
 {
     new_forward_heap.Clear();
     new_reverse_heap.Clear();
@@ -562,11 +560,10 @@ bool viaNodeCandidatePassesTTest(
 }
 } // anon. namespace
 
-InternalManyRoutesResult
-alternativePathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                      const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                      const PhantomNodes &phantom_node_pair,
-                      unsigned /*number_of_alternatives*/)
+InternalManyRoutesResult alternativePathSearch(SearchEngineData<Algorithm> &engine_working_data,
+                                               const DataFacade<Algorithm> &facade,
+                                               const PhantomNodes &phantom_node_pair,
+                                               unsigned /*number_of_alternatives*/)
 {
     InternalRouteResult primary_route;
     InternalRouteResult secondary_route;

src/engine/routing_algorithms/alternative_path_mld.cpp

@@ -28,7 +28,7 @@ using namespace mld;
 
 using Heap = SearchEngineData<Algorithm>::QueryHeap;
 using Partition = partition::MultiLevelPartitionView;
-using Facade = datafacade::ContiguousInternalMemoryDataFacade<Algorithm>;
+using Facade = DataFacade<Algorithm>;
 
 // Implementation details
 namespace

src/engine/routing_algorithms/direct_shortest_path.cpp

@@ -18,10 +18,9 @@ namespace routing_algorithms
 /// This variation is only an optimazation for graphs with slow queries, for example
 /// not fully contracted graphs.
 template <typename Algorithm>
-InternalRouteResult
-directShortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                         const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                         const PhantomNodes &phantom_nodes)
+InternalRouteResult directShortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
+                                             const DataFacade<Algorithm> &facade,
+                                             const PhantomNodes &phantom_nodes)
 {
     engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes());
     auto &forward_heap = *engine_working_data.forward_heap_1;
@@ -65,21 +64,20 @@ directShortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
     return extractRoute(facade, weight, phantom_nodes, unpacked_nodes, unpacked_edges);
 }
 
-template InternalRouteResult directShortestPathSearch(
-    SearchEngineData<corech::Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
-    const PhantomNodes &phantom_nodes);
+template InternalRouteResult
+directShortestPathSearch(SearchEngineData<corech::Algorithm> &engine_working_data,
+                         const DataFacade<corech::Algorithm> &facade,
+                         const PhantomNodes &phantom_nodes);
 
-template InternalRouteResult directShortestPathSearch(
-    SearchEngineData<ch::Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-    const PhantomNodes &phantom_nodes);
+template InternalRouteResult
+directShortestPathSearch(SearchEngineData<ch::Algorithm> &engine_working_data,
+                         const DataFacade<ch::Algorithm> &facade,
+                         const PhantomNodes &phantom_nodes);
 
 template <>
-InternalRouteResult directShortestPathSearch(
-    SearchEngineData<mld::Algorithm> &engine_working_data,
-    const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
-    const PhantomNodes &phantom_nodes)
+InternalRouteResult directShortestPathSearch(SearchEngineData<mld::Algorithm> &engine_working_data,
+                                             const DataFacade<mld::Algorithm> &facade,
+                                             const PhantomNodes &phantom_nodes)
 {
     engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes());
     auto &forward_heap = *engine_working_data.forward_heap_1;

src/engine/routing_algorithms/many_to_many.cpp

@@ -31,11 +31,10 @@ struct NodeBucket
 // FIXME This should be replaced by an std::unordered_multimap, though this needs benchmarking
 using SearchSpaceWithBuckets = std::unordered_map<NodeID, std::vector<NodeBucket>>;
 
-inline bool
-addLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-              const NodeID node,
-              EdgeWeight &weight,
-              EdgeDuration &duration)
+inline bool addLoopWeight(const DataFacade<ch::Algorithm> &facade,
+                          const NodeID node,
+                          EdgeWeight &weight,
+                          EdgeDuration &duration)
 { // Special case for CH when contractor creates a loop edge node->node
     BOOST_ASSERT(weight < 0);
 
@@ -56,7 +55,7 @@ addLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm
 }
 
 template <bool DIRECTION>
-void relaxOutgoingEdges(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
+void relaxOutgoingEdges(const DataFacade<ch::Algorithm> &facade,
                         const NodeID node,
                         const EdgeWeight weight,
                         const EdgeDuration duration,
@@ -97,22 +96,19 @@ void relaxOutgoingEdges(const datafacade::ContiguousInternalMemoryDataFacade<ch:
     }
 }
 
-inline bool addLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &,
-                          const NodeID,
-                          EdgeWeight &,
-                          EdgeDuration &)
+inline bool
+addLoopWeight(const DataFacade<mld::Algorithm> &, const NodeID, EdgeWeight &, EdgeDuration &)
 { // MLD overlay does not introduce loop edges
     return false;
 }
 
 template <bool DIRECTION>
-void relaxOutgoingEdges(
-    const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
-    const NodeID node,
-    const EdgeWeight weight,
-    const EdgeDuration duration,
-    typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &query_heap,
-    const PhantomNode &phantom_node)
+void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
+                        const NodeID node,
+                        const EdgeWeight weight,
+                        const EdgeDuration duration,
+                        typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &query_heap,
+                        const PhantomNode &phantom_node)
 {
     const auto &partition = facade.GetMultiLevelPartition();
     const auto &cells = facade.GetCellStorage();
@@ -218,7 +214,7 @@ void relaxOutgoingEdges(
 }
 
 template <typename Algorithm>
-void forwardRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void forwardRoutingStep(const DataFacade<Algorithm> &facade,
                         const unsigned row_idx,
                         const unsigned number_of_targets,
                         typename SearchEngineData<Algorithm>::ManyToManyQueryHeap &query_heap,
@@ -272,7 +268,7 @@ void forwardRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Alg
 }
 
 template <typename Algorithm>
-void backwardRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void backwardRoutingStep(const DataFacade<Algorithm> &facade,
                          const unsigned column_idx,
                          typename SearchEngineData<Algorithm>::ManyToManyQueryHeap &query_heap,
                          SearchSpaceWithBuckets &search_space_with_buckets,
@@ -291,12 +287,11 @@ void backwardRoutingStep(const datafacade::ContiguousInternalMemoryDataFacade<Al
 }
 
 template <typename Algorithm>
-std::vector<EdgeWeight>
-manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
-                 const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                 const std::vector<PhantomNode> &phantom_nodes,
-                 const std::vector<std::size_t> &source_indices,
-                 const std::vector<std::size_t> &target_indices)
+std::vector<EdgeWeight> manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
+                                         const DataFacade<Algorithm> &facade,
+                                         const std::vector<PhantomNode> &phantom_nodes,
+                                         const std::vector<std::size_t> &source_indices,
+                                         const std::vector<std::size_t> &target_indices)
 {
     const auto number_of_sources =
         source_indices.empty() ? phantom_nodes.size() : source_indices.size();
@@ -386,14 +381,14 @@ manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
 
 template std::vector<EdgeWeight>
 manyToManySearch(SearchEngineData<ch::Algorithm> &engine_working_data,
-                 const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
+                 const DataFacade<ch::Algorithm> &facade,
                  const std::vector<PhantomNode> &phantom_nodes,
                  const std::vector<std::size_t> &source_indices,
                  const std::vector<std::size_t> &target_indices);
 
 template std::vector<EdgeWeight>
 manyToManySearch(SearchEngineData<mld::Algorithm> &engine_working_data,
-                 const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
+                 const DataFacade<mld::Algorithm> &facade,
                  const std::vector<PhantomNode> &phantom_nodes,
                  const std::vector<std::size_t> &source_indices,
                  const std::vector<std::size_t> &target_indices);

src/engine/routing_algorithms/map_matching.cpp

@@ -50,7 +50,7 @@ unsigned getMedianSampleTime(const std::vector<unsigned> &timestamps)
 
 template <typename Algorithm>
 SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
-                            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                            const DataFacade<Algorithm> &facade,
                             const CandidateLists &candidates_list,
                             const std::vector<util::Coordinate> &trace_coordinates,
                             const std::vector<unsigned> &trace_timestamps,
@@ -422,7 +422,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
 
 template SubMatchingList
 mapMatching(SearchEngineData<ch::Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
+            const DataFacade<ch::Algorithm> &facade,
             const CandidateLists &candidates_list,
             const std::vector<util::Coordinate> &trace_coordinates,
             const std::vector<unsigned> &trace_timestamps,
@@ -431,7 +431,7 @@ mapMatching(SearchEngineData<ch::Algorithm> &engine_working_data,
 
 template SubMatchingList
 mapMatching(SearchEngineData<corech::Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
+            const DataFacade<corech::Algorithm> &facade,
             const CandidateLists &candidates_list,
             const std::vector<util::Coordinate> &trace_coordinates,
             const std::vector<unsigned> &trace_timestamps,
@@ -440,7 +440,7 @@ mapMatching(SearchEngineData<corech::Algorithm> &engine_working_data,
 
 template SubMatchingList
 mapMatching(SearchEngineData<mld::Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
+            const DataFacade<mld::Algorithm> &facade,
             const CandidateLists &candidates_list,
             const std::vector<util::Coordinate> &trace_coordinates,
             const std::vector<unsigned> &trace_timestamps,

src/engine/routing_algorithms/routing_base_ch.cpp

@@ -16,7 +16,7 @@ namespace ch
  * @param to the node the CH edge finishes at
  * @param unpacked_path the sequence of original NodeIDs that make up the expanded CH edge
  */
-void unpackEdge(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void unpackEdge(const DataFacade<Algorithm> &facade,
                 const NodeID from,
                 const NodeID to,
                 std::vector<NodeID> &unpacked_path)
@@ -72,7 +72,7 @@ void retrievePackedPathFromSingleHeap(const SearchEngineData<Algorithm>::QueryHe
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
 void search(SearchEngineData<Algorithm> & /*engine_working_data*/,
-            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+            const DataFacade<Algorithm> &facade,
             SearchEngineData<Algorithm>::QueryHeap &forward_heap,
             SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
             EdgeWeight &weight,
@@ -151,7 +151,7 @@ void search(SearchEngineData<Algorithm> & /*engine_working_data*/,
 // If heaps should be adjusted to be initialized outside of this function,
 // the addition of force_loop parameters might be required
 double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
-                          const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                          const DataFacade<Algorithm> &facade,
                           SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                           SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                           const PhantomNode &source_phantom,
@@ -204,7 +204,7 @@ namespace corech
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
 void search(SearchEngineData<Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+            const DataFacade<Algorithm> &facade,
             SearchEngineData<Algorithm>::QueryHeap &forward_heap,
             SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
             EdgeWeight &weight,
@@ -384,7 +384,7 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
 // If heaps should be adjusted to be initialized outside of this function,
 // the addition of force_loop parameters might be required
 double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
-                          const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                          const DataFacade<Algorithm> &facade,
                           SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                           SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                           const PhantomNode &source_phantom,

src/engine/routing_algorithms/shortest_path.cpp

@@ -22,7 +22,7 @@ const static constexpr bool DO_NOT_FORCE_LOOP = false;
 // searches source forward/reverse -> target forward/reverse
 template <typename Algorithm>
 void searchWithUTurn(SearchEngineData<Algorithm> &engine_working_data,
-                     const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                     const DataFacade<Algorithm> &facade,
                      typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                      typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                      const bool search_from_forward_node,
@@ -93,7 +93,7 @@ void searchWithUTurn(SearchEngineData<Algorithm> &engine_working_data,
 // source forward/reverse -> target reverse
 template <typename Algorithm>
 void search(SearchEngineData<Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+            const DataFacade<Algorithm> &facade,
             typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
             typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
             const bool search_from_forward_node,
@@ -178,7 +178,7 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
 }
 
 template <typename Algorithm>
-void unpackLegs(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void unpackLegs(const DataFacade<Algorithm> &facade,
                 const std::vector<PhantomNodes> &phantom_nodes_vector,
                 const std::vector<NodeID> &total_packed_path,
                 const std::vector<std::size_t> &packed_leg_begin,
@@ -210,11 +210,10 @@ void unpackLegs(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm>
 }
 
 template <typename Algorithm>
-InternalRouteResult
-shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                   const std::vector<PhantomNodes> &phantom_nodes_vector,
-                   const boost::optional<bool> continue_straight_at_waypoint)
+InternalRouteResult shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
+                                       const DataFacade<Algorithm> &facade,
+                                       const std::vector<PhantomNodes> &phantom_nodes_vector,
+                                       const boost::optional<bool> continue_straight_at_waypoint)
 {
     InternalRouteResult raw_route_data;
     raw_route_data.segment_end_coordinates = phantom_nodes_vector;
@@ -459,19 +458,19 @@ shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
 
 template InternalRouteResult
 shortestPathSearch(SearchEngineData<ch::Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
+                   const DataFacade<ch::Algorithm> &facade,
                    const std::vector<PhantomNodes> &phantom_nodes_vector,
                    const boost::optional<bool> continue_straight_at_waypoint);
 
 template InternalRouteResult
 shortestPathSearch(SearchEngineData<corech::Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
+                   const DataFacade<corech::Algorithm> &facade,
                    const std::vector<PhantomNodes> &phantom_nodes_vector,
                    const boost::optional<bool> continue_straight_at_waypoint);
 
 template InternalRouteResult
 shortestPathSearch(SearchEngineData<mld::Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
+                   const DataFacade<mld::Algorithm> &facade,
                    const std::vector<PhantomNodes> &phantom_nodes_vector,
                    const boost::optional<bool> continue_straight_at_waypoint);
 

src/engine/routing_algorithms/tile_turns.cpp

@@ -227,19 +227,15 @@ std::vector<TurnData> generateTurns(const datafacade &facade,
 } // namespace
 
 // CH Version of finding all turn penalties. Here is where the actual work is happening
-std::vector<TurnData>
-getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-             const std::vector<RTreeLeaf> &edges,
-             const std::vector<std::size_t> &sorted_edge_indexes)
+std::vector<TurnData> getTileTurns(const DataFacade<ch::Algorithm> &facade,
+                                   const std::vector<RTreeLeaf> &edges,
+                                   const std::vector<std::size_t> &sorted_edge_indexes)
 {
     // Define how to find the representative edge between two edge based nodes for a CH
     struct EdgeFinderCH
     {
-        EdgeFinderCH(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade)
-            : facade(facade)
-        {
-        }
-        const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade;
+        EdgeFinderCH(const DataFacade<ch::Algorithm> &facade) : facade(facade) {}
+        const DataFacade<ch::Algorithm> &facade;
 
         EdgeID operator()(const NodeID approach_node, const NodeID exit_node) const
         {
@@ -283,19 +279,15 @@ getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm>
 }
 
 // MLD version to find all turns
-std::vector<TurnData>
-getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
-             const std::vector<RTreeLeaf> &edges,
-             const std::vector<std::size_t> &sorted_edge_indexes)
+std::vector<TurnData> getTileTurns(const DataFacade<mld::Algorithm> &facade,
+                                   const std::vector<RTreeLeaf> &edges,
+                                   const std::vector<std::size_t> &sorted_edge_indexes)
 {
     // Define how to find the representative edge between two edge-based-nodes for a MLD
     struct EdgeFinderMLD
     {
-        EdgeFinderMLD(const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade)
-            : facade(facade)
-        {
-        }
-        const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade;
+        EdgeFinderMLD(const DataFacade<mld::Algorithm> &facade) : facade(facade) {}
+        const DataFacade<mld::Algorithm> &facade;
 
         EdgeID operator()(const NodeID approach_node, const NodeID exit_node) const
         {