[perf] Route FilterSet network rules incrementally during load

.github/workflows/capture-flamegraphs.yml

@@ -0,0 +1,68 @@
+# Capture CPU flamegraphs for issue #541 PR evidence.
+# Trigger: gh workflow run capture-flamegraphs.yml -R Tilzen/adblock-rust
+name: Capture flamegraphs
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  cpu-flamegraphs:
+    name: CPU flamegraphs (master vs PR)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+          ref: perf/incremental-filter-set-compilation
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - name: Install perf and flamegraph
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y linux-tools-common linux-tools-generic librsvg2-bin
+          sudo sysctl -w kernel.perf_event_paranoid=1
+          cargo install flamegraph --locked
+
+      - name: Prepare profiling harness
+        run: |
+          mkdir -p examples docs/perf/issue-541/images
+          git show perf/incremental-filter-set-compilation:examples/profile_brave_list_cpu.rs \
+            > examples/profile_brave_list_cpu.rs
+
+      - name: Capture master CPU flamegraph
+        run: |
+          git checkout master
+          git show perf/incremental-filter-set-compilation:examples/profile_brave_list_cpu.rs \
+            > examples/profile_brave_list_cpu.rs
+          CARGO_PROFILE_RELEASE_DEBUG=true cargo flamegraph \
+            --example profile_brave_list_cpu \
+            --output docs/perf/issue-541/images/cpu-before.svg
+
+      - name: Capture PR CPU flamegraph
+        run: |
+          rm -f examples/profile_brave_list_cpu.rs
+          git checkout perf/incremental-filter-set-compilation
+          git show perf/incremental-filter-set-compilation:examples/profile_brave_list_cpu.rs \
+            > examples/profile_brave_list_cpu.rs
+          CARGO_PROFILE_RELEASE_DEBUG=true cargo flamegraph \
+            --example profile_brave_list_cpu \
+            --output docs/perf/issue-541/images/cpu-after.svg
+          rsvg-convert -w 1400 docs/perf/issue-541/images/cpu-before.svg \
+            -o docs/perf/issue-541/images/cpu-before.png
+          rsvg-convert -w 1400 docs/perf/issue-541/images/cpu-after.svg \
+            -o docs/perf/issue-541/images/cpu-after.png
+
+      - name: Upload flamegraph artifacts
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: issue-541-flamegraphs
+          path: |
+            docs/perf/issue-541/images/cpu-before.svg
+            docs/perf/issue-541/images/cpu-after.svg
+            docs/perf/issue-541/images/cpu-before.png
+            docs/perf/issue-541/images/cpu-after.png
+          if-no-files-found: error

benches/bench_memory.rs

@@ -240,11 +240,20 @@ fn bench_cb(
     run_requests: &[&TestRequest],
     metric: MemoryAllocated,
     b: &mut Bencher<MemoryAllocated>,
+) {
+    bench_cb_with_opts(run_requests, metric, b, Default::default());
+}
+
+fn bench_cb_with_opts(
+    run_requests: &[&TestRequest],
+    metric: MemoryAllocated,
+    b: &mut Bencher<MemoryAllocated>,
+    opts: adblock::lists::ParseOptions,
 ) {
     let single_run = || {
         ALLOCATOR.reset();
         let rules = rules_from_lists(&["data/brave/brave-main-list.txt"]);
-        let mut engine = Engine::from_rules(rules, Default::default());
+        let mut engine = Engine::from_rules(rules, opts);
         let resource_json = std::fs::read_to_string("data/brave/brave-resources.json").unwrap();
         let resource_list: Vec<Resource> = serde_json::from_str(&resource_json).unwrap();
         std::mem::drop(resource_json);
@@ -292,6 +301,17 @@ fn bench_max_memory_usage(c: &mut Criterion<MemoryAllocated>) {
     group.bench_function("brave-list-initial/max", |b| {
         bench_cb(&[], MemoryAllocated::Max, b)
     });
+    group.bench_function("brave-list-network-only/max", |b| {
+        bench_cb_with_opts(
+            &[],
+            MemoryAllocated::Max,
+            b,
+            adblock::lists::ParseOptions {
+                rule_types: adblock::lists::RuleTypes::NetworkOnly,
+                ..Default::default()
+            },
+        )
+    });
     group.finish();
 }
 

benches/bench_rules.rs

@@ -78,6 +78,12 @@ fn list_parse(c: &mut Criterion) {
     group.finish();
 }
 
+fn get_engine_from_filter_set(rules: impl IntoIterator<Item = impl AsRef<str>>) -> Engine {
+    let mut filter_set = FilterSet::new(false);
+    filter_set.add_filters(rules, Default::default());
+    Engine::from_filter_set(filter_set, true)
+}
+
 fn get_engine(rules: impl IntoIterator<Item = impl AsRef<str>>) -> Engine {
     let (network_filters, cosmetic_filters) =
         adblock::lists::parse_filters(rules, false, Default::default());
@@ -100,13 +106,17 @@ fn blocker_new(c: &mut Criterion) {
     ])
     .collect();
     let brave_list_rules: Vec<_> = rules_from_lists(&["data/brave/brave-main-list.txt"]).collect();
+    let brave_list_rules_for_filter_set = brave_list_rules.clone();
     let engine = Engine::from_rules(&brave_list_rules, Default::default());
     let engine_serialized = engine.serialize().to_vec();
 
     group.bench_function("el+ep", move |b| b.iter(|| get_engine(&easylist_rules)));
     group.bench_function("brave-list", move |b| {
         b.iter(|| get_engine(&brave_list_rules))
     });
+    group.bench_function("brave-list-filter-set", move |b| {
+        b.iter(|| get_engine_from_filter_set(&brave_list_rules_for_filter_set))
+    });
     group.bench_function("brave-list-deserialize", move |b| {
         b.iter(|| {
             let mut engine = Engine::default();