Merge remote-tracking branch 'origin/hw7' into hw7

hw7/simu1/ANSWERS.md

 
 Hier wird der Lock durch das Vertauschen des Wertes in `mutex` mit dem Register `ax` gesetzt. Aufgehoben wird der Lock, in dem eine `0` in die Mutex-Variable (`mutex`) geschrieben wird.
 
-1. Das Programm liefert nun immer den erwarteten Wert. Sowohl mit `./x86.py -p test-and-set.s -M mutex,count -R ax,bx -i 1 -a ax=40:bx=40,ax=40:bx=40` als auch mit nur `-i 1000` steht am Ende der Wert `80` in `count`.
+1. Das Programm liefert nun immer den erwarteten Wert. Sowohl mit `./x86.py -p test-and-set.s -M mutex,count -R ax,bx -i 1 -a bx=40,bx=40` als auch mit nur `-i 1000` steht am Ende der Wert `80` in `count`.
 
-2. Die mit der Flag `-P` ausgeführten Tests laufen fehlerfrei. Beispielsweise liefern `./x86.py -p test-and-set.s -M mutex,count -R ax,bx -a ax=5:bx=5,ax=5:bx=5 -P 0011` und `./x86.py -p test-and-set.s -M mutex,count -R ax,bx -a ax=5:bx=5,ax=5:bx=5 -P 001000000000001` beide das erwartete Ergebnis (`10`).
+### `peterson.s`
+
+1. Trotz unterschiedlicher Interruptfrequenzen (`-i 1`, `-i 5`, `-i 10`, `-i 20`...) funktioniert der Code fehlerfrei.
+
+2. Mit beispielsweise `./x86.py -p peterson.s -M count,flag,turn -R ax,bx,cx,fx -a ax=5:bx=0,ax=5:bx=1 -P 11111111000000001000111111111111111` lassen sich mögliche Race Conditions ausschließen, da zwischen dem Testen auf einen Wert und dem zugehörigen Sprung jeweils ein Interrupt stattfindet. Das Endergebnis bleibt davon jedoch unbeeinflusst, was auf fehlerfreien Code schließen lässt.
+
+### `ticket.s`
+
+1. Die Wartezeit der Threads ist abhängig von der Interrupt-Häufigkeit. Wenn nur selten ein Interrupt stattfindet, beispielsweise mit `-i 10000`, hängen die einzelnen Threads sehr lange in der `.aquire`-Schleife fest.
+
+2. Eine größere Threadzahl macht im Gegensatz zur Interrupthäufigkeit keinen Unterschied. Die einzelnen Threads warten zwar dennoch länger, das liegt jedoch daran, dass mehr Tickets vergeben wurden und somit die Wartezeit auch höher ist.
+
+### `yield.s`
+
+1. Beim Aufruf von `./x86.py -p test-and-set.s -M mutex,count -R ax,bx -a ax=5:bx=5,ax=5:bx=5` bzw. `./x86.py -p yield.s -M mutex,count -R ax,bx -a ax=5:bx=5,ax=5:bx=5` ist der Unterschied deutlich zu merken. Der zweite Thread hängt in `test-and-set.s` in einer Schleife beim holen des Locks, und loopt bis zum nächsten Interrupt. `yield.s` tut hier was es soll, und spart somit ca. 50 Zyklen (bzw. etwas weniger als die Interruptrate). Die Einsparung von Zyklen tritt immer dann auf, wenn Thread 1 den Lock hat, dann ein Interrupt kommt und Thread 2 auf den Lock warten muss. Mit `test-and-set.s` wird in diesem Fall ewig geloopt, mit `yield.s` wird die CPU direkt wieder für den ersten Thread freigegeben.
+
+### `test-and-test-and-set.s`
+
+1. Dieser Lock tut dasselbe wie in `test-and-set.s`, nur wird beim holen des Locks ein zweiter Test durchgeführt.
+
+2. Im Vergleich mit `test-and-set.s` muss mit dieser Konfiguration kein atomarer Tausch der Werte in `%ax` und `mutex` ausgeführt werden, wenn der mutex nicht sowieso frei ist. Nur wenn der mutex auch verfügbar ist, wird dieser Tausch durchgeführt.

hw7/task1/src/hash256.rs

 use hasher_sha256::{Hasher, HashResult};
 use hasher_sha256::Sha256;
 
-
+/// Dieser Datentyp beschreibt die Lösung des Hashverfahrens.
 pub struct Solution {
     pub number: usize,
     pub hash: String,
 }
 
+/// `verify_product` dient der Verifikation eines gefundenen Hashes.
 pub fn verify_product(base: usize, number: usize, difficulty: &String) -> Option<Solution> {
     let sol = base * number;
     let input = sol.to_string();

hw7/task1/src/main.rs

 mod hasher_sha256;
 mod hash256;
 
+/// Hauptfunktion zum Starten des Hashers.
 pub fn main() {
     let matches = create_app().get_matches();
     let base = matches.value_of("base").unwrap_or("1");
     };
 }
 
