Working but still ugly.

hw8/task1/src/lib.rs

@@ -2,7 +2,6 @@ extern crate sha2;
 #[cfg(feature = "SHA2")]
 use self::sha2::Sha256;
 
-
 pub struct Sha256;
 
 pub trait Hasher {
@@ -17,7 +16,6 @@ pub trait HashResult {
     fn size() -> usize;
 }
 
-
 impl Hasher for Sha256 {
     type Output = [u8; 32];
 
@@ -110,9 +108,11 @@ pub fn verify_product(base: usize, number: usize, difficulty: &String) -> Option
     let hash = Sha256::hash(bytes).hex();
 
     if hash.ends_with(difficulty) {
-        return Some(Solution{ number: number, hash: hash,});
+        return Some(Solution {
+            number: number,
+            hash: hash,
+        });
     }
 
     None
 }
-

hw8/task1/src/main.rs

@@ -4,24 +4,35 @@ extern crate time;
 extern crate task1;
 extern crate sys_info;
 
-use std::sync::mpsc::channel;
+mod tests;
+
+use std::sync::mpsc::{Sender, channel};
 use time::get_time;
 use clap::App;
-use std::{process, thread};
-use task1::verify_product;
+use time::Duration;
 use std::sync::Arc;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering::Relaxed;
+use std::{process, thread};
+use task1::{Solution, verify_product};
+
 
 pub fn main() {
+    // Lade Commandline Einstellungen aus YAML-Datei
     let yaml = load_yaml!("cli.yml");
     let matches = App::from_yaml(yaml).get_matches();
+
+    // Speichere alle Argumente in Variablen
+    // Falls ein Wert für ein Argument nicht existiert, lade einen default-Wert
     let base = matches.value_of("base").unwrap_or("1");
-    let diff = Arc::new(matches.value_of("difficulty").unwrap_or("1").to_string());
+    let diff = Arc::new(String::from(matches.value_of("difficulty").unwrap_or("1")));
     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 wait = matches.is_present("wait");
-    let verbosity = matches.occurrences_of("verbose"); 
-    
+    let verbosity = matches.occurrences_of("verbose");
+
     let mut time_measurement = false;
 
     // Falls irgendein Zeichen nicht hexadezimal ist, breche ab.
@@ -37,9 +48,13 @@ pub fn main() {
         }
     }
 
-    if verbosity >= 1 {
+    // Gebe Headerinfos aus, wenn mindestens ein 'v' vorkommt
+    if verbosity > 0 {
         println!("--------------------------------------------");
-        println!("Container: \"{}\"", sys_info::hostname().unwrap_or("-".to_string()));
+        println!(
+            "Container     : \"{}\"",
+            sys_info::hostname().unwrap_or(String::from("-"))
+        );
         println!("Physical CPUs : {}", sys_info::cpu_num().unwrap_or(0));
         println!("Logical CPUs  : {}", sys_info::cpu_num().unwrap_or(0));
         println!("CPU Speed     : {}", sys_info::cpu_speed().unwrap_or(0));
@@ -48,56 +63,71 @@ pub fn main() {
         println!("--------------------------------------------");
     }
 
+    // Versuche Strings der Basis und Threadanzahl zu usize zu parsen
+    // Anderenfalls
     match (base.parse::<usize>(), threads.parse::<usize>()) {
         (Ok(b), Ok(t)) => {
             println!("Please wait...");
 
-            if verbosity >= 1 {
+            if verbosity > 0 {
                 println!("Searching with {} threads", t);
             }
 
-            let start = get_time();
-            let max = <usize>::max_value();
+            let total_start = get_time();
+
             let mut children = vec![];
 
-            let (tx, rx) = channel();
-            let mut found = &false;
+            let (solution_tx, solution_rx) = channel();
+            let (timing_tx, timing_rx) = channel();
 
-            for i in 0..t {
-                let d = diff.clone();
-                let tx = tx.clone();
-                
-                children.push(thread::spawn(move || {
-                    let mut n = i;
-                    while n < max {
+            let found = Arc::new(AtomicBool::new(false));
+            let m = time_measurement && verbosity > 0;
 
-                        if n % (100000 + i)  == 0 {
-                            println!("Thread {}: {}", i, n);
-                        }
+            if t > 1 {
 
-                        if *found && sync {
-                            return n; 
-                        }
+                for i in 0..t {
+                    let diff = diff.clone();
+                    let solution_tx = solution_tx.clone();
+                    let timing_tx = timing_tx.clone();
+                    let found = found.clone();
 
-                        if let Some(solution) = verify_product(b, n, &d) {
-                            *found = true;
-                            tx.send(solution).unwrap();
-                            if sync {
-                                break;
-                            }
-                        }
-                        n += t;
-                    }
-                    n
-                }));
+                    children.push(thread::spawn(move || {
+
+                        search_hash(
+                            &diff,
+                            b,
+                            i,
+                            t,
+                            sync,
+                            found,
+                            special,
+                            solution_tx,
+                            timing_tx,
+                            m,
+                        )
+                    }));
+                }
+            } else {
+                search_hash(
+                    &diff,
+                    b,
+                    0,
+                    1,
+                    sync,
+                    found,
+                    special,
+                    solution_tx,
+                    timing_tx,
+                    m,
+                )
             }
 
-            match rx.recv() {
+            match solution_rx.recv() {
                 Ok(sol) => {
-                    let end = get_time();
+                    let total_end = get_time();
                     println!("Number: {} --> hash: {}", sol.number, sol.hash);
-                    if time_measurement {
-                        let diff = end - start;
+                    if time_measurement && verbosity == 0 {
+                        let diff = total_end - total_start;
                         let s = diff.num_seconds();
                         let ms = diff.num_milliseconds();
                         let us = diff.num_microseconds().unwrap_or(ms * 1000);
@@ -107,13 +137,34 @@ pub fn main() {
                 Err(_) => {}
             }
 
-            if wait {
-                for child in children {
-                    let loops = child.join();
-                    println!("Loops: {}", loops.unwrap());
+            let mut sum_loops = 0usize;
+            let mut sum_time: Duration = Duration::zero();
+
+            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(_) => {}
+                    }
+                }
+
+                if wait {
+                    let _ = child.join();
                 }
             }
-        
+
+            if time_measurement && verbosity > 0 {
+                println!("Sum Loops in Producers:       {}", sum_loops);
+                let s = sum_time.num_seconds();
+                let ms = sum_time.num_milliseconds();
+                let us = sum_time.num_microseconds().unwrap_or(ms * 1000);
+                println!("Sum Duration in Producers:    {}s / {}ms / {}us", s, ms, us);
+            }
+
         }
         (_, Err(_)) => {
             println!("Number of threads is not integer.");
@@ -125,3 +176,42 @@ pub fn main() {
         }
     };
 }
+
+pub 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));
+    }
+}

hw8/task1/src/tests/mod.rs

@@ -0,0 +1,17 @@
+#[cfg(test)]
+mod tests {
+    use search_hash;
+
+    #[test]
+    fn test_faulty_diff() {
+        search_hash()
+    }
+
+
+    fn test_hash() {
+        assert_eq!(
+            hash("test".as_bytes()).hex(),
+            "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
+        );
+    }
+}

hw8/task1/src/unit_test.rs

@@ -1,7 +0,0 @@
-#[test]
-fn test_hash() {
-    assert_eq!(
-        Sha256::hash("test".as_bytes()).hex(),
-        "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
-    );
-}