Seqlock.hxx

浏览该文件的文档.

 
#ifndef __xwos_cxx_lock_Seqlock_hxx__
#define __xwos_cxx_lock_Seqlock_hxx__
 
#include <xwos/osal/lock/seqlock.hxx>
#include <xwos/cxx/sync/Cond.hxx>
 
namespace xwos {
namespace lock {
 
class Seqlock
{
  public:
    enum LockStatus : xwu32_t {
        SeqlockUnlocked = 0,
        SeqlockRdexLocked,
        SeqlockWrLocked,
    };
 
    class RdexLkGrd
    {
      protected:
        Seqlock * mSeqlock;
        enum LockStatus mStatus;
 
      public:
        RdexLkGrd(Seqlock * seqlock);
 
        RdexLkGrd(Seqlock & seqlock);
 
        ~RdexLkGrd();
 
        void unlock();
 
        enum LockStatus getStatus() { return mStatus; }
        xwer_t wait(sync::Cond * cond);
 
        xwer_t wait(sync::Cond & cond) { return wait(&cond); }
 
        xwer_t wait(sync::Cond * cond, xwtm_t to);
 
        xwer_t wait(sync::Cond & cond, xwtm_t to) { return wait(&cond, to); }
 
      protected:
        RdexLkGrd()
            : mSeqlock(nullptr)
            , mStatus(SeqlockUnlocked)
        {
        }
    };
 
    class TryRdexLkGrd : public RdexLkGrd
    {
      private:
        xwer_t mRc; 
      public:
        TryRdexLkGrd(Seqlock * seqlock);
 
        TryRdexLkGrd(Seqlock & seqlock);
 
        ~TryRdexLkGrd() {}
 
        xwer_t getRc() { return mRc; }
    };
 
    class RdexLkThGrd
    {
      protected:
        Seqlock * mSeqlock;
        enum LockStatus mStatus;
        xwreg_t mCpuirq; 
      public:
        RdexLkThGrd(Seqlock * seqlock);
 
        RdexLkThGrd(Seqlock & seqlock);
 
        ~RdexLkThGrd();
 
        void unlock();
 
        enum LockStatus getStatus() { return mStatus; }
 
        xwer_t wait(sync::Cond * cond);
 
        xwer_t wait(sync::Cond & cond) { return wait(&cond); }
 
        xwer_t wait(sync::Cond * cond, xwtm_t to);
 
        xwer_t wait(sync::Cond & cond, xwtm_t to) { return wait(&cond, to); }
 
      protected:
        RdexLkThGrd()
            : mSeqlock(nullptr)
            , mStatus(SeqlockUnlocked)
        {
        }
    };
 
    class TryRdexLkThGrd : public RdexLkThGrd
    {
      private:
        xwer_t mRc; 
      public:
        TryRdexLkThGrd(Seqlock * seqlock);
 
        TryRdexLkThGrd(Seqlock & seqlock);
 
        ~TryRdexLkThGrd() {}
 
        xwer_t getRc() { return mRc; }
    };
 
    class RdexLkBhGrd
    {
      protected:
        Seqlock * mSeqlock;
        enum LockStatus mStatus;
 
      public:
        RdexLkBhGrd(Seqlock * seqlock);
 
        RdexLkBhGrd(Seqlock & seqlock);
 
        ~RdexLkBhGrd();
 
        void unlock();
 
        enum LockStatus getStatus() { return mStatus; }
 
        xwer_t wait(sync::Cond * cond);
 
        xwer_t wait(sync::Cond & cond) { return wait(&cond); }
 
        xwer_t wait(sync::Cond * cond, xwtm_t to);
 
        xwer_t wait(sync::Cond & cond, xwtm_t to) { return wait(&cond, to); }
 
      protected:
        RdexLkBhGrd()
            : mSeqlock(nullptr)
            , mStatus(SeqlockUnlocked)
        {
        }
    };
 
    class TryRdexLkBhGrd : public RdexLkBhGrd
    {
      private:
        xwer_t mRc; 
      public:
        TryRdexLkBhGrd(Seqlock * seqlock);
 
        TryRdexLkBhGrd(Seqlock & seqlock);
 
        ~TryRdexLkBhGrd() {}
 
