TnbCyclicBarrier.h

[詳解]

#pragma once
#include "TnbSync.h"
 
 
 
//T-TestCaseコードカバレッジDisable
#pragma comment(user,"T-Coverage Disable")
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CCyclicBarrier : CCopyImpossible
{
public:
 
    struct IListener
    {
        virtual ~IListener(void) {}
 
        virtual void OnGathered(void) = 0;
    };
 
private:
 
    int             m_iParties;             
    IListener*      m_piListener;           
    CSyncEvent*     m_psyncEvent;           
    LONG            m_lWaitingCount;        
    CSyncSection    m_syncParam;            
    CSyncSemaphore* m_psyncSema;            
    LONG            m_lWaitExecutingCount;  
    bool            m_boIsReset;            
 
public:
 
    explicit CCyclicBarrier(int iParties = 2, IListener* I = NULL)
    {
        m_psyncEvent = NULL;
        m_psyncSema = NULL;
        m_iParties = 0;
        m_piListener = NULL;
        m_boIsReset = false;
        m_lWaitingCount = 0;
        m_lWaitExecutingCount = 0;
        Init(iParties, I);
    }
 
    ~CCyclicBarrier(void)
    {
        Reset();
        while ( m_lWaitExecutingCount != 0 )
        {
            ::Sleep(10); 
        }
        if ( m_psyncSema != NULL )
        {
            delete m_psyncSema;
        }
        if ( m_psyncEvent != NULL )
        {
            delete[] m_psyncEvent;
        }
    }
    
    bool Init(int iParties = 2, IListener* I = NULL)
    {
        if ( iParties < 2 )
        {
            ASSERT0(false, "CCyclicBarrier::Init()", "パーティ数が異常です。");
            return false;
        }
        Reset();
        while ( m_lWaitExecutingCount != 0 )
        {
            ::Sleep(10); 
        }
        if ( m_psyncSema != NULL )
        {
            delete m_psyncSema;
        }
        m_psyncSema = new CSyncSemaphore(NULL, iParties);
        //
        if ( m_iParties != iParties )
        {
            if ( m_psyncEvent != NULL )
            {
                delete[] m_psyncEvent;
            }
            m_psyncEvent = new CSyncEvent[iParties];
            m_iParties = iParties;
        }
        m_piListener = I;
        loop ( i, m_iParties )
        {
            m_psyncEvent[i].ToLock();
        }
        m_lWaitingCount = 0;
        return true;
    }
 
    void Reset(void)
    {
        m_boIsReset = true;
        for ( int i = m_iParties - 1; i >= 0; i-- )
        {
            m_psyncEvent[i].Unlock();
        }
    }
 
    int Wait(void)
    {
        ::InterlockedIncrement(&m_lWaitExecutingCount);
        LONG lNo = 0;
        int iRc = 0;
        SYNCBLOCK(m_psyncSema)
        {
            SYNCBLOCK(&m_syncParam)
            {
                lNo = m_lWaitingCount++;
                if ( lNo == 0 )
                {
                    //== TopWaiter
                    m_boIsReset = false;
                    loop ( i, m_iParties )
                    {
                        m_psyncEvent[i].ToLock();
                    }
                }
            }
            //
            if ( lNo == 0 )
            {
                //== TopWaiter
                for ( int i = 1; i < m_iParties; i++ )
                {
                    m_psyncEvent[i].Lock(); //他のWaiter待ち
                }
                if ( ! m_boIsReset )
                {
                    EXCLUSIVE(&m_syncParam);
                    if ( m_piListener != NULL )
                    {
                        m_piListener->OnGathered();
                    }
                    m_psyncEvent[0].Unlock();
                    m_lWaitingCount = 0;
                    iRc = 0;
                }
                else
                {
                    iRc = -1;
                }
                break;
            }
            else if ( m_iParties > lNo )
            {
                //== 後続のWaiter
                m_psyncEvent[lNo].Unlock();
                m_psyncEvent[0].Lock(); // TopWaiter待ち
                iRc = (m_boIsReset) ? -1 : lNo;
                break;
            }
            else
            {
                ASSERTLIB(false);   //こないはず
            }
        } 
        ::InterlockedDecrement(&m_lWaitExecutingCount);
        return iRc;
    }
 
    int GetNumberWaiting(void) { return m_lWaitingCount; }
 
    int GetParties(void) { return m_iParties; }
};
 
 
 
}; // TNB
 
 
 
//T-TestCaseコードカバレッジEnable
#pragma comment(user,"T-Coverage Enable")