source: XIOS3/branches/xios-3.0-beta/src/node/context.hpp @ 2423

#ifndef __XIOS_CContext__
#define __XIOS_CContext__

/// XIOS headers ///
#include "xios_spl.hpp"
//#include "node_type.hpp"
#include "calendar_wrapper.hpp"

#include "declare_group.hpp"
#include "data_output.hpp"
#include "garbage_collector.hpp"
#include "registry.hpp"
#include "mpi.hpp"
#include "services_manager.hpp"
#include "server_context.hpp"
#include "event_scheduler.hpp"


namespace xios
{
   class CContextClient;
   class CContextServer;


   /// ////////////////////// Déclarations ////////////////////// ///
   class CContextGroup;
   class CContextAttributes;
   class CContext;
   class CFile;
   class CCouplerIn ;
   class CCouplerOut ;
   ///--------------------------------------------------------------

   // Declare/Define CFileAttribute
   BEGIN_DECLARE_ATTRIBUTE_MAP(CContext)
#  include "context_attribute.conf"
   END_DECLARE_ATTRIBUTE_MAP(CContext)

   ///--------------------------------------------------------------
  /*!
  \class CContext
   This class corresponds to the concrete presentation of context in xml file and in play an essential role in XIOS
   Each object of this class contains all root definition of elements: files, fiels, domains, axis, etc, ... from which
   we can have access to each element.
   In fact, every thing must a be inside a particuliar context. After the xml file (iodef.xml) is parsed,
   object of the class is created and its contains all information of other elements in the xml file.
  */
   class CContext
      : public CObjectTemplate<CContext>
      , public CContextAttributes
   {
         public :
         enum EEventId
         {
           EVENT_ID_COLLECTIVE=100,
           EVENT_ID_CLOSE_DEFINITION,EVENT_ID_UPDATE_CALENDAR,
           EVENT_ID_CREATE_FILE_HEADER,EVENT_ID_CONTEXT_FINALIZE,
           EVENT_ID_CONTEXT_FINALIZE_CLIENT,
           EVENT_ID_COUPLER_IN_READY,
           EVENT_ID_COUPLER_IN_CLOSE_DEFINITION,
           EVENT_ID_COUPLER_IN_CONTEXT_FINALIZED,
           EVENT_ID_NO_COLLECTIVE=1000,
         };

         /// typedef ///
         typedef CObjectTemplate<CContext>   SuperClass;
         typedef CContextAttributes SuperClassAttribute;

      public :

         typedef CContextAttributes RelAttributes;
         typedef CContext           RelGroup;

         //---------------------------------------------------------

      public :

         /// Constructeurs ///
         CContext(void);
         explicit CContext(const StdString & id);
         CContext(const CContext & context);       // Not implemented yet.
         CContext(const CContext * const context); // Not implemented yet.

         /// Destructeur ///
         virtual ~CContext(void);

         static void releaseStaticAllocation(void) ;

         //---------------------------------------------------------

      public :

         /// Mutateurs ///
         void setCalendar(std::shared_ptr<CCalendar> newCalendar);

         /// Accesseurs ///
         std::shared_ptr<CCalendar>      getCalendar(void) const;

      public :
         // Initialize server or client
         void init(CServerContext* parentServerContext, MPI_Comm intraComm, int serviceType);
         void initClient(MPI_Comm intraComm, int serviceType);
         
         void initServer(MPI_Comm intraComm, int serviceType );
         void createClientInterComm(MPI_Comm interCommClient, MPI_Comm interCommServer)  ;
         void createServerInterComm(void)  ;

         bool isInitialized(void);

         StdString dumpClassAttributes(void);

         // Put sever or client into loop state
         bool eventLoop(bool enableEventsProcessing=true);
         bool scheduledEventLoop(bool enableEventsProcessing=true) ; 
         void globalEventLoop(void);

         // Finalize a context
         void finalize(void);

         bool isFinalized(void);

         void closeDefinition(void);

         // to be removed     
         std::vector<CField*> findAllEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
         // Some functions to process context
         std::vector<CField*> findAllEnabledFieldsInFileOut(const std::vector<CFile*>& activeFiles);
         std::vector<CField*> findAllEnabledFieldsInFileIn(const std::vector<CFile*>& activeFiles);
         std::vector<CField*> findAllEnabledFieldsCouplerOut(const std::vector<CCouplerOut*>& activeCouplerOut);
         std::vector<CField*> findAllEnabledFieldsCouplerIn(const std::vector<CCouplerIn*>& activeCouplerIn);
         // void findAllEnabledFields(void);
         // void findAllEnabledFieldsInReadModeFiles(void);
         void readAttributesOfEnabledFieldsInReadModeFiles();
         void solveAllInheritance(bool apply=true);
         void findEnabledFiles(void);
         void findEnabledCouplerIn(void);
         void findEnabledCouplerOut(void);
         void createCouplerInterCommunicator(void) ;
         void findEnabledWriteModeFiles(void);
         void findEnabledReadModeFiles(void);
         void closeAllFile(void);
         void updateCalendar(int step);
         void createFileHeader(void);
         void initReadFiles(void);
         void prepareTimeseries(void);
         void postProcessFilterGraph();
         void startPrefetchingOfEnabledReadModeFiles();
         void doPreTimestepOperationsForEnabledReadModeFiles();
         void doPostTimestepOperationsForEnabledReadModeFiles();
         void findFieldsWithReadAccess(void);
         void triggerLateFields(void) ;
          
         std::map<int, StdSize> getAttributesBufferSize(std::map<int, StdSize>& maxEventSize, CContextClient* contextClient, bool bufferForWriting = false);
         std::map<int, StdSize> getDataBufferSize(std::map<int, StdSize>& maxEventSize, CContextClient* contextClient, bool bufferForWriting = false);

         // Distribute files (in write mode) among secondary-server pools according to the estimated data flux
         void distributeFiles(const std::vector<CFile*>& files);
         void distributeFileOverBandwith(const std::vector<CFile*>& files) ;
         void distributeFileOverMemoryBandwith(const std::vector<CFile*>& files) ;
         
         // Send context close definition
         void sendCloseDefinition(void);
       public:
         void sendCloseDefinition(CContextClient* client) ;
       private:
         set<CContextClient*> sendCloseDefinition_done_ ;
       public:
         // There are something to send on closing context defintion
         void sendUpdateCalendar(int step);
         void sendCreateFileHeader(void);
         void sendEnabledFiles(const std::vector<CFile*>& activeFiles);
         void sendEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
         void sendRefDomainsAxisScalars(const std::vector<CFile*>& activeFiles);
         //!< after be gathered to the root process of the context, merged registry is sent to the root process of the servers
         void sendFinalizeClient(CContextClient* contextClient, const string& contextClientId);
         
         public:
         void sendContextToFileServer(CContextClient* client) ;
         private:
         std::set<CContextClient*> sendToFileServer_done_ ;
         
         public: 
         std::string getContextId() {return contextId_;}

         // Client side: Receive and process messages
         static void recvUpdateCalendar(CEventServer& event);
         void recvUpdateCalendar(CBufferIn& buffer);
         static void recvCloseDefinition(CEventServer& event);
         static void recvCreateFileHeader(CEventServer& event);
         void recvCreateFileHeader(CBufferIn& buffer);
         static void recvSolveInheritanceContext(CEventServer& event);
         void recvSolveInheritanceContext(CBufferIn& buffer);
         static void recvFinalizeClient(CEventServer& event) ;
         void recvFinalizeClient(CBufferIn& buffer);
        
       public:
         void sendCouplerInReady(CContextClient* client);
       private:
         set<CContextClient*> sendCouplerInReady_done_;
       public:
         static void recvCouplerInReady(CEventServer& event) ;
         void recvCouplerInReady(CBufferIn& buffer) ; //!< coupler is ready to receive grid definition.
         set<CContextClient*> couplerInReady_;
         bool isCouplerInReady(CContextClient* client) { return couplerInReady_.count(client)!=0 ;}

       public:
        void sendCouplerInCloseDefinition(CContextClient* client) ;
        set<CContextClient*> sendCouplerInCloseDefinition_done_;
        static void recvCouplerInCloseDefinition(CEventServer& event) ;
        void recvCouplerInCloseDefinition(CBufferIn& buffer) ; //!< coupler has finished it defintion, data can be sent     
        set<CContextClient*> couplerInCloseDefinition_ ;
        bool isCouplerInCloseDefinition(CContextClient* client) { return couplerInCloseDefinition_.count(client)!=0 ;}

       public:
        void sendCouplerInContextFinalized(CContextClient* client) ;
        set<CContextClient*> sendCouplerInContextFinalized_done_;
        static void recvCouplerInContextFinalized(CEventServer& event) ;
        void recvCouplerInContextFinalized(CBufferIn& buffer) ; //!< coupler has finished it defintion, data can be sent     
        set<CContextClient*> couplerInContextFinalized_ ;
        bool isCouplerInContextFinalized(CContextClient* client) { return couplerInContextFinalized_.count(client)!=0 ;}

       public:  
        void freeComms(void);                  //!< Free internally allcoated communicators
        void releaseClientBuffers(void);       //! Deallocate buffers allocated by clientContexts

         // dispatch event
         static bool dispatchEvent(CEventServer& event);

      public:
        // Get current context
        static CContext* getCurrent(void);

        // Get context root
        static CContextGroup* getRoot(void);
       
        // Set current context
        static void setCurrent(const string& id);

        // Create new context
        static CContext* create(const string& id = "");

        /// Accesseurs statiques ///
        static StdString GetName(void);
        static StdString GetDefName(void);
        static ENodeType GetType(void);

        static CContextGroup* GetContextGroup(void);

        // Some functions to visualize structure of current context
        static void ShowTree(StdOStream & out = std::clog);
        static void CleanTree(void);
        static void removeContext(const std::string& contextId);
        static void removeAllContexts(void) ;
        int getServiceType(void) {return serviceType_;}

      public :
         // Parse xml node and write all info into context
         virtual void parse(xml::CXMLNode & node);

         // Visualize a context
         virtual StdString toString(void) const;


         // Solve all inheritance relation in current context
         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0);

