Remove {forward,reverse}_core_heap arguments from search interface

include/engine/routing_algorithms/routing_base_ch.hpp

@@ -350,63 +350,29 @@ void retrievePackedPathFromSingleHeap(const SearchEngineData<Algorithm>::QueryHe
 // && source_phantom.GetForwardWeightPlusOffset() > target_phantom.GetForwardWeightPlusOffset())
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
-void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void search(SearchEngineData<Algorithm> &engine_working_data,
+            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
             SearchEngineData<Algorithm>::QueryHeap &forward_heap,
             SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
             std::int32_t &weight,
             std::vector<NodeID> &packed_leg,
             const bool force_loop_forward,
             const bool force_loop_reverse,
+            const PhantomNodes &phantom_nodes,
             const int duration_upper_bound = INVALID_EDGE_WEIGHT);
 
-// Alias to be compatible with the overload for CoreCH that needs 4 heaps
-inline void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &,
-                   SearchEngineData<Algorithm>::QueryHeap &,
-                   EdgeWeight &weight,
-                   std::vector<NodeID> &packed_leg,
-                   const bool force_loop_forward,
-                   const bool force_loop_reverse,
-                   const PhantomNodes & /*phantom_nodes*/,
-                   const int duration_upper_bound = INVALID_EDGE_WEIGHT)
-{
-    search(facade,
-           forward_heap,
-           reverse_heap,
-           weight,
-           packed_leg,
-           force_loop_forward,
-           force_loop_reverse,
-           duration_upper_bound);
-}
-
 // Requires the heaps for be empty
 // If heaps should be adjusted to be initialized outside of this function,
 // the addition of force_loop parameters might be required
 double
-getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
+getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
+                   const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
                    SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                    SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                    const PhantomNode &source_phantom,
                    const PhantomNode &target_phantom,
                    int duration_upper_bound = INVALID_EDGE_WEIGHT);
 
-// Alias to be compatible with the overload for CoreCH that needs 4 heaps
-inline double
-getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &,
-                   SearchEngineData<Algorithm>::QueryHeap &,
-                   const PhantomNode &source_phantom,
-                   const PhantomNode &target_phantom,
-                   int duration_upper_bound = INVALID_EDGE_WEIGHT)
-{
-    return getNetworkDistance(
-        facade, forward_heap, reverse_heap, source_phantom, target_phantom, duration_upper_bound);
-}
 } // namespace ch
 
 namespace corech
