paralize dir

Cargo.toml

@@ -30,6 +30,7 @@ iai = "0.1"
 miette = { version = "5.5.0", features = ["fancy"] }
 insta = { version = "1.28.0", features = ["json"] }
 test-case = "3.0.0"
+rayon = "1.7.0"
 
 [[bench]]
 name = "bench"

examples/dir.rs

@@ -1,50 +1,79 @@
 use main_error::MainError;
+use rayon::prelude::*;
 use std::env::args;
 use std::ffi::OsStr;
 use std::fs;
-use std::io::stdout;
+use std::hint::black_box;
-use std::io::Write;
+use std::sync::atomic::{AtomicUsize, Ordering};
-use std::time::{Duration, Instant};
+use std::time::Instant;
 use tf_log_parser::parse;
 use walkdir::WalkDir;
 
 fn main() -> Result<(), MainError> {
     let path = args().nth(1).expect("No path provided");
 
-    let mut parse_time = Duration::default();
+    let parse_time = AtomicUsize::default();
-    let mut count = 0;
+    let read_time = AtomicUsize::default();
+    let count = AtomicUsize::default();
     let start = Instant::now();
 
-    let mut stdout = stdout().lock();
+    WalkDir::new(path)
-
+        .into_iter()
-    for entry in WalkDir::new(path) {
+        .flatten()
-        let entry = entry?;
+        .par_bridge()
+        .for_each(|entry| {
             let path = entry.path();
             if path.extension() == Some(OsStr::new("log")) {
-            let _ = write!(&mut stdout, "{} - ", path.display());
+                // let _ = print!("{} - ", path.display());
+                let read_start = Instant::now();
                 let input = match fs::read_to_string(path) {
                     Ok(input) => input,
-                Err(e) => {
+                    Err(_e) => {
-                    println!("failed to read file: {}", e);
+                        // println!("failed to read file: {}", e);
-                    continue;
+                        return;
                     }
                 };
+
+                if count.load(Ordering::Relaxed) % 1_000 == 0 {
+                    println!("{}", path.display());
+                }
+
+                read_time.fetch_add(read_start.elapsed().as_micros() as usize, Ordering::Relaxed);
                 let parse_start = Instant::now();
-            let (output, _) = parse(&input)?;
+                let (output, _) = match parse(&input) {
-            parse_time += parse_start.elapsed();
+                    Ok(val) => val,
-            count += 1;
+                    Err(e) => {
-            let _ = writeln!(&mut stdout, "{} messages", output.chat.len());
+                        eprintln!("failed to parse {}: {}", path.display(), e);
+                        return;
                     }
+                };
+
+                parse_time.fetch_add(
+                    parse_start.elapsed().as_micros() as usize,
+                    Ordering::Relaxed,
+                );
+                count.fetch_add(1, Ordering::Relaxed);
+                black_box(output);
+                // let _ = println!("{} messages", output.chat.len());
             }
+        });
 
     let total = start.elapsed();
 
+    let read_time = read_time.load(Ordering::Relaxed);
+    let parse_time = parse_time.load(Ordering::Relaxed);
+
     println!(
-        "Parsed {} in {:01}s with {:01}s of IO overhead",
+        "Parsed {} in {:01}s, spend {:01}s reading files, in {:01}s of real time",
-        count,
+        count.load(Ordering::Relaxed),
-        parse_time.as_secs_f32(),
+        micros_as_sec(read_time),
-        total.as_secs_f32()
+        micros_as_sec(parse_time),
+        micros_as_sec(total.as_micros() as usize)
     );
 
     Ok(())
 }
+
+fn micros_as_sec(micros: usize) -> f32 {
+    micros as f32 / 1_000_000.0
+}

src/event/medic.rs

@@ -7,6 +7,7 @@ pub struct HealedEvent<'a> {
     #[event(name = "against")]
     pub target: RawSubject<'a>,
     #[event(name = "healing")]
+    #[event(default)]
     pub amount: u32,
 }