fix leveled compaction tests

Signed-off-by: Alex Chi Z <iskyzh@gmail.com>

mini-lsm-mvcc/src/compact/leveled.rs

@@ -118,6 +118,21 @@ impl LeveledCompactionController {
             }
         }
         priorities.sort_by(|a, b| a.partial_cmp(b).unwrap().reverse());
+
+        println!(
+            "target level sizes: {:?}, real level sizes: {:?}, base_level: {}",
+            target_level_size
+                .iter()
+                .map(|x| format!("{:.3}MB", *x as f64 / 1024.0 / 1024.0))
+                .collect::<Vec<_>>(),
+            real_level_size
+                .iter()
+                .map(|x| format!("{:.3}MB", *x as f64 / 1024.0 / 1024.0))
+                .collect::<Vec<_>>(),
+            base_level,
+        );
+        println!("compaction triggered by priority: {:?}", priorities);
+
         let priority = priorities.first();
         if let Some((_, level)) = priority {
             println!(

mini-lsm/src/tests/harness.rs

@@ -338,21 +338,19 @@ pub fn check_compaction_ratio(storage: Arc<MiniLsm>) {
         }) => {
             assert!(l0_sst_num < level0_file_num_compaction_trigger);
             assert!(level_size.len() <= max_levels);
-            for idx in 1..level_size.len() {
+            let last_level_size = *level_size.last().unwrap();
-                let prev_size = level_size[idx - 1];
+            let mut multiplier = 1.0;
-                let this_size = level_size[idx];
+            for idx in (1..level_size.len()).rev() {
-                if this_size == 0 {
+                multiplier *= level_size_multiplier as f64;
-                    continue;
+                let this_size = level_size[idx - 1];
-                }
                 assert!(
                     // do not add hard requirement on level size multiplier considering bloom filters...
-                    this_size as f64 / prev_size as f64 >= (level_size_multiplier as f64 - 0.5),
+                    this_size as f64 / last_level_size as f64 <= 1.0 / multiplier + 0.5,
-                    "L{}/L{}, {}/{}<<{}",
+                    "L{}/L_max, {}/{}>>1.0/{}",
-                    state.levels[idx].0,
                     state.levels[idx - 1].0,
                     this_size,
-                    prev_size,
+                    last_level_size,
-                    level_size_multiplier
+                    multiplier
                 );
             }
             assert!(