initiatorLatencyTest.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2008 VT MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: initiatorLatencyTest.h,v $ $Revision: 1.8 $ $State: Exp $
*******************************************************************************/


#ifndef DtInitiatorLatencyTest_H_
#define DtInitiatorLatencyTestr_H_


#include "rtiMsConfig.h"
#include "latencyTest.h"
#include <vlutil/vlString.h>
#include <vlutil/vlTime.h>
#include <vlutil/vlFedTarget.h>
#include <metadata.h>
#include "RIDparams.h"
#include "metadataFederateHostInformation.h"

class DtConnectionMgr;
class DtAssistantChangeLatencyTestModeMsg;
class DtAssistantLatencyReportMsg;
class DtAveragedLatencyTestReport;






class DT_DLL_LRC DtInitiatorLatencyTest : public DtLatencyTest
{

public:

   DtInitiatorLatencyTest(DtTestManager* parent);

   DtInitiatorLatencyTest();

   virtual ~DtInitiatorLatencyTest();

   virtual bool tick();

   virtual void addSendInteractionTimeStamp( unsigned int testID );

   virtual void addNetSendTimeStamp( unsigned int testID, DtRtiMsg& msg );

   virtual void addNetReceiveTimeStamp( unsigned int testID, const DtRtiMsg& msg );

   virtual void addReceiveInteractionTimeStamp( unsigned int testID, MAKRti::DtTime timeToUse );

   virtual void addAsyncQueueMsgTimeStamp( unsigned int testID, const DtRtiMsg& msg );

   virtual bool canInitiateTest() const;   

   virtual bool takeCompletedTestReport( unsigned int trialID,
                       DtAveragedLatencyTestReport& takenReport);

   virtual void initiateLatencyTest(unsigned int trialID, 
      unsigned int numInteractions,
      unsigned int sizeOfPayload,
      MAKRti::DtTime periodBetweenSends,
      DtFederateHandle handle);

   virtual bool testIsFinished( unsigned int testID ) const;

   virtual void getCurrentTestInfo(unsigned int& testID, 
                                   DtFederateHandle& handle,
                                   MAKRti::DtTransportType& transport,
                                   unsigned int& payloadSize ) const;
   
   virtual bool trialIsFinished( unsigned int trialID ) const;

   
protected:

   virtual bool getCompletedReportByTestID( unsigned int testID, 
      DtLatencyTestReportStruct& report ) const;
   
   virtual void averageReports(const std::vector<DtLatencyTestReportStruct*>& bestEffortTests,
                               const std::vector<DtLatencyTestReportStruct*>& reliableTests,
                               DtFederateHandle recipientHandle,
                               DtFederateHandle initiatorHandle,
                               const MAKRti::DtString& recipientName,
                               const MAKRti::DtString& initiatorName,
                               DtRIDParameters::DtAsynchronousIOModeEnum recipientAsyncMode,
                               DtRIDParameters::DtAsynchronousIOModeEnum initiatorAsyncMode,
                               unsigned int numBestEffortDropped,
                               unsigned int numReliableDropped,
                               DtAveragedLatencyTestReport& averaged) const;


   virtual unsigned int currTestId() const;
   
   virtual void consumeTestId();

private:
   DtInitiatorLatencyTest(DtInitiatorLatencyTest const& orig);

   DtInitiatorLatencyTest& operator= (DtInitiatorLatencyTest const& orig);

protected:

   MAKRti::DtTime myNextSend;
   unsigned short myTestOffset;

   typedef std::pair<unsigned int, MAKRti::DtTransportType> DtNumToTypePair;
   typedef std::multimap<DtFederateHandle, DtNumToTypePair> DtFedHandleToTestMap;

   // Storage of my completed initiated tests.
   DtTestToTimeStampMap myCompletedInitiatedTests;
   std::map<unsigned int, DtFederateHandle> myFedHandleByTestID;
  
   unsigned int myNumTestsToAverage;

   MAKRti::DtTime myLatencyInterval;

   unsigned int myPayloadSize;

   std::map<unsigned int, DtRIDParameters::DtAsynchronousIOModeEnum> myRecipientAsyncIOModeByFedHandle;

   std::set<unsigned int> myInitiatedTestIDs;

   std::map<unsigned int, DtFedHandleToTestMap> myNumberOfInteractionsLeftByFederate;

   std::map<unsigned int, DtRtiMtdFederateHostInformation::DtFederateHostInformation> myRecipientHostInfoMap;   

   std::map<unsigned int, std::set<unsigned int> > myTestIDsByTrial;

   DtFederateHandle myFedHandleOfCurrentTest;
   unsigned int myTestIDOfCurrentTest;
   

};

#endif