Commented code. Added test. Corrected loop count.

hw8/task1/src/lib.rs

     }
 }
 
-#[derive(Debug,PartialEq)]
+#[derive(Debug, PartialEq)]
 pub struct Solution {
     pub number: usize,
     pub hash: String,
 }
 
+/// Überprüft ob *base* und *number* auf einen Hash abbilden,
+/// der mit der übergebenen *difficulty* übereinstimmt.
+/// Falls ja, kommt eine `Solution` in der Option mit den Ergebnissen zurück.
+/// Falls nein, steht None im Optional
 pub fn verify_product(base: usize, number: usize, difficulty: &String) -> Option<Solution> {
     let sol = base * number;
     let input = sol.to_string();
     None
 }
 
+/// Sucht nach einem Hash für die angegebene Basis und die Schwierigkeit.
+/// Wenn `total` > 1 ist, dann hat jeder Aufruf mit einem anderen `start`-Wert (von 0 - total)
+/// eine disjunkte Zahlenmenge für die Suche zur Auswahl.
+fn search_hash(
+    hash: &String,
+    base: usize,
+    start: usize,
+    total: usize,
+    sync: bool,
+    found: Arc<AtomicBool>,
+    special: usize,
+    solution_tx: Sender<Solution>,
+    timing_tx: Sender<(Duration, usize)>,
+    measure: bool,
+) {
+    let max = <usize>::max_value();
+    let mut n = start;
+
+    let thread_start = get_time();
+    while n < max {
+
+        // Der special Parameter begrenzt die Anzahl der load()-Aufrufe auf jeden n.ten Loop.
+        if n % special == 0 && found.load(Relaxed) {
+            // Anderer Thread hat eine Lösung gefunden (sync ist aktiviert). Beende Suche.
+            break;
+        }
+
+        if let Some(solution) = verify_product(base, n, hash) {
+            if sync {
+                found.store(true, Relaxed);
+            }
+            // Sende gefundene Solution an den Consumer.
+            let _ = solution_tx.send(solution);
+            // Beende Suche.
+            break;
+        }
+        n += total;
+    }
+
+    // Falls measure aktiviert ist Sende Zeitdauer und Anzahl Loops an den Consumer.
+    if measure {
+        let thread_end = get_time();
+        let _ = timing_tx.send((thread_end - thread_start, (n / total)));
+    }
+}
+
+/// Teilt, wenn nötig, die Suche nach dem Hash auf mehrere Threads auf.
+/// Gibt ggf. die Solution (für die Tests) zurück.
+pub fn search_with_threads(
+    threads: usize,
+    diff_string: String,
+    with_base: usize,
+    time_measurement: bool,
+    verbosity: u64,
+    sync: Option<usize>,
+    wait: bool,
+) -> Option<Solution> {
 
-pub fn search_with_threads(threads:usize, diff_string:String, with_base:usize, time_measurement:bool, verbosity:u64, sync:Option<usize>, wait:bool){
-    let total_start = get_time();
     let diff = Arc::new(diff_string);
     let mut children = vec![];
+    let mut solution = None;
 
     let (solution_tx, solution_rx) = channel();
     let (timing_tx, timing_rx) = channel();
     let found = Arc::new(AtomicBool::new(false));
     let m = time_measurement && verbosity > 0;
 
+    let total_start = get_time();
     if threads > 1 {
 
+        if verbosity > 0 {
+            println!("Searching with {} threads", threads);
+        }
+
+        // Erstellt Anzahl angeforderter Threads.
+        // Klont für jeden Thread die Referenz auf die gemeinsamen Variablen.
         for i in 0..threads {
             let diff = diff.clone();
             let solution_tx = solution_tx.clone();
 
             children.push(thread::spawn(move || {
 
+                // Suche in jedem der Threads.
                 search_hash(
                     &diff,
                     with_base,
                     solution_tx,
                     timing_tx,
                     m,
-                )
+                );
+
+                if verbosity > 1 {
+                    println!("[DEBUG] Thread {} exited", i);
+                }
             }));
         }
     } else {
+        // Suche auf dem Main-Thread.
         search_hash(
             &diff,
             with_base,
             solution_tx,
             timing_tx,
             m,
-        )
+        );
+
+        if verbosity > 1 {
+            println!("[DEBUG] Finished search on main thread.");
+        }
     }
 
