Return to rwlock.h CVS log

Up to [Isaki's NoNo m68k/m88k emulator] / nono / lib

Annotation of nono/lib/rwlock.h, revision 1.1

1.1     ! root        1: //
        !             2: // nono
        !             3: // Copyright (C) 2025 nono project
        !             4: // Licensed under nono-license.txt
        !             5: //
        !             6: 
        !             7: //
        !             8: // rwlock (ただし書き込み優先)
        !             9: //
        !            10: 
        !            11: #pragma once
        !            12: 
        !            13: #include <condition_variable>
        !            14: #include <mutex>
        !            15: 
        !            16: class RWLock
        !            17: {
        !            18:  public:
        !            19:        RWLock()
        !            20:        {
        !            21:        }
        !            22: 
        !            23:        void EnterRead()
        !            24:        {
        !            25:                std::unique_lock<std::mutex> lock(mtx);
        !            26:                cv.wait(lock, [this]() {
        !            27:                        return rw_acquired >= 0 && writer_waiting == 0;
        !            28:                });
        !            29:                rw_acquired++;
        !            30:        }
        !            31: 
        !            32:        void LeaveRead()
        !            33:        {
        !            34:                std::lock_guard<std::mutex> lock(mtx);
        !            35:                assert(rw_acquired > 0);
        !            36:                if (--rw_acquired == 0) {
        !            37:                        cv.notify_all();
        !            38:                }
        !            39:        }
        !            40: 
        !            41:        void EnterWrite()
        !            42:        {
        !            43:                std::unique_lock<std::mutex> lock(mtx);
        !            44:                writer_waiting++;
        !            45:                cv.wait(lock, [this]() {
        !            46:                        return rw_acquired == 0;
        !            47:                });
        !            48:                writer_waiting--;
        !            49:                rw_acquired--;
        !            50:        }
        !            51: 
        !            52:        void LeaveWrite()
        !            53:        {
        !            54:                std::lock_guard<std::mutex> lock(mtx);
        !            55:                assert(rw_acquired < 0);
        !            56:                rw_acquired = 0;
        !            57:                cv.notify_all();
        !            58:        }
        !            59: 
        !            60:  private:
        !            61:        std::mutex mtx {};
        !            62:        std::condition_variable cv {};
        !            63: 
        !            64:        // 正なら読み込みロックの数。
        !            65:        // -1 なら書き込みがロック取得中。
        !            66:        int rw_acquired {};
        !            67: 
        !            68:        int writer_waiting {};
        !            69: };
        !            70: 
        !            71: class RWLockGuard_Read
        !            72: {
        !            73:  public:
        !            74:        explicit RWLockGuard_Read(RWLock& lock_)
        !            75:                : lock(lock_)
        !            76:        {
        !            77:                lock.EnterRead();
        !            78:        }
        !            79:        ~RWLockGuard_Read()
        !            80:        {
        !            81:                lock.LeaveRead();
        !            82:        }
        !            83: 
        !            84:  private:
        !            85:        RWLock& lock;
        !            86: };
        !            87: 
        !            88: class RWLockGuard_Write
        !            89: {
        !            90:  public:
        !            91:        explicit RWLockGuard_Write(RWLock& lock_)
        !            92:                : lock(lock_)
        !            93:        {
        !            94:                lock.EnterWrite();
        !            95:        }
        !            96:        ~RWLockGuard_Write()
        !            97:        {
        !            98:                lock.LeaveWrite();
        !            99:        }
        !           100: 
        !           101:  private:
        !           102:        RWLock& lock;
        !           103: };

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.