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

Last change on this file since 1848 was 1848, checked in by ymipsl, 22 months ago

Supress unusefull idServer context variable that create some trouble when sending context attribute to server.

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.7 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         std::string getContextId() {return contextId_;}
179
180         // Client side: Receive and process messages
181         static void recvUpdateCalendar(CEventServer& event);
182         void recvUpdateCalendar(CBufferIn& buffer);
183         static void recvCloseDefinition(CEventServer& event);
184         static void recvCreateFileHeader(CEventServer& event);
185         void recvCreateFileHeader(CBufferIn& buffer);
186         static void recvSolveInheritanceContext(CEventServer& event);
187         void recvSolveInheritanceContext(CBufferIn& buffer);
188         static void recvPostProcessing(CEventServer& event);
189         void recvPostProcessing(CBufferIn& buffer);
190         static void recvProcessingGridOfEnabledFields(CEventServer& event);
191         static void recvPostProcessingGlobalAttributes(CEventServer& event);
192         void recvPostProcessingGlobalAttributes(CBufferIn& buffer);
193         static void recvRegistry(CEventServer& event) ;
194         void recvRegistry(CBufferIn& buffer) ; //!< registry is received by the servers
195         static void recvFinalizeClient(CEventServer& event) ;
196         void recvFinalizeClient(CBufferIn& buffer);
197         
198         void freeComms(void);                  //!< Free internally allcoated communicators
199         void releaseClientBuffers(void);       //! Deallocate buffers allocated by clientContexts
200
201         // dispatch event
202         static bool dispatchEvent(CEventServer& event);
203
204      public:
205        // Get current context
206        static CContext* getCurrent(void);
207
208        // Get context root
209        static CContextGroup* getRoot(void);
210
211        // Set current context
212        static void setCurrent(const string& id);
213
214        // Create new context
215        static CContext* create(const string& id = "");
216
217        /// Accesseurs statiques ///
218        static StdString GetName(void);
219        static StdString GetDefName(void);
220        static ENodeType GetType(void);
221
222        static CContextGroup* GetContextGroup(void);
223
224        // Some functions to visualize structure of current context
225        static void ShowTree(StdOStream & out = std::clog);
226        static void CleanTree(void);
227        int getServiceType(void) {return serviceType_;}
228
229      public :
230         // Parse xml node and write all info into context
231         virtual void parse(xml::CXMLNode & node);
232
233         // Visualize a context
234         virtual StdString toString(void) const;
235
236
237         // Solve all inheritance relation in current context
238         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0);
239
240         // Verify if all root definition in a context have children
241         virtual bool hasChild(void) const;
242
243         bool isProcessingEvent(void) {return isProcessingEvent_;}
244         bool setProcessingEvent(void) {isProcessingEvent_=true ;}
245         bool unsetProcessingEvent(void) {isProcessingEvent_=false ;}
246         MPI_Comm getIntraComm(void) { return intraComm_ ;}
247
248         void addCouplingChanel(const std::string& contextId, bool out) ;
249
250      public :
251         // Calendar of context
252         std::shared_ptr<CCalendar>   calendar;
253
254         // List of all enabled files (files on which fields are written or read)
255         std::vector<CFile*> enabledFiles;
256         // List of all enabled files in read mode (files on which fields are read)
257         std::vector<CFile*> enabledReadModeFiles;
258         // List of all enabled files in write mode
259         std::vector<CFile*> enabledWriteModeFiles;
260
261         std::vector<CCouplerIn*> enabledCouplerIn;
262         std::vector<CCouplerOut*> enabledCouplerOut;
263
264
265         // List of all enabled fields whose instant data is accessible from the public API
266         // but which are not part of a file
267         std::vector<CField*> fieldsWithReadAccess;
268
269         // Context root
270         static std::shared_ptr<CContextGroup> root;
271
272         // Determine context on client or not
273         bool hasClient;
274
275         // Determine context on server or not
276         bool hasServer;
277
278         CContextServer* server;    //!< Concrete context server
279         CContextClient* client;    //!< Concrete contex client
280         std::vector<CContextServer*> serverPrimServer;
281         std::vector<CContextClient*> clientPrimServer;
282         std::map<std::string, CContextClient*> couplerClient_ ;
283         std::map<std::string, CContextServer*> couplerServer_ ;
284
285
286         std::vector<std::string> primServerId_;
287
288         CRegistry* registryIn ;    //!< input registry which is read from file
289         CRegistry* registryOut ;   //!< output registry which will be written into file at the finalize
290
291
292        MPI_Comm intraComm_ ; //! context intra communicator
293        int intraCommRank_ ; //! context intra communicator rank
294        int intraCommSize_ ; //! context intra communicator size
295       
296      private:
297         bool isPostProcessed;
298         bool allProcessed;
299         bool finalized;
300         int countChildContextFinalized_;        //!< Counter of child contexts (for now it is the number of secondary server pools)
301         CGarbageCollector garbageCollector;
302         std::list<MPI_Comm> comms; //!< Communicators allocated internally
303
304         int serviceType_;  //!< service associated to the context
305         string contextId_ ; //!< context client id for the servers. For clients this is same as getId()
306         bool isProcessingEvent_ ;
307         CServerContext* parentServerContext_ ;
308
309      public: // Some function maybe removed in the near future
310        // virtual void toBinary  (StdOStream & os) const;
311        // virtual void fromBinary(StdIStream & is);
312   }; // class CContext
313
314   ///--------------------------------------------------------------
315
316   // Declare/Define CContextGroup and CContextDefinition
317   DECLARE_GROUP(CContext);
318
319   ///--------------------------------------------------------------
320
321} // namespace xios
322
323#endif // __XIOS_CContext__
Note: See TracBrowser for help on using the repository browser.