mutex.hpp

Go to the documentation of this file.

#pragma once
#include <common.hpp>
#include <pthread.h>
 
 
namespace rack {
 

struct SharedMutex {
    pthread_rwlock_t rwlock;
 
    SharedMutex() {
        int err = pthread_rwlock_init(&rwlock, NULL);
        (void) err;
        assert(!err);
    }
    SharedMutex() {…}
    ~SharedMutex() {
        pthread_rwlock_destroy(&rwlock);
    }
    ~SharedMutex() {…}
 
    void lock() {
        int err = pthread_rwlock_wrlock(&rwlock);
        (void) err;
        assert(!err);
    }
    void lock() {…}

    bool try_lock() {
        return pthread_rwlock_trywrlock(&rwlock) == 0;
    }
    bool try_lock() {…}
    void unlock() {
        int err = pthread_rwlock_unlock(&rwlock);
        (void) err;
        assert(!err);
    }
    void unlock() {…}
 
    void lock_shared() {
        int err = pthread_rwlock_rdlock(&rwlock);
        (void) err;
        assert(!err);
    }
    void lock_shared() {…}

    bool try_lock_shared() {
        return pthread_rwlock_tryrdlock(&rwlock) == 0;
    }
    bool try_lock_shared() {…}
    void unlock_shared() {
        unlock();
    }
    void unlock_shared() {…}
};
struct SharedMutex {…};
 
 
template <class TMutex>
struct SharedLock {
    TMutex& m;
 
    SharedLock(TMutex& m) : m(m) {
        m.lock_shared();
    }
    SharedLock(TMutex& m) : m(m) {…}
    ~SharedLock() {
        m.unlock_shared();
    }
    ~SharedLock() {…}
};
struct SharedLock {…};
 
 
} // namespace rack