lockfreestack.h

Go to the documentation of this file.

 
#ifndef _LOCK_FREE_STACK_CLASS_HEADER_
#define _LOCK_FREE_STACK_CLASS_HEADER_
 
#include "tagged_ptr.h"
 
#ifndef A_UTILS_TAGGED_POINTER_AVALIABLE
    #include <stack>
    using std::stack;
#endif
 
 
 
namespace A_UTILS_NS
{
 
#ifdef A_UTILS_TAGGED_POINTER_AVALIABLE
 
template <class T>
class A_UTILS_CAS_ALIGNMENT lock_free_stack
{
    protected:
 
        struct A_UTILS_CAS_ALIGNMENT cNode
        {
            tagged_ptr<cNode> m_pNext;  
            T m_oData;                  
        };
 
        typedef tagged_ptr<cNode> tTaggedNodePtr;
 
        tTaggedNodePtr m_pLast;
 
        free_list<cNode, T> m_oFree;
 
    public:
 
        lock_free_stack(tUInt nReserve = 0, tBool bGrow = tTrue): m_pLast(nullptr), m_oFree(nReserve, bGrow)
        {
        }
 
        virtual ~lock_free_stack()
        {
            // clear stack
            T oTmp;
            while (static_cast<tErrorCode>(ERR_NOERROR) == Pop(&oTmp));
        }
 
        tErrorCode Push(const T& oValue)
        {
            // get a node from the free list
            cNode* pTmp = m_oFree.GetFreeNode();
            if (!pTmp)
            {
                return static_cast<tErrorCode>(ERR_MEMORY);
            }
 
            // store the value
            pTmp->m_oData = oValue;
            // and insert it into the list
            tTaggedNodePtr pOld;
            do
            {
                pOld.Set(m_pLast);
                pTmp->m_pNext.Set(pOld.GetPtr());
            }
            while (!m_pLast.CompareAndSwap(pOld, pTmp)); // try insertion until we succeed
 
            return static_cast<tErrorCode>(ERR_NOERROR);
        }
 
        tErrorCode Pop(T* pValue)
        {
            for (;;)
            {
                tTaggedNodePtr pOldTos;
                pOldTos.Set(m_pLast);
 
                if (!pOldTos)
                {
                    return static_cast<tErrorCode>(ERR_EMPTY);
                }
 
                cNode* pNewTos = pOldTos->m_pNext.GetPtr();
 
                if (m_pLast.CompareAndSwap(pOldTos, pNewTos))
                {
                    *pValue = pOldTos->m_oData;
                    m_oFree.AddFreeNode(pOldTos.GetPtr());
                    break;
                }
            }
 
            return static_cast<tErrorCode>(ERR_NOERROR);
        }
 
    private:
        lock_free_stack(const lock_free_stack& oOther);
};
 
#else
 
template <class T>
class lock_free_stack
{
    protected:
        std::recursive_mutex m_oMutex;
        std::stack<T>    m_oStack;
    public:
 
        lock_free_stack(tUInt nReserve = 0, tBool bGrow = tTrue)
        {
        }
 
        virtual ~lock_free_stack()
        {
        }
 
        tErrorCode Push(const T& oValue)
        {
            std::lock_guard<std::recursive_mutex> oLck(m_oMutex);
            m_oStack.push(oValue);
            return static_cast<tErrorCode>(ERR_NOERROR);
        }
 
        tErrorCode Pop(T* pValue)
        {
            std::lock_guard<std::recursive_mutex> oLck(m_oMutex);
            if (m_oStack.empty())
            {
                return static_cast<tErrorCode>(ERR_EMPTY);
            }
            *pValue = m_oStack.top();
            m_oStack.pop();
            return static_cast<tErrorCode>(ERR_NOERROR);
        }
 
    private:
        lock_free_stack(const lock_free_stack& oOther);
};
 
#endif
 
 
}
 
#endif