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

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

Two server levels: simplifying context finalization.
Send of context finalization is blocking now on all server types.

  • 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.0 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_POST_PROCESS, EVENT_ID_SEND_REGISTRY,
54           EVENT_ID_POST_PROCESS_GLOBAL_ATTRIBUTES,
55           EVENT_ID_PROCESS_GRID_ENABLED_FIELDS
56         };
57
58         /// typedef ///
59         typedef CObjectTemplate<CContext>   SuperClass;
60         typedef CContextAttributes SuperClassAttribute;
61
62      public :
63
64         typedef CContextAttributes RelAttributes;
65         typedef CContext           RelGroup;
66
67         //---------------------------------------------------------
68
69      public :
70
71         /// Constructeurs ///
72         CContext(void);
73         explicit CContext(const StdString & id);
74         CContext(const CContext & context);       // Not implemented yet.
75         CContext(const CContext * const context); // Not implemented yet.
76
77         /// Destructeur ///
78         virtual ~CContext(void);
79
80         //---------------------------------------------------------
81
82      public :
83
84         /// Mutateurs ///
85         void setCalendar(boost::shared_ptr<CCalendar> newCalendar);
86
87         /// Accesseurs ///
88         boost::shared_ptr<CCalendar>      getCalendar(void) const;
89
90      public :
91         // Initialize server or client
92         void initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer = 0);
93         void initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient = 0);
94         bool isInitialized(void);
95
96         // Put sever or client into loop state
97         bool checkBuffersAndListen(void);
98
99         // Finalize a context
100         void finalize(void);
101         bool isFinalized(void);
102
103         void closeDefinition(void);
104
105         // Some functions to process context
106         void findAllEnabledFields(void);
107         void findAllEnabledFieldsInReadModeFiles(void);
108         void readAttributesOfEnabledFieldsInReadModeFiles();
109         void solveAllInheritance(bool apply=true);
110         void findEnabledFiles(void);
111         void findEnabledReadModeFiles(void);
112         void closeAllFile(void);
113         void updateCalendar(int step);
114         void createFileHeader(void );
115         void checkAxisDomainsGridsEligibilityForCompressedOutput();
116         void prepareTimeseries(void);
117         void solveOnlyRefOfEnabledFields(bool sendToServer);         
118         void buildFilterGraphOfEnabledFields();
119         void startPrefetchingOfEnabledReadModeFiles();
120         void checkPrefetchingOfEnabledReadModeFiles();
121         void findFieldsWithReadAccess(void);
122         void solveAllRefOfFieldsWithReadAccess();
123         void buildFilterGraphOfFieldsWithReadAccess();
124         void postProcessing();
125         void postProcessingGlobalAttributes();         
126
127         void solveAllRefOfEnabledFieldsAndTransform(bool sendToServer);
128         void checkGridEnabledFields();
129         void sendGridEnabledFields();
130
131//         std::map<int, StdSize> getAttributesBufferSize(std::map<int, StdSize>& maxEventSize);
132//         std::map<int, StdSize> getDataBufferSize(std::map<int, StdSize>& maxEventSize);
133//         void setClientServerBuffer();
134         std::map<int, StdSize> getAttributesBufferSize(std::map<int, StdSize>& maxEventSize, CContextClient* contextClient);
135         std::map<int, StdSize> getDataBufferSize(std::map<int, StdSize>& maxEventSize, CContextClient* contextClient);
136         void setClientServerBuffer(CContextClient* contextClient);
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.