|
|
@ -19,12 +19,17 @@ use test::Bencher;
|
|
|
|
|
|
|
|
|
|
|
|
use lazy_static::{initialize, lazy_static};
|
|
|
|
use lazy_static::{initialize, lazy_static};
|
|
|
|
use rand::Rng;
|
|
|
|
use rand::Rng;
|
|
|
|
|
|
|
|
use rayon::prelude::*;
|
|
|
|
use regex::Regex;
|
|
|
|
use regex::Regex;
|
|
|
|
use serde_json::json;
|
|
|
|
use serde_json::json;
|
|
|
|
|
|
|
|
|
|
|
|
use cozo::{DbInstance, NamedRows};
|
|
|
|
use cozo::{DbInstance, NamedRows};
|
|
|
|
|
|
|
|
|
|
|
|
lazy_static! {
|
|
|
|
lazy_static! {
|
|
|
|
|
|
|
|
static ref ITERATIONS: usize = {
|
|
|
|
|
|
|
|
let size = env::var("COZO_BENCH_ITERATIONS").unwrap_or("100".to_string());
|
|
|
|
|
|
|
|
size.parse::<usize>().unwrap()
|
|
|
|
|
|
|
|
};
|
|
|
|
static ref SIZES: (usize, usize) = {
|
|
|
|
static ref SIZES: (usize, usize) = {
|
|
|
|
let size = env::var("COZO_BENCH_POKEC_SIZE").unwrap_or("medium".to_string());
|
|
|
|
let size = env::var("COZO_BENCH_POKEC_SIZE").unwrap_or("medium".to_string());
|
|
|
|
match &size as &str {
|
|
|
|
match &size as &str {
|
|
|
@ -195,12 +200,12 @@ lazy_static! {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
type QueryFn = fn() -> ();
|
|
|
|
type QueryFn = fn() -> ();
|
|
|
|
const READ_QUERIES: [QueryFn; 1] = [single_vertex];
|
|
|
|
const READ_QUERIES: [QueryFn; 1] = [single_vertex_read];
|
|
|
|
const WRITE_QUERIES: [QueryFn; 2] = [single_edge_write, single_vertex_write];
|
|
|
|
const WRITE_QUERIES: [QueryFn; 2] = [single_edge_write, single_vertex_write];
|
|
|
|
const UPDATE_QUERIES: [QueryFn; 1] = [single_vertex_update];
|
|
|
|
const UPDATE_QUERIES: [QueryFn; 1] = [single_vertex_update];
|
|
|
|
#[allow(dead_code)]
|
|
|
|
#[allow(dead_code)]
|
|
|
|
const AGGREGATE_QUERIES: [QueryFn; 4] =
|
|
|
|
const AGGREGATE_QUERIES: [QueryFn; 4] =
|
|
|
|
[aggregation, aggregation_filter, aggregation_count, min_max];
|
|
|
|
[aggregation_group, aggregation_filter, aggregation_count, aggregation_min_max];
|
|
|
|
const ANALYTICAL_QUERIES: [QueryFn; 15] = [
|
|
|
|
const ANALYTICAL_QUERIES: [QueryFn; 15] = [
|
|
|
|
expansion_1,
|
|
|
|
expansion_1,
|
|
|
|
expansion_2,
|
|
|
|
expansion_2,
|
|
|
@ -219,7 +224,7 @@ const ANALYTICAL_QUERIES: [QueryFn; 15] = [
|
|
|
|
pattern_short,
|
|
|
|
pattern_short,
|
|
|
|
];
|
|
|
|
];
|
|
|
|
|
|
|
|
|
|
|
|
fn single_vertex() {
|
|
|
|
fn single_vertex_read() {
|
|
|
|
let i = rand::thread_rng().gen_range(1..SIZES.0);
|
|
|
|
let i = rand::thread_rng().gen_range(1..SIZES.0);
|
|
|
|
TEST_DB
|
|
|
|
TEST_DB
|
|
|
|
.run_script(
|
|
|
|
.run_script(
|
|
|
@ -286,7 +291,7 @@ fn single_vertex_update() {
|
|
|
|
panic!()
|
|
|
|
panic!()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
fn aggregation() {
|
|
|
|
fn aggregation_group() {
|
|
|
|
TEST_DB
|
|
|
|
TEST_DB
|
|
|
|
.run_script("?[age, count(uid)] := *user{uid, age}", Default::default())
|
|
|
|
.run_script("?[age, count(uid)] := *user{uid, age}", Default::default())
|
|
|
|
.unwrap();
|
|
|
|
.unwrap();
|
|
|
@ -310,7 +315,7 @@ fn aggregation_filter() {
|
|
|
|
.unwrap();
|
|
|
|
.unwrap();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
fn min_max() {
|
|
|
|
fn aggregation_min_max() {
|
|
|
|
TEST_DB
|
|
|
|
TEST_DB
|
|
|
|
.run_script(
|
|
|
|
.run_script(
|
|
|
|
"?[min(uid), max(uid), mean(uid)] := *user{uid, age}",
|
|
|
|
"?[min(uid), max(uid), mean(uid)] := *user{uid, age}",
|
|
|
@ -538,15 +543,17 @@ fn backup_db(_: &mut Bencher) {
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let data_size = env::var("COZO_BENCH_POKEC_SIZE").unwrap_or("medium".to_string());
|
|
|
|
let data_size = env::var("COZO_BENCH_POKEC_SIZE").unwrap_or("medium".to_string());
|
|
|
|
let backup_taken = Instant::now();
|
|
|
|
let backup_taken = Instant::now();
|
|
|
|
TEST_DB.backup_db(format!("backup-{}.db", data_size)).unwrap();
|
|
|
|
TEST_DB
|
|
|
|
|
|
|
|
.backup_db(format!("backup-{}.db", data_size))
|
|
|
|
|
|
|
|
.unwrap();
|
|
|
|
dbg!(backup_taken.elapsed());
|
|
|
|
dbg!(backup_taken.elapsed());
|
|
|
|
dbg!(((SIZES.0 + 2 * SIZES.1) as f64) / backup_taken.elapsed().as_secs_f64());
|
|
|
|
dbg!(((SIZES.0 + 2 * SIZES.1) as f64) / backup_taken.elapsed().as_secs_f64());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
#[bench]
|
|
|
|
fn bench_aggregation(b: &mut Bencher) {
|
|
|
|
fn bench_aggregation_group(b: &mut Bencher) {
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
b.iter(aggregation)
|
|
|
|
b.iter(aggregation_group)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
#[bench]
|
|
|
@ -562,9 +569,9 @@ fn bench_aggregation_filter(b: &mut Bencher) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
#[bench]
|
|
|
|
fn bench_min_max(b: &mut Bencher) {
|
|
|
|
fn bench_aggregation_min_max(b: &mut Bencher) {
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
b.iter(min_max)
|
|
|
|
b.iter(aggregation_min_max)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
#[bench]
|
|
|
@ -659,7 +666,7 @@ fn bench_pattern_short(b: &mut Bencher) {
|
|
|
|
#[bench]
|
|
|
|
#[bench]
|
|
|
|
fn bench_single_vertex(b: &mut Bencher) {
|
|
|
|
fn bench_single_vertex(b: &mut Bencher) {
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
b.iter(single_vertex)
|
|
|
|
b.iter(single_vertex_read)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
#[bench]
|
|
|
@ -670,7 +677,7 @@ fn qps_single_vertex_read(_b: &mut Bencher) {
|
|
|
|
let count = 1_000_000;
|
|
|
|
let count = 1_000_000;
|
|
|
|
let qps_single_vertex_read_time = Instant::now();
|
|
|
|
let qps_single_vertex_read_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
single_vertex();
|
|
|
|
single_vertex_read();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / qps_single_vertex_read_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((count as f64) / qps_single_vertex_read_time.elapsed().as_secs_f64());
|
|
|
|
}
|
|
|
|
}
|
|
|
@ -707,162 +714,246 @@ fn bench_single_vertex_update(b: &mut Bencher) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
#[bench]
|
|
|
|
fn throughput(_: &mut Bencher) {
|
|
|
|
fn tp_expansion_1_plain(_b: &mut Bencher) {
|
|
|
|
use rayon::prelude::*;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
println!("throughput benchmarks");
|
|
|
|
|
|
|
|
dbg!(rayon::current_num_threads());
|
|
|
|
|
|
|
|
let init_time = Instant::now();
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
dbg!(init_time.elapsed());
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
let expansion_1_time = Instant::now();
|
|
|
|
let expansion_1_time = Instant::now();
|
|
|
|
let count = 100;
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
|
|
|
|
expansion_1();
|
|
|
|
expansion_1();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / expansion_1_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / expansion_1_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_expansion_1_filter(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let expansion_1_filter_time = Instant::now();
|
|
|
|
let expansion_1_filter_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
expansion_1_filter();
|
|
|
|
expansion_1_filter();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / expansion_1_filter_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / expansion_1_filter_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
|
|
|
|
let expansion_2_time = Instant::now();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_expansion_2_plain(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
|
|
|
|
let expansion_2_time = Instant::now();
|
|
|
|
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
expansion_2();
|
|
|
|
expansion_2();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / expansion_2_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / expansion_2_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_expansion_2_filter(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let expansion_2_filter_time = Instant::now();
|
|
|
|
let expansion_2_filter_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
expansion_2_filter();
|
|
|
|
expansion_2_filter();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / expansion_2_filter_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / expansion_2_filter_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
|
|
|
|
let expansion_3_time = Instant::now();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_expansion_3_plain(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
|
|
|
|
let expansion_3_time = Instant::now();
|
|
|
|
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
expansion_3();
|
|
|
|
expansion_3();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / expansion_3_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / expansion_3_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_expansion_3_filter(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let expansion_3_filter_time = Instant::now();
|
|
|
|
let expansion_3_filter_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
expansion_3_filter();
|
|
|
|
expansion_3_filter();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / expansion_3_filter_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / expansion_3_filter_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
|
|
|
|
let expansion_4_time = Instant::now();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_expansion_4_plain(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
|
|
|
|
let expansion_4_time = Instant::now();
|
|
|
|
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
expansion_4();
|
|
|
|
expansion_4();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / expansion_4_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / expansion_4_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_expansion_4_filter(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let expansion_4_filter_time = Instant::now();
|
|
|
|
let expansion_4_filter_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
expansion_4_filter();
|
|
|
|
expansion_4_filter();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / expansion_4_filter_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / expansion_4_filter_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_neighbours_2_plain(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let neighbours_2_time = Instant::now();
|
|
|
|
let neighbours_2_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
neighbours_2();
|
|
|
|
neighbours_2();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / neighbours_2_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / neighbours_2_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_neighbours_2_filter(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let neighbours_2_filter_time = Instant::now();
|
|
|
|
let neighbours_2_filter_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
neighbours_2_filter();
|
|
|
|
neighbours_2_filter();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / neighbours_2_filter_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / neighbours_2_filter_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_neighbours_2_data(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let neighbours_2_data_time = Instant::now();
|
|
|
|
let neighbours_2_data_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
neighbours_2_data();
|
|
|
|
neighbours_2_data();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / neighbours_2_data_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / neighbours_2_data_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_neighbours_2_filter_data(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let neighbours_2_filter_data_time = Instant::now();
|
|
|
|
let neighbours_2_filter_data_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
neighbours_2_filter_data();
|
|
|
|
neighbours_2_filter_data();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / neighbours_2_filter_data_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / neighbours_2_filter_data_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_pattern_cycle(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let pattern_cycle_time = Instant::now();
|
|
|
|
let pattern_cycle_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
pattern_cycle();
|
|
|
|
pattern_cycle();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / pattern_cycle_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / pattern_cycle_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_pattern_long(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let pattern_long_time = Instant::now();
|
|
|
|
let pattern_long_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
pattern_long();
|
|
|
|
pattern_long();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / pattern_long_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / pattern_long_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_pattern_short(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let pattern_short_time = Instant::now();
|
|
|
|
let pattern_short_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
pattern_short();
|
|
|
|
pattern_short();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / pattern_short_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / pattern_short_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
}
|
|
|
|
let aggregation_time = Instant::now();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
#[bench]
|
|
|
|
aggregation();
|
|
|
|
fn tp_aggregation_group(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
|
|
|
|
let aggregation_group_time = Instant::now();
|
|
|
|
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
|
|
|
|
aggregation_group();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / aggregation_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / aggregation_group_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_aggregation_count(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let aggregation_count_time = Instant::now();
|
|
|
|
let aggregation_count_time = Instant::now();
|
|
|
|
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
|
|
|
|
aggregation_count();
|
|
|
|
aggregation_count();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / aggregation_count_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / aggregation_count_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_aggregation_filter(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let aggregation_filter_time = Instant::now();
|
|
|
|
let aggregation_filter_time = Instant::now();
|
|
|
|
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
|
|
|
|
aggregation_filter();
|
|
|
|
aggregation_filter();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / aggregation_filter_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / aggregation_filter_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
}
|
|
|
|
let min_max_time = Instant::now();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
#[bench]
|
|
|
|
min_max();
|
|
|
|
fn tp_aggregation_min_max(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
|
|
|
|
let aggregation_min_max_time = Instant::now();
|
|
|
|
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
|
|
|
|
aggregation_min_max();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / min_max_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / aggregation_min_max_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
let single_vertex_time = Instant::now();
|
|
|
|
#[bench]
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
fn tp_single_vertex_read(_b: &mut Bencher) {
|
|
|
|
single_vertex();
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
|
|
|
|
let single_vertex_read_time = Instant::now();
|
|
|
|
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
|
|
|
|
single_vertex_read();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / single_vertex_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / single_vertex_read_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_single_vertex_write(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let single_vertex_write_time = Instant::now();
|
|
|
|
let single_vertex_write_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
single_vertex_write();
|
|
|
|
single_vertex_write();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / single_vertex_write_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / single_vertex_write_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_single_edge_write(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let single_edge_write_time = Instant::now();
|
|
|
|
let single_edge_write_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
single_edge_write();
|
|
|
|
single_vertex_write();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / single_edge_write_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / single_edge_write_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#[bench]
|
|
|
|
|
|
|
|
fn tp_single_vertex_update(_b: &mut Bencher) {
|
|
|
|
|
|
|
|
initialize(&TEST_DB);
|
|
|
|
let single_vertex_update_time = Instant::now();
|
|
|
|
let single_vertex_update_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..*ITERATIONS).into_par_iter().for_each(|_| {
|
|
|
|
single_vertex_update();
|
|
|
|
single_vertex_update();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / single_vertex_update_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((*ITERATIONS as f64) / single_vertex_update_time.elapsed().as_secs_f64());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
fn wrap(mixed_pct: f64, f: QueryFn) {
|
|
|
|
fn wrap(mixed_pct: f64, f: QueryFn) {
|
|
|
|
use rand::prelude::*;
|
|
|
|
use rand::prelude::*;
|
|
|
|
|
|
|
|
|
|
|
@ -1028,7 +1119,7 @@ fn mixed(_: &mut Bencher) {
|
|
|
|
let aggregation_time = Instant::now();
|
|
|
|
let aggregation_time = Instant::now();
|
|
|
|
|
|
|
|
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
wrap(mixed_pct, aggregation);
|
|
|
|
wrap(mixed_pct, aggregation_group);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / aggregation_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((count as f64) / aggregation_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
|
|
|
@ -1049,13 +1140,13 @@ fn mixed(_: &mut Bencher) {
|
|
|
|
let min_max_time = Instant::now();
|
|
|
|
let min_max_time = Instant::now();
|
|
|
|
|
|
|
|
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
wrap(mixed_pct, min_max);
|
|
|
|
wrap(mixed_pct, aggregation_min_max);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / min_max_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((count as f64) / min_max_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
|
|
|
|
let single_vertex_time = Instant::now();
|
|
|
|
let single_vertex_time = Instant::now();
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
(0..count).into_par_iter().for_each(|_| {
|
|
|
|
wrap(mixed_pct, single_vertex);
|
|
|
|
wrap(mixed_pct, single_vertex_read);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
dbg!((count as f64) / single_vertex_time.elapsed().as_secs_f64());
|
|
|
|
dbg!((count as f64) / single_vertex_time.elapsed().as_secs_f64());
|
|
|
|
|
|
|
|
|
|
|
|