         // Verify if all root definition in a context have children
         virtual bool hasChild(void) const;

         bool isProcessingEvent(void) {return isProcessingEvent_;}
         bool setProcessingEvent(void) {isProcessingEvent_=true ;}
         bool unsetProcessingEvent(void) {isProcessingEvent_=false ;}
         MPI_Comm getIntraComm(void) {return intraComm_ ;}
         int getIntraCommRank(void) {return intraCommRank_;}
         int getIntraCommSize(void) {return intraCommSize_;}

         void addCouplingChanel(const std::string& contextId, bool out) ;

      public :
         // Calendar of context
         std::shared_ptr<CCalendar>   calendar;

         // List of all enabled files (files on which fields are written or read)
         std::vector<CFile*> enabledFiles;
         // List of all enabled files in read mode (files on which fields are read)
         std::vector<CFile*> enabledReadModeFiles;
         // List of all enabled files in write mode
         std::vector<CFile*> enabledWriteModeFiles;

         std::vector<CCouplerIn*> enabledCouplerIn;
         std::vector<CCouplerOut*> enabledCouplerOut;


         // List of all enabled fields whose instant data is accessible from the public API
         // but which are not part of a file
         std::vector<CField*> fieldsWithReadAccess_;
         std::vector<CField*> couplerInFields_;
         std::vector<CField*> fileInFields_;


