Source code
Revision control
Copy as Markdown
Other Tools
use criterion::*;
use serde::{Deserialize, Serialize};
use adblock::request::Request;
use adblock::url_parser::parse_url;
use adblock::{Engine, FilterSet};
#[path = "../tests/test_utils.rs"]
mod test_utils;
use test_utils::rules_from_lists;
#[allow(non_snake_case)]
#[derive(Serialize, Deserialize, Clone)]
struct TestRequest {
frameUrl: String,
url: String,
cpt: String,
}
impl From<&TestRequest> for Request {
fn from(v: &TestRequest) -> Self {
Request::new(&v.url, &v.frameUrl, &v.cpt).unwrap()
}
}
fn load_requests() -> Vec<TestRequest> {
let requests_str = rules_from_lists(&["data/requests.json"]);
let reqs: Vec<TestRequest> = requests_str
.into_iter()
.map(|r| serde_json::from_str(&r))
.filter_map(Result::ok)
.collect();
reqs
}
fn get_engine(rules: impl IntoIterator<Item = impl AsRef<str>>) -> Engine {
let (network_filters, cosmetic_filters) =
adblock::lists::parse_filters(rules, false, Default::default());
Engine::from_filter_set(
FilterSet::new_with_rules(network_filters, cosmetic_filters, false),
true,
)
}
fn bench_rule_matching(engine: &Engine, requests: &[TestRequest]) -> (u32, u32) {
let mut matches = 0;
let mut passes = 0;
requests.iter().for_each(|r| {
let res = engine.check_network_request(&r.into());
if res.matched {
matches += 1;
} else {
passes += 1;
}
});
// println!("Got {} matches, {} passes, {} errors", matches, passes, errors);
(matches, passes)
}
fn bench_matching_only(engine: &Engine, requests: &[Request]) -> (u32, u32) {
let mut matches = 0;
let mut passes = 0;
requests.iter().for_each(|parsed| {
let check = engine.check_network_request(parsed);
if check.matched {
matches += 1;
} else {
passes += 1;
}
});
// println!("Got {} matches, {} passes", matches, passes);
(matches, passes)
}
type ParsedRequest = (String, String, String, String, bool);
fn bench_rule_matching_browserlike(blocker: &Engine, requests: &[ParsedRequest]) -> (u32, u32) {
let mut matches = 0;
let mut passes = 0;
requests.iter().for_each(
|(url, hostname, source_hostname, request_type, third_party)| {
let check = blocker.check_network_request(&Request::preparsed(
url,
hostname,
source_hostname,
request_type,
*third_party,
));
if check.matched {
matches += 1;
} else {
passes += 1;
}
},
);
// println!("Got {} matches, {} passes", matches, passes);
(matches, passes)
}
fn rule_match(c: &mut Criterion) {
let mut group = c.benchmark_group("rule-match");
let requests = load_requests();
let elep_req = requests.clone();
let el_req = requests.clone();
let slim_req = requests.clone();
let requests_len = requests.len() as u64;
group.throughput(Throughput::Elements(requests_len));
group.sample_size(10);
group.bench_function("el+ep", move |b| {
let rules = rules_from_lists(&[
"data/easylist.to/easylist/easylist.txt",
"data/easylist.to/easylist/easyprivacy.txt",
]);
let engine = Engine::from_rules(rules, Default::default());
b.iter(|| bench_rule_matching(&engine, &elep_req))
});
group.bench_function("easylist", move |b| {
let rules = rules_from_lists(&["data/easylist.to/easylist/easylist.txt"]);
let engine = Engine::from_rules(rules, Default::default());
b.iter(|| bench_rule_matching(&engine, &el_req))
});
group.bench_function("slimlist", move |b| {
let rules = rules_from_lists(&["data/slim-list.txt"]);
let engine = Engine::from_rules(rules, Default::default());
b.iter(|| bench_rule_matching(&engine, &slim_req))
});
group.finish();
}
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 requests = load_requests();
let requests_parsed: Vec<_> = requests
.into_iter()
.map(|r| Request::new(&r.url, &r.frameUrl, &r.cpt))
.filter_map(Result::ok)
.collect();
let requests_len = requests_parsed.len() as u64;
let engine = get_engine(rules);
group.throughput(Throughput::Elements(requests_len));
group.sample_size(10);
group.bench_function("easylist", move |b| {
b.iter(|| bench_matching_only(&engine, &requests_parsed))
});
group.finish();
}
fn rule_match_parsed_elep_slimlist(c: &mut Criterion) {
let mut group = c.benchmark_group("rule-match-parsed");
let full_rules = rules_from_lists(&[
"data/easylist.to/easylist/easylist.txt",
"data/easylist.to/easylist/easyprivacy.txt",
]);
let engine = get_engine(full_rules);
let requests = load_requests();
let requests_parsed: Vec<_> = requests
.into_iter()
.map(|r| Request::new(&r.url, &r.frameUrl, &r.cpt))
.filter_map(Result::ok)
.collect();
let requests_len = requests_parsed.len() as u64;
let slim_rules = rules_from_lists(&["data/slim-list.txt"]);
let slim_engine = get_engine(slim_rules);
let requests_copy = load_requests();
let requests_parsed_copy: Vec<_> = requests_copy
.into_iter()
.map(|r| Request::new(&r.url, &r.frameUrl, &r.cpt))
.filter_map(Result::ok)
.collect();
group.throughput(Throughput::Elements(requests_len));
group.sample_size(10);
group.bench_function("el+ep", move |b| {
b.iter(|| bench_matching_only(&engine, &requests_parsed))
});
group.bench_function("slimlist", move |b| {
b.iter(|| bench_matching_only(&slim_engine, &requests_parsed_copy))
});
group.finish();
}
fn rule_match_browserlike_comparable(c: &mut Criterion) {
let mut group = c.benchmark_group("rule-match-browserlike");
let requests = load_requests();
let requests_len = requests.len() as u64;
group.throughput(Throughput::Elements(requests_len));
group.sample_size(10);
fn requests_parsed(requests: &[TestRequest]) -> Vec<(String, String, String, String, bool)> {
requests
.iter()
.map(|r| {
let url_norm = r.url.to_ascii_lowercase();
let source_url_norm = r.frameUrl.to_ascii_lowercase();
let maybe_parsed_url = parse_url(&url_norm);
if maybe_parsed_url.is_none() {
return Err("bad url");
}
let parsed_url = maybe_parsed_url.unwrap();
let maybe_parsed_source = parse_url(&source_url_norm);
if let Some(parsed_source) = maybe_parsed_source {
Ok((
parsed_url.url.to_owned(),
parsed_url.hostname().to_owned(),
parsed_source.hostname().to_owned(),
r.cpt.clone(),
parsed_source.domain() != parsed_url.domain(),
))
} else {
Ok((
parsed_url.url.to_owned(),
parsed_url.hostname().to_owned(),
"".to_owned(),
r.cpt.clone(),
true,
))
}
})
.filter_map(Result::ok)
.collect::<Vec<_>>()
}
let requests = requests_parsed(&requests);
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, &requests))
});
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, &requests))
});
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, &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_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();
}
criterion_group!(
benches,
rule_match,
rule_match_parsed_el,
rule_match_parsed_elep_slimlist,
rule_match_browserlike_comparable,
rule_match_first_request,
);
criterion_main!(benches);