source: XIOS/trunk/src/interface/c/icdata.cpp @ 509

Last change on this file since 509 was 509, checked in by mhnguyen, 9 years ago

Implementing buffer size auto-detection for mode client -server

+) Process xml tree in client side then send all the information to server
+) Only information enabled fields in enabled files are sent to server
+) Some important change in structure of code which must be refactored

Test
+) On Curie
+) Only mode client-server
+) Passed for all tests

  • 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
  • Property svn:eol-style set to native
File size: 15.7 KB
Line 
1/* ************************************************************************** *
2 *      Copyright © IPSL/LSCE, xios, Avril 2010 - Octobre 2011         *
3 * ************************************************************************** */
4
5#include <boost/multi_array.hpp>
6#include <boost/shared_ptr.hpp>
7#include <string>
8#include <cstring>
9#include <iostream>
10
11
12#include "xmlioserver.hpp"
13#include "oasis_cinterface.hpp"
14
15#include "attribute_template.hpp"
16#include "object_template.hpp"
17#include "group_template.hpp"
18
19#include "icutil.hpp"
20#include "cxios.hpp"
21#include "client.hpp"
22#include "field.hpp"
23#include "context.hpp"
24#include "context_client.hpp"
25#include "mpi.hpp"
26#include "timer.hpp"
27#include "array_new.hpp"
28
29
30extern "C"
31{
32// /////////////////////////////// Définitions ////////////////////////////// //
33
34   // ----------------------- Redéfinition de types ----------------------------
35
36   typedef enum { NETCDF4 = 0 } XFileType;
37
38   typedef xios::CContext * XContextPtr;
39
40   // -------------------- Traitement des données ------------------------------
41   void cxios_init_server(void)
42   {
43     CXios::initServerSide();
44   }
45
46   void cxios_init_client(const char * client_id , int len_client_id, MPI_Fint* f_local_comm, MPI_Fint* f_return_comm )
47   {
48      std::string str;
49      MPI_Comm local_comm ;
50      MPI_Comm return_comm ;
51
52      if (!cstr2string(client_id, len_client_id, str)) return;
53
54      int initialized ;
55      MPI_Initialized(&initialized) ;
56      if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm) ;
57      else local_comm=MPI_COMM_NULL ;
58      CXios::initClientSide(str,local_comm,return_comm);
59      *f_return_comm=MPI_Comm_c2f(return_comm) ;
60      CTimer::get("XIOS init").suspend() ;
61      CTimer::get("XIOS").suspend() ;
62   }
63
64   void cxios_context_initialize(const char * context_id , int len_context_id, MPI_Fint* f_comm)
65   {
66     std::string str;
67     MPI_Comm comm ;
68
69     if (!cstr2string(context_id, len_context_id, str)) return;
70     CTimer::get("XIOS").resume() ;
71     CTimer::get("XIOS init context").resume() ;
72     comm=MPI_Comm_f2c(*f_comm) ;
73     CClient::registerContext(str,comm) ;
74     CTimer::get("XIOS init context").suspend() ;
75     CTimer::get("XIOS").suspend() ;
76   }
77
78   void cxios_context_is_initialized(const char * context_id , int len_context_id, bool* initialized)
79   {
80     std::string str;
81
82     if (!cstr2string(context_id, len_context_id, str)) return;
83     CTimer::get("XIOS").resume() ;
84     CContext* context = CContext::get(str,str) ;
85     *initialized=context->isInitialized() ;
86     CTimer::get("XIOS").suspend() ;
87   }
88
89    void cxios_context_close_definition()
90   {
91     CTimer::get("XIOS").resume() ;
92     CTimer::get("XIOS close definition").resume() ;
93     CContext* context = CContext::getCurrent() ;
94//     context->setClientServerBuffer();
95     context->closeDefinition() ;
96     CTimer::get("XIOS close definition").suspend() ;
97     CTimer::get("XIOS").suspend() ;
98   }
99
100   void cxios_context_finalize()
101   {
102     CTimer::get("XIOS").resume() ;
103     CTimer::get("XIOS context finalize").resume() ;
104     CContext* context = CContext::getCurrent() ;
105     context->finalize() ;
106     CTimer::get("XIOS context finalize").suspend() ;
107     CTimer::get("XIOS").suspend() ;
108   }
109
110   void cxios_finalize()
111   {
112     CTimer::get("XIOS").resume() ;
113     CTimer::get("XIOS finalize").resume() ;
114     CXios::clientFinalize() ;
115   }
116
117   void cxios_solve_inheritance()
118   {
119     CTimer::get("XIOS").resume() ;
120     CContext* context = CContext::getCurrent() ;
121     context->solveAllInheritance(false) ;
122     CTimer::get("XIOS").suspend() ;
123   }
124
125   /*! \brief This group of functions retrieve variable information from the configuration file (.xml)
126    *
127    * These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml),
128    * from a Fortran one, for example the value of a variable with id = "using_server".
129    * Each function corresponds to each basic type.
130    * \param varId        [in] id of the variable that we'd like to get
131    * \param varIdSize    [in] size of the variable type (integer, float, double, string)
132    * \param dataInt      [in/out] the retrieved data
133    * \param isVarExisted [in/out] Verify whether variable with varId exists
134   */
135   void cxios_get_variable_data_k8(const char * varId, int varIdSize, double * data, bool * isVarExisted)
136   {
137      std::string varIdStr;
138      if (!cstr2string(varId, varIdSize, varIdStr)) return;
139
140      CTimer::get("XIOS").resume();
141      CTimer::get("XIOS get variable data").resume();
142
143      CContext* context = CContext::getCurrent();
144      *isVarExisted = CVariable::has(context->getId(), varIdStr);
145
146      if (*isVarExisted)
147      {
148        *data = CVariable::get(context->getId(),varIdStr)->getData<double>();
149      }
150
151      CTimer::get("XIOS get variable data").suspend() ;
152      CTimer::get("XIOS").suspend() ;
153   }
154
155   void cxios_get_variable_data_k4(const char * varId, int varIdSize, float * data, bool * isVarExisted)
156   {
157      std::string varIdStr;
158      if (!cstr2string(varId, varIdSize, varIdStr)) return;
159
160      CTimer::get("XIOS").resume();
161      CTimer::get("XIOS get variable data").resume();
162
163      CContext* context = CContext::getCurrent();
164      *isVarExisted = CVariable::has(context->getId(), varIdStr);
165
166      if (*isVarExisted)
167      {
168        *data = CVariable::get(context->getId(),varIdStr)->getData<float>();
169      }
170
171      CTimer::get("XIOS get variable data").suspend() ;
172      CTimer::get("XIOS").suspend() ;
173   }
174
175   void cxios_get_variable_data_int(const char * varId, int varIdSize, int * data, bool * isVarExisted)
176   {
177      std::string varIdStr;
178      if (!cstr2string(varId, varIdSize, varIdStr)) return;
179
180      CTimer::get("XIOS").resume();
181      CTimer::get("XIOS get variable data").resume();
182
183      CContext* context = CContext::getCurrent();
184      *isVarExisted = CVariable::has(context->getId(), varIdStr);
185
186      if (*isVarExisted)
187      {
188        *data = CVariable::get(context->getId(),varIdStr)->getData<int>();
189      }
190
191      CTimer::get("XIOS get variable data").suspend() ;
192      CTimer::get("XIOS").suspend() ;
193   }
194
195   void cxios_get_variable_data_logic(const char * varId, int varIdSize, bool * data, bool * isVarExisted)
196   {
197      std::string varIdStr;
198      if (!cstr2string(varId, varIdSize, varIdStr)) return;
199
200      CTimer::get("XIOS").resume();
201      CTimer::get("XIOS get variable data").resume();
202
203      CContext* context = CContext::getCurrent();
204      *isVarExisted = CVariable::has(context->getId(), varIdStr);
205
206      if (*isVarExisted)
207      {
208        *data = CVariable::get(context->getId(),varIdStr)->getData<bool>();
209      }
210
211      CTimer::get("XIOS get variable data").suspend() ;
212      CTimer::get("XIOS").suspend() ;
213   }
214
215   void cxios_get_variable_data_char(const char * varId, int varIdSize, char * data, int dataSizeIn, bool * isVarExisted)
216   {
217      std::string varIdStr;
218      if (!cstr2string(varId, varIdSize, varIdStr)) return;
219
220      CTimer::get("XIOS").resume();
221      CTimer::get("XIOS get variable data").resume();
222
223      CContext* context = CContext::getCurrent();
224      *isVarExisted = CVariable::has(context->getId(), varIdStr);
225
226      if (*isVarExisted)
227      {
228        int dataSizeOut = CVariable::get(context->getId(),varIdStr)->getData<string>().length();
229        strncpy(data, CVariable::get(context->getId(),varIdStr)->getData<string>().c_str(), std::min(dataSizeIn, dataSizeOut));
230      }
231
232      CTimer::get("XIOS get variable data").suspend() ;
233      CTimer::get("XIOS").suspend() ;
234   }
235
236   /*! \brief This group of functions write information into existing variable in the configuration file (.xml)
237    *
238    *  These functions provide intermediate C interfaces to get variable information of the configuration file (e.x iodef.xml),
239    * from a Fortran one, for example the value of a variable with id = "using_server".
240    * Each function corresponds to each basic type.
241    * \param varId        [in] id of the variable that we'd like to get
242    * \param varIdSize    [in] size of the variable type (integer, float, double, string)
243    * \param data         [in] the input data
244    * \param isVarExisted [in/out] Verify whether variable with varId exists
245   */
246   void cxios_set_variable_data_k8(const char * varId, int varIdSize, double data, bool * isVarExisted)
247   {
248      std::string varIdStr;
249      if (!cstr2string(varId, varIdSize, varIdStr)) return;
250
251      CTimer::get("XIOS").resume();
252      CTimer::get("XIOS set variable data").resume();
253
254      CContext* context = CContext::getCurrent() ;
255      *isVarExisted = CVariable::has(context->getId(), varIdStr);
256
257      if (*isVarExisted)
258      {
259        CVariable::get(context->getId(),varIdStr)->setData<double>(data);
260        //CVariable::get(context->getId(),varIdStr)->sendValue();
261      }
262
263      CTimer::get("XIOS set variable data").suspend() ;
264      CTimer::get("XIOS").suspend() ;
265   }
266
267   void cxios_set_variable_data_k4(const char * varId, int varIdSize, float data, bool * isVarExisted)
268   {
269      std::string varIdStr;
270      if (!cstr2string(varId, varIdSize, varIdStr)) return;
271
272      CTimer::get("XIOS").resume();
273      CTimer::get("XIOS set variable data").resume();
274
275      CContext* context = CContext::getCurrent() ;
276      *isVarExisted = CVariable::has(context->getId(), varIdStr);
277
278      if (*isVarExisted)
279      {
280        CVariable::get(context->getId(),varIdStr)->setData<float>(data);
281        //CVariable::get(context->getId(),varIdStr)->sendValue();
282      }
283
284      CTimer::get("XIOS set variable data").suspend() ;
285      CTimer::get("XIOS").suspend() ;
286   }
287
288   void cxios_set_variable_data_int(const char * varId, int varIdSize, int data, bool * isVarExisted)
289   {
290      std::string varIdStr;
291      if (!cstr2string(varId, varIdSize, varIdStr)) return;
292
293      CTimer::get("XIOS").resume();
294      CTimer::get("XIOS set variable data").resume();
295
296      CContext* context = CContext::getCurrent() ;
297      *isVarExisted = CVariable::has(context->getId(), varIdStr);
298
299      if (*isVarExisted)
300      {
301        CVariable::get(context->getId(),varIdStr)->setData<int>(data);
302        //CVariable::get(context->getId(),varIdStr)->sendValue();
303      }
304
305
306      CTimer::get("XIOS set variable data").suspend() ;
307      CTimer::get("XIOS").suspend() ;
308   }
309
310   void cxios_set_variable_data_logic(const char * varId, int varIdSize, bool data, bool * isVarExisted)
311   {
312      std::string varIdStr;
313      if (!cstr2string(varId, varIdSize, varIdStr)) return;
314
315      CTimer::get("XIOS").resume();
316      CTimer::get("XIOS set variable data").resume();
317
318      CContext* context = CContext::getCurrent() ;
319      *isVarExisted = CVariable::has(context->getId(), varIdStr);
320
321      if (*isVarExisted)
322      {
323        CVariable::get(context->getId(),varIdStr)->setData<bool>(data);
324        //CVariable::get(context->getId(),varIdStr)->sendValue();
325      }
326
327      CTimer::get("XIOS set variable data").suspend() ;
328      CTimer::get("XIOS").suspend() ;
329   }
330
331   void cxios_set_variable_data_char(const char * varId, int varIdSize, const char * data, int dataSizeIn, bool * isVarExisted)
332   {
333      std::string varIdStr, dataStr;
334      if (!cstr2string(varId, varIdSize, varIdStr)) return;
335      if (!cstr2string(data, dataSizeIn, dataStr))
336      {
337        *isVarExisted = false;
338        return;
339      }
340
341      CTimer::get("XIOS").resume();
342      CTimer::get("XIOS set variable data").resume();
343
344      CContext* context = CContext::getCurrent() ;
345      *isVarExisted = CVariable::has(context->getId(), varIdStr);
346
347      if (*isVarExisted)
348      {
349        CVariable::get(context->getId(),varIdStr)->setData<string>(dataStr);
350        //CVariable::get(context->getId(),varIdStr)->sendValue();
351      }
352
353      CTimer::get("XIOS set variable data").suspend() ;
354      CTimer::get("XIOS").suspend() ;
355   }
356
357
358   // ---------------------- Ecriture des données ------------------------------
359
360   void cxios_write_data_k81(const char * fieldid, int fieldid_size, double * data_k8, int data_Xsize)
361   {
362      std::string fieldid_str;
363      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
364
365      CTimer::get("XIOS").resume() ;
366      CTimer::get("XIOS send field").resume() ;
367      CContext* context = CContext::getCurrent() ;
368      if (!context->hasServer) context->client->checkBuffers() ;
369      CArray<double,(StdSize)1> data(data_k8,shape(data_Xsize),neverDeleteData) ;
370      CField::get(fieldid_str)->setData(data) ;
371      CTimer::get("XIOS send field").suspend() ;
372      CTimer::get("XIOS").suspend() ;
373   }
374
375   void cxios_write_data_k82(const char * fieldid, int fieldid_size, double * data_k8, int data_Xsize, int data_Ysize)
376   {
377      std::string fieldid_str;
378      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
379
380      CTimer::get("XIOS").resume() ;
381      CTimer::get("XIOS send field").resume() ;
382      CContext* context = CContext::getCurrent() ;
383      if (!context->hasServer) context->client->checkBuffers() ;
384
385      CArray<double,2>data(data_k8,shape(data_Xsize,data_Ysize),neverDeleteData) ;
386      CField::get(fieldid_str)->setData(data) ;
387      CTimer::get("XIOS send field").suspend() ;
388      CTimer::get("XIOS").suspend() ;
389   }
390
391   void cxios_write_data_k83(const char * fieldid, int fieldid_size, double * data_k8, int data_Xsize, int data_Ysize, int data_Zsize)
392   {
393      std::string fieldid_str;
394      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
395
396      CTimer::get("XIOS").resume() ;
397      CTimer::get("XIOS send field").resume() ;
398      CContext* context = CContext::getCurrent() ;
399      if (!context->hasServer) context->client->checkBuffers() ;
400
401      CArray<double,3>data(data_k8,shape(data_Xsize,data_Ysize,data_Zsize),neverDeleteData) ;
402      CField::get(fieldid_str)->setData(data) ;
403      CTimer::get("XIOS send field").suspend() ;
404      CTimer::get("XIOS").suspend() ;
405   }
406
407   void cxios_write_data_k41(const char * fieldid, int fieldid_size, float * data_k4, int data_Xsize)
408   {
409      std::string fieldid_str;
410     if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
411
412      CTimer::get("XIOS").resume() ;
413      CTimer::get("XIOS send field").resume() ;
414      CContext* context = CContext::getCurrent() ;
415      if (!context->hasServer) context->client->checkBuffers() ;
416
417      CArray<float,1> data_tmp(data_k4,shape(data_Xsize),neverDeleteData) ;
418      CArray<double,1> data(data_Xsize) ;
419      data=data_tmp ;
420      CField::get(fieldid_str)->setData(data) ;
421      CTimer::get("XIOS send field").suspend() ;
422      CTimer::get("XIOS").suspend() ;
423   }
424
425   void cxios_write_data_k42(const char * fieldid, int fieldid_size, float * data_k4, int data_Xsize, int data_Ysize)
426   {
427      std::string fieldid_str;
428      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
429
430      CTimer::get("XIOS").resume() ;
431      CTimer::get("XIOS send field").resume() ;
432      CContext* context = CContext::getCurrent() ;
433      if (!context->hasServer) context->client->checkBuffers() ;
434
435      CArray<float,2> data_tmp(data_k4,shape(data_Xsize,data_Ysize),neverDeleteData) ;
436      CArray<double,2> data(data_Xsize,data_Ysize) ;
437      data=data_tmp ;
438      CField::get(fieldid_str)->setData(data) ;
439      CTimer::get("XIOS send field").suspend() ;
440      CTimer::get("XIOS").suspend() ;
441   }
442
443   void cxios_write_data_k43(const char * fieldid, int fieldid_size, float * data_k4, int data_Xsize, int data_Ysize, int data_Zsize)
444   {
445      std::string fieldid_str;
446
447      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
448
449      CTimer::get("XIOS").resume() ;
450      CTimer::get("XIOS send field").resume() ;
451      CContext* context = CContext::getCurrent() ;
452      if (!context->hasServer) context->client->checkBuffers() ;
453
454      CArray<float,3> data_tmp(data_k4,shape(data_Xsize,data_Ysize,data_Zsize),neverDeleteData) ;
455      CArray<double,3> data(data_Xsize,data_Ysize,data_Zsize) ;
456      data=data_tmp ;
457
458      CField::get(fieldid_str)->setData(data) ;
459      CTimer::get("XIOS send field").suspend() ;
460      CTimer::get("XIOS").suspend() ;
461
462    }
463
464} // extern "C"
Note: See TracBrowser for help on using the repository browser.