Example

The timeMgmtHlaBroker example:

• Creates a new portal object to represent the broker's HLA time management state.
• Creates a translator to inform other HLA brokers what the current time state of this federation is. This is used to keep times synchronized between multiple federations through VR-Exchange. Timestamp ordered messages are still translated only in receive order.
• Adds an additional command line and configuration file option to specify the lookahead value.

---

/*********************************************************************
 ** Copyright (c) 1992-2012 VT MAK
 ** All rights reserved.
 *********************************************************************/



#include "timeMgmtTrans.h"
#include "timeMgmtBrokerInit.h"

#include <libRprBroker/rprBroker.h>
#include <libRprBroker/rprBrokerApp.h>
#include <libRprBroker/rprBrokerInitializer.h>

#include <portal/pConnection.h>
#include <vlutil/vlExceptions.h>
#include <iostream>

using namespace MAKVrExchange;
using namespace MAKVrExchange::DtRprBroker;

int main( int argc, char* argv[] )
{
   try
   {
      DtInfo << "Starting HLA Broker with Time Management Support" << std::endl;

      // Load the configuration options
      DtTimeManagementBrokerInitializer* hlaInit =
         new DtTimeManagementBrokerInitializer( argc, argv,
         DtPortalConnection::version().c_str() );
      hlaInit->parseCmdLine(); //Automatically loads the file specified by the CmdLine

      DtRprBrokerApp brokerApp( hlaInit );
      if ( ! hlaInit->showConnectionInfoDialog() )
      {
         // Install the time management translator by creating a default factory.
         // This needs to be done before the call to DtBrokerApp::run() where all
         // the translator instances are created. The translator name is used by
         // the factory, so if you want to replace a translator it needs to have
         // the same name, but if you want to add a translator it should have a
         // different name. 
         brokerApp.rprBroker()->objectTranslatorFactory()->
            addCreator<DtTimeManagementTranslator>();
         brokerApp.run();
      }
      else
      {
         brokerApp.showInfoDialog();
      }
   }
   DtCATCH_AND_WARN( std::cout )

   return 0;
}

---

/****************************************************************************
 * Copyright (c) 2012 VT MAK
 * All rights reserved.
 ****************************************************************************/


#include "timeMgmtTrans.h"
#include "timeMgmtBrokerInit.h"
#include <libRprBroker/rprBroker.h>
#include <portal/pCollisionInter.h>
#include <portal/pMessageKinds.h>
#include <vl/collideInter.h>
#include <vl/exerciseConn.h>

#ifdef DtHLA_1516_EVOLVED
#include <RTI/RTI1516.h>
#include <RTI/RTIambassadorFactory.h>
#include <RTI/time/HLAfloat64TimeFactory.h>
#include <RTI/time/HLAfloat64Time.h>
#include <RTI/time/HLAfloat64Interval.h>
#elif defined DtHLA_1516
#include <RTI/RTI1516.h>
#include <RTI/RTIambassadorFactory.h>
#include <RTI/logicalTimeFactoryImpl.h>
#include <RTI/logicalTimeImpl.h>
#include <RTI/logicalTimeIntervalImpl.h>
#else // HLA 1.3
#include <fedtime.hh>
#endif



DtTimeManagementTranslator::DtTimeManagementTranslator(
      MAKVrExchange::DtRprBroker::DtRprBroker* broker )
   : DtObjectTranslator( broker, translatorName(), DtPortalTimeMgmtObject::theKind )
   , myRprBroker( broker )
   , myPortalReflectedList(0)
   , myPortalPublisher(0)
   , myLookahead(1.0)
   , myCurrentLbts(0)
   , myCurrentTime(0)
   , myIsTimeRegulating(false)
   , myIsTimeConstrained(false)
   , myRequestTime(false)
{
   try
   {
      DtTimeManagementBrokerInitializer* initializer =
         dynamic_cast<DtTimeManagementBrokerInitializer*>(broker->brokerInitializer());
      if(initializer)
      {
         myLookahead = initializer->lookahead();
      }

      myPortalReflectedList = new DtPortalReflectedTimeMgmtObjectManager( broker->portalConnection() );
      myPortalReflectedList->addRemovalCallback( portalRemovalCallback, this );
      myPortalReflectedList->setDiscoveryCondition( portalDiscoveryCriteria, this );

      myPortalPublisher = new DtPortalTimeMgmtObjectPublisher(broker->portalConnection());
      DtString tmObjId("TmObj");
      tmObjId += DtString(broker->brokerId());
      myPortalPublisher->sr()->setIdentifier(tmObjId);

      // Register for any callbacks that inform us of our logical time
      broker->connection()->fedAmb()->addTimeConstrainedEnabledCb(processTimeConstrained, this);
      broker->connection()->fedAmb()->addTimeRegulationEnabledCb(processTimeRegulating, this);
      broker->connection()->fedAmb()->addTimeAdvanceGrantCb(processTimeGrant, this);

      // Enable asynchronous delivery. We want to receive RO messages regardless
      // of whether or not we are time advancing.
      broker->connection()->rtiAmb()->enableAsynchronousDelivery();
   }
   DtCATCH_AND_PROPAGATE( DtException );
}

