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

hw8/simu1/ANSWERS.md

@@ -32,28 +32,37 @@
 
 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. Blah
+5. `main-deadlock-global.c`
 
-    1.
+    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.
+    2. Beim Ausführen des Programms treten keine Fehler auf.
 
-    3.
+    3. helgrind sollte eigentlich keinen Fehler melden, da der globale Lock einen Deadlock verhindert.
 
-    4.
+    4. Da helgrind den Fehler dennoch erkennt, ist es ein sehr nützliches Werkzeug um Lockfehler zu erkennen.
 
-6.
+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. Blah
+7.
 
-    1.
+    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.
+    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. Blah
+8. `main-signal-cv.c`
 
-    1.
+    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.
+    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.
+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

@@ -3,16 +3,21 @@
 #include "mythreads.h"
 
 int balance = 0;
+pthread_mutex_t mut;
 
 void* worker(void* arg) {
-    //balance++; // unprotected access
+    pthread_mutex_lock(&mut);
+    balance++; // protected access
+    pthread_mutex_unlock(&mut);
     return NULL;
 }
 
 int main(int argc, char *argv[]) {
     pthread_t p;
     Pthread_create(&p, NULL, worker, NULL);
+    pthread_mutex_lock(&mut);
     balance++; // unprotected access
+    pthread_mutex_unlock(&mut);
     Pthread_join(p, NULL);
     return 0;
 }