source: XIOS/dev/dev_ym/XIOS_COUPLING/src/node/context.hpp @ 1784

Last change on this file since 1784 was 1784, checked in by ymipsl, 23 months ago
  • Preparing coupling functionalities.
  • Make some cleaner things

YM

  • 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: 12.8 KB
Line 
1#ifndef __XIOS_CContext__
2#define __XIOS_CContext__
3
4/// XIOS headers ///
5#include "xios_spl.hpp"
6//#include "node_type.hpp"
7#include "calendar_wrapper.hpp"
8
9#include "declare_group.hpp"
10#include "data_output.hpp"
11#include "garbage_collector.hpp"
12#include "registry.hpp"
13#include "mpi.hpp"
14#include "services_manager.hpp"
15#include "server_context.hpp"
16
17
18namespace xios {
19   class CContextClient;
20   class CContextServer;
21
22
23   /// ////////////////////// Déclarations ////////////////////// ///
24   class CContextGroup;
25   class CContextAttributes;
26   class CContext;
27   class CFile;
28   class CCouplerIn ;
29   class CCouplerOut ;
30   ///--------------------------------------------------------------
31
32   // Declare/Define CFileAttribute
33   BEGIN_DECLARE_ATTRIBUTE_MAP(CContext)
34#  include "context_attribute.conf"
35   END_DECLARE_ATTRIBUTE_MAP(CContext)
36
37   ///--------------------------------------------------------------
38  /*!
39  \class CContext
40   This class corresponds to the concrete presentation of context in xml file and in play an essential role in XIOS
41   Each object of this class contains all root definition of elements: files, fiels, domains, axis, etc, ... from which
42   we can have access to each element.
43   In fact, every thing must a be inside a particuliar context. After the xml file (iodef.xml) is parsed,
44   object of the class is created and its contains all information of other elements in the xml file.
45  */
46   class CContext
47      : public CObjectTemplate<CContext>
48      , public CContextAttributes
49   {
50         public :
51         enum EEventId
52         {
53           EVENT_ID_CLOSE_DEFINITION,EVENT_ID_UPDATE_CALENDAR,
54           EVENT_ID_CREATE_FILE_HEADER,EVENT_ID_CONTEXT_FINALIZE,
55           EVENT_ID_POST_PROCESS, EVENT_ID_SEND_REGISTRY,
56           EVENT_ID_POST_PROCESS_GLOBAL_ATTRIBUTES,
57           EVENT_ID_PROCESS_GRID_ENABLED_FIELDS,
58           EVENT_ID_CONTEXT_FINALIZE_CLIENT,
59         };
60
61         /// typedef ///
62         typedef CObjectTemplate<CContext>   SuperClass;
63         typedef CContextAttributes SuperClassAttribute;
64
65      public :
66
67         typedef CContextAttributes RelAttributes;
68         typedef CContext           RelGroup;
69
70         //---------------------------------------------------------
71
72      public :
73
74         /// Constructeurs ///
75         CContext(void);
76         explicit CContext(const StdString & id);
77         CContext(const CContext & context);       // Not implemented yet.
78         CContext(const CContext * const context); // Not implemented yet.
79
80         /// Destructeur ///
81         virtual ~CContext(void);
82
83         //---------------------------------------------------------
84
85      public :
86
87         /// Mutateurs ///
88         void setCalendar(std::shared_ptr<CCalendar> newCalendar);
89
90         /// Accesseurs ///
91         std::shared_ptr<CCalendar>      getCalendar(void) const;
92
93      public :
94         // Initialize server or client
95         void init(CServerContext* parentServerContext, MPI_Comm intraComm, int serviceType);
96         void initClient(MPI_Comm intraComm, int serviceType);
97         
98         void initServer(MPI_Comm intraComm, int serviceType );
99         void createClientInterComm(MPI_Comm interCommClient, MPI_Comm interCommServer)  ;
100         void createServerInterComm(void)  ;
101
102         bool isInitialized(void);
103
104         StdString dumpClassAttributes(void);
105
106         // Put sever or client into loop state
107         bool eventLoop(bool enableEventsProcessing=true);
108         void globalEventLoop(void);
109
110         // Finalize a context
111         void finalize(void);
112
113         bool isFinalized(void);
114
115         void closeDefinition(void);
116
117         // Some functions to process context
118         void findAllEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
119         // void findAllEnabledFields(void);
120         // void findAllEnabledFieldsInReadModeFiles(void);
121         void readAttributesOfEnabledFieldsInReadModeFiles();
122         void solveAllInheritance(bool apply=true);
123         void findEnabledFiles(void);
124         void findEnabledCouplerIn(void);
125         void findEnabledCouplerOut(void);
126         void createCouplerInterCommunicator(void) ;
127         void findEnabledWriteModeFiles(void);
128         void findEnabledReadModeFiles(void);
129         void closeAllFile(void);
130         void updateCalendar(int step);
131         void createFileHeader(void);
132         void initReadFiles(void);
133         void checkAxisDomainsGridsEligibilityForCompressedOutput();
134         void prepareTimeseries(void);
135         void solveOnlyRefOfEnabledFields(void);         
136         void buildFilterGraphOfEnabledFields();
137         void postProcessFilterGraph();
138         void startPrefetchingOfEnabledReadModeFiles();
139         void doPreTimestepOperationsForEnabledReadModeFiles();
140         void doPostTimestepOperationsForEnabledReadModeFiles();
141         void findFieldsWithReadAccess(void);
142         void solveAllRefOfFieldsWithReadAccess();
143         void buildFilterGraphOfFieldsWithReadAccess();
144         void postProcessing();
145         void postProcessingGlobalAttributes();         
146
147         void solveAllRefOfEnabledFieldsAndTransform(void);
148         void checkGridEnabledFields();
149         void checkGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
150         void sendGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles); 
151         void sendGridComponentEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles)       ;
152
153         std::map<int, StdSize> getAttributesBufferSize(std::map<int, StdSize>& maxEventSize, CContextClient* contextClient, bool bufferForWriting = false);
154         std::map<int, StdSize> getDataBufferSize(std::map<int, StdSize>& maxEventSize, CContextClient* contextClient, bool bufferForWriting = false);
155         void setClientServerBuffer(CContextClient* contextClient, bool bufferForWriting = false);
156
157         // Distribute files (in write mode) among secondary-server pools according to the estimated data flux
158         void distributeFiles(void);
159         void distributeFileOverBandwith() ;
160         void distributeFileOverMemoryBandwith() ;
161         
162         // Send context close definition
163         void sendCloseDefinition(void);
164         // There are something to send on closing context defintion
165         void sendUpdateCalendar(int step);
166         void sendCreateFileHeader(void);
167         void sendEnabledFiles(const std::vector<CFile*>& activeFiles);
168         void sendEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
169         void sendRefDomainsAxisScalars(const std::vector<CFile*>& activeFiles);
170         void sendRefGrid(const std::vector<CFile*>& activeFiles);
171         void sendPostProcessing();
172         void sendPostProcessingGlobalAttributes();
173         void sendProcessingGridOfEnabledFields();
174         //!< after be gathered to the root process of the context, merged registry is sent to the root process of the servers
175         void sendRegistry(void) ;
176         void sendFinalizeClient(CContextClient* contextClient, const string& contextClientId);
177
178
179         const StdString& getIdServer();
180         void setIdServer(const StdString& idServer);
181         const StdString& getIdServer(const int srvPoolNb);
182         std::string getContextId() {return contextId_;}
183
184         // Client side: Receive and process messages
185         static void recvUpdateCalendar(CEventServer& event);
186         void recvUpdateCalendar(CBufferIn& buffer);
187         static void recvCloseDefinition(CEventServer& event);
188         static void recvCreateFileHeader(CEventServer& event);
189         void recvCreateFileHeader(CBufferIn& buffer);
190         static void recvSolveInheritanceContext(CEventServer& event);
191         void recvSolveInheritanceContext(CBufferIn& buffer);
192         static void recvPostProcessing(CEventServer& event);
193         void recvPostProcessing(CBufferIn& buffer);
194         static void recvProcessingGridOfEnabledFields(CEventServer& event);
195         static void recvPostProcessingGlobalAttributes(CEventServer& event);
196         void recvPostProcessingGlobalAttributes(CBufferIn& buffer);
197         static void recvRegistry(CEventServer& event) ;
198         void recvRegistry(CBufferIn& buffer) ; //!< registry is received by the servers
199         static void recvFinalizeClient(CEventServer& event) ;
200         void recvFinalizeClient(CBufferIn& buffer);
201         
202         void freeComms(void);                  //!< Free internally allcoated communicators
203         void releaseClientBuffers(void);       //! Deallocate buffers allocated by clientContexts
204
205         // dispatch event
206         static bool dispatchEvent(CEventServer& event);
207
208      public:
209        // Get current context
210        static CContext* getCurrent(void);
211
212        // Get context root
213        static CContextGroup* getRoot(void);
214
215        // Set current context
216        static void setCurrent(const string& id);
217
218        // Create new context
219        static CContext* create(const string& id = "");
220
221        /// Accesseurs statiques ///
222        static StdString GetName(void);
223        static StdString GetDefName(void);
224        static ENodeType GetType(void);
225
226        static CContextGroup* GetContextGroup(void);
227
228        // Some functions to visualize structure of current context
229        static void ShowTree(StdOStream & out = std::clog);
230        static void CleanTree(void);
231        int getServiceType(void) {return serviceType_;}
232
233      public :
234         // Parse xml node and write all info into context
235         virtual void parse(xml::CXMLNode & node);
236
237         // Visualize a context
238         virtual StdString toString(void) const;
239
240
241         // Solve all inheritance relation in current context
242         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0);
243
244         // Verify if all root definition in a context have children
245         virtual bool hasChild(void) const;
246
247         bool isProcessingEvent(void) {return isProcessingEvent_;}
248         bool setProcessingEvent(void) {isProcessingEvent_=true ;}
249         bool unsetProcessingEvent(void) {isProcessingEvent_=false ;}
250         MPI_Comm getIntraComm(void) { return intraComm_ ;}
251
252         void addCouplingChanel(const std::string& contextId, bool out) ;
253
254      public :
255         // Calendar of context
256         std::shared_ptr<CCalendar>   calendar;
257
258         // List of all enabled files (files on which fields are written or read)
259         std::vector<CFile*> enabledFiles;
260         // List of all enabled files in read mode (files on which fields are read)
261         std::vector<CFile*> enabledReadModeFiles;
262         // List of all enabled files in write mode
263         std::vector<CFile*> enabledWriteModeFiles;
264
265         std::vector<CCouplerIn*> enabledCouplerIn;
266         std::vector<CCouplerOut*> enabledCouplerOut;
267
268
269         // List of all enabled fields whose instant data is accessible from the public API
270         // but which are not part of a file
271         std::vector<CField*> fieldsWithReadAccess;
272
273         // Context root
274         static std::shared_ptr<CContextGroup> root;
275
276         // Determine context on client or not
277         bool hasClient;
278
279         // Determine context on server or not
280         bool hasServer;
281
282         CContextServer* server;    //!< Concrete context server
283         CContextClient* client;    //!< Concrete contex client
284         std::vector<CContextServer*> serverPrimServer;
285         std::vector<CContextClient*> clientPrimServer;
286         std::map<std::string, CContextClient*> couplerClient_ ;
287         std::map<std::string, CContextServer*> couplerServer_ ;
288
289
290         std::vector<std::string> primServerId_;
291
292         CRegistry* registryIn ;    //!< input registry which is read from file
293         CRegistry* registryOut ;   //!< output registry which will be written into file at the finalize
294
295
296        MPI_Comm intraComm_ ; //! context intra communicator
297        int intraCommRank_ ; //! context intra communicator rank
298        int intraCommSize_ ; //! context intra communicator size
299       
300      private:
301         bool isPostProcessed;
302         bool allProcessed;
303         bool finalized;
304         int countChildContextFinalized_;        //!< Counter of child contexts (for now it is the number of secondary server pools)
305         StdString idServer_;
306         CGarbageCollector garbageCollector;
307         std::list<MPI_Comm> comms; //!< Communicators allocated internally
308
309         int serviceType_;  //!< service associated to the context
310         string contextId_ ; //!< context client id for the servers. For clients this is same as getId()
311         bool isProcessingEvent_ ;
312         CServerContext* parentServerContext_ ;
313
314      public: // Some function maybe removed in the near future
315        // virtual void toBinary  (StdOStream & os) const;
316        // virtual void fromBinary(StdIStream & is);
317   }; // class CContext
318
319   ///--------------------------------------------------------------
320
321   // Declare/Define CContextGroup and CContextDefinition
322   DECLARE_GROUP(CContext);
323
324   ///--------------------------------------------------------------
325
326} // namespace xios
327
328#endif // __XIOS_CContext__
Note: See TracBrowser for help on using the repository browser.