DtTimeManagementTranslator::~DtTimeManagementTranslator()
{
   DtDELETE( myPortalReflectedList );
}

void DtTimeManagementTranslator::enableTranslator(bool enabled)
{
   if(enabled)
   {
      myPortalReflectedList->addAdditionCallback( portalAdditionCallback, this );

      // Become time regulating and constrained
      if(!myIsTimeRegulating)
      {
#ifdef DtHLA_1516_EVOLVED
         rti1516e::HLAfloat64Interval lookAhead(myLookahead);
         myRprBroker->connection()->rtiAmb()->enableTimeRegulation(lookAhead);
#elif defined DtHLA_1516
         LogicalTimeIntervalImpl lookAhead(myLookahead);
         myRprBroker->connection()->rtiAmb()->enableTimeRegulation(lookAhead);
#else // HLA 1.3
         RTIfedTime currentTime(0.0);
         RTIfedTime lookAhead(myLookahead);
         myRprBroker->connection()->rtiAmb()->enableTimeRegulation(currentTime, lookAhead);
#endif
      }
      if(!myIsTimeConstrained)
      {
         myRprBroker->connection()->rtiAmb()->enableTimeConstrained();
      }
   }
   else
   {
      myPortalReflectedList->removeAdditionCallback( portalAdditionCallback, this );

      // Stop being time regulating and constrained
      if(myIsTimeRegulating)
      {
         myRprBroker->connection()->rtiAmb()->disableTimeRegulation();
         myIsTimeRegulating = false;
      }
      if(myIsTimeConstrained)
      {
         myRprBroker->connection()->rtiAmb()->disableTimeConstrained();
         myIsTimeConstrained = false;
      }
   }
}

void DtTimeManagementTranslator::tick()
{
   try
   {
      if(myRequestTime)
      {
         advanceTime();
      }

      myPortalPublisher->tick();
   }
   DtCATCH_AND_PROPAGATE( DtException )
}

void DtTimeManagementTranslator::portalAdditionCallback(
   const DtPortalReflectedTimeMgmtObject& object, void* userData )
{
   DtTimeManagementTranslator *translator = static_cast<DtTimeManagementTranslator*>( userData );
   translator->discoverPortalObject( object );
}

void DtTimeManagementTranslator::portalUpdateCallback(
   const DtPortalReflectedTimeMgmtObject& object, void* userData )
{
   DtTimeManagementTranslator *translator = static_cast<DtTimeManagementTranslator*>( userData );
   translator->receivePortalUpdate( object );
}

void DtTimeManagementTranslator::portalRemovalCallback(
   const DtPortalReflectedTimeMgmtObject& object, void *userData )
{
   DtTimeManagementTranslator *translator = static_cast<DtTimeManagementTranslator*>( userData );
   translator->removePortalObject( &object );
}

void DtTimeManagementTranslator::discoverPortalObject(
   const DtPortalReflectedTimeMgmtObject& object )
{
   try
   {
      object.addUpdateCallback( portalUpdateCallback, this );
      receivePortalUpdate( object );
   }
   DtCATCH_AND_PROPAGATE( DtException )
}

void DtTimeManagementTranslator::receivePortalUpdate(
   const DtPortalReflectedTimeMgmtObject& object )
{
   try
   {
      const DtPortalTimeMgmtObject& portalTMState = *(object.sr());

      myLbtsValues[portalTMState.identifier()] = portalTMState.lbts();
   }
   DtCATCH_AND_PROPAGATE( DtException )
}

bool DtTimeManagementTranslator::portalDiscoveryCriteria(
   const MAKVrExchange::DtPortalReflectedObject* object, void* userData )
{
   bool canBeDiscovered = false;

   if (userData && object)
   {
      canBeDiscovered = true;
   }

   return canBeDiscovered;
}

