Ignore:
Timestamp:
01/23/19 10:31:44 (5 years ago)
Author:
yushan
Message:

dev on ADA. add flag switch _usingEP/_usingMPI

Location:
XIOS/dev/branch_openmp/src/interface/c
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • XIOS/dev/branch_openmp/src/interface/c/icaxis.cpp

    r1545 r1642  
    2828    
    2929   void cxios_axis_handle_create (XAxisPtr * _ret, const char * _id, int _id_len) 
     30   TRY 
    3031   { 
    3132      std::string id;  
    … …  
    3536      CTimer::get("XIOS").suspend() ; 
    3637   } 
     38   CATCH_DUMP_STACK 
    3739    
    3840   void cxios_axisgroup_handle_create (XAxisGroupPtr * _ret, const char * _id, int _id_len) 
     41   TRY 
    3942   { 
    4043      std::string id;  
    … …  
    4447      CTimer::get("XIOS").suspend() ; 
    4548    } 
     49   CATCH_DUMP_STACK 
    4650 
    4751   // -------------------- Vérification des identifiants ----------------------- 
    4852 
    4953   void cxios_axis_valid_id (bool * _ret, const char * _id, int _id_len) 
     54   TRY 
    5055   { 
    5156      std::string id; 
    … …  
    5661      CTimer::get("XIOS").suspend() ; 
    5762   } 
     63   CATCH_DUMP_STACK 
    5864 
    5965   void cxios_axisgroup_valid_id (bool * _ret, const char * _id, int _id_len) 
     66   TRY 
    6067   { 
    6168      std::string id; 
    … …  
    6774 
    6875   } 
     76   CATCH_DUMP_STACK 
    6977    
    7078} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/iccalendar.cpp

    r1545 r1642  
    1010{ 
    1111  void cxios_update_calendar(int step) 
     12  TRY 
    1213  { 
    1314    CTimer::get("XIOS").resume(); 
    … …  
    1920    CTimer::get("XIOS").suspend(); 
    2021  } 
     22  CATCH_DUMP_STACK 
    2123 
    2224  void cxios_get_current_date(cxios_date* current_date_c) 
     25  TRY 
    2326  { 
    2427    CTimer::get("XIOS").resume(); 
    … …  
    3740    CTimer::get("XIOS").suspend(); 
    3841  } 
     42  CATCH_DUMP_STACK 
    3943 
    4044  int cxios_get_year_length_in_seconds(int year) 
     45  TRY 
    4146  { 
    4247    CTimer::get("XIOS").resume(); 
    … …  
    5055    return length; 
    5156  } 
     57  CATCH_DUMP_STACK 
    5258 
    5359  int cxios_get_day_length_in_seconds() 
     60  TRY 
    5461  { 
    5562    CTimer::get("XIOS").resume(); 
    … …  
    6370    return length; 
    6471  } 
     72  CATCH_DUMP_STACK 
    6573} 

  • XIOS/dev/branch_openmp/src/interface/c/iccalendar_wrapper.cpp

    r1545 r1642  
    2929 
    3030  void cxios_calendar_wrapper_handle_create(XCalendarWrapperPtr* _ret, const char* _id, int _id_len) 
     31  TRY 
    3132  { 
    3233    std::string id; 
    … …  
    3637    CTimer::get("XIOS").suspend(); 
    3738  } 
     39  CATCH_DUMP_STACK 
    3840 
    3941  void cxios_get_current_calendar_wrapper(XCalendarWrapperPtr* _ret) 
     42  TRY 
    4043  { 
    4144    CTimer::get("XIOS").resume(); 
    … …  
    4346    CTimer::get("XIOS").suspend(); 
    4447  } 
     48  CATCH_DUMP_STACK 
    4549 
    4650  // -------------------- Vérification des identifiants ----------------------- 
    4751 
    4852  void cxios_calendar_wrapper_valid_id(bool* _ret, const char* _id, int _id_len) 
     53  TRY 
    4954  { 
    5055    std::string id; 
    … …  
    5459    CTimer::get("XIOS").suspend(); 
    5560  } 
     61  CATCH_DUMP_STACK 
    5662 
    5763  // ----------------------- Custom getters and setters ----------------------- 
    5864 
    5965  void cxios_set_calendar_wrapper_date_start_date(XCalendarWrapperPtr calendarWrapper_hdl, cxios_date start_date_c) 
     66  TRY 
    6067  { 
    6168    CTimer::get("XIOS").resume(); 
    … …  
    7077    CTimer::get("XIOS").suspend(); 
    7178  } 
     79  CATCH_DUMP_STACK 
    7280 
    7381  void cxios_get_calendar_wrapper_date_start_date(XCalendarWrapperPtr calendarWrapper_hdl, cxios_date* start_date_c) 
     82  TRY 
    7483  { 
    7584    CTimer::get("XIOS").resume(); 
    … …  
    8392    CTimer::get("XIOS").suspend(); 
    8493  } 
     94  CATCH_DUMP_STACK 
    8595 
    8696  void cxios_set_calendar_wrapper_date_time_origin(XCalendarWrapperPtr calendarWrapper_hdl, cxios_date time_origin_c) 
     97  TRY 
    8798  { 
    8899    CTimer::get("XIOS").resume(); 
    … …  
    97108    CTimer::get("XIOS").suspend(); 
    98109  } 
     110  CATCH_DUMP_STACK 
    99111 
    100112  void cxios_get_calendar_wrapper_date_time_origin(XCalendarWrapperPtr calendarWrapper_hdl, cxios_date* time_origin_c) 
     113  TRY 
    101114  { 
    102115    CTimer::get("XIOS").resume(); 
    … …  
    110123    CTimer::get("XIOS").suspend(); 
    111124  } 
     125  CATCH_DUMP_STACK 
    112126 
    113127  // ----------------------- Calendar creation and update ---------------------- 
    114128 
    115129  void cxios_create_calendar(XCalendarWrapperPtr calendarWrapper_hdl) 
     130  TRY 
    116131  { 
    117132    CTimer::get("XIOS").resume(); 
    … …  
    119134    CTimer::get("XIOS").suspend(); 
    120135  } 
     136  CATCH_DUMP_STACK 
    121137 
    122138  void cxios_update_calendar_timestep(XCalendarWrapperPtr calendarWrapper_hdl) 
     139  TRY 
    123140  { 
    124141    CTimer::get("XIOS").resume(); 
    … …  
    126143    CTimer::get("XIOS").suspend(); 
    127144  } 
     145  CATCH_DUMP_STACK 
    128146} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/iccompute_connectivity_domain.cpp

    r1545 r1642  
    2525   // ------------------------ Création des handle ----------------------------- 
    2626   void cxios_compute_connectivity_domain_handle_create(XComConDomainPtr * _ret, const char * _id, int _id_len) 
     27   TRY 
    2728   { 
    2829      std::string id; 
    … …  
    3233      CTimer::get("XIOS").suspend() ; 
    3334   } 
     35   CATCH_DUMP_STACK 
    3436 
    3537   // -------------------- Vérification des identifiants ----------------------- 
    3638   void cxios_compute_connectivity_domain_valid_id(bool * _ret, const char * _id, int _id_len) 
     39   TRY 
    3740   { 
    3841      std::string id; 
    … …  
    4346      CTimer::get("XIOS").suspend() ; 
    4447   } 
     48   CATCH_DUMP_STACK 
    4549} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/iccontext.cpp

    r1545 r1642  
    3232 
    3333   void cxios_context_handle_create (XContextPtr * _ret, const char * _id, int _id_len) 
     34   TRY 
    3435   { 
    3536      std::string id; 
    … …  
    5455      // Lever une exeception ici 
    5556   } 
     57   CATCH_DUMP_STACK 
    5658 
    5759   // ------------------------ Changements de contextes ------------------------ 
    5860 
    5961   void cxios_context_get_current(XContextPtr* context) 
     62   TRY 
    6063   { 
    6164      CTimer::get("XIOS").resume(); 
    … …  
    6366      CTimer::get("XIOS").suspend(); 
    6467   } 
     68   CATCH_DUMP_STACK 
    6569 
    6670   void cxios_context_set_current(XContextPtr context, bool withswap) 
     71   TRY 
    6772   { 
    6873      CTimer::get("XIOS").resume() ; 
    … …  
    7075      CTimer::get("XIOS").suspend() ; 
    7176   } 
     77   CATCH_DUMP_STACK 
    7278 
    7379   // -------------------- Vérification des identifiants ----------------------- 
    7480 
    7581   void cxios_context_valid_id (bool * _ret, const char * _id, int _id_len) 
     82   TRY 
    7683   { 
    7784      std::string id; 
    … …  
    93100      CTimer::get("XIOS").suspend(); 
    94101   } 
     102   CATCH_DUMP_STACK 
    95103} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icdata.cpp

    r1545 r1642  
    99#include <iostream> 
    1010 
    11 #include "mpi_std.hpp" 
     11 
    1212#include "xios.hpp" 
    13 //#include "oasis_cinterface.hpp" 
     13#include "oasis_cinterface.hpp" 
    1414 
    1515#include "attribute_template.hpp" 
    … …  
    2323#include "context.hpp" 
    2424#include "context_client.hpp" 
    25  
     25#include "mpi.hpp" 
    2626#include "timer.hpp" 
    2727#include "array_new.hpp" 
    … …  
    4343   // it is only used from the parse_xml.exe standalone test tool. 
    4444   void cxios_init(void) 
     45   TRY 
    4546   { 
    4647     CXios::initialize(); 
    4748   } 
     49   CATCH_DUMP_STACK 
    4850 
    4951   void cxios_init_server(void) 
     52   TRY 
    5053   { 
    5154     CXios::initServerSide(); 
    5255   } 
     56   CATCH_DUMP_STACK 
    5357 
    5458   void cxios_init_client(const char* client_id , int len_client_id, MPI_Fint* f_local_comm, MPI_Fint* f_return_comm ) 
     59   TRY 
    5560   { 
    5661      std::string str; 
    … …  
    6166 
    6267      int initialized; 
    63       MPI_Initialized(&initialized); 
     68      ep_lib::MPI_Initialized(&initialized); 
    6469      #ifdef _usingMPI 
    6570      if (initialized) local_comm=MPI_Comm_f2c(*f_local_comm); 
    6671      else local_comm=MPI_COMM_NULL; 
    6772      #elif _usingEP 
    68       ep_lib::fc_comm_map.clear(); 
    69       if (initialized) local_comm=ep_lib::EP_Comm_f2c((f_local_comm)); 
    70       else local_comm=MPI_COMM_NULL; 
     73      if (initialized) local_comm=EP_Comm_f2c(f_local_comm); 
     74      else local_comm=EP_COMM_NULL; 
    7175      #endif 
    72        
    73  
    74  
    7576      CXios::initClientSide(str, local_comm, return_comm); 
    7677      #ifdef _usingMPI 
    7778      *f_return_comm=MPI_Comm_c2f(return_comm); 
    7879      #elif _usingEP 
    79       *f_return_comm=*static_cast<MPI_Fint*>(ep_lib::EP_Comm_c2f(return_comm)); 
     80      *f_return_comm=*static_cast<MPI_Fint* >(EP_Comm_c2f(return_comm)); 
    8081      #endif 
    8182      CTimer::get("XIOS init").suspend(); 
    8283      CTimer::get("XIOS").suspend(); 
    8384   } 
     85   CATCH_DUMP_STACK 
    8486 
    8587   void cxios_context_initialize(const char* context_id , int len_context_id, MPI_Fint* f_comm) 
     88   TRY 
    8689   { 
    8790     std::string str; 
    … …  
    9497     comm=MPI_Comm_f2c(*f_comm); 
    9598     #elif _usingEP 
    96      comm = ep_lib::EP_Comm_f2c(f_comm); 
     99     comm=EP_Comm_f2c(f_comm); 
    97100     #endif 
    98101     CClient::registerContext(str, comm); 
    … …  
    100103     CTimer::get("XIOS").suspend(); 
    101104   } 
     105   CATCH_DUMP_STACK 
     106 
     107   void cxios_oasis_enddef() 
     108   TRY 
     109   { 
     110     CTimer::get("XIOS").resume(); 
     111     CClient::callOasisEnddef(); 
     112     CTimer::get("XIOS").suspend(); 
     113   } 
     114   CATCH_DUMP_STACK 
    102115 
    103116   void cxios_context_is_initialized(const char* context_id , int len_context_id, bool* initialized) 
     117   TRY 
    104118   { 
    105119     std::string str; 
    … …  
    111125     CTimer::get("XIOS").suspend(); 
    112126   } 
    113  
    114     void cxios_context_close_definition() 
     127   CATCH_DUMP_STACK 
     128 
     129   void cxios_context_close_definition() 
     130   TRY 
    115131   { 
    116132     CTimer::get("XIOS").resume(); 
    … …  
    121137     CTimer::get("XIOS").suspend(); 
    122138   } 
     139   CATCH_DUMP_STACK 
    123140 
    124141   void cxios_context_finalize() 
     142   TRY 
    125143   { 
    126144     CTimer::get("XIOS").resume(); 
    … …  
    131149     CTimer::get("XIOS").suspend(); 
    132150   } 
     151   CATCH_DUMP_STACK 
    133152 
    134153   void cxios_finalize() 
     154   TRY 
    135155   { 
    136156     CTimer::get("XIOS").resume(); 
    … …  
    138158     CXios::clientFinalize(); 
    139159   } 
     160   CATCH_DUMP_STACK 
    140161 
    141162   void cxios_solve_inheritance() 
     163   TRY 
    142164   { 
    143165     CTimer::get("XIOS").resume(); 
    … …  
    146168     CTimer::get("XIOS").suspend(); 
    147169   } 
     170   CATCH_DUMP_STACK 
    148171 
    149172   /*! \brief This group of functions retrieve variable information from the configuration file (.xml) 
    … …  
    158181   */ 
    159182   void cxios_get_variable_data_k8(const char* varId, int varIdSize, double* data, bool* isVarExisted) 
     183   TRY 
    160184   { 
    161185      std::string varIdStr; 
    … …  
    176200      CTimer::get("XIOS").suspend(); 
    177201   } 
     202   CATCH_DUMP_STACK 
    178203 
    179204   void cxios_get_variable_data_k4(const char* varId, int varIdSize, float* data, bool* isVarExisted) 
     205   TRY 
    180206   { 
    181207      std::string varIdStr; 
    … …  
    196222      CTimer::get("XIOS").suspend(); 
    197223   } 
     224   CATCH_DUMP_STACK 
    198225 
    199226   void cxios_get_variable_data_int(const char* varId, int varIdSize, int* data, bool* isVarExisted) 
     227   TRY 
    200228   { 
    201229      std::string varIdStr; 
    … …  
    216244      CTimer::get("XIOS").suspend(); 
    217245   } 
     246   CATCH_DUMP_STACK 
    218247 
    219248   void cxios_get_variable_data_logic(const char* varId, int varIdSize, bool* data, bool* isVarExisted) 
     249   TRY 
    220250   { 
    221251      std::string varIdStr; 
    … …  
    236266      CTimer::get("XIOS").suspend(); 
    237267   } 
     268   CATCH_DUMP_STACK 
    238269 
    239270   void cxios_get_variable_data_char(const char* varId, int varIdSize, char* data, int dataSizeIn, bool* isVarExisted) 
     271   TRY 
    240272   { 
    241273      std::string varIdStr; 
    … …  
    257289      CTimer::get("XIOS").suspend(); 
    258290   } 
     291   CATCH_DUMP_STACK 
    259292 
    260293   /*! \brief This group of functions write information into existing variable in the configuration file (.xml) 
    … …  
    269302   */ 
    270303   void cxios_set_variable_data_k8(const char* varId, int varIdSize, double data, bool* isVarExisted) 
    271    { 
     304   TRY 
     305  { 
    272306      std::string varIdStr; 
    273307      if (!cstr2string(varId, varIdSize, varIdStr)) return; 
    … …  
    288322      CTimer::get("XIOS").suspend(); 
    289323   } 
     324   CATCH_DUMP_STACK 
    290325 
    291326   void cxios_set_variable_data_k4(const char* varId, int varIdSize, float data, bool* isVarExisted) 
     327   TRY 
    292328   { 
    293329      std::string varIdStr; 
    … …  
    309345      CTimer::get("XIOS").suspend(); 
    310346   } 
     347   CATCH_DUMP_STACK 
    311348 
    312349   void cxios_set_variable_data_int(const char* varId, int varIdSize, int data, bool* isVarExisted) 
     350   TRY 
    313351   { 
    314352      std::string varIdStr; 
    … …  
    331369      CTimer::get("XIOS").suspend(); 
    332370   } 
     371   CATCH_DUMP_STACK 
    333372 
    334373   void cxios_set_variable_data_logic(const char* varId, int varIdSize, bool data, bool* isVarExisted) 
     374   TRY 
    335375   { 
    336376      std::string varIdStr; 
    … …  
    352392      CTimer::get("XIOS").suspend(); 
    353393   } 
     394   CATCH_DUMP_STACK 
    354395 
    355396   void cxios_set_variable_data_char(const char* varId, int varIdSize, const char* data, int dataSizeIn, bool* isVarExisted) 
    356    { 
     397   TRY 
     398  { 
    357399      std::string varIdStr, dataStr; 
    358400      if (!cstr2string(varId, varIdSize, varIdStr)) return; 
    … …  
    378420      CTimer::get("XIOS").suspend(); 
    379421   } 
    380  
     422   CATCH_DUMP_STACK 
    381423 
    382424   // ---------------------- Ecriture des données ------------------------------ 
    383425 
    384426   void cxios_write_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) 
     427   TRY 
    385428   { 
    386429      std::string fieldid_str; 
    … …  
    397440      CTimer::get("XIOS").suspend(); 
    398441   } 
     442   CATCH_DUMP_STACK 
    399443 
    400444   void cxios_write_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) 
     445   TRY 
    401446   { 
    402447      std::string fieldid_str; 
    … …  
    416461      CTimer::get("XIOS").suspend(); 
    417462   } 
     463   CATCH_DUMP_STACK 
    418464 
    419465   void cxios_write_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize) 
     466   TRY 
    420467   { 
    421468      std::string fieldid_str; 
    … …  
    435482      CTimer::get("XIOS").suspend(); 
    436483   } 
     484   CATCH_DUMP_STACK 
    437485 
    438486   void cxios_write_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize) 
     487   TRY 
    439488   { 
    440489      std::string fieldid_str; 
    … …  
    454503      CTimer::get("XIOS").suspend(); 
    455504   } 
     505   CATCH_DUMP_STACK 
    456506 
    457507   void cxios_write_data_k84(const char* fieldid, int fieldid_size, double* data_k8, int data_0size, int data_1size, int data_2size, int data_3size) 
     508   TRY 
    458509   { 
    459510      std::string fieldid_str; 
    … …  
    473524      CTimer::get("XIOS").suspend(); 
    474525   } 
     526   CATCH_DUMP_STACK 
    475527 
    476528   void cxios_write_data_k85(const char* fieldid, int fieldid_size, double* data_k8, 
    477529                             int data_0size, int data_1size, int data_2size, 
    478530                             int data_3size, int data_4size) 
     531   TRY 
    479532   { 
    480533      std::string fieldid_str; 
    … …  
    494547      CTimer::get("XIOS").suspend(); 
    495548   } 
     549   CATCH_DUMP_STACK 
    496550 
    497551   void cxios_write_data_k86(const char* fieldid, int fieldid_size, double* data_k8, 
    498552                             int data_0size, int data_1size, int data_2size, 
    499553                             int data_3size, int data_4size, int data_5size) 
     554   TRY 
    500555   { 
    501556      std::string fieldid_str; 
    … …  
    515570      CTimer::get("XIOS").suspend(); 
    516571   } 
     572   CATCH_DUMP_STACK 
    517573 
    518574   void cxios_write_data_k87(const char* fieldid, int fieldid_size, double* data_k8, 
    … …  
    520576                             int data_3size, int data_4size, int data_5size, 
    521577                             int data_6size) 
     578   TRY 
    522579   { 
    523580      std::string fieldid_str; 
    … …  
    537594      CTimer::get("XIOS").suspend(); 
    538595   } 
     596   CATCH_DUMP_STACK 
    539597 
    540598   void cxios_write_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
     599   TRY 
    541600   { 
    542601      std::string fieldid_str; 
    … …  
    556615      CTimer::get("XIOS").suspend(); 
    557616   } 
     617   CATCH_DUMP_STACK 
    558618 
    559619   void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
     620   TRY 
    560621   { 
    561622      std::string fieldid_str; 
    … …  
    577638      CTimer::get("XIOS").suspend(); 
    578639   } 
     640   CATCH_DUMP_STACK 
    579641 
    580642   void cxios_write_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize) 
     643   TRY 
    581644   { 
    582645      std::string fieldid_str; 
    … …  
    598661      CTimer::get("XIOS").suspend(); 
    599662   } 
     663   CATCH_DUMP_STACK 
    600664 
    601665   void cxios_write_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) 
     666   TRY 
    602667   { 
    603668      std::string fieldid_str; 
    … …  
    619684      CTimer::get("XIOS").suspend(); 
    620685    } 
     686   CATCH_DUMP_STACK 
    621687 
    622688   void cxios_write_data_k44(const char* fieldid, int fieldid_size, float* data_k4, 
    623689                             int data_0size, int data_1size, int data_2size, 
    624690                             int data_3size) 
     691   TRY 
    625692   { 
    626693      std::string fieldid_str; 
    … …  
    642709      CTimer::get("XIOS").suspend(); 
    643710    } 
     711   CATCH_DUMP_STACK 
    644712 
    645713   void cxios_write_data_k45(const char* fieldid, int fieldid_size, float* data_k4, 
    646714                             int data_0size, int data_1size, int data_2size, 
    647715                             int data_3size, int data_4size) 
     716   TRY 
    648717   { 
    649718      std::string fieldid_str; 
    … …  
    665734      CTimer::get("XIOS").suspend(); 
    666735    } 
     736   CATCH_DUMP_STACK 
    667737 
    668738   void cxios_write_data_k46(const char* fieldid, int fieldid_size, float* data_k4, 
    669739                             int data_0size, int data_1size, int data_2size, 
    670740                             int data_3size, int data_4size, int data_5size) 
     741   TRY 
    671742   { 
    672743      std::string fieldid_str; 
    … …  
    688759      CTimer::get("XIOS").suspend(); 
    689760    } 
     761   CATCH_DUMP_STACK 
    690762 
    691763   void cxios_write_data_k47(const char* fieldid, int fieldid_size, float* data_k4, 
    … …  
    693765                             int data_3size, int data_4size, int data_5size, 
    694766                             int data_6size) 
     767   TRY 
    695768   { 
    696769      std::string fieldid_str; 
    … …  
    712785      CTimer::get("XIOS").suspend(); 
    713786    } 
     787   CATCH_DUMP_STACK 
    714788 
    715789   // ---------------------- Lecture des données ------------------------------ 
    716790 
    717791   void cxios_read_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) 
     792   TRY 
    718793   { 
    719794      std::string fieldid_str; 
    … …  
    733808      CTimer::get("XIOS").suspend(); 
    734809   } 
     810   CATCH_DUMP_STACK 
    735811 
    736812   void cxios_read_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) 
     813   TRY 
    737814   { 
    738815      std::string fieldid_str; 
    … …  
    752829      CTimer::get("XIOS").suspend(); 
    753830   } 
     831   CATCH_DUMP_STACK 
    754832 
    755833   void cxios_read_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize) 
     834   TRY 
    756835   { 
    757836      std::string fieldid_str; 
    … …  
    771850      CTimer::get("XIOS").suspend(); 
    772851   } 
     852   CATCH_DUMP_STACK 
    773853 
    774854   void cxios_read_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize) 
     855   TRY 
    775856   { 
    776857      std::string fieldid_str; 
    … …  
    790871      CTimer::get("XIOS").suspend(); 
    791872   } 
     873   CATCH_DUMP_STACK 
    792874 
    793875   void cxios_read_data_k84(const char* fieldid, int fieldid_size, double* data_k8, 
    794876                            int data_0size, int data_1size, int data_2size, 
    795877                            int data_3size) 
     878   TRY 
    796879   { 
    797880      std::string fieldid_str; 
    … …  
    811894      CTimer::get("XIOS").suspend(); 
    812895   } 
     896   CATCH_DUMP_STACK 
    813897 
    814898   void cxios_read_data_k85(const char* fieldid, int fieldid_size, double* data_k8, 
    815899                            int data_0size, int data_1size, int data_2size, 
    816900                            int data_3size, int data_4size) 
     901   TRY 
    817902   { 
    818903      std::string fieldid_str; 
    … …  
    832917      CTimer::get("XIOS").suspend(); 
    833918   } 
     919   CATCH_DUMP_STACK 
    834920 
    835921   void cxios_read_data_k86(const char* fieldid, int fieldid_size, double* data_k8, 
    836922                            int data_0size, int data_1size, int data_2size, 
    837923                            int data_3size, int data_4size, int data_5size) 
     924   TRY 
    838925   { 
    839926      std::string fieldid_str; 
    … …  
    853940      CTimer::get("XIOS").suspend(); 
    854941   } 
     942   CATCH_DUMP_STACK 
    855943 
    856944   void cxios_read_data_k87(const char* fieldid, int fieldid_size, double* data_k8, 
    … …  
    858946                            int data_3size, int data_4size, int data_5size, 
    859947                            int data_6size) 
     948   TRY 
    860949   { 
    861950      std::string fieldid_str; 
    … …  
    875964      CTimer::get("XIOS").suspend(); 
    876965   } 
     966   CATCH_DUMP_STACK 
    877967 
    878968   void cxios_read_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
     969   TRY 
    879970   { 
    880971      std::string fieldid_str; 
    … …  
    896987      CTimer::get("XIOS").suspend(); 
    897988   } 
     989   CATCH_DUMP_STACK 
    898990 
    899991   void cxios_read_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
     992   TRY 
    900993   { 
    901994      std::string fieldid_str; 
    … …  
    9171010      CTimer::get("XIOS").suspend(); 
    9181011   } 
     1012   CATCH_DUMP_STACK 
    9191013 
    9201014   void cxios_read_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize) 
     1015   TRY 
    9211016   { 
    9221017      std::string fieldid_str; 
    … …  
    9381033      CTimer::get("XIOS").suspend(); 
    9391034   } 
     1035   CATCH_DUMP_STACK 
    9401036 
    9411037   void cxios_read_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) 
     1038   TRY 
    9421039   { 
    9431040      std::string fieldid_str; 
    … …  
    9591056      CTimer::get("XIOS").suspend(); 
    9601057    } 
     1058   CATCH_DUMP_STACK 
    9611059 
    9621060   void cxios_read_data_k44(const char* fieldid, int fieldid_size, float* data_k4, 
    9631061                            int data_0size, int data_1size, int data_2size, 
    9641062                            int data_3size) 
     1063   TRY 
    9651064   { 
    9661065      std::string fieldid_str; 
    … …  
    9821081      CTimer::get("XIOS").suspend(); 
    9831082    } 
     1083   CATCH_DUMP_STACK 
    9841084 
    9851085   void cxios_read_data_k45(const char* fieldid, int fieldid_size, float* data_k4, 
    9861086                            int data_0size, int data_1size, int data_2size, 
    9871087                            int data_3size, int data_4size) 
     1088   TRY 
    9881089   { 
    9891090      std::string fieldid_str; 
    … …  
    10051106      CTimer::get("XIOS").suspend(); 
    10061107    } 
     1108   CATCH_DUMP_STACK 
    10071109 
    10081110   void cxios_read_data_k46(const char* fieldid, int fieldid_size, float* data_k4, 
    10091111                            int data_0size, int data_1size, int data_2size, 
    10101112                            int data_3size, int data_4size, int data_5size) 
     1113   TRY 
    10111114   { 
    10121115      std::string fieldid_str; 
    … …  
    10281131      CTimer::get("XIOS").suspend(); 
    10291132    } 
     1133   CATCH_DUMP_STACK 
    10301134 
    10311135   void cxios_read_data_k47(const char* fieldid, int fieldid_size, float* data_k4, 
    … …  
    10331137                            int data_3size, int data_4size, int data_5size, 
    10341138                            int data_6size) 
     1139   TRY 
    10351140   { 
    10361141      std::string fieldid_str; 
    … …  
    10521157      CTimer::get("XIOS").suspend(); 
    10531158    } 
     1159   CATCH_DUMP_STACK 
    10541160} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icdate.cpp

    r1545 r1642  
    3535{ 
    3636  long long int cxios_date_convert_to_seconds(cxios_date date_c) 
     37  TRY 
    3738  { 
    3839    xios::CDate date = xios::CDate(getCalendar("long long int cxios_date_convert_to_seconds(cxios_date date_c)"), 
    … …  
    4142    return date; 
    4243  } 
     44  CATCH_DUMP_STACK 
    4345 
    4446  void cxios_date_convert_to_string(cxios_date date_c, char* str, int str_size) 
     47  TRY 
    4548  { 
    4649    xios::CDate date = xios::CDate(getCalendar("void cxios_date_convert_to_string(cxios_date date_c, char* str, int str_size)"), 
    … …  
    5154      ERROR("void cxios_date_convert_to_string(cxios_date date_c, char* str, int str_size)", << "Input string is too short"); 
    5255  } 
     56  CATCH_DUMP_STACK 
    5357 
    5458  cxios_date cxios_date_convert_from_string(const char* str, int str_size) 
     59  TRY 
    5560  { 
    5661    std::string date_str; 
    … …  
    6368    return { date.getYear(), date.getMonth(), date.getDay(), date.getHour(), date.getMinute(), date.getSecond() }; 
    6469  } 
     70  CATCH_DUMP_STACK 
    6571 
    6672  cxios_date cxios_date_add_duration(cxios_date date_c, cxios_duration dur_c) 
     73  TRY 
    6774  { 
    6875    xios::CDate date = xios::CDate(getCalendar("cxios_date cxios_date_add_duration(cxios_date date_c, cxios_duration dur_c)"), 
    6976                                   date_c.year, date_c.month, date_c.day, 
    7077                                   date_c.hour, date_c.minute, date_c.second); 
    71  
    7278    xios::CDuration dur( dur_c.year, dur_c.month, dur_c.day, dur_c.hour, dur_c.minute, dur_c.second, dur_c.timestep ); 
    7379    xios::CDate res = date + dur; 
    7480    return { res.getYear(), res.getMonth(), res.getDay(), res.getHour(), res.getMinute(), res.getSecond() }; 
    7581  } 
     82  CATCH_DUMP_STACK 
    7683 
    7784  cxios_date cxios_date_sub_duration(cxios_date date_c, cxios_duration dur_c) 
     85  TRY 
    7886  { 
    7987    xios::CDate date = xios::CDate(getCalendar("cxios_date cxios_date_sub_duration(cxios_date date_c, cxios_duration dur_c)"), 
    … …  
    8593    return { res.getYear(), res.getMonth(), res.getDay(), res.getHour(), res.getMinute(), res.getSecond() }; 
    8694  } 
     95  CATCH_DUMP_STACK 
    8796 
    8897  cxios_duration cxios_date_sub(cxios_date date1_c, cxios_date date2_c) 
     98  TRY 
    8999  { 
    90100    xios::CDate date1 = xios::CDate(getCalendar("cxios_duration cxios_date_sub(cxios_date date1_c, cxios_date date2_c)"), 
    … …  
    97107    return { res.year, res.month, res.day, res.hour, res.minute, res.second, res.timestep }; 
    98108  } 
     109  CATCH_DUMP_STACK 
    99110 
    100111  bool cxios_date_eq(cxios_date date1_c, cxios_date date2_c) 
     112  TRY 
    101113  { 
    102114    xios::CDate date1 = xios::CDate(getCalendar("bool cxios_date_eq(cxios_date date1_c, cxios_date date2_c)"), 
    … …  
    108120    return (date1 == date2); 
    109121  } 
     122  CATCH_DUMP_STACK 
    110123 
    111124  bool cxios_date_neq(cxios_date date1_c, cxios_date date2_c) 
     125  TRY 
    112126  { 
    113127    xios::CDate date1 = xios::CDate(getCalendar("bool cxios_date_eq(cxios_date date1_c, cxios_date date2_c)"), 
    … …  
    119133    return (date1 != date2); 
    120134  } 
     135  CATCH_DUMP_STACK 
    121136 
    122137  bool cxios_date_lt(cxios_date date1_c, cxios_date date2_c) 
     138  TRY 
    123139  { 
    124140    xios::CDate date1 = xios::CDate(getCalendar("bool cxios_date_eq(cxios_date date1_c, cxios_date date2_c)"), 
    … …  
    130146    return (date1 < date2); 
    131147  } 
     148  CATCH_DUMP_STACK 
    132149 
    133150  bool cxios_date_le(cxios_date date1_c, cxios_date date2_c) 
     151  TRY 
    134152  { 
    135153    xios::CDate date1 = xios::CDate(getCalendar("bool cxios_date_eq(cxios_date date1_c, cxios_date date2_c)"), 
    … …  
    141159    return (date1 <= date2); 
    142160  } 
     161  CATCH_DUMP_STACK 
    143162 
    144163  bool cxios_date_gt(cxios_date date1_c, cxios_date date2_c) 
     164  TRY 
    145165  { 
    146166    xios::CDate date1 = xios::CDate(getCalendar("bool cxios_date_eq(cxios_date date1_c, cxios_date date2_c)"), 
    … …  
    152172    return (date1 > date2); 
    153173  } 
     174  CATCH_DUMP_STACK 
    154175 
    155176  bool cxios_date_ge(cxios_date date1_c, cxios_date date2_c) 
     177  TRY 
    156178  { 
    157179    xios::CDate date1 = xios::CDate(getCalendar("bool cxios_date_eq(cxios_date date1_c, cxios_date date2_c)"), 
    … …  
    163185    return (date1 >= date2); 
    164186  } 
     187  CATCH_DUMP_STACK 
    165188 
    166189  int cxios_date_get_second_of_year(cxios_date date_c) 
     190  TRY 
    167191  { 
    168192    xios::CDate date = xios::CDate(getCalendar("int cxios_date_get_second_of_year(cxios_date date_c)"), 
    … …  
    171195    return date.getSecondOfYear(); 
    172196  } 
     197  CATCH_DUMP_STACK 
    173198 
    174199  double cxios_date_get_day_of_year(cxios_date date_c) 
     200  TRY 
    175201  { 
    176202    xios::CDate date = xios::CDate(getCalendar("int cxios_date_get_day_of_year(cxios_date date_c)"), 
    … …  
    179205    return date.getDayOfYear(); 
    180206  } 
     207  CATCH_DUMP_STACK 
    181208 
    182209  double cxios_date_get_fraction_of_year(cxios_date date_c) 
     210  TRY 
    183211  { 
    184212    xios::CDate date = xios::CDate(getCalendar("int cxios_date_get_fraction_of_year(cxios_date date_c)"), 
    … …  
    187215    return date.getFractionOfYear(); 
    188216  } 
     217  CATCH_DUMP_STACK 
    189218 
    190219  int cxios_date_get_second_of_day(cxios_date date_c) 
     220  TRY 
    191221  { 
    192222    xios::CDate date = xios::CDate(getCalendar("int cxios_date_get_second_of_day(cxios_date date_c)"), 
    … …  
    195225    return date.getSecondOfDay(); 
    196226  } 
     227  CATCH_DUMP_STACK 
    197228 
    198229  double cxios_date_get_fraction_of_day(cxios_date date_c) 
     230  TRY 
    199231  { 
    200232    xios::CDate date = xios::CDate(getCalendar("int cxios_date_get_fraction_of_day(cxios_date date_c)"), 
    … …  
    203235    return date.getFractionOfDay(); 
    204236  } 
     237  CATCH_DUMP_STACK 
    205238} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icdomain.cpp

    r1545 r1642  
    2929    
    3030   void cxios_domain_handle_create (XDomainPtr * _ret, const char * _id, int _id_len) 
     31   TRY 
    3132   { 
    3233      std::string id;  
    … …  
    3637      CTimer::get("XIOS").suspend() ; 
    3738   } 
     39   CATCH_DUMP_STACK 
    3840    
    3941   void cxios_domaingroup_handle_create (XDomainGroupPtr * _ret, const char * _id, int _id_len) 
     42   TRY 
    4043   { 
    4144      std::string id;  
    … …  
    4649      CTimer::get("XIOS").suspend() ; 
    4750   } 
     51   CATCH_DUMP_STACK 
    4852 
    4953   // -------------------- Vérification des identifiants ----------------------- 
    5054 
    5155   void cxios_domain_valid_id (bool * _ret, const char * _id, int _id_len) 
     56   TRY 
    5257   { 
    5358      std::string id; 
    … …  
    5863      CTimer::get("XIOS").suspend() ; 
    5964   } 
     65   CATCH_DUMP_STACK 
    6066 
    6167   void cxios_domaingroup_valid_id (bool * _ret, const char * _id, int _id_len) 
     68   TRY 
    6269   { 
    6370      std::string id; 
    … …  
    6774      CTimer::get("XIOS").suspend() ; 
    6875   } 
     76   CATCH_DUMP_STACK 
    6977} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icduplicate_scalar_to_axis.cpp

    r1545 r1642  
    2626   // ------------------------ Création des handle ----------------------------- 
    2727   void cxios_duplicate_scalar_to_axis_handle_create(XDuplicateScalarToAxisPtr * _ret, const char * _id, int _id_len) 
     28   TRY 
    2829   { 
    2930      std::string id; 
    … …  
    3334      CTimer::get("XIOS").suspend() ; 
    3435   } 
     36   CATCH_DUMP_STACK 
    3537 
    3638   // -------------------- Vérification des identifiants ----------------------- 
    3739   void cxios_duplicate_scalar_to_axis_valid_id(bool * _ret, const char * _id, int _id_len) 
     40   TRY 
    3841   { 
    3942      std::string id; 
    … …  
    4447      CTimer::get("XIOS").suspend() ; 
    4548   } 
     49   CATCH_DUMP_STACK 
    4650 
    4751} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icduration.cpp

    r1545 r1642  
     1#include "xios.hpp" 
     2 
    13#include "icutil.hpp" 
    24#include "icdate.hpp" 
    … …  
    68{ 
    79  void cxios_duration_convert_to_string(cxios_duration dur_c, char* str, int str_size) 
     10  TRY 
    811  { 
    912    xios::CDuration dur( dur_c.year, dur_c.month, dur_c.day, dur_c.hour, dur_c.minute, dur_c.second, dur_c.timestep ); 
    … …  
    1215      ERROR("void cxios_duration_convert_to_string(cxios_duration dur_c, char* str, int str_size)", << "Input string is too short"); 
    1316  } 
     17  CATCH_DUMP_STACK 
    1418 
    1519  cxios_duration cxios_duration_convert_from_string(const char* str, int str_size) 
     20  TRY 
    1621  { 
    1722    std::string dur_str; 
    … …  
    2328    return { dur.year, dur.month, dur.day, dur.hour, dur.minute, dur.second, dur.timestep }; 
    2429  } 
     30  CATCH_DUMP_STACK 
    2531 
    2632  cxios_duration cxios_duration_add(cxios_duration dur1_c, cxios_duration dur2_c) 
     33  TRY 
    2734  { 
    2835    xios::CDuration dur1( dur1_c.year, dur1_c.month, dur1_c.day, dur1_c.hour, dur1_c.minute, dur1_c.second, dur1_c.timestep ); 
    … …  
    3239    return { res.year, res.month, res.day, res.hour, res.minute, res.second, res.timestep }; 
    3340  } 
     41  CATCH_DUMP_STACK 
    3442 
    3543  cxios_duration cxios_duration_sub(cxios_duration dur1_c, cxios_duration dur2_c) 
     44  TRY 
    3645  { 
    3746    xios::CDuration dur1( dur1_c.year, dur1_c.month, dur1_c.day, dur1_c.hour, dur1_c.minute, dur1_c.second, dur1_c.timestep ); 
    … …  
    4150    return { res.year, res.month, res.day, res.hour, res.minute, res.second, res.timestep }; 
    4251  } 
     52  CATCH_DUMP_STACK 
    4353 
    4454  cxios_duration cxios_duration_mult(double val, cxios_duration dur_c) 
     55  TRY 
    4556  { 
    4657    xios::CDuration dur( dur_c.year, dur_c.month, dur_c.day, dur_c.hour, dur_c.minute, dur_c.second, dur_c.timestep ); 
    … …  
    4859    return { res.year, res.month, res.day, res.hour, res.minute, res.second, res.timestep }; 
    4960  } 
     61  CATCH_DUMP_STACK 
    5062 
    5163  cxios_duration cxios_duration_neg(cxios_duration dur_c) 
     64  TRY 
    5265  { 
    5366    xios::CDuration dur( dur_c.year, dur_c.month, dur_c.day, dur_c.hour, dur_c.minute, dur_c.second, dur_c.timestep ); 
    … …  
    5568    return { res.year, res.month, res.day, res.hour, res.minute, res.second, res.timestep }; 
    5669  } 
     70  CATCH_DUMP_STACK 
    5771 
    5872  bool cxios_duration_eq(cxios_duration dur1_c, cxios_duration dur2_c) 
     73  TRY 
    5974  { 
    6075    xios::CDuration dur1( dur1_c.year, dur1_c.month, dur1_c.day, dur1_c.hour, dur1_c.minute, dur1_c.second, dur1_c.timestep ); 
    … …  
    6277    return (dur1 == dur2); 
    6378  } 
     79  CATCH_DUMP_STACK 
    6480 
    6581  bool cxios_duration_neq(cxios_duration dur1_c, cxios_duration dur2_c) 
     82  TRY 
    6683  { 
    6784    xios::CDuration dur1( dur1_c.year, dur1_c.month, dur1_c.day, dur1_c.hour, dur1_c.minute, dur1_c.second, dur1_c.timestep ); 
    … …  
    6986    return (dur1 != dur2); 
    7087  } 
     88  CATCH_DUMP_STACK 
    7189} 

  • XIOS/dev/branch_openmp/src/interface/c/icexpand_domain.cpp

    r1545 r1642  
    2727   // ------------------------ Création des handle ----------------------------- 
    2828   void cxios_expand_domain_handle_create(XExpandDomainPtr * _ret, const char * _id, int _id_len) 
     29   TRY 
    2930   { 
    3031      std::string id; 
    … …  
    3435      CTimer::get("XIOS").suspend() ; 
    3536   } 
     37   CATCH_DUMP_STACK 
    3638 
    3739   // -------------------- Vérification des identifiants ----------------------- 
    3840   void cxios_expand_domain_valid_id(bool * _ret, const char * _id, int _id_len) 
     41   TRY 
    3942   { 
    4043      std::string id; 
    … …  
    4548      CTimer::get("XIOS").suspend() ; 
    4649   } 
     50   CATCH_DUMP_STACK 
    4751} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icextract_to_axis.cpp

    r1545 r1642  
    2626   // ------------------------ Création des handle ----------------------------- 
    2727   void cxios_extract_domain_to_axis_handle_create(XExtractDomainToAxisPtr * _ret, const char * _id, int _id_len) 
     28   TRY 
    2829   { 
    2930      std::string id; 
    … …  
    3334      CTimer::get("XIOS").suspend() ; 
    3435   } 
     36   CATCH_DUMP_STACK 
    3537 
    3638   // -------------------- Vérification des identifiants ----------------------- 
    3739   void cxios_extract_domain_to_axis_valid_id(bool * _ret, const char * _id, int _id_len) 
     40   TRY 
    3841   { 
    3942      std::string id; 
    … …  
    4447      CTimer::get("XIOS").suspend() ; 
    4548   } 
     49   CATCH_DUMP_STACK 
    4650 
    4751} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icextract_to_scalar.cpp

    r1545 r1642  
    2626   // ------------------------ Création des handle ----------------------------- 
    2727   void cxios_extract_axis_to_scalar_handle_create(XExtractAxisToScalarPtr * _ret, const char * _id, int _id_len) 
     28   TRY 
    2829   { 
    2930      std::string id; 
    … …  
    3334      CTimer::get("XIOS").suspend() ; 
    3435   } 
     36   CATCH_DUMP_STACK 
    3537 
    3638   // -------------------- Vérification des identifiants ----------------------- 
    3739   void cxios_extract_axis_to_scalar_valid_id(bool * _ret, const char * _id, int _id_len) 
     40   TRY 
    3841   { 
    3942      std::string id; 
    … …  
    4447      CTimer::get("XIOS").suspend() ; 
    4548   } 
     49   CATCH_DUMP_STACK 
    4650 
    4751} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icfield.cpp

    r1545 r1642  
    3535    
    3636   void cxios_field_handle_create (XFieldPtr * _ret, const char * _id, int _id_len) 
     37   TRY 
    3738   { 
    3839      std::string id;  
    … …  
    4243      CTimer::get("XIOS").suspend() ; 
    4344   } 
     45   CATCH_DUMP_STACK 
    4446    
    4547   void cxios_fieldgroup_handle_create (XFieldGroupPtr * _ret, const char * _id, int _id_len) 
     48   TRY 
    4649   { 
    4750      std::string id;  
    … …  
    5154      CTimer::get("XIOS").suspend() ; 
    5255   } 
    53  
     56   CATCH_DUMP_STACK 
    5457 
    5558   // -------------------- Vérification des identifiants ----------------------- 
    5659 
    5760   void cxios_field_valid_id (bool * _ret, const char * _id, int _id_len) 
     61   TRY 
    5862   { 
    5963      std::string id; 
    … …  
    6367      CTimer::get("XIOS").suspend() ; 
    6468   } 
     69   CATCH_DUMP_STACK 
    6570 
    6671   void cxios_fieldgroup_valid_id (bool * _ret, const char * _id, int _id_len) 
     72   TRY 
    6773   { 
    6874      std::string id; 
    … …  
    7278      CTimer::get("XIOS").suspend() ; 
    7379   } 
     80   CATCH_DUMP_STACK 
    7481 
    7582// -----------------------------------------------------------------------------------------------------    
    … …  
    7885 
    7986  void cxios_field_is_active (XFieldPtr field_hdl, bool at_current_timestep, bool* ret) 
     87  TRY 
    8088  { 
    8189    CTimer::get("XIOS").resume() ; 
    … …  
    8391    CTimer::get("XIOS").suspend() ; 
    8492  } 
     93  CATCH_DUMP_STACK 
    8594 
    8695// ----------------------------------------------------------------------------------------------------- 
    … …  
    8897// ----------------------------------------------------------------------------------------------------- 
    8998  void cxios_field_get_domain_handle(XDomainPtr * domain_hdl_ret, XFieldPtr field_hdl, int domainIndex) 
     99  TRY 
    90100  { 
    91101     CTimer::get("XIOS").resume() ; 
    … …  
    93103     CTimer::get("XIOS").suspend(); 
    94104  } 
     105  CATCH_DUMP_STACK 
    95106 
    96107  void cxios_field_get_axis_handle(XAxisPtr * axis_hdl_ret, XFieldPtr field_hdl, int axisIndex) 
     108  TRY 
    97109  { 
    98110     CTimer::get("XIOS").resume() ; 
    … …  
    100112     CTimer::get("XIOS").suspend(); 
    101113  } 
     114  CATCH_DUMP_STACK 
    102115 
    103116  void cxios_field_get_scalar_handle(XScalarPtr * scalar_hdl_ret, XFieldPtr field_hdl, int scalarIndex) 
     117  TRY 
    104118  { 
    105119     CTimer::get("XIOS").resume() ; 
    … …  
    107121     CTimer::get("XIOS").suspend(); 
    108122  } 
     123  CATCH_DUMP_STACK 
    109124} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icfile.cpp

    r1545 r1642  
    2828    
    2929   void cxios_file_handle_create (XFilePtr * _ret, const char * _id, int _id_len) 
     30   TRY 
    3031   { 
    3132      std::string id;  
    … …  
    3536      CTimer::get("XIOS").suspend() ; 
    3637   } 
     38   CATCH_DUMP_STACK 
    3739    
    3840   void cxios_filegroup_handle_create (XFileGroupPtr * _ret, const char * _id, int _id_len) 
     41   TRY 
    3942   { 
    4043      std::string id;  
    … …  
    4447      CTimer::get("XIOS").suspend() ; 
    4548   } 
     49   CATCH_DUMP_STACK 
    4650 
    4751   // -------------------- Vérification des identifiants ----------------------- 
    4852 
    4953   void cxios_file_valid_id (bool * _ret, const char * _id, int _id_len) 
     54   TRY 
    5055   { 
    5156      std::string id; 
    … …  
    5560      CTimer::get("XIOS").suspend() ; 
    5661   } 
     62   CATCH_DUMP_STACK 
    5763 
    5864   void cxios_filegroup_valid_id (bool * _ret, const char * _id, int _id_len) 
     65   TRY 
    5966   { 
    6067      std::string id; 
    … …  
    6471      CTimer::get("XIOS").suspend() ; 
    6572   } 
     73   CATCH_DUMP_STACK 
    6674} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icgenerate_rectilinear_domain.cpp

    r1545 r1642  
    2727   // ------------------------ Création des handle ----------------------------- 
    2828   void cxios_generate_rectilinear_domain_handle_create(XGenDomainPtr * _ret, const char * _id, int _id_len) 
     29   TRY 
    2930   { 
    3031      std::string id; 
    … …  
    3435      CTimer::get("XIOS").suspend() ; 
    3536   } 
     37   CATCH_DUMP_STACK 
    3638 
    3739   // -------------------- Vérification des identifiants ----------------------- 
    3840   void cxios_generate_rectilinear_domain_valid_id(bool * _ret, const char * _id, int _id_len) 
     41   TRY 
    3942   { 
    4043      std::string id; 
    … …  
    4548      CTimer::get("XIOS").suspend() ; 
    4649   } 
     50   CATCH_DUMP_STACK 
    4751} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icgrid.cpp

    r1545 r1642  
    2727   
    2828   void cxios_grid_handle_create (XGridPtr * _ret, const char * _id, int _id_len) 
     29   TRY 
    2930   { 
    3031      std::string id;  
    … …  
    3435      CTimer::get("XIOS").suspend() ; 
    3536   } 
     37   CATCH_DUMP_STACK 
    3638    
    3739   void cxios_gridgroup_handle_create (XGridGroupPtr * _ret, const char * _id, int _id_len) 
     40   TRY 
    3841   { 
    3942      std::string id;  
    … …  
    4346      CTimer::get("XIOS").suspend() ; 
    4447   } 
     48   CATCH_DUMP_STACK 
    4549 
    4650   // -------------------- Vérification des identifiants ----------------------- 
    4751 
    4852   void cxios_grid_valid_id (bool * _ret, const char * _id, int _id_len) 
     53   TRY 
    4954   { 
    5055      std::string id; 
    … …  
    5459      CTimer::get("XIOS").suspend() ; 
    5560   } 
     61   CATCH_DUMP_STACK 
    5662 
    5763   void cxios_gridgroup_valid_id (bool * _ret, const char * _id, int _id_len) 
     64   TRY 
    5865   { 
    5966      std::string id; 
    … …  
    6370      CTimer::get("XIOS").suspend() ; 
    6471   } 
     72   CATCH_DUMP_STACK 
    6573} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icinterpolate.cpp

    r1545 r1642  
    2727   // ------------------------ Création des handle ----------------------------- 
    2828   void cxios_interpolate_domain_handle_create(XInterpolateDomainPtr * _ret, const char * _id, int _id_len) 
     29   TRY 
    2930   { 
    3031      std::string id; 
    … …  
    3435      CTimer::get("XIOS").suspend() ; 
    3536   } 
     37   CATCH_DUMP_STACK 
    3638 
    3739   // -------------------- Vérification des identifiants ----------------------- 
    3840   void cxios_interpolate_domain_valid_id(bool * _ret, const char * _id, int _id_len) 
     41   TRY 
    3942   { 
    4043      std::string id; 
    … …  
    4548      CTimer::get("XIOS").suspend() ; 
    4649   } 
     50   CATCH_DUMP_STACK 
    4751 
    4852    // ------------------------ Création des handle ----------------------------- 
    4953   void cxios_interpolate_axis_handle_create(XInterpolateAxisPtr * _ret, const char * _id, int _id_len) 
     54   TRY 
    5055   { 
    5156      std::string id; 
    … …  
    5560      CTimer::get("XIOS").suspend() ; 
    5661   } 
     62   CATCH_DUMP_STACK 
    5763 
    5864   // -------------------- Vérification des identifiants ----------------------- 
    5965   void cxios_interpolate_axis_valid_id(bool * _ret, const char * _id, int _id_len) 
     66   TRY 
    6067   { 
    6168      std::string id; 
    … …  
    6673      CTimer::get("XIOS").suspend() ; 
    6774   } 
     75   CATCH_DUMP_STACK 
    6876} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icinverse_axis.cpp

    r1545 r1642  
    2727   // ------------------------ Création des handle ----------------------------- 
    2828   void cxios_inverse_axis_handle_create(XInverseAxisPtr * _ret, const char * _id, int _id_len) 
     29   TRY 
    2930   { 
    3031      std::string id; 
    … …  
    3435      CTimer::get("XIOS").suspend() ; 
    3536   } 
     37   CATCH_DUMP_STACK 
    3638 
    3739   // -------------------- Vérification des identifiants ----------------------- 
    3840   void cxios_inverse_axis_valid_id(bool * _ret, const char * _id, int _id_len) 
     41   TRY 
    3942   { 
    4043      std::string id; 
    … …  
    4548      CTimer::get("XIOS").suspend() ; 
    4649   } 
     50   CATCH_DUMP_STACK 
    4751} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icreduce_axis_to_axis.cpp

    r1545 r1642  
    2727   // ------------------------ Création des handle ----------------------------- 
    2828   void cxios_reduce_axis_to_axis_handle_create(XReduceAxisToAxisPtr * _ret, const char * _id, int _id_len) 
     29   TRY 
    2930   { 
    3031      std::string id; 
    … …  
    3435      CTimer::get("XIOS").suspend() ; 
    3536   } 
     37   CATCH_DUMP_STACK 
    3638 
    3739   // -------------------- Vérification des identifiants ----------------------- 
    3840   void cxios_reduce_axis_to_axis_valid_id(bool * _ret, const char * _id, int _id_len) 
     41   TRY 
    3942   { 
    4043      std::string id; 
    … …  
    4548      CTimer::get("XIOS").suspend() ; 
    4649   } 
     50   CATCH_DUMP_STACK 
    4751 
    4852} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icreduce_scalar_to_scalar.cpp

    r1545 r1642  
    2727   // ------------------------ Création des handle ----------------------------- 
    2828   void cxios_reduce_scalar_to_scalar_handle_create(XReduceScalarToScalarPtr * _ret, const char * _id, int _id_len) 
     29   TRY 
    2930   { 
    3031      std::string id; 
    … …  
    3435      CTimer::get("XIOS").suspend() ; 
    3536   } 
     37   CATCH_DUMP_STACK 
    3638 
    3739   // -------------------- Vérification des identifiants ----------------------- 
    3840   void cxios_reduce_scalar_to_scalar_valid_id(bool * _ret, const char * _id, int _id_len) 
     41   TRY 
    3942   { 
    4043      std::string id; 
    … …  
    4548      CTimer::get("XIOS").suspend() ; 
    4649   } 
     50   CATCH_DUMP_STACK 
    4751 
    4852} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icreduce_to_axis.cpp

    r1545 r1642  
    2727   // ------------------------ Création des handle ----------------------------- 
    2828   void cxios_reduce_domain_to_axis_handle_create(XReduceDomainToAxisPtr * _ret, const char * _id, int _id_len) 
     29   TRY 
    2930   { 
    3031      std::string id; 
    … …  
    3435      CTimer::get("XIOS").suspend() ; 
    3536   } 
     37   CATCH_DUMP_STACK 
    3638 
    3739   // -------------------- Vérification des identifiants ----------------------- 
    3840   void cxios_reduce_domain_to_axis_valid_id(bool * _ret, const char * _id, int _id_len) 
     41   TRY 
    3942   { 
    4043      std::string id; 
    … …  
    4548      CTimer::get("XIOS").suspend() ; 
    4649   } 
     50   CATCH_DUMP_STACK 
    4751 
    4852} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icreduce_to_scalar.cpp

    r1545 r1642  
    2727   // ------------------------ Création des handle ----------------------------- 
    2828   void cxios_reduce_axis_to_scalar_handle_create(XReduceAxisToScalarPtr * _ret, const char * _id, int _id_len) 
     29   TRY 
    2930   { 
    3031      std::string id; 
    … …  
    3435      CTimer::get("XIOS").suspend() ; 
    3536   } 
     37   CATCH_DUMP_STACK 
    3638 
    3739   // -------------------- Vérification des identifiants ----------------------- 
    3840   void cxios_reduce_axis_to_scalar_valid_id(bool * _ret, const char * _id, int _id_len) 
     41   TRY 
    3942   { 
    4043      std::string id; 
    … …  
    4548      CTimer::get("XIOS").suspend() ; 
    4649   } 
     50   CATCH_DUMP_STACK 
    4751 
    4852   void cxios_reduce_domain_to_scalar_handle_create(XReduceDomainToScalarPtr * _ret, const char * _id, int _id_len) 
     53   TRY 
    4954   { 
    5055      std::string id; 
    … …  
    5459      CTimer::get("XIOS").suspend() ; 
    5560   } 
     61   CATCH_DUMP_STACK 
    5662 
    5763   // -------------------- Vérification des identifiants ----------------------- 
    5864   void cxios_reduce_domain_to_scalar_valid_id(bool * _ret, const char * _id, int _id_len) 
     65   TRY 
    5966   { 
    6067      std::string id; 
    … …  
    6572      CTimer::get("XIOS").suspend() ; 
    6673   } 
     74   CATCH_DUMP_STACK 
    6775 
    6876} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icreorder_domain.cpp

    r1545 r1642  
    2727   // ------------------------ Création des handle ----------------------------- 
    2828   void cxios_reorder_domain_handle_create(XReorderDomainPtr * _ret, const char * _id, int _id_len) 
     29   TRY 
    2930   { 
    3031      std::string id; 
    … …  
    3435      CTimer::get("XIOS").suspend() ; 
    3536   } 
     37   CATCH_DUMP_STACK 
    3638 
    3739   // -------------------- Vérification des identifiants ----------------------- 
    3840   void cxios_reorder_domain_valid_id(bool * _ret, const char * _id, int _id_len) 
     41   TRY 
    3942   { 
    4043      std::string id; 
    … …  
    4548      CTimer::get("XIOS").suspend() ; 
    4649   } 
     50   CATCH_DUMP_STACK 
    4751} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icscalar.cpp

    r1545 r1642  
    2828 
    2929   void cxios_scalar_handle_create (XScalarPtr * _ret, const char * _id, int _id_len) 
     30   TRY 
    3031   { 
    3132      std::string id; 
    … …  
    3536      CTimer::get("XIOS").suspend() ; 
    3637   } 
     38   CATCH_DUMP_STACK 
    3739 
    3840   void cxios_scalargroup_handle_create (XScalarGroupPtr * _ret, const char * _id, int _id_len) 
     41   TRY 
    3942   { 
    4043      std::string id; 
    … …  
    4447      CTimer::get("XIOS").suspend() ; 
    4548    } 
     49   CATCH_DUMP_STACK 
    4650 
    4751   // -------------------- Vérification des identifiants ----------------------- 
    4852 
    4953   void cxios_scalar_valid_id (bool * _ret, const char * _id, int _id_len) 
     54   TRY 
    5055   { 
    5156      std::string id; 
    … …  
    5661      CTimer::get("XIOS").suspend() ; 
    5762   } 
     63   CATCH_DUMP_STACK 
    5864 
    5965   void cxios_scalargroup_valid_id (bool * _ret, const char * _id, int _id_len) 
     66   TRY 
    6067   { 
    6168      std::string id; 
    … …  
    6774 
    6875   } 
     76   CATCH_DUMP_STACK 
    6977 
    7078} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/ictemporal_splitting.cpp

    r1545 r1642  
    2727   // ------------------------ Création des handle ----------------------------- 
    2828   void cxios_temporal_splitting_handle_create(XTemporalSplittingPtr * _ret, const char * _id, int _id_len) 
     29   TRY 
    2930   { 
    3031      std::string id; 
    … …  
    3435      CTimer::get("XIOS").suspend() ; 
    3536   } 
     37   CATCH_DUMP_STACK 
    3638 
    3739   // -------------------- Vérification des identifiants ----------------------- 
    3840   void cxios_temporal_splitting_valid_id(bool * _ret, const char * _id, int _id_len) 
     41   TRY 
    3942   { 
    4043      std::string id; 
    … …  
    4548      CTimer::get("XIOS").suspend() ; 
    4649   } 
     50   CATCH_DUMP_STACK 
    4751 
    4852} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/icvariable.cpp

    r1545 r1642  
    2929    
    3030   void cxios_variable_handle_create (XVariablePtr * _ret, const char * _id, int _id_len) 
     31   TRY 
    3132   { 
    3233      std::string id;  
    … …  
    3637      CTimer::get("XIOS").suspend() ; 
    3738   } 
     39   CATCH_DUMP_STACK 
    3840    
    3941   void cxios_variablegroup_handle_create (XVariableGroupPtr * _ret, const char * _id, int _id_len) 
     42   TRY 
    4043   { 
    4144      std::string id;  
    … …  
    4548      CTimer::get("XIOS").suspend() ; 
    4649    } 
     50   CATCH_DUMP_STACK 
    4751 
    4852   // -------------------- Vérification des identifiants ----------------------- 
    4953 
    5054   void cxios_variable_valid_id (bool * _ret, const char * _id, int _id_len) 
     55   TRY 
    5156   { 
    5257      std::string id; 
    … …  
    5762      CTimer::get("XIOS").suspend() ; 
    5863   } 
     64   CATCH_DUMP_STACK 
    5965 
    6066   void cxios_variablegroup_valid_id (bool * _ret, const char * _id, int _id_len) 
     67   TRY 
    6168   { 
    6269      std::string id; 
    … …  
    6875 
    6976   } 
     77   CATCH_DUMP_STACK 
    7078    
    7179} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/iczoom.cpp

    r1545 r1642  
    2828   // ------------------------ Création des handle ----------------------------- 
    2929   void cxios_zoom_axis_handle_create (XZoomAxisPtr * _ret, const char * _id, int _id_len) 
     30   TRY 
    3031   { 
    3132      std::string id; 
    … …  
    3536      CTimer::get("XIOS").suspend() ; 
    3637   } 
     38   CATCH_DUMP_STACK 
    3739 
    3840   // -------------------- Vérification des identifiants ----------------------- 
    3941   void cxios_zoom_axis_valid_id (bool * _ret, const char * _id, int _id_len) 
     42   TRY 
    4043   { 
    4144      std::string id; 
    … …  
    4649      CTimer::get("XIOS").suspend() ; 
    4750   } 
     51   CATCH_DUMP_STACK 
    4852 
    4953   // ------------------------ Création des handle ----------------------------- 
    5054   void cxios_zoom_domain_handle_create(XZoomDomainPtr * _ret, const char * _id, int _id_len) 
     55   TRY 
    5156   { 
    5257      std::string id; 
    … …  
    5661      CTimer::get("XIOS").suspend() ; 
    5762   } 
     63   CATCH_DUMP_STACK 
    5864 
    5965   // -------------------- Vérification des identifiants ----------------------- 
    6066   void cxios_zoom_domain_valid_id(bool * _ret, const char * _id, int _id_len) 
     67   TRY 
    6168   { 
    6269      std::string id; 
    … …  
    6774      CTimer::get("XIOS").suspend() ; 
    6875   } 
     76   CATCH_DUMP_STACK 
    6977} // extern "C" 

  • XIOS/dev/branch_openmp/src/interface/c/oasis_cinterface.cpp

    r1365 r1642  
    11#include "oasis_cinterface.hpp" 
    22#include <string> 
    3 using namespace ep_lib; 
     3#include "mpi.hpp" 
    44 
    55namespace xios 
    … …  
    2121  } 
    2222 
    23   void oasis_get_localcomm(MPI_Comm& comm) 
     23  void oasis_get_localcomm(ep_lib::MPI_Comm& comm) 
    2424  { 
    25     MPI_Fint f_comm ; 
     25    ep_lib::MPI_Fint f_comm ; 
    2626     
    2727    fxios_oasis_get_localcomm(&f_comm) ; 
    28     //comm=EP_Comm_f2c(f_comm.mpi_fint) ; 
     28    //comm=MPI_Comm_f2c(f_comm) ; 
    2929  } 
    3030  
    31   void oasis_get_intracomm(MPI_Comm& comm_client_server,const std::string& server_id) 
     31  void oasis_get_intracomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) 
    3232  { 
    33     MPI_Fint f_comm ; 
     33    ep_lib::MPI_Fint f_comm ; 
    3434     
    3535    fxios_oasis_get_intracomm(&f_comm,server_id.data(),server_id.size()) ; 
    36     //comm_client_server=EP_Comm_f2c(f_comm.mpi_fint) ; 
     36    //comm_client_server=MPI_Comm_f2c(f_comm) ; 
    3737  } 
    3838  
    39   void oasis_get_intercomm(MPI_Comm& comm_client_server,const std::string& server_id) 
     39  void oasis_get_intercomm(ep_lib::MPI_Comm& comm_client_server,const std::string& server_id) 
    4040  { 
    41     MPI_Fint f_comm ; 
     41    ep_lib::MPI_Fint f_comm ; 
    4242     
    4343    fxios_oasis_get_intercomm(&f_comm,server_id.data(),server_id.size()) ; 
    44     //comm_client_server=EP_Comm_f2c(f_comm.mpi_fint) ; 
     44    //comm_client_server=MPI_Comm_f2c(f_comm) ; 
    4545  } 
    4646} 
Note: See TracChangeset for help on using the changeset viewer.