Updated main-race.c

hw8/simu1/ANSWERS.md

@@ -0,0 +1,68 @@
+# hw8 - Simulation 1 - Antworten
+
+1. Helgrind markiert die richtigen Stellen im Code:
+    ```text
+    ==1930== Possible data race during write of size 4 at 0x60207C by thread #1
+    ==1930== Locks held: none
+    ==1930==    at 0x400C9A: main (main-race.c:15)
+    ==1930==
+    ==1930== This conflicts with a previous write of size 4 by thread #2
+    ==1930== Locks held: none
+    ==1930==    at 0x400C5A: worker (main-race.c:8)
+    ```
+    Weiterhin erhält man die Information über den Lock (hier `none`), die Art des Problems (`Possible data race`) und die Größe der Daten, die geschrieben werden.
+
+2. Codekorrektur
+
+    1. Wenn ich eine der Zeilen lösche (bzw. auskommentiere), meldet helgrind keinen Fehler mehr (auch nicht für die zweite betreffende Zeile).
+
+    2. Wenn man nur bei einer Variable den Lock setzt, erkennt helgrind den Fehler:
+        ```text
+        ==18432== Possible data race during write of size 4 at 0x602084 by thread #1
+        ==18432== Locks held: none
+        ==18432==    at 0x400CB2: main (main-race.c:18)
+        ==18432==
+        ==18432== This conflicts with a previous write of size 4 by thread #2
+        ==18432== Locks held: 1, at address 0x6020A0
+        ==18432==    at 0x400C68: worker (main-race.c:10)
+        ```
+    3. Wenn man bei beiden Variablen einen Lock setzt, findet helgrind wieder keine Fehler.
+
+3. Vermutlich ist der Fehler, dass Thread 1 einen Lock auf v1 setzt, Thread 2 einen Lock auf v2, und anschließend warten beide Threads, bis der jeweils andere diesen Lock wieder freigibt. Auf der Labshell läuft das Programm. Dieser Deadlock tritt nur auf, wenn Thread 1 und Thread 2 wirklich absolut parallel laufen.
+
+4. Helgrind gibt mir viele Informationen zur Lockreihenfolge. Es sagt, dass es durch das Festlegen des ersten Locks eine feste Reihenfolge gibt, in der neue Locks gesetzt werden müssen. Zusätzlich bekomme ich die Information, wo die Reihenfolge festgelegt wird und wo sie nicht eingehalten wird.
+
+5. `main-deadlock-global.c`
+
+    1. Das Problem der Lockreihenfolge sollte hier nicht auftreten, da im Worker ein globaler Lock gesetzt wird. Dieser blockiert während dem kritischen Bereich einfach alle anderen Threads.
+
+    2. Beim Ausführen des Programms treten keine Fehler auf.
+
+    3. helgrind sollte eigentlich keinen Fehler melden, da der globale Lock einen Deadlock verhindert.
+
+    4. Da helgrind den Fehler dennoch erkennt, ist es ein sehr nützliches Werkzeug um Lockfehler zu erkennen.
+
+6. Dieser Code ist sehr ineffizient, da der Parent-Thread durch seine while-Schleife die CPU zu 100% auslastet und somit zum einen sehr viel Strom verbraucht und zum anderen die anderen Threads ihrer Rechenzeit "beraubt". Dies ist besonders auffällig, wenn das Child sehr lange benötigt.
+
+7.
+
+    1. helgrind meldet einen Data-Race-Fehler in der Variable `done`:
+        ```text
+        ==1064== Possible data race during read of size 4 at 0x602084 by thread #1
+        ==1064== Locks held: none
+        ==1064==    at 0x400CEB: main (main-signal.c:16)
+        ==1064==
+        ==1064== This conflicts with a previous write of size 4 by thread #2
+        ==1064== Locks held: none
+        ```
+        Dieser Fehler wird gemeldet, da der Kindthread in `done` eine 1 schreibt, sobald er fertig ist, im Elternthread jedoch eine while-Schleife mit dieser Variable läuft.
+
+    2. Trotz der Meldung von helgrind ist der Code korrekt, da im Elternthread die Variable `done` nie geschrieben wird, sondern nur gelesen wird. "Verpasst" die while-Schleife die Änderung in `done`, so spielt das keine Rolle und die Schleife läuft einfach noch ein letztes Mal durch.
+
+8. `main-signal-cv.c`
+
+    1. Diese Version ist besser als die alte, da der Elternthread nicht mehr die CPU blockiert, während der Kindthread noch nicht fertig ist, sondern auf das Signal des Kinds wartet.
+
+    2. Da der alte Code korrekt ist, spielt nur die Effizienz des Codes eine Rolle. Natürlich ist die hier angegebene Lösung außerdem deutlich eleganter.
+
+9. helgrind meldet keine Fehler bei der korrigierten Version. Dies liegt daran, dass nun ein Lock um die Variable `done` gesetzt wird, wenn diese geschrieben wird.

