readwrite_mutex.h

Go to the documentation of this file.

// Copyright (C) 2020-2022 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