RWlockLF.h

#pragma once


#include <libutl/host_thread.h>
#include <libutl/NamedObjectMI.h>


UTL_NS_BEGIN;


class Mutex;

// RWlockLF ////////////////////////////////////////////////////////////////////////////////////////


class RWlockLF : public Object, public NamedObjectMI
{
    UTL_CLASS_DECL(RWlockLF, Object);
    UTL_CLASS_NO_COPY;

public:
    bool haveWriteLock() const;

    void
    lock(uint_t mode)
    {
        (mode == io_rd) ? rdlock() : wrlock();
    }

    void rdlock();

    void wrlock();

    void unlock();

    bool
    trylock(uint_t mode)
    {
        return (mode == io_rd) ? tryrdlock() : trywrlock();
    }

    bool tryrdlock();

    bool trywrlock();

private:
    void init();

    void
    deInit()
    {
    }

    thread_handle_t
    owner() const
    {
        return _writeLockOwner.load(std::memory_order_relaxed);
    }

private:
    char pad1[UTL_CACHE_LINE_SIZE - sizeof(void*)];
    std::atomic<thread_handle_t> _writeLockOwner;
    size_t _depth;
    char pad2[UTL_CACHE_LINE_SIZE - sizeof(size_t)];
    std::atomic_size_t _numActive;
    char pad3[UTL_CACHE_LINE_SIZE - sizeof(size_t)];
};

// RWlockLFguard ///////////////////////////////////////////////////////////////////////////////////


class RWlockLFguard
{
public:
    RWlockLFguard()
        : _locked(false)
        , _rwlock(nullptr)
    {
    }

    RWlockLFguard(RWlockLF* rwlock, uint_t mode)
        : _locked(false)
        , _rwlock(rwlock)
    {
        _lock(mode);
    }

    ~RWlockLFguard()
    {
        unlock();
    }

    void
    lock(RWlockLF* rwlock, uint_t mode)
    {
        unlock();
        _rwlock = rwlock;
        _lock(mode);
    }

    void
    lock(uint_t mode)
    {
        (mode == io_rd) ? rdlock() : wrlock();
    }

    void
    rdlock(RWlockLF* rwlock)
    {
        unlock();
        _rwlock = rwlock;
        _rdlock();
    }

    void
    wrlock(RWlockLF* rwlock)
    {
        unlock();
        _rwlock = rwlock;
        _wrlock();
    }

    void
    rdlock()
    {
        unlock();
        _rdlock();
    }

    void
    wrlock()
    {
        unlock();
        _wrlock();
    }

    bool
    trylock(RWlockLF* rwlock, uint_t mode)
    {
        unlock();
        _rwlock = rwlock;
        return _trylock(mode);
    }

    bool
    trylock(uint_t mode)
    {
        return (mode == io_rd) ? tryrdlock() : trywrlock();
    }

    bool
    tryrdlock(RWlockLF* rwlock)
    {
        unlock();
        _rwlock = rwlock;
        return _tryrdlock();
    }

    bool
    trywrlock(RWlockLF* rwlock)
    {
        unlock();
        _rwlock = rwlock;
        return _trywrlock();
    }

    bool
    tryrdlock()
    {
        unlock();
        return _tryrdlock();
    }

    bool
    trywrlock()
    {
        unlock();
        return _trywrlock();
    }

    inline void
    unlock()
    {
        if (_locked) _unlock();
    }

private:
    void
    _lock(uint_t mode)
    {
        (mode == io_rd) ? _rdlock() : _wrlock();
    }

    void
    _rdlock()
    {
        ASSERTD(_rwlock != nullptr);
        ASSERTD(!_locked);
        _rwlock->rdlock();
        _locked = true;
    }

    void
    _wrlock()
    {
        ASSERTD(_rwlock != nullptr);
        ASSERTD(!_locked);
        _rwlock->wrlock();
        _locked = true;
    }

    bool
    _trylock(uint_t mode)
    {
        return (mode == io_rd) ? _tryrdlock() : _trywrlock();
    }

    bool
    _tryrdlock()
    {
        ASSERTD(_rwlock != nullptr);
        ASSERTD(!_locked);
        if (_rwlock->tryrdlock()) _locked = true;
        return _locked;
    }

    bool
    _trywrlock()
    {
        ASSERTD(_rwlock != nullptr);
        ASSERTD(!_locked);
        if (_rwlock->trywrlock()) _locked = true;
        return _locked;
    }

    void
    _unlock()
    {
        ASSERTD(_rwlock != nullptr);
        ASSERTD(_locked);
        _rwlock->unlock();
        _locked = false;
    }

private:
    bool _locked;
    RWlockLF* _rwlock;
};


UTL_NS_END;