Flat buffers

.github/workflows/ci.yml

@@ -30,6 +30,9 @@ jobs:
       - name: Cargo build 'adblock' package
         run: cargo build --all-features --all-targets
 
+      - name: Cargo build 'adblock' package (default features)
+        run: cargo build --all-targets
+
       - name: Cargo build 'adblock' package (no default features)
         run: cargo build --no-default-features --all-targets
 
@@ -61,6 +64,9 @@ jobs:
       - name: Cargo test 'adblock' package
         run: cargo test --all-features --tests --no-fail-fast
 
+      - name: Cargo test 'adblock' package (default features)
+        run: cargo test --tests --no-fail-fast
+
       - name: Cargo test 'adblock' package (no default features)
         run: cargo test --no-default-features --features embedded-domain-resolver,full-regex-handling --tests --no-fail-fast
 
@@ -79,7 +85,7 @@ jobs:
           # This hackily checks that the filter is working.
           # If this check fails, something might have been renamed inadvertantly.
           echo "Ensure that '$TEST_NAME_FILTER' still matches exactly 2 tests."
-          cargo test --all-features --test live --no-fail-fast -- --ignored "$TEST_NAME_FILTER" --list | grep "2 tests, 0 benchmarks"
+          cargo test --test live --no-fail-fast -- --ignored "$TEST_NAME_FILTER" --list | grep "2 tests, 0 benchmarks"
 
           # Now run the tests
-          cargo test --all-features --test live --no-fail-fast -- --ignored "$TEST_NAME_FILTER"
+          cargo test --test live --no-fail-fast -- --ignored "$TEST_NAME_FILTER"

.github/workflows/perf-ci.yml

@@ -26,16 +26,16 @@ jobs:
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
 
       - name: Bench network filter matching
-        run: cargo bench --bench bench_matching rule-match-browserlike/brave-list -- --output-format bencher | tee -a output.txt
+        run: cargo bench --bench bench_matching --features flatbuffers rule-match-browserlike/brave-list -- --output-format bencher | tee -a output.txt
 
       - name: Bench first request matching delay
-        run: cargo bench --bench bench_matching rule-match-first-request -- --output-format bencher | tee -a output.txt
+        run: cargo bench --bench bench_matching --features flatbuffers rule-match-first-request -- --output-format bencher | tee -a output.txt
 
       - name: Bench startup speed
-        run: cargo bench --bench bench_rules blocker_new/brave-list -- --output-format bencher | tee -a output.txt
+        run: cargo bench --bench bench_rules --features flatbuffers blocker_new/brave-list -- --output-format bencher | tee -a output.txt
 
       - name: Bench memory usage
-        run: cargo bench --bench bench_memory -- --output-format bencher | tee -a output.txt
+        run: cargo bench --bench bench_memory --features flatbuffers -- --output-format bencher | tee -a output.txt
 
       - name: Store benchmark result
         uses: benchmark-action/github-action-benchmark@d48d326b4ca9ba73ca0cd0d59f108f9e02a381c7 # v1.20.4

Cargo.toml

@@ -41,6 +41,7 @@ cssparser = { version = "0.28", optional = true }
 selectors = { version = "0.23", optional = true }
 serde_json = "1.0"
 thiserror = "1.0"
+flatbuffers = "24.12.23"
 
 [dev-dependencies]
 criterion = "0.5"
@@ -55,6 +56,9 @@ sha2 = "0.9"
 [lib]
 bench = false
 
+[profile.bench]
+debug = true
+
 [[bench]]
 name = "bench_regex"
 harness = false
@@ -98,3 +102,4 @@ css-validation = ["cssparser", "selectors"]
 content-blocking = []
 embedded-domain-resolver = ["addr"] # Requires setting an external domain resolver if disabled.
 resource-assembler = []
+flatbuffers = []

benches/bench_cosmetic_matching.rs

