testManager.h

Go to the documentation of this file.

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


#ifndef DtTestManager_H_
#define DtTestManager_H_

#include <rtiMsConfig.h>
#include <rtiApiTypes.h>
#if !defined(DtIFSPEC13)
#include <RTI/RTIambassador.h>
#endif

#include <vlutil/vlString.h>
#include <vlutil/vlTime.h>
#include <vlutil/vlFedTarget.h>
#include <vlutil/vlMutex.h>

#include <metadata.h>
#include <vector>
#include <list>

class DtFederateMgr;
class DtConnectionMgr;
class DtLatencyTestInteraction;
class DtRIDParameters;
class DtInteractionMsg;
class DtPhvps;
class DtSubInterMsg;
class DtUnsubInterMsg;
class DtAssistantChangeLatencyTestModeMsg;
class DtChangeLatencyTestModeMsg;
class DtRecipientLatencyTest;
class DtTestMgrFedAmbWrapper;
class DtInitiatorLatencyTest;
class DtResignMsg;



class DT_DLL_LRC DtTestManager
{
protected:

   typedef enum DtInitiatorByType_e { DtInitiatedByExec, DtInitiatedByAssistant } DtInitiatorByType;
   typedef std::multimap<DtMetadataType, MAKRti::DtTime> DtTimeStampMap;
   typedef std::map<unsigned int, DtTimeStampMap > DtTestToTimeStampMap;   
   
   struct DtTrialDetails
   {
       DtTrialDetails() :
       trialID(0),
       federateHandle(0),
       initiatorType (DtInitiatedByAssistant),
       numInteractions(0),
       payLoadSize(0),
       period(.1),
       continuous(false)
       { };

      unsigned int trialID;
      unsigned int federateHandle;
      DtInitiatorByType initiatorType;
      unsigned int numInteractions;
      unsigned int payLoadSize;
      MAKRti::DtTime period;
      bool continuous;
   };

public:

   DtTestManager(bool initiallyEnabled);

   DtTestManager(DtFederateMgr* fedMgr, bool initiallyEnabled);

   virtual ~DtTestManager();


   DtRIDParameters* params();

   DtRIDParameters* params() const;

   DtFederateMgr* fedMgr();

   DtFederateMgr* fedMgr() const;

   RTI_API::RTIambassador* rtiAmb();

   RTI_API::RTIambassador* rtiAmb() const;

   virtual DtConnectionMgr* connectMgr();

   virtual DtConnectionMgr* connectMgr() const;

   virtual MAKRti::DtTime time() const;

   virtual void postJoinInit();

   virtual void resign();

   virtual void tick(unsigned long tickCount);

   virtual float averageTickPeriod() const;

   virtual void enableNetworkTesting();

   virtual void disableNetworkTesting();

   virtual bool networkTestingEnabled() const;

   void processResign(const DtResignMsg& msg);

   virtual bool receiveInteraction(DtInteractionClassHandle classHandle, const DtPhvps & params);

   virtual bool testMgrCurrentlySending() const;

   virtual bool queueMsgForSend(DtRtiMsg& msg ) const;

   virtual void setTestMgrCurrentlySending( bool isSending,
                                            unsigned int testID = 0 );

   virtual bool addSendTimeStampMetaDataIfNecessary( DtRtiMsg& msg );

   virtual bool addReceiveTimeStampIfNecessary( DtRtiMsg& msg );

   virtual bool addAsyncQueueMsgOnRecieve(DtRtiMsg& msg);
   
   virtual bool isTestInteractionClassHandle(DtInteractionClassHandle classHandle);

   virtual void sendStatusMessages() const;

protected:

   virtual void processSub( const DtSubInterMsg& msg );

   virtual void processUnsub( const DtUnsubInterMsg& msg );

   virtual void processChangeLatencyTestStatus(const DtAssistantChangeLatencyTestModeMsg& testMsg);
   virtual void processChangeLatencyTestStatus(const DtChangeLatencyTestModeMsg& testMsg);