        xwer_t getRc() { return mRc; }
    };
 
    template<xwirq_t... TIrqList>
    class RdexLkIrqsGrd
    {
      protected:
        Seqlock * mSeqlock;
        enum LockStatus mStatus;
        xwirq_t mIrqs[sizeof...(TIrqList)];
        xwreg_t mIrqFlags[sizeof...(TIrqList)];
 
      public:
        RdexLkIrqsGrd(Seqlock * seqlock)
            : mSeqlock(seqlock)
            , mStatus(Seqlock::LockStatus::SeqlockUnlocked)
            , mIrqs{ TIrqList... }
        {
            if (nullptr != mSeqlock) {
                xwos_sqlk_rdex_lock_irqssv(&mSeqlock->mLock, mIrqs, mIrqFlags,
                                           sizeof...(TIrqList));
                mStatus = Seqlock::LockStatus::SeqlockRdexLocked;
            }
        }
 
        RdexLkIrqsGrd(Seqlock & seqlock)
            : mSeqlock(&seqlock)
            , mStatus(Seqlock::LockStatus::SeqlockUnlocked)
            , mIrqs{ TIrqList... }
        {
            if (nullptr != mSeqlock) {
                xwos_sqlk_rdex_lock_irqssv(&mSeqlock->mLock, mIrqs, mIrqFlags,
                                           sizeof...(TIrqList));
                mStatus = Seqlock::LockStatus::SeqlockRdexLocked;
            }
        }
 
        ~RdexLkIrqsGrd()
        {
            if (nullptr != mSeqlock) {
                if (Seqlock::LockStatus::SeqlockRdexLocked == mStatus) {
                    mStatus = Seqlock::LockStatus::SeqlockUnlocked;
                    xwos_sqlk_rdex_unlock_irqsrs(&mSeqlock->mLock, mIrqs, mIrqFlags,
                                                 sizeof...(TIrqList));
                }
            }
        }
 
        void unlock()
        {
            if (nullptr != mSeqlock) {
                if (Seqlock::LockStatus::SeqlockRdexLocked == mStatus) {
                    mStatus = Seqlock::LockStatus::SeqlockUnlocked;
                    xwos_sqlk_rdex_unlock_irqsrs(&mSeqlock->mLock, mIrqs, mIrqFlags,
                                                 sizeof...(TIrqList));
                }
            }
        }
 
        enum LockStatus getStatus() { return mStatus; }
 
        xwer_t wait(sync::Cond * cond)
        {
            xwer_t rc;
            if (nullptr != mSeqlock) {
                if (Seqlock::LockStatus::SeqlockRdexLocked == mStatus) {
                    union xwos_ulock lock;
                    xwsq_t lkst;
                    lock.osal.sqlk = &mSeqlock->mLock;
                    rc = xwos_cond_wait(cond->getXwosObj(), lock, XWOS_LK_SQLK_RDEX,
                                        nullptr, &lkst);
                    if (rc < 0) {
                        if (XWOS_LKST_UNLOCKED == lkst) {
                            xwos_sqlk_rdex_lock(&mSeqlock->mLock);
                        }
                    }
                } else {
                    rc = -ENOLCK;
                }
            } else {
                rc = -EFAULT;
            }
            return rc;
        }
 
        xwer_t wait(sync::Cond & cond) { return wait(&cond); }
 
        xwer_t wait(sync::Cond * cond, xwtm_t to)
        {
            xwer_t rc;
            if (nullptr != mSeqlock) {
                if (Seqlock::LockStatus::SeqlockRdexLocked == mStatus) {
                    union xwos_ulock lock;
                    xwsq_t lkst;
                    lock.osal.sqlk = &mSeqlock->mLock;
                    rc = xwos_cond_wait_to(cond->getXwosObj(), lock, XWOS_LK_SQLK_RDEX,
                                           nullptr, to, &lkst);
                    if (rc < 0) {
                        if (XWOS_LKST_UNLOCKED == lkst) {
                            xwos_sqlk_rdex_lock(&mSeqlock->mLock);
                        }
                    }
                } else {
                    rc = -ENOLCK;
                }
            } else {
                rc = -EFAULT;
            }
            return rc;
        }
 
