SynchronizerImpl.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
///
/// \file
/// \author Gerald Fahrnholz
/// 
/// \brief
/// Implementation of class Synchronizer
/// 
////////////////////////////////////////////////////////////////////////////////

#pragma once

#include "TestToolBox/CommonSources/CommonDefinitions.h"
#include "TestToolBox/Synchronizer.h"
#include "TestToolBox/IEventReceiver.h"
#include <assert.h>

///\cond do not document

// Switch to use as inline code (to be included in each cpp file)
// or as regular functions to be compiled within a lib or e.g. within stdafx.cpp
#ifdef TTB_NOT_INLINE
    #define TTB_INLINE
#else
    #define TTB_INLINE inline
#endif

namespace TestToolBox
{

//************************************************************************
//
// Interface ISynchronizer
//
//************************************************************************


TTB_INLINE void Synchronizer::ConnectWithEventReceiver(
    IEventReceiver* in_pIEventReceiver)
{
    m_pIEventReceiver = in_pIEventReceiver;

} // Synchronizer::ConnectWithEventReceiver


//************************************************************************
//************************************************************************


TTB_INLINE void Synchronizer::SetSyncTimeout(
    long in_timeoutMs)
{
    InterlockedExchange(&m_syncTimeoutMs, in_timeoutMs);

} // Synchronizer::SetSyncTimeout


//************************************************************************
//************************************************************************


TTB_INLINE void Synchronizer::InitSync(
    long in_numSyncEventsToWaitFor)
{
    AutoLock o (this);

    m_curSyncCount = 0;
    m_numSyncEventsToWaitFor = in_numSyncEventsToWaitFor;
    ResetEvent(m_hSyncEvent);

} // Synchronizer::InitSync


//************************************************************************
//************************************************************************


TTB_INLINE void Synchronizer::WaitSync(
    const char* in_fileName,
    const long  in_lineNum)
{
        // Currently the possibility to define the number of sync events
        // directly within the call of this function has been disabled.
        // When the need arises the param may be reactivated.
        // When using this possibility the user has to obey the rule that
        // the given param in_numSyncEvents <= m_numSyncEventsToWaitFor as given
        // by the last preceeding call of InitSync().
        long in_numSyncEvents = 0;

    TRCF("Synchronizer::WaitSync");
    TRC(TL_DEBUG,"Begin");
    long oldMaxCount     = 0;
    bool waitForEvent    = true;
    bool restoreMaxCount = false;

    // ----------  Check wait conditions  ----------

    {
        AutoLock o (this);
        TRC(TL_DEBUG, "after lock: "
            "m_numSyncEventsToWaitFor = %d, m_curSyncCount = %d",
            m_numSyncEventsToWaitFor, m_curSyncCount);

        if ((m_numSyncEventsToWaitFor == 0) && (in_numSyncEvents == 0))
        {
            waitForEvent =  false;
        }
        else
        {
            if (in_numSyncEvents != 0) // use specific maximum count
            {
                if (m_curSyncCount >= in_numSyncEvents) // all syncs already received
                {
                    waitForEvent = false;
                    if (m_curSyncCount > in_numSyncEvents)
                    {
                        std::ostringstream tmpStr;
                        AddFileNameAndLineNumber (tmpStr, in_fileName, in_lineNum);
                        tmpStr
                            << "WaitSync-Warning: "
                            << m_curSyncCount
                            << " events already arrived, but expected only "
                            << in_numSyncEvents
                            << " events";
        
                        TRC(TL_ERROR, tmpStr. str().c_str());
                                                assert (m_pIEventReceiver);
                                                m_pIEventReceiver->Event (TestToolBox::CTX_TOO_MANY_EVENTS, tmpStr. str());
                    }
                }
                else // we really have to wait
                {
                    oldMaxCount = m_numSyncEventsToWaitFor;
                    m_numSyncEventsToWaitFor = in_numSyncEvents;
                    restoreMaxCount = true;

                    TRC(TL_DEBUG, "Temporary setting: m_numSyncEventsToWaitFor = %d",
                        m_numSyncEventsToWaitFor);
                }
            }
            else // use standard maximum count
            {
                if (m_curSyncCount >= m_numSyncEventsToWaitFor) // all syncs already received
                {
                    waitForEvent = false;
                    if (m_curSyncCount > m_numSyncEventsToWaitFor)
                    {
                        std::ostringstream tmpStr;
                        AddFileNameAndLineNumber (tmpStr, in_fileName, in_lineNum);
                        tmpStr
                            << "WaitSync-Warning: "
                            << m_curSyncCount
                            << " events already arrived, but expected only "
                            << m_numSyncEventsToWaitFor
                            << " events";
        
                        TRC(TL_ERROR, tmpStr. str().c_str());
                                        assert (m_pIEventReceiver);
                                                m_pIEventReceiver->Event (TestToolBox::CTX_TOO_MANY_EVENTS, tmpStr. str());
                    }
                }
            }
        }

        if (waitForEvent)
        {
            // make sure that the event is not signalled
            // (this may be possible because the old max count may have been reached
            // or through inproper testing several calls of Sync() without following
            // WaitSync() have caused setting of event)
            ResetEvent(m_hSyncEvent);
        }

    } // automatic unlock


    // ----------  Wait until sync events occure or timeout elapses  ----------

    DWORD waitStatus;
    if (waitForEvent) // we really have to wait until all events occurred
    {
        TRC(TL_DEBUG, "WaitForSingleObject");
        waitStatus = WaitForSingleObject(m_hSyncEvent, m_syncTimeoutMs);
    }
    else // wait conditions are already fulfilled
    {
        TRC(TL_DEBUG, "No WaitForSingleObject necessary, m_curSyncCount = %d", m_curSyncCount);
        waitStatus = WAIT_OBJECT_0; // simulate event
    }


    // ----------  Check wait results  ----------

    {
        AutoLock o (this);

        if (waitStatus == WAIT_OBJECT_0) // all sync events received
        {
            // reset number of sync events for next wait
            m_curSyncCount = 0;
            ResetEvent(m_hSyncEvent);
        }
        else if (waitStatus == WAIT_TIMEOUT)
        {
            std::ostringstream tmpStr;
            AddFileNameAndLineNumber (tmpStr, in_fileName, in_lineNum);
            tmpStr
                << "WaitSync-Warning: Timeout of "
                << m_syncTimeoutMs
                << " ms reached! Only "
                << m_curSyncCount
                << " events of "
                << m_numSyncEventsToWaitFor
                << " received!";
        
            TRC(TL_ERROR, tmpStr. str().c_str());
                        assert (m_pIEventReceiver);
                        m_pIEventReceiver->Event (TestToolBox::CTX_TIMEOUT_ELAPSED, tmpStr. str());

            m_curSyncCount = 0;
        }
        else // e.g. WAIT_FAILED
        {
            std::ostringstream tmpStr;
            AddFileNameAndLineNumber (tmpStr, in_fileName, in_lineNum);
            tmpStr
                << "Sync-Error: Wait failed, last error "
                << GetLastError();
        
            TRC(TL_ERROR, tmpStr. str().c_str());

                        assert (m_pIEventReceiver);
                        m_pIEventReceiver->Event (TestToolBox::CTX_FATAL_ERROR, tmpStr. str());

            m_curSyncCount = 0;
        }

        if (restoreMaxCount)
        {
            m_numSyncEventsToWaitFor = oldMaxCount;
        }

    } // automatic unlock

    TRC(TL_DEBUG, "End");

} // Synchronizer::WaitSync


//************************************************************************
//************************************************************************


TTB_INLINE void Synchronizer::Sync(
    const char* in_fileName,
    const long  in_lineNum)
{
    TRCF("Synchronizer::Sync");
    TRC(TL_DEBUG, "Synchronizer::Sync", "Begin");

    AutoLock o (this);

    m_curSyncCount++;

    TRC(TL_DEBUG, "(after lock): m_curSyncCount incremented to %d "
        "m_numSyncEventsToWaitFor = %d", m_curSyncCount, m_numSyncEventsToWaitFor);

    if (m_curSyncCount == m_numSyncEventsToWaitFor)
    {
        SetEvent (m_hSyncEvent);
    }

    if (    (m_curSyncCount           > m_numSyncEventsToWaitFor)
         && (m_numSyncEventsToWaitFor > 0))
    {
        std::ostringstream tmpStr;
        AddFileNameAndLineNumber (tmpStr, in_fileName, in_lineNum);
        tmpStr
            << "Sync-Warning: SyncEvent "
            << m_curSyncCount
            << " generated, but expected a maximum of only "
            << m_numSyncEventsToWaitFor
            << " events";
        TRC(TL_ERROR, tmpStr. str().c_str());
                assert (m_pIEventReceiver);
                m_pIEventReceiver->Event (TestToolBox::CTX_TOO_MANY_EVENTS, tmpStr. str());
    }
    
    TRC(TL_DEBUG, "End");

} // Synchronizer::Sync


//************************************************************************
//
// Other functions
//
//************************************************************************


TTB_INLINE Synchronizer::Synchronizer():
    m_curSyncCount            (0),
    m_numSyncEventsToWaitFor  (1),
    m_syncTimeoutMs           (10000),
    m_hSyncEvent              (0),
    m_pIEventReceiver           (0)

{
    TRCF("Synchronizer::Synchronizer");
    TRC(TL_DEBUG, "Synchronizer::Synchronizer", "Constructor");

    m_hSyncEvent = ::CreateEvent(
        NULL,   // security
        TRUE,   // manual reset
        FALSE,  // initially nonsignaled
        NULL);  // no name

} // Synchronizer::Synchronizer


//************************************************************************
//************************************************************************


TTB_INLINE Synchronizer::~Synchronizer()
{
    TRCF("Synchronizer::~Synchronizer");
    TRC(TL_DEBUG, "Destructor");
    m_pIEventReceiver = 0;
    CloseHandle(m_hSyncEvent);

} // Synchronizer::Synchronizer()


//************************************************************************
//************************************************************************

}; // namespace TestToolBox

///\endcond

// end of file Synchronizer.cpp

---