Spinlock.hxx

浏览该文件的文档.

 
#ifndef __xwos_cxx_lock_Spinlock_hxx__
#define __xwos_cxx_lock_Spinlock_hxx__
 
#include <xwos/osal/lock/spinlock.hxx>
#include <xwos/cxx/sync/Cond.hxx>
 
namespace xwos {
namespace lock {
 
class Spinlock
{
  public:
    enum LockStatus : xwu32_t {
        SpinlockUnlocked = 0,
        SpinlockLocked,
    };
 
    class LkGrd
    {
      protected:
        Spinlock * mSpinlock;
        enum LockStatus mStatus;
 
      public:
        LkGrd(Spinlock * spinlock);
 
        LkGrd(Spinlock & spinlock);
 
        ~LkGrd();
 
        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:
        LkGrd()
            : mSpinlock(nullptr)
            , mStatus(SpinlockUnlocked)
        {
        }
    };
 
    class TryLkGrd : public LkGrd
    {
      private:
        xwer_t mRc; 
      public:
        TryLkGrd(Spinlock * spinlock);
 
        TryLkGrd(Spinlock & spinlock);
 
        ~TryLkGrd() {}
 
        xwer_t getRc() { return mRc; }
    };
 
    class LkThGrd
    {
      protected:
        Spinlock * mSpinlock;
        enum LockStatus mStatus;
        xwreg_t mCpuirq; 
      public:
        LkThGrd(Spinlock * spinlock);
 
        LkThGrd(Spinlock & spinlock);
 
        ~LkThGrd();
 
        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:
        LkThGrd()
            : mSpinlock(nullptr)
            , mStatus(SpinlockUnlocked)
        {
        }
    };
 
    class TryLkThGrd : public LkThGrd
    {
      private:
        xwer_t mRc; 
      public:
        TryLkThGrd(Spinlock * spinlock);
 
        TryLkThGrd(Spinlock & spinlock);
 
        ~TryLkThGrd() {}
 
        xwer_t getRc() { return mRc; }
    };
 
    class LkBhGrd
    {
      protected:
        Spinlock * mSpinlock;
        enum LockStatus mStatus;
 
      public:
        LkBhGrd(Spinlock * spinlock);
 
        LkBhGrd(Spinlock & spinlock);
 
        ~LkBhGrd();
 
        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:
        LkBhGrd()
            : mSpinlock(nullptr)
            , mStatus(SpinlockUnlocked)
        {
        }
    };
 
    class TryLkBhGrd : public LkBhGrd
    {
      private:
        xwer_t mRc; 
      public:
        TryLkBhGrd(Spinlock * spinlock);
 
        TryLkBhGrd(Spinlock & spinlock);
 
        ~TryLkBhGrd() {}
 
        xwer_t getRc() { return mRc; }
    };
 
    template<xwirq_t... TIrqList>
    class LkIrqsGrd
    {
      protected:
        Spinlock * mSpinlock;
        enum LockStatus mStatus;
        xwirq_t mIrqs[sizeof...(TIrqList)];
        xwreg_t mIrqFlags[sizeof...(TIrqList)];
 
      public:
        LkIrqsGrd(Spinlock * spinlock)
            : mSpinlock(spinlock)
            , mStatus(Spinlock::LockStatus::SpinlockUnlocked)
            , mIrqs{ TIrqList... }
        {
            if (nullptr != mSpinlock) {
                xwos_splk_lock_irqssv(&mSpinlock->mLock, mIrqs, mIrqFlags,
                                      sizeof...(TIrqList));
                mStatus = Spinlock::LockStatus::SpinlockLocked;
            }
        }
 
        LkIrqsGrd(Spinlock & spinlock)
            : mSpinlock(&spinlock)
            , mStatus(Spinlock::LockStatus::SpinlockUnlocked)
            , mIrqs{ TIrqList... }
        {
            if (nullptr != mSpinlock) {
                xwos_splk_lock_irqssv(&mSpinlock->mLock, mIrqs, mIrqFlags,
                                      sizeof...(TIrqList));
                mStatus = Spinlock::LockStatus::SpinlockLocked;
            }
        }
 
        ~LkIrqsGrd()
        {
            if (nullptr != mSpinlock) {
                if (Spinlock::LockStatus::SpinlockLocked == mStatus) {
                    mStatus = Spinlock::LockStatus::SpinlockUnlocked;
                    xwos_splk_unlock_irqsrs(&mSpinlock->mLock, mIrqs, mIrqFlags,
                                            sizeof...(TIrqList));
                }
            }
        }
 
