Add parameters to limit number of settled nodes during preparation, much faster preparation for certain graphs (#37)

easbar · web-flow · commit 36b9fec8b783 · 2021-09-13T08:14:09.000+02:00
diff --git a/README.md b/README.md
@@ -117,14 +117,14 @@ For this to work `another_input_graph` must have the same number of nodes as `in
 |California&Nevada|1.890.816|4.630.444|
 |USA|23.947.348|57.708.624|
 
-|graph|metric|preparation time|average query time|
-|-|-|-|-|
-|NY city|distance|15 s|108 μs|
-|CAL&NV|distance|70 s|243 μs|
-|USA|distance|21 min|1452 μs|
-|NY city|time|10 s|54 μs|
-|CAL&NV|time|50 s|149 μs|
-|USA|time|11 min|856 μs|
+|graph|metric|preparation time|average query time|out edges|in edges|
+|-|-|-|-|-|-|
+|NY city|distance|13 s|100 μs|747.555|747.559|
+|CAL&NV|distance|57 s|244 μs|4.147.109|4.147.183|
+|USA|distance|17 min|1433 μs|52.617.216|52.617.642|
+|NY city|time|9 s|55 μs|706.053|706.084|
+|CAL&NV|time|42 s|148 μs|3.975.276|3.975.627|
+|USA|time|9.8 min|872 μs|49.277.058|49.283.162|
 
 The shortest path calculation time was averaged over 100k random routing queries. The benchmarks were run using Rust 1.50.0
 
diff --git a/changelog b/changelog
@@ -1,7 +1,11 @@
 0.3.0 (not yet released)
+      breaking: add max_settled_nodes parameters to Params, important performance tuning for graphs with large-weight edges, #37
+      add InputGraph::to_file, #35
+      faster fast_graph building, 82e9a2ef417af6de1b2cb41bcee41b6302db1b4a
       allow passing &[T] instead of &Vec<T> in a few places, #32
       add calc_path_multiple_sources_and_targets, #30
-0.2.0 add clone and copy derives, #26
+0.2.0 [April 25th 2021]
+      add clone and copy derives, #26
       faster fast_graph building
       faster queries (stall on demand optimization), #18
       fix serious performance regression for Rust >=1.45, #21
@@ -10,5 +14,7 @@
       WebAssembly compatibility, #11
       deterministic fast_graph building, #10
       license change to dual MIT/Apache 2.0, #4
-0.1.1 adds travis and meta information to Cargo.toml
-0.1.0 initial version
+0.1.1 [June 17th 2019]
+      adds travis and meta information to Cargo.toml
+0.1.0 [June 17th 2019]
+      initial version
diff --git a/src/fast_graph_builder.rs b/src/fast_graph_builder.rs
@@ -62,14 +62,26 @@ impl FastGraphBuilder {
     pub fn build_with_order(
         input_graph: &InputGraph,
         order: &[NodeId],
+    ) -> Result<FastGraph, String> {
+        FastGraphBuilder::build_with_order_with_params(
+            input_graph,
+            order,
+            &ParamsWithOrder::default(),
+        )
+    }
+
+    pub fn build_with_order_with_params(
+        input_graph: &InputGraph,
+        order: &[NodeId],
+        params: &ParamsWithOrder,
     ) -> Result<FastGraph, String> {
         if input_graph.get_num_nodes() != order.len() {
             return Err(String::from(
                 "The given order must have as many nodes as the input graph",
             ));
         }
         let mut builder = FastGraphBuilder::new(input_graph);
-        builder.run_contraction_with_order(input_graph, order);
+        builder.run_contraction_with_order(input_graph, order, params);
         Ok(builder.fast_graph)
     }
 
@@ -85,6 +97,7 @@ impl FastGraphBuilder {
                 &mut witness_search,
                 node,
                 0,
+                params.max_settled_nodes_initial_relevance,
             ) as Weight;
             queue.push(node, Reverse(priority));
         }
@@ -121,7 +134,12 @@ impl FastGraphBuilder {
             self.fast_graph.first_edge_ids_bwd[rank + 1] = self.fast_graph.get_num_in_edges();
 
             self.fast_graph.ranks[node] = rank;
-            node_contractor::contract_node(&mut preparation_graph, &mut witness_search, node);
+            node_contractor::contract_node(
+                &mut preparation_graph,
+                &mut witness_search,
+                node,
+                params.max_settled_nodes_contraction,
+            );
             for neighbor in neighbors {
                 levels[neighbor] = max(levels[neighbor], levels[node] + 1);
                 let priority = node_contractor::calc_relevance(
@@ -130,6 +148,7 @@ impl FastGraphBuilder {
                     &mut witness_search,
                     neighbor,
                     levels[neighbor],
+                    params.max_settled_nodes_neighbor_relevance,
                 ) as Weight;
                 queue.change_priority(&neighbor, Reverse(priority));
             }
@@ -145,7 +164,12 @@ impl FastGraphBuilder {
         self.finish_contraction();
     }
 
-    fn run_contraction_with_order(&mut self, input_graph: &InputGraph, order: &[NodeId]) {
+    fn run_contraction_with_order(
+        &mut self,
+        input_graph: &InputGraph,
+        order: &[NodeId],
+        params: &ParamsWithOrder,
+    ) {
         let mut preparation_graph = PreparationGraph::from_input_graph(input_graph);
         let mut witness_search = WitnessSearch::new(self.num_nodes);
         for (rank, node) in order.iter().cloned().enumerate() {
@@ -177,7 +201,12 @@ impl FastGraphBuilder {
             self.fast_graph.first_edge_ids_bwd[rank + 1] = self.fast_graph.get_num_in_edges();
 
             self.fast_graph.ranks[node] = rank;
-            node_contractor::contract_node(&mut preparation_graph, &mut witness_search, node);
+            node_contractor::contract_node(
+                &mut preparation_graph,
+                &mut witness_search,
+                node,
+                params.max_settled_nodes_contraction_with_order,
+            );
             debug!(
                 "contracted node {} / {}, num edges fwd: {}, num edges bwd: {}",
                 rank + 1,
@@ -240,20 +269,73 @@ impl FastGraphBuilder {
 }
 
 pub struct Params {
+    /// Smaller values typically yield less shortcuts and a faster preparation time. The relation to
+    /// query speeds is less clear. For large values that yield a much higher number of shortcuts
+    /// queries become slow, but otherwise the query speed might only change by a small amount
+    /// when you change this parameter. The optimal value can only be found heuristically for your
+    /// specific graph and can even depend on the other parameters below. We recommend trying
+    /// different values between 0 and 1.
     pub hierarchy_depth_factor: f32,
+    /// This parameter is simply set to 1.0, because only it's relative size compared to
+    /// hierarchy_depth_factor plays a role.
     pub edge_quotient_factor: f32,
+    /// The maximum number of settled nodes per witness search performed when priorities are
+    /// calculated for all nodes initially. Since this does not take much time you should probably
+    /// keep the default.
+    pub max_settled_nodes_initial_relevance: usize,
+    /// The maximum number of settled nodes per witness search performed when updating priorities
+    /// of neighbor nodes after a node was contracted. The preparation time can strongly depend on
+    /// this value and even setting it to a very small value like 0 or 1 might be feasible.
+    /// Higher values (like ~500+) should yield less shortcuts and faster query times at the cost of
+    /// a longer preparation time. Lower values (like ~0-100) should yield a faster preparation at
+    /// the cost of slower query times and more shortcuts. To know for sure you should still run
+    /// your own experiments for your specific graph.
+    pub max_settled_nodes_neighbor_relevance: usize,
+    /// The maximum number of settled nodes per witness search when contracting a node. Higher values
+    /// like ~500+ mean less shortcuts (fast graph edges), slower preparation and faster queries.
+    /// Lower values mean more shortcuts, slower queries and faster preparation.
+    pub max_settled_nodes_contraction: usize,
 }
 
 impl Params {
-    pub fn new(ratio: f32) -> Self {
+    pub fn new(
+        ratio: f32,
+        max_settled_nodes_initial_relevance: usize,
+        max_settled_nodes_neighbor_relevance: usize,
+        max_settled_nodes_contraction: usize,
+    ) -> Self {
         Params {
             hierarchy_depth_factor: ratio,
             edge_quotient_factor: 1.0,
+            max_settled_nodes_initial_relevance,
+            max_settled_nodes_neighbor_relevance,
+            max_settled_nodes_contraction,
+        }
+    }
+
+    pub fn default() -> Self {
+        Params::new(0.1, 500, 100, 500)
+    }
+}
+
+pub struct ParamsWithOrder {
+    /// The maximum number of settled nodes per witness search when contracting a node. Smaller
+    /// values mean slower queries, more shortcuts, but a faster preparation. Note that the
+    /// performance can also strongly depend on the relation between this parameter and
+    /// Params::max_settled_nodes_contraction that was used to build the FastGraph and obtain the
+    /// node ordering initially. In most cases you should use the same value for these two parameters.
+    pub max_settled_nodes_contraction_with_order: usize,
+}
+
+impl ParamsWithOrder {
+    pub fn new(max_settled_nodes_contraction_with_order: usize) -> Self {
+        ParamsWithOrder {
+            max_settled_nodes_contraction_with_order,
         }
     }
 
     pub fn default() -> Self {
-        Params::new(0.1)
+        ParamsWithOrder::new(100)
     }
 }
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -27,6 +27,7 @@ pub use crate::fast_graph::FastGraph;
 pub use crate::fast_graph32::FastGraph32;
 pub use crate::fast_graph_builder::FastGraphBuilder;
 pub use crate::fast_graph_builder::Params;
+use crate::fast_graph_builder::ParamsWithOrder;
 pub use crate::input_graph::Edge;
 pub use crate::input_graph::InputGraph;
 pub use crate::path_calculator::PathCalculator;
@@ -67,6 +68,15 @@ pub fn prepare_with_order(input_graph: &InputGraph, order: &[NodeId]) -> Result<
     FastGraphBuilder::build_with_order(input_graph, order)
 }
 
+/// Like `prepare_with_order()`, but allows specifying some parameters used for the graph preparation
+pub fn prepare_with_order_with_params(
+    input_graph: &InputGraph,
+    order: &[NodeId],
+    params: &ParamsWithOrder,
+) -> Result<FastGraph, String> {
+    FastGraphBuilder::build_with_order_with_params(input_graph, order, params)
+}
+
 /// Calculates the shortest path from `source` to `target`.
 pub fn calc_path(fast_graph: &FastGraph, source: NodeId, target: NodeId) -> Option<ShortestPath> {
     let mut calc = PathCalculator::new(fast_graph.get_num_nodes());
@@ -136,6 +146,7 @@ mod tests {
     use crate::preparation_graph::PreparationGraph;
 
     use super::*;
+    use crate::fast_graph_builder::ParamsWithOrder;
 
     #[test]
     fn routing_on_random_graph() {
@@ -391,9 +402,11 @@ mod tests {
     fn run_performance_test_dist() {
         println!("Running performance test for Bremen dist");
         // road network extracted from OSM data from Bremen, Germany using the road distance as weight
+        // prep: 190ms, query: 16μs, out: 68494, in: 68426
+        // todo: try to tune parameters
         run_performance_test(
             &InputGraph::from_file("meta/test_maps/bremen_dist.gr"),
-            &Params::default(),
+            &Params::new(0.1, 500, 2, 50),
             845493338,
             30265,
         )
@@ -404,9 +417,11 @@ mod tests {
     fn run_performance_test_time() {
         println!("Running performance test for Bremen time");
         // road network extracted from OSM data from Bremen, Germany using the travel time as weight
+        // prep: 256ms, query: 11μs, out: 64825, in: 65027
+        // todo: try to tune parameters
         run_performance_test(
             &InputGraph::from_file("meta/test_maps/bremen_time.gr"),
-            &Params::default(),
+            &Params::new(0.1, 100, 2, 100),
             88104267255,
             30265,
         );
@@ -416,9 +431,11 @@ mod tests {
     #[test]
     fn run_performance_test_ballard() {
         println!("Running performance test for ballard");
+        // prep: 1150ms, query: 53μs, out: 43849, in: 43700
+        // todo: try to tune parameters
         run_performance_test(
             &InputGraph::from_file("meta/test_maps/graph_ballard.gr"),
-            &Params::new(0.01),
+            &Params::new(0.1, 100, 3, 100),
             28409159409,
             14992,
         );
@@ -428,9 +445,11 @@ mod tests {
     #[test]
     fn run_performance_test_23rd() {
         println!("Running performance test for 23rd");
+        // prep: 170ms, query: 23μs, out: 11478, in: 11236
+        // todo: try to tune parameters
         run_performance_test(
             &InputGraph::from_file("meta/test_maps/graph_23rd.gr"),
-            &Params::default(),
+            &Params::new(0.1, 100, 3, 100),
             19438403873,
             20421,
         );
@@ -440,26 +459,46 @@ mod tests {
     #[test]
     fn run_performance_test_south_seattle_car() {
         println!("Running performance test for South Seattle car");
+        // prep: 877ms, query: 26μs, out: 68777, in: 68161
+        // todo: try to tune parameters
         run_performance_test(
             &InputGraph::from_file("meta/test_maps/south_seattle_car.gr"),
-            &Params::default(),
+            &Params::new(0.1, 100, 10, 100),
             77479396,
             30805,
         );
     }
 
     #[ignore]
     #[test]
-    fn run_performance_test_dist_fixed_ordering() {
+    fn run_performance_test_bremen_dist_fixed_ordering() {
         println!("Running performance test for Bremen dist (fixed node ordering)");
+        // prep: 340ms, prep_order: 64ms, query: 16μs, out: 66646, in: 66725
+        // todo: try to tune parameters
         run_performance_test_fixed_ordering(
             &InputGraph::from_file("meta/test_maps/bremen_dist.gr"),
             &Params::default(),
+            &ParamsWithOrder::default(),
             845493338,
             30265,
         );
     }
 
+    #[ignore]
+    #[test]
+    fn run_performance_test_south_seattle_fixed_ordering() {
+        println!("Running performance test for South Seattle car (fixed node ordering)");
+        // prep: 811ms, prep order: 138ms, query: 27μs, out: 68777, in: 68161
+        // todo: try to tune parameters
+        run_performance_test_fixed_ordering(
+            &InputGraph::from_file("meta/test_maps/south_seattle_car.gr"),
+            &Params::new(0.1, 100, 10, 100),
+            &ParamsWithOrder::new(100),
+            77479396,
+            30805,
+        );
+    }
+
     fn run_performance_test(
         input_graph: &InputGraph,
         params: &Params,
@@ -484,6 +523,7 @@ mod tests {
     fn run_performance_test_fixed_ordering(
         input_graph: &InputGraph,
         params: &Params,
+        params_with_order: &ParamsWithOrder,
         expected_checksum: usize,
         expected_num_not_found: usize,
     ) {
@@ -496,7 +536,10 @@ mod tests {
         );
         let order = get_node_ordering(&fast_graph);
         prepare_algo(
-            &mut |input_graph| fast_graph = prepare_with_order(input_graph, &order).unwrap(),
+            &mut |input_graph| {
+                fast_graph =
+                    prepare_with_order_with_params(input_graph, &order, params_with_order).unwrap()
+            },
             &input_graph,
         );
         print_fast_graph_stats(&fast_graph);
diff --git a/src/node_contractor.rs b/src/node_contractor.rs
diff --git a/src/witness_search.rs b/src/witness_search.rs
