Skip to content

(WIP) Add benchmarks comparing performance of parse functions #50

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
wants to merge 2 commits into
base: main
Choose a base branch
from
Draft

(WIP) Add benchmarks comparing performance of parse functions #50

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
49d61b1
Add pg_query_parse and pg_query_parse_protobuf benchmarks.
duckinator Feb 14, 2025
99a414a
Split benchmarks into multiple files, to allow generation of per-benc…
duckinator Feb 14, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
23 changes: 23 additions & 0 deletions Cargo.lock
View file
Open in desktop

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

12 changes: 12 additions & 0 deletions Cargo.toml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -30,3 +30,15 @@ glob = "0.3.1"
easy-parallel = "3.2.0"
pretty_assertions = "1.4.0"
regex = "1.6.0"
brunch = "0.8.*"
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Crates should be ordered alphabetically. Also it's better to use 0.8 (now 0.10) when you don't intend to pin to a patch version.


[profile.bench]
debug = true

[[bench]]
name = "parse"
harness = false

[[bench]]
name = "parse_protobuf"
harness = false
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Since the actual code in the benchmarks is so simple, I wonder if they should be merged into a single benchmark file:

use brunch::Bench;
use pg_query::bindings::*;
use std::ffi::{c_char, CString};

brunch::benches!(
    Bench::new("parse_json").run_seeded_with(seed, |query| unsafe { pg_query_parse(query.as_ptr() as *const c_char) }),
    Bench::new("parse_protobuf").run_seeded_with(seed, |query| unsafe { pg_query_parse_protobuf(query.as_ptr() as *const c_char) }),
    Bench::new("parse_summary").run_seeded_with(seed, |query| unsafe { pg_query_parse_summary(query.as_ptr() as *const c_char, 0, 0) }),
);

fn seed() -> CString {
    CString::new(build_query(100)).unwrap()
}

fn build_query(table_references: i32) -> String {
    let mut query = "SELECT * FROM t".to_string();
    for i in 0..table_references {
        query = format!("{query} JOIN t{i} ON t.id = t{i}.t_id AND t{i}.k IN (1, 2, 3, 4) AND t{i}.f IN (SELECT o FROM p WHERE q = 'foo')");
    }
    query
}

17 changes: 17 additions & 0 deletions benches/helpers.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,17 @@
use std::ffi::CString;

pub fn build_query(table_references: i32) -> String {
let mut query = "SELECT * FROM t".to_string();
for i in 0..table_references {
query = format!("{query} JOIN t{i} ON t.id = t{i}.t_id AND t{i}.k IN (1, 2, 3, 4) AND t{i}.f IN (SELECT o FROM p WHERE q = 'foo')");
}
query
}

pub fn seed() -> String {
build_query(100)
}

pub fn c_seed() -> CString {
CString::new(seed()).unwrap()
}
25 changes: 25 additions & 0 deletions benches/parse.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,25 @@
mod helpers;
use helpers::*;

use std::ffi::c_char;
use brunch::Bench;
use pg_query;
use pg_query::bindings::{pg_query_parse, pg_query_parse_protobuf};


// pub fn pg_query_parse_protobuf(input: *const ::std::os::raw::c_char) -> PgQueryProtobufParseResult;
// pub fn pg_query_parse_protobuf_opts(input: *const ::std::os::raw::c_char, parser_options: ::std::os::raw::c_int) -> PgQueryProtobufParseResult;

// pub fn pg_query_parse(input: *const ::std::os::raw::c_char) -> PgQueryParseResult;
// pub fn pg_query_parse_opts(input: *const ::std::os::raw::c_char, parser_options: ::std::os::raw::c_int) -> PgQueryParseResult;

// pg_query_raw_parse ?

brunch::benches!(
Bench::new("pg_query_parse")
.run_seeded_with(c_seed, |query| {
unsafe { pg_query_parse(query.as_ptr() as *const c_char) }
//let result = pg_query::parse(&query);
//assert!(result.is_ok());
}),
);
15 changes: 15 additions & 0 deletions benches/parse_protobuf.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,15 @@
mod helpers;
use helpers::*;

use std::ffi::c_char;
use brunch::Bench;
use pg_query;
use pg_query::bindings::{pg_query_parse, pg_query_parse_protobuf};


brunch::benches!(
Bench::new("pg_query_parse_protobuf")
.run_seeded_with(c_seed, |query| {
unsafe { pg_query_parse_protobuf(query.as_ptr() as *const c_char) }
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It might be interesting to include the deserialization in Rust as well, so we can get a sense for where to optimize (if we were to optimize the serialization itself).

For the protobuf parse benchmark we can use the same mechanism the crate currently uses. For JSON we could (just for testing) use the mechanism that pg_parse uses (which shares a common history with this crate, but we since diverged to focus on the Protobuf format).

}),
);
2 changes: 1 addition & 1 deletion src/lib.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -38,7 +38,7 @@
//! ```
//!

mod bindings;
pub mod bindings;
mod error;
mod node_enum;
mod node_mut;
Expand Down
Loading