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