readwrite_mutex.h

Go to the documentation of this file.

// Copyright (C) 2020 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef READWRITE_MUTEX_H
#define READWRITE_MUTEX_H


#include <exceptions/exceptions.h>
#include <boost/noncopyable.hpp>
#include <climits>
#include <condition_variable>
#include <mutex>

namespace isc {
namespace util {

class ReadWriteMutex : public boost::noncopyable {
public:


    static const unsigned WRITE_ENTERED =
        1U << (sizeof(unsigned) * CHAR_BIT - 1);

    static const unsigned MAX_READERS = ~WRITE_ENTERED;

    ReadWriteMutex() : state_(0) {
    }

    virtual ~ReadWriteMutex() {
        std::lock_guard<std::mutex> lk(mutex_);
    }

    void writeLock() {
        std::unique_lock<std::mutex> lk(mutex_);
        // Wait until the write entered flag can be set.
        gate1_.wait(lk, [=]() { return (!writeEntered()); });
        state_ |= WRITE_ENTERED;
        // Wait until there are no more readers.
        gate2_.wait(lk, [=]() { return (readers() == 0); });
    }

    void writeUnlock() {
        std::lock_guard<std::mutex> lk(mutex_);
        state_ = 0;
        // Wake-up waiting threads when exiting the guard.
        gate1_.notify_all();
    }

    void readLock() {
        std::unique_lock<std::mutex> lk(mutex_);
        // Wait if there is a writer or if readers overflow.
        gate1_.wait(lk, [=]() { return (state_ < MAX_READERS); });
        ++state_;
    }

    void readUnlock() {
        std::lock_guard<std::mutex> lk(mutex_);
        unsigned prev = state_--;
        if (writeEntered()) {
            if (readers() == 0) {
                // Last reader: wake up a waiting writer.
                gate2_.notify_one();
            }
        } else {
            if (prev == MAX_READERS) {
                // Reader overflow: wake up one waiting reader.
                gate1_.notify_one();
            }
        }
    }

private:


    bool writeEntered() const {
        return (state_ & WRITE_ENTERED);
    }

    unsigned readers() const {
        return (state_ & MAX_READERS);
    }


    std::mutex mutex_;

    std::condition_variable gate1_;

    std::condition_variable gate2_;

    unsigned state_;
};

class ReadLockGuard : public boost::noncopyable {
public:

    ReadLockGuard(ReadWriteMutex& rw_mutex) : rw_mutex_(rw_mutex) {
        rw_mutex_.readLock();
    }

    virtual ~ReadLockGuard() {
        rw_mutex_.readUnlock();
    }

private:
    ReadWriteMutex& rw_mutex_;

};

class WriteLockGuard : public boost::noncopyable {
public:

    WriteLockGuard(ReadWriteMutex& rw_mutex) : rw_mutex_(rw_mutex) {
        rw_mutex_.writeLock();
    }

    virtual ~WriteLockGuard() {
        rw_mutex_.writeUnlock();
    }

private:
    ReadWriteMutex& rw_mutex_;
};

} // namespace util
} // namespace isc

#endif // READWRITE_MUTEX_H