+    // Empfängt die Lösung von einem der Producer.
     match solution_rx.recv() {
         Ok(sol) => {
+            solution = Some(Solution {
+                number: sol.number,
+                hash: sol.hash.clone(),
+            });
             let total_end = get_time();
             println!("Number: {} --> hash: {}", sol.number, sol.hash);
             if time_measurement && verbosity == 0 {
     for child in children {
 
         if time_measurement && verbosity > 0 {
-            match timing_rx.recv() {
-                Ok(stats) => {
-                    sum_time = sum_time + stats.0;
-                    sum_loops += stats.1;
-                }
-                Err(_) => {}
+            // Warte auf Zeitstatistik-Nachricht von jedem Thread auf dem zweiten MPSC Channel.
+            if let Ok(stats) = timing_rx.recv() {
+                // Addiere Werte dieses threads zu der Summe.
+                sum_time = sum_time + stats.0;
+                sum_loops += stats.1;
             }
         }
 
+        // Falls *wait* wahr ist, warte auf aktuellen thread (child)
         if wait {
             let _ = child.join();
         }
     }
 
+    // Gebe die Gesamtergebnisse der Threads aus.
     if time_measurement && verbosity > 0 {
         println!("Sum Loops in Producers:       {}", sum_loops);
         let s = sum_time.num_seconds();
         let us = sum_time.num_microseconds().unwrap_or(ms * 1000);
         println!("Sum Duration in Producers:    {}s / {}ms / {}us", s, ms, us);
     }
-}
-
-fn search_hash(
-    hash: &String,
-    base: usize,
-    current: usize,
-    total: usize,
-    sync: bool,
-    found: Arc<AtomicBool>,
-    special: usize,
-    solution_tx: Sender<Solution>,
-    timing_tx: Sender<(Duration, usize)>,
-    measure: bool,
-) {
-    let max = <usize>::max_value();
-    let mut n = current;
 
-    let thread_start = get_time();
-    while n < max {
-
-        if n % special == 0 && found.load(Relaxed) {
-            break;
-        }
-
-        if let Some(solution) = verify_product(base, n, hash) {
-            if sync {
-                found.store(true, Relaxed);
-            }
-
-            let _ = solution_tx.send(solution);
-            break;
-        }
-        n += total;
-    }
-
-    if measure {
-        let thread_end = get_time();
-        let _ = timing_tx.send((thread_end - thread_start, n));
-    }
+    // Gebe die Option einer Solution zurück.
+    solution
 }

hw8/task1/src/main.rs

     let cpus = sys_info::cpu_num().unwrap_or(1).to_string();
     let threads = matches.value_of("threads").unwrap_or(&cpus);
     let sync = matches.is_present("sync");
-    let special = matches.value_of("special").unwrap_or("1").parse::<usize>().unwrap_or(1);
+    let special = matches
+        .value_of("special")
+        .unwrap_or("1")
+        .parse::<usize>()
+        .unwrap_or(1);
     let wait = matches.is_present("wait");
     let verbosity = matches.occurrences_of("verbose");
 
         (Ok(b), Ok(t)) => {
             println!("Please wait...");
 
-            if verbosity > 0 {
-                println!("Searching with {} threads", t);
-            }
-
             let mut sync_opt = None;
             if sync {
                 sync_opt = Some(special);
             }
 
-            search_with_threads(t,diff,b,time, verbosity,sync_opt,wait);
+            let _ = search_with_threads(t, diff, b, time, verbosity, sync_opt, wait);
 
         }
         (_, Err(_)) => {
         }
     };
 }
-

hw8/task1/src/tests/mod.rs

 #[cfg(test)]
 mod tests {
-    use *;
+    use ::*;
+
 
     #[test]
-    fn test_correct_diff() {
-        let hash = String::from("b6bea2a40ed1bd6d9999b2232072092f3df0e02c4b507aa3ad947367b9712345");
+    fn test_multithreaded_search() {
         assert_eq!(
-            verify_product(42,567621, &String::from("12345")),
-            Some(Solution{number:567621, hash:hash})
+            search_with_threads(4, String::from("12345"), 42, false, 0, None, false),
+            Some(Solution {
+                number: 567621,
+                hash: String::from(
+                    "b6bea2a40ed1bd6d9999b2232072092f3df0e02c4b507aa3ad947367b9712345",
+                ),
+            })
         )
     }
 
     #[test]
-    fn test_wrong_diff() {
+    fn test_correct_diff() {
+        let hash = String::from(
+            "b6bea2a40ed1bd6d9999b2232072092f3df0e02c4b507aa3ad947367b9712345",
+        );
         assert_eq!(
-            verify_product(42,13253224, &String::from("12345")),
-            None
+            verify_product(42, 567621, &String::from("12345")),
+            Some(Solution {
+                number: 567621,
+                hash: hash,
+            })
         )
     }
 
+    #[test]
+    fn test_wrong_diff() {
+        assert_eq!(verify_product(42, 13253224, &String::from("12345")), None)
+    }
+
     #[test]
     fn test_hashing() {
         assert_eq!(