+/// Diese Funktion dient der Konfiguration der App mit dem Paket **Clap**.
 fn create_app<'a, 'b>() -> App<'a, 'b> {
     App::new("Hash256")
         .version("1.0")

hw7/task2/src/errortype.rs

+/// Dieser Datentyp beschreibt die in der Shell auftretenden Fehler.
+#[derive(Debug, PartialEq)]
+pub enum ErrorType {
+    PathError,
+    BrokenPipeError,
+    ForkError,
+}

hw7/task2/src/lib.rs

 use std::io::{BufRead, Write};
 use std::str::FromStr;
 use std::env;
-use std::str::Split;
-use std::os::unix::io::RawFd;
 use std::ffi::{OsString, CString};
 use nix::unistd::ForkResult::{Child, Parent};
-use nix::sys::wait::{wait, WaitStatus};
-use nix::unistd::dup2;
-use nix::unistd::close;
-use nix::unistd::{execvp, fork, pipe, read, write};
+use nix::sys::wait::wait;
+use nix::unistd::{dup2, close, execvp, fork, pipe};
 
-mod shellerror;
+mod errortype;
 
-use shellerror::ShellError;
+use errortype::ErrorType;
 
 #[derive(PartialEq, Debug)]
 pub enum Command {
 }
 
 impl FromStr for Command {
-    type Err = ShellError;
+    type Err = ErrorType;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
 
         let mut parts = s.split_whitespace();
     }
     /// Initializes the Shell Loop.
     /// Starts the shell.
-    pub fn start(&mut self) -> Result<(), &str> {
+    pub fn start(&mut self) -> Result<(), ErrorType> {
         self.shell_loop()
     }
 
     /// Loops while exit hasn't been called.
     /// When *prompt()* returns (the user hit enter) a Command is created through the FromStr-Trait.
     /// If the Command-creation succeeds, run the command.
-    fn shell_loop(&mut self) -> Result<(), &str> {
+    fn shell_loop(&mut self) -> Result<(), ErrorType> {
         while !self.should_exit {
             if let Ok(Some(line)) = self.prompt() {
                 let _ = Command::from_str(&line).and_then(|cmd| self.run(cmd));
 
     /// Prints the shell prompt.
     /// Waits for user input and returns the read line.
-    pub fn prompt(&mut self) -> Result<Option<String>, &str> {
+    pub fn prompt(&mut self) -> Result<Option<String>, ErrorType> {
         match env::current_dir() {
             Ok(pwd) => {
                 let _ = self.writer.write(
                     Err(_) => Ok(None),
                 }
             }
-            Err(_) => return Err("Path Error"),
+            Err(_) => return Err(ErrorType::PathError),
         }
     }
 
     /// Runs a command.
     /// Currently only `cd` and `exit` are working.
-    fn run(&mut self, command: Command) -> Result<(), ShellError> {
+    fn run(&mut self, command: Command) -> Result<(), ErrorType> {
 
         match command {
             Command::Empty => {},
             Command::Program(cmd) => {
 
-                let mut commands = cmd.split('|');
+                let commands = cmd.split('|');
                 let commands_vec: Vec<&str> = commands.collect();
-                
+
                 let needs_pipe = commands_vec.len() == 2;
 
-                if let Ok((reader, writer)) = pipe() {
 
                     let fi = fork();
                     match fi {
-                        Ok(Parent { .. }) => {
-                            wait();
-                        }
-                        Ok(Child) => {
-                            if let Some(first) = commands_vec.get(0) {
-                                if needs_pipe {
-                                    close(reader).unwrap();
-                                    dup2(writer, 1).unwrap();
-                                }
-                                self.execute(first);
-                            }
-                        }
-                        Err(_) => println!("Fatal error: Fork failed"),
-                    }
-
+                        Ok(Parent { child: _child }) => {
+                            let _ = wait();
 
-                    let sec = fork();
-                    match sec {
-                        Ok(Parent { .. }) => {
-                            wait();
                         }
                         Ok(Child) => {
-                            if let Some(second) = commands_vec.get(1) {
-                                close(1).unwrap();
-                                close(writer).unwrap();
-                                dup2(reader, 0).unwrap();
-                                self.execute(second);
+                            if let Ok((reader, writer)) = pipe() {
+                                let sec = fork();
+                                match sec {
+                                    Ok(Parent { child: _child }) => {
+                                        let _ = wait();
+                                        if let Some(second) = commands_vec.get(1) {
+                                            match close(writer) {
+                                                Ok(_) => {},
+                                                Err(_) => return Err(ErrorType::BrokenPipeError),
+                                            }
+                                            dup2(reader, 0).unwrap();
+                                            self.execute(second);
+                                        }
+                                    }
+                                    Ok(Child) => {
+                                        if let Some(first) = commands_vec.get(0) {
+                                            if needs_pipe {
+                                                close(reader).unwrap();
+                                                dup2(writer, 1).unwrap();
+                                            }
+                                            self.execute(first);
+                                        }
+                                    }
+                                    Err(_) => return Err(ErrorType::ForkError),
+                                }
                             }
                         }
-                        Err(_) => println!("Fatal error: Fork failed"),
+                        Err(_) => return Err(ErrorType::ForkError),
                     }
 
-                }
-
             },
             Command::Exit => self.should_exit = true,
             Command::Cd(_) => {
     }
 
     fn execute(&self, cmd: &str){
-        let mut parts:Vec<&str> = cmd.split_whitespace().collect();
+        let parts:Vec<&str> = cmd.split_whitespace().collect();
         let args:Vec<CString> = parts.iter().map(|f| CString::new(*f).unwrap()).collect();
         let t = args.into_boxed_slice();
 
-        execvp(&t[0], &t);
+        execvp(&t[0], &t).unwrap();
     }
 }
 

hw7/task2/src/main.rs

 use std::io;
 use task2::Shell;
 
+
+/// Diese Funktion startet die Shell durch Aufruf
+/// von `Shell::new()`.
 fn main() {
     let stdin = io::stdin();
     let stdout = io::stdout();
 
     let mut s = Shell::new(stdin.lock(), stdout.lock(), "schell".to_string());
+    // Kontrolliertes bzw. unkontrolliertes Beenden der Shell
     match s.start() {
         Ok(_) => process::exit(0),
         Err(_) => process::exit(1),

hw7/task2/src/shellerror.rs

-#[derive(PartialEq, Debug)]
-pub struct ShellError;