        xwer_t wait(sync::Cond & cond, xwtm_t to) { return wait(&cond, to); }
 
      protected:
        RdexLkIrqsGrd()
            : mSeqlock(nullptr)
            , mStatus(SeqlockUnlocked)
        {
        }
    };
 
    template<xwirq_t... TIrqList>
    class TryRdexLkIrqsGrd : public RdexLkIrqsGrd<TIrqList...>
    {
      private:
        xwer_t mRc; 
      public:
        TryRdexLkIrqsGrd(Seqlock * seqlock)
            : RdexLkIrqsGrd<TIrqList...>()
        {
            RdexLkIrqsGrd<TIrqList...>::mSeqlock = seqlock;
            if (nullptr != RdexLkIrqsGrd<TIrqList...>::mSeqlock) {
                mRc = xwos_sqlk_rdex_trylock_irqssv(
                    &RdexLkIrqsGrd<TIrqList...>::mSeqlock->mLock,
                    RdexLkIrqsGrd<TIrqList...>::mIrqs,
                    RdexLkIrqsGrd<TIrqList...>::mIrqFlags, sizeof...(TIrqList));
                if (XWOK != mRc) {
                    RdexLkIrqsGrd<TIrqList...>::mSeqlock = nullptr;
                }
            }
        }
 
        TryRdexLkIrqsGrd(Seqlock & seqlock)
            : RdexLkIrqsGrd<TIrqList...>()
        {
            RdexLkIrqsGrd<TIrqList...>::mSeqlock = seqlock;
            if (nullptr != RdexLkIrqsGrd<TIrqList...>::mSeqlock) {
                mRc = xwos_sqlk_rdex_trylock_irqssv(
                    &RdexLkIrqsGrd<TIrqList...>::mSeqlock->mLock,
                    RdexLkIrqsGrd<TIrqList...>::mIrqs,
                    RdexLkIrqsGrd<TIrqList...>::mIrqFlags, sizeof...(TIrqList));
                if (XWOK != mRc) {
                    RdexLkIrqsGrd<TIrqList...>::mSeqlock = nullptr;
                }
            }
        }
 
        ~TryRdexLkIrqsGrd() {}
 
        xwer_t getRc() { return mRc; }
    };
 
    class WrLkGrd
    {
      protected:
        Seqlock * mSeqlock;
        enum LockStatus mStatus;
 
      public:
        WrLkGrd(Seqlock * seqlock);
 
        WrLkGrd(Seqlock & seqlock);
 
        ~WrLkGrd();
 
        void unlock();
 
        enum LockStatus getStatus() { return mStatus; }
 
        xwer_t wait(sync::Cond * cond);
 
        xwer_t wait(sync::Cond & cond) { return wait(&cond); }
 
        xwer_t wait(sync::Cond * cond, xwtm_t to);
 
        xwer_t wait(sync::Cond & cond, xwtm_t to) { return wait(&cond, to); }
 
      protected:
        WrLkGrd()
            : mSeqlock(nullptr)
            , mStatus(SeqlockUnlocked)
        {
        }
    };
 
    class TryWrLkGrd : public WrLkGrd
    {
      private:
        xwer_t mRc; 
      public:
        TryWrLkGrd(Seqlock * seqlock);
 
        TryWrLkGrd(Seqlock & seqlock);
 
        ~TryWrLkGrd() {}
 
        xwer_t getRc() { return mRc; }
    };
 
    class WrLkThGrd
    {
      protected:
        Seqlock * mSeqlock;
        enum LockStatus mStatus;
        xwreg_t mCpuirq; 
      public:
        WrLkThGrd(Seqlock * seqlock);
 
        WrLkThGrd(Seqlock & seqlock);
 
        ~WrLkThGrd();
 
        void unlock();
 
        enum LockStatus getStatus() { return mStatus; }
 
        xwer_t wait(sync::Cond * cond);
 
        xwer_t wait(sync::Cond & cond) { return wait(&cond); }
 
        xwer_t wait(sync::Cond * cond, xwtm_t to);
 
        xwer_t wait(sync::Cond & cond, xwtm_t to) { return wait(&cond, to); }
 