   virtual void changeLatencyTestRequestByType( bool initiateTest, bool continuousCommand,
      bool stopContinuous, bool observing, DtInitiatorByType type, MAKRti::DtTime period, 
      unsigned int numInteractions, unsigned int payloadSize );

   virtual void initiateLatencyTest();

   virtual void processLatencyTest();

   // Upon netread - get the testID from the metadata.
   virtual bool getTestIDFromMetaData( DtRtiMsg& msg, unsigned int& testID) const;

   virtual void addKnownFederate(DtFederateHandle subscribedFed);

   virtual void removeKnownFederate(DtFederateHandle unsubscribedFed);

   virtual bool atLeastOneKnownFederate() const;

   virtual bool isKnownFederateHandle(DtFederateHandle handle) const;

   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 removeKnowledgeOfTestId( unsigned int testID );

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

   MAKRti::DtTransportType transportTypeForTestID( unsigned int testID );

   
   virtual unsigned int lastSentTestID() const;

   virtual void setLastSentTestID( unsigned int testID );
   
   virtual bool sendSingleLatencyInteraction(unsigned int testID, 
                                             DtFederateHandle recipient,
                                             MAKRti::DtTransportType transport,
                                             unsigned int payload );
      
   virtual bool addMetadataIfNecessary( DtRtiMsg& msg, unsigned int& testID ) const;

   virtual bool shouldAddMetadataToMessage( DtRtiMsg& msg ) const;

   virtual bool isInitiatorOfTestID( unsigned int testID ) const;

   virtual void calculateTickTime(unsigned long tickCount );

   virtual bool sendInteraction(unsigned int testID, 
          DtInteractionClassHandle handle, const DtPhvps& params, unsigned int payloadSize );

protected:

   static void processSub( const DtSubInterMsg& msg, void* usr );

   static void processUnsub( const DtUnsubInterMsg& msg, void* usr );

   static void queueLatencyTestRequest( const DtAssistantChangeLatencyTestModeMsg& testMsg, void* usr );

   static void processChangeLatencyTestStatus( const DtAssistantChangeLatencyTestModeMsg& testMsg, void* usr );
   static void processChangeLatencyTestStatus( const DtChangeLatencyTestModeMsg& testMsg, void* usr );

private:
   DtTestManager(DtTestManager const& orig);

   DtTestManager& operator= (DtTestManager const& orig);

protected:

   DtFederateMgr* myFedMgr;

   DtInitiatorLatencyTest* myInitiatorTest;

   DtRecipientLatencyTest* myRecipientTest;

   DtLatencyTestInteraction* myLatencyInteraction;

   MAKRti::DtClock myClock;
   
   bool myRunningContinuous;
   DtTrialDetails myContinuousDetails;

   std::set<DtInitiatorByType> myObservers;

   DtTestToTimeStampMap myCompletedAveragedInitiatedTests;
  
   bool mySendingInteraction;

   unsigned int myTestIDOfLastSentInteraction;

   unsigned int myCurrentTrialID;

   unsigned int myInitiatedTrialID;
   DtFederateHandle myInitiatedFedHandle;

   // Send subscribe when we learn about new federates so they can know about us
   bool mySendSubscribe;

   DtTestMgrFedAmbWrapper* myTestFedAmbWrapper;
   
   std::list<DtTrialDetails> myTrialsToInitiate;

   DtFederateHandleStdSet myListOfKnownFederates;

   float myInitialTickTime;

   unsigned long myInitialTickCount;

   float mySecondTickTime;

   unsigned long mySecondTickCount;

   float myAverageTickPeriod;   

   bool myEnabled;

   unsigned myNumInitiatedTests;

   unsigned myNumTestReportsGenerated;

   DtMutex myInitiatorMutex;
   DtMutex myRecipientMutex;

};

#endif