Question

I wrote a code to implement spin lock and mutex lock.
There is an interesting but. A magic cout can keep my program alive. If I remove the cout, my program will be sleeping forever. (This only happens in Linux. Windows is doing fine)
Any one have a clue?

#include <pthread.h>
#include <iostream>
#include <queue>
#include <sys/time.h>
#include <stdexcept>
#include <cstdio>
#include <cstdlib>
using namespace std;

#define Tcount 10
#define TheLock MutexLock

static inline int TAS(volatile int * ptr) {
    unsigned long result;
    asm volatile("lock;"
                "xchgl %0, %1;"
                : "=r"(result), "=m"(*ptr)
                : "0"(1), "m"(*ptr)
                : "memory");
    return result;
}




class SpinLock {
private:
    int lock;
    pthread_t owner;
public:

    SpinLock() {
        lock = 0;
    }

    void getLock() {
        while (TAS(&lock) == 1) {

        }

        owner = pthread_self();

    }

    void releaseLock() {
        if (lock == 0) {
            cout << "Spin no lock" << endl;
            return;
        } else if (owner == pthread_self()) {
            owner = NULL;
            lock = 0;
        } else {
            throw runtime_error("Spin can't release");
        }
    }


};

class MutexLock {
private:
    int lock;
    pthread_t owner;
    queue<pthread_t> q;
    SpinLock qLock;
public:

    MutexLock() {
        lock = 0;
    }

    void getLock(int id) {
        pthread_t self = pthread_self();
    cout<<"a"<<endl;// magic cout

        if (TAS(&lock) == 0) {
            owner = self;
            return;
        }
        qLock.getLock();
        q.push(self);
        qLock.releaseLock();

        while (owner != self) { 
        }

    }

    void releaseLock(int id) {
        if (lock == 0) {
            cout << "Mutex no lock" << endl;
            return;
        } else if (owner == pthread_self()) {
            qLock.getLock();
            if (q.empty()) {
                owner = NULL;
                lock = 0;
            } else {
        owner = q.front();
                q.pop();        
            }
            qLock.releaseLock();
        } else {
                throw runtime_error("Mutex can't release");
        }
    }
};

TheLock lock;
int g = 0;
void* run(void* pt) {

    int id = (int) pt;
    for (int i = 0; i < 10000; i++) {

        lock.getLock(id);
        //cout<<"Thread "<<id<<" get lock, g="<<g<<endl;
        int next = g + 1;
        g = next;
        //cout<<"Thread "<<id<<" release lock, g="<<g<<endl;
        lock.releaseLock(id);


    }

    return NULL;

}

int main() {

    pthread_t th[Tcount];

    long mtime, seconds, useconds;
    struct timeval start, end;
    gettimeofday(&start, NULL);

    for (int i = 0; i < Tcount; i++) {
        pthread_create(&th[i], NULL, run, (void*) (i+10));
    }
    for (int i = 0; i < Tcount; i++) {
        pthread_join(th[i], 0);
    }
    gettimeofday(&end, NULL);

    seconds = end.tv_sec - start.tv_sec;
    useconds = end.tv_usec - start.tv_usec;

    mtime = ((seconds) * 1000000 + useconds);

    cout << "g=" << g << endl;
    cout << "time=" << mtime << endl;



    return 0;
}

Answer 1

You cannot implement a mutex by using the volatile keyword as the operations may not be atomic. This means that the OS might switch to a different thread before the operation has completed.

For mutex you have to use the OS. It is the only thing that knows when threads are being switched.