void DtTimeManagementTranslator::processTimeGrant(
#if DtHLA_1516
   const RTI::LogicalTime &fedTime,
#else
   const RTI::FedTime &fedTime,
#endif
   void *usr)
{
   reinterpret_cast<DtTimeManagementTranslator*>(usr)->processTimeGrant(fedTime);
}

void DtTimeManagementTranslator::processTimeGrant(
#if DtHLA_1516
   const RTI::LogicalTime &fedTime)
#else
   const RTI::FedTime &fedTime)
#endif
{
#ifdef DtHLA_1516_EVOLVED
   myCurrentTime = static_cast<rti1516e::HLAfloat64Time>(fedTime).getTime();
#elif defined DtHLA_1516
   myCurrentTime = static_cast<LogicalTimeImpl>(fedTime).getTime();
#else // HLA 1.3
   myCurrentTime = static_cast<RTIfedTime>(fedTime).getTime();
#endif

   myRequestTime = true;
}


void DtTimeManagementTranslator::processTimeRegulating(
#if DtHLA_1516
   const RTI::LogicalTime &fedTime,
#else
   const RTI::FedTime &fedTime,
#endif
   void *usr)
{
   reinterpret_cast<DtTimeManagementTranslator*>(usr)->processTimeRegulating(fedTime);
}

void DtTimeManagementTranslator::processTimeRegulating(
#if DtHLA_1516
   const RTI::LogicalTime &fedTime)
#else
   const RTI::FedTime &fedTime)
#endif
{
   myIsTimeRegulating = true;

#ifdef DtHLA_1516_EVOLVED
   myCurrentTime = static_cast<rti1516e::HLAfloat64Time>(fedTime).getTime();
#elif defined DtHLA_1516
   myCurrentTime = static_cast<LogicalTimeImpl>(fedTime).getTime();
#else // HLA 1.3
   myCurrentTime = static_cast<RTIfedTime>(fedTime).getTime();
#endif

   if(myIsTimeRegulating && myIsTimeConstrained)
   {
      myRequestTime = true;
   }
}


void DtTimeManagementTranslator::processTimeConstrained(
#if DtHLA_1516
   const RTI::LogicalTime &fedTime,
#else
   const RTI::FedTime &fedTime,
#endif
   void *usr)
{
   reinterpret_cast<DtTimeManagementTranslator*>(usr)->processTimeConstrained(fedTime);
}

void DtTimeManagementTranslator::processTimeConstrained(
#if DtHLA_1516
   const RTI::LogicalTime &fedTime)
#else
   const RTI::FedTime &fedTime)
#endif
{
   myIsTimeConstrained = true;

#ifdef DtHLA_1516_EVOLVED
   myCurrentTime = static_cast<rti1516e::HLAfloat64Time>(fedTime).getTime();
#elif defined DtHLA_1516
   myCurrentTime = static_cast<LogicalTimeImpl>(fedTime).getTime();
#else // HLA 1.3
   myCurrentTime = static_cast<RTIfedTime>(fedTime).getTime();
#endif

   if(myIsTimeRegulating && myIsTimeConstrained)
   {
      myRequestTime = true;
   }
}

void DtTimeManagementTranslator::advanceTime()
{
   // Get current LBTS/GALT
#ifdef DtHLA_1516_EVOLVED
   rti1516e::HLAfloat64Time galt;
   myRprBroker->connection()->rtiAmb()->queryGALT(galt);

   if(galt.isFinal())
   {
      // No other regulating federates yet. Just stick to our current time.
      myCurrentLbts = myCurrentTime;
   }
   else
   {
      myCurrentLbts = galt.getTime();
   }
#elif defined DtHLA_1516
   LogicalTimeImpl galt;
   myRprBroker->connection()->rtiAmb()->queryGALT(galt);

   if(galt.isFinal())
   {
      // No other regulating federates yet. Just stick to our current time.
      myCurrentLbts = myCurrentTime;
   }
   else
   {
      myCurrentLbts = galt.getTime();
   }
#else // HLA 1.3
   RTIfedTime lbts;
   myRprBroker->connection()->rtiAmb()->queryLBTS(lbts);

   if(lbts.isPositiveInfinity())
   {
      // No other regulating federates yet. Just stick to our current time.
      myCurrentLbts = myCurrentTime;
   }
   else
   {
      myCurrentLbts = lbts.getTime();
   }
#endif

   // Inform other brokers of current LBTS/GALT
   if(myCurrentLbts != myPortalPublisher->sr()->lbts())
   {
      myPortalPublisher->sr()->setLbts(myCurrentLbts);
      myPortalPublisher->tick();
   }

   // Determine the lowest of all the LBTS values
   double lowestLbts = myCurrentLbts;

   std::map<DtString, double>::const_iterator lbtsIter = myLbtsValues.begin();
   std::map<DtString, double>::const_iterator iterEnd = myLbtsValues.end();
   for(; lbtsIter != iterEnd; ++lbtsIter)
   {
      if(lbtsIter->second < lowestLbts)
      {
         lowestLbts = lbtsIter->second;
      }
   }

   // Perform time advance request to lowest LBTS/GALT value.
   // TAR is only done if our current time is less than the request value.
   // If not, then we are ahead of other federations, and we need to chill.
   if(myCurrentTime < lowestLbts)
   {
      myRequestTime = false;
#ifdef DtHLA_1516_EVOLVED
      rti1516e::HLAfloat64Time req(lowestLbts);
#elif defined DtHLA_1516
      LogicalTimeImpl req(lowestLbts);
#else // HLA 1.3
      RTIfedTime req(lowestLbts);
#endif
      myRprBroker->connection()->rtiAmb()->timeAdvanceRequest(req);
   }
}

