[concurrency] Work on mutex

- Remove global variables from mutex example, use lambdas.

In order to not show using globals, I thought using lambdas to capture
local variables is cleaner.
I moved to C++17, since we say in the lecture now that people should
alwyas use scoped_lock.

I also return an exit status that captures whether or not there was a
race.

Author: hageboeck

code/race/Makefile

@@ -5,7 +5,7 @@ clean:
 	rm -f *o racing *~ core racing.sol
 
 racing : racing.cpp
-	${CXX} -g -std=c++11 -O0 -pthread -Wall -Wextra -L. -o $@ $<
+	${CXX} -g -std=c++17 -O0 -pthread -Wall -Wextra -L. -o $@ $<
 
 racing.sol : solution/racing.sol.cpp
-	${CXX} -g -std=c++11 -O0 -pthread -Wall -Wextra -L. -o $@ $<
+	${CXX} -g -std=c++17 -O0 -pthread -Wall -Wextra -L. -o $@ $<

code/race/racing.cpp

@@ -1,28 +1,38 @@
 #include <iostream>
 #include <thread>
 
-int a = 0;
-
-void inc() {
-  a++;
-}
-
-void inc100() {
-  for (int i = 0; i < 100; i++)
-    inc();
-}
+/*
+ * This program tries to increment an integer 200 times in two threads.
+ * Check whether the result is indeed always 200.
+ */
 
 int main() {
+  int nError = 0;
+
   for (int j = 0; j < 1000; j++) {
-    a = 0;
+    int a = 0;
+
+    // Increment the variable a 100 times:
+    auto inc100 = [&a](){
+      for (int i = 0; i < 100; ++i) {
+        a++;
+      }
+    };
+
+    // Run with two threads
     std::thread t1(inc100);
     std::thread t2(inc100);
-    for (auto t: {&t1,&t2}) t->join();
+    for (auto t : {&t1,&t2}) t->join();
+
+    // Check
     if (a != 200) {
-      std::cout << a;
+      std::cout << "Race: " << a << ' ';
+      nError++;
     } else {
       std::cout << '.';
     }
   }
   std::cout << '\n';
+
+  return nError;
 }

code/race/solution/racing.sol.cpp

@@ -2,30 +2,40 @@
 #include <thread>
 #include <mutex>
 
-int a = 0;
-std::mutex m;
-
-void inc() {
-  std::lock_guard<std::mutex> guard(m);
-  a++;
-}
-
-void inc100() {
-  for (int i = 0; i < 100; i++)
-    inc();
-}
+/*
+ * This program tries to increment an integer 200 times in two threads.
+ * We fix the race condition by locking a mutex before each increment.
+ */
 
 int main() {
+  int nError = 0;
+
   for (int j = 0; j < 1000; j++) {
-    a = 0;
+    int a = 0;
+    std::mutex aMutex;
+
+    // Increment the variable a 100 times:
+    auto inc100 = [&a,&aMutex](){
+      for (int i = 0; i < 100; ++i) {
+        std::scoped_lock lock{aMutex};
+        a++;
+      }
+    };
+
+    // Run with two threads
     std::thread t1(inc100);
     std::thread t2(inc100);
-    for (auto t: {&t1,&t2}) t->join();
+    for (auto t : {&t1,&t2}) t->join();
+
+    // Check
     if (a != 200) {
-      std::cout << a;
+      std::cout << "Race: " << a << ' ';
+      nError++;
     } else {
       std::cout << '.';
     }
   }
   std::cout << '\n';
+
+  return nError;
 }

talk/concurrency/mutexes.tex

@@ -92,7 +92,7 @@
   \pause
   \begin{block}{The objects}
     \begin{description}[labelwidth=1.8cm]
-    \item[std::mutex] in the mutex header
+    \item[std::mutex] in the mutex header. \textbf{Mut}ual \textbf{ex}clusion
     \item[std::scoped\_lock] RAII to lock and unlock automatically
     \item[std::unique\_lock] same, but can be released/relocked explicitly
     \end{description}
@@ -114,7 +114,7 @@
   \frametitlecpp[17]{Mutexes and Locks}
   \begin{block}{Good practice}
     \begin{itemize}
-      \item Always use \texttt{scoped\_lock} (\cpp11: \texttt{lock\_guard})
+      \item Generally use \texttt{scoped\_lock} (\cpp11: \texttt{lock\_guard})
       \item Hold as short as possible, wrap critical section in "\texttt{\string{  \string}}"
       \item Only if manual control needed, use \texttt{unique\_lock}
     \end{itemize}
@@ -133,7 +133,7 @@
 \end{frame}
 
 \begin{frame}[fragile]
-  \frametitle{Mutexes}
+  \frametitle{Mutexes and Locks}
   \begin{alertblock}{Exercise Time}
     \begin{itemize}
     \item Go to code/race
@@ -179,6 +179,7 @@
   \frametitlecpp[11]{How to avoid dead locks}
   \begin{block}{Possible solutions}
     \begin{itemize}
+    \item \cpp17: \mintinline{cpp}{std::scoped_lock lock{m1, m2};} comes with deadlock-avoidance algorithm
     \item Never take several locks
       \begin{itemize}
       \item Or add master lock protecting the locking phase