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

Last change on this file since 1139 was 1139, checked in by oabramkina, 3 years ago

Fixing a bug in context finalization. Now context finalization is done in two stages.
Tested on Cure with test_regular and test_xios2_cmip6.

  • 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: 9.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 "context_client.hpp"
11//#include "context_server.hpp"
12#include "data_output.hpp"
13#include "garbage_collector.hpp"
14#include "registry.hpp"
15#include "mpi.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   ///--------------------------------------------------------------
29
30   // Declare/Define CFileAttribute
31   BEGIN_DECLARE_ATTRIBUTE_MAP(CContext)
32#  include "context_attribute.conf"
33   END_DECLARE_ATTRIBUTE_MAP(CContext)
34
35   ///--------------------------------------------------------------
36  /*!
37  \class CContext
38   This class corresponds to the concrete presentation of context in xml file and in play an essential role in XIOS
39   Each object of this class contains all root definition of elements: files, fiels, domains, axis, etc, ... from which
40   we can have access to each element.
41   In fact, every thing must a be inside a particuliar context. After the xml file (iodef.xml) is parsed,
42   object of the class is created and its contains all information of other elements in the xml file.
43  */
44   class CContext
45      : public CObjectTemplate<CContext>
46      , public CContextAttributes
47   {
48         public :
49         enum EEventId
50         {
51           EVENT_ID_CLOSE_DEFINITION,EVENT_ID_UPDATE_CALENDAR,
52           EVENT_ID_CREATE_FILE_HEADER,EVENT_ID_CONTEXT_FINALIZE,
53           EVENT_ID_CONTEXT_POST_FINALIZE,
54           EVENT_ID_POST_PROCESS, EVENT_ID_SEND_REGISTRY,
55           EVENT_ID_POST_PROCESS_GLOBAL_ATTRIBUTES,
56           EVENT_ID_PROCESS_GRID_ENABLED_FIELDS
57         };
58
59         /// typedef ///
60         typedef CObjectTemplate<CContext>   SuperClass;
61         typedef CContextAttributes SuperClassAttribute;
62
63      public :
64
65         typedef CContextAttributes RelAttributes;
66         typedef CContext           RelGroup;
67
68         //---------------------------------------------------------
69
70      public :
71
72         /// Constructeurs ///
73         CContext(void);
74         explicit CContext(const StdString & id);
75         CContext(const CContext & context);       // Not implemented yet.
76         CContext(const CContext * const context); // Not implemented yet.
77
78         /// Destructeur ///
79         virtual ~CContext(void);
80
81         //---------------------------------------------------------
82
83      public :
84
85         /// Mutateurs ///
86         void setCalendar(boost::shared_ptr<CCalendar> newCalendar);
87
88         /// Accesseurs ///
89         boost::shared_ptr<CCalendar>      getCalendar(void) const;
90
91      public :
92         // Initialize server or client
93         void initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer = 0);
94         void initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient = 0);
95         bool isInitialized(void);
96
97         // Put sever or client into loop state
98         bool checkBuffersAndListen(void);
99
100         // Finalize a context
101         void finalize(void);
102         void postFinalize(void);
103         bool isFinalized(void);
104
105         void closeDefinition(void);
106
107         // Some functions to process context
108         void findAllEnabledFields(void);
109         void findAllEnabledFieldsInReadModeFiles(void);
110         void readAttributesOfEnabledFieldsInReadModeFiles();
111         void solveAllInheritance(bool apply=true);
112         void findEnabledFiles(void);
113         void findEnabledReadModeFiles(void);
114         void closeAllFile(void);
115         void updateCalendar(int step);
116         void createFileHeader(void );
117         void checkAxisDomainsGridsEligibilityForCompressedOutput();
118         void prepareTimeseries(void);
119         void solveOnlyRefOfEnabledFields(bool sendToServer);         
120         void buildFilterGraphOfEnabledFields();
121         void startPrefetchingOfEnabledReadModeFiles();
122         void checkPrefetchingOfEnabledReadModeFiles();
123         void findFieldsWithReadAccess(void);
124         void solveAllRefOfFieldsWithReadAccess();
125         void buildFilterGraphOfFieldsWithReadAccess();
126         void postProcessing();
127         void postProcessingGlobalAttributes();         
128
129         void solveAllRefOfEnabledFieldsAndTransform(bool sendToServer);
130         void solveAllEnabledFields();
131         void checkGridEnabledFields();
132         void sendGridEnabledFields();
133
134         std::map<int, StdSize> getAttributesBufferSize(std::map<int, StdSize>& maxEventSize);
135         std::map<int, StdSize> getDataBufferSize(std::map<int, StdSize>& maxEventSize);
136         void setClientServerBuffer();
137
138         // Send context close definition
139         void sendCloseDefinition(void);
140         // There are something to send on closing context defintion
141         void sendUpdateCalendar(int step);
142         void sendCreateFileHeader(void);
143         void sendEnabledFiles();
144         void sendEnabledFields();
145         void sendRefDomainsAxis();
146         void sendRefGrid();
147         void sendPostProcessing();
148         void sendPostProcessingGlobalAttributes();
149         void sendProcessingGridOfEnabledFields();
150         //!< after be gathered to the root process of the context, merged registry is sent to the root process of the servers
151         void sendRegistry(void) ;
152
153         const StdString& getIdServer();
154         const StdString& getIdServer(const int srvPoolNb);
155
156         // Client side: Receive and process messages
157         static void recvUpdateCalendar(CEventServer& event);
158         void recvUpdateCalendar(CBufferIn& buffer);
159         static void recvCloseDefinition(CEventServer& event);
160         static void recvCreateFileHeader(CEventServer& event);
161         void recvCreateFileHeader(CBufferIn& buffer);
162         static void recvSolveInheritanceContext(CEventServer& event);
163         void recvSolveInheritanceContext(CBufferIn& buffer);
164         static void recvPostProcessing(CEventServer& event);
165         void recvPostProcessing(CBufferIn& buffer);
166         static void recvProcessingGridOfEnabledFields(CEventServer& event);
167         static void recvPostProcessingGlobalAttributes(CEventServer& event);
168         void recvPostProcessingGlobalAttributes(CBufferIn& buffer);
169         static void recvRegistry(CEventServer& event) ;
170         void recvRegistry(CBufferIn& buffer) ; //!< registry is received by the servers
171
172         void freeComms(void);                  //!< Free internally allcoated communicators
173         void releaseClientBuffers(void);       //! Deallocate buffers allocated by clientContexts
174
175         // dispatch event
176         static bool dispatchEvent(CEventServer& event);
177
178      public:
179        // Get current context
180        static CContext* getCurrent(void);
181
182        // Get context root
183        static CContextGroup* getRoot(void);
184
185        // Set current context
186        static void setCurrent(const string& id);
187
188        // Create new context
189        static CContext* create(const string& id = "");
190
191        /// Accesseurs statiques ///
192        static StdString GetName(void);
193        static StdString GetDefName(void);
194        static ENodeType GetType(void);
195
196        static CContextGroup* GetContextGroup(void);
197
198        // Some functions to visualize structure of current context
199        static void ShowTree(StdOStream & out = std::clog);
200        static void CleanTree(void);
201
202      public :
203         // Parse xml node and write all info into context
204         virtual void parse(xml::CXMLNode & node);
205
206         // Visualize a context
207         virtual StdString toString(void) const;
208
209
210         // Solve all inheritance relation in current context
211         virtual void solveDescInheritance(bool apply, const CAttributeMap * const parent = 0);
212
213         // Verify if all root definition in a context have children
214         virtual bool hasChild(void) const;
215
216
217      public :
218         // Calendar of context
219         boost::shared_ptr<CCalendar>   calendar;
220
221         // List of all enabled files (files on which fields are written or read)
222         std::vector<CFile*> enabledFiles;
223         // List of all enabled files in read mode (files on which fields are read)
224         std::vector<CFile*> enabledReadModeFiles;
225
226         // List of all enabled fields whose instant data is accessible from the public API
227         // but which are not part of a file
228         std::vector<CField*> fieldsWithReadAccess;
229
230         // Context root
231         static shared_ptr<CContextGroup> root;
232
233         // Determine context on client or not
234         bool hasClient;
235
236         // Determine context on server or not
237         bool hasServer;
238
239         CContextServer* server;    //!< Concrete context server
240         CContextClient* client;    //!< Concrete contex client
241         std::vector<CContextServer*> serverPrimServer;
242         std::vector<CContextClient*> clientPrimServer;
243
244         CRegistry* registryIn ;    //!< input registry which is read from file
245         CRegistry* registryOut ;   //!< output registry which will be written into file at the finalize
246
247      private:
248         bool isPostProcessed;
249         bool allProcessed;
250         bool finalized;
251         int countChildCtx_;        //!< Counter of child contexts (for now it is the number of secondary server pools)
252         StdString idServer_;
253         CGarbageCollector garbageCollector;
254         std::list<MPI_Comm> comms; //!< Communicators allocated internally
255
256      public: // Some function maybe removed in the near future
257        // virtual void toBinary  (StdOStream & os) const;
258        // virtual void fromBinary(StdIStream & is);
259   }; // class CContext
260
261   ///--------------------------------------------------------------
262
263   // Declare/Define CContextGroup and CContextDefinition
264   DECLARE_GROUP(CContext);
265
266   ///--------------------------------------------------------------
267
268} // namespace xios
269
270#endif // __XIOS_CContext__
Note: See TracBrowser for help on using the repository browser.