source: XIOS/dev/dev_olga/src/node/context.hpp @ 1612

Last change on this file since 1612 was 1612, checked in by oabramkina, 5 years ago

Dev: adding exception handling.

To activate it, compilation flag -DXIOS_EXCEPTION should be added.

  • Property copyright set to
    Software name : XIOS (Xml I/O Server)
    http://forge.ipsl.jussieu.fr/ioserver
    Creation date : January 2009
    Licence : CeCCIL version2
    see license file in root directory : Licence_CeCILL_V2-en.txt
    or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
    Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
    CNRS/IPSL (Institut Pierre Simon Laplace)
    Project Manager : Yann Meurdesoif
    yann.meurdesoif@cea.fr
File size: 10.9 KB
RevLine 
[591]1#ifndef __XIOS_CContext__
2#define __XIOS_CContext__
[219]3
[591]4/// XIOS headers ///
5#include "xios_spl.hpp"
[352]6//#include "node_type.hpp"
[549]7#include "calendar_wrapper.hpp"
[219]8
9#include "declare_group.hpp"
[300]10#include "data_output.hpp"
[639]11#include "garbage_collector.hpp"
[697]12#include "registry.hpp"
[382]13#include "mpi.hpp"
[300]14
[219]15
[335]16namespace xios {
[549]17   class CContextClient;
18   class CContextServer;
[509]19
20
[219]21   /// ////////////////////// Déclarations ////////////////////// ///
22   class CContextGroup;
23   class CContextAttributes;
24   class CContext;
[352]25   class CFile;
[219]26   ///--------------------------------------------------------------
27
28   // Declare/Define CFileAttribute
29   BEGIN_DECLARE_ATTRIBUTE_MAP(CContext)
30#  include "context_attribute.conf"
31   END_DECLARE_ATTRIBUTE_MAP(CContext)
32
33   ///--------------------------------------------------------------
[509]34  /*!
35  \class CContext
36   This class corresponds to the concrete presentation of context in xml file and in play an essential role in XIOS
37   Each object of this class contains all root definition of elements: files, fiels, domains, axis, etc, ... from which
38   we can have access to each element.
39   In fact, every thing must a be inside a particuliar context. After the xml file (iodef.xml) is parsed,
40   object of the class is created and its contains all information of other elements in the xml file.
41  */
[219]42   class CContext
43      : public CObjectTemplate<CContext>
44      , public CContextAttributes
45   {
[300]46         public :
47         enum EEventId
48         {
49           EVENT_ID_CLOSE_DEFINITION,EVENT_ID_UPDATE_CALENDAR,
[509]50           EVENT_ID_CREATE_FILE_HEADER,EVENT_ID_CONTEXT_FINALIZE,
[1025]51           EVENT_ID_POST_PROCESS, EVENT_ID_SEND_REGISTRY,
52           EVENT_ID_POST_PROCESS_GLOBAL_ATTRIBUTES,
53           EVENT_ID_PROCESS_GRID_ENABLED_FIELDS
[549]54         };
[509]55
[219]56         /// typedef ///
57         typedef CObjectTemplate<CContext>   SuperClass;
58         typedef CContextAttributes SuperClassAttribute;
59
60      public :
61
62         typedef CContextAttributes RelAttributes;
63         typedef CContext           RelGroup;
64
65         //---------------------------------------------------------
66
67      public :
68
69         /// Constructeurs ///
70         CContext(void);
71         explicit CContext(const StdString & id);
72         CContext(const CContext & context);       // Not implemented yet.
73         CContext(const CContext * const context); // Not implemented yet.
74
75         /// Destructeur ///
76         virtual ~CContext(void);
77
78         //---------------------------------------------------------
79
80      public :
[509]81
[219]82         /// Mutateurs ///
[1542]83         void setCalendar(std::shared_ptr<CCalendar> newCalendar);
[509]84
[219]85         /// Accesseurs ///
[1542]86         std::shared_ptr<CCalendar>      getCalendar(void) const;
[219]87
88      public :
[509]89         // Initialize server or client
[983]90         void initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer = 0);
[597]91         void initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient = 0);
[549]92         bool isInitialized(void);
[219]93
[1612]94         StdString dumpClassAttributes(void);
95
[509]96         // Put sever or client into loop state
[1378]97         bool checkBuffersAndListen(bool enableEventsProcessing=true);
[597]98
[509]99         // Finalize a context
[549]100         void finalize(void);
[1071]101         bool isFinalized(void);
[509]102
[1130]103         void closeDefinition(void);
104
[509]105         // Some functions to process context
[1232]106         void findAllEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
107         // void findAllEnabledFields(void);
108         // void findAllEnabledFieldsInReadModeFiles(void);
[775]109         void readAttributesOfEnabledFieldsInReadModeFiles();
[549]110         void solveAllInheritance(bool apply=true);
[300]111         void findEnabledFiles(void);
[1232]112         void findEnabledWriteModeFiles(void);
[598]113         void findEnabledReadModeFiles(void);
[549]114         void closeAllFile(void);
115         void updateCalendar(int step);
[1232]116         void createFileHeader(void);
117         void initReadFiles(void);
[676]118         void checkAxisDomainsGridsEligibilityForCompressedOutput();
[711]119         void prepareTimeseries(void);
[1129]120         void solveOnlyRefOfEnabledFields(bool sendToServer);         
[640]121         void buildFilterGraphOfEnabledFields();
[1358]122         void postProcessFilterGraph();
[598]123         void startPrefetchingOfEnabledReadModeFiles();
[1358]124         void doPreTimestepOperationsForEnabledReadModeFiles();
[1318]125         void doPostTimestepOperationsForEnabledReadModeFiles();
[593]126         void findFieldsWithReadAccess(void);
127         void solveAllRefOfFieldsWithReadAccess();
[640]128         void buildFilterGraphOfFieldsWithReadAccess();
[509]129         void postProcessing();
[1025]130         void postProcessingGlobalAttributes();         
[509]131
[1129]132         void solveAllRefOfEnabledFieldsAndTransform(bool sendToServer);
[1099]133         void checkGridEnabledFields();
[1232]134         void checkGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
[1239]135         void sendGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles); 
136         void sendGridComponentEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles)       ;
[1025]137
[1330]138         std::map<int, StdSize> getAttributesBufferSize(std::map<int, StdSize>& maxEventSize, CContextClient* contextClient, bool bufferForWriting = false);
139         std::map<int, StdSize> getDataBufferSize(std::map<int, StdSize>& maxEventSize, CContextClient* contextClient, bool bufferForWriting = false);
140         void setClientServerBuffer(CContextClient* contextClient, bool bufferForWriting = false);
[509]141
[1212]142         // Distribute files (in write mode) among secondary-server pools according to the estimated data flux
[1208]143         void distributeFiles(void);
[1349]144         void distributeFileOverBandwith() ;
145         void distributeFileOverMemoryBandwith() ;
146         
[509]147         // Send context close definition
[549]148         void sendCloseDefinition(void);
[509]149         // There are something to send on closing context defintion
[549]150         void sendUpdateCalendar(int step);
151         void sendCreateFileHeader(void);
[1232]152         void sendEnabledFiles(const std::vector<CFile*>& activeFiles);
153         void sendEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
154         void sendRefDomainsAxisScalars(const std::vector<CFile*>& activeFiles);
155         void sendRefGrid(const std::vector<CFile*>& activeFiles);
[509]156         void sendPostProcessing();
[1025]157         void sendPostProcessingGlobalAttributes();
158         void sendProcessingGridOfEnabledFields();
[983]159         //!< after be gathered to the root process of the context, merged registry is sent to the root process of the servers
160         void sendRegistry(void) ;
161
[511]162         const StdString& getIdServer();
[1009]163         const StdString& getIdServer(const int srvPoolNb);
[511]164
[509]165         // Client side: Receive and process messages
[549]166         static void recvUpdateCalendar(CEventServer& event);
167         void recvUpdateCalendar(CBufferIn& buffer);
168         static void recvCloseDefinition(CEventServer& event);
169         static void recvCreateFileHeader(CEventServer& event);
170         void recvCreateFileHeader(CBufferIn& buffer);
[509]171         static void recvSolveInheritanceContext(CEventServer& event);
172         void recvSolveInheritanceContext(CBufferIn& buffer);
173         static void recvPostProcessing(CEventServer& event);
174         void recvPostProcessing(CBufferIn& buffer);
[1025]175         static void recvProcessingGridOfEnabledFields(CEventServer& event);
176         static void recvPostProcessingGlobalAttributes(CEventServer& event);
177         void recvPostProcessingGlobalAttributes(CBufferIn& buffer);
[697]178         static void recvRegistry(CEventServer& event) ;
[983]179         void recvRegistry(CBufferIn& buffer) ; //!< registry is received by the servers
[509]180
[1130]181         void freeComms(void);                  //!< Free internally allcoated communicators
182         void releaseClientBuffers(void);       //! Deallocate buffers allocated by clientContexts
[1054]183
[509]184         // dispatch event
[549]185         static bool dispatchEvent(CEventServer& event);
[509]186
187      public:
188        // Get current context
189        static CContext* getCurrent(void);
190
191        // Get context root
192        static CContextGroup* getRoot(void);
193
194        // Set current context
195        static void setCurrent(const string& id);
196
197        // Create new context
198        static CContext* create(const string& id = "");
199
200        /// Accesseurs statiques ///
201        static StdString GetName(void);
202        static StdString GetDefName(void);
203        static ENodeType GetType(void);
204
205        static CContextGroup* GetContextGroup(void);
206
207        // Some functions to visualize structure of current context
208        static void ShowTree(StdOStream & out = std::clog);
209        static void CleanTree(void);
210
[219]211      public :
[509]212         // Parse xml node and write all info into context
[219]213         virtual void parse(xml::CXMLNode & node);
214
[509]215         // Visualize a context
[219]216         virtual StdString toString(void) const;
[509]217
218
219         // Solve all inheritance relation in current context
220         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0);
221
222         // Verify if all root definition in a context have children
223         virtual bool hasChild(void) const;
224
[1054]225
[300]226      public :
[509]227         // Calendar of context
[1542]228         std::shared_ptr<CCalendar>   calendar;
[509]229
[598]230         // List of all enabled files (files on which fields are written or read)
[347]231         std::vector<CFile*> enabledFiles;
[598]232         // List of all enabled files in read mode (files on which fields are read)
233         std::vector<CFile*> enabledReadModeFiles;
[1208]234         // List of all enabled files in write mode
235         std::vector<CFile*> enabledWriteModeFiles;
[509]236
[740]237         // List of all enabled fields whose instant data is accessible from the public API
238         // but which are not part of a file
[593]239         std::vector<CField*> fieldsWithReadAccess;
240
[509]241         // Context root
[1542]242         static std::shared_ptr<CContextGroup> root;
[219]243
[509]244         // Determine context on client or not
[549]245         bool hasClient;
[300]246
[509]247         // Determine context on server or not
[549]248         bool hasServer;
[509]249
[1130]250         CContextServer* server;    //!< Concrete context server
251         CContextClient* client;    //!< Concrete contex client
[1071]252         std::vector<CContextServer*> serverPrimServer;
253         std::vector<CContextClient*> clientPrimServer;
254
[1130]255         CRegistry* registryIn ;    //!< input registry which is read from file
256         CRegistry* registryOut ;   //!< output registry which will be written into file at the finalize
[775]257
[509]258      private:
259         bool isPostProcessed;
[1025]260         bool allProcessed;
[1139]261         bool finalized;
[1130]262         int countChildCtx_;        //!< Counter of child contexts (for now it is the number of secondary server pools)
[511]263         StdString idServer_;
[639]264         CGarbageCollector garbageCollector;
[1071]265         std::list<MPI_Comm> comms; //!< Communicators allocated internally
[509]266
267      public: // Some function maybe removed in the near future
268        // virtual void toBinary  (StdOStream & os) const;
269        // virtual void fromBinary(StdIStream & is);
[219]270   }; // class CContext
271
272   ///--------------------------------------------------------------
273
274   // Declare/Define CContextGroup and CContextDefinition
275   DECLARE_GROUP(CContext);
276
277   ///--------------------------------------------------------------
278
[335]279} // namespace xios
[219]280
[591]281#endif // __XIOS_CContext__
Note: See TracBrowser for help on using the repository browser.