netStatsMonitor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2012 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
#ifndef netStatsMonitor_h__
#define netStatsMonitor_h__


#include "netStats.h"
#include "objClassInfo.h"
#include "intClassInfo.h"

#include <vlutil/vlFilename.h>
#include <vlutil/vlFedTarget.h>

// Forward References
class DtRtiMsg;
class DtRtiAmbassadorImplementor;
class DtNetStatsFedAmbWrapper;
class DtConnectionMgr;
class QtGui;
class DtAssistantNetStatsObserveReqMsg;
class DtRtiAssistantLrcClient;
class DtFomClassMgr;
class DtObjectClassInfo;
class DtInteractionClassInfo;

//
// The DtNetStatsMonitor class records statistics on RTI network
// utilization through callbacks from it's connection manager.
// It is intended to compliment the LRC console GUI.
//
class DtNetStatsMonitor
{
public:

   // Constructor
   DtNetStatsMonitor( DtRtiAmbassadorImplementor* rtiAmb, DtNetStatsFedAmbWrapper* fedAmb, DtRtiAssistantLrcClient* assistantClient );

   // Destructor
   virtual ~DtNetStatsMonitor();

   // Sets local Federate ID after successful join
   virtual void postJoinInit( const DtFederateHandle& fedId );

   // Get a copy of the current statistics
   virtual const DtTrafficStats& getNetworkStats() const;

   // Reset the network statistics
   virtual void reset();

   // Print the current state of the statistics
   // - prints in tab-separated values form
   virtual void printStats( bool withHeader = false ) const;

   // Record stats for sent / received message called directly when
   // not using callback method
   // NOTE: - if callbacks are enabled, and this method is used,
   //         it will result in msg duplication!
   virtual void recordSentMsgStats( const DtRtiMsg& msg, double sendTime );
   virtual void recordSentMsgStats(unsigned int fedId, DtRtiMsgKind msgKind, unsigned int msgSize, double time);
   virtual void recordSentMsgStats(unsigned int fedId, DtRtiMsgKind msgKind, unsigned int msgSize, double time, 
      DtObjectClassHandle* classHandle, DtObjectInstanceHandle* instanceHandle);
   virtual void recordSentMsgStats(unsigned int fedId, DtRtiMsgKind msgKind, unsigned int msgSize, double time, 
      DtInteractionClassHandle* classHandle);

   virtual void recordRecvdMsgStats( const DtRtiMsg& msg, double sendTime, bool joined );

   // Record stats for RTI Ambassador and Federate Ambassador API calls and
   // callbacks
   virtual void recordApiStats( const DtRtiAmbAPIType callName, double callTime );
   virtual void recordFedAmbStats( const DtFedAmbAPIType callName, double callTime );

   // Add newly Registered or Discovered objects to the list
   virtual void addRegisteredObject( DtObjectInstanceHandle objHandle,
      DtObjectClassHandle theClass, const char* theObject);
   virtual void addDiscoveredObject( DtObjectInstanceHandle objHandle,
      DtObjectClassHandle theClass, const char* theObject);

   // Add subscribed or published sent and received interactions to the list
   virtual void addSentInteraction( DtInteractionClassHandle theInteraction );
   virtual void addRecvdInteraction( DtInteractionClassHandle theInteraction );

   // Record stats for individual objects and interactions
   virtual void recordObjectStats( bool isSent, unsigned int msgKind,
      unsigned int msgSize, double time, const DtRtiMsg& msg );
   virtual void recordObjectStats(DtObjectInstanceHandle* objectInstanceHandle, DtObjectClassHandle* objectClassHandle, 
      bool isSent, unsigned int msgSize, double time);

   virtual void recordInteractionStats( bool isSent, unsigned int msgKind,
      unsigned int msgSize, double time, const DtRtiMsg& msg );
   virtual void recordInteractionStats(DtInteractionClassHandle* handle, bool isSent, unsigned int msgSize, double time);

   // Adds object class handles to set if publish, subscribe, transport, or order changes.
   virtual void changedPubSubTransOrder(DtObjectClassHandle classHandle);

   // Adds interaction class handles to set if publish, subscribe, transport, or order changes.
   virtual void changedInterPubSubTransOrder(DtInteractionClassHandle classHandle);

   // Callback function for generic DtRtiMsgs: records traffic statistics
   static void processMsg( const DtRtiMsg& msg, void* thisMonitor );

   // Calback for posttick in FedMgr
   static void netStatsPostTick(void* instance);

   // Have the stats changed since the last test? (resets flag)
   virtual bool isChanged();

protected:

   // Instance local version of the processMsg callback
   virtual void processMsg( const DtRtiMsg& msg );

   // Instance local version of the netStatsPostTick callback
   virtual void netStatsPostTick();

   static void processNetStatsObserveReqMsg( const DtAssistantNetStatsObserveReqMsg& msg, void* usr );
   virtual void processNetStatsObserveReqMsg( const DtAssistantNetStatsObserveReqMsg& msg);

   virtual void gatherClassDataAndSend(DtFomClassMgr * fomMgr, DtRtiAssistantLrcClient* rtiAstntLrcClient);

   virtual void gatherInstanceDataAndSend(DtRtiAssistantLrcClient* rtiAstntLrcClient);

   virtual void createSerializedTreesAndSend();

