feat(libredirection): improve performance for building action, testing and creating impact

Author: joelwurtz

Cargo.toml

@@ -25,12 +25,14 @@ tera = "1.19.1"
 default = ["compress", "router"]
 compress = ["dep:brotli", "dep:flate2"]
 router = []
+dot = ["dep:dot_graph"]
 
 [dependencies]
 brotli = { version = "3.4.0", optional = true }
 cfg-if = "1.0.0"
 chrono = { version = "0.4.31", features = ["serde"] }
 cidr = { version = "0.2.2", features = ["serde"] }
+dot_graph = { version = "0.2.3", optional = true }
 flate2 = { version = "1.0.27", optional = true }
 heck = "0.4.1"
 http = "0.2.9"
@@ -66,6 +68,10 @@ harness = false
 name = "filter_body_benchmark"
 harness = false
 
+[[bench]]
+name = "test_examples_benchmark"
+harness = false
+
 [dependencies.web-sys]
 version = "0.3"
 features = [

benches/build_router_rule_benchmark.rs

@@ -1,24 +1,27 @@
 #[macro_use]
 extern crate criterion;
+
 use criterion::{BatchSize, BenchmarkId, Criterion};
+use flate2::read::GzDecoder;
 use redirectionio::api::{Rule, RulesMessage};
 use redirectionio::router::{Router, RouterConfig};
-use std::fs::read_to_string;
+use std::fs::File;
 
 fn create_rules(filename: String) -> RulesMessage {
-    let content = read_to_string(filename).expect("Cannot open file");
-    let rules: RulesMessage = serde_json::from_str(content.as_str()).expect("Cannot deserialize");
+    let content_gzip = File::open(filename.clone()).expect("Cannot open file");
+    let rules: RulesMessage = serde_json::from_reader(GzDecoder::new(content_gzip)).expect("Cannot deserialize");
 
     rules
 }
 
 fn build_router_bench(c: &mut Criterion) {
     let files = vec![
-        "../bench-files/large-rules-1k.json".to_string(),
-        "../bench-files/large-rules-10k.json".to_string(),
-        "../bench-files/large-rules-50k.json".to_string(),
-        "../bench-files/large-rules-150k.json".to_string(),
-        "../bench-files/large-rules-200k.json".to_string(),
+        "../bench-files/large-rules-1k.json.gz".to_string(),
+        "../bench-files/large-rules-10k.json.gz".to_string(),
+        "../bench-files/large-rules-50k.json.gz".to_string(),
+        "../bench-files/large-rules-150k.json.gz".to_string(),
+        "../bench-files/large-rules-200k.json.gz".to_string(),
+        "../bench-files/large-rules-210k.json.gz".to_string(),
     ];
 
     let mut group = c.benchmark_group("router_builder");
@@ -31,10 +34,15 @@ fn build_router_bench(c: &mut Criterion) {
                 |rules| {
                     let config = RouterConfig::default();
                     let mut router = Router::<Rule>::from_config(config.clone());
+                    let rules_len = rules.rules.len();
 
                     for rule in rules.rules {
-                        router.insert(rule.into_route(&config));
+                        router.insert(rule);
                     }
+
+                    router.cache(10_000);
+
+                    assert_eq!(router.len(), rules_len);
                 },
                 BatchSize::NumIterations(1),
             );

benches/filter_body_benchmark.rs

@@ -7,7 +7,7 @@ use criterion::{BenchmarkId, Criterion};
 use redirectionio::action::Action;
 use redirectionio::api::Rule;
 use redirectionio::http::{Header, Request};
-use redirectionio::router::RouterConfig;
+use redirectionio::router::{IntoRoute, RouterConfig};
 use std::io::Write;
 use std::sync::Arc;
 

benches/match_rule_benchmark.rs

@@ -1,31 +1,33 @@
 #[macro_use]
 extern crate criterion;
 use criterion::{BenchmarkId, Criterion};
+use flate2::read::GzDecoder;
 use redirectionio::action::{Action, UnitTrace};
 use redirectionio::api::{Rule, RulesMessage};
 use redirectionio::http::Request;
 use redirectionio::router::{Router, RouterConfig};
-use std::fs::read_to_string;
+use std::fs::File;
 
 fn create_router(filename: String, config: &RouterConfig) -> Router<Rule> {
-    let content = read_to_string(filename).expect("Cannot open file");
-    let rules: RulesMessage = serde_json::from_str(content.as_str()).expect("Cannot deserialize");
-    let mut router = Router::<Rule>::default();
+    let content_gzip = File::open(filename.clone()).expect("Cannot open file");
+    let rules: RulesMessage = serde_json::from_reader(GzDecoder::new(content_gzip)).expect("Cannot deserialize");
+    let mut router = Router::<Rule>::from_config(config.clone());
 
     for rule in rules.rules {
-        router.insert(rule.into_route(config))
+        router.insert(rule)
     }
 
     router
 }
 
 fn no_match_bench(c: &mut Criterion) {
     let files = vec![
-        "../bench-files/large-rules-1k.json".to_string(),
-        "../bench-files/large-rules-10k.json".to_string(),
-        "../bench-files/large-rules-50k.json".to_string(),
-        "../bench-files/large-rules-150k.json".to_string(),
-        "../bench-files/large-rules-200k.json".to_string(),
+        "../bench-files/large-rules-1k.json.gz".to_string(),
+        "../bench-files/large-rules-10k.json.gz".to_string(),
+        "../bench-files/large-rules-50k.json.gz".to_string(),
+        "../bench-files/large-rules-150k.json.gz".to_string(),
+        "../bench-files/large-rules-200k.json.gz".to_string(),
+        "../bench-files/large-rules-210k.json.gz".to_string(),
     ];
 
     let mut group = c.benchmark_group("no_match");
@@ -48,11 +50,12 @@ fn no_match_bench(c: &mut Criterion) {
 
 fn no_match_cache_bench(c: &mut Criterion) {
     let files = vec![
-        "../bench-files/large-rules-1k.json".to_string(),
-        "../bench-files/large-rules-10k.json".to_string(),
-        "../bench-files/large-rules-50k.json".to_string(),
-        "../bench-files/large-rules-150k.json".to_string(),
-        "../bench-files/large-rules-200k.json".to_string(),
+        "../bench-files/large-rules-1k.json.gz".to_string(),
+        "../bench-files/large-rules-10k.json.gz".to_string(),
+        "../bench-files/large-rules-50k.json.gz".to_string(),
+        "../bench-files/large-rules-150k.json.gz".to_string(),
+        "../bench-files/large-rules-200k.json.gz".to_string(),
+        "../bench-files/large-rules-210k.json.gz".to_string(),
     ];
 
     let mut group = c.benchmark_group("no_match_cache");
@@ -77,7 +80,7 @@ fn no_match_cache_bench(c: &mut Criterion) {
 
 fn match_rule_in_200k(c: &mut Criterion) {
     let config = RouterConfig::default();
-    let mut router = create_router("../bench-files/large-rules-200k.json".to_string(), &config);
+    let mut router = create_router("../bench-files/large-rules-200k.json.gz".to_string(), &config);
     let request = Request::from_config(
         &config,
         "/sites/default/files/image-gallery/lowtideonuseppaimage000000edited_0.jpg".to_string(),
@@ -104,7 +107,7 @@ fn match_rule_in_200k(c: &mut Criterion) {
 
 fn build_action_rule_in_200k(c: &mut Criterion) {
     let config = RouterConfig::default();
-    let mut router = create_router("../bench-files/large-rules-200k.json".to_string(), &config);
+    let mut router = create_router("../bench-files/large-rules-200k.json.gz".to_string(), &config);
     let request = Request::from_config(
         &config,
         "/sites/default/files/image-gallery/lowtideonuseppaimage000000edited_0.jpg".to_string(),
@@ -156,7 +159,7 @@ fn build_action_rule_in_200k(c: &mut Criterion) {
 
 fn impact(c: &mut Criterion) {
     let config = RouterConfig::default();
-    let mut router = create_router("../bench-files/large-rules-200k.json".to_string(), &config);
+    let mut router = create_router("../bench-files/large-rules-200k.json.gz".to_string(), &config);
     let request = Request::from_config(
         &config,
         "/sites/default/files/image-gallery/lowtideonuseppaimage000000edited_0.jpg".to_string(),

benches/perf.rs

@@ -1,7 +1,7 @@
 use std::{fs::File, os::raw::c_int, path::Path};
 
 use criterion::profiler::Profiler;
-use pprof::ProfilerGuard;
+use pprof::{ProfilerGuard, ProfilerGuardBuilder};
 
 /// Small custom profiler that can be used with Criterion to create a flamegraph for benchmarks.
 /// Also see [the Criterion documentation on this][custom-profiler].
@@ -52,12 +52,13 @@ impl<'a> FlamegraphProfiler<'a> {
 
 impl<'a> Profiler for FlamegraphProfiler<'a> {
     fn start_profiling(&mut self, _benchmark_id: &str, _benchmark_dir: &Path) {
-        self.active_profiler = Some(ProfilerGuard::new(self.frequency).unwrap());
+        let profiler = ProfilerGuardBuilder::default().frequency(self.frequency).build().unwrap();
+
+        self.active_profiler = Some(profiler);
     }
 
-    fn stop_profiling(&mut self, _benchmark_id: &str, benchmark_dir: &Path) {
-        std::fs::create_dir_all(benchmark_dir).unwrap();
-        let flamegraph_path = benchmark_dir.join("flamegraph.svg");
+    fn stop_profiling(&mut self, _benchmark_id: &str, _benchmark_dir: &Path) {
+        let flamegraph_path = Path::new("flamegraph.svg");
         let flamegraph_file = File::create(flamegraph_path).expect("File system error while creating flamegraph.svg");
         if let Some(profiler) = self.active_profiler.take() {
             profiler

benches/test_examples_benchmark.rs

@@ -0,0 +1,51 @@
+#[macro_use]
+extern crate criterion;
+use criterion::{BenchmarkId, Criterion};
+use flate2::read::GzDecoder;
+use redirectionio::api::{Rule, RuleChangeSet, RulesMessage, TestExamplesOutput, TestExamplesProjectInput};
+use redirectionio::router::{Router, RouterConfig};
+use std::fs::File;
+
+mod perf;
+
+fn test_examples_bench(c: &mut Criterion) {
+    let files = vec!["../bench-files/large-rules-210k.json.gz".to_string()];
+
+    let mut group = c.benchmark_group("no_match");
+    group.sample_size(10);
+
+    for filename in files {
+        let config = RouterConfig::default();
+        let content_gzip = File::open(filename.clone()).expect("Cannot open file");
+        let rules: RulesMessage = serde_json::from_reader(GzDecoder::new(content_gzip)).expect("Cannot deserialize");
+        let mut router = Router::<Rule>::from_config(config.clone());
+
+        for rule in rules.rules {
+            router.insert(rule)
+        }
+
+        router.cache(10_000);
+
+        let arc_router = std::sync::Arc::new(router);
+
+        group.bench_with_input(BenchmarkId::from_parameter(filename.clone()), &filename, |b, _f| {
+            b.iter(|| {
+                TestExamplesOutput::from_project(
+                    TestExamplesProjectInput {
+                        change_set: RuleChangeSet::default(),
+                    },
+                    arc_router.clone(),
+                );
+            });
+        });
+    }
+
+    group.finish();
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().with_profiler(perf::FlamegraphProfiler::new(99));
+    targets = test_examples_bench
+}
+criterion_main!(benches);