source: XIOS/trunk/src/node/context.hpp @ 1622

Last change on this file since 1622 was 1622, checked in by oabramkina, 22 months ago

Exception handling on trunk.

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
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
15
16namespace xios {
17   class CContextClient;
18   class CContextServer;
19
20
21   /// ////////////////////// Déclarations ////////////////////// ///
22   class CContextGroup;
23   class CContextAttributes;
24   class CContext;
25   class CFile;
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   ///--------------------------------------------------------------
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  */
42   class CContext
43      : public CObjectTemplate<CContext>
44      , public CContextAttributes
45   {
46         public :
47         enum EEventId
48         {
49           EVENT_ID_CLOSE_DEFINITION,EVENT_ID_UPDATE_CALENDAR,
50           EVENT_ID_CREATE_FILE_HEADER,EVENT_ID_CONTEXT_FINALIZE,
51           EVENT_ID_POST_PROCESS, EVENT_ID_SEND_REGISTRY,
52           EVENT_ID_POST_PROCESS_GLOBAL_ATTRIBUTES,
53           EVENT_ID_PROCESS_GRID_ENABLED_FIELDS
54         };
55
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 :
81
82         /// Mutateurs ///
83         void setCalendar(std::shared_ptr<CCalendar> newCalendar);
84
85         /// Accesseurs ///
86         std::shared_ptr<CCalendar>      getCalendar(void) const;
87
88      public :
89         // Initialize server or client
90         void initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer = 0);
91         void initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient = 0);
92         bool isInitialized(void);
93
94         StdString dumpClassAttributes(void);
95
96         // Put sever or client into loop state
97         bool checkBuffersAndListen(bool enableEventsProcessing=true);
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 findAllEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
107         // void findAllEnabledFields(void);
108         // void findAllEnabledFieldsInReadModeFiles(void);
109         void readAttributesOfEnabledFieldsInReadModeFiles();
110         void solveAllInheritance(bool apply=true);
111         void findEnabledFiles(void);
112         void findEnabledWriteModeFiles(void);
113         void findEnabledReadModeFiles(void);
114         void closeAllFile(void);
115         void updateCalendar(int step);
116         void createFileHeader(void);
117         void initReadFiles(void);
118         void checkAxisDomainsGridsEligibilityForCompressedOutput();
119         void prepareTimeseries(void);
120         void solveOnlyRefOfEnabledFields(bool sendToServer);         
121         void buildFilterGraphOfEnabledFields();
122         void postProcessFilterGraph();
123         void startPrefetchingOfEnabledReadModeFiles();
124         void doPreTimestepOperationsForEnabledReadModeFiles();
125         void doPostTimestepOperationsForEnabledReadModeFiles();
126         void findFieldsWithReadAccess(void);
127         void solveAllRefOfFieldsWithReadAccess();
128         void buildFilterGraphOfFieldsWithReadAccess();
129         void postProcessing();
130         void postProcessingGlobalAttributes();         
131
132         void solveAllRefOfEnabledFieldsAndTransform(bool sendToServer);
133         void checkGridEnabledFields();
134         void checkGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles);
135         void sendGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles); 
136         void sendGridComponentEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles)       ;
137
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);
141
142         // Distribute files (in write mode) among secondary-server pools according to the estimated data flux
143         void distributeFiles(void);
144         void distributeFileOverBandwith() ;
145         void distributeFileOverMemoryBandwith() ;
146         
147         // Send context close definition
148         void sendCloseDefinition(void);
149         // There are something to send on closing context defintion
150         void sendUpdateCalendar(int step);
151         void sendCreateFileHeader(void);
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);
156         void sendPostProcessing();
157         void sendPostProcessingGlobalAttributes();
158         void sendProcessingGridOfEnabledFields();
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
162         const StdString& getIdServer();
163         const StdString& getIdServer(const int srvPoolNb);
164
165         // Client side: Receive and process messages
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);
171         static void recvSolveInheritanceContext(CEventServer& event);
172         void recvSolveInheritanceContext(CBufferIn& buffer);
173         static void recvPostProcessing(CEventServer& event);
174         void recvPostProcessing(CBufferIn& buffer);
175         static void recvProcessingGridOfEnabledFields(CEventServer& event);
176         static void recvPostProcessingGlobalAttributes(CEventServer& event);
177         void recvPostProcessingGlobalAttributes(CBufferIn& buffer);
178         static void recvRegistry(CEventServer& event) ;
179         void recvRegistry(CBufferIn& buffer) ; //!< registry is received by the servers
180
181         void freeComms(void);                  //!< Free internally allcoated communicators
182         void releaseClientBuffers(void);       //! Deallocate buffers allocated by clientContexts
183
184         // dispatch event
185         static bool dispatchEvent(CEventServer& event);
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
211      public :
212         // Parse xml node and write all info into context
213         virtual void parse(xml::CXMLNode & node);
214
215         // Visualize a context
216         virtual StdString toString(void) const;
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
225
226      public :
227         // Calendar of context
228         std::shared_ptr<CCalendar>   calendar;
229
230         // List of all enabled files (files on which fields are written or read)
231         std::vector<CFile*> enabledFiles;
232         // List of all enabled files in read mode (files on which fields are read)
233         std::vector<CFile*> enabledReadModeFiles;
234         // List of all enabled files in write mode
235         std::vector<CFile*> enabledWriteModeFiles;
236
237         // List of all enabled fields whose instant data is accessible from the public API
238         // but which are not part of a file
239         std::vector<CField*> fieldsWithReadAccess;
240
241         // Context root
242         static std::shared_ptr<CContextGroup> root;
243
244         // Determine context on client or not
245         bool hasClient;
246
247         // Determine context on server or not
248         bool hasServer;
249
250         CContextServer* server;    //!< Concrete context server
251         CContextClient* client;    //!< Concrete contex client
252         std::vector<CContextServer*> serverPrimServer;
253         std::vector<CContextClient*> clientPrimServer;
254
255         CRegistry* registryIn ;    //!< input registry which is read from file
256         CRegistry* registryOut ;   //!< output registry which will be written into file at the finalize
257
258      private:
259         bool isPostProcessed;
260         bool allProcessed;
261         bool finalized;
262         int countChildCtx_;        //!< Counter of child contexts (for now it is the number of secondary server pools)
263         StdString idServer_;
264         CGarbageCollector garbageCollector;
265         std::list<MPI_Comm> comms; //!< Communicators allocated internally
266
267      public: // Some function maybe removed in the near future
268        // virtual void toBinary  (StdOStream & os) const;
269        // virtual void fromBinary(StdIStream & is);
270   }; // class CContext
271
272   ///--------------------------------------------------------------
273
274   // Declare/Define CContextGroup and CContextDefinition
275   DECLARE_GROUP(CContext);
276
277   ///--------------------------------------------------------------
278
279} // namespace xios
280
281#endif // __XIOS_CContext__
Note: See TracBrowser for help on using the repository browser.