legionNetworkInterface.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2020 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#pragma once

#include "legionNetworkInterface/legionNetworkInterfaceDefines.h"
#include "vrfMsgTransport/networkManagerInterface.h"
#include "legionNet/boundary.h"
#include <legionDataStore/dataTypes.h>
#include <vlpi/simulationAddress.h>

#include <boost/unordered_map.hpp>
#include <matrix/vlVector.h>
#include <tbb/spin_rw_mutex.h>
#include <set>

#include <boost/signals2.hpp>

class DtCommunicationManager;
class DtUUID;

namespace Legion
{
   class Connection;
   class EventManager;
   class ControlManager;
   class Configuration;
}

namespace makVrfEvents
{
   class DtTransferRequestEvent;
   class DtTransferResponseEvent;
   class DtEvent;
}

namespace makVrf
{
   class DtStateDataManager;
   class DtLegionEventTranslatorManager;
   class DtRemoteObjectManager;
   class DtLegionNetworkInterface;
   class DtLegionOwnershipTransferManager;

   typedef DtLegionNetworkInterface* (*DtLegionNetworkInterfaceCreatorFcn)(DtStateDataManager*, Legion::Connection*, Legion::Configuration*);

   class DT_DLL_legionNetworkInterface DtLegionNetworkInterface : public DtNetworkManagerInterface
   {
   public:

      DtLegionNetworkInterface(DtStateDataManager*, Legion::Connection* useConnection = 0, Legion::Configuration* config = 0);

      virtual ~DtLegionNetworkInterface();

      virtual void beginFrame(double) override;
      virtual bool preAdvanceFrame() override;
      virtual void advanceFrame(double* networkTime = nullptr) override;

      virtual const char* type() const { return Type(); };
      static const char* Type() { return "legion-network-interface"; };

      virtual void setInterest(const DtVector& geocentricCenter, const DtVector& ll, const DtVector& ur);
      virtual void setInterest(const DtVector& geocentricCenter, double radius);
      virtual void setInterest(const Legion::Boundary&, bool andIntent = true);
      virtual void setIntent(const Legion::Boundary&);

      virtual bool selfReflecting() const;
      virtual void setSelfReflecting(bool);

      virtual bool wantsToSelfReflect(unsigned int) const;

      virtual bool printDataToStream(const DtUUID&, DtOutputStream&) const;

      virtual const DtStateData* stateDataForEntityId(const DtEntityIdentifier&) const;

      virtual const DtStateData* stateDataForLegionId(Legion::GlobalIdentifier) const;

      virtual void setRunFullyThreaded(bool) {};
      virtual void setEnabled(bool) {};
      virtual void setCoordinateSystem(const Coordinate_System*);
      virtual void setExerciseStartTime(double);

      virtual bool validateScenario(const DtScenario&, DtString&) const  { return true; };

      virtual void setSiteAppId(int, int);

      virtual void removeAndDeleteAll();

      virtual void setSimTime(double);
      virtual void setTimeMultiplier(double);

      virtual void setNeedsInterestRegionSet(bool val);
      virtual bool needsInterestRegionSet() const;

      virtual DtString nextEventId(const DtString& = DtString::nullString()) override;

      virtual std::string protocol() const override
      {
         return std::string("Legion");
      }

      virtual void setProcessSelfReflect(bool b);
      bool processSelfReflect() const
      {
         return myProcessSelfReflect;
      }

      virtual DtRemoteObjectManager* createRemoteObjectManager();

      static void setLegionNetworkInterfaceCreatorFcn(DtLegionNetworkInterfaceCreatorFcn);
      static DtLegionNetworkInterface* createLegionNetworkInterface(DtStateDataManager*, Legion::Connection* connection = 0,
         Legion::Configuration* config = 0);
      virtual void setEventManager(makVrfEvents::DtEventManager*);
      makVrfEvents::DtEventManager* eventManager()
      {
         return myEventManager;
      }

      DtStateDataManager* stateDataManager()
      {
         return myStateDataManager;
      }

      const DtSimulationAddress& simulationAddress() const
      {
         return mySimulationAddress;
      }

      bool destructing() const
      {
         return myDestructing;
      }