@@ -420,11 +386,10 @@ namespace corech
 // && source_phantom.GetForwardWeightPlusOffset() > target_phantom.GetForwardWeightPlusOffset())
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
-void search(const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
+void search(SearchEngineData<Algorithm> &engine_working_data,
+            const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
             SearchEngineData<Algorithm>::QueryHeap &forward_heap,
             SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-            SearchEngineData<Algorithm>::QueryHeap &forward_core_heap,
-            SearchEngineData<Algorithm>::QueryHeap &reverse_core_heap,
             int &weight,
             std::vector<NodeID> &packed_leg,
             const bool force_loop_forward,
@@ -436,11 +401,10 @@ void search(const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorit
 // If heaps should be adjusted to be initialized outside of this function,
 // the addition of force_loop parameters might be required
 double
-getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
+getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
+                   const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
                    SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                    SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_core_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_core_heap,
                    const PhantomNode &source_phantom,
                    const PhantomNode &target_phantom,
                    int duration_upper_bound = INVALID_EDGE_WEIGHT);

include/engine/routing_algorithms/routing_base_mld.hpp

@@ -181,7 +181,8 @@ void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm>
 
 template <typename... Args>
 std::tuple<EdgeWeight, NodeID, NodeID, std::vector<EdgeID>>
-search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+search(SearchEngineData<Algorithm> &engine_working_data,
+       const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
        SearchEngineData<Algorithm>::QueryHeap &forward_heap,
        SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
        const bool force_loop_forward,
@@ -293,7 +294,8 @@ search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
             NodeID subpath_source, subpath_target;
             std::vector<EdgeID> subpath;
             std::tie(subpath_weight, subpath_source, subpath_target, subpath) =
-                search(facade,
+                search(engine_working_data,
+                       facade,
                        forward_heap,
                        reverse_heap,
                        force_loop_forward,
@@ -311,12 +313,12 @@ search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
     return std::make_tuple(weight, source_node, target_node, std::move(unpacked_path));
 }
 
+// TODO reorder parameters
 // Alias to be compatible with the overload for CoreCH that needs 4 heaps for shortest path search
-inline void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+inline void search(SearchEngineData<Algorithm> &engine_working_data,
+                   const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
                    SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                    SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &,
-                   SearchEngineData<Algorithm>::QueryHeap &,
                    EdgeWeight &weight,
                    std::vector<NodeID> &packed_leg,
                    const bool force_loop_forward,
@@ -326,7 +328,8 @@ inline void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorith
 {
     NodeID source_node, target_node;
     std::vector<EdgeID> unpacked_edges;
-    std::tie(weight, source_node, target_node, unpacked_edges) = mld::search(facade,
+    std::tie(weight, source_node, target_node, unpacked_edges) = mld::search(engine_working_data,
+                                                                             facade,
                                                                              forward_heap,
                                                                              reverse_heap,
                                                                              force_loop_forward,
@@ -372,11 +375,10 @@ void unpackPath(const FacadeT &facade,
 }
 
 inline double
-getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
+                   const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
                    SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                    SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   SearchEngineData<Algorithm>::QueryHeap & /*forward_core_heap*/,
-                   SearchEngineData<Algorithm>::QueryHeap & /*reverse_core_heap*/,
                    const PhantomNode &source_phantom,
                    const PhantomNode &target_phantom,
                    EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
@@ -390,7 +392,8 @@ getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<Algorith
     EdgeWeight weight;
     NodeID source_node, target_node;
     std::vector<EdgeID> unpacked_edges;
-    std::tie(weight, source_node, target_node, unpacked_edges) = search(facade,
+    std::tie(weight, source_node, target_node, unpacked_edges) = search(engine_working_data,
+                                                                        facade,
                                                                         forward_heap,
                                                                         reverse_heap,
                                                                         DO_NOT_FORCE_LOOPS,

src/engine/routing_algorithms/direct_shortest_path.cpp

@@ -62,25 +62,19 @@ InternalRouteResult directShortestPathSearchImpl(
     const PhantomNodes &phantom_nodes)
 {
     engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes());
-    engine_working_data.InitializeOrClearSecondThreadLocalStorage(facade.GetNumberOfNodes());
     auto &forward_heap = *engine_working_data.forward_heap_1;
     auto &reverse_heap = *engine_working_data.reverse_heap_1;
-    auto &forward_core_heap = *engine_working_data.forward_heap_2;
-    auto &reverse_core_heap = *engine_working_data.reverse_heap_2;
     forward_heap.Clear();
     reverse_heap.Clear();
-    forward_core_heap.Clear();
-    reverse_core_heap.Clear();
 
     EdgeWeight weight = INVALID_EDGE_WEIGHT;
     std::vector<NodeID> packed_leg;
     insertNodesInHeaps(forward_heap, reverse_heap, phantom_nodes);
 
-    search(facade,
+    search(engine_working_data,
+           facade,
            forward_heap,
            reverse_heap,
-           forward_core_heap,
-           reverse_core_heap,
            weight,
            packed_leg,
            DO_NOT_FORCE_LOOPS,
@@ -140,7 +134,8 @@ InternalRouteResult directShortestPathSearch(
     EdgeWeight weight;
     NodeID source_node, target_node;
     std::vector<EdgeID> unpacked_edges;
-    std::tie(weight, source_node, target_node, unpacked_edges) = mld::search(facade,
+    std::tie(weight, source_node, target_node, unpacked_edges) = mld::search(engine_working_data,
+                                                                             facade,
                                                                              forward_heap,
                                                                              reverse_heap,
                                                                              DO_NOT_FORCE_LOOPS,

src/engine/routing_algorithms/map_matching.cpp

@@ -143,12 +143,9 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
 
     const auto nodes_number = facade.GetNumberOfNodes();
     engine_working_data.InitializeOrClearFirstThreadLocalStorage(nodes_number);
-    engine_working_data.InitializeOrClearSecondThreadLocalStorage(nodes_number);
 
     auto &forward_heap = *engine_working_data.forward_heap_1;
     auto &reverse_heap = *engine_working_data.reverse_heap_1;
-    auto &forward_core_heap = *engine_working_data.forward_heap_2;
-    auto &reverse_core_heap = *engine_working_data.reverse_heap_2;
 
     std::size_t breakage_begin = map_matching::INVALID_STATE;
     std::vector<std::size_t> split_points;
@@ -220,11 +217,10 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
                     }
 
                     double network_distance =
-                        getNetworkDistance(facade,
+                        getNetworkDistance(engine_working_data,
+                                           facade,
                                            forward_heap,
                                            reverse_heap,
-                                           forward_core_heap,
-                                           reverse_core_heap,
                                            prev_unbroken_timestamps_list[s].phantom_node,
                                            current_timestamps_list[s_prime].phantom_node,
                                            weight_upper_bound);

src/engine/routing_algorithms/routing_base_ch.cpp

@@ -71,13 +71,15 @@ void retrievePackedPathFromSingleHeap(const SearchEngineData<Algorithm>::QueryHe
 // && source_phantom.GetForwardWeightPlusOffset() > target_phantom.GetForwardWeightPlusOffset())
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
-void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void search(SearchEngineData<Algorithm> & /*engine_working_data*/,
+            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
             SearchEngineData<Algorithm>::QueryHeap &forward_heap,
             SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
             EdgeWeight &weight,
             std::vector<NodeID> &packed_leg,
             const bool force_loop_forward,
             const bool force_loop_reverse,
+            const PhantomNodes & /*phantom_nodes*/,
             const EdgeWeight weight_upper_bound)
 {
     NodeID middle = SPECIAL_NODEID;
@@ -142,7 +144,8 @@ void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &fac
 // Requires the heaps for be empty
 // If heaps should be adjusted to be initialized outside of this function,
 // the addition of force_loop parameters might be required
-double getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
+                          const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
                           SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                           SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                           const PhantomNode &source_phantom,
@@ -180,13 +183,15 @@ double getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<A
 
     EdgeWeight weight = INVALID_EDGE_WEIGHT;
     std::vector<NodeID> packed_path;
-    search(facade,
+    search(engine_working_data,
+           facade,
            forward_heap,
            reverse_heap,
            weight,
            packed_path,
            DO_NOT_FORCE_LOOPS,
            DO_NOT_FORCE_LOOPS,
+           {source_phantom, target_phantom},
            weight_upper_bound);
 
     if (weight == INVALID_EDGE_WEIGHT)
@@ -216,11 +221,10 @@ namespace corech
 // && source_phantom.GetForwardWeightPlusOffset() > target_phantom.GetForwardWeightPlusOffset())
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
-void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void search(SearchEngineData<Algorithm> &engine_working_data,
-            SearchEngineData<ch::Algorithm>::QueryHeap &forward_heap,
+            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-            SearchEngineData<ch::Algorithm>::QueryHeap &reverse_heap,
+            SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-            SearchEngineData<ch::Algorithm>::QueryHeap &forward_core_heap,
+            SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-            SearchEngineData<ch::Algorithm>::QueryHeap &reverse_core_heap,
             EdgeWeight &weight,
             std::vector<NodeID> &packed_leg,
             const bool force_loop_forward,
@@ -286,7 +290,7 @@ void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &fac
     }
 
     const auto insertInCoreHeap = [](const CoreEntryPoint &p,
-                                     SearchEngineData<ch::Algorithm>::QueryHeap &core_heap) {
+                                     SearchEngineData<Algorithm>::QueryHeap &core_heap) {
         NodeID id;
         EdgeWeight weight;
         NodeID parent;
@@ -295,13 +299,16 @@ void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &fac
         core_heap.Insert(id, weight, parent);
     };
 
-    forward_core_heap.Clear();
+    engine_working_data.InitializeOrClearSecondThreadLocalStorage(facade.GetNumberOfNodes());
+
+    auto &forward_core_heap = *engine_working_data.forward_heap_2;
+    auto &reverse_core_heap = *engine_working_data.reverse_heap_2;
+
     for (const auto &p : forward_entry_points)
     {
         insertInCoreHeap(p, forward_core_heap);
     }
 
-    reverse_core_heap.Clear();
     for (const auto &p : reverse_entry_points)
     {
         insertInCoreHeap(p, reverse_core_heap);
@@ -395,29 +402,25 @@ void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &fac
 // Requires the heaps for be empty
 // If heaps should be adjusted to be initialized outside of this function,
 // the addition of force_loop parameters might be required
-double getNetworkDistance(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
+                          const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
                           SearchEngineData<ch::Algorithm>::QueryHeap &forward_heap,
                           SearchEngineData<ch::Algorithm>::QueryHeap &reverse_heap,
-                          SearchEngineData<ch::Algorithm>::QueryHeap &forward_core_heap,
-                          SearchEngineData<ch::Algorithm>::QueryHeap &reverse_core_heap,
                           const PhantomNode &source_phantom,
                           const PhantomNode &target_phantom,
                           EdgeWeight weight_upper_bound)
 {
     forward_heap.Clear();
     reverse_heap.Clear();
-    forward_core_heap.Clear();
-    reverse_core_heap.Clear();
 
     insertNodesInHeaps(forward_heap, reverse_heap, {source_phantom, target_phantom});
 
     EdgeWeight weight = INVALID_EDGE_WEIGHT;
     std::vector<NodeID> packed_path;
-    search(facade,
+    search(engine_working_data,
+           facade,
            forward_heap,
            reverse_heap,
-           forward_core_heap,
-           reverse_core_heap,
            weight,
            packed_path,
            DO_NOT_FORCE_LOOPS,

src/engine/routing_algorithms/shortest_path.cpp

@@ -21,11 +21,10 @@ const static constexpr bool DO_NOT_FORCE_LOOP = false;
 // allows a uturn at the target_phantom
 // searches source forward/reverse -> target forward/reverse
 template <typename Algorithm>
-void searchWithUTurn(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void searchWithUTurn(SearchEngineData<Algorithm> &engine_working_data,
+                     const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
                      typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                      typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                     typename SearchEngineData<Algorithm>::QueryHeap &forward_core_heap,
-                     typename SearchEngineData<Algorithm>::QueryHeap &reverse_core_heap,
                      const bool search_from_forward_node,
                      const bool search_from_reverse_node,
                      const bool search_to_forward_node,
@@ -75,15 +74,10 @@ void searchWithUTurn(const datafacade::ContiguousInternalMemoryDataFacade<Algori
     auto needs_loop_backwards =
         is_oneway_target && needsLoopBackwards(source_phantom, target_phantom);
 
-    forward_core_heap.Clear();
+    search(engine_working_data,
-    reverse_core_heap.Clear();
+           facade,
-    BOOST_ASSERT(forward_core_heap.Size() == 0);
-    BOOST_ASSERT(reverse_core_heap.Size() == 0);
-    search(facade,
            forward_heap,
            reverse_heap,
-           forward_core_heap,
-           reverse_core_heap,
            new_total_weight,
            leg_packed_path,
            needs_loop_forwards,
@@ -101,11 +95,10 @@ void searchWithUTurn(const datafacade::ContiguousInternalMemoryDataFacade<Algori
 // source forward/reverse -> target forward
 // source forward/reverse -> target reverse
 template <typename Algorithm>
-void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void search(SearchEngineData<Algorithm> &engine_working_data,
+            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
             typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
             typename SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-            typename SearchEngineData<Algorithm>::QueryHeap &forward_core_heap,
-            typename SearchEngineData<Algorithm>::QueryHeap &reverse_core_heap,
             const bool search_from_forward_node,
             const bool search_from_reverse_node,
             const bool search_to_forward_node,
@@ -144,15 +137,10 @@ void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &fac
         BOOST_ASSERT(forward_heap.Size() > 0);
         BOOST_ASSERT(reverse_heap.Size() > 0);
 
-        forward_core_heap.Clear();
+        search(engine_working_data,
-        reverse_core_heap.Clear();
+               facade,
-        BOOST_ASSERT(forward_core_heap.Size() == 0);
-        BOOST_ASSERT(reverse_core_heap.Size() == 0);
-        search(facade,
                forward_heap,
                reverse_heap,
-               forward_core_heap,
-               reverse_core_heap,
                new_total_weight_to_forward,
                leg_packed_path_forward,
                needsLoopForward(source_phantom, target_phantom),
@@ -183,15 +171,10 @@ void search(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &fac
         }
         BOOST_ASSERT(forward_heap.Size() > 0);
         BOOST_ASSERT(reverse_heap.Size() > 0);
-        forward_core_heap.Clear();
+        search(engine_working_data,
-        reverse_core_heap.Clear();
+               facade,
-        BOOST_ASSERT(forward_core_heap.Size() == 0);
-        BOOST_ASSERT(reverse_core_heap.Size() == 0);
-        search(facade,
                forward_heap,
                reverse_heap,
-               forward_core_heap,
-               reverse_core_heap,
                new_total_weight_to_reverse,
                leg_packed_path_reverse,
                routing_algorithms::DO_NOT_FORCE_LOOP,
@@ -246,12 +229,9 @@ shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
                                         : facade.GetContinueStraightDefault());
 
     engine_working_data.InitializeOrClearFirstThreadLocalStorage(facade.GetNumberOfNodes());
-    engine_working_data.InitializeOrClearSecondThreadLocalStorage(facade.GetNumberOfNodes());
 
     auto &forward_heap = *engine_working_data.forward_heap_1;
     auto &reverse_heap = *engine_working_data.reverse_heap_1;
-    auto &forward_core_heap = *engine_working_data.forward_heap_2;
-    auto &reverse_core_heap = *engine_working_data.reverse_heap_2;
 
     int total_weight_to_forward = 0;
     int total_weight_to_reverse = 0;
@@ -294,11 +274,10 @@ shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
         {
             if (allow_uturn_at_waypoint)
             {
-                searchWithUTurn(facade,
+                searchWithUTurn(engine_working_data,
+                                facade,
                                 forward_heap,
                                 reverse_heap,
-                                forward_core_heap,
-                                reverse_core_heap,
                                 search_from_forward_node,
                                 search_from_reverse_node,
                                 search_to_forward_node,
@@ -331,11 +310,10 @@ shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
             }
             else
             {
-                search(facade,
+                search(engine_working_data,
+                       facade,
                        forward_heap,
                        reverse_heap,
-                       forward_core_heap,
-                       reverse_core_heap,
                        search_from_forward_node,
                        search_from_reverse_node,
                        search_to_forward_node,