atoms/rwmutex.hh

Go to the documentation of this file.

#ifndef ATOMS_RWMUTEX_HH
#define ATOMS_RWMUTEX_HH

#include <atoms/gen.hh>
#include <pthread.h>
#ifndef PTHREAD_RWLOCK_INITIALIZER
#include <boost/static_assert.hpp>
#include <boost/integer_traits.hpp>
#include <atoms/mutex.hh>
#include <atoms/thread.hh> // for Condition
#endif

namespace atoms {

class RWMutex : boost::noncopyable {
public:
    RWMutex() :
#ifdef PTHREAD_RWLOCK_INITIALIZER
        me(PTHREAD_RWLOCK_INITIALIZER)
#else
        active(0), numBlockedWriters(0)
#endif
        {}

    class ReadMon : public Monitor {
    public:
        ReadMon(RWMutex &m);
        ~ReadMon();
    private:
        RWMutex &m;
    };

    class WriteMon : public Monitor {
    public:
        WriteMon(RWMutex &m);
        ~WriteMon();
    private:
        RWMutex &m;
    };
private:
#ifdef PTHREAD_RWLOCK_INITIALIZER
    pthread_rwlock_t me;
#else
    const static unsigned short MAX_ACTIVE_READERS = 16;
    Mutex m;
    unsigned short active;
    unsigned short numBlockedWriters;
    Condition writerCondition;
    Condition readerCondition;
#endif
};

#ifdef PTHREAD_RWLOCK_INITIALIZER
RWMutex::ReadMon::ReadMon(RWMutex &m) : m(m) {
    int retval = pthread_rwlock_rdlock(&mm.me);
    assert(retval == 0);
}

RWMutex::ReadMon::~ReadMon() {
    int retval = pthread_rwlock_unlock(&mm.me);
    assert(retval == 0);
}

RWMutex::WriteMon::WriteMon(RWMutex &m) : m(m) {
    int retval = pthread_rwlock_wrlock(&&m.me);
    assert(retval == 0);
}

RWMutex::WriteMon::~WriteMon() {
    int retval = pthread_rwlock_unlock(&mm.me);
    assert(retval == 0);
}
#else 
inline RWMutex::ReadMon::ReadMon(RWMutex &m) : m(m) {
    Mutex::Mon mm(m.m);
    while (m.active == MAX_ACTIVE_READERS || m.numBlockedWriters > 0) {
        m.readerCondition.wait(mm);
    }
    m.active++;
}

inline RWMutex::ReadMon::~ReadMon() {
    Mutex::Mon mm(m.m);
    assert(m.active > 0);
    if (m.numBlockedWriters > 0) {
        m.writerCondition.signal();
    } else if (m.active-- == MAX_ACTIVE_READERS) {
        m.readerCondition.signal();
    }
}

inline RWMutex::WriteMon::WriteMon(RWMutex &m) : m(m) {
    Mutex::Mon mm(m.m);
    while (m.active > 0) {
        if (++m.numBlockedWriters == 0) {
            // Wrapped; too many writers.
            abort();
        }
        try {
            m.writerCondition.wait(mm);
        } catch (...) {
            if (--m.numBlockedWriters == 0) {
                m.readerCondition.broadcast();
            }
            throw;
        }
        m.numBlockedWriters--;
    }
    m.active = MAX_ACTIVE_READERS;
}

inline RWMutex::WriteMon::~WriteMon() {
    Mutex::Mon mm(m.m);
    assert(m.active == MAX_ACTIVE_READERS);
    m.active = 0;
    if (m.numBlockedWriters > 0) {
        m.writerCondition.signal();
    } else {
        m.readerCondition.broadcast();
    }
}
#endif 

} // namespace atoms

#endif // !ATOMS_RWMUTEX_HH

---