multiple-readers, single-writer locks in OpenMP

Question

There is an object shared by multiple threads to read from and write to, and I need to implement the class with a reader-writer lock which has the following functions:

• It might be declared occupied by one and no more than one thread. Any other threads that try to occupy it will be rejected, and continue to do their works rather than be blocked.
• Any of the threads are allowed to ask whether the object is occupied by self or by others at any time, except for the time when it is being declared occupied or released.
• Only the owner of the object is allowed to release its ownership, though others might try to do it as well. If it is not the owner, the releasing operation will be canceled.
• The performance needs to be carefully considered.

I'm doing the work with OpenMP, so I hope to implement the lock using only the APIs within OpenMP, rather than POSIX, or so on. I have read this answer, but there are only solutions for implementations of C++ standard library. As mixing OpenMP with C++ standard library or POSIX thread model may slow down the program, I wonder is there a good solution for OpenMP?

I have tried like this, sometimes it worked fine but sometimes it crashed, and sometimes it was dead locked. I find it hard to debug as well.

class Element
{
  public:
    typedef int8_t label_t;
    Element() : occupied_(-1) {}

    // Set it occupied by thread @myThread.
    // Return whether it is set successfully.
    bool setOccupiedBy(const int myThread)
    {
        if (lock_.try_lock())
        {
            if (occupied_ == -1)
            {
                occupied_ = myThread;
                ready_.set(true);
            }
        }
        // assert(lock_.get() && ready_.get());
        return occupied_ == myThread;
    }

    // Return whether it is occupied by other threads
    // except for thread @myThread.
    bool isOccupiedByOthers(const int myThread) const
    {
        bool value = true;
        while (lock_.get() != ready_.get());
        value = occupied_ != -1 && occupied_ != myThread;
        return value;
    }

    // Return whether it is occupied by thread @myThread.
    bool isOccupiedBySelf(const int myThread) const
    {
        bool value = true;
        while (lock_.get() != ready_.get());
        value = occupied_ == myThread;
        return value;
    }

    // Clear its occupying mark by thread @myThread.
    void clearOccupied(const int myThread)
    {
        while (true)
        {
            bool ready = ready_.get();
            bool lock = lock_.get();
            if (!ready && !lock)
                return;
            if (ready && lock)
                break;
        }
        label_t occupied = occupied_;
        if (occupied == myThread)
        {
            ready_.set(false);
            occupied_ = -1;
            lock_.unlock();
        }
        // assert(ready_.get() == lock_.get());
    }

 protected:
    Atomic<label_t> occupied_;

    // Locked means it is occupied by one of the threads,
    // and one of the threads might be modifying the ownership
    MutexLock lock_;

    // Ready means it is occupied by one the the threads,
    // and none of the threads is modifying the ownership.
    Mutex ready_;
};

The atomic variable, mutex, and the mutex lock is implemented with OpenMP instructions as following:

template <typename T>
class Atomic
{
  public:
    Atomic() {}
    Atomic(T&& value) : mutex_(value) {}

    T set(const T& value)
    {
        T oldValue;
#pragma omp atomic capture
        {
            oldValue = mutex_;
            mutex_ = value;
        }
        return oldValue;
    }
    T get() const
    {
        T value;
#pragma omp read
        value = mutex_;
        return value;
    }
    operator T() const { return get(); }
    Atomic& operator=(const T& value)
    {
        set(value);
        return *this;
    }
    bool operator==(const T& value) { return get() == value; }
    bool operator!=(const T& value) { return get() != value; }

  protected:
    volatile T mutex_;
};

class Mutex : public Atomic<bool>
{
  public:
    Mutex() : Atomic<bool>(false) {}
};

class MutexLock : private Mutex
{
  public:
    void lock()
    {
        bool oldMutex = false;
        while (oldMutex = set(true), oldMutex == true) {}
    }
    void unlock() { set(false); }
    bool try_lock()
    {
        bool oldMutex = set(true);
        return oldMutex == false;
    }
    using Mutex::operator bool;
    using Mutex::get;
};

I also use the lock provided by OpenMP in alternative:

class OmpLock
{
  public:
    OmpLock() { omp_init_lock(&lock_); }
    ~OmpLock() { omp_destroy_lock(&lock_); }

    void lock() { omp_set_lock(&lock_); }
    void unlock() { omp_unset_lock(&lock_); }
    int try_lock() { return omp_test_lock(&lock_); }

  private:
    omp_lock_t lock_;
};

By the way, I use gcc 4.9.4 and OpenMP 4.0, on x86_64 GNU/Linux.