      protected:
        WrLkThGrd()
            : mSeqlock(nullptr)
            , mStatus(SeqlockUnlocked)
        {
        }
    };
 
    class TryWrLkThGrd : public WrLkThGrd
    {
      private:
        xwer_t mRc; 
      public:
        TryWrLkThGrd(Seqlock * seqlock);
 
        TryWrLkThGrd(Seqlock & seqlock);
 
        ~TryWrLkThGrd() {}
 
        xwer_t getRc() { return mRc; }
    };
 
    class WrLkBhGrd
    {
      protected:
        Seqlock * mSeqlock;
        enum LockStatus mStatus;
 
      public:
        WrLkBhGrd(Seqlock * seqlock);
 
        WrLkBhGrd(Seqlock & seqlock);
 
        ~WrLkBhGrd();
 
        void unlock();
 
        enum LockStatus getStatus() { return mStatus; }
 
        xwer_t wait(sync::Cond * cond);
 
        xwer_t wait(sync::Cond & cond) { return wait(&cond); }
 
        xwer_t wait(sync::Cond * cond, xwtm_t to);
 
        xwer_t wait(sync::Cond & cond, xwtm_t to) { return wait(&cond, to); }
 
      protected:
        WrLkBhGrd()
            : mSeqlock(nullptr)
            , mStatus(SeqlockUnlocked)
        {
        }
    };
 
    class TryWrLkBhGrd : public WrLkBhGrd
    {
      private:
        xwer_t mRc; 
      public:
        TryWrLkBhGrd(Seqlock * seqlock);
 
        TryWrLkBhGrd(Seqlock & seqlock);
 
        ~TryWrLkBhGrd() {}
 
        xwer_t getRc() { return mRc; }
    };
 
    template<xwirq_t... TIrqList>
    class WrLkIrqsGrd
    {
      protected:
        Seqlock * mSeqlock;
        enum LockStatus mStatus;
        xwirq_t mIrqs[sizeof...(TIrqList)];
        xwreg_t mIrqFlags[sizeof...(TIrqList)];
 
      public:
        WrLkIrqsGrd(Seqlock * seqlock)
            : mSeqlock(seqlock)
            , mStatus(Seqlock::LockStatus::SeqlockUnlocked)
            , mIrqs{ TIrqList... }
        {
            if (nullptr != mSeqlock) {
                xwos_sqlk_wr_lock_irqssv(&mSeqlock->mLock, mIrqs, mIrqFlags,
                                         sizeof...(TIrqList));
                mStatus = Seqlock::LockStatus::SeqlockWrLocked;
            }
        }
 
        WrLkIrqsGrd(Seqlock & seqlock)
            : mSeqlock(&seqlock)
            , mStatus(Seqlock::LockStatus::SeqlockUnlocked)
            , mIrqs{ TIrqList... }
        {
            if (nullptr != mSeqlock) {
                xwos_sqlk_wr_lock_irqssv(&mSeqlock->mLock, mIrqs, mIrqFlags,
                                         sizeof...(TIrqList));
                mStatus = Seqlock::LockStatus::SeqlockWrLocked;
            }
        }
 
        ~WrLkIrqsGrd()
        {
            if (nullptr != mSeqlock) {
                if (Seqlock::LockStatus::SeqlockWrLocked == mStatus) {
                    mStatus = Seqlock::LockStatus::SeqlockUnlocked;
                    xwos_sqlk_wr_unlock_irqsrs(&mSeqlock->mLock, mIrqs, mIrqFlags,
                                               sizeof...(TIrqList));
                }
            }
        }
 
        void unlock()
        {
            if (nullptr != mSeqlock) {
                if (Seqlock::LockStatus::SeqlockWrLocked == mStatus) {
                    mStatus = Seqlock::LockStatus::SeqlockUnlocked;
                    xwos_sqlk_wr_unlock_irqsrs(&mSeqlock->mLock, mIrqs, mIrqFlags,
                                               sizeof...(TIrqList));
                }
            }
        }
 
        enum LockStatus getStatus() { return mStatus; }
 
