Compare single-threaded version to multi-threaded version

src/main.rs

@@ -7,7 +7,40 @@ use std::{
     time::Instant,
 };
 
-fn generate_primes(threads: usize, max_value: usize) -> Vec<usize> {
+fn generate_primes_single_threaded(max_value: usize) -> Vec<usize> {
+    let size = max_value + 1;
+    let mut prime_map = vec![true; size];
+
+    let to_sqrt = 2..(f64::sqrt(max_value as f64) as usize);
+
+    for index in to_sqrt {
+        if let Some(slot) = prime_map.get(index) {
+            let slot: &bool = slot;
+
+            if *slot {
+                for composite in (index * 2..size).step_by(index) {
+                    if let Some(slot) = prime_map.get_mut(composite) {
+                        *slot = false;
+                    }
+                }
+            }
+        }
+    }
+
+    (0..size)
+        .filter(|index| {
+            if let Some(slot) = prime_map.get(*index) {
+                let slot: &bool = slot;
+
+                *slot
+            } else {
+                false
+            }
+        })
+        .collect::<Vec<_>>()
+}
+
+fn generate_primes_multi_threaded(threads: usize, max_value: usize) -> Vec<usize> {
     let size = max_value + 1;
     let prime_map = (0..size).map(|_| AtomicBool::new(true)).collect::<Vec<_>>();
 
@@ -64,9 +97,7 @@ fn generate_primes(threads: usize, max_value: usize) -> Vec<usize> {
     })
 }
 
-fn main() {
-    let max_prime = 3_000_000_000;
-
+fn run_multi_threaded(max_prime: usize) -> Vec<usize> {
     let now = Instant::now();
 
     let threads: usize = std::thread::available_parallelism()
@@ -78,18 +109,32 @@ fn main() {
         now.elapsed()
     );
 
-    let mut primes = generate_primes(threads, max_prime);
+    let mut primes = generate_primes_multi_threaded(threads, max_prime);
     println!("{:?} - Generated {} primes", now.elapsed(), primes.len());
     primes.sort();
     println!("{:?} - Sorted", now.elapsed());
+    primes
+}
 
+fn run_single_threaded(max_prime: usize) -> Vec<usize> {
+    let now = Instant::now();
+    println!(
+        "{:?} - Generating primes up to {max_prime} with 1 thread",
+        now.elapsed()
+    );
+    let primes = generate_primes_single_threaded(max_prime);
+    println!("{:?} - Generated {} primes", now.elapsed(), primes.len());
+    primes
+}
+
+fn print_primes(primes: Vec<usize>) {
     let buf = Vec::with_capacity(primes.len() * 8);
     let mut buf_writer = BufWriter::new(buf);
     for prime in primes {
         write!(buf_writer, "{prime}\n").expect("Writing succedes");
     }
     buf_writer.flush().expect("Flush succeeds");
-    println!("{:?} - Built output string", now.elapsed());
+    println!("Built output string");
     /*
     println!(
         "{}",
@@ -98,3 +143,10 @@ fn main() {
     );
     */
 }
+
+fn main() {
+    let max_prime = 3_000_000_000;
+
+    print_primes(run_multi_threaded(max_prime));
+    print_primes(run_single_threaded(max_prime));
+}