void DtTimeManagementTranslator::createPortalPublisher( DtBrokerObject* brokerObject )
{
}

void DtTimeManagementTranslator::createHlaPublisher(DtBrokerObject* brokerObject)
{
}

void DtTimeManagementTranslator::deletePortalPublisher(DtBrokerObject* brokerObject)
{
}

void DtTimeManagementTranslator::deleteHlaPublisher(DtBrokerObject* brokerObject)
{
}

bool DtTimeManagementTranslator::isPortalPublishable(const DtBrokerObject* brokerObject) const
{
   return true;
}

bool DtTimeManagementTranslator::isHlaPublishable(const DtBrokerObject* brokerObject) const
{
   return false;
}

---

/******************************************************************************
 ** Copyright (c) 1992-2012 VT MAK
******************************************************************************/



#include "pTimeMgmtObj.h"
#include <vlutil/vlPrintUtil.h>       //DtPrintAttribute()


const MAKVrExchange::DtPortalMessageKind DtPortalTimeMgmtObject::theKind = 
   MAKVrExchange::DtPortalMessageKind(MAKVrExchange::DtMaxReservedMessageKinds+1);

DtPortalTimeMgmtObject::DtPortalTimeMgmtObject() 
   : MAKVrExchange::DtPortalBaseObject()
   , myLbts(0)
{
}

DtPortalTimeMgmtObject::~DtPortalTimeMgmtObject()
{
}

DtPortalTimeMgmtObject::DtPortalTimeMgmtObject( const DtPortalTimeMgmtObject &original )
   : DtPortalBaseObject( original )
   , myLbts( original.lbts() )
{
}

DtPortalTimeMgmtObject &DtPortalTimeMgmtObject::operator=( const DtPortalTimeMgmtObject& original )
{
   if (this != &original)
   {
      DtPortalBaseObject::operator=( original );
      setLbts( original.lbts() );
   }
   return *this;
}

int DtPortalTimeMgmtObject::operator==( const DtPortalTimeMgmtObject &rightOperand ) const
{
   int rc = ( (DtPortalBaseObject::operator==( rightOperand )) &&
              (myLbts == rightOperand.lbts()) );

   return rc;
}

int DtPortalTimeMgmtObject::operator!=( const DtPortalTimeMgmtObject &rightOperand ) const
{
   return ! (*this == rightOperand);
}

unsigned int DtPortalTimeMgmtObject::netSize() const
{
   int size = DtPortalBaseObject::netSize();

   size += getSize( myLbts );

   return size;
}

void DtPortalTimeMgmtObject::writeSelfToBuffer(void *buffer) const
{
   DtPortalBaseObject::writeSelfToBuffer( buffer );

   char *ptr = (char *)buffer + DtPortalBaseObject::netSize();

   ptr = encode( myLbts, ptr );
}

void DtPortalTimeMgmtObject::readSelfFromBuffer(const void *buffer)
{
   DtPortalBaseObject::readSelfFromBuffer( buffer );

   const char *ptr = (const char *)buffer + DtPortalBaseObject::netSize();

   ptr = decode( myLbts, ptr );
}


std::ostream &DtPortalTimeMgmtObject::printDataToStream( std::ostream &stream ) const
{
   DtPortalBaseObject::printDataToStream( stream );

   DtPrintAttribute( stream, "LBTS", myLbts );

   return stream;
}