demostf/parser
1
0
Fork 0
mirror of https://codeberg.org/demostf/parser.git synced 2026-06-03 10:14:06 +02:00
Code Issues Releases Wiki Activity

move benchmarks to iai-callgrind

Browse source
This commit is contained in:
Robin Appelman 2025-07-13 22:46:05 +02:00
commit ec3685bfb3
7 changed files with 151 additions and 516 deletions
Download patch file Download diff file Expand all files Collapse all files

60
benches/allmessages.rs
View file

@ -1,60 +0,0 @@
#![allow(dead_code)]
#![allow(unused_imports)]
#![allow(unused_variables)]
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use pretty_assertions::assert_eq;
use std::fs;
use std::collections::{HashMap, HashSet};
use tf_demo_parser::demo::data::DemoTick;
use tf_demo_parser::demo::message::Message;
use tf_demo_parser::demo::packet::datatable::{ParseSendTable, SendTableName};
use tf_demo_parser::demo::packet::stringtable::StringTableEntry;
use tf_demo_parser::demo::parser::MessageHandler;
use tf_demo_parser::demo::sendprop::RawSendPropDefinition;
use tf_demo_parser::{Demo, DemoParser, MatchState, MessageType, MessageTypeAnalyser, ParserState};
struct AllMessages;
impl MessageHandler for AllMessages {
type Output = bool;
fn does_handle(message_type: MessageType) -> bool {
true
}
fn handle_message(&mut self, message: &Message, tick: DemoTick, _parser_state: &ParserState) {
black_box(message);
}
fn into_output(self, state: &ParserState) -> Self::Output {
black_box(true)
}
}
fn bench_all(input_file: &str, b: &mut Criterion) {
let file = fs::read(input_file).expect("Unable to read file");
let demo = Demo::new(&file);
let stream = demo.get_stream();
b.bench_function("bench_all", |b| {
b.iter(|| {
let _ = black_box(
DemoParser::new_with_analyser(stream.clone(), AllMessages)
.parse()
.unwrap(),
);
})
});
}
fn all_test_gully(b: &mut Criterion) {
bench_all("test_data/gully.dem", b);
}
criterion_group! {
name = benches;
config = Criterion::default().sample_size(10);
targets = all_test_gully
}
criterion_main!(benches);

56
benches/bench.rs
View file

@ -1,56 +0,0 @@
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use std::fs;
use tf_demo_parser::demo::parser::gamestateanalyser::GameStateAnalyser;
use tf_demo_parser::{Demo, DemoParser, Stream};
fn bench_file(input_file: &str, b: &mut Criterion) {
let file = fs::read(input_file).expect("Unable to read file");
let demo = Demo::new(&file);
let stream: Stream = demo.get_stream();
b.bench_function(&format!("bench file {}", input_file), |b| {
b.iter(|| {
let (_, state) = DemoParser::new(stream.clone()).parse().unwrap();
black_box(state);
})
});
}
fn bench_gamestate(input_file: &str, b: &mut Criterion) {
let file = fs::read(input_file).expect("Unable to read file");
let demo = Demo::new(&file);
let stream: Stream = demo.get_stream();
b.bench_function(&format!("bench gamestate {}", input_file), |b| {
b.iter(|| {
let (_, state) =
DemoParser::new_with_analyser(stream.clone(), GameStateAnalyser::default())
.parse()
.unwrap();
black_box(state);
})
});
}
fn bench_gully(b: &mut Criterion) {
bench_file("test_data/gully.dem", b);
}
fn bench_comp(b: &mut Criterion) {
bench_file("test_data/comp.dem", b);
}
fn bench_gamestate_gully(b: &mut Criterion) {
bench_gamestate("test_data/gully.dem", b);
}
fn bench_gamestate_comp(b: &mut Criterion) {
bench_gamestate("test_data/comp.dem", b);
}
criterion_group!(
benches,
bench_comp,
bench_gully,
bench_gamestate_comp,
bench_gamestate_gully
);
criterion_main!(benches);

37
benches/iai.rs
View file

@ -1,37 +0,0 @@
use iai::black_box;
use tf_demo_parser::demo::data::DemoTick;
use tf_demo_parser::demo::message::Message;
use tf_demo_parser::demo::parser::MessageHandler;
use tf_demo_parser::{Demo, DemoParser, MessageType, ParserState};
struct AllMessages;
impl MessageHandler for AllMessages {
type Output = bool;
fn does_handle(_message_type: MessageType) -> bool {
true
}
fn handle_message(&mut self, message: &Message, _tick: DemoTick, _parser_state: &ParserState) {
black_box(message);
}
fn into_output(self, _state: &ParserState) -> Self::Output {
black_box(true)
}
}
const INPUT: &[u8] = include_bytes!("../test_data/gully.dem");
fn bench_all() {
let demo = Demo::new(INPUT);
let stream = demo.get_stream();
black_box(
DemoParser::new_with_analyser(stream.clone(), AllMessages)
.parse()
.unwrap(),
);
}
iai::main!(bench_all);

57
benches/parse.rs Normal file
View file

@ -0,0 +1,57 @@
use iai_callgrind::{library_benchmark, library_benchmark_group, main};
use std::fs::read;
use std::hint::black_box;
use std::path::Path;
use tf_demo_parser::demo::data::DemoTick;
use tf_demo_parser::demo::message::Message;
use tf_demo_parser::demo::parser::analyser::Analyser;
use tf_demo_parser::demo::parser::gamestateanalyser::GameStateAnalyser;
use tf_demo_parser::demo::parser::MessageHandler;
use tf_demo_parser::{Demo, DemoParser, MessageType, ParserState};
struct AllMessages;
impl MessageHandler for AllMessages {
type Output = bool;
fn does_handle(_message_type: MessageType) -> bool {
true
}
fn handle_message(&mut self, message: &Message, _tick: DemoTick, _parser_state: &ParserState) {
black_box(message);
}
fn into_output(self, _state: &ParserState) -> Self::Output {
black_box(true)
}
}
fn read_file<P: AsRef<Path>>(path: P) -> Demo<'static> {
let data = read(path).unwrap();
Demo::owned(data)
}
fn get_parser<P: AsRef<Path>, A: MessageHandler>(path: P, analyser: A) -> DemoParser<'static, A> {
let demo = read_file(path);
let stream = demo.get_stream();
DemoParser::new_with_analyser(stream.clone(), analyser)
}
#[library_benchmark(setup = get_parser)]
#[bench::basic_small("test_data/small.dem", Analyser::new())]
#[bench::basic_gully("test_data/gully.dem", Analyser::new())]
#[bench::game_state_small("test_data/small.dem", GameStateAnalyser::new())]
#[bench::game_state_gully("test_data/gully.dem", GameStateAnalyser::new())]
#[bench::all_small("test_data/small.dem", AllMessages)]
#[bench::all_gully("test_data/gully.dem", AllMessages)]
fn parse<A: MessageHandler>(parser: DemoParser<A>) {
black_box(parser.parse().unwrap());
}
library_benchmark_group!(
name = bench_parse;
benchmarks = parse
);
main!(library_benchmark_groups = bench_parse);