C++ Threads

• This is from Gregorie Chapter 27.
  • He points out parallel processing (SIMD/SPMD like) is one reason.
  • But also natural organization of tasks (MIMD like)
    • Compute in one thread and handle I/O in a second.
    • The I/O thread would not block, even if the computation took a long time.
• Threads as objects
  • The thread class provides a thread object.
  • This takes a function and parameters.
  • This is called a variadic function , or a function that can take a number of parameters.
  • This uses RAII
    • Resource Allocation Is Instantiation.
    • This is the idea behind a smart pointer.
    • The thread is created when the object is created.
    • The thread is destroyed when the object goes out of scope.
    • This includes all memory needed.
  • The join is a member function, which blocks until the thread is ready to be joined. IE Exited.
  • joinable returns a bool if the thread can be joined or not.
• Look at pi2.cpp and pi4.cpp
• He discusses problems with threads.
  • A race condition when two or more processes compete for a shared resource.
    • One race condition appears when we try to "lock" something without hardware support.

      • while (lock != 0) {
        } 
        lock = 1;
        critical do work
        lock = 0; 

      • This is sometimes called a spin lock.
      • Think of the assembly involved with this.

      • top:    load $R1, lock
                bne $R1 0 top
        
                addi $R1, $R0, 1
                store $R1, lock
        
                ...
                store $R0, lock 

      • But think about what could happen

      • lock       P1                   P2              Other Process
          1                                                store $R0, lock
          0        load $r1, lock
          0        beq $r1, top (not taken)
          0        addi $r1, $r0, 1 (enters critical area)
          0                                store $R1, lock
          0                                load $R1, lock   
          0                                beq $r1, top (not taken)
          1                                addi $R1, 1 (enters critical area)
          1        store $R1, lock
                          BOTH THREADS IN CRITICAL REGION.  

    • But can this really happen?
      • Consider threadTest.cpp.
      • rand_r is reentrant.
      • nanosleep is the current best sleep.
      • I am just trying to adjust for the time of the pthread_create call.
  • Deadlock
    • We briefly discussed this.
    • Two threads are deadlocked if they are both waiting on the other for a resource.
• Atomic variables
  • Making a variable atomic makes basic operations thread safe.
  • The read, math and write are equivalent to a single operation.
  • #include <atomic>
  • Declare atomic<type> varname{init}
  • varname.fetch_add(value) for doubles.
  • integers have far more operations.
  • Far more operations were added in c++23
  • play with pi5.cpp
• mutex or mutual exclusion
  • Some form of shared variable with atomic operations.
• C++ has a mutex class..
  • lock, blocking lock
  • try_lock
    • if it returns true, you have the lock.
    • If it returns false, no lock
  • unlock , make sure you do this.
  • See pi3a.cpp
• C++ also has a lock healper function.
• Which is used by lock_guard class.
  • RIAA
  • See pi3.cpp.