From 2a6988e742f4ddff34e37330f4f916b5ffc74402 Mon Sep 17 00:00:00 2001 From: onyinyang Date: Tue, 6 Jul 2021 18:08:52 -0400 Subject: [PATCH] Add tests for varying percentages of blocked bridge --- crates/lox-library/src/tests.rs | 295 +++++++++++++++++++++++++++----- 1 file changed, 248 insertions(+), 47 deletions(-) diff --git a/crates/lox-library/src/tests.rs b/crates/lox-library/src/tests.rs index 1895a7f..e218426 100644 --- a/crates/lox-library/src/tests.rs +++ b/crates/lox-library/src/tests.rs @@ -4,7 +4,9 @@ BridgeLine::random() or private fields */ use super::bridge_table::BridgeLine; use super::proto::*; use super::*; +use rand::Rng; use statistical::{mean, standard_deviation}; +use std::collections::HashSet; use std::time::{Duration, Instant}; struct PerfStat { @@ -84,7 +86,7 @@ impl TestHarness { open_invite::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap(); let resp_handle_t = resp_handle_start.elapsed(); - return ( + ( PerfStat { req_len, resp_len, @@ -93,7 +95,7 @@ impl TestHarness { resp_handle_t, }, (cred, bridgeline), - ); + ) } fn trust_promotion(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Migration) { @@ -116,7 +118,7 @@ impl TestHarness { let migcred = trust_promotion::handle_response(promstate, decode_resp).unwrap(); let resp_handle_t = resp_handle_start.elapsed(); - return ( + ( PerfStat { req_len, resp_len, @@ -125,7 +127,7 @@ impl TestHarness { resp_handle_t, }, migcred, - ); + ) } fn level0_migration( @@ -152,7 +154,7 @@ impl TestHarness { let cred = migration::handle_response(migstate, decode_resp, &self.ba.lox_pub).unwrap(); let resp_handle_t = resp_handle_start.elapsed(); - return ( + ( PerfStat { req_len, resp_len, @@ -161,7 +163,7 @@ impl TestHarness { resp_handle_t, }, cred, - ); + ) } fn level_up(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Lox) { @@ -201,7 +203,7 @@ impl TestHarness { let cred = level_up::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap(); let resp_handle_t = resp_handle_start.elapsed(); - return ( + ( PerfStat { req_len, resp_len, @@ -210,7 +212,7 @@ impl TestHarness { resp_handle_t, }, cred, - ); + ) } fn issue_invite(&mut self, cred: &cred::Lox) -> (PerfStat, (cred::Lox, cred::Invitation)) { @@ -253,7 +255,7 @@ impl TestHarness { .unwrap(); let resp_handle_t = resp_handle_start.elapsed(); - return ( + ( PerfStat { req_len, resp_len, @@ -262,7 +264,7 @@ impl TestHarness { resp_handle_t, }, (cred, invite), - ); + ) } fn redeem_invite(&mut self, inv: &cred::Invitation) -> (PerfStat, cred::Lox) { @@ -285,7 +287,7 @@ impl TestHarness { let cred = redeem_invite::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap(); let resp_handle_t = resp_handle_start.elapsed(); - return ( + ( PerfStat { req_len, resp_len, @@ -294,7 +296,7 @@ impl TestHarness { resp_handle_t, }, cred, - ); + ) } fn check_blockage(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Migration) { @@ -316,7 +318,7 @@ impl TestHarness { let migcred = check_blockage::handle_response(state, decode_resp).unwrap(); let resp_handle_t = resp_handle_start.elapsed(); - return ( + ( PerfStat { req_len, resp_len, @@ -325,7 +327,7 @@ impl TestHarness { resp_handle_t, }, migcred, - ); + ) } fn blockage_migration( @@ -355,7 +357,7 @@ impl TestHarness { blockage_migration::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap(); let resp_handle_t = resp_handle_start.elapsed(); - return ( + ( PerfStat { req_len, resp_len, @@ -364,7 +366,7 @@ impl TestHarness { resp_handle_t, }, cred, - ); + ) } } @@ -936,8 +938,8 @@ fn stats_test_invitations() { th.advance_days(14); let (_, cred2) = th.level_up(&cred1); th.advance_days(28); - let (perf_stat, (cred2a, invite)) = th.issue_invite(&cred2); - let (bob_perf_stat, bob_cred) = th.redeem_invite(&invite); + 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()); resp_size.push(perf_stat.resp_len as f64); @@ -970,7 +972,203 @@ fn stats_test_invitations() { } #[test] -fn stats_test_blockage_migration() { +fn stats_test_blockage_migration_5() { + let mut th = TestHarness::new_buckets(10, 10); + let mut credentials: Vec = Vec::new(); + for _ in 0..1000 { + let cred = th.open_invite().1 .0; + th.advance_days(30); + let (_, migcred) = th.trust_promotion(&cred); + let (_, cred1) = th.level0_migration(&cred, &migcred); + th.advance_days(14); + let (_, cred2) = th.level_up(&cred1); + let (_, (cred2a, invite)) = th.issue_invite(&cred2); + let (_, bob_cred) = th.redeem_invite(&invite); + th.advance_days(28); + let (_, _) = th.level_up(&bob_cred); + let (_, cred3) = th.level_up(&cred2a); + credentials.push(cred3); + } + + block_bridges(&mut th, 5, credentials); +} + +#[test] +fn stats_test_blockage_migration_10() { + let mut th = TestHarness::new_buckets(10, 10); + let mut credentials: Vec = Vec::new(); + for _ in 0..1000 { + let cred = th.open_invite().1 .0; + th.advance_days(30); + let (_, migcred) = th.trust_promotion(&cred); + let (_, cred1) = th.level0_migration(&cred, &migcred); + th.advance_days(14); + let (_, cred2) = th.level_up(&cred1); + let (_, (cred2a, invite)) = th.issue_invite(&cred2); + let (_, bob_cred) = th.redeem_invite(&invite); + th.advance_days(28); + let (_, _) = th.level_up(&bob_cred); + let (_, cred3) = th.level_up(&cred2a); + credentials.push(cred3); + } + + block_bridges(&mut th, 10, credentials); +} + +#[test] +fn stats_test_blockage_migration_15() { + let mut th = TestHarness::new_buckets(10, 10); + let mut credentials: Vec = Vec::new(); + for _ in 0..100 { + let cred = th.open_invite().1 .0; + th.advance_days(30); + let (_, migcred) = th.trust_promotion(&cred); + let (_, cred1) = th.level0_migration(&cred, &migcred); + th.advance_days(14); + let (_, cred2) = th.level_up(&cred1); + let (_, (cred2a, invite)) = th.issue_invite(&cred2); + let (_, bob_cred) = th.redeem_invite(&invite); + th.advance_days(28); + let (_, _) = th.level_up(&bob_cred); + let (_, cred3) = th.level_up(&cred2a); + credentials.push(cred3); + } + + block_bridges(&mut th, 15, credentials); +} + +#[test] +fn stats_test_blockage_migration_20() { + let mut th = TestHarness::new_buckets(10, 10); + let mut credentials: Vec = Vec::new(); + for _ in 0..100 { + let cred = th.open_invite().1 .0; + th.advance_days(30); + let (_, migcred) = th.trust_promotion(&cred); + let (_, cred1) = th.level0_migration(&cred, &migcred); + th.advance_days(14); + let (_, cred2) = th.level_up(&cred1); + let (_, (cred2a, invite)) = th.issue_invite(&cred2); + let (_, bob_cred) = th.redeem_invite(&invite); + th.advance_days(28); + let (_, _) = th.level_up(&bob_cred); + let (_, cred3) = th.level_up(&cred2a); + credentials.push(cred3); + } + + block_bridges(&mut th, 20, credentials); +} + +#[test] +fn stats_test_blockage_migration_25() { + let mut th = TestHarness::new_buckets(10, 10); + let mut credentials: Vec = Vec::new(); + for _ in 0..100 { + let cred = th.open_invite().1 .0; + th.advance_days(30); + let (_, migcred) = th.trust_promotion(&cred); + let (_, cred1) = th.level0_migration(&cred, &migcred); + th.advance_days(14); + let (_, cred2) = th.level_up(&cred1); + let (_, (cred2a, invite)) = th.issue_invite(&cred2); + let (_, bob_cred) = th.redeem_invite(&invite); + th.advance_days(28); + let (_, _) = th.level_up(&bob_cred); + let (_, cred3) = th.level_up(&cred2a); + credentials.push(cred3); + } + + block_bridges(&mut th, 25, credentials); +} + +#[test] +fn stats_test_blockage_migration_30() { + let mut th = TestHarness::new_buckets(10, 10); + let mut credentials: Vec = Vec::new(); + for _ in 0..100 { + let cred = th.open_invite().1 .0; + th.advance_days(30); + let (_, migcred) = th.trust_promotion(&cred); + let (_, cred1) = th.level0_migration(&cred, &migcred); + th.advance_days(14); + let (_, cred2) = th.level_up(&cred1); + let (_, (cred2a, invite)) = th.issue_invite(&cred2); + let (_, bob_cred) = th.redeem_invite(&invite); + th.advance_days(28); + let (_, _) = th.level_up(&bob_cred); + let (_, cred3) = th.level_up(&cred2a); + credentials.push(cred3); + } + + block_bridges(&mut th, 30, credentials); +} + +#[test] +fn stats_test_blockage_migration_35() { + let mut th = TestHarness::new_buckets(10, 10); + let mut credentials: Vec = Vec::new(); + for _ in 0..100 { + let cred = th.open_invite().1 .0; + th.advance_days(30); + let (_, migcred) = th.trust_promotion(&cred); + let (_, cred1) = th.level0_migration(&cred, &migcred); + th.advance_days(14); + let (_, cred2) = th.level_up(&cred1); + let (_, (cred2a, invite)) = th.issue_invite(&cred2); + let (_, bob_cred) = th.redeem_invite(&invite); + th.advance_days(28); + let (_, _) = th.level_up(&bob_cred); + let (_, cred3) = th.level_up(&cred2a); + credentials.push(cred3); + } + + block_bridges(&mut th, 35, credentials); +} + +#[test] +fn stats_test_blockage_migration_40() { + let mut th = TestHarness::new_buckets(10, 10); + let mut credentials: Vec = Vec::new(); + for _ in 0..100 { + let cred = th.open_invite().1 .0; + th.advance_days(30); + let (_, migcred) = th.trust_promotion(&cred); + let (_, cred1) = th.level0_migration(&cred, &migcred); + th.advance_days(14); + let (_, cred2) = th.level_up(&cred1); + let (_, (cred2a, invite)) = th.issue_invite(&cred2); + let (_, bob_cred) = th.redeem_invite(&invite); + th.advance_days(28); + let (_, _) = th.level_up(&bob_cred); + let (_, cred3) = th.level_up(&cred2a); + credentials.push(cred3); + } + + block_bridges(&mut th, 40, credentials); +} + +/// Blocks a percentage of the total number of bridges for the passed Test Harness +/// for the number of buckets and hot spares passed at initialization + +fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec) { + let to_block: usize = (th.ba.bridge_table.buckets.len() * percentage / 100).into(); + let mut block_index: HashSet = HashSet::new(); + let mut rng = rand::thread_rng(); + + while block_index.len() <= to_block - 1 { + let rand_num = rng.gen_range(0, th.ba.bridge_table.buckets.len()); + block_index.insert(rand_num); + } + + for index in block_index { + let b0 = th.ba.bridge_table.buckets[index][0]; + let b1 = th.ba.bridge_table.buckets[index][1]; + let b2 = th.ba.bridge_table.buckets[index][2]; + th.ba.bridge_unreachable(&b0, &mut th.bdb); + th.ba.bridge_unreachable(&b1, &mut th.bdb); + th.ba.bridge_unreachable(&b2, &mut th.bdb); + } + let mut req_size: Vec = Vec::new(); let mut resp_size: Vec = Vec::new(); let mut req_t_size: Vec = Vec::new(); @@ -981,39 +1179,39 @@ fn stats_test_blockage_migration() { let mut red_req_t_size: Vec = Vec::new(); let mut red_resp_t_size: Vec = Vec::new(); let mut red_resp_handle_t_size: Vec = Vec::new(); - for _ in 0..10000 { - let mut th = TestHarness::new_buckets(3, 3); - let cred = th.open_invite().1 .0; - th.advance_days(30); - let (_, migcred) = th.trust_promotion(&cred); - let (_, cred1) = th.level0_migration(&cred, &migcred); - th.advance_days(14); - let (_, cred2) = th.level_up(&cred1); - th.advance_days(28); - let (_, cred3) = th.level_up(&cred2); - let (id, key) = bridge_table::from_scalar(cred3.bucket).unwrap(); + for cred in credentials { + let (id, key) = bridge_table::from_scalar(cred.bucket).unwrap(); let encbuckets = th.ba.enc_bridge_table(); let bucket = bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap(); - th.ba.bridge_unreachable(&bucket.0[0], &mut th.bdb); - th.ba.bridge_unreachable(&bucket.0[1], &mut th.bdb); - th.ba.bridge_unreachable(&bucket.0[2], &mut th.bdb); - let (perf_stat, migration) = th.check_blockage(&cred3); - let (block_perf_stat, cred4) = th.blockage_migration(&cred3, &migration); - 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()); - 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_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()); + let mut count = 0; + for bridge_line in &bucket.0 { + if th.ba.bridge_table.reachable.contains_key(bridge_line) { + count = count + 1; + } + } + + if count < 2 { + 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()); + 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()); + 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_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()); + } } - println!("\n---------------Check Blockage----------------\n"); + println!( + "\n---------------Check Blockage {}---------------\n", + percentage + ); print_stats_test_results( req_size, req_t_size, @@ -1022,7 +1220,10 @@ fn stats_test_blockage_migration() { resp_handle_t_size, ); - println!("\n---------------Blockage Migration----------------\n"); + println!( + "\n---------------Blockage Migration {}---------------\n", + percentage + ); print_stats_test_results( red_req_size, red_req_t_size,