From 322a80b6af31fee717eccb5612e861d326537199 Mon Sep 17 00:00:00 2001 From: Hoverbear Date: Tue, 4 Sep 2018 11:09:31 -0700 Subject: [PATCH 1/3] Fix clippy lints. --- src/eraftpb.rs | 2 +- src/errors.rs | 4 ++-- src/lib.rs | 7 +++---- src/raft.rs | 2 +- src/raw_node.rs | 2 +- src/read_only.rs | 2 +- tests/tests.rs | 5 ++--- 7 files changed, 11 insertions(+), 13 deletions(-) diff --git a/src/eraftpb.rs b/src/eraftpb.rs index e1fe5642c..18bae7dfa 100644 --- a/src/eraftpb.rs +++ b/src/eraftpb.rs @@ -3,7 +3,7 @@ // https://github.com/Manishearth/rust-clippy/issues/702 #![allow(unknown_lints)] -#![allow(clippy)] +#![cfg_attr(feature = "cargo-clippy", allow(clippy::all))] #![cfg_attr(rustfmt, rustfmt_skip)] diff --git a/src/errors.rs b/src/errors.rs index 41ee32689..4a7ea6f1f 100644 --- a/src/errors.rs +++ b/src/errors.rs @@ -67,7 +67,7 @@ quick_error! { } impl cmp::PartialEq for Error { - #[allow(match_same_arms)] + #[cfg_attr(feature = "cargo-clippy", allow(clippy::match_same_arms))] fn eq(&self, other: &Error) -> bool { match (self, other) { (&Error::StepPeerNotFound, &Error::StepPeerNotFound) => true, @@ -112,7 +112,7 @@ quick_error! { } impl cmp::PartialEq for StorageError { - #[allow(match_same_arms)] + #[cfg_attr(feature = "cargo-clippy", allow(clippy::match_same_arms))] fn eq(&self, other: &StorageError) -> bool { match (self, other) { (&StorageError::Compacted, &StorageError::Compacted) => true, diff --git a/src/lib.rs b/src/lib.rs index 475d0bab3..152a5f014 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -212,9 +212,8 @@ For more information, check out an [example](examples/single_mem_node/main.rs#L1 */ -#![cfg_attr(feature = "dev", feature(plugin))] -#![cfg_attr(feature = "dev", plugin(clippy))] -#![cfg_attr(not(feature = "dev"), allow(unknown_lints))] +#![cfg_attr(not(feature = "cargo-clippy"), allow(unknown_lints))] +#![cfg_attr(feature = "cargo-clippy", feature(tool_lints))] #![deny(missing_docs)] extern crate fxhash; @@ -289,6 +288,6 @@ pub mod prelude { /// Do any common test initialization. Eg set up logging, setup fail-rs. #[cfg(test)] -pub fn setup_for_test() { +fn setup_for_test() { let _ = env_logger::try_init(); } diff --git a/src/raft.rs b/src/raft.rs index 4f4f62823..b45163b64 100644 --- a/src/raft.rs +++ b/src/raft.rs @@ -560,7 +560,7 @@ impl Raft { self.bcast_heartbeat_with_ctx(ctx) } - #[allow(needless_pass_by_value)] + #[cfg_attr(feature = "cargo-clippy", allow(clippy::needless_pass_by_value))] fn bcast_heartbeat_with_ctx(&mut self, ctx: Option>) { let self_id = self.id; let mut prs = self.take_prs(); diff --git a/src/raw_node.rs b/src/raw_node.rs index 18d83c49a..42f1e4af2 100644 --- a/src/raw_node.rs +++ b/src/raw_node.rs @@ -286,7 +286,7 @@ impl RawNode { } /// ProposeConfChange proposes a config change. - #[allow(needless_pass_by_value)] + #[cfg_attr(feature = "cargo-clippy", allow(clippy::needless_pass_by_value))] pub fn propose_conf_change(&mut self, context: Vec, cc: ConfChange) -> Result<()> { let data = protobuf::Message::write_to_bytes(&cc)?; let mut m = Message::new(); diff --git a/src/read_only.rs b/src/read_only.rs index 0dbd6a279..efa57dc8c 100644 --- a/src/read_only.rs +++ b/src/read_only.rs @@ -135,7 +135,7 @@ impl ReadOnly { } *x == m.get_context() }) { - for _ in 0..i + 1 { + for _ in 0..=i { let rs = self.read_index_queue.pop_front().unwrap(); let status = self.pending_read_index.remove(&rs).unwrap(); rss.push(status); diff --git a/tests/tests.rs b/tests/tests.rs index de99854d1..0666745e4 100644 --- a/tests/tests.rs +++ b/tests/tests.rs @@ -11,9 +11,8 @@ // See the License for the specific language governing permissions and // limitations under the License. -#![cfg_attr(feature = "dev", feature(plugin))] -#![cfg_attr(feature = "dev", plugin(clippy))] -#![cfg_attr(not(feature = "dev"), allow(unknown_lints))] +#![cfg_attr(not(feature = "cargo-clippy"), allow(unknown_lints))] +#![cfg_attr(feature = "cargo-clippy", feature(tool_lints))] #[macro_use] extern crate log; From 2442bef35a98092dd9e8862c797e516ddfbea9c6 Mon Sep 17 00:00:00 2001 From: Hoverbear Date: Mon, 27 Aug 2018 14:31:18 -0700 Subject: [PATCH 2/3] Introduce benchmarking using Criterion. --- Cargo.toml | 9 +- README.md | 35 +++++++- benches/benches.rs | 15 ++++ benches/suites/mod.rs | 8 ++ benches/suites/progress.rs | 13 +++ benches/suites/progress_set.rs | 155 +++++++++++++++++++++++++++++++++ benches/suites/raft.rs | 86 ++++++++++++++++++ benches/suites/raw_node.rs | 22 +++++ src/lib.rs | 3 + src/raft.rs | 5 +- 10 files changed, 346 insertions(+), 5 deletions(-) create mode 100644 benches/benches.rs create mode 100644 benches/suites/mod.rs create mode 100644 benches/suites/progress.rs create mode 100644 benches/suites/progress_set.rs create mode 100644 benches/suites/raft.rs create mode 100644 benches/suites/raw_node.rs diff --git a/Cargo.toml b/Cargo.toml index 6e829363d..f60828f9e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,14 +12,19 @@ description = "The rust language implementation of Raft algorithm." categories = ["algorithms", "database-implementations"] [dependencies] -log = "0.4.3" +log = "0.4" protobuf = "2.0.4" quick-error = "1.2.2" rand = "0.5.4" fxhash = "0.2.1" [dev-dependencies] -env_logger = "0.5.12" +env_logger = "0.5" +criterion = ">0.2.4" + +[[bench]] +name = "benches" +harness = false [badges] travis-ci = { repository = "pingcap/raft-rs" } diff --git a/README.md b/README.md index 7b2aac169..fdd594b55 100644 --- a/README.md +++ b/README.md @@ -38,20 +38,26 @@ Using `rustup` you can get started this way: ```bash rustup override set stable rustup toolchain install nightly +rustup component add clippy-review --nightly +rustup component add rustfmt-preview ``` In order to have your PR merged running the following must finish without error: ```bash -cargo +nightly test --features dev +cargo test --all && \ +cargo +nightly clippy --all && \ +cargo fmt --all -- --check ``` You may optionally want to install `cargo-watch` to allow for automated rebuilding while editing: ```bash -cargo watch -s "cargo check --features dev" +cargo watch -s "cargo check" ``` +### Modifying Protobufs + If proto file `eraftpb.proto` changed, run the command to regenerate `eraftpb.rs`: ```bash @@ -60,6 +66,31 @@ protoc proto/eraftpb.proto --rust_out=src You can check `Cargo.toml` to find which version of `protobuf-codegen` is required. +### Benchmarks + +We use [Criterion](https://github.com/japaric/criterion.rs) for benchmarking. + +> It's currently an ongoing effort to build an appropriate benchmarking suite. If you'd like to help out please let us know! [Interested?](https://github.com/pingcap/raft-rs/issues/109) + +You can run the benchmarks by installing `gnuplot` then running: + +```bash +cargo bench +``` + +You can check `target/criterion/report/index.html` for plots and charts relating to the benchmarks. + +You can check the performance between two branches: + +```bash +git checkout master +cargo bench --bench benches -- --save-baseline master +git checkout other +cargo bench --bench benches -- --baseline master +``` + +This will report relative increases or decreased for each benchmark. + ## Acknowledgments Thanks [etcd](https://github.com/coreos/etcd) for providing the amazing Go implementation! diff --git a/benches/benches.rs b/benches/benches.rs new file mode 100644 index 000000000..501fd1edf --- /dev/null +++ b/benches/benches.rs @@ -0,0 +1,15 @@ +#![allow(dead_code)] // Due to criterion we need this to avoid warnings. + +#[macro_use] +extern crate criterion; +extern crate raft; + +mod suites; +use suites::*; + +criterion_main!( + bench_raft, + bench_raw_node, + bench_progress, + bench_progress_set, +); diff --git a/benches/suites/mod.rs b/benches/suites/mod.rs new file mode 100644 index 000000000..f6e36f7ef --- /dev/null +++ b/benches/suites/mod.rs @@ -0,0 +1,8 @@ +mod raft; +pub use self::raft::*; +mod raw_node; +pub use self::raw_node::*; +mod progress; +pub use self::progress::*; +mod progress_set; +pub use self::progress_set::*; diff --git a/benches/suites/progress.rs b/benches/suites/progress.rs new file mode 100644 index 000000000..030ef506c --- /dev/null +++ b/benches/suites/progress.rs @@ -0,0 +1,13 @@ +use criterion::{Bencher, Criterion}; +use raft::Progress; + +criterion_group!(bench_progress, bench_progress_default); + +pub fn bench_progress_default(c: &mut Criterion) { + let bench = |b: &mut Bencher| { + // No setup. + b.iter(|| Progress::default()); + }; + + c.bench_function("Progress::default", bench); +} diff --git a/benches/suites/progress_set.rs b/benches/suites/progress_set.rs new file mode 100644 index 000000000..0b14e8ceb --- /dev/null +++ b/benches/suites/progress_set.rs @@ -0,0 +1,155 @@ +use criterion::{Bencher, Criterion}; +use raft::ProgressSet; + +criterion_group!( + bench_progress_set, + bench_progress_set_new, + bench_progress_set_insert_voter, + bench_progress_set_insert_learner, + bench_progress_set_promote_learner, + bench_progress_set_remove, + bench_progress_set_iter, + bench_progress_set_get, + bench_progress_set_nodes, +); + +fn quick_progress_set(voters: usize, learners: usize) -> ProgressSet { + let mut set = ProgressSet::new(voters, learners); + (0..voters).for_each(|id| { + set.insert_voter(id as u64, Default::default()).ok(); + }); + (voters..learners).for_each(|id| { + set.insert_learner(id as u64, Default::default()).ok(); + }); + set +} + +pub fn bench_progress_set_new(c: &mut Criterion) { + let bench = |voters, learners| { + move |b: &mut Bencher| { + // No setup. + b.iter(|| ProgressSet::new(voters, learners)); + } + }; + + c.bench_function("ProgressSet::new (0, 0)", bench(0, 0)); + c.bench_function("ProgressSet::new (3, 1)", bench(3, 1)); + c.bench_function("ProgressSet::new (5, 2)", bench(5, 2)); + c.bench_function("ProgressSet::new (7, 3)", bench(7, 3)); +} + +pub fn bench_progress_set_insert_voter(c: &mut Criterion) { + let bench = |voters, learners| { + move |b: &mut Bencher| { + let set = quick_progress_set(voters, learners); + b.iter(|| { + let mut set = set.clone(); + set.insert_voter(99, Default::default()).ok() + }); + } + }; + c.bench_function("ProgressSet::insert_voter (0, 0)", bench(0, 0)); + c.bench_function("ProgressSet::insert_voter (3, 1)", bench(3, 1)); + c.bench_function("ProgressSet::insert_voter (5, 2)", bench(5, 2)); + c.bench_function("ProgressSet::insert_voter (7, 3)", bench(7, 3)); +} + +pub fn bench_progress_set_insert_learner(c: &mut Criterion) { + let bench = |voters, learners| { + move |b: &mut Bencher| { + let set = quick_progress_set(voters, learners); + b.iter(|| { + let mut set = set.clone(); + set.insert_learner(99, Default::default()).ok() + }); + } + }; + c.bench_function("ProgressSet::insert_learner (0, 0)", bench(0, 0)); + c.bench_function("ProgressSet::insert_learner (3, 1)", bench(3, 1)); + c.bench_function("ProgressSet::insert_learner (5, 2)", bench(5, 2)); + c.bench_function("ProgressSet::insert_learner (7, 3)", bench(7, 3)); +} + +pub fn bench_progress_set_remove(c: &mut Criterion) { + let bench = |voters, learners| { + move |b: &mut Bencher| { + let set = quick_progress_set(voters, learners); + b.iter(|| { + let mut set = set.clone(); + set.remove(3) + }); + } + }; + c.bench_function("ProgressSet::remove (0, 0)", bench(0, 0)); + c.bench_function("ProgressSet::remove (3, 1)", bench(3, 1)); + c.bench_function("ProgressSet::remove (5, 2)", bench(5, 2)); + c.bench_function("ProgressSet::remove (7, 3)", bench(7, 3)); +} + +pub fn bench_progress_set_promote_learner(c: &mut Criterion) { + let bench = |voters, learners| { + move |b: &mut Bencher| { + let set = quick_progress_set(voters, learners); + b.iter(|| { + let mut set = set.clone(); + set.promote_learner(3) + }); + } + }; + c.bench_function("ProgressSet::promote (0, 0)", bench(0, 0)); + c.bench_function("ProgressSet::promote (3, 1)", bench(3, 1)); + c.bench_function("ProgressSet::promote (5, 2)", bench(5, 2)); + c.bench_function("ProgressSet::promote (7, 3)", bench(7, 3)); +} + +pub fn bench_progress_set_iter(c: &mut Criterion) { + let bench = |voters, learners| { + move |b: &mut Bencher| { + let set = quick_progress_set(voters, learners); + b.iter(|| { + let set = set.clone(); + let agg = set.iter().all(|_| true); + agg + }); + } + }; + c.bench_function("ProgressSet::iter (0, 0)", bench(0, 0)); + c.bench_function("ProgressSet::iter (3, 1)", bench(3, 1)); + c.bench_function("ProgressSet::iter (5, 2)", bench(5, 2)); + c.bench_function("ProgressSet::iter (7, 3)", bench(7, 3)); +} + +pub fn bench_progress_set_nodes(c: &mut Criterion) { + let bench = |voters, learners| { + move |b: &mut Bencher| { + let set = quick_progress_set(voters, learners); + b.iter(|| { + let set = set.clone(); + let agg = set.iter().all(|_| true); + agg + }); + } + }; + c.bench_function("ProgressSet::nodes (0, 0)", bench(0, 0)); + c.bench_function("ProgressSet::nodes (3, 1)", bench(3, 1)); + c.bench_function("ProgressSet::nodes (5, 2)", bench(5, 2)); + c.bench_function("ProgressSet::nodes (7, 3)", bench(7, 3)); +} + +pub fn bench_progress_set_get(c: &mut Criterion) { + let bench = |voters, learners| { + move |b: &mut Bencher| { + let set = quick_progress_set(voters, learners); + b.iter(|| { + let set = set.clone(); + { + set.get(1); + } + }); + } + }; + c.bench_function("ProgressSet::get (0, 0)", bench(0, 0)); + c.bench_function("ProgressSet::get (3, 1)", bench(3, 1)); + c.bench_function("ProgressSet::get (5, 2)", bench(5, 2)); + c.bench_function("ProgressSet::get (7, 3)", bench(7, 3)); +} diff --git a/benches/suites/raft.rs b/benches/suites/raft.rs new file mode 100644 index 000000000..3e38a4a9c --- /dev/null +++ b/benches/suites/raft.rs @@ -0,0 +1,86 @@ +use criterion::{Bencher, Criterion}; +use raft::{storage::MemStorage, Config, Raft}; + +criterion_group!(bench_raft, bench_raft_new, bench_raft_campaign,); + +fn quick_raft(voters: usize, learners: usize) -> Raft { + let id = 1; + let storage = MemStorage::default(); + let config = Config::new(id); + let mut raft = Raft::new(&config, storage); + (0..voters).for_each(|id| { + raft.add_node(id as u64); + }); + (voters..learners).for_each(|id| { + raft.add_learner(id as u64); + }); + raft +} + +pub fn bench_raft_new(c: &mut Criterion) { + let bench = |voters, learners| { + move |b: &mut Bencher| { + // No setup. + b.iter(|| quick_raft(voters, learners)); + } + }; + + c.bench_function("Raft::new (0, 0)", bench(0, 0)); + c.bench_function("Raft::new (3, 1)", bench(3, 1)); + c.bench_function("Raft::new (5, 2)", bench(5, 2)); + c.bench_function("Raft::new (7, 3)", bench(7, 3)); +} + +pub fn bench_raft_campaign(c: &mut Criterion) { + let bench = |voters, learners, variant| { + move |b: &mut Bencher| { + b.iter(|| { + // TODO: Make raft clone somehow. + let mut raft = quick_raft(voters, learners); + raft.campaign(variant) + }) + } + }; + + // We don't want to make `raft::raft` public at this point. + let pre_election = b"CampaignPreElection"; + let election = b"CampaignElection"; + let transfer = b"CampaignTransfer"; + + c.bench_function( + "Raft::campaign (3, 1, pre_election)", + bench(3, 1, &pre_election[..]), + ); + c.bench_function( + "Raft::campaign (3, 1, election)", + bench(3, 1, &election[..]), + ); + c.bench_function( + "Raft::campaign (3, 1, transfer)", + bench(3, 1, &transfer[..]), + ); + c.bench_function( + "Raft::campaign (5, 2, pre_election)", + bench(5, 2, &pre_election[..]), + ); + c.bench_function( + "Raft::campaign (5, 2, election)", + bench(5, 2, &election[..]), + ); + c.bench_function( + "Raft::campaign (5, 2, transfer)", + bench(5, 2, &transfer[..]), + ); + c.bench_function( + "Raft::campaign (7, 3, pre_election)", + bench(7, 3, &pre_election[..]), + ); + c.bench_function( + "Raft::campaign (7, 3, election)", + bench(7, 3, &election[..]), + ); + c.bench_function( + "Raft::campaign (7, 3, transfer)", + bench(7, 3, &transfer[..]), + ); +} diff --git a/benches/suites/raw_node.rs b/benches/suites/raw_node.rs new file mode 100644 index 000000000..bbc55d0f3 --- /dev/null +++ b/benches/suites/raw_node.rs @@ -0,0 +1,22 @@ +use criterion::{Bencher, Criterion}; +use raft::{storage::MemStorage, Config, RawNode}; + +criterion_group!(bench_raw_node, bench_raw_node_new,); + +fn quick_raw_node() -> RawNode { + let id = 1; + let peers = vec![]; + let storage = MemStorage::default(); + let config = Config::new(id); + let node = RawNode::new(&config, storage, peers).unwrap(); + node +} + +pub fn bench_raw_node_new(c: &mut Criterion) { + let bench = |b: &mut Bencher| { + // No setup. + b.iter(|| quick_raw_node()); + }; + + c.bench_function("RawNode::new", bench); +} diff --git a/src/lib.rs b/src/lib.rs index 152a5f014..220f536a4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -233,6 +233,9 @@ pub mod eraftpb; mod errors; mod log_unstable; mod progress; +#[cfg(test)] +pub mod raft; +#[cfg(not(test))] mod raft; mod raft_log; pub mod raw_node; diff --git a/src/raft.rs b/src/raft.rs index b45163b64..4e9e3502a 100644 --- a/src/raft.rs +++ b/src/raft.rs @@ -780,7 +780,10 @@ impl Raft { .count() } - fn campaign(&mut self, campaign_type: &[u8]) { + /// Campaign to attempt to become a leader. + /// + /// If prevote is enabled, this is handled as well. + pub fn campaign(&mut self, campaign_type: &[u8]) { let (vote_msg, term) = if campaign_type == CAMPAIGN_PRE_ELECTION { self.become_pre_candidate(); // Pre-vote RPCs are sent for next term before we've incremented self.term. From c6dc9d7099a827975beee944823448564be6caf0 Mon Sep 17 00:00:00 2001 From: Hoverbear Date: Tue, 4 Sep 2018 12:24:49 -0700 Subject: [PATCH 3/3] Refine criterion a bit --- benches/benches.rs | 31 +++++++--- benches/suites/progress.rs | 4 +- benches/suites/progress_set.rs | 109 ++++++++++++++++++++------------- benches/suites/raft.rs | 75 +++++++++-------------- benches/suites/raw_node.rs | 4 +- 5 files changed, 123 insertions(+), 100 deletions(-) diff --git a/benches/benches.rs b/benches/benches.rs index 501fd1edf..6b034e269 100644 --- a/benches/benches.rs +++ b/benches/benches.rs @@ -1,15 +1,28 @@ #![allow(dead_code)] // Due to criterion we need this to avoid warnings. -#[macro_use] extern crate criterion; +extern crate env_logger; extern crate raft; +use criterion::Criterion; +use std::time::Duration; + mod suites; -use suites::*; - -criterion_main!( - bench_raft, - bench_raw_node, - bench_progress, - bench_progress_set, -); + +pub const DEFAULT_RAFT_SETS: [(usize, usize); 4] = [(0, 0), (3, 1), (5, 2), (7, 3)]; + +fn main() { + criterion::init_logging(); + let mut c = Criterion::default() + // Configure defaults before overriding with args. + .warm_up_time(Duration::from_millis(500)) + .measurement_time(Duration::from_secs(1)) + .configure_from_args(); + + suites::bench_raft(&mut c); + suites::bench_raw_node(&mut c); + suites::bench_progress(&mut c); + suites::bench_progress_set(&mut c); + + c.final_summary(); +} diff --git a/benches/suites/progress.rs b/benches/suites/progress.rs index 030ef506c..8de69e6c2 100644 --- a/benches/suites/progress.rs +++ b/benches/suites/progress.rs @@ -1,7 +1,9 @@ use criterion::{Bencher, Criterion}; use raft::Progress; -criterion_group!(bench_progress, bench_progress_default); +pub fn bench_progress(c: &mut Criterion) { + bench_progress_default(c); +} pub fn bench_progress_default(c: &mut Criterion) { let bench = |b: &mut Bencher| { diff --git a/benches/suites/progress_set.rs b/benches/suites/progress_set.rs index 0b14e8ceb..9490a7d55 100644 --- a/benches/suites/progress_set.rs +++ b/benches/suites/progress_set.rs @@ -1,17 +1,17 @@ use criterion::{Bencher, Criterion}; use raft::ProgressSet; +use DEFAULT_RAFT_SETS; -criterion_group!( - bench_progress_set, - bench_progress_set_new, - bench_progress_set_insert_voter, - bench_progress_set_insert_learner, - bench_progress_set_promote_learner, - bench_progress_set_remove, - bench_progress_set_iter, - bench_progress_set_get, - bench_progress_set_nodes, -); +pub fn bench_progress_set(c: &mut Criterion) { + bench_progress_set_new(c); + bench_progress_set_insert_voter(c); + bench_progress_set_insert_learner(c); + bench_progress_set_promote_learner(c); + bench_progress_set_remove(c); + bench_progress_set_iter(c); + bench_progress_set_get(c); + bench_progress_set_nodes(c); +} fn quick_progress_set(voters: usize, learners: usize) -> ProgressSet { let mut set = ProgressSet::new(voters, learners); @@ -32,10 +32,12 @@ pub fn bench_progress_set_new(c: &mut Criterion) { } }; - c.bench_function("ProgressSet::new (0, 0)", bench(0, 0)); - c.bench_function("ProgressSet::new (3, 1)", bench(3, 1)); - c.bench_function("ProgressSet::new (5, 2)", bench(5, 2)); - c.bench_function("ProgressSet::new (7, 3)", bench(7, 3)); + DEFAULT_RAFT_SETS.iter().for_each(|(voters, learners)| { + c.bench_function( + &format!("ProgressSet::new ({}, {})", voters, learners), + bench(*voters, *learners), + ); + }); } pub fn bench_progress_set_insert_voter(c: &mut Criterion) { @@ -48,10 +50,13 @@ pub fn bench_progress_set_insert_voter(c: &mut Criterion) { }); } }; - c.bench_function("ProgressSet::insert_voter (0, 0)", bench(0, 0)); - c.bench_function("ProgressSet::insert_voter (3, 1)", bench(3, 1)); - c.bench_function("ProgressSet::insert_voter (5, 2)", bench(5, 2)); - c.bench_function("ProgressSet::insert_voter (7, 3)", bench(7, 3)); + + DEFAULT_RAFT_SETS.iter().for_each(|(voters, learners)| { + c.bench_function( + &format!("ProgressSet::insert_voter ({}, {})", voters, learners), + bench(*voters, *learners), + ); + }); } pub fn bench_progress_set_insert_learner(c: &mut Criterion) { @@ -64,10 +69,13 @@ pub fn bench_progress_set_insert_learner(c: &mut Criterion) { }); } }; - c.bench_function("ProgressSet::insert_learner (0, 0)", bench(0, 0)); - c.bench_function("ProgressSet::insert_learner (3, 1)", bench(3, 1)); - c.bench_function("ProgressSet::insert_learner (5, 2)", bench(5, 2)); - c.bench_function("ProgressSet::insert_learner (7, 3)", bench(7, 3)); + + DEFAULT_RAFT_SETS.iter().for_each(|(voters, learners)| { + c.bench_function( + &format!("ProgressSet::insert_learner ({}, {})", voters, learners), + bench(*voters, *learners), + ); + }); } pub fn bench_progress_set_remove(c: &mut Criterion) { @@ -80,10 +88,13 @@ pub fn bench_progress_set_remove(c: &mut Criterion) { }); } }; - c.bench_function("ProgressSet::remove (0, 0)", bench(0, 0)); - c.bench_function("ProgressSet::remove (3, 1)", bench(3, 1)); - c.bench_function("ProgressSet::remove (5, 2)", bench(5, 2)); - c.bench_function("ProgressSet::remove (7, 3)", bench(7, 3)); + + DEFAULT_RAFT_SETS.iter().for_each(|(voters, learners)| { + c.bench_function( + &format!("ProgressSet::remove ({}, {})", voters, learners), + bench(*voters, *learners), + ); + }); } pub fn bench_progress_set_promote_learner(c: &mut Criterion) { @@ -96,10 +107,13 @@ pub fn bench_progress_set_promote_learner(c: &mut Criterion) { }); } }; - c.bench_function("ProgressSet::promote (0, 0)", bench(0, 0)); - c.bench_function("ProgressSet::promote (3, 1)", bench(3, 1)); - c.bench_function("ProgressSet::promote (5, 2)", bench(5, 2)); - c.bench_function("ProgressSet::promote (7, 3)", bench(7, 3)); + + DEFAULT_RAFT_SETS.iter().for_each(|(voters, learners)| { + c.bench_function( + &format!("ProgressSet::promote ({}, {})", voters, learners), + bench(*voters, *learners), + ); + }); } pub fn bench_progress_set_iter(c: &mut Criterion) { @@ -113,10 +127,13 @@ pub fn bench_progress_set_iter(c: &mut Criterion) { }); } }; - c.bench_function("ProgressSet::iter (0, 0)", bench(0, 0)); - c.bench_function("ProgressSet::iter (3, 1)", bench(3, 1)); - c.bench_function("ProgressSet::iter (5, 2)", bench(5, 2)); - c.bench_function("ProgressSet::iter (7, 3)", bench(7, 3)); + + DEFAULT_RAFT_SETS.iter().for_each(|(voters, learners)| { + c.bench_function( + &format!("ProgressSet::iter ({}, {})", voters, learners), + bench(*voters, *learners), + ); + }); } pub fn bench_progress_set_nodes(c: &mut Criterion) { @@ -130,10 +147,13 @@ pub fn bench_progress_set_nodes(c: &mut Criterion) { }); } }; - c.bench_function("ProgressSet::nodes (0, 0)", bench(0, 0)); - c.bench_function("ProgressSet::nodes (3, 1)", bench(3, 1)); - c.bench_function("ProgressSet::nodes (5, 2)", bench(5, 2)); - c.bench_function("ProgressSet::nodes (7, 3)", bench(7, 3)); + + DEFAULT_RAFT_SETS.iter().for_each(|(voters, learners)| { + c.bench_function( + &format!("ProgressSet::nodes ({}, {})", voters, learners), + bench(*voters, *learners), + ); + }); } pub fn bench_progress_set_get(c: &mut Criterion) { @@ -148,8 +168,11 @@ pub fn bench_progress_set_get(c: &mut Criterion) { }); } }; - c.bench_function("ProgressSet::get (0, 0)", bench(0, 0)); - c.bench_function("ProgressSet::get (3, 1)", bench(3, 1)); - c.bench_function("ProgressSet::get (5, 2)", bench(5, 2)); - c.bench_function("ProgressSet::get (7, 3)", bench(7, 3)); + + DEFAULT_RAFT_SETS.iter().for_each(|(voters, learners)| { + c.bench_function( + &format!("ProgressSet::get ({}, {})", voters, learners), + bench(*voters, *learners), + ); + }); } diff --git a/benches/suites/raft.rs b/benches/suites/raft.rs index 3e38a4a9c..30d7213b9 100644 --- a/benches/suites/raft.rs +++ b/benches/suites/raft.rs @@ -1,7 +1,11 @@ use criterion::{Bencher, Criterion}; use raft::{storage::MemStorage, Config, Raft}; +use DEFAULT_RAFT_SETS; -criterion_group!(bench_raft, bench_raft_new, bench_raft_campaign,); +pub fn bench_raft(c: &mut Criterion) { + bench_raft_new(c); + bench_raft_campaign(c); +} fn quick_raft(voters: usize, learners: usize) -> Raft { let id = 1; @@ -25,10 +29,12 @@ pub fn bench_raft_new(c: &mut Criterion) { } }; - c.bench_function("Raft::new (0, 0)", bench(0, 0)); - c.bench_function("Raft::new (3, 1)", bench(3, 1)); - c.bench_function("Raft::new (5, 2)", bench(5, 2)); - c.bench_function("Raft::new (7, 3)", bench(7, 3)); + DEFAULT_RAFT_SETS.iter().for_each(|(voters, learners)| { + c.bench_function( + &format!("Raft::new ({}, {})", voters, learners), + bench(*voters, *learners), + ); + }); } pub fn bench_raft_campaign(c: &mut Criterion) { @@ -42,45 +48,22 @@ pub fn bench_raft_campaign(c: &mut Criterion) { } }; - // We don't want to make `raft::raft` public at this point. - let pre_election = b"CampaignPreElection"; - let election = b"CampaignElection"; - let transfer = b"CampaignTransfer"; - - c.bench_function( - "Raft::campaign (3, 1, pre_election)", - bench(3, 1, &pre_election[..]), - ); - c.bench_function( - "Raft::campaign (3, 1, election)", - bench(3, 1, &election[..]), - ); - c.bench_function( - "Raft::campaign (3, 1, transfer)", - bench(3, 1, &transfer[..]), - ); - c.bench_function( - "Raft::campaign (5, 2, pre_election)", - bench(5, 2, &pre_election[..]), - ); - c.bench_function( - "Raft::campaign (5, 2, election)", - bench(5, 2, &election[..]), - ); - c.bench_function( - "Raft::campaign (5, 2, transfer)", - bench(5, 2, &transfer[..]), - ); - c.bench_function( - "Raft::campaign (7, 3, pre_election)", - bench(7, 3, &pre_election[..]), - ); - c.bench_function( - "Raft::campaign (7, 3, election)", - bench(7, 3, &election[..]), - ); - c.bench_function( - "Raft::campaign (7, 3, transfer)", - bench(7, 3, &transfer[..]), - ); + DEFAULT_RAFT_SETS + .iter() + .skip(1) + .for_each(|(voters, learners)| { + // We don't want to make `raft::raft` public at this point. + let msgs = [ + "CampaignPreElection", + "CampaignElection", + "CampaignTransfer", + ]; + // Skip the first since it's 0,0 + for msg in msgs.iter() { + c.bench_function( + &format!("Raft::campaign ({}, {}, {})", voters, learners, msg), + bench(*voters, *learners, msg.as_bytes()), + ); + } + }); } diff --git a/benches/suites/raw_node.rs b/benches/suites/raw_node.rs index bbc55d0f3..3760463d3 100644 --- a/benches/suites/raw_node.rs +++ b/benches/suites/raw_node.rs @@ -1,7 +1,9 @@ use criterion::{Bencher, Criterion}; use raft::{storage::MemStorage, Config, RawNode}; -criterion_group!(bench_raw_node, bench_raw_node_new,); +pub fn bench_raw_node(c: &mut Criterion) { + bench_raw_node_new(c); +} fn quick_raw_node() -> RawNode { let id = 1;