wip

Author: Van-nam Do

challenges/wc-command/src/lib.rs

@@ -1,11 +1,13 @@
+use core::num;
 use core::str;
+use std::time::Instant;
+use memmap2::MmapOptions;
 use std::cmp::min;
 use std::fs::File;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::thread;
-use memmap2::MmapOptions;
 
 pub fn read_file_as_string(file_path: &str) -> String {
     let file = File::open(file_path).expect("Path is not valid");
@@ -19,52 +21,101 @@ pub fn count_words(text: &str) -> usize {
 }
 
 pub fn count_word_occurrences(text: &str, word: String) -> usize {
-    count_in_paralell(text, move |chunk| count_word_occurrences_in_chunk(chunk, &word))
+    count_in_paralell(text, move |chunk| {
+        count_word_occurrences_in_chunk(chunk, &word)
+    })
 }
 
 fn count_in_paralell<F>(text: &str, count_fn: F) -> usize
 where
-    F: Fn(&[String]) -> usize + Send + Sync + 'static,
+    F: Fn(&[&str]) -> usize + Send + Sync + 'static,
 {
     let num_threads: usize = std::thread::available_parallelism().unwrap().get();
-    let lines: Vec<String> = text.lines().map(|line| line.to_string()).collect();
+    let lines: Vec<&str> = text.lines().collect();
     let lines_per_thread = (lines.len() + num_threads - 1) / num_threads;
     let total_word_count = Arc::new(AtomicUsize::new(0));
-    let mut handles = Vec::new();
+    // let mut handles = Vec::new();
     let count_fn = Arc::new(count_fn);
+    let start = Instant::now();
+    // for i in 0..num_threads {
+    //     let start = lines_per_thread * i;
+    //     let end = min(start + lines_per_thread, lines.len());
+    //     if is_valid_range(start, end, lines.len()) {
+    //         let chunk = lines[start..end].to_vec();
+    //         let count_fn_clone = Arc::clone(&count_fn);
+    //         let total_word_count_clone = total_word_count.clone();
 
-    for i in 0..num_threads {
-        let start = lines_per_thread * i;
-        let end = min(start + lines_per_thread, lines.len());
-        let chunk = lines[start..end].to_vec();
-        let count_fn_clone = Arc::clone(&count_fn);
-        let total_word_count_clone = total_word_count.clone();
-
-        let handle = thread::spawn(move || {
-            let count = count_fn_clone(&chunk);
-            total_word_count_clone.fetch_add(count, Ordering::Relaxed);
-        });
-        handles.push(handle);
-    }
+    //         let handle = thread::spawn(move || {
+    //             let count = count_fn_clone(chunk);
+    //             total_word_count_clone.fetch_add(count, Ordering::Relaxed);
+    //         });
+    //         handles.push(handle);
+    //     }
+    // }
 
-    for handle in handles {
-        handle.join().unwrap();
-    }
+
+    thread::scope(|s| {
+        for i in 0..num_threads {
+            let start = lines_per_thread * i;
+            let end = min(start + lines_per_thread, lines.len());
+            
+            if is_valid_range(start, end, lines.len()) {
+                let chunk = &lines[start..end]; // Borrow a slice of `&str`
+                let count_fn_clone = Arc::clone(&count_fn);
+                let total_word_count_clone = Arc::clone(&total_word_count);
+
+                s.spawn(move || {
+                    let count = count_fn_clone(chunk); // Use the borrowed slice here
+                    total_word_count_clone.fetch_add(count, Ordering::Relaxed);
+                });
+            }
+        }
+    });
+
+    println!("Finish loop in: {:?}", start.elapsed());
+
+    // for handle in handles {
+    //     handle.join().unwrap();
+    // }
     total_word_count.load(Ordering::Relaxed)
 }
 
+fn is_valid_range(start: usize, end: usize, len: usize) -> bool {
+    start < end && end <= len 
+}
 
-fn count_words_in_chunk(chunk: &[String]) -> usize {
+fn chunk_text(text: &str, num_chunks: usize) -> Vec<&str> {
+    let chunk_size = text.len() / num_chunks;
+    let mut chunks = Vec::new();
+    let mut start = 0;
+
+    while start < text.len() {
+        let end = min(text.len(), start + chunk_size);
+        let chunk = &text[start..end];
+        chunks.push(chunk);
+        start = end;
+    }
+    chunks
+}
+
+
+fn collect_lines_parallel(text: &str, num_threads: usize) -> Vec<&str> {
+    let mut result: Vec<&str> = Vec::new();
+    let mut handles = Vec::new();
+    
+}
+
+fn count_words_in_chunk(chunk: &[&str]) -> usize {
     chunk
         .iter()
         .flat_map(|line| line.split_whitespace())
         .count()
 }
 
-fn count_word_occurrences_in_chunk(chunk: &[String], word: &str) -> usize {
+fn count_word_occurrences_in_chunk(chunk: &[&str], word: &str) -> usize {
     chunk
         .iter()
         .flat_map(|line| line.split_whitespace())
         .filter(|&w| w == word)
         .count()
-}
+}

challenges/wc-command/src/main.rs

@@ -1,6 +1,6 @@
 
 use wc_command::{count_word_occurrences, count_words, read_file_as_string};
-use std::env;
+use std::{env, time::Instant};
 
 fn main() {
     let args: Vec<String> = env::args().collect();
@@ -16,21 +16,23 @@ fn main() {
                 eprintln!("Usage: rccwc -w <file>");
                 return;
             }
+            let start = Instant::now();
             let file_path = &args[3];
             let text = read_file_as_string(&file_path);
             let total_words = count_words(&text);
-            println!("Total words: {}", total_words);
+            println!("Total words: {}, elapsed time: {:?}", total_words, start.elapsed());
         } 
         "-wo" => {
             if args.len() != 5 {
                 eprintln!("Usage: rccwc -wc <word> <file_path>");
                 return;
             }
+            let start = Instant::now();
             let word = &args[3];
             let file_path = &args[4];
             let text = read_file_as_string(&file_path);
             let total_occurrences = count_word_occurrences(&text, word.to_string());
-            println!("Total occurrences of '{}': {} ", word, total_occurrences);
+            println!("Total occurrences of '{}': {}, elapsed time: {:?}", word, total_occurrences, start.elapsed());
         }
         _ => {
             eprintln!("Invalid option. Usage: rccwc -w <file_path> or -wo <word> <file_path>")

challenges/wc-command/tests/test.rs

@@ -1,9 +1,59 @@
 #[cfg(test)]
 mod tests {
+    use wc_command::{count_word_occurrences, count_words};
 
+    #[test]
+    fn test_count_words_empty() {
+        let text = "";
+        assert_eq!(count_words(text), 0)
+    }
+
+    #[test]
+    fn test_count_words_single_line() {
+        let text = "hello world";
+        assert_eq!(count_words(text), 2);
+    }
+
+    #[test]
+    fn test_count_words_multiple_lines() {
+        let text = "Hello world\nThis is a test\nRust is awesome";
+        assert_eq!(count_words(text), 9);
+    }
+
+    #[test]
+    fn test_count_word_occurrences_empty() {
+        let text = "";
+        let word = "rust".to_string();
+        assert_eq!(count_word_occurrences(text, word), 0);
+    }
 
     #[test]
-    fn test_solve() {
-        // Call the solve function and check for expected results
+    fn test_count_word_occurrences_single_line() {
+        let text = "performance and memory safety";
+        let word = "performance".to_string();
+        assert_eq!(count_word_occurrences(text, word), 1);
     }
+
+    #[test]
+    fn test_count_word_occurrences_multiple_occurrences() {
+        let text = "Hello world\nThis is a test\nThis test is just a test";
+        let word = "test".to_string();
+        assert_eq!(count_word_occurrences(text, word), 3);
+    }
+
+    #[test]
+    fn test_count_word_large_input() {
+        let text = "hello world ".repeat(1_000_000);
+        assert_eq!(count_words(&text), 2_000_000);
+    }
+
+    #[test]
+    fn test_count_word_occurrences_large_input() {
+        let text = "this is a test\nthis is another test\nfinally another test\n".repeat(1_000_000);
+        let test = "test".to_string();
+        let another = "another".to_string();
+        assert_eq!(count_word_occurrences(&text, test), 3_000_000);
+        assert_eq!(count_word_occurrences(&text, another), 2_000_000);
+    }
+
 }