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();
 
        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();
 
        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();
 
        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);
 
        RdexLkIrqsGrd(Seqlock & seqlock);
 
        ~RdexLkIrqsGrd();
 
        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:
        RdexLkIrqsGrd(): mSeqlock(nullptr), mStatus(SeqlockUnlocked) {}
    };
 
    template<xwirq_t ... TIrqList>
    class TryRdexLkIrqsGrd
        : public RdexLkIrqsGrd<TIrqList ...>
    {
      private:
        xwer_t mRc; 
      public:
        TryRdexLkIrqsGrd(Seqlock * seqlock);
 
        TryRdexLkIrqsGrd(Seqlock & seqlock);
 
        ~TryRdexLkIrqsGrd() {}
 
        xwer_t getRc() { return mRc; }
    };
 
    class WrLkGrd
    {
      protected:
        Seqlock * mSeqlock;
        enum LockStatus mStatus;
 
      public:
        WrLkGrd(Seqlock * seqlock);
 
        WrLkGrd(Seqlock & seqlock);
 
        ~WrLkGrd();
 
        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();
 
        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();
 
        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);
 
        WrLkIrqsGrd(Seqlock & seqlock);
 
        ~WrLkIrqsGrd();
 
        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:
        WrLkIrqsGrd(): mSeqlock(nullptr), mStatus(SeqlockUnlocked) {}
    };
 
    template<xwirq_t ... TIrqList>
    class TryWrLkIrqsGrd
        : public WrLkIrqsGrd<TIrqList ...>
    {
      private:
        xwer_t mRc; 
      public:
        TryWrLkIrqsGrd(Seqlock * seqlock);
 
        TryWrLkIrqsGrd(Seqlock & seqlock);
 
        ~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 */