vecna
/
lox
mirror of https://gitlab.torproject.org/vecna/lox.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added perfstat time outputs for each test

This commit is contained in:
onyinyang 2021-09-29 01:11:12 -04:00
parent 3d8f1e799e
commit 82272ea933
No known key found for this signature in database
GPG Key ID: 156A6435430C2036
1 changed files with 159 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

376
crates/lox-library/src/tests.rs
View File

@ -713,206 +713,146 @@ fn test_blockage_migration() {
}
#[test]
fn stats_test_open_invite() {
fn stats_test_trust_levels() {
let mut th = TestHarness::new_buckets(150, 150);
let mut req_size: Vec<f64> = Vec::new();
let mut resp_size: Vec<f64> = Vec::new();
let mut req_t_size: Vec<f64> = Vec::new();
let mut resp_t_size: Vec<f64> = Vec::new();
let mut resp_handle_t_size: Vec<f64> = Vec::new();
for _ in 0..10000 {
let (perf_stat, _) = th.open_invite();
req_size.push(perf_stat.req_len as f64);
req_t_size.push(perf_stat.req_t.as_secs_f64());
resp_size.push(perf_stat.resp_len as f64);
resp_t_size.push(perf_stat.resp_t.as_secs_f64());
resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64());
}
println!("\n---------------Open Invitationn-------------------\n");
print_stats_test_results(
req_size,
req_t_size,
resp_size,
resp_t_size,
resp_handle_t_size,
);
}
#[test]
fn stats_test_trust_promotion() {
let mut th = TestHarness::new_buckets(150, 150);
let mut req_size: Vec<f64> = Vec::new();
let mut resp_size: Vec<f64> = Vec::new();
let mut req_t_size: Vec<f64> = Vec::new();
let mut resp_t_size: Vec<f64> = Vec::new();
let mut resp_handle_t_size: Vec<f64> = Vec::new();
for _ in 0..10000 {
let cred = th.open_invite().1 .0;
th.advance_days(47);
let (perf_stat, _) = th.trust_promotion(&cred);
req_size.push(perf_stat.req_len as f64);
req_t_size.push(perf_stat.req_t.as_secs_f64());
resp_size.push(perf_stat.resp_len as f64);
resp_t_size.push(perf_stat.resp_t.as_secs_f64());
resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64());
}
println!("\n-------Trust Promotion--------\n");
print_stats_test_results(
req_size,
req_t_size,
resp_size,
resp_t_size,
resp_handle_t_size,
);
}
#[test]
fn stats_test_trust_level0_migration() {
let mut th = TestHarness::new_buckets(150, 150);
let mut req_size: Vec<f64> = Vec::new();
let mut resp_size: Vec<f64> = Vec::new();
let mut req_t_size: Vec<f64> = Vec::new();
let mut resp_t_size: Vec<f64> = Vec::new();
let mut resp_handle_t_size: Vec<f64> = Vec::new();
let mut tot_req_size: Vec<f64> = Vec::new();
let mut tot_resp_size: Vec<f64> = Vec::new();
let mut tot_req_t_size: Vec<f64> = Vec::new();
let mut tot_resp_t_size: Vec<f64> = Vec::new();
let mut tot_resp_handle_t_size: Vec<f64> = Vec::new();
for _ in 0..10000 {
let cred = th.open_invite().1 .0;
th.advance_days(47);
let (tp_perf_stat, migcred) = th.trust_promotion(&cred);
let (perf_stat, _) = th.level0_migration(&cred, &migcred);
req_size.push(perf_stat.req_len as f64);
req_t_size.push(perf_stat.req_t.as_secs_f64());
resp_size.push(perf_stat.resp_len as f64);
resp_t_size.push(perf_stat.resp_t.as_secs_f64());
resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64());
tot_req_size.push((perf_stat.req_len + tp_perf_stat.req_len) as f64);
tot_req_t_size.push((perf_stat.req_t + tp_perf_stat.req_t).as_secs_f64());
tot_resp_size.push((perf_stat.resp_len + tp_perf_stat.resp_len) as f64);
tot_resp_t_size.push((perf_stat.resp_t + tp_perf_stat.resp_t).as_secs_f64());
tot_resp_handle_t_size
.push((perf_stat.resp_handle_t + tp_perf_stat.resp_handle_t).as_secs_f64());
}
println!("\n-------------Trust Level0 Migration----------------\n");
print_stats_test_results(
req_size,
req_t_size,
resp_size,
resp_t_size,
resp_handle_t_size,
);
println!("\n-------Total Trust Promotion to Level 1-------\n");
print_stats_test_results(
tot_req_size,
tot_req_t_size,
tot_resp_size,
tot_resp_t_size,
tot_resp_handle_t_size,
);
}
#[test]
fn stats_test_trust_level_up() {
let mut th = TestHarness::new_buckets(150, 150);
let mut req_size: Vec<f64> = Vec::new();
let mut resp_size: Vec<f64> = Vec::new();
let mut req_t_size: Vec<f64> = Vec::new();
let mut resp_t_size: Vec<f64> = Vec::new();
let mut resp_handle_t_size: Vec<f64> = Vec::new();
let mut promo_req_size: Vec<f64> = Vec::new();
let mut promo_resp_size: Vec<f64> = Vec::new();
let mut promo_req_time: Vec<f64> = Vec::new();
let mut promo_resp_time: Vec<f64> = Vec::new();
let mut promo_resp_handle_time: Vec<f64> = Vec::new();
let mut mig_req_size: Vec<f64> = Vec::new();
let mut mig_resp_size: Vec<f64> = Vec::new();
let mut mig_req_time: Vec<f64> = Vec::new();
let mut mig_resp_time: Vec<f64> = Vec::new();
let mut mig_resp_handle_time: Vec<f64> = Vec::new();
let mut sec_req_size: Vec<f64> = Vec::new();
let mut sec_resp_size: Vec<f64> = Vec::new();
let mut sec_req_t_size: Vec<f64> = Vec::new();
let mut sec_resp_t_size: Vec<f64> = Vec::new();
let mut sec_resp_handle_t_size: Vec<f64> = Vec::new();
let mut sec_req_time: Vec<f64> = Vec::new();
let mut sec_resp_time: Vec<f64> = Vec::new();
let mut sec_resp_handle_time: Vec<f64> = Vec::new();
let mut three_req_size: Vec<f64> = Vec::new();
let mut three_resp_size: Vec<f64> = Vec::new();
let mut three_req_t_size: Vec<f64> = Vec::new();
let mut three_resp_t_size: Vec<f64> = Vec::new();
let mut three_resp_handle_t_size: Vec<f64> = Vec::new();
let mut three_req_time: Vec<f64> = Vec::new();
let mut three_resp_time: Vec<f64> = Vec::new();
let mut three_resp_handle_time: Vec<f64> = Vec::new();
let mut four_req_size: Vec<f64> = Vec::new();
let mut four_resp_size: Vec<f64> = Vec::new();
let mut four_req_t_size: Vec<f64> = Vec::new();
let mut four_resp_t_size: Vec<f64> = Vec::new();
let mut four_resp_handle_t_size: Vec<f64> = Vec::new();
let mut four_req_time: Vec<f64> = Vec::new();
let mut four_resp_time: Vec<f64> = Vec::new();
let mut four_resp_handle_time: Vec<f64> = Vec::new();
let mut open_req_size: Vec<f64> = Vec::new();
let mut open_resp_size: Vec<f64> = Vec::new();
let mut open_req_time: Vec<f64> = Vec::new();
let mut open_resp_time: Vec<f64> = Vec::new();
let mut open_resp_handle_time: Vec<f64> = Vec::new();
for _ in 0..10000 {
let cred = th.open_invite().1 .0;
let (open_perf_stat, cred) = th.open_invite();
th.advance_days(30);
let (tp_perf_stat, migcred) = th.trust_promotion(&cred);
let (perf_stat, cred1) = th.level0_migration(&cred, &migcred);
let (tp_perf_stat, migcred) = th.trust_promotion(&cred.0);
let (mig_perf_stat, cred1) = th.level0_migration(&cred.0, &migcred);
th.advance_days(14);
let (sec_perf_stat, cred2) = th.level_up(&cred1);
th.advance_days(28);
let (three_perf_stat, cred3) = th.level_up(&cred2);
th.advance_days(56);
let (four_perf_stat, _) = th.level_up(&cred3);
req_size.push((perf_stat.req_len + tp_perf_stat.req_len) as f64);
req_t_size.push((perf_stat.req_t + tp_perf_stat.req_t).as_secs_f64());
resp_size.push((perf_stat.resp_len + tp_perf_stat.resp_len) as f64);
resp_t_size.push((perf_stat.resp_t + tp_perf_stat.resp_t).as_secs_f64());
resp_handle_t_size
.push((perf_stat.resp_handle_t + tp_perf_stat.resp_handle_t).as_secs_f64());
open_req_size.push(open_perf_stat.req_len as f64);
open_req_time.push(open_perf_stat.req_t.as_secs_f64());
open_resp_size.push(open_perf_stat.resp_len as f64);
open_resp_time.push(open_perf_stat.resp_t.as_secs_f64());
open_resp_handle_time.push(open_perf_stat.resp_handle_t.as_secs_f64());
promo_req_size.push(tp_perf_stat.req_len as f64);
promo_req_time.push(tp_perf_stat.req_t.as_secs_f64());
promo_resp_size.push(tp_perf_stat.resp_len as f64);
promo_resp_time.push(tp_perf_stat.resp_t.as_secs_f64());
promo_resp_handle_time.push(tp_perf_stat.resp_handle_t.as_secs_f64());
mig_req_size.push(mig_perf_stat.req_len as f64);
mig_req_time.push(mig_perf_stat.req_t.as_secs_f64());
mig_resp_size.push(mig_perf_stat.resp_len as f64);
mig_resp_time.push(mig_perf_stat.resp_t.as_secs_f64());
mig_resp_handle_time.push(mig_perf_stat.resp_handle_t.as_secs_f64());
sec_req_size.push(sec_perf_stat.req_len as f64);
sec_req_t_size.push(sec_perf_stat.req_t.as_secs_f64());
sec_req_time.push(sec_perf_stat.req_t.as_secs_f64());
sec_resp_size.push(sec_perf_stat.resp_len as f64);
sec_resp_t_size.push(sec_perf_stat.resp_t.as_secs_f64());
sec_resp_handle_t_size.push(sec_perf_stat.resp_handle_t.as_secs_f64());
sec_resp_time.push(sec_perf_stat.resp_t.as_secs_f64());
sec_resp_handle_time.push(sec_perf_stat.resp_handle_t.as_secs_f64());
three_req_size.push(three_perf_stat.req_len as f64);
three_req_t_size.push(three_perf_stat.req_t.as_secs_f64());
three_req_time.push(three_perf_stat.req_t.as_secs_f64());
three_resp_size.push(three_perf_stat.resp_len as f64);
three_resp_t_size.push(three_perf_stat.resp_t.as_secs_f64());
three_resp_handle_t_size.push(three_perf_stat.resp_handle_t.as_secs_f64());
three_resp_time.push(three_perf_stat.resp_t.as_secs_f64());
three_resp_handle_time.push(three_perf_stat.resp_handle_t.as_secs_f64());
four_req_size.push(four_perf_stat.req_len as f64);
four_req_t_size.push(four_perf_stat.req_t.as_secs_f64());
four_req_time.push(four_perf_stat.req_t.as_secs_f64());
four_resp_size.push(four_perf_stat.resp_len as f64);
four_resp_t_size.push(four_perf_stat.resp_t.as_secs_f64());
four_resp_handle_t_size.push(four_perf_stat.resp_handle_t.as_secs_f64());
four_resp_time.push(four_perf_stat.resp_t.as_secs_f64());
four_resp_handle_time.push(four_perf_stat.resp_handle_t.as_secs_f64());
println!("OPEN_INVITE");
print_time_test_results(open_perf_stat);
println!("TRUST_PROMOTION");
print_time_test_results(tp_perf_stat);
println!("LEVEL_1_MIGRATION");
print_time_test_results(mig_perf_stat);
println!("LEVEL_2_UP");
print_time_test_results(sec_perf_stat);
println!("LEVEL_3_UP");
print_time_test_results(three_perf_stat);
println!("LEVEL_4_UP");
print_time_test_results(four_perf_stat);
}
println!("\n---Trust Promotion + Migration to Level 1: 30 days----\n");
println!("\n---------------Open Invitationn-------------------\n");
print_stats_test_results(
req_size,
req_t_size,
resp_size,
resp_t_size,
resp_handle_t_size,
open_req_size,
open_req_time,
open_resp_size,
open_resp_time,
open_resp_handle_time,
);
println!("\n-------Trust Promotion to Level 1: 30 days----\n");
print_stats_test_results(
promo_req_size,
promo_req_time,
promo_resp_size,
promo_resp_time,
promo_resp_handle_time,
);
println!("\n-------Trust Level 0 Migration: 30 days------------\n");
print_stats_test_results(
mig_req_size,
mig_req_time,
mig_resp_size,
mig_resp_time,
mig_resp_handle_time,
);
println!("\n-------Trust Promotion to Level 2: 44 days-------\n");
print_stats_test_results(
sec_req_size,
sec_req_t_size,
sec_req_time,
sec_resp_size,
sec_resp_t_size,
sec_resp_handle_t_size,
sec_resp_time,
sec_resp_handle_time,
);
println!("\n-------Trust Promotion to Level 3: 72 days------\n");
print_stats_test_results(
three_req_size,
three_req_t_size,
three_req_time,
three_resp_size,
three_resp_t_size,
three_resp_handle_t_size,
three_resp_time,
three_resp_handle_time,
);
println!("\n-------Trust Promotion to Level 4: 128 days------\n");
print_stats_test_results(
four_req_size,
four_req_t_size,
four_req_time,
four_resp_size,
four_resp_t_size,
four_resp_handle_t_size,
four_resp_time,
four_resp_handle_time,
);
}
@ -922,14 +862,14 @@ fn stats_test_invitations() {
let mut req_size: Vec<f64> = Vec::new();
let mut resp_size: Vec<f64> = Vec::new();
let mut req_t_size: Vec<f64> = Vec::new();
let mut resp_t_size: Vec<f64> = Vec::new();
let mut resp_handle_t_size: Vec<f64> = Vec::new();
let mut req_time: Vec<f64> = Vec::new();
let mut resp_time: Vec<f64> = Vec::new();
let mut resp_handle_time: Vec<f64> = Vec::new();
let mut red_req_size: Vec<f64> = Vec::new();
let mut red_resp_size: Vec<f64> = Vec::new();
let mut red_req_t_size: Vec<f64> = Vec::new();
let mut red_resp_t_size: Vec<f64> = Vec::new();
let mut red_resp_handle_t_size: Vec<f64> = Vec::new();
let mut red_req_time: Vec<f64> = Vec::new();
let mut red_resp_time: Vec<f64> = Vec::new();
let mut red_resp_handle_time: Vec<f64> = Vec::new();
for _ in 0..10000 {
let cred = th.open_invite().1 .0;
th.advance_days(30);
@ -941,33 +881,31 @@ fn stats_test_invitations() {
let (perf_stat, (_, invite)) = th.issue_invite(&cred2);
let (bob_perf_stat, _) = th.redeem_invite(&invite);
req_size.push(perf_stat.req_len as f64);
req_t_size.push(perf_stat.req_t.as_secs_f64());
req_time.push(perf_stat.req_t.as_secs_f64());
resp_size.push(perf_stat.resp_len as f64);
resp_t_size.push(perf_stat.resp_t.as_secs_f64());
resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64());
resp_time.push(perf_stat.resp_t.as_secs_f64());
resp_handle_time.push(perf_stat.resp_handle_t.as_secs_f64());
red_req_size.push(bob_perf_stat.req_len as f64);
red_req_t_size.push(bob_perf_stat.req_t.as_secs_f64());
red_req_time.push(bob_perf_stat.req_t.as_secs_f64());
red_resp_size.push(bob_perf_stat.resp_len as f64);
red_resp_t_size.push(bob_perf_stat.resp_t.as_secs_f64());
red_resp_handle_t_size.push(bob_perf_stat.resp_handle_t.as_secs_f64());
red_resp_time.push(bob_perf_stat.resp_t.as_secs_f64());
red_resp_handle_time.push(bob_perf_stat.resp_handle_t.as_secs_f64());
println!("ISSUE_INVITE");
print_time_test_results(perf_stat);
println!("REDEEM_INVITE");
print_time_test_results(bob_perf_stat);
}
println!("\n---------------Issue Invitation----------------\n");
print_stats_test_results(
req_size,
req_t_size,
resp_size,
resp_t_size,
resp_handle_t_size,
);
print_stats_test_results(req_size, req_time, resp_size, resp_time, resp_handle_time);
println!("\n---------------Redeem Invitation----------------\n");
print_stats_test_results(
red_req_size,
red_req_t_size,
red_req_time,
red_resp_size,
red_resp_t_size,
red_resp_handle_t_size,
red_resp_time,
red_resp_handle_time,
);
}
@ -1443,14 +1381,14 @@ fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec<cred:
let mut req_size: Vec<f64> = Vec::new();
let mut resp_size: Vec<f64> = Vec::new();
let mut req_t_size: Vec<f64> = Vec::new();
let mut resp_t_size: Vec<f64> = Vec::new();
let mut resp_handle_t_size: Vec<f64> = Vec::new();
let mut req_time: Vec<f64> = Vec::new();
let mut resp_time: Vec<f64> = Vec::new();
let mut resp_handle_time: Vec<f64> = Vec::new();
let mut red_req_size: Vec<f64> = Vec::new();
let mut red_resp_size: Vec<f64> = Vec::new();
let mut red_req_t_size: Vec<f64> = Vec::new();
let mut red_resp_t_size: Vec<f64> = Vec::new();
let mut red_resp_handle_t_size: Vec<f64> = Vec::new();
let mut red_req_time: Vec<f64> = Vec::new();
let mut red_resp_time: Vec<f64> = Vec::new();
let mut red_resp_handle_time: Vec<f64> = Vec::new();
for cred in credentials {
let (id, key) = bridge_table::from_scalar(cred.bucket).unwrap();
let encbuckets = th.ba.enc_bridge_table();
@ -1468,15 +1406,19 @@ fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec<cred:
let (perf_stat, migration) = th.check_blockage(&cred);
let (block_perf_stat, _) = th.blockage_migration(&cred, &migration);
req_size.push(perf_stat.req_len as f64);
req_t_size.push(perf_stat.req_t.as_secs_f64());
req_time.push(perf_stat.req_t.as_secs_f64());
resp_size.push(perf_stat.resp_len as f64);
resp_t_size.push(perf_stat.resp_t.as_secs_f64());
resp_handle_t_size.push(perf_stat.resp_handle_t.as_secs_f64());
resp_time.push(perf_stat.resp_t.as_secs_f64());
resp_handle_time.push(perf_stat.resp_handle_t.as_secs_f64());
red_req_size.push(block_perf_stat.req_len as f64);
red_req_t_size.push(block_perf_stat.req_t.as_secs_f64());
red_req_time.push(block_perf_stat.req_t.as_secs_f64());
red_resp_size.push(block_perf_stat.resp_len as f64);
red_resp_t_size.push(block_perf_stat.resp_t.as_secs_f64());
red_resp_handle_t_size.push(block_perf_stat.resp_handle_t.as_secs_f64());
red_resp_time.push(block_perf_stat.resp_t.as_secs_f64());
red_resp_handle_time.push(block_perf_stat.resp_handle_t.as_secs_f64());
println!("CHECK_BLOCKAGE_{}", percentage);
print_time_test_results(perf_stat);
println!("BLOCKAGE_MIGRATION_{}", percentage);
print_time_test_results(block_perf_stat);
}
}
@ -1484,13 +1426,7 @@ fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec<cred:
"\n---------------Check Blockage {}---------------\n",
percentage
);
print_stats_test_results(
req_size,
req_t_size,
resp_size,
resp_t_size,
resp_handle_t_size,
);
print_stats_test_results(req_size, req_time, resp_size, resp_time, resp_handle_time);
println!(
"\n---------------Blockage Migration {}---------------\n",
@ -1498,10 +1434,10 @@ fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec<cred:
);
print_stats_test_results(
red_req_size,
red_req_t_size,
red_req_time,
red_resp_size,
red_resp_t_size,
red_resp_handle_t_size,
red_resp_time,
red_resp_handle_time,
);
}
@ -1513,51 +1449,57 @@ fn print_test_results(perf_stat: PerfStat) {
println!("Response handle time = {:?}", perf_stat.resp_handle_t);
}
fn print_time_test_results(perf_stat: PerfStat) {
println!("Request time = {:?}", perf_stat.req_t);
println!("Response time = {:?}", perf_stat.resp_t);
println!("Response handle time = {:?}", perf_stat.resp_handle_t);
}
fn print_stats_test_results(
req_size: Vec<f64>,
req_t_size: Vec<f64>,
req_time: Vec<f64>,
resp_size: Vec<f64>,
resp_t_size: Vec<f64>,
resp_handle_t_size: Vec<f64>,
resp_time: Vec<f64>,
resp_handle_time: Vec<f64>,
) {
let mean_req_size = mean(&req_size);
let req_std_dev = standard_deviation(&req_size, Some(mean_req_size));
let mean_req_t_size = mean(&req_t_size);
let req_t_std_dev = standard_deviation(&req_t_size, Some(mean_req_t_size));
let mean_req_time = mean(&req_time);
let req_time_std_dev = standard_deviation(&req_time, Some(mean_req_time));
let mean_resp_size = mean(&resp_size);
let resp_std_dev = standard_deviation(&resp_size, Some(mean_resp_size));
let mean_resp_t_size = mean(&resp_t_size);
let resp_t_std_dev = standard_deviation(&resp_t_size, Some(mean_resp_t_size));
let mean_resp_handle_t_size = mean(&resp_handle_t_size);
let resp_handle_t_std_dev =
standard_deviation(&resp_handle_t_size, Some(mean_resp_handle_t_size));
let mean_resp_time = mean(&resp_time);
let resp_time_std_dev = standard_deviation(&resp_time, Some(mean_resp_time));
let mean_resp_handle_time = mean(&resp_handle_time);
let resp_handle_time_std_dev =
standard_deviation(&resp_handle_time, Some(mean_resp_handle_time));
println!("Average request size = {} bytes", mean_req_size);
println!("Request size standard deviation = {} bytes", req_std_dev);
println!(
"Average request time = {:?}",
Duration::from_secs_f64(mean_req_t_size)
Duration::from_secs_f64(mean_req_time)
);
println!(
"Request time standard deviation = {:?}",
Duration::from_secs_f64(req_t_std_dev)
Duration::from_secs_f64(req_time_std_dev)
);
println!("Average response size = {} bytes", mean_resp_size);
println!("Response standard deviation = {} bytes", resp_std_dev);
println!(
"Average response time = {:?}",
Duration::from_secs_f64(mean_resp_t_size)
Duration::from_secs_f64(mean_resp_time)
);
println!(
"Response time standard deviation = {:?}",
Duration::from_secs_f64(resp_t_std_dev)
Duration::from_secs_f64(resp_time_std_dev)
);
println!(
"Average response handling time = {:?}",
Duration::from_secs_f64(mean_resp_handle_t_size)
Duration::from_secs_f64(mean_resp_handle_time)
);
println!(
"Response handling time standard deviation = {:?}",
Duration::from_secs_f64(resp_handle_t_std_dev)
Duration::from_secs_f64(resp_handle_time_std_dev)
);
}