Changeset 1612


Ignore:
Timestamp:
11/23/18 14:48:14 (21 months ago)
Author:
oabramkina
Message:

Dev: adding exception handling.

To activate it, compilation flag -DXIOS_EXCEPTION should be added.

Location:
XIOS/dev/dev_olga
Files:
89 edited

Legend:

Unmodified
Added
Removed
  • XIOS/dev/dev_olga/arch/arch-X64_IRENE.fcm

    r1542 r1612  
    1111#%DEV_CFLAGS     -g -traceback 
    1212%DEV_CFLAGS     -g  
    13 %DEBUG_CFLAGS   -DBZ_DEBUG -g -traceback -fno-inline 
     13%DEBUG_CFLAGS   -DBZ_DEBUG -g -traceback -fno-inline -D__XIOS_EXCEPTION 
    1414 
    1515%BASE_FFLAGS    -D__NONE__  
  • XIOS/dev/dev_olga/src/array_new.hpp

    r1290 r1612  
    532532      virtual void fromString(const string& str) { istringstream iss(str); iss >> *this; initialized = true; } 
    533533      virtual string toString(void) const { ostringstream oss; oss << *this; return oss.str(); } 
     534 
     535      virtual string dump(void) const 
     536      { 
     537        ostringstream oss; 
     538        oss << this->shape()<<" "; 
     539        if (this->shape().numElements() == 1 && this->shape().dataFirst()[0] == 1) 
     540          oss << this->dataFirst()[0]; 
     541        else 
     542          oss << this->dataFirst()[0] <<" ... "<< this->dataFirst()[this->numElements()-1]; 
     543        return oss.str(); 
     544      } 
     545 
    534546      virtual void reset(void) { this->free(); initialized = false; } 
    535547      virtual bool isEmpty(void) const { return !initialized; } 
  • XIOS/dev/dev_olga/src/attribute.hpp

    r1158 r1612  
    4141            virtual StdString toString(void) const = 0; 
    4242            virtual void fromString(const StdString & str) = 0; 
     43            virtual StdString dump(void) const = 0; 
    4344            virtual bool isEqual(const CAttribute& ) = 0; 
    4445 
  • XIOS/dev/dev_olga/src/attribute_array.hpp

    r1219 r1612  
    5555            virtual bool toBuffer  (CBufferOut& buffer) const { return _toBuffer(buffer);} 
    5656            virtual bool fromBuffer(CBufferIn& buffer) { return _fromBuffer(buffer); } 
     57            virtual string dump(void) const { return _dump();} 
    5758 
    5859            virtual void generateCInterface(ostream& oss,const string& className) ; 
     
    6970          CArray<T_numtype, N_rank> inheritedValue ; 
    7071          StdString _toString(void) const; 
     72          StdString _dump(void) const; 
    7173          void _fromString(const StdString & str); 
    7274          bool _toBuffer  (CBufferOut& buffer) const; 
  • XIOS/dev/dev_olga/src/attribute_array_impl.hpp

    r1219 r1612  
    129129    } 
    130130 
     131    template <typename T_numtype, int N_rank> 
     132    StdString CAttributeArray<T_numtype,N_rank>::_dump(void) const 
     133    { 
     134      StdOStringStream oss; 
     135      if (! isEmpty() && this->hasId() && (this->numElements()!=0)) 
     136        oss << this->getName() << "=\"" << CArray<T_numtype, N_rank>::dump() << "\""; 
     137      return (oss.str()); 
     138    } 
     139 
     140 
    131141      template <typename T_numtype, int N_rank> 
    132142         void CAttributeArray<T_numtype, N_rank>::_fromString(const StdString & str) 
  • XIOS/dev/dev_olga/src/attribute_enum.hpp

    r1219 r1612  
    1414namespace xios 
    1515{ 
    16       /// ////////////////////// Déclarations ////////////////////// /// 
     16      /// ////////////////////// Declarations ////////////////////// /// 
    1717        /*! 
    1818        \class CAttributeEnum 
     
    6262            virtual StdString toString(void) const { return _toString();} 
    6363            virtual void fromString(const StdString & str) { if (str==resetInheritanceStr) { reset(); _canInherite=false ;}  else _fromString(str);} 
     64            virtual StdString dump(void) const { return _toString();} 
    6465 
    6566            virtual bool toBuffer  (CBufferOut& buffer) const { return _toBuffer(buffer);}  
  • XIOS/dev/dev_olga/src/attribute_map.cpp

    r1158 r1612  
    2828            att.second->reset(); 
    2929         } 
     30      } 
     31 
     32      ///-------------------------------------------------------------- 
     33      /*! 
     34         Dump of all non-empty attributes of an object 
     35      */ 
     36      StdString CAttributeMap::dumpXiosAttributes(void) const 
     37      { 
     38        int maxNbChar = 250; 
     39        StdString str; 
     40        typedef std::pair<StdString, CAttribute*> StdStrAttPair; 
     41        auto it = SuperClassMap::begin(), end = SuperClassMap::end(); 
     42        for (; it != end; it++) 
     43        { 
     44          const StdStrAttPair& att = *it; 
     45          if (!att.second->isEmpty()) 
     46          { 
     47            if (str.length() < maxNbChar) 
     48            { 
     49              str.append(att.second->dump()); 
     50              str.append(" "); 
     51            } 
     52            else if (str.length() == maxNbChar) 
     53            { 
     54              str.append("..."); 
     55            } 
     56          } 
     57        } 
     58        return str; 
    3059      } 
    3160 
  • XIOS/dev/dev_olga/src/attribute_map.hpp

    r1158 r1612  
    3838            void duplicateAttributes(const CAttributeMap* const _parent); 
    3939            void clearAllAttributes(void); 
     40            StdString dumpXiosAttributes(void) const; 
    4041 
    4142            void clearAttribute(const StdString& key); 
  • XIOS/dev/dev_olga/src/attribute_template.hpp

    r1478 r1612  
    7474//            virtual void toBinary  (StdOStream & os) const; 
    7575//            virtual void fromBinary(StdIStream & is); 
     76            virtual StdString dump(void) const { return _dump();} 
    7677 
    7778            virtual bool toBuffer  (CBufferOut& buffer) const { return _toBuffer(buffer);} 
     
    9899          bool isEqual_(const CAttributeTemplate& attr); 
    99100          StdString _toString(void) const; 
     101          StdString _dump(void) const; 
    100102          void _fromString(const StdString & str); 
    101103          bool _toBuffer  (CBufferOut& buffer) const; 
  • XIOS/dev/dev_olga/src/attribute_template_impl.hpp

    r1478 r1612  
    199199        CType<T>::fromString(str) ; 
    200200      } 
     201 
     202      //--------------------------------------------------------------- 
     203 
     204      template <class T> 
     205         StdString CAttributeTemplate<T>::_dump(void) const 
     206      { 
     207         StdOStringStream oss; 
     208         if (!CType<T>::isEmpty() && this->hasId()) 
     209            oss << this->getName() << "=\"" << CType<T>::dump() << "\""; 
     210         return (oss.str()); 
     211      } 
     212 
    201213 
    202214      //--------------------------------------------------------------- 
  • XIOS/dev/dev_olga/src/cxios.cpp

    r1519 r1612  
    2020  string CXios::serverPrmFile="./xios_server1"; 
    2121  string CXios::serverSndFile="./xios_server2"; 
     22 
     23  bool CXios::xiosStack = true; 
     24  bool CXios::systemStack = false; 
    2225 
    2326  bool CXios::isClient ; 
     
    6265    printLogs2Files=getin<bool>("print_file",false); 
    6366 
     67    xiosStack=getin<bool>("xios_stack",true) ; 
     68    systemStack=getin<bool>("system_stack",false) ; 
     69    if (xiosStack && systemStack) 
     70    { 
     71      xiosStack = false; 
     72    } 
     73 
    6474    StdString bufMemory("memory"); 
    6575    StdString bufPerformance("performance"); 
     
    91101  */ 
    92102  void CXios::initClientSide(const string& codeId, MPI_Comm& localComm, MPI_Comm& returnComm) 
     103  TRY 
    93104  { 
    94105    initialize() ; 
     
    114125    } 
    115126  } 
     127  CATCH 
    116128 
    117129  void CXios::clientFinalize(void) 
  • XIOS/dev/dev_olga/src/cxios.hpp

    r1377 r1612  
    3333     static string serverPrmFile;  //!< Filename template for primary server in case of two server levels 
    3434     static string serverSndFile;  //!< Filename template for secondary server in case of two server levels 
     35 
     36     static bool xiosStack;    //!< Exception handling 
     37     static bool systemStack;  //!< Exception handling 
    3538 
    3639     static bool isClient ; //!< Check if xios is client 
  • XIOS/dev/dev_olga/src/data_output.cpp

    r1542 r1612  
    4747 
    4848      void CDataOutput::writeGrid(CDomain* domain, CAxis* axis) 
     49      TRY 
    4950      { 
    5051         this->writeDomain_(domain); 
    5152         this->writeAxis_(axis); 
    5253      } 
     54      CATCH 
    5355 
    5456      void CDataOutput::writeGrid(std::vector<CDomain*> domains, std::vector<CAxis*> axis) 
     57      TRY 
    5558      { 
    5659        int domSize = domains.size(); 
     
    5962        for (int i = 0; i < aSize; ++i) this->writeAxis_(axis[i]); 
    6063      } 
     64      CATCH 
    6165 
    6266      void CDataOutput::writeGrid(std::vector<CDomain*> domains, std::vector<CAxis*> axis, std::vector<CScalar*> scalars) 
     67      TRY 
    6368      { 
    6469        int domSize = domains.size(); 
     
    6974        for (int i = 0; i < sSize; ++i) this->writeScalar_(scalars[i]); 
    7075      } 
     76      CATCH 
    7177 
    7278      //---------------------------------------------------------------- 
    7379 
    7480      void CDataOutput::writeGrid(CDomain* domain) 
     81      TRY 
    7582      { 
    7683         this->writeDomain_(domain); 
    7784      } 
     85      CATCH 
    7886 
    7987      void CDataOutput::writeTimeDimension(void) 
     88      TRY 
    8089      { 
    8190         this->writeTimeDimension_(); 
    8291      } 
     92      CATCH 
    8393 
    8494      //---------------------------------------------------------------- 
    8595 
    8696      void CDataOutput::writeFieldTimeAxis(CField* field) 
     97      TRY 
    8798      { 
    8899         CContext* context = CContext::getCurrent() ; 
     
    91102         this->writeTimeAxis_(field, calendar); 
    92103      } 
    93        
     104      CATCH 
     105 
    94106      void CDataOutput::writeField(CField* field) 
     107      TRY 
    95108      { 
    96109         this->writeField_(field); 
    97110      } 
     111      CATCH 
    98112 
    99113      //---------------------------------------------------------------- 
    100114 
    101115      void CDataOutput::writeFieldGrid(CField* field) 
     116      TRY 
    102117      { 
    103118         this->writeGrid(field->getRelGrid(), 
    104119                         !field->indexed_output.isEmpty() && field->indexed_output); 
    105120      } 
    106  
     121      CATCH 
    107122      //---------------------------------------------------------------- 
    108123 
    109124      void CDataOutput::writeFieldData(CField* field) 
     125      TRY 
    110126      { 
    111127//         CGrid* grid = CGrid::get(field->grid_ref.getValue()); 
     
    113129         this->writeFieldData_(field); 
    114130      } 
     131      CATCH 
    115132 
    116133      ///---------------------------------------------------------------- 
  • XIOS/dev/dev_olga/src/exception.cpp

    r828 r1612  
    55#include "client.hpp" 
    66#include "server.hpp" 
    7 #include "cxios.hpp" 
    87#include "log.hpp" 
    98 
     
    1211  /// ////////////////////// Définitions ////////////////////// /// 
    1312   CException::CException(void) 
    14       : CObject(), desc_rethrow(true) 
     13      : CObject(), desc_rethrow(true), stream() 
    1514   { /* Ne rien faire de plus */ } 
    1615 
    17    CException::CException(const StdString & id) 
    18       : CObject(id), desc_rethrow(true) 
     16   CException::CException(const std::string & id) 
     17      : CObject(id), desc_rethrow(true), stream() 
    1918   { /* Ne rien faire de plus */ } 
    2019 
    2120   CException::CException(const CException & exception) 
    22       : std::basic_ios<char>() 
    23       , CObject(exception.getId()) 
    24       , StdOStringStream() 
    25       , desc_rethrow(false) 
     21//      : std::basic_ios<char>() 
     22       : CObject(exception.getId()) 
     23//      , StdOStringStream() 
     24//      , desc_rethrow(false) 
    2625   { (*this) << exception.str(); } 
    2726 
    2827   CException::~CException(void) 
    2928   { 
    30       if (desc_rethrow) 
    31 #ifdef __XIOS_NOABORT 
    32       { 
    33         throw (*this); 
    34       } 
    35 #else 
    36      { 
    37       error << this->getMessage() << std::endl; 
    38       MPI_Abort(CXios::globalComm, -1); //abort(); 
    39       } 
    40 #endif 
     29//      if (desc_rethrow) 
     30//#ifdef __XIOS_NOABORT 
     31//      { 
     32//        throw (*this); 
     33//      } 
     34//#else 
     35//     { 
     36//      error << this->getMessage() << std::endl; 
     37//        throw 4; 
     38//      MPI_Abort(CXios::globalComm, -1); //abort(); 
     39//      } 
     40//#endif 
    4141   } 
    4242 
    4343   //--------------------------------------------------------------- 
    4444 
    45    StdString CException::getMessage(void) const 
     45   std::string CException::getMessage(void) const 
    4646   { 
    47       StdOStringStream oss; 
    48       oss << "> Error [" << this->getId() << "] : " << this->str(); 
    49       return (oss.str()); 
     47//     StdOStringStream oss; 
     48//     oss << "> Error [" << this->getId() << "] : " << this->str(); 
     49//     return (oss.str()); 
     50     return (stream.str()); 
    5051   } 
    5152 
    5253   StdOStringStream &  CException::getStream(void) 
    53    { return (*boost::polymorphic_cast<StdOStringStream*>(this)); } 
     54//   { return (*boost::polymorphic_cast<StdOStringStream*>(this)); } 
     55   { return stream; } 
    5456 
    55    StdString CException::toString(void) const 
    56    { return (StdString(this->getMessage())); } 
     57   std::string CException::toString(void) const 
     58//   { return (std::string(this->getMessage())); } 
     59   { return stream.str(); } 
    5760 
    58    void CException::fromString(const StdString & str) 
    59    { this->str(str); } 
     61   void CException::fromString(const std::string & str) 
     62   { } 
     63//   { this->str(str); } 
    6064 
    6165   //--------------------------------------------------------------- 
  • XIOS/dev/dev_olga/src/exception.hpp

    r792 r1612  
    55#include "xios_spl.hpp" 
    66#include "object.hpp" 
     7#include <iomanip> 
     8#include <stdexcept> 
    79 
    810namespace xios 
    911{ 
    1012   /// ////////////////////// Déclarations ////////////////////// /// 
     13 
    1114   class CException 
    1215      : private CObject, public StdOStringStream 
     
    3336         virtual void fromString(const StdString & str); 
    3437 
     38         struct StackInfo 
     39         { 
     40           StdString file; 
     41           StdString function; 
     42           int line; 
     43           StdString info; 
     44         }; 
     45 
     46         std::list<StackInfo> stack; 
     47 
    3548      private : 
    3649 
    3750         /// Propriétés /// 
    3851         bool desc_rethrow; // throw destructor 
     52         StdOStringStream stream; 
    3953 
    4054   }; // CException 
     
    4357/// //////////////////////////// Macros //////////////////////////// /// 
    4458 
     59#define FILE_NAME (std::strrchr("/" __FILE__, '/') + 1) 
     60 
     61#define FUNCTION_NAME (StdString(BOOST_CURRENT_FUNCTION).length() > 100 ? \ 
     62                       StdString(BOOST_CURRENT_FUNCTION).substr(0,100).append("...)") : BOOST_CURRENT_FUNCTION) 
     63 
    4564#define INFO(x) \ 
    46    "In file \'" __FILE__ "\', line " << __LINE__ << " -> " x << std::endl; 
     65   "In file \""<< FILE_NAME <<"\", function \"" << BOOST_CURRENT_FUNCTION <<"\", line " << __LINE__ << " -> " x << std::endl; 
    4766 
    4867#ifdef __XIOS_DEBUG 
     
    5271#endif 
    5372 
    54 #define ERROR(id, x) xios::CException(id).getStream() << INFO(x) 
     73#define ERROR(id, x)  \ 
     74{                     \ 
     75       xios::CException exc(id);                \ 
     76       exc.getStream() << INFO(x);              \ 
     77       error << exc.getMessage() << std::endl;  \ 
     78       throw exc;                               \ 
     79} 
     80 
     81#ifdef __XIOS_EXCEPTION 
     82  #define TRY                          \ 
     83    {                                  \ 
     84      int funcFirstLine = __LINE__;    \ 
     85      try 
     86  #define CATCH                              \ 
     87      catch(CException& e)                   \ 
     88      {                                      \ 
     89        CException::StackInfo stk;           \ 
     90        stk.file = FILE_NAME;                \ 
     91        stk.function = FUNCTION_NAME;        \ 
     92        stk.line = funcFirstLine;            \ 
     93        e.stack.push_back(stk);              \ 
     94        if (CXios::xiosStack)                \ 
     95          throw;                             \ 
     96       else                                  \ 
     97         throw 0;                            \ 
     98      }                                      \ 
     99    } 
     100  #define CATCH_DUMP_ATTR                    \ 
     101      catch(CException& e)                   \ 
     102      {                                      \ 
     103        CException::StackInfo stk;           \ 
     104        stk.info.append(StdString("Object id=\"" + this->getId()) + "\" object type=\"" + this->getName() + "\"\n"); \ 
     105        stk.info.append("*** XIOS attributes as defined in XML file(s) or via Fortran interface:\n");                \ 
     106        stk.info.append("[" + this->dumpXiosAttributes() + "]\n");     \ 
     107        stk.info.append("*** Additional information:\n");              \ 
     108        stk.info.append("[" + this->dumpClassAttributes() + "]\n");    \ 
     109        stk.file = FILE_NAME;                \ 
     110        stk.function = FUNCTION_NAME;        \ 
     111        stk.line = funcFirstLine;            \ 
     112        e.stack.push_back(stk);              \ 
     113        if (CXios::xiosStack)                \ 
     114          throw;                             \ 
     115       else                                  \ 
     116         throw 0;                            \ 
     117      }                                      \ 
     118    } 
     119  #define CATCH_DUMP_STACK                                           \ 
     120      catch(CException& e)                                           \ 
     121      {                                                              \ 
     122        CException::StackInfo stk;                                   \ 
     123        int i = 1;                                                   \ 
     124        stk.file = FILE_NAME;                                        \ 
     125        stk.function = FUNCTION_NAME;                                \ 
     126        stk.line = funcFirstLine;                                    \ 
     127        e.stack.push_back(stk);                                      \ 
     128        for (auto itr = e.stack.crbegin(); itr!=e.stack.crend(); ++itr) \ 
     129        {                                                            \ 
     130          error << "("<< i <<") **************** ";                  \ 
     131          error << itr->function << std::endl;                       \ 
     132          error << itr->info << std::endl;                           \ 
     133          ++i;                                                       \ 
     134        }                                                            \ 
     135        error << left << "      ";                                   \ 
     136        error << left << std::setw(40) << "File " ;                  \ 
     137        error << left << std::setw(106) << "Function " ;             \ 
     138        error << std::setw(5)   << "Line " << std::endl;             \ 
     139        i = e.stack.size();                                          \ 
     140        for (auto itr = e.stack.begin(); itr!=e.stack.end(); itr++)  \ 
     141        {                                                            \ 
     142          StdOStringStream tmp;                                      \ 
     143          tmp <<  "("<< i <<")";                                     \ 
     144          error << left << std::setw(6) << tmp.str();                \ 
     145          error << left << std::setw(40)  << itr->file;              \ 
     146          error << left << std::setw(106) << itr->function;          \ 
     147          error << left << std::setw(5)   << itr->line << std::endl; \ 
     148          --i;                                                       \ 
     149        }                                                            \ 
     150        throw;                                                       \ 
     151      }                                                              \ 
     152    } 
     153#else 
     154  #define TRY 
     155  #define CATCH 
     156  #define CATCH_DUMP_ATTR 
     157  #define CATCH_DUMP_STACK 
     158#endif 
    55159 
    56160#endif // __XIOS_CException__ 
     161 
  • XIOS/dev/dev_olga/src/interface/c/icaxis.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/iccalendar.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/iccalendar_wrapper.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/iccompute_connectivity_domain.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/iccontext.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icdata.cpp

    r1590 r1612  
    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; 
     
    6974      CTimer::get("XIOS").suspend(); 
    7075   } 
     76   CATCH_DUMP_STACK 
    7177 
    7278   void cxios_context_initialize(const char* context_id , int len_context_id, MPI_Fint* f_comm) 
     79   TRY 
    7380   { 
    7481     std::string str; 
     
    8390     CTimer::get("XIOS").suspend(); 
    8491   } 
     92   CATCH_DUMP_STACK 
    8593 
    8694   void cxios_oasis_enddef() 
     95   TRY 
    8796   { 
    8897     CTimer::get("XIOS").resume(); 
     
    9099     CTimer::get("XIOS").suspend(); 
    91100   } 
     101   CATCH_DUMP_STACK 
    92102 
    93103   void cxios_context_is_initialized(const char* context_id , int len_context_id, bool* initialized) 
     104   TRY 
    94105   { 
    95106     std::string str; 
     
    101112     CTimer::get("XIOS").suspend(); 
    102113   } 
    103  
    104     void cxios_context_close_definition() 
     114   CATCH_DUMP_STACK 
     115 
     116   void cxios_context_close_definition() 
     117   TRY 
    105118   { 
    106119     CTimer::get("XIOS").resume(); 
     
    111124     CTimer::get("XIOS").suspend(); 
    112125   } 
     126   CATCH_DUMP_STACK 
    113127 
    114128   void cxios_context_finalize() 
     129   TRY 
    115130   { 
    116131     CTimer::get("XIOS").resume(); 
     
    121136     CTimer::get("XIOS").suspend(); 
    122137   } 
     138   CATCH_DUMP_STACK 
    123139 
    124140   void cxios_finalize() 
     141   TRY 
    125142   { 
    126143     CTimer::get("XIOS").resume(); 
     
    128145     CXios::clientFinalize(); 
    129146   } 
     147   CATCH_DUMP_STACK 
    130148 
    131149   void cxios_solve_inheritance() 
     150   TRY 
    132151   { 
    133152     CTimer::get("XIOS").resume(); 
     
    136155     CTimer::get("XIOS").suspend(); 
    137156   } 
     157   CATCH_DUMP_STACK 
    138158 
    139159   /*! \brief This group of functions retrieve variable information from the configuration file (.xml) 
     
    148168   */ 
    149169   void cxios_get_variable_data_k8(const char* varId, int varIdSize, double* data, bool* isVarExisted) 
     170   TRY 
    150171   { 
    151172      std::string varIdStr; 
     
    166187      CTimer::get("XIOS").suspend(); 
    167188   } 
     189   CATCH_DUMP_STACK 
    168190 
    169191   void cxios_get_variable_data_k4(const char* varId, int varIdSize, float* data, bool* isVarExisted) 
     192   TRY 
    170193   { 
    171194      std::string varIdStr; 
     
    186209      CTimer::get("XIOS").suspend(); 
    187210   } 
     211   CATCH_DUMP_STACK 
    188212 
    189213   void cxios_get_variable_data_int(const char* varId, int varIdSize, int* data, bool* isVarExisted) 
     214   TRY 
    190215   { 
    191216      std::string varIdStr; 
     
    206231      CTimer::get("XIOS").suspend(); 
    207232   } 
     233   CATCH_DUMP_STACK 
    208234 
    209235   void cxios_get_variable_data_logic(const char* varId, int varIdSize, bool* data, bool* isVarExisted) 
     236   TRY 
    210237   { 
    211238      std::string varIdStr; 
     
    226253      CTimer::get("XIOS").suspend(); 
    227254   } 
     255   CATCH_DUMP_STACK 
    228256 
    229257   void cxios_get_variable_data_char(const char* varId, int varIdSize, char* data, int dataSizeIn, bool* isVarExisted) 
     258   TRY 
    230259   { 
    231260      std::string varIdStr; 
     
    247276      CTimer::get("XIOS").suspend(); 
    248277   } 
     278   CATCH_DUMP_STACK 
    249279 
    250280   /*! \brief This group of functions write information into existing variable in the configuration file (.xml) 
     
    259289   */ 
    260290   void cxios_set_variable_data_k8(const char* varId, int varIdSize, double data, bool* isVarExisted) 
    261    { 
     291   TRY 
     292  { 
    262293      std::string varIdStr; 
    263294      if (!cstr2string(varId, varIdSize, varIdStr)) return; 
     
    278309      CTimer::get("XIOS").suspend(); 
    279310   } 
     311   CATCH_DUMP_STACK 
    280312 
    281313   void cxios_set_variable_data_k4(const char* varId, int varIdSize, float data, bool* isVarExisted) 
     314   TRY 
    282315   { 
    283316      std::string varIdStr; 
     
    299332      CTimer::get("XIOS").suspend(); 
    300333   } 
     334   CATCH_DUMP_STACK 
    301335 
    302336   void cxios_set_variable_data_int(const char* varId, int varIdSize, int data, bool* isVarExisted) 
     337   TRY 
    303338   { 
    304339      std::string varIdStr; 
     
    321356      CTimer::get("XIOS").suspend(); 
    322357   } 
     358   CATCH_DUMP_STACK 
    323359 
    324360   void cxios_set_variable_data_logic(const char* varId, int varIdSize, bool data, bool* isVarExisted) 
     361   TRY 
    325362   { 
    326363      std::string varIdStr; 
     
    342379      CTimer::get("XIOS").suspend(); 
    343380   } 
     381   CATCH_DUMP_STACK 
    344382 
    345383   void cxios_set_variable_data_char(const char* varId, int varIdSize, const char* data, int dataSizeIn, bool* isVarExisted) 
    346    { 
     384   TRY 
     385  { 
    347386      std::string varIdStr, dataStr; 
    348387      if (!cstr2string(varId, varIdSize, varIdStr)) return; 
     
    368407      CTimer::get("XIOS").suspend(); 
    369408   } 
    370  
     409   CATCH_DUMP_STACK 
    371410 
    372411   // ---------------------- Ecriture des données ------------------------------ 
    373412 
    374413   void cxios_write_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) 
     414   TRY 
    375415   { 
    376416      std::string fieldid_str; 
     
    387427      CTimer::get("XIOS").suspend(); 
    388428   } 
     429   CATCH_DUMP_STACK 
    389430 
    390431   void cxios_write_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) 
     432   TRY 
    391433   { 
    392434      std::string fieldid_str; 
     
    406448      CTimer::get("XIOS").suspend(); 
    407449   } 
     450   CATCH_DUMP_STACK 
    408451 
    409452   void cxios_write_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize) 
     453   TRY 
    410454   { 
    411455      std::string fieldid_str; 
     
    425469      CTimer::get("XIOS").suspend(); 
    426470   } 
     471   CATCH_DUMP_STACK 
    427472 
    428473   void cxios_write_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize) 
     474   TRY 
    429475   { 
    430476      std::string fieldid_str; 
     
    444490      CTimer::get("XIOS").suspend(); 
    445491   } 
     492   CATCH_DUMP_STACK 
    446493 
    447494   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) 
     495   TRY 
    448496   { 
    449497      std::string fieldid_str; 
     
    463511      CTimer::get("XIOS").suspend(); 
    464512   } 
     513   CATCH_DUMP_STACK 
    465514 
    466515   void cxios_write_data_k85(const char* fieldid, int fieldid_size, double* data_k8, 
    467516                             int data_0size, int data_1size, int data_2size, 
    468517                             int data_3size, int data_4size) 
     518   TRY 
    469519   { 
    470520      std::string fieldid_str; 
     
    484534      CTimer::get("XIOS").suspend(); 
    485535   } 
     536   CATCH_DUMP_STACK 
    486537 
    487538   void cxios_write_data_k86(const char* fieldid, int fieldid_size, double* data_k8, 
    488539                             int data_0size, int data_1size, int data_2size, 
    489540                             int data_3size, int data_4size, int data_5size) 
     541   TRY 
    490542   { 
    491543      std::string fieldid_str; 
     
    505557      CTimer::get("XIOS").suspend(); 
    506558   } 
     559   CATCH_DUMP_STACK 
    507560 
    508561   void cxios_write_data_k87(const char* fieldid, int fieldid_size, double* data_k8, 
     
    510563                             int data_3size, int data_4size, int data_5size, 
    511564                             int data_6size) 
     565   TRY 
    512566   { 
    513567      std::string fieldid_str; 
     
    527581      CTimer::get("XIOS").suspend(); 
    528582   } 
     583   CATCH_DUMP_STACK 
    529584 
    530585   void cxios_write_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
     586   TRY 
    531587   { 
    532588      std::string fieldid_str; 
     
    546602      CTimer::get("XIOS").suspend(); 
    547603   } 
     604   CATCH_DUMP_STACK 
    548605 
    549606   void cxios_write_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
     607   TRY 
    550608   { 
    551609      std::string fieldid_str; 
     
    567625      CTimer::get("XIOS").suspend(); 
    568626   } 
     627   CATCH_DUMP_STACK 
    569628 
    570629   void cxios_write_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize) 
     630   TRY 
    571631   { 
    572632      std::string fieldid_str; 
     
    588648      CTimer::get("XIOS").suspend(); 
    589649   } 
     650   CATCH_DUMP_STACK 
    590651 
    591652   void cxios_write_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) 
     653   TRY 
    592654   { 
    593655      std::string fieldid_str; 
     
    609671      CTimer::get("XIOS").suspend(); 
    610672    } 
     673   CATCH_DUMP_STACK 
    611674 
    612675   void cxios_write_data_k44(const char* fieldid, int fieldid_size, float* data_k4, 
    613676                             int data_0size, int data_1size, int data_2size, 
    614677                             int data_3size) 
     678   TRY 
    615679   { 
    616680      std::string fieldid_str; 
     
    632696      CTimer::get("XIOS").suspend(); 
    633697    } 
     698   CATCH_DUMP_STACK 
    634699 
    635700   void cxios_write_data_k45(const char* fieldid, int fieldid_size, float* data_k4, 
    636701                             int data_0size, int data_1size, int data_2size, 
    637702                             int data_3size, int data_4size) 
     703   TRY 
    638704   { 
    639705      std::string fieldid_str; 
     
    655721      CTimer::get("XIOS").suspend(); 
    656722    } 
     723   CATCH_DUMP_STACK 
    657724 
    658725   void cxios_write_data_k46(const char* fieldid, int fieldid_size, float* data_k4, 
    659726                             int data_0size, int data_1size, int data_2size, 
    660727                             int data_3size, int data_4size, int data_5size) 
     728   TRY 
    661729   { 
    662730      std::string fieldid_str; 
     
    678746      CTimer::get("XIOS").suspend(); 
    679747    } 
     748   CATCH_DUMP_STACK 
    680749 
    681750   void cxios_write_data_k47(const char* fieldid, int fieldid_size, float* data_k4, 
     
    683752                             int data_3size, int data_4size, int data_5size, 
    684753                             int data_6size) 
     754   TRY 
    685755   { 
    686756      std::string fieldid_str; 
     
    702772      CTimer::get("XIOS").suspend(); 
    703773    } 
     774   CATCH_DUMP_STACK 
    704775 
    705776   // ---------------------- Lecture des données ------------------------------ 
    706777 
    707778   void cxios_read_data_k80(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) 
     779   TRY 
    708780   { 
    709781      std::string fieldid_str; 
     
    723795      CTimer::get("XIOS").suspend(); 
    724796   } 
     797   CATCH_DUMP_STACK 
    725798 
    726799   void cxios_read_data_k81(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize) 
     800   TRY 
    727801   { 
    728802      std::string fieldid_str; 
     
    742816      CTimer::get("XIOS").suspend(); 
    743817   } 
     818   CATCH_DUMP_STACK 
    744819 
    745820   void cxios_read_data_k82(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize) 
     821   TRY 
    746822   { 
    747823      std::string fieldid_str; 
     
    761837      CTimer::get("XIOS").suspend(); 
    762838   } 
     839   CATCH_DUMP_STACK 
    763840 
    764841   void cxios_read_data_k83(const char* fieldid, int fieldid_size, double* data_k8, int data_Xsize, int data_Ysize, int data_Zsize) 
     842   TRY 
    765843   { 
    766844      std::string fieldid_str; 
     
    780858      CTimer::get("XIOS").suspend(); 
    781859   } 
     860   CATCH_DUMP_STACK 
    782861 
    783862   void cxios_read_data_k84(const char* fieldid, int fieldid_size, double* data_k8, 
    784863                            int data_0size, int data_1size, int data_2size, 
    785864                            int data_3size) 
     865   TRY 
    786866   { 
    787867      std::string fieldid_str; 
     
    801881      CTimer::get("XIOS").suspend(); 
    802882   } 
     883   CATCH_DUMP_STACK 
    803884 
    804885   void cxios_read_data_k85(const char* fieldid, int fieldid_size, double* data_k8, 
    805886                            int data_0size, int data_1size, int data_2size, 
    806887                            int data_3size, int data_4size) 
     888   TRY 
    807889   { 
    808890      std::string fieldid_str; 
     
    822904      CTimer::get("XIOS").suspend(); 
    823905   } 
     906   CATCH_DUMP_STACK 
    824907 
    825908   void cxios_read_data_k86(const char* fieldid, int fieldid_size, double* data_k8, 
    826909                            int data_0size, int data_1size, int data_2size, 
    827910                            int data_3size, int data_4size, int data_5size) 
     911   TRY 
    828912   { 
    829913      std::string fieldid_str; 
     
    843927      CTimer::get("XIOS").suspend(); 
    844928   } 
     929   CATCH_DUMP_STACK 
    845930 
    846931   void cxios_read_data_k87(const char* fieldid, int fieldid_size, double* data_k8, 
     
    848933                            int data_3size, int data_4size, int data_5size, 
    849934                            int data_6size) 
     935   TRY 
    850936   { 
    851937      std::string fieldid_str; 
     
    865951      CTimer::get("XIOS").suspend(); 
    866952   } 
     953   CATCH_DUMP_STACK 
    867954 
    868955   void cxios_read_data_k40(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
     956   TRY 
    869957   { 
    870958      std::string fieldid_str; 
     
    886974      CTimer::get("XIOS").suspend(); 
    887975   } 
     976   CATCH_DUMP_STACK 
    888977 
    889978   void cxios_read_data_k41(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize) 
     979   TRY 
    890980   { 
    891981      std::string fieldid_str; 
     
    907997      CTimer::get("XIOS").suspend(); 
    908998   } 
     999   CATCH_DUMP_STACK 
    9091000 
    9101001   void cxios_read_data_k42(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize) 
     1002   TRY 
    9111003   { 
    9121004      std::string fieldid_str; 
     
    9281020      CTimer::get("XIOS").suspend(); 
    9291021   } 
     1022   CATCH_DUMP_STACK 
    9301023 
    9311024   void cxios_read_data_k43(const char* fieldid, int fieldid_size, float* data_k4, int data_Xsize, int data_Ysize, int data_Zsize) 
     1025   TRY 
    9321026   { 
    9331027      std::string fieldid_str; 
     
    9491043      CTimer::get("XIOS").suspend(); 
    9501044    } 
     1045   CATCH_DUMP_STACK 
    9511046 
    9521047   void cxios_read_data_k44(const char* fieldid, int fieldid_size, float* data_k4, 
    9531048                            int data_0size, int data_1size, int data_2size, 
    9541049                            int data_3size) 
     1050   TRY 
    9551051   { 
    9561052      std::string fieldid_str; 
     
    9721068      CTimer::get("XIOS").suspend(); 
    9731069    } 
     1070   CATCH_DUMP_STACK 
    9741071 
    9751072   void cxios_read_data_k45(const char* fieldid, int fieldid_size, float* data_k4, 
    9761073                            int data_0size, int data_1size, int data_2size, 
    9771074                            int data_3size, int data_4size) 
     1075   TRY 
    9781076   { 
    9791077      std::string fieldid_str; 
     
    9951093      CTimer::get("XIOS").suspend(); 
    9961094    } 
     1095   CATCH_DUMP_STACK 
    9971096 
    9981097   void cxios_read_data_k46(const char* fieldid, int fieldid_size, float* data_k4, 
    9991098                            int data_0size, int data_1size, int data_2size, 
    10001099                            int data_3size, int data_4size, int data_5size) 
     1100   TRY 
    10011101   { 
    10021102      std::string fieldid_str; 
     
    10181118      CTimer::get("XIOS").suspend(); 
    10191119    } 
     1120   CATCH_DUMP_STACK 
    10201121 
    10211122   void cxios_read_data_k47(const char* fieldid, int fieldid_size, float* data_k4, 
     
    10231124                            int data_3size, int data_4size, int data_5size, 
    10241125                            int data_6size) 
     1126   TRY 
    10251127   { 
    10261128      std::string fieldid_str; 
     
    10421144      CTimer::get("XIOS").suspend(); 
    10431145    } 
     1146   CATCH_DUMP_STACK 
    10441147} // extern "C" 
  • XIOS/dev/dev_olga/src/interface/c/icdate.cpp

    r1542 r1612  
    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)"), 
     
    7380    return { res.getYear(), res.getMonth(), res.getDay(), res.getHour(), res.getMinute(), res.getSecond() }; 
    7481  } 
     82  CATCH_DUMP_STACK 
    7583 
    7684  cxios_date cxios_date_sub_duration(cxios_date date_c, cxios_duration dur_c) 
     85  TRY 
    7786  { 
    7887    xios::CDate date = xios::CDate(getCalendar("cxios_date cxios_date_sub_duration(cxios_date date_c, cxios_duration dur_c)"), 
     
    8493    return { res.getYear(), res.getMonth(), res.getDay(), res.getHour(), res.getMinute(), res.getSecond() }; 
    8594  } 
     95  CATCH_DUMP_STACK 
    8696 
    8797  cxios_duration cxios_date_sub(cxios_date date1_c, cxios_date date2_c) 
     98  TRY 
    8899  { 
    89100    xios::CDate date1 = xios::CDate(getCalendar("cxios_duration cxios_date_sub(cxios_date date1_c, cxios_date date2_c)"), 
     
    96107    return { res.year, res.month, res.day, res.hour, res.minute, res.second, res.timestep }; 
    97108  } 
     109  CATCH_DUMP_STACK 
    98110 
    99111  bool cxios_date_eq(cxios_date date1_c, cxios_date date2_c) 
     112  TRY 
    100113  { 
    101114    xios::CDate date1 = xios::CDate(getCalendar("bool cxios_date_eq(cxios_date date1_c, cxios_date date2_c)"), 
     
    107120    return (date1 == date2); 
    108121  } 
     122  CATCH_DUMP_STACK 
    109123 
    110124  bool cxios_date_neq(cxios_date date1_c, cxios_date date2_c) 
     125  TRY 
    111126  { 
    112127    xios::CDate date1 = xios::CDate(getCalendar("bool cxios_date_eq(cxios_date date1_c, cxios_date date2_c)"), 
     
    118133    return (date1 != date2); 
    119134  } 
     135  CATCH_DUMP_STACK 
    120136 
    121137  bool cxios_date_lt(cxios_date date1_c, cxios_date date2_c) 
     138  TRY 
    122139  { 
    123140    xios::CDate date1 = xios::CDate(getCalendar("bool cxios_date_eq(cxios_date date1_c, cxios_date date2_c)"), 
     
    129146    return (date1 < date2); 
    130147  } 
     148  CATCH_DUMP_STACK 
    131149 
    132150  bool cxios_date_le(cxios_date date1_c, cxios_date date2_c) 
     151  TRY 
    133152  { 
    134153    xios::CDate date1 = xios::CDate(getCalendar("bool cxios_date_eq(cxios_date date1_c, cxios_date date2_c)"), 
     
    140159    return (date1 <= date2); 
    141160  } 
     161  CATCH_DUMP_STACK 
    142162 
    143163  bool cxios_date_gt(cxios_date date1_c, cxios_date date2_c) 
     164  TRY 
    144165  { 
    145166    xios::CDate date1 = xios::CDate(getCalendar("bool cxios_date_eq(cxios_date date1_c, cxios_date date2_c)"), 
     
    151172    return (date1 > date2); 
    152173  } 
     174  CATCH_DUMP_STACK 
    153175 
    154176  bool cxios_date_ge(cxios_date date1_c, cxios_date date2_c) 
     177  TRY 
    155178  { 
    156179    xios::CDate date1 = xios::CDate(getCalendar("bool cxios_date_eq(cxios_date date1_c, cxios_date date2_c)"), 
     
    162185    return (date1 >= date2); 
    163186  } 
     187  CATCH_DUMP_STACK 
    164188 
    165189  int cxios_date_get_second_of_year(cxios_date date_c) 
     190  TRY 
    166191  { 
    167192    xios::CDate date = xios::CDate(getCalendar("int cxios_date_get_second_of_year(cxios_date date_c)"), 
     
    170195    return date.getSecondOfYear(); 
    171196  } 
     197  CATCH_DUMP_STACK 
    172198 
    173199  double cxios_date_get_day_of_year(cxios_date date_c) 
     200  TRY 
    174201  { 
    175202    xios::CDate date = xios::CDate(getCalendar("int cxios_date_get_day_of_year(cxios_date date_c)"), 
     
    178205    return date.getDayOfYear(); 
    179206  } 
     207  CATCH_DUMP_STACK 
    180208 
    181209  double cxios_date_get_fraction_of_year(cxios_date date_c) 
     210  TRY 
    182211  { 
    183212    xios::CDate date = xios::CDate(getCalendar("int cxios_date_get_fraction_of_year(cxios_date date_c)"), 
     
    186215    return date.getFractionOfYear(); 
    187216  } 
     217  CATCH_DUMP_STACK 
    188218 
    189219  int cxios_date_get_second_of_day(cxios_date date_c) 
     220  TRY 
    190221  { 
    191222    xios::CDate date = xios::CDate(getCalendar("int cxios_date_get_second_of_day(cxios_date date_c)"), 
     
    194225    return date.getSecondOfDay(); 
    195226  } 
     227  CATCH_DUMP_STACK 
    196228 
    197229  double cxios_date_get_fraction_of_day(cxios_date date_c) 
     230  TRY 
    198231  { 
    199232    xios::CDate date = xios::CDate(getCalendar("int cxios_date_get_fraction_of_day(cxios_date date_c)"), 
     
    202235    return date.getFractionOfDay(); 
    203236  } 
     237  CATCH_DUMP_STACK 
    204238} // extern "C" 
  • XIOS/dev/dev_olga/src/interface/c/icdomain.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icduplicate_scalar_to_axis.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icduration.cpp

    r1472 r1612  
     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/dev_olga/src/interface/c/icexpand_domain.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icextract_to_axis.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icextract_to_scalar.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icfield.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icfile.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icgenerate_rectilinear_domain.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icgrid.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icinterpolate.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icinverse_axis.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icreduce_axis_to_axis.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icreduce_scalar_to_scalar.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icreduce_to_axis.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icreduce_to_scalar.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icreorder_domain.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icscalar.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/ictemporal_splitting.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/icvariable.cpp

    r1542 r1612  
    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/dev_olga/src/interface/c/iczoom.cpp

    r1542 r1612  
    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/dev_olga/src/io/nc4_data_input.cpp

    r1589 r1612  
    2929 
    3030  StdSize CNc4DataInput::getFieldNbRecords_(CField* field) 
     31  TRY 
    3132  { 
    3233    StdString fieldId = field->getFieldOutputName(); 
     
    4041    return 1; 
    4142  } 
     43  CATCH 
    4244 
    4345  void CNc4DataInput::readFieldData_(CField* field) 
     46  TRY 
    4447  { 
    4548    CContext* context = CContext::getCurrent(); 
     
    121124    } 
    122125  } 
     126  CATCH 
    123127 
    124128  void CNc4DataInput::readFieldAttributes_(CField* field, bool readAttributeValues) 
     129  TRY 
    125130  { 
    126131    StdString fieldId = field->getFieldOutputName(); 
     
    248253    } 
    249254  } 
     255  CATCH 
    250256 
    251257  /*! 
     
    258264  void CNc4DataInput::readDomainAttributeValueFromFile(CDomain* domain, std::list<std::pair<StdString, StdSize> >& dimSizeMap, 
    259265                                                       int elementPosition, const StdString& fieldId) 
     266  TRY 
    260267  { 
    261268    // There are some optional attributes of a domain to retrieve from file    // + lon lat? 
     
    436443    domain->fillInLonLat(); 
    437444  } 
     445  CATCH 
    438446 
    439447  /*! 
     
    446454  void CNc4DataInput::readDomainAttributesFromFile(CDomain* domain, std::list<std::pair<StdString, StdSize> >& dimSizeMap, 
    447455                                                   int elementPosition, const StdString& fieldId) 
     456  TRY 
    448457  { 
    449458    // There are some mandatory attributes of a domain to retrieve from file 
     
    514523    } 
    515524  } 
     525  CATCH 
    516526 
    517527  /*! 
     
    524534  void CNc4DataInput::readAxisAttributesFromFile(CAxis* axis, std::list<std::pair<StdString, StdSize> >& dimSizeMap, 
    525535                                                 int elementPosition, const StdString& fieldId) 
     536  TRY 
    526537  { 
    527538    std::list<std::pair<StdString, StdSize> >::const_iterator itMapN = dimSizeMap.begin(), 
     
    540551    axis->n_glo.setValue(itMapN->second); 
    541552  } 
     553  CATCH 
    542554 
    543555  /*! 
     
    550562  void CNc4DataInput::readAxisAttributeValueFromFile(CAxis* axis, std::list<std::pair<StdString, StdSize> >& dimSizeMap, 
    551563                                                    int elementPosition, const StdString& fieldId) 
     564  TRY 
    552565  { 
    553566    std::list<std::pair<StdString, StdSize> >::const_iterator itMapN = dimSizeMap.begin(), 
     
    570583    } 
    571584  } 
     585  CATCH 
    572586 
    573587  /*! 
     
    598612 
    599613  void CNc4DataInput::closeFile_(void) 
     614  TRY 
    600615  { 
    601616    SuperClassWriter::close(); 
    602617  } 
     618  CATCH 
    603619} // namespace xios 
  • XIOS/dev/dev_olga/src/io/nc4_data_output.cpp

    r1590 r1612  
    5454 
    5555      void CNc4DataOutput::writeDomain_(CDomain* domain) 
     56      TRY 
    5657      { 
    5758        StdString lonName,latName ; 
     
    540541         domain->addRelFile(this->filename); 
    541542      } 
     543      CATCH 
    542544 
    543545    //-------------------------------------------------------------- 
  • XIOS/dev/dev_olga/src/node/axis.cpp

    r1600 r1612  
    4848   bool CAxis::dummyTransformationMapList_ = CAxis::initializeTransformationMap(CAxis::transformationMapList_); 
    4949   bool CAxis::initializeTransformationMap(std::map<StdString, ETranformationType>& m) 
     50   TRY 
    5051   { 
    5152     m["zoom_axis"] = TRANS_ZOOM_AXIS; 
     
    6061 
    6162   } 
     63   CATCH 
    6264 
    6365   ///--------------------------------------------------------------- 
    6466 
    6567   const std::set<StdString> & CAxis::getRelFiles(void) const 
     68   TRY 
    6669   { 
    6770      return (this->relFiles); 
    6871   } 
     72   CATCH 
    6973 
    7074   bool CAxis::IsWritten(const StdString & filename) const 
     75   TRY 
    7176   { 
    7277      return (this->relFiles.find(filename) != this->relFiles.end()); 
    7378   } 
     79   CATCH 
    7480 
    7581   bool CAxis::isWrittenCompressed(const StdString& filename) const 
     82   TRY 
    7683   { 
    7784      return (this->relFilesCompressed.find(filename) != this->relFilesCompressed.end()); 
    7885   } 
     86   CATCH 
    7987 
    8088   bool CAxis::isDistributed(void) const 
     89   TRY 
    8190   { 
    8291      bool distributed = (!this->begin.isEmpty() && !this->n.isEmpty() && (this->begin + this->n < this->n_glo)) || 
    8392             (!this->n.isEmpty() && (this->n != this->n_glo)); 
    84       // A same stupid condition to make sure that if there is only one client, axis 
     93      // A condition to make sure that if there is only one client, axis 
    8594      // should be considered to be distributed. This should be a temporary solution      
    8695      distributed |= (1 == CContext::getCurrent()->client->clientSize); 
    8796      return distributed; 
    8897   } 
     98   CATCH 
    8999 
    90100   /*! 
     
    94104    */ 
    95105   bool CAxis::isCompressible(void) const 
     106   TRY 
    96107   { 
    97108      return isCompressible_; 
    98109   } 
     110   CATCH 
    99111 
    100112   void CAxis::addRelFile(const StdString & filename) 
     113   TRY 
    101114   { 
    102115      this->relFiles.insert(filename); 
    103116   } 
     117   CATCH_DUMP_ATTR 
    104118 
    105119   void CAxis::addRelFileCompressed(const StdString& filename) 
     120   TRY 
    106121   { 
    107122      this->relFilesCompressed.insert(filename); 
    108123   } 
     124   CATCH_DUMP_ATTR 
    109125 
    110126   //---------------------------------------------------------------- 
     
    115131   */ 
    116132   int CAxis::getNumberWrittenIndexes(MPI_Comm writtenCom) 
     133   TRY 
    117134   { 
    118135     int writtenSize; 
     
    120137     return numberWrittenIndexes_[writtenSize]; 
    121138   } 
     139   CATCH_DUMP_ATTR 
    122140 
    123141   /*! 
     
    126144   */ 
    127145   int CAxis::getTotalNumberWrittenIndexes(MPI_Comm writtenCom) 
     146   TRY 
    128147   { 
    129148     int writtenSize; 
     
    131150     return totalNumberWrittenIndexes_[writtenSize]; 
    132151   } 
     152   CATCH_DUMP_ATTR 
    133153 
    134154   /*! 
     
    137157   */ 
    138158   int CAxis::getOffsetWrittenIndexes(MPI_Comm writtenCom) 
     159   TRY 
    139160   { 
    140161     int writtenSize; 
     
    142163     return offsetWrittenIndexes_[writtenSize]; 
    143164   } 
     165   CATCH_DUMP_ATTR 
    144166 
    145167   CArray<int, 1>& CAxis::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom) 
     168   TRY 
    146169   { 
    147170     int writtenSize; 
     
    149172     return compressedIndexToWriteOnServer[writtenSize]; 
    150173   } 
     174   CATCH_DUMP_ATTR 
     175 
    151176   //---------------------------------------------------------------- 
    152177 
     
    158183   std::map<int, StdSize> CAxis::getAttributesBufferSize(CContextClient* client, const std::vector<int>& globalDim, int orderPositionInGrid, 
    159184                                                         CServerDistributionDescription::ServerDistributionType distType) 
     185   TRY 
    160186   { 
    161187 
     
    221247       } 
    222248     } 
    223  
    224249     return attributesSizes; 
    225250   } 
     251   CATCH_DUMP_ATTR 
    226252 
    227253   //---------------------------------------------------------------- 
     
    234260 
    235261   CAxis* CAxis::createAxis() 
     262   TRY 
    236263   { 
    237264     CAxis* axis = CAxisGroup::get("axis_definition")->createChild(); 
    238265     return axis; 
    239266   } 
     267   CATCH 
    240268 
    241269   /*! 
     
    244272   */ 
    245273   void CAxis::checkAttributes(void) 
     274   TRY 
    246275   { 
    247276     CContext* context=CContext::getCurrent(); 
     
    311340      } 
    312341   } 
     342   CATCH_DUMP_ATTR 
    313343 
    314344   /*! 
     
    317347 
    318348   void CAxis::checkData() 
     349   TRY 
    319350   { 
    320351      if (data_begin.isEmpty()) data_begin.setValue(0); 
     
    363394 
    364395   } 
     396   CATCH_DUMP_ATTR 
    365397 
    366398    size_t CAxis::getGlobalWrittenSize(void) 
     
    373405   */ 
    374406   void CAxis::checkMask() 
     407   TRY 
    375408   { 
    376409      if (!mask.isEmpty()) 
     
    391424      } 
    392425   } 
     426   CATCH_DUMP_ATTR 
    393427 
    394428   /*! 
     
    396430   */ 
    397431   void CAxis::checkBounds() 
     432   TRY 
    398433   { 
    399434     if (!bounds.isEmpty()) 
     
    408443     else hasBounds = false; 
    409444   } 
     445   CATCH_DUMP_ATTR 
    410446 
    411447  void CAxis::checkLabel() 
     448  TRY 
    412449  { 
    413450    if (!label.isEmpty()) 
     
    422459    else hasLabel = false; 
    423460  } 
     461  CATCH_DUMP_ATTR 
    424462 
    425463  /*! 
     
    427465  */ 
    428466  void CAxis::checkEligibilityForCompressedOutput() 
     467  TRY 
    429468  { 
    430469    // We don't check if the mask is valid here, just if a mask has been defined at this point. 
    431470    isCompressible_ = !mask.isEmpty(); 
    432471  } 
     472  CATCH_DUMP_ATTR 
    433473 
    434474  /*! 
     
    436476  */ 
    437477  bool CAxis::dispatchEvent(CEventServer& event) 
     478  TRY 
    438479  { 
    439480     if (SuperClass::dispatchEvent(event)) return true; 
     
    461502     } 
    462503  } 
     504  CATCH 
    463505 
    464506   /*! 
     
    466508   */ 
    467509   void CAxis::checkAttributesOnClient() 
     510   TRY 
    468511   { 
    469512     if (this->areClientAttributesChecked_) return; 
     
    474517     this->areClientAttributesChecked_ = true; 
    475518   } 
     519   CATCH_DUMP_ATTR 
    476520 
    477521   /* 
     
    481525   void CAxis::checkAttributesOnClientAfterTransformation(const std::vector<int>& globalDim, int orderPositionInGrid, 
    482526                                                          CServerDistributionDescription::ServerDistributionType distType) 
     527   TRY 
    483528   { 
    484529     CContext* context=CContext::getCurrent() ; 
     
    494539     this->isClientAfterTransformationChecked = true; 
    495540   } 
     541   CATCH_DUMP_ATTR 
    496542 
    497543   /* 
     
    504550   void CAxis::sendCheckedAttributes(const std::vector<int>& globalDim, int orderPositionInGrid, 
    505551                                     CServerDistributionDescription::ServerDistributionType distType) 
     552   TRY 
    506553   { 
    507554     if (!this->areClientAttributesChecked_) checkAttributesOnClient(); 
     
    514561     this->isChecked = true; 
    515562   } 
     563   CATCH_DUMP_ATTR 
    516564 
    517565  /*! 
     
    522570  void CAxis::sendAttributes(const std::vector<int>& globalDim, int orderPositionInGrid, 
    523571                             CServerDistributionDescription::ServerDistributionType distType) 
     572  TRY 
    524573  { 
    525574     sendDistributionAttribute(globalDim, orderPositionInGrid, distType); 
     
    536585     }      
    537586  } 
     587  CATCH_DUMP_ATTR 
    538588 
    539589  /* 
     
    547597  void CAxis::computeConnectedClients(const std::vector<int>& globalDim, int orderPositionInGrid, 
    548598                                     CServerDistributionDescription::ServerDistributionType distType) 
     599  TRY 
    549600  { 
    550601    CContext* context = CContext::getCurrent(); 
     
    666717    } 
    667718  } 
     719  CATCH_DUMP_ATTR 
    668720 
    669721  /* 
     
    673725  */ 
    674726  void CAxis::computeWrittenIndex() 
     727  TRY 
    675728  {   
    676729    if (computedWrittenIndex_) return; 
     
    714767 
    715768  } 
     769  CATCH_DUMP_ATTR 
    716770 
    717771  void CAxis::computeWrittenCompressedIndex(MPI_Comm writtenComm) 
     772  TRY 
    718773  { 
    719774    int writtenCommSize; 
     
    804859    } 
    805860  } 
     861  CATCH_DUMP_ATTR 
    806862 
    807863  /*! 
     
    814870  void CAxis::sendDistributionAttribute(const std::vector<int>& globalDim, int orderPositionInGrid, 
    815871                                        CServerDistributionDescription::ServerDistributionType distType) 
     872  TRY 
    816873  { 
    817874    std::list<CContextClient*>::iterator it; 
     
    852909    } 
    853910  } 
     911  CATCH_DUMP_ATTR 
    854912 
    855913  /* 
     
    858916  */ 
    859917  void CAxis::recvDistributionAttribute(CEventServer& event) 
     918  TRY 
    860919  { 
    861920    CBufferIn* buffer = event.subEvents.begin()->buffer; 
     
    864923    get(axisId)->recvDistributionAttribute(*buffer); 
    865924  } 
     925  CATCH 
    866926 
    867927  /* 
     
    870930  */ 
    871931  void CAxis::recvDistributionAttribute(CBufferIn& buffer) 
     932  TRY 
    872933  { 
    873934    int ni_srv, begin_srv; 
     
    879940    begin.setValue(begin_srv); 
    880941  } 
     942  CATCH_DUMP_ATTR 
    881943 
    882944  /* 
     
    886948  */ 
    887949  void CAxis::sendNonDistributedAttributes() 
     950  TRY 
    888951  { 
    889952    std::list<CContextClient*>::iterator it; 
     
    9391002    } 
    9401003  } 
     1004  CATCH_DUMP_ATTR 
    9411005 
    9421006  /* 
     
    9451009  */ 
    9461010  void CAxis::recvNonDistributedAttributes(CEventServer& event) 
     1011  TRY 
    9471012  { 
    9481013    list<CEventServer::SSubEvent>::iterator it; 
     
    9551020    } 
    9561021  } 
     1022  CATCH 
    9571023 
    9581024  /* 
     
    9621028  */ 
    9631029  void CAxis::recvNonDistributedAttributes(int rank, CBufferIn& buffer) 
     1030  TRY 
    9641031  {  
    9651032    CArray<int,1> tmp_index, tmp_data_index; 
     
    10031070    for (int idx = 0; idx < index.numElements(); ++idx) globalLocalIndexMap_[index(idx)] = idx; 
    10041071  } 
     1072  CATCH_DUMP_ATTR 
    10051073 
    10061074  /* 
     
    10101078  */ 
    10111079  void CAxis::sendDistributedAttributes(void) 
     1080  TRY 
    10121081  { 
    10131082    int ind, idx; 
     
    11131182    } 
    11141183  } 
     1184  CATCH_DUMP_ATTR 
    11151185 
    11161186  /* 
     
    11191189  */ 
    11201190  void CAxis::recvDistributedAttributes(CEventServer& event) 
     1191  TRY 
    11211192  { 
    11221193    string axisId; 
     
    11341205    get(axisId)->recvDistributedAttributes(ranks, buffers); 
    11351206  } 
     1207  CATCH 
    11361208 
    11371209  /* 
     
    11411213  */ 
    11421214  void CAxis::recvDistributedAttributes(vector<int>& ranks, vector<CBufferIn*> buffers) 
     1215  TRY 
    11431216  { 
    11441217    int nbReceived = ranks.size(), idx, ind, gloInd, locInd; 
     
    12591332    data_n.setValue(data_index.numElements()); 
    12601333  } 
     1334  CATCH_DUMP_ATTR 
    12611335 
    12621336  /*! 
     
    12681342  */ 
    12691343  bool CAxis::isEqual(CAxis* obj) 
     1344  TRY 
    12701345  { 
    12711346    vector<StdString> excludedAttr; 
     
    12911366    return objEqual; 
    12921367  } 
     1368  CATCH_DUMP_ATTR 
    12931369 
    12941370  /* 
     
    12981374  */ 
    12991375  CTransformation<CAxis>* CAxis::addTransformation(ETranformationType transType, const StdString& id) 
     1376  TRY 
    13001377  { 
    13011378    transformationMap_.push_back(std::make_pair(transType, CTransformation<CAxis>::createTransformation(transType,id))); 
    13021379    return transformationMap_.back().second; 
    13031380  } 
     1381  CATCH_DUMP_ATTR 
    13041382 
    13051383  /* 
     
    13071385  */ 
    13081386  bool CAxis::hasTransformation() 
     1387  TRY 
    13091388  { 
    13101389    return (!transformationMap_.empty()); 
    13111390  } 
     1391  CATCH_DUMP_ATTR 
    13121392 
    13131393  /* 
     
    13161396  */ 
    13171397  void CAxis::setTransformations(const TransMapTypes& axisTrans) 
     1398  TRY 
    13181399  { 
    13191400    transformationMap_ = axisTrans; 
    13201401  } 
     1402  CATCH_DUMP_ATTR 
    13211403 
    13221404  /* 
     
    13251407  */ 
    13261408  CAxis::TransMapTypes CAxis::getAllTransformations(void) 
     1409  TRY 
    13271410  { 
    13281411    return transformationMap_; 
    13291412  } 
     1413  CATCH_DUMP_ATTR 
    13301414 
    13311415  /* 
     
    13341418  */ 
    13351419  void CAxis::duplicateTransformation(CAxis* src) 
     1420  TRY 
    13361421  { 
    13371422    if (src->hasTransformation()) 
     
    13401425    } 
    13411426  } 
     1427  CATCH_DUMP_ATTR 
    13421428 
    13431429  /*! 
     
    13451431   */ 
    13461432  void CAxis::solveInheritanceTransformation() 
     1433  TRY 
    13471434  { 
    13481435    if (hasTransformation() || !hasDirectAxisReference()) 
     
    13611448        refAxis[i]->setTransformations(axis->getAllTransformations()); 
    13621449  } 
     1450  CATCH_DUMP_ATTR 
    13631451 
    13641452  void CAxis::setContextClient(CContextClient* contextClient) 
     1453  TRY 
    13651454  { 
    13661455    if (clientsSet.find(contextClient)==clientsSet.end()) 
     
    13701459    } 
    13711460  } 
     1461  CATCH_DUMP_ATTR 
    13721462 
    13731463  void CAxis::parse(xml::CXMLNode & node) 
     1464  TRY 
    13741465  { 
    13751466    SuperClass::parse(node); 
     
    14021493    } 
    14031494  } 
     1495  CATCH_DUMP_ATTR 
    14041496 
    14051497  DEFINE_REF_FUNC(Axis,axis) 
  • XIOS/dev/dev_olga/src/node/context.cpp

    r1542 r1612  
    3333      , idServer_(), client(0), server(0) 
    3434      , allProcessed(false), countChildCtx_(0) 
     35 
    3536   { /* Ne rien faire de plus */ } 
    3637 
     
    6566   */ 
    6667   CContextGroup* CContext::getRoot(void) 
     68   TRY 
    6769   { 
    6870      if (root.get()==NULL) root=std::shared_ptr<CContextGroup>(new CContextGroup(xml::CXMLNode::GetRootName())); 
    6971      return root.get(); 
    7072   } 
     73   CATCH 
    7174 
    7275   //---------------------------------------------------------------- 
     
    7780   */ 
    7881   std::shared_ptr<CCalendar> CContext::getCalendar(void) const 
     82   TRY 
    7983   { 
    8084      return (this->calendar); 
    8185   } 
     86   CATCH 
    8287 
    8388   //---------------------------------------------------------------- 
     
    8893   */ 
    8994   void CContext::setCalendar(std::shared_ptr<CCalendar> newCalendar) 
     95   TRY 
    9096   { 
    9197      this->calendar = newCalendar; 
    9298   } 
     99   CATCH_DUMP_ATTR 
    93100 
    94101   //---------------------------------------------------------------- 
     
    98105   */ 
    99106   void CContext::parse(xml::CXMLNode & node) 
     107   TRY 
    100108   { 
    101109      CContext::SuperClass::parse(node); 
     
    152160      } 
    153161   } 
     162   CATCH_DUMP_ATTR 
    154163 
    155164   //---------------------------------------------------------------- 
    156165   //! Show tree structure of context 
    157166   void CContext::ShowTree(StdOStream & out) 
     167   TRY 
    158168   { 
    159169      StdString currentContextId = CContext::getCurrent() -> getId(); 
     
    176186      CContext::setCurrent(currentContextId); 
    177187   } 
    178  
     188   CATCH 
    179189 
    180190   //---------------------------------------------------------------- 
     
    182192   //! Convert context object into string (to print) 
    183193   StdString CContext::toString(void) const 
     194   TRY 
    184195   { 
    185196      StdOStringStream oss; 
     
    201212 
    202213      } 
    203  
    204214      oss << "</" << CContext::GetName() << " >"; 
    205  
    206215      return (oss.str()); 
    207216   } 
     217   CATCH 
    208218 
    209219   //---------------------------------------------------------------- 
     
    216226   */ 
    217227   void CContext::solveDescInheritance(bool apply, const CAttributeMap * const UNUSED(parent)) 
     228   TRY 
    218229   { 
    219230#define DECLARE_NODE(Name_, name_)    \ 
     
    223234#include "node_type.conf" 
    224235   } 
     236   CATCH_DUMP_ATTR 
    225237 
    226238   //---------------------------------------------------------------- 
     
    228240   //! Verify if all root definition in the context have child. 
    229241   bool CContext::hasChild(void) const 
     242   TRY 
    230243   { 
    231244      return ( 
     
    236249      false); 
    237250} 
     251   CATCH 
    238252 
    239253   //---------------------------------------------------------------- 
    240254 
    241255   void CContext::CleanTree(void) 
     256   TRY 
    242257   { 
    243258#define DECLARE_NODE(Name_, name_) C##Name_##Definition::ClearAllAttributes(); 
     
    245260#include "node_type.conf" 
    246261   } 
     262   CATCH 
     263 
    247264   ///--------------------------------------------------------------- 
    248265 
    249266   //! Initialize client side 
    250267   void CContext::initClient(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtServer /*= 0*/) 
     268   TRY 
    251269   { 
    252270 
     
    298316     } 
    299317   } 
     318   CATCH_DUMP_ATTR 
    300319 
    301320   /*! 
     
    306325  */ 
    307326   void CContext::setClientServerBuffer(CContextClient* contextClient, bool bufferForWriting) 
     327   TRY 
    308328   { 
    309329      // Estimated minimum event size for small events (10 is an arbitrary constant just for safety) 
     
    352372     } 
    353373     contextClient->setBufferSize(bufferSize, maxEventSize); 
    354  
    355    } 
     374   } 
     375   CATCH_DUMP_ATTR 
    356376 
    357377   //! Verify whether a context is initialized 
    358378   bool CContext::isInitialized(void) 
     379   TRY 
    359380   { 
    360381     return hasClient; 
    361382   } 
     383   CATCH_DUMP_ATTR 
    362384 
    363385   void CContext::initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient /*= 0*/) 
     386   TRY 
    364387   { 
    365388     hasServer=true; 
     
    394417     client = new CContextClient(this,intraCommClient,interCommClient, cxtClient); 
    395418   } 
     419   CATCH_DUMP_ATTR 
    396420 
    397421   //! Try to send the buffers and receive possible answers 
    398422  bool CContext::checkBuffersAndListen(bool enableEventsProcessing /*= true*/) 
     423  TRY 
    399424  { 
    400425    bool clientReady, serverFinished; 
     
    434459    } 
    435460  } 
     461   CATCH_DUMP_ATTR 
    436462 
    437463   //! Terminate a context 
    438464   void CContext::finalize(void) 
     465   TRY 
    439466   { 
    440467      if (hasClient && !hasServer) // For now we only use server level 1 to read data 
     
    527554     } 
    528555   } 
     556   CATCH_DUMP_ATTR 
    529557 
    530558   //! Free internally allocated communicators 
    531559   void CContext::freeComms(void) 
     560   TRY 
    532561   { 
    533562     for (std::list<MPI_Comm>::iterator it = comms.begin(); it != comms.end(); ++it) 
     
    535564     comms.clear(); 
    536565   } 
     566   CATCH_DUMP_ATTR 
    537567 
    538568   //! Deallocate buffers allocated by clientContexts 
    539569   void CContext::releaseClientBuffers(void) 
     570   TRY 
    540571   { 
    541572     client->releaseBuffers(); 
     
    543574       clientPrimServer[i]->releaseBuffers(); 
    544575   } 
     576   CATCH_DUMP_ATTR 
    545577 
    546578   void CContext::postProcessingGlobalAttributes() 
     579   TRY 
    547580   { 
    548581     if (allProcessed) return;   
     
    608641     allProcessed = true; 
    609642   } 
     643   CATCH_DUMP_ATTR 
    610644 
    611645   void CContext::sendPostProcessingGlobalAttributes() 
     646   TRY 
    612647   { 
    613648      // Use correct context client to send message 
     
    634669     } 
    635670   } 
     671   CATCH_DUMP_ATTR 
    636672 
    637673   void CContext::recvPostProcessingGlobalAttributes(CEventServer& event) 
     674   TRY 
    638675   { 
    639676      CBufferIn* buffer=event.subEvents.begin()->buffer; 
     
    642679      get(id)->recvPostProcessingGlobalAttributes(*buffer); 
    643680   } 
     681   CATCH 
    644682 
    645683   void CContext::recvPostProcessingGlobalAttributes(CBufferIn& buffer) 
     684   TRY 
    646685   {       
    647686      postProcessingGlobalAttributes(); 
    648687   } 
     688   CATCH_DUMP_ATTR 
    649689 
    650690   /*! 
     
    657697   and the active fields (fields will be written onto active files) 
    658698   */ 
     699 
    659700   void CContext::closeDefinition(void) 
     701   TRY 
    660702   { 
    661703    CTimer::get("Context : close definition").resume() ; 
     
    688730    CTimer::get("Context : close definition").suspend() ; 
    689731   } 
     732   CATCH_DUMP_ATTR 
    690733 
    691734   void CContext::findAllEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles) 
     735   TRY 
    692736   { 
    693737     for (unsigned int i = 0; i < activeFiles.size(); i++) 
    694738     (void)activeFiles[i]->getEnabledFields(); 
    695739   } 
     740   CATCH_DUMP_ATTR 
    696741 
    697742   void CContext::readAttributesOfEnabledFieldsInReadModeFiles() 
     743   TRY 
    698744   { 
    699745      for (unsigned int i = 0; i < this->enabledReadModeFiles.size(); ++i) 
    700746        (void)this->enabledReadModeFiles[i]->readAttributesOfEnabledFieldsInReadMode(); 
    701747   } 
     748   CATCH_DUMP_ATTR 
    702749 
    703750   void CContext::sendGridComponentEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles) 
     751   TRY 
    704752   { 
    705753     int size = activeFiles.size(); 
     
    709757     } 
    710758   } 
     759   CATCH_DUMP_ATTR 
    711760 
    712761   /*! 
     
    715764   */ 
    716765   void CContext::sendGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles) 
     766   TRY 
    717767   { 
    718768     int size = activeFiles.size(); 
     
    722772     } 
    723773   } 
     774   CATCH_DUMP_ATTR 
    724775 
    725776   void CContext::checkGridEnabledFields() 
     777   TRY 
    726778   { 
    727779     int size = enabledFiles.size(); 
     
    731783     } 
    732784   } 
     785   CATCH_DUMP_ATTR 
    733786 
    734787   /*! 
     
    737790   */ 
    738791   void CContext::checkGridEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles) 
     792   TRY 
    739793   { 
    740794     int size = activeFiles.size(); 
     
    744798     } 
    745799   } 
     800   CATCH_DUMP_ATTR 
    746801 
    747802    /*! 
     
    751806   */ 
    752807   void CContext::solveOnlyRefOfEnabledFields(bool sendToServer) 
     808   TRY 
    753809   { 
    754810     int size = this->enabledFiles.size(); 
     
    763819     } 
    764820   } 
     821   CATCH_DUMP_ATTR 
    765822 
    766823    /*! 
     
    771828   */ 
    772829   void CContext::solveAllRefOfEnabledFieldsAndTransform(bool sendToServer) 
     830   TRY 
    773831   { 
    774832     int size = this->enabledFiles.size(); 
     
    778836     } 
    779837   } 
     838   CATCH_DUMP_ATTR 
    780839 
    781840   void CContext::buildFilterGraphOfEnabledFields() 
     841   TRY 
    782842   { 
    783843     int size = this->enabledFiles.size(); 
     
    787847     } 
    788848   } 
     849   CATCH_DUMP_ATTR 
    789850 
    790851   void CContext::postProcessFilterGraph() 
     852   TRY 
    791853   { 
    792854     int size = enabledFiles.size(); 
     
    796858     } 
    797859   } 
     860   CATCH_DUMP_ATTR 
    798861 
    799862   void CContext::startPrefetchingOfEnabledReadModeFiles() 
     863   TRY 
    800864   { 
    801865     int size = enabledReadModeFiles.size(); 
     
    805869     } 
    806870   } 
     871   CATCH_DUMP_ATTR 
    807872 
    808873   void CContext::doPreTimestepOperationsForEnabledReadModeFiles() 
     874   TRY 
    809875   { 
    810876     int size = enabledReadModeFiles.size(); 
     
    814880     } 
    815881   } 
     882   CATCH_DUMP_ATTR 
    816883 
    817884   void CContext::doPostTimestepOperationsForEnabledReadModeFiles() 
     885   TRY 
    818886   { 
    819887     int size = enabledReadModeFiles.size(); 
     
    823891     } 
    824892   } 
     893   CATCH_DUMP_ATTR 
    825894 
    826895  void CContext::findFieldsWithReadAccess(void) 
     896  TRY 
    827897  { 
    828898    fieldsWithReadAccess.clear(); 
     
    838908    } 
    839909  } 
     910  CATCH_DUMP_ATTR 
    840911 
    841912  void CContext::solveAllRefOfFieldsWithReadAccess() 
     913  TRY 
    842914  { 
    843915    for (size_t i = 0; i < fieldsWithReadAccess.size(); ++i) 
    844916      fieldsWithReadAccess[i]->solveAllReferenceEnabledField(false); 
    845917  } 
     918  CATCH_DUMP_ATTR 
    846919 
    847920  void CContext::buildFilterGraphOfFieldsWithReadAccess() 
     921  TRY 
    848922  { 
    849923    for (size_t i = 0; i < fieldsWithReadAccess.size(); ++i) 
    850924      fieldsWithReadAccess[i]->buildFilterGraph(garbageCollector, true); 
    851925  } 
     926  CATCH_DUMP_ATTR 
    852927 
    853928   void CContext::solveAllInheritance(bool apply) 
     929   TRY 
    854930   { 
    855931     // Résolution des héritages descendants (càd des héritages de groupes) 
     
    874950 
    875951   } 
     952  CATCH_DUMP_ATTR 
    876953 
    877954   void CContext::findEnabledFiles(void) 
     955   TRY 
    878956   { 
    879957      const std::vector<CFile*> allFiles = CFile::getAll(); 
     
    9241002 
    9251003   } 
     1004   CATCH_DUMP_ATTR 
    9261005 
    9271006   void CContext::distributeFiles(void) 
     1007   TRY 
    9281008   { 
    9291009     bool distFileMemory=false ; 
     
    9331013     else distributeFileOverBandwith() ; 
    9341014   } 
    935  
     1015   CATCH_DUMP_ATTR 
    9361016 
    9371017   void CContext::distributeFileOverBandwith(void) 
     1018   TRY 
    9381019   { 
    9391020     double eps=std::numeric_limits<double>::epsilon()*10 ; 
     
    10151096     } 
    10161097   } 
     1098   CATCH_DUMP_ATTR 
    10171099 
    10181100   void CContext::distributeFileOverMemoryBandwith(void) 
     1101   TRY 
    10191102   { 
    10201103     // If primary server 
     
    11071190   } 
    11081191} 
    1109  
    1110  
     1192   CATCH_DUMP_ATTR 
    11111193 
    11121194   /*! 
     
    11141196   */ 
    11151197   void CContext::findEnabledWriteModeFiles(void) 
     1198   TRY 
    11161199   { 
    11171200     int size = this->enabledFiles.size(); 
     
    11231206     } 
    11241207   } 
     1208   CATCH_DUMP_ATTR 
    11251209 
    11261210   /*! 
     
    11281212   */ 
    11291213   void CContext::findEnabledReadModeFiles(void) 
     1214   TRY 
    11301215   { 
    11311216     int size = this->enabledFiles.size(); 
     
    11361221     } 
    11371222   } 
     1223   CATCH_DUMP_ATTR 
    11381224 
    11391225   void CContext::closeAllFile(void) 
     1226   TRY 
    11401227   { 
    11411228     std::vector<CFile*>::const_iterator 
     
    11481235     } 
    11491236   } 
     1237   CATCH_DUMP_ATTR 
    11501238 
    11511239   /*! 
     
    11571245   */ 
    11581246   bool CContext::dispatchEvent(CEventServer& event) 
     1247   TRY 
    11591248   { 
    11601249 
     
    11981287      } 
    11991288   } 
     1289   CATCH 
    12001290 
    12011291   //! Client side: Send a message to server to make it close 
    12021292   void CContext::sendCloseDefinition(void) 
     1293   TRY 
    12031294   { 
    12041295     // Use correct context client to send message 
     
    12231314     } 
    12241315   } 
     1316   CATCH_DUMP_ATTR 
    12251317 
    12261318   //! Server side: Receive a message of client announcing a context close 
    12271319   void CContext::recvCloseDefinition(CEventServer& event) 
     1320   TRY 
    12281321   { 
    12291322      CBufferIn* buffer=event.subEvents.begin()->buffer; 
     
    12321325      get(id)->closeDefinition(); 
    12331326   } 
     1327   CATCH 
    12341328 
    12351329   //! Client side: Send a message to update calendar in each time step 
    12361330   void CContext::sendUpdateCalendar(int step) 
     1331   TRY 
    12371332   { 
    12381333     // Use correct context client to send message 
     
    12581353     } 
    12591354   } 
     1355   CATCH_DUMP_ATTR 
    12601356 
    12611357   //! Server side: Receive a message of client annoucing calendar update 
    12621358   void CContext::recvUpdateCalendar(CEventServer& event) 
     1359   TRY 
    12631360   { 
    12641361      CBufferIn* buffer=event.subEvents.begin()->buffer; 
     
    12671364      get(id)->recvUpdateCalendar(*buffer); 
    12681365   } 
     1366   CATCH 
    12691367 
    12701368   //! Server side: Receive a message of client annoucing calendar update 
    12711369   void CContext::recvUpdateCalendar(CBufferIn& buffer) 
     1370   TRY 
    12721371   { 
    12731372      int step; 
     
    12791378      } 
    12801379   } 
     1380   CATCH_DUMP_ATTR 
    12811381 
    12821382   //! Client side: Send a message to create header part of netcdf file 
    12831383   void CContext::sendCreateFileHeader(void) 
     1384   TRY 
    12841385   { 
    12851386     // Use correct context client to send message 
     
    13061407     } 
    13071408   } 
     1409   CATCH_DUMP_ATTR 
    13081410 
    13091411   //! Server side: Receive a message of client annoucing the creation of header part of netcdf file 
    13101412   void CContext::recvCreateFileHeader(CEventServer& event) 
     1413   TRY 
    13111414   { 
    13121415      CBufferIn* buffer=event.subEvents.begin()->buffer; 
     
    13151418      get(id)->recvCreateFileHeader(*buffer); 
    13161419   } 
     1420   CATCH 
    13171421 
    13181422   //! Server side: Receive a message of client annoucing the creation of header part of netcdf file 
    13191423   void CContext::recvCreateFileHeader(CBufferIn& buffer) 
     1424   TRY 
    13201425   { 
    13211426      if (!hasClient && hasServer)  
    13221427        createFileHeader(); 
    13231428   } 
     1429   CATCH_DUMP_ATTR 
    13241430 
    13251431   //! Client side: Send a message to do some post processing on server 
    13261432   void CContext::sendProcessingGridOfEnabledFields() 
     1433   TRY 
    13271434   { 
    13281435      // Use correct context client to send message 
     
    13481455     } 
    13491456   } 
     1457   CATCH_DUMP_ATTR 
    13501458 
    13511459   //! Server side: Receive a message to do some post processing 
    13521460   void CContext::recvProcessingGridOfEnabledFields(CEventServer& event) 
     1461   TRY 
    13531462   { 
    13541463      CBufferIn* buffer=event.subEvents.begin()->buffer; 
     
    13561465      *buffer>>id;       
    13571466   } 
     1467   CATCH 
    13581468 
    13591469   //! Client side: Send a message to do some post processing on server 
    13601470   void CContext::sendPostProcessing() 
     1471   TRY 
    13611472   { 
    13621473      // Use correct context client to send message 
     
    13821493     } 
    13831494   } 
     1495   CATCH_DUMP_ATTR 
    13841496 
    13851497   //! Server side: Receive a message to do some post processing 
    13861498   void CContext::recvPostProcessing(CEventServer& event) 
     1499   TRY 
    13871500   { 
    13881501      CBufferIn* buffer=event.subEvents.begin()->buffer; 
     
    13911504      get(id)->recvPostProcessing(*buffer); 
    13921505   } 
     1506   CATCH 
    13931507 
    13941508   //! Server side: Receive a message to do some post processing 
    13951509   void CContext::recvPostProcessing(CBufferIn& buffer) 
     1510   TRY 
    13961511   { 
    13971512      CCalendarWrapper::get(CCalendarWrapper::GetDefName())->createCalendar(); 
    13981513      postProcessing(); 
    13991514   } 
     1515   CATCH_DUMP_ATTR 
    14001516 
    14011517   const StdString& CContext::getIdServer() 
     1518   TRY 
    14021519   { 
    14031520      if (hasClient) 
     
    14091526      if (hasServer) return (this->getId()); 
    14101527   } 
     1528   CATCH_DUMP_ATTR 
    14111529 
    14121530   const StdString& CContext::getIdServer(const int i) 
     1531   TRY 
    14131532   { 
    14141533     idServer_ = this->getId(); 
     
    14171536     return idServer_; 
    14181537   } 
    1419  
     1538   CATCH_DUMP_ATTR 
    14201539 
    14211540   /*! 
     
    14261545   */ 
    14271546   void CContext::postProcessing() 
     1547   TRY 
    14281548   { 
    14291549     if (isPostProcessed) return; 
     
    14881608      isPostProcessed = true; 
    14891609   } 
     1610   CATCH_DUMP_ATTR 
    14901611 
    14911612   /*! 
     
    14981619   std::map<int, StdSize> CContext::getAttributesBufferSize(std::map<int, StdSize>& maxEventSize, 
    14991620                                                           CContextClient* contextClient, bool bufferForWriting /*= "false"*/) 
     1621   TRY 
    15001622   { 
    15011623         // As calendar attributes are sent even if there are no active files or fields, maps are initialized according the size of calendar attributes 
     
    15291651     return attributesSize; 
    15301652   } 
     1653   CATCH_DUMP_ATTR 
    15311654 
    15321655   /*! 
     
    15391662   std::map<int, StdSize> CContext::getDataBufferSize(std::map<int, StdSize>& maxEventSize, 
    15401663                                                      CContextClient* contextClient, bool bufferForWriting /*= "false"*/) 
     1664   TRY 
    15411665   { 
    15421666     std::map<int, StdSize> dataSize; 
     
    15471671     for (size_t i = 0; i < numEnabledFiles; ++i) 
    15481672     { 
    1549 //       CFile* file = this->enabledFiles[i]; 
    15501673       CFile* file = fileList[i]; 
    15511674       if (file->getContextClient() == contextClient) 
     
    15751698     return dataSize; 
    15761699   } 
     1700   CATCH_DUMP_ATTR 
    15771701 
    15781702   //! Client side: Send infomation of active files (files are enabled to write out) 
    15791703   void CContext::sendEnabledFiles(const std::vector<CFile*>& activeFiles) 
     1704   TRY 
    15801705   { 
    15811706     int size = activeFiles.size(); 
     
    15951720     } 
    15961721   } 
     1722   CATCH_DUMP_ATTR 
    15971723 
    15981724   //! Client side: Send information of active fields (ones are written onto files) 
    15991725   void CContext::sendEnabledFieldsInFiles(const std::vector<CFile*>& activeFiles) 
     1726   TRY 
    16001727   { 
    16011728     int size = activeFiles.size(); 
     
    16051732     } 
    16061733   } 
     1734   CATCH_DUMP_ATTR 
    16071735 
    16081736   //! Client side: Check if the defined axis, domains and grids are eligible for compressed indexed output 
    16091737   void CContext::checkAxisDomainsGridsEligibilityForCompressedOutput() 
     1738   TRY 
    16101739   { 
    16111740     if (!hasClient) return; 
     
    16231752       (*it)->checkEligibilityForCompressedOutput(); 
    16241753   } 
     1754   CATCH_DUMP_ATTR 
    16251755 
    16261756   //! Client side: Prepare the timeseries by adding the necessary files 
    16271757   void CContext::prepareTimeseries() 
     1758   TRY 
    16281759   { 
    16291760     if (!hasClient) return; 
     
    17231854     } 
    17241855   } 
     1856   CATCH_DUMP_ATTR 
    17251857 
    17261858   //! Client side: Send information of reference grid of active fields 
    17271859   void CContext::sendRefGrid(const std::vector<CFile*>& activeFiles) 
     1860   TRY 
    17281861   { 
    17291862     std::set<StdString> gridIds; 
     
    17571890     } 
    17581891   } 
     1892   CATCH_DUMP_ATTR 
    17591893 
    17601894   //! Client side: Send information of reference domain, axis and scalar of active fields 
    17611895   void CContext::sendRefDomainsAxisScalars(const std::vector<CFile*>& activeFiles) 
     1896   TRY 
    17621897   { 
    17631898     std::set<StdString> domainIds, axisIds, scalarIds; 
     
    18181953     } 
    18191954   } 
     1955   CATCH_DUMP_ATTR 
    18201956 
    18211957   //! Update calendar in each time step 
    18221958   void CContext::updateCalendar(int step) 
     1959   TRY 
    18231960   { 
    18241961      int prevStep = calendar->getStep(); 
     
    18501987              << "Illegal calendar update: previous step was " << prevStep << ", new step " << step << "is in the past!") 
    18511988   } 
     1989   CATCH_DUMP_ATTR 
    18521990 
    18531991   void CContext::initReadFiles(void) 
     1992   TRY 
    18541993   { 
    18551994      vector<CFile*>::const_iterator it; 
     
    18601999      } 
    18612000   } 
     2001   CATCH_DUMP_ATTR 
    18622002 
    18632003   //! Server side: Create header of netcdf file 
    18642004   void CContext::createFileHeader(void) 
     2005   TRY 
    18652006   { 
    18662007      vector<CFile*>::const_iterator it; 
     
    18722013      } 
    18732014   } 
     2015   CATCH_DUMP_ATTR 
    18742016 
    18752017   //! Get current context 
    18762018   CContext* CContext::getCurrent(void) 
     2019   TRY 
    18772020   { 
    18782021     return CObjectFactory::GetObject<CContext>(CObjectFactory::GetCurrentContextId()).get(); 
    18792022   } 
     2023   CATCH 
    18802024 
    18812025   /*! 
     
    18842028   */ 
    18852029   void CContext::setCurrent(const string& id) 
     2030   TRY 
    18862031   { 
    18872032     CObjectFactory::SetCurrentContextId(id); 
    18882033     CGroupFactory::SetCurrentContextId(id); 
    18892034   } 
     2035   CATCH 
    18902036 
    18912037  /*! 
     
    18952041  */ 
    18962042  CContext* CContext::create(const StdString& id) 
     2043  TRY 
    18972044  { 
    18982045    CContext::setCurrent(id); 
     
    19102057    return (context); 
    19112058  } 
    1912  
     2059  CATCH 
    19132060 
    19142061     //! Server side: Receive a message to do some post processing 
    19152062  void CContext::recvRegistry(CEventServer& event) 
     2063  TRY 
    19162064  { 
    19172065    CBufferIn* buffer=event.subEvents.begin()->buffer; 
     
    19202068    get(id)->recvRegistry(*buffer); 
    19212069  } 
     2070  CATCH 
    19222071 
    19232072  void CContext::recvRegistry(CBufferIn& buffer) 
     2073  TRY 
    19242074  { 
    19252075    if (server->intraCommRank==0) 
     
    19302080    } 
    19312081  } 
     2082  CATCH_DUMP_ATTR 
    19322083 
    19332084  void CContext::sendRegistry(void) 
     2085  TRY 
    19342086  { 
    19352087    registryOut->hierarchicalGatherRegistry() ; 
     
    19572109    } 
    19582110  } 
     2111  CATCH_DUMP_ATTR 
    19592112 
    19602113  /*! 
     
    19632116  */ 
    19642117  bool CContext::isFinalized(void) 
     2118  TRY 
    19652119  { 
    19662120    return finalized; 
    19672121  } 
     2122  CATCH_DUMP_ATTR 
     2123  ///-------------------------------------------------------------- 
     2124  StdString CContext::dumpClassAttributes(void) 
     2125  { 
     2126    StdString str; 
     2127    str.append("enabled files=\""); 
     2128    int size = this->enabledFiles.size(); 
     2129    for (int i = 0; i < size; ++i) 
     2130    { 
     2131      str.append(enabledFiles[i]->getId()); 
     2132      str.append(" "); 
     2133    } 
     2134    str.append("\""); 
     2135    return str; 
     2136  } 
    19682137 
    19692138} // namespace xios 
  • XIOS/dev/dev_olga/src/node/context.hpp

    r1542 r1612  
    9191         void initServer(MPI_Comm intraComm, MPI_Comm interComm, CContext* cxtClient = 0); 
    9292         bool isInitialized(void); 
     93 
     94         StdString dumpClassAttributes(void); 
    9395 
    9496         // Put sever or client into loop state 
     
    143145         void distributeFileOverMemoryBandwith() ; 
    144146          
    145  
    146147         // Send context close definition 
    147148         void sendCloseDefinition(void); 
  • XIOS/dev/dev_olga/src/node/domain.cpp

    r1600 r1612  
    5858 
    5959   void CDomain::assignMesh(const StdString meshName, const int nvertex) 
     60   TRY 
    6061   { 
    6162     mesh = CMesh::getMesh(meshName, nvertex); 
    6263   } 
     64   CATCH_DUMP_ATTR 
    6365 
    6466   CDomain* CDomain::createDomain() 
     67   TRY 
    6568   { 
    6669     CDomain* domain = CDomainGroup::get("domain_definition")->createChild(); 
    6770     return domain; 
    6871   } 
     72   CATCH 
    6973 
    7074   std::map<StdString, ETranformationType> CDomain::transformationMapList_ = std::map<StdString, ETranformationType>(); 
     
    7276 
    7377   bool CDomain::initializeTransformationMap(std::map<StdString, ETranformationType>& m) 
     78   TRY 
    7479   { 
    7580     m["zoom_domain"] = TRANS_ZOOM_DOMAIN; 
     
    8186     m["extract_domain"] = TRANS_EXTRACT_DOMAIN; 
    8287   } 
     88   CATCH 
    8389 
    8490   const std::set<StdString> & CDomain::getRelFiles(void) const 
     91   TRY 
    8592   { 
    8693      return (this->relFiles); 
    8794   } 
    88  
     95   CATCH 
    8996 
    9097   /*! 
     
    93100   */ 
    94101   int CDomain::getNumberWrittenIndexes(MPI_Comm writtenCom) 
     102   TRY 
    95103   { 
    96104     int writtenSize; 
     
    98106     return numberWrittenIndexes_[writtenSize]; 
    99107   } 
     108   CATCH_DUMP_ATTR 
    100109 
    101110   /*! 
     
    104113   */ 
    105114   int CDomain::getTotalNumberWrittenIndexes(MPI_Comm writtenCom) 
     115   TRY 
    106116   { 
    107117     int writtenSize; 
     
    109119     return totalNumberWrittenIndexes_[writtenSize]; 
    110120   } 
     121   CATCH_DUMP_ATTR 
    111122 
    112123   /*! 
     
    115126   */ 
    116127   int CDomain::getOffsetWrittenIndexes(MPI_Comm writtenCom) 
     128   TRY 
    117129   { 
    118130     int writtenSize; 
     
    120132     return offsetWrittenIndexes_[writtenSize]; 
    121133   } 
     134   CATCH_DUMP_ATTR 
    122135 
    123136   CArray<int, 1>& CDomain::getCompressedIndexToWriteOnServer(MPI_Comm writtenCom) 
     137   TRY 
    124138   { 
    125139     int writtenSize; 
     
    127141     return compressedIndexToWriteOnServer[writtenSize]; 
    128142   } 
     143   CATCH_DUMP_ATTR 
    129144 
    130145   //---------------------------------------------------------------- 
     
    136151    */ 
    137152   std::map<int, StdSize> CDomain::getAttributesBufferSize(CContextClient* client, bool bufferForWriting /*= false*/) 
     153   TRY 
    138154   { 
    139155 
     
    176192     return attributesSizes; 
    177193   } 
     194   CATCH_DUMP_ATTR 
    178195 
    179196   //---------------------------------------------------------------- 
    180197 
    181198   bool CDomain::isEmpty(void) const 
     199   TRY 
    182200   { 
    183201     return ((this->i_index.isEmpty()) || (0 == this->i_index.numElements())); 
    184202   } 
     203   CATCH 
    185204 
    186205   //---------------------------------------------------------------- 
    187206 
    188207   bool CDomain::IsWritten(const StdString & filename) const 
     208   TRY 
    189209   { 
    190210      return (this->relFiles.find(filename) != this->relFiles.end()); 
    191211   } 
     212   CATCH 
    192213 
    193214   bool CDomain::isWrittenCompressed(const StdString& filename) const 
     215   TRY 
    194216   { 
    195217      return (this->relFilesCompressed.find(filename) != this->relFilesCompressed.end()); 
    196218   } 
     219   CATCH 
    197220 
    198221   //---------------------------------------------------------------- 
    199222 
    200223   bool CDomain::isDistributed(void) const 
     224   TRY 
    201225   { 
    202226      bool distributed =  !((!ni.isEmpty() && (ni == ni_glo) && !nj.isEmpty() && (nj == nj_glo)) || 
     
    206230      return distributed; 
    207231   } 
     232   CATCH 
    208233 
    209234   //---------------------------------------------------------------- 
     
    215240    */ 
    216241   bool CDomain::isCompressible(void) const 
     242   TRY 
    217243   { 
    218244      return isCompressible_; 
    219245   } 
     246   CATCH 
    220247 
    221248   void CDomain::addRelFile(const StdString & filename) 
     249   TRY 
    222250   { 
    223251      this->relFiles.insert(filename); 
    224252   } 
     253   CATCH_DUMP_ATTR 
    225254 
    226255   void CDomain::addRelFileCompressed(const StdString& filename) 
     256   TRY 
    227257   { 
    228258      this->relFilesCompressed.insert(filename); 
    229259   } 
     260   CATCH_DUMP_ATTR 
    230261 
    231262   StdString CDomain::GetName(void)   { return (StdString("domain")); } 
     
    240271   */ 
    241272   bool CDomain::distributionAttributesHaveValue() const 
     273   TRY 
    242274   { 
    243275      bool hasValues = true; 
     
    251283      return hasValues; 
    252284   } 
     285   CATCH 
    253286 
    254287   /*! 
     
    260293   */ 
    261294   void CDomain::redistribute(int nbLocalDomain) 
     295   TRY 
    262296   { 
    263297     if (this->isRedistributed_) return; 
     
    422456     checkDomain(); 
    423457   } 
     458   CATCH_DUMP_ATTR 
    424459 
    425460   /*! 
     
    427462   */ 
    428463   void CDomain::fillInLonLat() 
     464   TRY 
    429465   { 
    430466     switch (type) 
     
    444480     } 
    445481     completeLonLatClient() ; 
    446  
    447    } 
     482   } 
     483   CATCH_DUMP_ATTR 
    448484 
    449485   /*! 
     
    453489   */ 
    454490   void CDomain::fillInRectilinearLonLat() 
     491   TRY 
    455492   { 
    456493     if (!lonvalue_rectilinear_read_from_file.isEmpty() && lonvalue_2d.isEmpty() && lonvalue_1d.isEmpty()) 
     
    462499       lon_end.setValue(lonvalue_rectilinear_read_from_file(ni_glo-1)); 
    463500     } 
    464      else 
     501     else if (!hasLonInReadFile_) 
    465502     { 
    466503       if (!lonvalue_2d.isEmpty()) lonvalue_2d.free(); 
     
    496533       lat_end.setValue(latvalue_rectilinear_read_from_file(nj_glo-1)); 
    497534     } 
    498      else 
     535     else if (!hasLatInReadFile_) 
    499536     { 
    500537       if (!latvalue_2d.isEmpty()) latvalue_1d.free(); 
     
    521558     } 
    522559   } 
     560   CATCH_DUMP_ATTR 
    523561 
    524562    /* 
     
    527565    */ 
    528566   void CDomain::fillInCurvilinearLonLat() 
     567   TRY 
    529568   { 
    530569     if (!lonvalue_curvilinear_read_from_file.isEmpty() && lonvalue_2d.isEmpty() && lonvalue_1d.isEmpty()) 
     
    569608       bounds_latvalue_curvilinear_read_from_file.free(); 
    570609     } 
    571  
    572    } 
     610   } 
     611   CATCH_DUMP_ATTR 
    573612 
    574613    /* 
     
    577616    */ 
    578617   void CDomain::fillInUnstructuredLonLat() 
     618   TRY 
    579619   { 
    580620     if (i_index.isEmpty()) 
     
    628668     } 
    629669   } 
     670   CATCH_DUMP_ATTR 
    630671 
    631672  /* 
     
    633674  */ 
    634675   void CDomain::AllgatherRectilinearLonLat(CArray<double,1>& lon, CArray<double,1>& lat, CArray<double,1>& lon_g, CArray<double,1>& lat_g) 
     676   TRY 
    635677   { 
    636678     CContext* context = CContext::getCurrent(); 
     
    664706      delete[] nj_g ; 
    665707   } 
     708   CATCH_DUMP_ATTR 
    666709 
    667710   void CDomain::fillInRectilinearBoundLonLat(CArray<double,1>& lon, CArray<double,1>& lat, 
    668711                                              CArray<double,2>& boundsLon, CArray<double,2>& boundsLat) 
    669    { 
     712   TRY 
     713  { 
    670714     int i,j,k; 
    671715 
     
    766810      } 
    767811   } 
     812   CATCH_DUMP_ATTR 
    768813 
    769814   /* 
     
    771816   */ 
    772817   void CDomain::checkDomain(void) 
     818   TRY 
    773819   { 
    774820     if (type.isEmpty()) 
     
    862908     } 
    863909   } 
     910   CATCH_DUMP_ATTR 
    864911 
    865912   size_t CDomain::getGlobalWrittenSize(void) 
     
    871918   // Check validity of local domain on using the combination of 3 parameters: ibegin, ni and i_index 
    872919   void CDomain::checkLocalIDomain(void) 
     920   TRY 
    873921   { 
    874922      // If ibegin and ni are provided then we use them to check the validity of local domain 
     
    929977      } 
    930978   } 
     979   CATCH_DUMP_ATTR 
    931980 
    932981   // Check validity of local domain on using the combination of 3 parameters: jbegin, nj and j_index 
    933982   void CDomain::checkLocalJDomain(void) 
     983   TRY 
    934984   { 
    935985    // If jbegin and nj are provided then we use them to check the validity of local domain 
     
    9801030     } 
    9811031   } 
     1032   CATCH_DUMP_ATTR 
    9821033 
    9831034   //---------------------------------------------------------------- 
    9841035 
    9851036   void CDomain::checkMask(void) 
     1037   TRY 
    9861038   { 
    9871039      if (!mask_1d.isEmpty() && !mask_2d.isEmpty()) 
     
    10291081     } 
    10301082   } 
     1083   CATCH_DUMP_ATTR 
    10311084 
    10321085   //---------------------------------------------------------------- 
    10331086 
    10341087   void CDomain::checkDomainData(void) 
     1088   TRY 
    10351089   { 
    10361090      if (data_dim.isEmpty()) 
     
    10721126      } 
    10731127   } 
     1128   CATCH_DUMP_ATTR 
    10741129 
    10751130   //---------------------------------------------------------------- 
    10761131 
    10771132   void CDomain::checkCompression(void) 
     1133   TRY 
    10781134   { 
    10791135     int i,j,ind; 
     
    12021258      } 
    12031259   } 
     1260   CATCH_DUMP_ATTR 
    12041261 
    12051262   //---------------------------------------------------------------- 
    12061263   void CDomain::computeLocalMask(void) 
     1264   TRY 
    12071265   { 
    12081266     localMask.resize(i_index.numElements()) ; 
     
    12361294     } 
    12371295   } 
     1296   CATCH_DUMP_ATTR 
    12381297 
    12391298   void CDomain::checkEligibilityForCompressedOutput(void) 
     1299   TRY 
    12401300   { 
    12411301     // We don't check if the mask or the indexes are valid here, just if they have been defined at this point. 
    12421302     isCompressible_ = !mask_1d.isEmpty() || !mask_2d.isEmpty() || !data_i_index.isEmpty(); 
    12431303   } 
     1304   CATCH_DUMP_ATTR 
    12441305 
    12451306   //---------------------------------------------------------------- 
     
    12501311   */ 
    12511312   void CDomain::completeLonLatClient(void) 
     1313   TRY 
    12521314   { 
    12531315     bool lonlatValueExisted = (0 != lonvalue.numElements()) || (0 != latvalue.numElements()); 
     
    13631425     } 
    13641426   } 
     1427   CATCH_DUMP_ATTR 
    13651428 
    13661429   /* 
     
    13681431   */ 
    13691432   void CDomain::convertLonLatValue(void) 
     1433   TRY 
    13701434   { 
    13711435     bool lonlatValueExisted = (0 != lonvalue.numElements()) || (0 != latvalue.numElements()); 
     
    14651529     } 
    14661530   } 
    1467  
     1531   CATCH_DUMP_ATTR 
    14681532 
    14691533   void CDomain::checkBounds(void) 
     1534   TRY 
    14701535   { 
    14711536     bool hasBoundValues = (0 != bounds_lonvalue.numElements()) || (0 != bounds_latvalue.numElements()); 
     
    15591624     } 
    15601625   } 
     1626   CATCH_DUMP_ATTR 
    15611627 
    15621628   void CDomain::checkArea(void) 
     1629   TRY 
    15631630   { 
    15641631     bool hasAreaValue = (!areavalue.isEmpty() && 0 != areavalue.numElements()); 
     
    15881655     } 
    15891656   } 
     1657   CATCH_DUMP_ATTR 
    15901658 
    15911659   void CDomain::checkLonLat() 
     1660   TRY 
    15921661   { 
    15931662     if (!hasLonLat) hasLonLat = (!latvalue_1d.isEmpty() && !lonvalue_1d.isEmpty()) || 
     
    16491718     } 
    16501719   } 
     1720   CATCH_DUMP_ATTR 
    16511721 
    16521722   void CDomain::checkAttributesOnClientAfterTransformation() 
     1723   TRY 
    16531724   { 
    16541725     CContext* context=CContext::getCurrent() ; 
     
    16651736     this->isClientAfterTransformationChecked = true; 
    16661737   } 
     1738   CATCH_DUMP_ATTR 
    16671739 
    16681740   //---------------------------------------------------------------- 
     
    16701742   // This function only checks all attributes of current domain 
    16711743   void CDomain::checkAttributesOnClient() 
     1744   TRY 
    16721745   { 
    16731746     if (this->isClientChecked) return; 
     
    16951768      this->isClientChecked = true; 
    16961769   } 
     1770   CATCH_DUMP_ATTR 
    16971771 
    16981772   // Send all checked attributes to server 
    16991773   void CDomain::sendCheckedAttributes() 
     1774   TRY 
    17001775   { 
    17011776     if (!this->isClientChecked) checkAttributesOnClient(); 
     
    17101785     this->isChecked = true; 
    17111786   } 
     1787   CATCH_DUMP_ATTR 
    17121788 
    17131789   void CDomain::checkAttributes(void) 
     1790   TRY 
    17141791   { 
    17151792      if (this->isChecked) return; 
     
    17411818      this->isChecked = true; 
    17421819   } 
     1820   CATCH_DUMP_ATTR 
    17431821 
    17441822  /*! 
     
    17491827  */ 
    17501828  void CDomain::computeConnectedClients() 
     1829  TRY 
    17511830  { 
    17521831    CContext* context=CContext::getCurrent() ; 
     
    18761955    } 
    18771956  } 
     1957  CATCH_DUMP_ATTR 
    18781958 
    18791959   /*! 
     
    18831963   */ 
    18841964   void CDomain::computeWrittenIndex() 
     1965   TRY 
    18851966   {   
    18861967      if (computedWrittenIndex_) return; 
     
    19202001      } 
    19212002   } 
     2003   CATCH_DUMP_ATTR 
    19222004 
    19232005  void CDomain::computeWrittenCompressedIndex(MPI_Comm writtenComm) 
     2006  TRY 
    19242007  { 
    19252008    int writtenCommSize; 
     
    19892072      } 
    19902073  } 
     2074  CATCH_DUMP_ATTR 
    19912075 
    19922076  /*! 
     
    19952079  */ 
    19962080  void CDomain::sendAttributes() 
     2081  TRY 
    19972082  { 
    19982083    sendDistributionAttributes(); 
     
    20022087    sendDataIndex(); 
    20032088  } 
    2004  
     2089  CATCH 
    20052090  /*! 
    20062091    Send global index from client to connected client(s) 
    20072092  */ 
    20082093  void CDomain::sendIndex() 
     2094  TRY 
    20092095  { 
    20102096    int ns, n, i, j, ind, nv, idx; 
     
    20492135    } 
    20502136  } 
     2137  CATCH_DUMP_ATTR 
    20512138 
    20522139  /*! 
     
    20562143  */ 
    20572144  void CDomain::sendDistributionAttributes(void) 
     2145  TRY 
    20582146  { 
    20592147    std::list<CContextClient*>::iterator it; 
     
    21022190    } 
    21032191  } 
     2192  CATCH_DUMP_ATTR 
    21042193 
    21052194  /*! 
     
    21072196  */ 
    21082197  void CDomain::sendArea() 
     2198  TRY 
    21092199  { 
    21102200    if (!hasArea) return; 
     
    21502240    } 
    21512241  } 
     2242  CATCH_DUMP_ATTR 
    21522243 
    21532244  /*! 
     
    21572248  */ 
    21582249  void CDomain::sendLonLat() 
     2250  TRY 
    21592251  { 
    21602252    if (!hasLonLat) return; 
     
    22452337    } 
    22462338  } 
     2339  CATCH_DUMP_ATTR 
    22472340 
    22482341  /*! 
     
    22532346  */ 
    22542347  void CDomain::sendDataIndex() 
     2348  TRY 
    22552349  { 
    22562350    int ns, n, i, j, ind, nv, idx; 
     
    23212415    } 
    23222416  } 
     2417  CATCH 
    23232418   
    23242419  bool CDomain::dispatchEvent(CEventServer& event) 
     2420  TRY 
    23252421  { 
    23262422    if (SuperClass::dispatchEvent(event)) return true; 
     
    23602456    } 
    23612457  } 
     2458  CATCH 
    23622459 
    23632460  /*! 
     
    23662463  */ 
    23672464  void CDomain::recvIndex(CEventServer& event) 
     2465  TRY 
    23682466  { 
    23692467    string domainId; 
     
    23792477    get(domainId)->recvIndex(rankBuffers); 
    23802478  } 
     2479  CATCH 
    23812480 
    23822481  /*! 
     
    23862485  */ 
    23872486  void CDomain::recvIndex(std::map<int, CBufferIn*>& rankBuffers) 
     2487  TRY 
    23882488  { 
    23892489    int nbReceived = rankBuffers.size(), i, ind, index, type_int, iIndex, jIndex; 
     
    24452545    domainMask.resize(0); // Mask is not defined anymore on servers 
    24462546  } 
     2547  CATCH 
    24472548 
    24482549  /*! 
     
    24512552  */ 
    24522553  void CDomain::recvDistributionAttributes(CEventServer& event) 
     2554  TRY 
    24532555  { 
    24542556    CBufferIn* buffer=event.subEvents.begin()->buffer; 
     
    24572559    get(domainId)->recvDistributionAttributes(*buffer); 
    24582560  } 
     2561  CATCH 
    24592562 
    24602563  /*! 
     
    24642567  */ 
    24652568  void CDomain::recvDistributionAttributes(CBufferIn& buffer) 
     2569  TRY 
    24662570  { 
    24672571    int ni_tmp, ibegin_tmp, nj_tmp, jbegin_tmp; 
     
    24792583 
    24802584  } 
    2481  
     2585 CATCH_DUMP_ATTR 
    24822586  /*! 
    24832587    Receive longitude event from clients(s) 
     
    24852589  */ 
    24862590  void CDomain::recvLon(CEventServer& event) 
     2591  TRY 
    24872592  { 
    24882593    string domainId; 
     
    24982603    get(domainId)->recvLon(rankBuffers); 
    24992604  } 
     2605  CATCH 
    25002606 
    25012607  /*! 
     
    25042610  */ 
    25052611  void CDomain::recvLon(std::map<int, CBufferIn*>& rankBuffers) 
     2612  TRY 
    25062613  { 
    25072614    int nbReceived = rankBuffers.size(), i, ind, index, iindex, jindex, lInd; 
     
    25632670    } 
    25642671  } 
     2672  CATCH_DUMP_ATTR 
    25652673 
    25662674  /*! 
     
    25692677  */ 
    25702678  void CDomain::recvLat(CEventServer& event) 
     2679  TRY 
    25712680  { 
    25722681    string domainId; 
     
    25822691    get(domainId)->recvLat(rankBuffers); 
    25832692  } 
     2693  CATCH 
    25842694 
    25852695  /*! 
     
    25882698  */ 
    25892699  void CDomain::recvLat(std::map<int, CBufferIn*>& rankBuffers) 
     2700  TRY 
    25902701  { 
    25912702    int nbReceived = rankBuffers.size(), i, ind, index, iindex, jindex, lInd; 
     
    26492760    } 
    26502761  } 
     2762  CATCH_DUMP_ATTR 
    26512763 
    26522764  /*! 
     
    26552767  */ 
    26562768  void CDomain::recvArea(CEventServer& event) 
     2769  TRY 
    26572770  { 
    26582771    string domainId; 
     
    26682781    get(domainId)->recvArea(rankBuffers); 
    26692782  } 
     2783  CATCH 
    26702784 
    26712785  /*! 
     
    26742788  */ 
    26752789  void CDomain::recvArea(std::map<int, CBufferIn*>& rankBuffers) 
     2790  TRY 
    26762791  { 
    26772792    int nbReceived = rankBuffers.size(), i, ind, index, lInd; 
     
    27192834    } 
    27202835  } 
     2836  CATCH_DUMP_ATTR 
    27212837 
    27222838  /*! 
     
    27282844  */ 
    27292845  bool CDomain::isEqual(CDomain* obj) 
     2846  TRY 
    27302847  { 
    27312848    vector<StdString> excludedAttr; 
     
    27502867    return objEqual; 
    27512868  } 
     2869  CATCH_DUMP_ATTR 
    27522870 
    27532871  /*! 
     
    27562874  */ 
    27572875  void CDomain::recvDataIndex(CEventServer& event) 
     2876  TRY 
    27582877  { 
    27592878    string domainId; 
     
    27692888    get(domainId)->recvDataIndex(rankBuffers); 
    27702889  } 
     2890  CATCH 
    27712891 
    27722892  /*! 
     
    27802900  */ 
    27812901  void CDomain::recvDataIndex(std::map<int, CBufferIn*>& rankBuffers) 
     2902  TRY 
    27822903  { 
    27832904    int nbReceived = rankBuffers.size(), i, ind, index, indexI, indexJ, type_int, lInd;     
     
    28462967    data_jbegin.setValue(0); 
    28472968  } 
     2969  CATCH_DUMP_ATTR 
    28482970 
    28492971  CTransformation<CDomain>* CDomain::addTransformation(ETranformationType transType, const StdString& id) 
     2972  TRY 
    28502973  { 
    28512974    transformationMap_.push_back(std::make_pair(transType, CTransformation<CDomain>::createTransformation(transType,id))); 
    28522975    return transformationMap_.back().second; 
    28532976  } 
     2977  CATCH_DUMP_ATTR 
    28542978 
    28552979  /*! 
     
    28582982  */ 
    28592983  bool CDomain::hasTransformation() 
     2984  TRY 
    28602985  { 
    28612986    return (!transformationMap_.empty()); 
    28622987  } 
     2988  CATCH_DUMP_ATTR 
    28632989 
    28642990  /*! 
     
    28672993  */ 
    28682994  void CDomain::setTransformations(const TransMapTypes& domTrans) 
     2995  TRY 
    28692996  { 
    28702997    transformationMap_ = domTrans; 
    28712998  } 
     2999  CATCH_DUMP_ATTR 
    28723000 
    28733001  /*! 
     
    28763004  */ 
    28773005  CDomain::TransMapTypes CDomain::getAllTransformations(void) 
     3006  TRY 
    28783007  { 
    28793008    return transformationMap_; 
    28803009  } 
     3010  CATCH_DUMP_ATTR 
    28813011 
    28823012  void CDomain::duplicateTransformation(CDomain* src) 
     3013  TRY 
    28833014  { 
    28843015    if (src->hasTransformation()) 
     
    28873018    } 
    28883019  } 
     3020  CATCH_DUMP_ATTR 
    28893021 
    28903022  /*! 
     
    28923024   */ 
    28933025  void CDomain::solveInheritanceTransformation() 
     3026  TRY 
    28943027  { 
    28953028    if (hasTransformation() || !hasDirectDomainReference()) 
     
    29083041        refDomains[i]->setTransformations(domain->getAllTransformations()); 
    29093042  } 
     3043  CATCH_DUMP_ATTR 
    29103044 
    29113045  void CDomain::setContextClient(CContextClient* contextClient) 
     3046  TRY 
    29123047  { 
    29133048    if (clientsSet.find(contextClient)==clientsSet.end()) 
     
    29173052    } 
    29183053  } 
     3054  CATCH_DUMP_ATTR 
    29193055 
    29203056  /*! 
     
    29243060  */ 
    29253061  void CDomain::parse(xml::CXMLNode & node) 
     3062  TRY 
    29263063  { 
    29273064    SuperClass::parse(node); 
     
    29543091    } 
    29553092  } 
     3093  CATCH_DUMP_ATTR 
    29563094   //---------------------------------------------------------------- 
    29573095 
  • XIOS/dev/dev_olga/src/node/field.cpp

    r1594 r1612  
    7171 
    7272   void CField::setVirtualVariableGroup(CVariableGroup* newVVariableGroup) 
     73   TRY 
    7374   { 
    7475      this->vVariableGroup = newVVariableGroup; 
    7576   } 
     77   CATCH 
    7678 
    7779   CVariableGroup* CField::getVirtualVariableGroup(void) const 
     80   TRY 
    7881   { 
    7982      return this->vVariableGroup; 
    8083   } 
     84   CATCH 
    8185 
    8286   std::vector<CVariable*> CField::getAllVariables(void) const 
     87   TRY 
    8388   { 
    8489      return this->vVariableGroup->getAllChildren(); 
    8590   } 
     91   CATCH 
    8692 
    8793   void CField::solveDescInheritance(bool apply, const CAttributeMap* const parent) 
     94   TRY 
    8895   { 
    8996      SuperClassAttribute::setAttributes(parent, apply); 
    9097      this->getVirtualVariableGroup()->solveDescInheritance(apply, NULL); 
    9198   } 
     99   CATCH_DUMP_ATTR 
    92100 
    93101  //---------------------------------------------------------------- 
    94102 
    95103  bool CField::dispatchEvent(CEventServer& event) 
     104  TRY 
    96105  { 
    97106    if (SuperClass::dispatchEvent(event)) return true; 
     
    131140    } 
    132141  } 
     142  CATCH 
    133143 
    134144  void CField::sendUpdateData(const CArray<double,1>& data) 
     145  TRY 
    135146  { 
    136147    CTimer::get("Field : send data").resume(); 
     
    189200    CTimer::get("Field : send data").suspend(); 
    190201  } 
     202  CATCH_DUMP_ATTR 
    191203 
    192204  void CField::recvUpdateData(CEventServer& event) 
     205  TRY 
    193206  { 
    194207    std::map<int,CBufferIn*> rankBuffers; 
     
    207220    CTimer::get("Field : recv data").suspend(); 
    208221  } 
     222  CATCH 
    209223 
    210224  void  CField::recvUpdateData(std::map<int,CBufferIn*>& rankBuffers) 
     225  TRY 
    211226  { 
    212227    CContext* context = CContext::getCurrent(); 
     
    249264    recvDataSrv.reset() ; 
    250265  } 
     266  CATCH_DUMP_ATTR 
    251267 
    252268  void CField::writeUpdateData(const CArray<double,1>& data) 
     269  TRY 
    253270  { 
    254271    CContext* context = CContext::getCurrent(); 
     
    277294    } 
    278295  } 
     296  CATCH_DUMP_ATTR 
    279297 
    280298  void CField::writeField(void) 
     299  TRY 
    281300  { 
    282301    if (!getRelFile()->isEmptyZone()) 
     
    290309    } 
    291310  } 
     311  CATCH_DUMP_ATTR 
    292312 
    293313  /* 
     
    299319  */ 
    300320  bool CField::sendReadDataRequest(const CDate& tsDataRequested) 
     321  TRY 
    301322  { 
    302323    CContext* context = CContext::getCurrent(); 
     
    330351    return !isEOF; 
    331352  } 
     353  CATCH_DUMP_ATTR 
    332354 
    333355  /*! 
     
    336358  */ 
    337359  bool CField::sendReadDataRequestIfNeeded(void) 
     360  TRY 
    338361  { 
    339362    const CDate& currentDate = CContext::getCurrent()->getCalendar()->getCurrentDate(); 
     
    353376    return dataRequested; 
    354377  } 
     378  CATCH_DUMP_ATTR 
    355379 
    356380  void CField::recvReadDataRequest(CEventServer& event) 
     381  TRY 
    357382  { 
    358383    CBufferIn* buffer = event.subEvents.begin()->buffer; 
     
    361386    get(fieldId)->recvReadDataRequest(); 
    362387  } 
     388  CATCH 
    363389 
    364390  /*! 
     
    369395  */ 
    370396  void CField::recvReadDataRequest(void) 
     397  TRY 
    371398  { 
    372399    CContext* context = CContext::getCurrent(); 
     
    449476    } 
    450477  } 
     478  CATCH_DUMP_ATTR 
    451479 
    452480  /*! 
     
    456484  */ 
    457485  CField::EReadField CField::readField(void) 
     486  TRY 
    458487  { 
    459488    CContext* context = CContext::getCurrent(); 
     
    508537    return readState; 
    509538  } 
     539  CATCH_DUMP_ATTR 
    510540 
    511541  /* 
     
    516546  */ 
    517547  void CField::recvReadDataReady(CEventServer& event) 
     548  TRY 
    518549  { 
    519550    string fieldId; 
     
    531562    get(fieldId)->recvReadDataReady(ranks, buffers); 
    532563  } 
     564  CATCH 
    533565 
    534566  /*! 
     
    538570  */ 
    539571  void CField::recvReadDataReady(vector<int> ranks, vector<CBufferIn*> buffers) 
     572  TRY 
    540573  { 
    541574    CContext* context = CContext::getCurrent(); 
     
    574607      serverSourceFilter->streamDataFromServer(lastDataReceivedFromServer, data); 
    575608  } 
     609  CATCH_DUMP_ATTR 
    576610 
    577611  void CField::checkForLateDataFromServer(void) 
     612  TRY 
    578613  { 
    579614    CContext* context = CContext::getCurrent(); 
     
    607642    } 
    608643  } 
     644  CATCH_DUMP_ATTR 
    609645 
    610646  void CField::checkIfMustAutoTrigger(void) 
     647  TRY 
    611648  { 
    612649    mustAutoTrigger = serverSourceFilter ? serverSourceFilter->mustAutoTrigger() : false; 
    613650  } 
     651  CATCH_DUMP_ATTR 
    614652 
    615653  void CField::autoTriggerIfNeeded(void) 
     654  TRY 
    616655  { 
    617656    if (mustAutoTrigger) 
    618657      serverSourceFilter->trigger(CContext::getCurrent()->getCalendar()->getCurrentDate()); 
    619658  } 
     659  CATCH_DUMP_ATTR 
    620660 
    621661   //---------------------------------------------------------------- 
    622662 
    623663   void CField::setRelFile(CFile* _file) 
     664   TRY 
    624665   { 
    625666      this->file = _file; 
    626667      hasOutputFile = true; 
    627668   } 
     669   CATCH_DUMP_ATTR 
    628670 
    629671   //---------------------------------------------------------------- 
     
    636678 
    637679   CGrid* CField::getRelGrid(void) const 
     680   TRY 
    638681   { 
    639682      return this->grid; 
    640683   } 
     684   CATCH 
    641685 
    642686   //---------------------------------------------------------------- 
    643687 
    644688   CFile* CField::getRelFile(void) const 
     689   TRY 
    645690   { 
    646691      return this->file; 
    647692   } 
     693   CATCH 
    648694 
    649695   int CField::getNStep(void) const 
     696   TRY 
    650697   { 
    651698      return this->nstep; 
    652699   } 
     700   CATCH 
    653701 
    654702   func::CFunctor::ETimeType CField::getOperationTimeType() const 
     703   TRY 
    655704   { 
    656705     return operationTimeType; 
    657706   } 
     707   CATCH 
    658708 
    659709   //---------------------------------------------------------------- 
    660710 
    661711   void CField::incrementNStep(void) 
     712   TRY 
    662713   { 
    663714      this->nstep++; 
    664715   } 
     716   CATCH_DUMP_ATTR 
    665717 
    666718   void CField::resetNStep(int nstep /*= 0*/) 
     719   TRY 
    667720   { 
    668721      this->nstep = nstep; 
    669722   } 
     723   CATCH_DUMP_ATTR 
    670724 
    671725   void CField::resetNStepMax(void) 
     726   TRY 
    672727   { 
    673728      this->nstepMax = 0; 
    674729      nstepMaxRead = false; 
    675730   } 
     731   CATCH_DUMP_ATTR 
    676732 
    677733   //---------------------------------------------------------------- 
    678734 
    679735   bool CField::isActive(bool atCurrentTimestep /*= false*/) const 
     736   TRY 
    680737   { 
    681738      if (clientSourceFilter) 
     
    689746      return false; 
    690747   } 
     748   CATCH 
    691749