        void unlock()
        {
            if (nullptr != mSpinlock) {
                if (Spinlock::LockStatus::SpinlockLocked == mStatus) {
                    mStatus = Spinlock::LockStatus::SpinlockUnlocked;
                    xwos_splk_unlock_irqsrs(&mSpinlock->mLock, mIrqs, mIrqFlags,
                                            sizeof...(TIrqList));
                }
            }
        }
 
        enum LockStatus getStatus() { return mStatus; }
 
        xwer_t wait(sync::Cond * cond)
        {
            xwer_t rc;
            if (nullptr != mSpinlock) {
                if (Spinlock::LockStatus::SpinlockLocked == mStatus) {
                    union xwos_ulock lock;
                    xwsq_t lkst;
                    lock.osal.splk = &mSpinlock->mLock;
                    rc = xwos_cond_wait(cond->getXwosObj(), lock, XWOS_LK_SPLK, nullptr,
                                        &lkst);
                    if (rc < 0) {
                        if (XWOS_LKST_UNLOCKED == lkst) {
                            xwos_splk_lock(&mSpinlock->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 != mSpinlock) {
                if (Spinlock::LockStatus::SpinlockLocked == mStatus) {
                    union xwos_ulock lock;
                    xwsq_t lkst;
                    lock.osal.splk = &mSpinlock->mLock;
                    rc = xwos_cond_wait_to(cond->getXwosObj(), lock, XWOS_LK_SPLK,
                                           nullptr, to, &lkst);
                    if (rc < 0) {
                        if (XWOS_LKST_UNLOCKED == lkst) {
                            xwos_splk_lock(&mSpinlock->mLock);
                        }
                    }
                } else {
                    rc = -ENOLCK;
                }
            } else {
                rc = -EFAULT;
            }
            return rc;
        }
 
        xwer_t wait(sync::Cond & cond, xwtm_t to) { return wait(&cond, to); }
 
      protected:
        LkIrqsGrd()
            : mSpinlock(nullptr)
            , mStatus(SpinlockUnlocked)
        {
        }
    };
 
    template<xwirq_t... TIrqList>
    class TryLkIrqsGrd : public LkIrqsGrd<TIrqList...>
    {
      private:
        xwer_t mRc; 
      public:
        TryLkIrqsGrd(Spinlock * spinlock)
            : LkIrqsGrd<TIrqList...>()
        {
            LkIrqsGrd<TIrqList...>::mSpinlock = spinlock;
            if (nullptr != LkIrqsGrd<TIrqList...>::mSpinlock) {
                mRc = xwos_splk_trylock_irqssv(
                    &LkIrqsGrd<TIrqList...>::mSpinlock->mLock,
                    LkIrqsGrd<TIrqList...>::mIrqs, LkIrqsGrd<TIrqList...>::mIrqFlags,
                    sizeof...(TIrqList));
                if (XWOK != mRc) {
                    LkIrqsGrd<TIrqList...>::mSpinlock = nullptr;
                } else {
                    LkIrqsGrd<TIrqList...>::mStatus =
                        Spinlock::LockStatus::SpinlockLocked;
                }
            }
        }
 
        TryLkIrqsGrd(Spinlock & spinlock)
            : LkIrqsGrd<TIrqList...>()
        {
            LkIrqsGrd<TIrqList...>::mSpinlock = spinlock;
            if (nullptr != LkIrqsGrd<TIrqList...>::mSpinlock) {
                mRc = xwos_splk_trylock_irqssv(
                    &LkIrqsGrd<TIrqList...>::mSpinlock->mLock,
                    LkIrqsGrd<TIrqList...>::mIrqs, LkIrqsGrd<TIrqList...>::mIrqFlags,
                    sizeof...(TIrqList));
                if (XWOK != mRc) {
                    LkIrqsGrd<TIrqList...>::mSpinlock = nullptr;
                } else {
                    LkIrqsGrd<TIrqList...>::mStatus =
                        Spinlock::LockStatus::SpinlockLocked;
                }
            }
        }
 
        ~TryLkIrqsGrd() {}
 
        xwer_t getRc() { return mRc; }
    };
 
  private:
    struct xwos_splk mLock; 
  public:
    Spinlock(); 
    ~Spinlock(); 
    struct xwos_splk * getXwosObj() { return &mLock; } 
};
 
} // namespace lock
} // namespace xwos
 
#endif /* xwos/cxx/lock/Spinlock.hxx */