        xwer_t wait(sync::Cond * cond)
        {
            xwer_t rc;
            if (nullptr != mSeqlock) {
                if (Seqlock::LockStatus::SeqlockWrLocked == mStatus) {
                    union xwos_ulock lock;
                    xwsq_t lkst;
                    lock.osal.sqlk = &mSeqlock->mLock;
                    rc = xwos_cond_wait(cond->getXwosObj(), lock, XWOS_LK_SQLK_WR,
                                        nullptr, &lkst);
                    if (rc < 0) {
                        if (XWOS_LKST_UNLOCKED == lkst) {
                            xwos_sqlk_wr_lock(&mSeqlock->mLock);
                        }
                    }
                } else {
                    rc = -ENOLCK;
                }
            } else {
                rc = -EFAULT;
            }
            return rc;
        }
 
        xwer_t wait(sync::Cond & cond) { return wait(&cond); }
 
        xwer_t wait(sync::Cond * cond, xwtm_t to)
        {
            xwer_t rc;
            if (nullptr != mSeqlock) {
                if (Seqlock::LockStatus::SeqlockWrLocked == mStatus) {
                    union xwos_ulock lock;
                    xwsq_t lkst;
                    lock.osal.sqlk = &mSeqlock->mLock;
                    rc = xwos_cond_wait_to(cond->getXwosObj(), lock, XWOS_LK_SQLK_WR,
                                           nullptr, to, &lkst);
                    if (rc < 0) {
                        if (XWOS_LKST_UNLOCKED == lkst) {
                            xwos_sqlk_wr_lock(&mSeqlock->mLock);
                        }
                    }
                } else {
                    rc = -ENOLCK;
                }
            } else {
                rc = -EFAULT;
            }
            return rc;
        }
 
        xwer_t wait(sync::Cond & cond, xwtm_t to) { return wait(&cond, to); }
 
      protected:
        WrLkIrqsGrd()
            : mSeqlock(nullptr)
            , mStatus(SeqlockUnlocked)
        {
        }
    };
 
    template<xwirq_t... TIrqList>
    class TryWrLkIrqsGrd : public WrLkIrqsGrd<TIrqList...>
    {
      private:
        xwer_t mRc; 
      public:
        TryWrLkIrqsGrd(Seqlock * seqlock)
            : WrLkIrqsGrd<TIrqList...>()
        {
            WrLkIrqsGrd<TIrqList...>::mSeqlock = seqlock;
            if (nullptr != WrLkIrqsGrd<TIrqList...>::mSeqlock) {
                mRc = xwos_sqlk_wr_trylock_irqssv(
                    &WrLkIrqsGrd<TIrqList...>::mSeqlock->mLock,
                    WrLkIrqsGrd<TIrqList...>::mIrqs,
                    WrLkIrqsGrd<TIrqList...>::mIrqFlags, sizeof...(TIrqList));
                if (XWOK != mRc) {
                    WrLkIrqsGrd<TIrqList...>::mSeqlock = nullptr;
                }
            }
        }
 
        TryWrLkIrqsGrd(Seqlock & seqlock)
            : WrLkIrqsGrd<TIrqList...>()
        {
            WrLkIrqsGrd<TIrqList...>::mSeqlock = seqlock;
            if (nullptr != WrLkIrqsGrd<TIrqList...>::mSeqlock) {
                mRc = xwos_sqlk_wr_trylock_irqssv(
                    &WrLkIrqsGrd<TIrqList...>::mSeqlock->mLock,
                    WrLkIrqsGrd<TIrqList...>::mIrqs,
                    WrLkIrqsGrd<TIrqList...>::mIrqFlags, sizeof...(TIrqList));
                if (XWOK != mRc) {
                    WrLkIrqsGrd<TIrqList...>::mSeqlock = nullptr;
                }
            }
        }
 
        ~TryWrLkIrqsGrd() {}
 
        xwer_t getRc() { return mRc; }
    };
 
  private:
    struct xwos_sqlk mLock; 
  public:
    Seqlock(); 
    ~Seqlock(); 
    struct xwos_sqlk * getXwosObj() { return &mLock; } 
    xwsq_t readBegin();
 
    bool readRetry(xwsq_t start);
 
    xwsq_t getSeq();
};
 
} // namespace lock
} // namespace xwos
 
#endif /* xwos/cxx/lock/Seqlock.hxx */