main.cpp

Go to the documentation of this file.

#include <iostream>             // std::cout
#include <thread>               // std::thread
#include <mutex>                // std::mutex, std::adopt_lock, std::unique_lock
#include <chrono>               // std::chrono
#include <condition_variable>   // std::condition_variable
#include <random>               // std::default_random_generator

#include "LockGuard.h"          // chal::LockGuard

#define NUM_THDS 3              // number of threads to execute


// Globals
std::mutex mtx;                 // shared mutex
std::condition_variable cond;   // shared condition variable
bool DEBUG = false;             // turn on debug messages



void debugPrinter(int id, std::string msg) {
    
    std::cerr << "***\tDEBUG from" << id+1 << ": " 
              << msg << "\t***" << std::endl;
}

void debugPrinter(int id, int next_thd) {
    
    std::cerr << "***\tDEBUG from" << id+1 << ": " 
              << " next: " << next_thd << "\t***" << std::endl;
}

void debugPrinter(int id, std::string msg, int next_thd) {
    
    std::cerr << "***\tDEBUG from" << id+1 << ": " 
              << msg << " next: " << next_thd << "\t***" << std::endl;
}



void thd_printer(int id, std::string msg) {
    //bool DEBUG = true;

    if(DEBUG) 
        debugPrinter(id, "made it to thd_printer");

    //mtx.lock();
    if(DEBUG) 
        debugPrinter(id, "made it to mtx.lock");
    
    //chal::LockGuard<std::mutex> lck (mtx, std::adopt_lock);
    if(DEBUG)
        debugPrinter(id, "made it to LockGuard");
    
    std::cout << "thread" << id+1 << ": " << msg << std::endl;
}


void thd_worker (const int id, int &next_thd, std::default_random_engine &rand_e) {
    //bool DEBUG = true;
    
    if(DEBUG) 
        debugPrinter(id, next_thd);

    int wait_tm; 

    thd_printer(id, "starting, waiting.");

    // repeat forever
    while(1) {
    
        // lock mutex
        if(DEBUG) 
            debugPrinter(id, "ABOUT TO LOCK", next_thd);
        mtx.lock();
        std::unique_lock<std::mutex> locker (mtx, std::adopt_lock);
        
        // wait for condition signal
        // Upon condition signal, check if current thread is next
        // if yes continue, if not keep waiting
        // lambda function creates condition predicate 
        if(DEBUG) 
            debugPrinter(id, "made it to cond.wait");   
        cond.wait(locker, [&]() { return id == next_thd; }); // lambda
        if(DEBUG) 
            debugPrinter(id, "made it past cond.wait");   

        thd_printer(id, "signal received, doing work ....");

        // generate pseudo-random value between 1 and 5 seconds
        wait_tm = 1 + rand_e() % 5; 
         
        // sleep to simulate work
        if(DEBUG) 
            debugPrinter(id, "sleeping for:", wait_tm);
        std::this_thread::sleep_for(std::chrono::seconds(wait_tm));

        thd_printer(id, "done with work, signal next thread");
        if(DEBUG) 
            debugPrinter(id, "returned from thd_printer");

        // if topmost thread, reset next_thd
        if(next_thd == NUM_THDS-1) 
            next_thd = 0;
        else
            ++next_thd; // otherwise, just increment 

        if(DEBUG) 
            debugPrinter(id, "ABOUT TO NOTIFY", next_thd);
        cond.notify_all();  // restart sequence
    }
}



int main () {
    //bool DEBUG = true;
    int id = -1; // identifier to pass to Debug Printer

    std::thread threads[NUM_THDS]; 
    int next_thd = -1; // prevent a spurious wake from prematurely activating thread 0

    std::default_random_engine rand_e; 
   
    std::cout << "main: starting all threads" << std::endl;

    // spawn NUM_THDS threads:
    for (int i=0; i<NUM_THDS; ++i) {
        
        if(DEBUG) 
            debugPrinter(id, "main for loop #");

        // populate the array of thread objects
        // pass in: * their unique ID by value
        //          * an integer to keep track of thread order by reference
        //          * a shared psuedo-random number generator by reference
        threads[i] = std::thread(thd_worker, i, std::ref(next_thd), std::ref(rand_e));
    }

    std::this_thread::sleep_for(std::chrono::seconds(3));

    if(DEBUG) 
        debugPrinter(id, "waited three seconds");

    cond.notify_all();  // start sequence
    next_thd = 0;       // allow thread 0 to be activated

    if(DEBUG) 
        debugPrinter(id, "main join for starting");

    // clean up
    for ( auto& th : threads ) {
        th.join();
        
        if(DEBUG) { 
            debugPrinter(id, "an instance of main for join loop");
        }
    }

    return 0;
}