         // Context root
         static std::shared_ptr<CContextGroup> root;

         // Determine context on client or not
         bool hasClient;

         // Determine context on server or not
         bool hasServer;

         CContextServer* server;    //!< Concrete context server
         CContextClient* client;    //!< Concrete contex client
         std::vector<CContextServer*> serverPrimServer;
         std::vector<CContextClient*> clientPrimServer;

         // list of slave servers (IO server or others)
         // Already in trunk within the new service management, commit ids = [2405-2407]
         std::vector<CContextClient*> slaveServers_ ;
         std::map<CContextClient*, std::string> clientsId_ ;

      private:
         // the map containing context client associated to it string id for coupling out ;
         std::map<std::string, CContextClient*> couplerOutClient_ ;
         // the map containing context server associated to it string id for coupling out ;
         std::map<std::string, CContextServer*> couplerOutServer_ ;
         // the map containing context client associated to it string id for coupling in ;
         std::map<std::string, CContextClient*> couplerInClient_ ;
         // the map containing context server associated to it string id for coupling in ;
         std::map<std::string, CContextServer*> couplerInServer_ ;
      public:
         CContextClient* getCouplerInClient(const string& contextId) { return couplerInClient_[contextId] ;}
         CContextServer* getCouplerInServer(const string& contextId) { return couplerInServer_[contextId] ;}
         CContextClient* getCouplerOutClient(const string& contextId) { return couplerOutClient_[contextId] ;}
         CContextServer* getCouplerOutServer(const string& contextId) { return couplerOutServer_[contextId] ;}
      
  
         std::vector<std::string> primServerId_;

         CRegistry* registryIn=nullptr ;    //!< input registry which is read from file
         CRegistry* registryOut=nullptr ;   //!< output registry which will be written into file at the finalize


        MPI_Comm intraComm_ ; //! context intra communicator
        int intraCommRank_ ; //! context intra communicator rank
        int intraCommSize_ ; //! context intra communicator size
        
      private:
         CEventScheduler* eventScheduler_ ; //! The local event scheduler for context
         size_t hashId_ ; //! the local hashId for scheduler
         size_t timeLine_=0 ;
         void initEventScheduler(void) ;

         bool isPostProcessed;
         bool allProcessed;
         bool finalized;
         int countChildContextFinalized_;        //!< Counter of child contexts (for now it is the number of secondary server pools)
         CGarbageCollector garbageCollector;
         std::list<MPI_Comm> comms; //!< Communicators allocated internally

         int serviceType_;  //!< service associated to the context
         string contextId_ ; //!< context client id for the servers. For clients this is same as getId() 
         bool isProcessingEvent_ ;
    private:     
         CServerContext* parentServerContext_ ;
    public:
         CServerContext* getParentServerContext(void) { return parentServerContext_; }
    private: 
      bool lockedContext_=false;
    public: 
        void lockContext(void) {lockedContext_=true; }
        void unlockContext(void) {lockedContext_=false; }
        bool isLockedContext(void) { return lockedContext_;}
      public: // Some function maybe removed in the near future
        // virtual void toBinary  (StdOStream & os) const;
        // virtual void fromBinary(StdIStream & is);
   }; // class CContext

   ///--------------------------------------------------------------

   // Declare/Define CContextGroup and CContextDefinition
   DECLARE_GROUP(CContext);

   ///--------------------------------------------------------------

} // namespace xios

#endif // __XIOS_CContext__