From 3550279bea05360d7d84b7cd70939106096af43b Mon Sep 17 00:00:00 2001 From: Determinant Date: Thu, 11 Jun 2020 12:49:23 -0400 Subject: clean up test code --- tests/common/mod.rs | 137 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 134 insertions(+), 3 deletions(-) (limited to 'tests/common/mod.rs') diff --git a/tests/common/mod.rs b/tests/common/mod.rs index a5a41d5..76533eb 100644 --- a/tests/common/mod.rs +++ b/tests/common/mod.rs @@ -2,7 +2,7 @@ #[allow(dead_code)] extern crate growthring; -use growthring::wal::{WALFile, WALStore, WALPos, WALBytes, WALRingId}; +use growthring::wal::{WALFile, WALStore, WALLoader, WALPos, WALBytes, WALRingId}; use indexmap::{IndexMap, map::Entry}; use rand::Rng; use std::collections::{HashMap, hash_map}; @@ -241,12 +241,13 @@ impl PaintStrokes { PaintStrokes(res) } - pub fn gen_rand(max_pos: u32, max_len: u32, max_col: u32, n: usize, rng: &mut R) -> PaintStrokes { + pub fn gen_rand(max_pos: u32, max_len: u32, + max_col: u32, n: usize, rng: &mut R) -> PaintStrokes { assert!(max_pos > 0); let mut strokes = Self::new(); for _ in 0..n { let pos = rng.gen_range(0, max_pos); - let len = rng.gen_range(1, max_pos - pos + 1); + let len = rng.gen_range(1, std::cmp::min(max_len, max_pos - pos + 1)); strokes.stroke(pos, pos + len, rng.gen_range(0, max_col)) } strokes @@ -409,3 +410,133 @@ fn test_canvas() { assert!(canvas1.is_same(&canvas2)); canvas1.print(10); } + + +pub struct PaintingSim { + pub block_nbit: u8, + pub file_nbit: u8, + pub file_cache: usize, + /// number of PaintStrokes (WriteBatch) + pub n: usize, + /// number of strokes per PaintStrokes + pub m: usize, + /// number of scheduled ticks per PaintStroke submission + pub k: usize, + /// the size of canvas + pub csize: usize, + /// max length of a single stroke + pub stroke_max_len: u32, + /// max color value + pub stroke_max_col: u32, + /// max number of strokes per PaintStroke + pub stroke_max_n: usize, + /// random seed + pub seed: u64 +} + + +impl PaintingSim { + fn run( + &self, + state: &mut WALStoreEmulState, canvas: &mut Canvas, wal: WALLoader, + ops: &mut Vec, ringid_map: &mut HashMap, + fgen: Rc) -> Result<(), ()> { + let mut rng = ::seed_from_u64(self.seed); + let mut wal = wal.recover(WALStoreEmul::new(state, fgen, |_, _|{}))?; + for _ in 0..self.n { + let pss = (0..self.m).map(|_| + PaintStrokes::gen_rand( + self.csize as u32, + self.stroke_max_len, + self.stroke_max_col, + rng.gen_range(1, self.stroke_max_n + 1), &mut rng)) + .collect::>(); + let payloads = pss.iter().map(|e| e.to_bytes()).collect::>(); + // write ahead + let (rids, ok) = wal.grow(payloads); + // keep track of the operations + for (ps, rid) in pss.iter().zip(rids.iter()) { + ops.push(ps.clone()); + ringid_map.insert(*rid, ops.len() - 1); + } + ok?; + // finish appending to WAL + /* + for rid in rids.iter() { + println!("got ringid: {:?}", rid); + } + */ + // prepare data writes + for (ps, rid) in pss.into_iter().zip(rids.into_iter()) { + canvas.prepaint(&ps, &rid); + } + // run k ticks of the fine-grained scheduler + for _ in 0..self.k { + if let Some((fin_rid, _)) = canvas.rand_paint(&mut rng) { + if let Some(rid) = fin_rid { + wal.peel(&[rid])? + } + } else { break } + } + } + // keep running until all operations are finished + while let Some((fin_rid, _)) = canvas.rand_paint(&mut rng) { + if let Some(rid) = fin_rid { + wal.peel(&[rid])? + } + } + canvas.print(40); + Ok(()) + } + + fn get_walloader(&self) -> WALLoader { + WALLoader::new(self.file_nbit, self.block_nbit, self.file_cache) + } + + pub fn get_nticks(&self) -> usize { + let mut state = WALStoreEmulState::new(); + let mut canvas = Canvas::new(self.csize); + let mut ops: Vec = Vec::new(); + let mut ringid_map = HashMap::new(); + let fgen = Rc::new(CountFailGen::new()); + self.run(&mut state, &mut canvas, self.get_walloader(), &mut ops, &mut ringid_map, fgen.clone()).unwrap(); + fgen.get_count() + } + + fn check(state: &mut WALStoreEmulState, canvas: &mut Canvas, + wal: WALLoader, + ops: &Vec, ringid_map: &HashMap) -> bool { + if ops.is_empty() { return true } + let mut last_idx = 0; + canvas.clear_queued(); + wal.recover(WALStoreEmul::new(state, Rc::new(ZeroFailGen), |payload, ringid| { + let s = PaintStrokes::from_bytes(&payload); + canvas.prepaint(&s, &ringid); + if ringid_map.get(&ringid).is_none() { println!("{:?}", ringid) } + last_idx = *ringid_map.get(&ringid).unwrap() + 1; + })).unwrap(); + println!("last = {}/{}", last_idx, ops.len()); + canvas.paint_all(); + // recover complete + let canvas0 = canvas.new_reference(&ops[..last_idx]); + let res = canvas.is_same(&canvas0); + if !res { + canvas.print(40); + canvas0.print(40); + } + res + } + + pub fn test(&self, fgen: G) -> bool { + let mut state = WALStoreEmulState::new(); + let mut canvas = Canvas::new(self.csize); + let mut ops: Vec = Vec::new(); + let mut ringid_map = HashMap::new(); + if self.run(&mut state, &mut canvas, self.get_walloader(), &mut ops, &mut ringid_map, Rc::new(fgen)).is_err() { + if !Self::check(&mut state, &mut canvas, self.get_walloader(), &ops, &ringid_map) { + return false + } + } + true + } +} -- cgit v1.2.3