Add new benchmarks, update the lists

Author: atuchin-m

benches/bench_matching.rs

@@ -76,9 +76,11 @@ fn bench_matching_only(blocker: &Blocker, resources: &ResourceStorage, requests:
     (matches, passes)
 }
 
+type ParsedRequest = (String, String, String, String, bool);
+
 fn bench_rule_matching_browserlike(
     blocker: &Engine,
-    requests: &Vec<(String, String, String, String, bool)>,
+    requests: &Vec<ParsedRequest>,
 ) -> (u32, u32) {
     let mut matches = 0;
     let mut passes = 0;
@@ -331,27 +333,60 @@ fn rule_match_browserlike_comparable(c: &mut Criterion) {
             .collect::<Vec<_>>()
     }
 
-    let elep_req = requests_parsed(&requests);
-    let el_req = elep_req.clone();
-    let slim = elep_req.clone();
+    let requests = requests_parsed(&requests);
 
-    group.bench_function("el+ep", move |b| {
+    group.bench_function("el+ep", |b| {
         let rules = rules_from_lists(&[
             "data/easylist.to/easylist/easylist.txt",
             "data/easylist.to/easylist/easyprivacy.txt",
         ]);
         let engine = Engine::from_rules_parametrised(rules, Default::default(), false, true);
-        b.iter(|| bench_rule_matching_browserlike(&engine, &elep_req))
+        b.iter(|| bench_rule_matching_browserlike(&engine, &requests))
     });
-    group.bench_function("el", move |b| {
+    group.bench_function("el", |b| {
         let rules = rules_from_lists(&["data/easylist.to/easylist/easylist.txt"]);
         let engine = Engine::from_rules_parametrised(rules, Default::default(), false, true);
-        b.iter(|| bench_rule_matching_browserlike(&engine, &el_req))
+        b.iter(|| bench_rule_matching_browserlike(&engine, &requests))
     });
-    group.bench_function("slimlist", move |b| {
+    group.bench_function("slimlist", |b| {
         let rules = rules_from_lists(&["data/slim-list.txt"]);
         let engine = Engine::from_rules_parametrised(rules, Default::default(), false, true);
-        b.iter(|| bench_rule_matching_browserlike(&engine, &slim))
+        b.iter(|| bench_rule_matching_browserlike(&engine, &requests))
+    });
+    group.bench_function("brave-list", |b| {
+      let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
+      let engine = Engine::from_rules_parametrised(rules, Default::default(), false, true);
+      b.iter(|| bench_rule_matching_browserlike(&engine, &requests))
+  });
+
+    group.finish();
+}
+
+fn rule_match_first_request(c: &mut Criterion) {
+    let mut group = c.benchmark_group("rule-match-first-request");
+
+    group.sample_size(10);
+
+    let requests: Vec<ParsedRequest> = vec![(
+        "https://example.com".to_string(),
+        "example.com".to_string(),
+        "example.com".to_string(),
+        "document".to_string(),
+        false,
+    )];
+
+    group.bench_function("brave-list", |b| {
+        b.iter_with_setup(
+            || {
+                // Setup: Create a fresh engine for each iteration
+                let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
+                Engine::from_rules_parametrised(rules, Default::default(), false, true)
+            },
+            |engine| {
+                // Measured: Single request check with fresh engine
+                bench_rule_matching_browserlike(&engine, &requests)
+            }
+        )
     });
 
     group.finish();
@@ -363,6 +398,7 @@ criterion_group!(
     rule_match_parsed_el,
     rule_match_parsed_elep_slimlist,
     rule_match_browserlike_comparable,
+    rule_match_first_request,
     serialization,
     deserialization
 );

benches/bench_rules.rs

@@ -84,8 +84,6 @@ fn list_parse(c: &mut Criterion) {
 fn get_blocker(rules: impl IntoIterator<Item=impl AsRef<str>>) -> Blocker {
     let (network_filters, _) = adblock::lists::parse_filters(rules, false, Default::default());
 
-    println!("Got {} network filters", network_filters.len());
-
     let blocker_options = BlockerOptions {
         enable_optimizations: true,
     };
@@ -99,12 +97,16 @@ fn blocker_new(c: &mut Criterion) {
     group.throughput(Throughput::Elements(1));
     group.sample_size(10);
 
-    let rules: Vec<_> = rules_from_lists(&[
+    let easylist_rules: Vec<_> = rules_from_lists(&[
         "data/easylist.to/easylist/easylist.txt",
         "data/easylist.to/easylist/easyprivacy.txt",
     ]).collect();
+    let brave_list_rules: Vec<_> = rules_from_lists(&[
+        "data/brave/brave-main-list.txt",
+    ]).collect();
 
-    group.bench_function("el+ep", move |b| b.iter(|| get_blocker(&rules)));
+    group.bench_function("el+ep", move |b| b.iter(|| get_blocker(&easylist_rules)));
+    group.bench_function("brave-list", move |b| b.iter(|| get_blocker(&brave_list_rules)));
 
     group.finish();
 }