Enhance project configuration by adding .idea directory to .gitignore, streamline release workflow by removing unnecessary whitespace, and improve code readability by simplifying print statements in CLI commands. Adjust metrics implementation for clarity and consistency.

Author: TKorr

.github/workflows/release.yml

@@ -80,10 +80,10 @@ jobs:
           cargo publish --package tracekit
           echo "Waiting for crates.io to index tracekit..."
           sleep 30
-          
+
           cargo publish --package tracekit-formats
           cargo publish --package tracekit-cachekit
           echo "Waiting for crates.io to index dependencies..."
           sleep 30
-          
+
           cargo publish --package tracekit-cli

.gitignore

@@ -16,6 +16,9 @@ target
 # Covers JetBrains IDEs: IntelliJ, GoLand, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
 # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
 
+# Ignore entire .idea directory
+.idea/
+
 # User-specific stuff
 .idea/**/workspace.xml
 .idea/**/vcs.xml

tracekit-cli/src/cmd_simulate.rs

@@ -32,7 +32,7 @@ pub fn run(args: SimulateArgs) -> Result<(), Box<dyn std::error::Error>> {
     use std::collections::HashMap;
     use std::fs::File;
     use std::io::BufReader;
-    use tracekit::{simulate, CacheModel};
+    use tracekit::{CacheModel, simulate};
     use tracekit_formats::KeyOnlyReader;
 
     // Simple LRU implementation for demonstration

tracekit-cli/src/cmd_tracegen.rs

@@ -114,11 +114,7 @@ pub fn run(args: TracegenArgs) -> Result<(), Box<dyn std::error::Error>> {
     }
 
     if let Some(path) = &args.output {
-        eprintln!(
-            "Generated {} events to {}",
-            args.count,
-            path.display()
-        );
+        eprintln!("Generated {} events to {}", args.count, path.display());
     }
 
     Ok(())

tracekit/src/metrics.rs

@@ -188,7 +188,7 @@ impl LatencySampler {
     #[inline]
     pub fn record(&mut self, duration: Duration) {
         self.count += 1;
-        if !self.count.is_multiple_of(self.sample_rate) {
+        if self.count % self.sample_rate != 0 {
             return;
         }
 
@@ -254,7 +254,6 @@ impl Default for BenchmarkConfig {
     }
 }
 
-
 // ============================================================================
 // Specialized Benchmarks
 // ============================================================================
@@ -263,7 +262,6 @@ impl Default for BenchmarkConfig {
 ///
 /// Returns (baseline_hit_rate, scan_hit_rate, recovery_hit_rate).
 /// A scan-resistant policy should have recovery_hit_rate close to baseline_hit_rate.
-
 /// Results from scan resistance measurement.
 #[derive(Debug, Clone, Copy)]
 pub struct ScanResistanceResult {
@@ -289,8 +287,6 @@ impl ScanResistanceResult {
     }
 }
 
-
-
 /// Results from adaptation speed measurement.
 #[derive(Debug, Clone)]
 pub struct AdaptationResult {

tracekit/src/workload.rs

@@ -155,19 +155,19 @@ impl WorkloadGenerator {
         let bursty_zipfian = match workload {
             Workload::Bursty { base_exponent, .. } => {
                 Some(Zipf::new(universe as f64, base_exponent).unwrap())
-            },
+            }
             _ => None,
         };
         let flash_zipfian = match workload {
             Workload::FlashCrowd { base_exponent, .. } => {
                 Some(Zipf::new(universe as f64, base_exponent).unwrap())
-            },
+            }
             _ => None,
         };
         let scan_resistance_zipfian = match workload {
             Workload::ScanResistance { point_exponent, .. } => {
                 Some(Zipf::new(universe as f64, point_exponent).unwrap())
-            },
+            }
             _ => None,
         };
         Self {
@@ -223,35 +223,35 @@ impl WorkloadGenerator {
                 } else {
                     hot_size + (self.rng.random::<u64>() % (self.universe - hot_size))
                 }
-            },
+            }
 
             Workload::Scan => {
                 let key = self.scan_pos;
                 self.scan_pos = (self.scan_pos + 1) % self.universe;
                 key
-            },
+            }
 
             Workload::Zipfian { .. } => {
                 let zipf = self.zipfian.as_ref().unwrap();
                 let sample: f64 = zipf.sample(&mut self.rng);
                 (sample as u64).saturating_sub(1).min(self.universe - 1)
-            },
+            }
 
             Workload::ScrambledZipfian { .. } => {
                 let zipf = self.zipfian.as_ref().unwrap();
                 let sample: f64 = zipf.sample(&mut self.rng);
                 let key = (sample as u64).saturating_sub(1).min(self.universe - 1);
                 // FNV-1a hash to scramble the key
                 fnv_hash(key) % self.universe
-            },
+            }
 
             Workload::Latest { .. } => {
                 let zipf = self.zipfian.as_ref().unwrap();
                 let sample: f64 = zipf.sample(&mut self.rng);
                 let offset = (sample as u64).saturating_sub(1).min(self.universe - 1);
                 // Access keys near the most recent insert, wrapping around
                 self.insert_counter.wrapping_sub(offset) % self.universe
-            },
+            }
 
             Workload::ShiftingHotspot {
                 shift_interval,
@@ -271,23 +271,23 @@ impl WorkloadGenerator {
                 } else {
                     self.rng.random::<u64>() % self.universe
                 }
-            },
+            }
 
             Workload::Exponential { .. } => {
                 let exp = self.exponential.as_ref().unwrap();
                 let sample: f64 = exp.sample(&mut self.rng);
                 // Map exponential sample to key space, favoring lower keys
                 let key = (sample * (self.universe as f64 / 10.0)) as u64;
                 key.min(self.universe - 1)
-            },
+            }
 
             Workload::Pareto { .. } => {
                 let pareto = self.pareto.as_ref().unwrap();
                 let sample: f64 = pareto.sample(&mut self.rng);
                 // Pareto samples start at scale (1.0), map to key space
                 let key = ((sample - 1.0) * (self.universe as f64 / 10.0)) as u64;
                 key.min(self.universe - 1)
-            },
+            }
 
             Workload::ScanResistance {
                 scan_fraction,
@@ -315,7 +315,7 @@ impl WorkloadGenerator {
                     let sample: f64 = zipf.sample(&mut self.rng);
                     (sample as u64).saturating_sub(1).min(self.universe - 1)
                 }
-            },
+            }
 
             Workload::Correlated {
                 stride,
@@ -337,13 +337,13 @@ impl WorkloadGenerator {
                     // Random access
                     self.rng.random::<u64>() % self.universe
                 }
-            },
+            }
 
             Workload::Loop { working_set_size } => {
                 let key = self.loop_pos % working_set_size.max(1);
                 self.loop_pos = self.loop_pos.wrapping_add(1);
                 key
-            },
+            }
 
             Workload::WorkingSetChurn {
                 working_set_size,
@@ -358,7 +358,7 @@ impl WorkloadGenerator {
                 // Access within current working set
                 let offset = self.rng.random::<u64>() % working_set_size;
                 (self.working_set_base + offset) % self.universe
-            },
+            }
 
             Workload::Bursty { hurst, .. } => {
                 // Simplified bursty model using Hurst parameter to control burst probability
@@ -384,7 +384,7 @@ impl WorkloadGenerator {
                 } else {
                     key
                 }
-            },
+            }
 
             Workload::FlashCrowd {
                 flash_prob,
@@ -422,7 +422,7 @@ impl WorkloadGenerator {
                     let sample: f64 = zipf.sample(&mut self.rng);
                     (sample as u64).saturating_sub(1).min(self.universe - 1)
                 }
-            },
+            }
 
             Workload::Mixture => {
                 // Default mixture: 70% Zipfian, 20% Scan-like, 10% Uniform
@@ -441,7 +441,7 @@ impl WorkloadGenerator {
                     // Uniform random
                     self.rng.random::<u64>() % self.universe
                 }
-            },
+            }
         }
     }
 }