@@ -57,13 +57,7 @@ fn by_classes_ids(c: &mut Criterion) {
         let (_, cosmetic_filters) = parse_filters(&rules, false, FilterFormat::Standard);
         let cfcache = CosmeticFilterCache::from_rules(cosmetic_filters);
         let exceptions = Default::default();
-        b.iter(|| {
-            cfcache.hidden_class_id_selectors(
-                &["ad"],
-                &["ad"],
-                &exceptions,
-            )
-        })
+        b.iter(|| cfcache.hidden_class_id_selectors(&["ad"], &["ad"], &exceptions))
     });
     group.bench_function("many lists", move |b| {
         let rules = rules_from_lists(&[
@@ -75,13 +69,7 @@ fn by_classes_ids(c: &mut Criterion) {
         let (_, cosmetic_filters) = parse_filters(&rules, false, FilterFormat::Standard);
         let cfcache = CosmeticFilterCache::from_rules(cosmetic_filters);
         let exceptions = Default::default();
-        b.iter(|| {
-            cfcache.hidden_class_id_selectors(
-                &["ad"],
-                &["ad"],
-                &exceptions,
-            )
-        })
+        b.iter(|| cfcache.hidden_class_id_selectors(&["ad"], &["ad"], &exceptions))
     });
     group.bench_function("many matching classes and ids", move |b| {
         let rules = rules_from_lists(&[

benches/bench_matching.rs

@@ -2,11 +2,11 @@ use criterion::*;
 
 use serde::{Deserialize, Serialize};
 
-use adblock::Engine;
 use adblock::blocker::{Blocker, BlockerOptions};
 use adblock::request::Request;
 use adblock::resources::ResourceStorage;
 use adblock::url_parser::parse_url;
+use adblock::{Engine, Serialize as _};
 
 #[path = "../tests/test_utils.rs"]
 mod test_utils;
@@ -36,7 +36,7 @@ fn load_requests() -> Vec<TestRequest> {
     reqs
 }
 
-fn get_blocker(rules: impl IntoIterator<Item=impl AsRef<str>>) -> Blocker {
+fn get_blocker(rules: impl IntoIterator<Item = impl AsRef<str>>) -> Blocker {
     let (network_filters, _) = adblock::lists::parse_filters(rules, false, Default::default());
 
     let blocker_options = BlockerOptions {
@@ -61,7 +61,11 @@ fn bench_rule_matching(engine: &Engine, requests: &Vec<TestRequest>) -> (u32, u3
     (matches, passes)
 }
 
-fn bench_matching_only(blocker: &Blocker, resources: &ResourceStorage, requests: &Vec<Request>) -> (u32, u32) {
+fn bench_matching_only(
+    blocker: &Blocker,
+    resources: &ResourceStorage,
+    requests: &Vec<Request>,
+) -> (u32, u32) {
     let mut matches = 0;
     let mut passes = 0;
     requests.iter().for_each(|parsed| {
@@ -78,10 +82,7 @@ fn bench_matching_only(blocker: &Blocker, resources: &ResourceStorage, requests:
 
 type ParsedRequest = (String, String, String, String, bool);
 
-fn bench_rule_matching_browserlike(
-    blocker: &Engine,
-    requests: &Vec<ParsedRequest>,
-) -> (u32, u32) {
+fn bench_rule_matching_browserlike(blocker: &Engine, requests: &Vec<ParsedRequest>) -> (u32, u32) {
     let mut matches = 0;
     let mut passes = 0;
     requests.iter().for_each(
@@ -141,9 +142,7 @@ fn rule_match(c: &mut Criterion) {
 fn rule_match_parsed_el(c: &mut Criterion) {
     let mut group = c.benchmark_group("rule-match-parsed");
 
-    let rules = rules_from_lists(&[
-        "data/easylist.to/easylist/easylist.txt",
-    ]);
+    let rules = rules_from_lists(&["data/easylist.to/easylist/easylist.txt"]);
     let requests = load_requests();
     let requests_parsed: Vec<_> = requests
         .into_iter()
@@ -221,9 +220,7 @@ fn serialization(c: &mut Criterion) {
         b.iter(|| assert!(engine.serialize_raw().unwrap().len() > 0))
     });
     group.bench_function("el", move |b| {
-        let full_rules = rules_from_lists(&[
-            "data/easylist.to/easylist/easylist.txt",
-        ]);
+        let full_rules = rules_from_lists(&["data/easylist.to/easylist/easylist.txt"]);
 
         let engine = Engine::from_rules(full_rules, Default::default());
         b.iter(|| assert!(engine.serialize_raw().unwrap().len() > 0))
@@ -258,9 +255,7 @@ fn deserialization(c: &mut Criterion) {
         })
     });
     group.bench_function("el", move |b| {
-        let full_rules = rules_from_lists(&[
-            "data/easylist.to/easylist/easylist.txt",
-        ]);
+        let full_rules = rules_from_lists(&["data/easylist.to/easylist/easylist.txt"]);
 
         let engine = Engine::from_rules(full_rules, Default::default());
         let serialized = engine.serialize_raw().unwrap();
@@ -294,9 +289,7 @@ fn rule_match_browserlike_comparable(c: &mut Criterion) {
     group.throughput(Throughput::Elements(requests_len));
     group.sample_size(20);
 
-    fn requests_parsed(
-        requests: &[TestRequest],
-    ) -> Vec<(String, String, String, String, bool)> {
+    fn requests_parsed(requests: &[TestRequest]) -> Vec<(String, String, String, String, bool)> {
         requests
             .iter()
             .map(|r| {
@@ -354,10 +347,10 @@ fn rule_match_browserlike_comparable(c: &mut Criterion) {
         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))
-  });
+        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();
 }
@@ -376,21 +369,20 @@ fn rule_match_first_request(c: &mut Criterion) {
     )];
 
     group.bench_function("brave-list", |b| {
-        b.iter_custom(
-            |iters| {
-                let mut total_time = std::time::Duration::ZERO;
-                for _ in 0..iters {
-                  let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
-                  let engine = Engine::from_rules_parametrised(rules, Default::default(), false, true);
-
-                  // Measure only the matching time, skip setup and destruction
-                  let start_time = std::time::Instant::now();
-                  bench_rule_matching_browserlike(&engine, &requests);
-                  total_time += start_time.elapsed();
-                }
-                total_time
+        b.iter_custom(|iters| {
+            let mut total_time = std::time::Duration::ZERO;
+            for _ in 0..iters {
+                let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
+                let engine =
+                    Engine::from_rules_parametrised(rules, Default::default(), false, true);
+
+                // Measure only the matching time, skip setup and destruction
+                let start_time = std::time::Instant::now();
+                bench_rule_matching_browserlike(&engine, &requests);
+                total_time += start_time.elapsed();
             }
-        )
+            total_time
+        })
     });
 
     group.finish();

benches/bench_memory.rs

@@ -4,12 +4,12 @@
  * You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use criterion::*;
+use serde::{Deserialize, Serialize};
 use std::alloc::{GlobalAlloc, Layout, System};
 use std::sync::atomic::{AtomicUsize, Ordering};
-use serde::{Deserialize, Serialize};
 
-use adblock::Engine;
 use adblock::request::Request;
+use adblock::Engine;
 
 #[path = "../tests/test_utils.rs"]
 mod test_utils;
@@ -110,15 +110,15 @@ fn bench_memory_usage(c: &mut Criterion) {
         let mut result = 0;
         b.iter_custom(|iters| {
             for _ in 0..iters {
-              ALLOCATOR.reset();
-              let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
-              let engine = Engine::from_rules(rules, Default::default());
+                ALLOCATOR.reset();
+                let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
+                let engine = Engine::from_rules(rules, Default::default());
 
-              noise += 1; // add some noise to make criterion happy
-              result += ALLOCATOR.current_usage() + noise;
+                noise += 1; // add some noise to make criterion happy
+                result += ALLOCATOR.current_usage() + noise;
 
-              // Prevent engine from being optimized
-              criterion::black_box(&engine);
+                // Prevent engine from being optimized
+                criterion::black_box(&engine);
             }
 
             // Return the memory usage as a Duration
@@ -134,15 +134,15 @@ fn bench_memory_usage(c: &mut Criterion) {
                 let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
                 let engine = Engine::from_rules(rules, Default::default());
 
-              for request in first_1000_requests.clone() {
-                  criterion::black_box(engine.check_network_request(&request.into()));
-              }
+                for request in first_1000_requests.clone() {
+                    criterion::black_box(engine.check_network_request(&request.into()));
+                }
 
-              noise += 1; // add some noise to make criterion happy
-              result += ALLOCATOR.current_usage() + noise;
+                noise += 1; // add some noise to make criterion happy
+                result += ALLOCATOR.current_usage() + noise;
 
-              // Prevent engine from being optimized
-              criterion::black_box(&engine);
+                // Prevent engine from being optimized
+                criterion::black_box(&engine);
             }
 
             // Return the memory usage as a Duration