   virtual void recursivelyAddObjects(DtObjectClassInfo::DtObjectClassByHandleMap& objectClasses, MAKRti::DtU32 parentHandle,
      std::vector<MAKRti::DtU32>& objectClassHandles, std::vector<MAKRti::DtU32>& parentObjectClassHandles,
      std::vector<MAKRti::DtString>& objectClassNames);
   void recursivelyAddInteractions(DtInteractionClassInfo::DtInteractionClassByHandleMap& interactionClasses, MAKRti::DtU32 parentHandle,
      std::vector<MAKRti::DtU32>& interactionClassHandles, std::vector<MAKRti::DtU32>& parentInteractionClassHandles,
      std::vector<MAKRti::DtString>& interactionClassNames);

   void sendCurrentAttributeAndParameterValues();
   void sendAttributeNames();   
   void recursivelyAddAttributes(DtObjectClassInfo::DtObjectClassByHandleMap& objectClasses,
      std::vector<MAKRti::DtU32>& objectClassHandles, std::vector<MAKRti::DtU32>& attributeHandles, 
      std::vector<MAKRti::DtString>& attributeNames, std::vector<bool>& attributePub, 
      std::vector<bool>& attributeSub, std::vector<DtTransportType>& attributeTransport, 
      std::vector<DtOrderType>& attributeOrder);
   void recursivelyAddAttributesNames(DtObjectClassInfo::DtObjectClassByHandleMap& objectClasses,
       std::vector<MAKRti::DtU32>& objectClassHandles, std::vector<MAKRti::DtU32>& attributeHandles,
       std::vector<MAKRti::DtString>& attributeNames, std::vector<MAKRti::DtU32>& parentClassHandles,
       std::set<MAKRti::DtString> parentAttributeNames, MAKRti::DtU32 parentClassHandle,
       std::vector<MAKRti::DtU32>& totalObjectHandles);
    void sendParameterNames();
    void recursivelyAddParametersNames(DtInteractionClassInfo::DtInteractionClassByHandleMap& interactionClasses,
       std::vector<MAKRti::DtU32>& interactionClassHandles, std::vector<MAKRti::DtU32>& parameterHandles,
       std::vector<MAKRti::DtString>& parameterNames, std::vector<MAKRti::DtU32>& parentInterHandles,
       std::set<MAKRti::DtString> parentParametersNames, MAKRti::DtU32 parentInterHandle,
       std::vector<MAKRti::DtU32>& totalInterHandles);
    void sendInitAttrState();
    void recursivelyAddAttrInitState(DtObjectClassInfo::DtObjectClassByHandleMap& objectClasses,
       std::vector<MAKRti::DtU32>& objectClassHandles, std::vector<MAKRti::DtU32>& attributeHandles,
       std::vector<bool>& attributePub, std::vector<bool>& attributeSub,
       std::vector<DtTransportType>& attributeTransport, std::vector<DtOrderType>& attributeOrder,
       std::vector<bool>& objectPub, std::vector<bool>& objectSub, std::vector<MAKRti::DtU32>& objPubSubHandles);

    void recursivelyAddParamInitState(DtInteractionClassInfo::DtInteractionClassByHandleMap& interactionClasses,
       std::vector<MAKRti::DtU32>& objectClassHandles,
       std::vector<MAKRti::DtU32>& attributeHandles, std::vector<bool>& attributePub,
       std::vector<bool>& attributeSub, std::vector<DtTransportType>& attributeTransport,
       std::vector<DtOrderType>& attributeOrder, std::vector<bool>& objectPub,
       std::vector<bool>& objectSub, std::vector<MAKRti::DtU32>& objPubSubHandles);
    void sendInitParamState();
    void sendAttributeParameterState();
    void sendAttributeState();
    void sendParameterState();
private:

   // Default ctor, Copy ctor, and Assignment Operator are undefined
   DtNetStatsMonitor();
   DtNetStatsMonitor( const DtNetStatsMonitor& orig );
   DtNetStatsMonitor& operator=( const DtNetStatsMonitor& orig );
   MAKRti::DtString getNameFromObject(DtObjectClassInfo * object);
   MAKRti::DtString getNameFromInteraction(DtInteractionClassInfo * interaction);
protected:

   // LRC's Federate Handle
   DtFederateHandle myFedId;

   // LRC's RTI Ambassador Implementor
   DtRtiAmbassadorImplementor* myRtiAmb;

   // LRC's Fed Amb wrapper which handles stats gathering
   DtNetStatsFedAmbWrapper*    myFedAmbWrap;

   // LRC's connection manager
   DtConnectionMgr*    myConnMgr;             

   // Structure to hold all gathered statistics
   DtTrafficStats      myNetStats;

   // Has there been an update since the last test?
   bool                myChanged;

   // Whether or not this is observed
   bool                isObserved;
   bool                haveSentClassData;

   bool                isFomObserved;
   bool                haveSentInitialFomData;
   bool                haveSentInitState;

   // Minimum interval between sending updates (if observed)
   MAKRti::DtTime      interval;
   MAKRti::DtTime      fomInterval;

   MAKRti::DtClock     intervalTimer;
   MAKRti::DtClock     fomIntervalTimer;

   // LRC's assistant client
   DtRtiAssistantLrcClient* myAssistantClient;

   bool               shouldSendTransport;
   bool               shouldSendOrder;

   public:

      bool isJoined;
};


inline const DtTrafficStats& DtNetStatsMonitor::getNetworkStats() const
{
   return myNetStats;
}
#endif // netStatsMonitor_h__