mutex_pool.hpp

Go to the documentation of this file.

Go to the SVN repository for this file.

#ifndef UTIL___MUTEX_POOL__HPP
#define UTIL___MUTEX_POOL__HPP
 
/*  $Id: mutex_pool.hpp 99880 2023-05-18 17:38:00Z vasilche $
* ===========================================================================
*
*                            PUBLIC DOMAIN NOTICE
*               National Center for Biotechnology Information
*
*  This software/database is a "United States Government Work" under the
*  terms of the United States Copyright Act.  It was written as part of
*  the author's official duties as a United States Government employee and
*  thus cannot be copyrighted.  This software/database is freely available
*  to the public for use. The National Library of Medicine and the U.S.
*  Government have not placed any restriction on its use or reproduction.
*
*  Although all reasonable efforts have been taken to ensure the accuracy
*  and reliability of the software and data, the NLM and the U.S.
*  Government do not and cannot warrant the performance or results that
*  may be obtained by using this software or data. The NLM and the U.S.
*  Government disclaim all warranties, express or implied, including
*  warranties of performance, merchantability or fitness for any particular
*  purpose.
*
*  Please cite the author in any work or product based on this material.
*
* ===========================================================================
*
* Author: Eugene Vasilchenko
*
* File Description:
*   CMutexPool -- to distribute mutex pool among several objects.
*
*/
 
 
#include <corelib/ncbistd.hpp>
#include <corelib/ncbiobj.hpp>
#include <corelib/ncbimtx.hpp>
 
#include <list>
 
BEGIN_NCBI_SCOPE
 
class CInitMutexPool;
class CInitMutex_Base;
class CInitGuard;
 
////////////////////////////////////////////////////////////////////
//
//  CMutexPool::
//
//    Distribute a mutex pool among multiple objects
//
 
 
class NCBI_XUTIL_EXPORT CInitMutexPool
{
public:
    CInitMutexPool(void);
    ~CInitMutexPool(void);
 
    class CPoolMutex : public CObject
    {
    public:
        CPoolMutex(CInitMutexPool& pool)
            : m_Pool(pool)
            {
            }
        ~CPoolMutex(void)
            {
            }
 
        CInitMutexPool& GetPool(void) const
            {
                return m_Pool;
            }
        CMutex& GetMutex(void)
            {
                return m_Mutex;
            }
 
    private:
        CInitMutexPool& m_Pool;
        CMutex      m_Mutex;
    };
    typedef CPoolMutex TMutex;
 
protected:
    friend class CInitGuard;
 
    // assign a mutex to 'init' and store it also to CRef<> 'mutex'
    // if the 'init' was initialized already and 'force' == false then no mutex is assigned
    // return true if the mutex was assigned
    bool AcquireMutex(CInitMutex_Base& init, CRef<TMutex>& mutex, bool force = false);
    // release mutex from 'init' if it was successfully initialized
    void ReleaseMutex(CInitMutex_Base& init, CRef<TMutex>& mutex);
 
private:
    typedef list< CRef<TMutex> > TMutexList;
    TMutexList m_MutexList;
    CFastMutex m_Pool_Mtx;
 
private:
    CInitMutexPool(const CInitMutexPool&);
    const CInitMutexPool& operator=(const CInitMutexPool&);
};
 
 
class NCBI_XUTIL_EXPORT CInitMutex_Base
{
public:
    DECLARE_OPERATOR_BOOL(m_Initialized.load(memory_order_acquire));
 
protected:
    CInitMutex_Base(void)
        : m_Initialized(false)
        {
        }
    // Copy constructor to allow CInitMutex_Base placement in STL containers.
    // It doesn't copy mutex/object, just verifies that source is empty too.
    CInitMutex_Base(const CInitMutex_Base& _DEBUG_ARG(mutex))
        : m_Initialized(false)
        {
            _ASSERT(!mutex);
        }
    ~CInitMutex_Base(void)
        {
            _ASSERT(!m_Mutex || m_Mutex->ReferencedOnlyOnce());
        }
 
    friend class CInitMutexPool;
 
    typedef CInitMutexPool::TMutex TMutex;
 