      virtual bool typeIsPublishable(const DtEntityType&) const;

      virtual int clientId() const;
      virtual UInt64 uuidToGlobalId(const DtUUID&) const;
      virtual DtUUID globalIdToUUID(UInt64) const;

      virtual Legion::EventManager* legionEventManager();
      virtual Legion::ControlManager* legionControlManager();

      virtual UInt64 toGlobalIdentifier(const DtEntityIdentifier&) const;
      virtual DtEntityIdentifier toEntityIdentifier(UInt64) const;

      virtual const makVrf::DtStateData* stateDataForGlobalId(const DtString&) const;

      virtual void setDisableRemoteDiscovery(bool);
      bool disableRemoteDiscovery() const
      {
         return myDisableRemoteDiscovery;
      }

      virtual void setProcessRemoteObjectsInParallel(bool);
      bool processRemoteObjectsInParallel() const
      {
         return myProcessRemoteObjectsInParallel;
      }

      virtual void setNumCallbackThreads(unsigned);

      DtLegionOwnershipTransferManager* ownershipTransferManager()
      {
         return myOwnershipTransferManager;
      }

      DtCommunicationManager* communicationManager()
      {
         return myCommunicationManager;
      }

      Legion::Connection* connection()
      {
         return mySTEConnection;
      }

      DtLegionEventTranslatorManager* eventTranslatorManager()
      {
         return myLegionEventTranslatorManager;
      }

      virtual bool needsUnpublishedDatabase() const
      {
         return true;
      }

   protected:
      virtual bool stateDataAdded(DtStateData*);

      virtual void stateDataAboutToBeRemoved(const DtStateData*);

      virtual bool init(DtCommunicationManager*);

      virtual void reserve(unsigned numToReserve);

      virtual void printReflectedObjectCounts() const;

      virtual void requestUpdatesForRemoteNonVrfObjects() const;

      virtual void rediscoverObjects(const std::set<DtString>& ignore);

      virtual unsigned int maxNameLengthForType(const DtObjectType&) const { return 0xFFFFFFFF; };

      virtual void startScenarioLoad(bool);
      virtual void endScenarioLoad(bool) {};
      virtual void setParameterDatabase(DtVrfParameterDb*) {};
      virtual void setVrfSessionId(int) {};
      virtual void setVrfMessageVersionSupported(int) {};
      virtual void resetSimulation();
      virtual void rewindScenario();

      virtual void run();

      virtual void pause();

      virtual void setFrameRateMode(const DtString& mode, double deltaTime, bool manageTime = false);

      virtual AddEventResult addEvent(const makVrfEvents::DtEvent&, bool& selfReflected);

      virtual AddEventResult sendEvent(const makVrfEvents::DtEvent&);

      virtual bool hasSimulationTime() const { return false; };

      virtual bool rediscoverObjects();

      virtual bool publishingOnLegionNetwork() const { return true; };

   protected:
      DtStateDataManager* myStateDataManager;
      Legion::Connection* mySTEConnection;
      std::set<makVrf::SimStateID> myPublishing;
      mutable tbb::spin_rw_mutex myPublishMutex;

      typedef boost::unordered_map<UInt64, const DtStateData*> StateDataByEntityId;
      StateDataByEntityId myStateDataByEntityId;
      bool myNeedsInterestSet;
      DtSimulationAddress mySimulationAddress;
      int myAppId;
      int myEntityId;
      makVrfEvents::DtEventManager* myEventManager;
      const Coordinate_System* myCoordinateSystem;
      DtLegionEventTranslatorManager* myLegionEventTranslatorManager;
      bool myOwnsLegionConnection;

      Legion::EventManager* myLegionEventManager;
      Legion::ControlManager* myLegionControlManager;

      bool myProcessSelfReflect;

      static DtLegionNetworkInterfaceCreatorFcn theCreatorFunction;
      DtCommunicationManager* myCommunicationManager;

      DtRemoteObjectManager* myRemoteObjectManager;
      bool myDisableRemoteDiscovery;
      bool myProcessRemoteObjectsInParallel;
      unsigned int myNumCallbackThreads;

      DtLegionOwnershipTransferManager* myOwnershipTransferManager;
      bool myDestructing;
   };
}