Merge branch 'hw8' of github.com:themultiplexer/bsys-ws17-grp11 into hw8

hw8/task1/src/cli.yml

-name: "task1"
+name: "Proof of Work Mechanism 0.2"
+author: "Lorenz Bung & Joshua Rutschmann"
+about: "now the basics in Rust, no C anymore"
 args:
     - base:
         value_name: "base"

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 wait = matches.is_present("wait");
     let verbosity = matches.occurrences_of("verbose"); 
     
     let mut time_measurement = false;
-    let mut found = false;
 
+    // Falls irgendein Zeichen nicht hexadezimal ist, breche ab.
     if diff.chars().any(|c| !c.is_digit(16)) {
         println!("Difficulty is not hexadecimal.");
         process::exit(1)
     }
 
+    // Falls das Unterkommando timings angegeben wurde aktiviere die Zeitmessung.
     if let Some(ref sub_command) = matches.subcommand {
         if sub_command.name.eq("timings") {
             time_measurement = true;
             let mut children = vec![];
 
             let (tx, rx) = channel();
+            let mut found = &false;
 
             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 {
 
-                        if found && sync {
-                            process::exit(0);
+                        if n % (100000 + i)  == 0 {
+                            println!("Thread {}: {}", i, n);
+                        }
+
+                        if *found && sync {
+                            return n; 
                         }
 
                         if let Some(solution) = verify_product(b, n, &d) {
-                            found = sync;
+                            *found = true;
                             tx.send(solution).unwrap();
+                            if sync {
+                                break;
+                            }
                         }
                         n += t;
                     }
-
+                    n
                 }));
             }
 
                 }
                 Err(_) => {}
             }
+
+            if wait {
+                for child in children {
+                    let loops = child.join();
+                    println!("Loops: {}", loops.unwrap());
+                }
+            }
+        
         }
         (_, Err(_)) => {
             println!("Number of threads is not integer.");