hw8/simu1/main-race.c

@@ -7,7 +7,7 @@ pthread_mutex_t mut;
 
 void* worker(void* arg) {
     pthread_mutex_lock(&mut);
-    balance++; // unprotected access
+    balance++; // protected access
     pthread_mutex_unlock(&mut);
     return NULL;
 }

hw8/task1/Cargo.toml

@@ -4,3 +4,7 @@ version = "0.1.0"
 authors = ["Joshua Rutschmann <joshua.rutschmann@gmx.de>"]
 
 [dependencies]
+sha2 = "0.7.0"
+clap = {version = "~2.29.0", features = ["yaml"]}
+time = "0.1"
+sys-info = "*"

hw8/task1/README.md

@@ -117,7 +117,7 @@ Please wait ...
 Number: 567621 --> hash: b6bea2a40ed1bd6d9999b2232072092f3df0e02c4b507aa3ad947367b9712345
 ```
 
-Benutzen Sie für die Systeminformationen die externe [Crate sys-info](<>).
+Benutzen Sie für die Systeminformationen die externe [Crate sys-info][].
 
 ### Suchen mit mehreren Threads
 
@@ -130,7 +130,7 @@ Consumer" Lösung an. Viele Producer suchen nach dem Hash. Die zu untersuchende
 'Menge' an Zahlen muss dazu geeignet auf alle Threads verteilt werden. Der
 Producer, der ihn findet, sendet den Hash an den Consumer.  
 
-Die Rust Standardbibliothek bietet dafür die [MPSC]() Synchronisationsprimitive
+Die Rust Standardbibliothek bietet dafür die [MPSC][] Synchronisationsprimitive
 an. Einen ähnlichen Mechanismus haben Sie bereits mit der Pipe kennengelernt. 
 
 Findet einer der Producer das Ergebnis, so sendet er dies an den Consumer. Der

hw8/task1/src/cli.yml

@@ -0,0 +1,50 @@
+name: "task1"
+args:
+    - base:
+        value_name: "base"
+        help: "Sets the base to use"
+        takes_value: true
+        required: true
+
+    - difficulty:
+        value_name: "difficulty"
+        help: "Sets the difficulty to use"
+        takes_value: true
+        required: true
+         
+    - threads:
+        value_name: "threads"
+        help: "Sets the number of the threads to use (default = number of cpus)"
+        takes_value: true
+        required: false
+
+    - verbose:
+        short: "v"
+        help: "Prints help information"
+        multiple: true
+        required: false
+             
+    - sync:
+        short: "s"
+        long: "sync"
+        help: "enables sync when solution found"
+        required: false
+
+    - wait:
+        short: "w"
+        long: "wait"
+        help: "consumer waits for all producers"
+        required: false
+
+    - special:
+        long: "special"
+        value_name: "VALUE"
+        help: "sets special sync parameter"
+        takes_value: true
+
+subcommands:
+    - timings:
+        about: "controls timing features"
+        version: "1.0"
+        author: "Lorenz Bung & Joshua Rutschmann"
+

hw8/task1/src/lib.rs

@@ -1,7 +1,118 @@
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
+extern crate sha2;
+#[cfg(feature = "SHA2")]
+use self::sha2::Sha256;
+
+
+pub struct Sha256;
+
+pub trait Hasher {
+    type Output: HashResult;
+    fn hash(input: &[u8]) -> Self::Output;
+}
+
+pub trait HashResult {
+    /// Get the output in hex notation.
+    fn hex(&self) -> String;
+    /// Size of the output in bytes.
+    fn size() -> usize;
+}
+
+
+impl Hasher for Sha256 {
+    type Output = [u8; 32];
+
+    fn hash(input: &[u8]) -> Self::Output {
+        use self::sha2::*;
+        let mut tmp = Sha256::new();
+        tmp.input(input);
+        let r = tmp.result().as_slice().to_vec();
+        [
+            r[0],
+            r[1],
+            r[2],
+            r[3],
+            r[4],
+            r[5],
+            r[6],
+            r[7],
+            r[8],
+            r[9],
+            r[10],
+            r[11],
+            r[12],
+            r[13],
+            r[14],
+            r[15],
+            r[16],
+            r[17],
+            r[18],
+            r[19],
+            r[20],
+            r[21],
+            r[22],
+            r[23],
+            r[24],
+            r[25],
+            r[26],
+            r[27],
+            r[28],
+            r[29],
+            r[30],
+            r[31],
+        ]
+    }
+}
+
+impl HashResult for [u8; 32] {
+    fn hex(&self) -> String {
+        const HEX: [char; 16] = [
+            '0',
+            '1',
+            '2',
+            '3',
+            '4',
+            '5',
+            '6',
+            '7',
+            '8',
+            '9',
+            'a',
+            'b',
+            'c',
+            'd',
+            'e',
+            'f',
+        ];
+        let mut tmp = String::with_capacity(32 * 2);
+        for byte in self.iter() {
+            tmp.push(HEX[*byte as usize / 16]);
+            tmp.push(HEX[*byte as usize % 16]);
+        }
+        tmp
+    }
+
+    fn size() -> usize {
+        32
+    }
+}
+
+
+pub struct Solution {
+    pub number: usize,
+    pub hash: String,
+}
+
+pub fn verify_product(base: usize, number: usize, difficulty: &String) -> Option<Solution> {
+    let sol = base * number;
+    let input = sol.to_string();
+    let bytes = input.as_bytes();
+
+    let hash = Sha256::hash(bytes).hex();
+
+    if hash.ends_with(difficulty) {
+        return Some(Solution{ number: number, hash: hash,});
     }
+
+    None
 }
+

hw8/task1/src/main.rs

@@ -0,0 +1,109 @@
+#[macro_use]
+extern crate clap;
+extern crate time;
+extern crate task1;
+extern crate sys_info;
+
+use std::sync::mpsc::channel;
+use time::get_time;
+use clap::App;
+use std::{process, thread};
+use task1::verify_product;
+use std::sync::Arc;
+
+pub fn main() {
+    let yaml = load_yaml!("cli.yml");
+    let matches = App::from_yaml(yaml).get_matches();
+    let base = matches.value_of("base").unwrap_or("1");
+    let diff = Arc::new(matches.value_of("difficulty").unwrap_or("1").to_string());
+    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 verbosity = matches.occurrences_of("verbose"); 
+    
+    let mut time_measurement = false;
+    let mut found = false;
+
+    if diff.chars().any(|c| !c.is_digit(16)) {
+        println!("Difficulty is not hexadecimal.");
+        process::exit(1)
+    }
+
+    if let Some(ref sub_command) = matches.subcommand {
+        if sub_command.name.eq("timings") {
+            time_measurement = true;
+        }
+    }
+
+    if verbosity >= 1 {
+        println!("--------------------------------------------");
+        println!("Container: \"{}\"", sys_info::hostname().unwrap_or("-".to_string()));
+        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));
+        println!("Load Average  : {:?}", sys_info::loadavg().unwrap());
+        println!("Processes     : {}", sys_info::proc_total().unwrap_or(0));
+        println!("--------------------------------------------");
+    }
+
+    match (base.parse::<usize>(), threads.parse::<usize>()) {
+        (Ok(b), Ok(t)) => {
+            println!("Please wait...");
+
+            if verbosity >= 1 {
+                println!("Searching with {} threads", t);
+            }
+
+            let start = get_time();
+            let max = <usize>::max_value();
+            let mut children = vec![];
+
+            let (tx, 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 {
+
+                        if found && sync {
+                            process::exit(0);
+                        }
+
+                        if let Some(solution) = verify_product(b, n, &d) {
+                            found = sync;
+                            tx.send(solution).unwrap();
+                        }
+                        n += t;
+                    }
+
+                }));
+            }
+
+            match rx.recv() {
+                Ok(sol) => {
+                    let end = get_time();
+                    println!("Number: {} --> hash: {}", sol.number, sol.hash);
+                    if time_measurement {
+                        let diff = end - start;
+                        let s = diff.num_seconds();
+                        let ms = diff.num_milliseconds();
+                        let us = diff.num_microseconds().unwrap_or(ms * 1000);
+                        println!("(Duration {}s / {}ms / {}us)", s, ms, us);
+                    }
+                }
+                Err(_) => {}
+            }
+        }
+        (_, Err(_)) => {
+            println!("Number of threads is not integer.");
+            process::exit(1)
+        }
+        (Err(_), _) => {
+            println!("Base is not integer.");
+            process::exit(1)
+        }
+    };
+}

hw8/task1/src/unit_test.rs

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