bug-fix: invalid contract node

include/contractor/contractor_search.hpp

@@ -13,6 +13,7 @@ namespace osrm::contractor
 
 void search(ContractorHeap &heap,
             const ContractorGraph &graph,
+            const std::vector<bool> &contractable,
             const unsigned number_of_targets,
             const int node_limit,
             const EdgeWeight weight_limit,

include/util/xor_fast_hash.hpp

@@ -42,7 +42,7 @@ template <std::size_t MaxNumElements = (1u << 16u)> class XORFastHash
   public:
     XORFastHash()
     {
-        std::mt19937 generator; // impl. defined but deterministic default seed
+        std::mt19937 generator(1); // impl. defined but deterministic default seed
 
         std::iota(begin(table1), end(table1), 0u);
         std::shuffle(begin(table1), end(table1), generator);

src/contractor/contractor_search.cpp

@@ -10,6 +10,7 @@ namespace
 {
 void relaxNode(ContractorHeap &heap,
                const ContractorGraph &graph,
+               const std::vector<bool> &contractable,
                const NodeID node,
                const EdgeWeight node_weight,
                const NodeID forbidden_node)
@@ -34,6 +35,10 @@ void relaxNode(ContractorHeap &heap,
         // New Node discovered -> Add to Heap + Node Info Storage
         if (!toHeapNode)
         {
+            if (!contractable[to])
+            {
+                continue;
+            }
             heap.Insert(to, to_weight, ContractorHeapData{current_hop, false});
         }
         // Found a shorter Path -> Update weight
@@ -49,6 +54,7 @@ void relaxNode(ContractorHeap &heap,
 
 void search(ContractorHeap &heap,
             const ContractorGraph &graph,
+            const std::vector<bool> &contractable,
             const unsigned number_of_targets,
             const int node_limit,
             const EdgeWeight weight_limit,
@@ -80,7 +86,7 @@ void search(ContractorHeap &heap,
             }
         }
 
-        relaxNode(heap, graph, node, node_weight, forbidden_node);
+        relaxNode(heap, graph, contractable, node, node_weight, forbidden_node);
     }
 }
 } // namespace osrm::contractor

src/contractor/graph_contractor.cpp

@@ -138,6 +138,7 @@ void ContractNode(ContractorThreadData *data,
                   const ContractorGraph &graph,
                   const NodeID node,
                   std::vector<EdgeWeight> &node_weights,
+                  const std::vector<bool> &contractable,
                   ContractionStats *stats = nullptr)
 {
     auto &heap = data->heap;
@@ -245,12 +246,24 @@ void ContractNode(ContractorThreadData *data,
         if (RUNSIMULATION)
         {
             const int constexpr SIMULATION_SEARCH_SPACE_SIZE = 1000;
-            search(heap, graph, number_of_targets, SIMULATION_SEARCH_SPACE_SIZE, max_weight, node);
+            search(heap,
+                   graph,
+                   contractable,
+                   number_of_targets,
+                   SIMULATION_SEARCH_SPACE_SIZE,
+                   max_weight,
+                   node);
         }
         else
         {
             const int constexpr FULL_SEARCH_SPACE_SIZE = 2000;
-            search(heap, graph, number_of_targets, FULL_SEARCH_SPACE_SIZE, max_weight, node);
+            search(heap,
+                   graph,
+                   contractable,
+                   number_of_targets,
+                   FULL_SEARCH_SPACE_SIZE,
+                   max_weight,
+                   node);
         }
         for (auto out_edge : graph.GetAdjacentEdgeRange(node))
         {
@@ -344,18 +357,20 @@ void ContractNode(ContractorThreadData *data,
 void ContractNode(ContractorThreadData *data,
                   const ContractorGraph &graph,
                   const NodeID node,
-                  std::vector<EdgeWeight> &node_weights)
+                  std::vector<EdgeWeight> &node_weights,
+                  const std::vector<bool> &contractable)
 {
-    ContractNode<false>(data, graph, node, node_weights, nullptr);
+    ContractNode<false>(data, graph, node, node_weights, contractable, nullptr);
 }
 
 ContractionStats SimulateNodeContraction(ContractorThreadData *data,
                                          const ContractorGraph &graph,
                                          const NodeID node,
-                                         std::vector<EdgeWeight> &node_weights)
+                                         std::vector<EdgeWeight> &node_weights,
+                                         const std::vector<bool> &contractable)
 {
     ContractionStats stats;
-    ContractNode<true>(data, graph, node, node_weights, &stats);
+    ContractNode<true>(data, graph, node, node_weights, contractable, &stats);
     return stats;
 }
 
@@ -487,7 +502,8 @@ bool UpdateNodeNeighbours(ContractorNodeData &node_data,
         if (node_data.contractable[u])
         {
             node_data.priorities[u] = EvaluateNodePriority(
-                SimulateNodeContraction(data, graph, u, node_data.weights), node_data.depths[u]);
+                SimulateNodeContraction(data, graph, u, node_data.weights, node_data.contractable),
+                node_data.depths[u]);
         }
     }
     return true;
@@ -618,19 +634,21 @@ std::vector<bool> contractGraph(ContractorGraph &graph,
     {
         util::UnbufferedLog log;
         log << "initializing node priorities...";
-        tbb::parallel_for(tbb::blocked_range<std::size_t>(0, remaining_nodes.size(), PQGrainSize),
-                          [&](const auto &range)
-                          {
-                              ContractorThreadData *data = thread_data_list.GetThreadData();
-                              for (auto x = range.begin(), end = range.end(); x != end; ++x)
-                              {
-                                  auto node = remaining_nodes[x].id;
-                                  BOOST_ASSERT(node_data.contractable[node]);
-                                  node_data.priorities[node] = EvaluateNodePriority(
-                                      SimulateNodeContraction(data, graph, node, node_data.weights),
-                                      node_data.depths[node]);
-                              }
-                          });
+        tbb::parallel_for(
+            tbb::blocked_range<std::size_t>(0, remaining_nodes.size(), PQGrainSize),
+            [&](const auto &range)
+            {
+                ContractorThreadData *data = thread_data_list.GetThreadData();
+                for (auto x = range.begin(), end = range.end(); x != end; ++x)
+                {
+                    auto node = remaining_nodes[x].id;
+                    BOOST_ASSERT(node_data.contractable[node]);
+                    node_data.priorities[node] = EvaluateNodePriority(
+                        SimulateNodeContraction(
+                            data, graph, node, node_data.weights, node_data.contractable),
+                        node_data.depths[node]);
+                }
+            });
         log << " ok.";
     }
 
@@ -688,7 +706,7 @@ std::vector<bool> contractGraph(ContractorGraph &graph,
                 for (auto position = range.begin(), end = range.end(); position != end; ++position)
                 {
                     const NodeID node = remaining_nodes[position].id;
-                    ContractNode(data, graph, node, node_data.weights);
+                    ContractNode(data, graph, node, node_data.weights, node_data.contractable);
                 }
             });
 

unit_tests/contractor/graph_contractor.cpp

@@ -1,9 +1,11 @@
 #include "contractor/graph_contractor.hpp"
+#include <contractor/contract_excludable_graph.hpp>
 
 #include "../common/range_tools.hpp"
 #include "helper.hpp"
 
 #include <boost/test/unit_test.hpp>
+
 #include <tbb/global_control.h>
 
 using namespace osrm;
@@ -12,6 +14,85 @@ using namespace osrm::unit_test;
 
 BOOST_AUTO_TEST_SUITE(graph_contractor)
 
+BOOST_AUTO_TEST_CASE(contract_exclude_graph)
+{
+    tbb::global_control scheduler(tbb::global_control::max_allowed_parallelism, 1);
+    /* Edge 0 is labeled with toll,
+     * no edge will be contracted
+     *
+     * toll
+     * (0)  <--1--< (1)
+     *  v             v
+     *  |              \
+     *  1               2
+     *  |                \
+     *  > (3) <--2--< (2) <
+     */
+    std::vector edges = {TestEdge{1, 0, 1},
+                         TestEdge{0, 3, 1},
+
+                         TestEdge{1, 2, 2},
+                         TestEdge{2, 3, 2}};
+    auto reference_graph = makeGraph(edges);
+
+    auto contracted_graph = reference_graph;
+
+    QueryGraph query_graph;
+    std::vector<std::vector<bool>> edge_filters;
+    std::tie(query_graph, edge_filters) =
+        contractExcludableGraph(contracted_graph,
+                                {{1}, {1}, {1}, {1}},
+                                {{true, true, true, true}, {false, true, true, true}});
+    REQUIRE_SIZE_RANGE(query_graph.GetAdjacentEdgeRange(0), 0);
+    BOOST_CHECK(query_graph.FindEdge(0, 1) == SPECIAL_EDGEID);
+    BOOST_CHECK(query_graph.FindEdge(0, 3) == SPECIAL_EDGEID);
+    REQUIRE_SIZE_RANGE(query_graph.GetAdjacentEdgeRange(1), 2);
+    BOOST_CHECK(query_graph.FindEdge(1, 0) != SPECIAL_EDGEID);
+    BOOST_CHECK(query_graph.FindEdge(1, 2) != SPECIAL_EDGEID);
+    REQUIRE_SIZE_RANGE(query_graph.GetAdjacentEdgeRange(2), 0);
+    BOOST_CHECK(query_graph.FindEdge(2, 1) == SPECIAL_EDGEID);
+    BOOST_CHECK(query_graph.FindEdge(2, 3) == SPECIAL_EDGEID);
+    REQUIRE_SIZE_RANGE(query_graph.GetAdjacentEdgeRange(3), 2);
+    BOOST_CHECK(query_graph.FindEdge(3, 0) != SPECIAL_EDGEID);
+    BOOST_CHECK(query_graph.FindEdge(3, 2) != SPECIAL_EDGEID);
+
+    auto reference_graph2 = makeGraph(edges);
+
+    auto contracted_graph2 = reference_graph2;
+
+    /* All edges are normal edges,
+     * edge 2 will be contracted
+     *
+     * Deleted edge_based_edges 1 -> 2, 3 -> 2
+     *
+     * (0)  <--1--< (1)
+     *  v             v
+     *  |              \
+     *  1               2
+     *  |                \
+     *  > (3) <--2--< (2) <
+     */
+    QueryGraph query_graph2;
+    std::vector<std::vector<bool>> edge_filters2;
+    std::tie(query_graph2, edge_filters2) =
+        contractExcludableGraph(contracted_graph2,
+                                {{1}, {1}, {1}, {1}},
+                                {{true, true, true, true}, {true, true, true, true}});
+
+    REQUIRE_SIZE_RANGE(query_graph2.GetAdjacentEdgeRange(0), 0);
+    BOOST_CHECK(query_graph2.FindEdge(0, 1) == SPECIAL_EDGEID);
+    BOOST_CHECK(query_graph2.FindEdge(0, 3) == SPECIAL_EDGEID);
+    REQUIRE_SIZE_RANGE(query_graph2.GetAdjacentEdgeRange(1), 1);
+    BOOST_CHECK(query_graph2.FindEdge(1, 0) != SPECIAL_EDGEID);
+    BOOST_CHECK(query_graph2.FindEdge(1, 2) == SPECIAL_EDGEID);
+    REQUIRE_SIZE_RANGE(query_graph2.GetAdjacentEdgeRange(2), 2);
+    BOOST_CHECK(query_graph2.FindEdge(2, 1) != SPECIAL_EDGEID);
+    BOOST_CHECK(query_graph2.FindEdge(2, 3) != SPECIAL_EDGEID);
+    REQUIRE_SIZE_RANGE(query_graph2.GetAdjacentEdgeRange(3), 1);
+    BOOST_CHECK(query_graph2.FindEdge(3, 0) != SPECIAL_EDGEID);
+    BOOST_CHECK(query_graph2.FindEdge(3, 2) == SPECIAL_EDGEID);
+}
+
 BOOST_AUTO_TEST_CASE(contract_graph)
 {
     tbb::global_control scheduler(tbb::global_control::max_allowed_parallelism, 1);