Barrier Synchronization between 2 process using mutex

Question

I need to implement barrier synchronization between 2 threads using mutex (only). Barrier synchronization is that 2 threads will wait for each other to meet at predefined step before proceeding.

I am able to do it using seamaphore but how can I achieve this only using mutex . I was given a hint that I need 2 mutex not 1 to do this.

Using Seamaphore:

#include <pthread.h>
#include <semaphore.h>
using namespace std;

sem_t s1;
sem_t s2;


void* fun1(void* i)
{
    cout << "fun1 stage 1" << endl;
    cout << "fun1 stage 2" << endl;
    cout << "fun1 stage 3" << endl;
    sem_post (&s1);
    sem_wait (&s2);
    cout << "fun1 stage 4" << endl;
}

void* fun2(void* i)
{
    cout << "fun2 stage 1" << endl;
    cout << "fun2 stage 2" << endl;
//    sleep(5);
    sem_post (&s2);
    sem_wait (&s1);
    cout << "fun2 stage 3" << endl;
}

main()
{
    sem_init(&s1, 0, 0);
    sem_init(&s2, 0, 0);
    int value; 
    sem_getvalue(&s2, &value);
    cout << "s2 = " << value << endl;

    pthread_t iThreadId;

    cout << pthread_create(&iThreadId, NULL, &fun2, NULL) << endl;
//    cout << pthread_create(&iThreadId, NULL, &fun2, NULL) << endl;
    pthread_create(&iThreadId, NULL, &fun1, NULL);
    sleep(10);
}

Compile the above code as "g++ barrier.cc -lpthread"

Answer 1

How about NO MUTEXES and no locks? Using ATOMIC OPERATIONS only:

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <signal.h>

static sigset_t _fSigSet;
static volatile int _cMax=20, _cWait = 0;
static pthread_t    _aThread[1000];

void * thread(void *idIn)
{
int nSig, iThread, cWait, id = (int)idIn;

    printf("Start %d\n", id, cWait, _cMax);
    // do some fake weork
    nanosleep(&(struct timespec){0, 500000000}, NULL);
    // barrier
    cWait = __sync_add_and_fetch(&_cWait, 1);
    printf("Middle %d, %d/%d Waiting\n", id, cWait, _cMax);
    if (cWait < _cMax)
    {        
        // if we are not the last thread, sleep on signal
        sigwait(&_fSigSet, &nSig); // sleepytime
    }
    else
    {
        // if we are the last thread, don't sleep and wake everyone else up
        for (iThread = 0; iThread < _cMax; ++iThread)
            if (iThread != id)
                pthread_kill(_aThread[iThread], SIGUSR1);
    }

    // watch em wake up    
    cWait = __sync_add_and_fetch(&_cWait, -1);
    printf("End %d, %d/%d Active\n", id, cWait, _cMax);

    return 0;
}

int main(int argc, char** argv)
{
    pthread_attr_t attr;
    int i, err;

    sigemptyset(&_fSigSet);
    sigaddset(&_fSigSet, SIGUSR1);
    sigaddset(&_fSigSet, SIGSEGV);

    printf("Start\n");
    pthread_attr_init(&attr);
    if ((err = pthread_attr_setstacksize(&attr, 16384)) != 0)
    {
        printf("pthread_attr_setstacksize failed: err: %d %s\n", err, strerror(err));
        exit(0);
    }

    for (i = 0; i < _cMax; i++)
    {
        if ((err = pthread_create(&_aThread[i], &attr, thread, (void*)i)) != 0)
        {
            printf("pthread_create failed on thread %d, error code: %d %s\n", i, err, strerror(err));
            exit(0);
        }
    }

    for (i = 0; i < _cMax; ++i)
        pthread_join(_aThread[i], NULL);

    printf("\nDone.\n");
    return 0;
}

Answer 2

I am not sure that you need two mutexes, with one mutex and a condition variable and an extra flag might be enough. The idea is that you enter the critical section by acquiring the mutex, then you check whether you are the first thread to come, if so, you wait on the condition. If you are the second thread coming then you wake up the waiting thread and both leave.