    CRef<TMutex>  m_Mutex;
    CRef<CObject> m_Object;
    atomic<bool>  m_Initialized;
 
private:
    const CInitMutex_Base& operator=(const CInitMutex_Base&) = delete;
};
 
 
template<class C>
class CInitMutex : public CInitMutex_Base
{
public:
    typedef C TObjectType;
 
    using CInitMutex_Base::CInitMutex_Base;
 
    void Reset()
        {
            m_Initialized = false;
            m_Object.Reset();
            m_Initialized = false;
        }
    void Reset(TObjectType* object)
        {
            m_Initialized = false;
            m_Object.Reset(object);
            m_Initialized = (object != nullptr);
        }
 
    inline
    TObjectType& GetObject(void)
        {
            return static_cast<TObjectType&>(m_Object.GetObject());
        }
    inline
    const TObjectType& GetObject(void) const
        {
            return static_cast<const TObjectType&>(m_Object.GetObject());
        }
    inline
    TObjectType* GetPointer(void)
        {
            return static_cast<TObjectType*>(m_Object.GetPointer());
        }
    inline
    const TObjectType* GetPointer(void) const
        {
            return static_cast<const TObjectType*>(m_Object.GetPointer());
        }
    inline
    TObjectType* GetPointerOrNull(void)
        {
            return static_cast<TObjectType*>(m_Object.GetPointerOrNull());
        }
    inline
    const TObjectType* GetPointerOrNull(void) const
        {
            return
                static_cast<const TObjectType*>(m_Object.GetPointerOrNull());
        }
 
    inline
    TObjectType& operator*(void)
        {
            return GetObject();
        }
    inline
    TObjectType* operator->(void)
        {
            return GetPointer();
        }
    inline
    const TObjectType& operator*(void) const
        {
            return GetObject();
        }
    inline
    const TObjectType* operator->(void) const
        {
            return GetPointer();
        }
 
    const CInitMutex<TObjectType>& operator=(const CRef<TObjectType>& ref)
        {
            Reset(ref.GetNCPointerOrNull());
            return *this;
        }
    operator CRef<TObjectType>(void) const
        {
            return CRef<TObjectType>(const_cast<TObjectType*>(GetPointer()));
        }
    operator CConstRef<TObjectType>(void) const
        {
            return CConstRef<TObjectType>(GetPointer());
        }
};
 
 
class CInitGuard
{
public:
    enum EForce {
        force
    };
    CInitGuard(CInitMutex_Base& init, CInitMutexPool& pool)
        : m_Init(init), m_Guard(eEmptyGuard)
        {
            if ( !init && pool.AcquireMutex(init, m_Mutex) ) {
                m_Guard.Guard(m_Mutex->GetMutex());
                if ( init ) {
                    x_Release();
                }
            }
        }
    CInitGuard(CInitMutex_Base& init, CInitMutexPool& pool, EForce)
        : m_Init(init), m_Guard(eEmptyGuard)
        {
            if ( pool.AcquireMutex(init, m_Mutex, true) ) {
                m_Guard.Guard(m_Mutex->GetMutex());
            }
        }
    ~CInitGuard(void)
        {
            Release();
        }
 
    void Release(void)
        {
            if ( m_Mutex ) {
                x_Release();
            }
        }
 
    void ForceGuard(CInitMutex_Base& init, CInitMutexPool& pool)
        {
            pool.AcquireMutex(init, m_Mutex, true);
            m_Guard.Guard(m_Mutex->GetMutex());
        }
 
    // true means that this thread should perform initialization
    DECLARE_OPERATOR_BOOL(!m_Init);
 
protected:
    typedef CInitMutexPool::TMutex TMutex;
 
    void x_Release(void)
        {
            m_Mutex->GetPool().ReleaseMutex(m_Init, m_Mutex);
            m_Guard.Release();
        }
 
    CInitMutex_Base& m_Init;
    CRef<TMutex>     m_Mutex;
    CMutexGuard      m_Guard;
 
private:
    CInitGuard(const CInitGuard&);
    const CInitGuard& operator=(const CInitGuard&);
};
 
 
END_NCBI_SCOPE
 
#endif  /* UTIL___MUTEX_POOL__HPP */