Ignore:
Timestamp:
05/21/12 17:57:22 (12 years ago)
Author:
ymipsl
Message:
  • Supress lot of shared_ptr
  • instrument code for vampir-trace and timer diagnostic

YM

Location:
XIOS/trunk/src/interface
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/interface/c/icaxis.cpp

    r346 r347  
    1313 
    1414#include "icutil.hpp" 
     15#include "timer.hpp" 
    1516 
    1617extern "C" 
    … …  
    2930      std::string id;  
    3031      if (!cstr2string(_id, _id_len, id)) return; 
    31  
    32       *_ret = xios::CAxis::get(id).get(); 
     32      CTimer::get("XIOS").resume() ; 
     33      *_ret = xios::CAxis::get(id); 
     34      CTimer::get("XIOS").suspend() ; 
    3335   } 
    3436    
    … …  
    3739      std::string id;  
    3840      if (!cstr2string(_id, _id_len, id)) return; 
    39  
    40       *_ret = xios::CAxisGroup::get(id).get(); 
    41    } 
     41      CTimer::get("XIOS").resume() ; 
     42      *_ret = xios::CAxisGroup::get(id); 
     43      CTimer::get("XIOS").suspend() ; 
     44    } 
    4245 
    4346   // -------------------- Vérification des identifiants ----------------------- 
    … …  
    4851      if (!cstr2string(_id, _id_len, id)) return; 
    4952 
     53      CTimer::get("XIOS").resume() ; 
    5054      *_ret = xios::CAxis::has(id); 
     55      CTimer::get("XIOS").suspend() ; 
    5156   } 
    5257 
    … …  
    5661      if (!cstr2string(_id, _id_len, id)) return; 
    5762 
     63      CTimer::get("XIOS").resume() ; 
    5864      *_ret = xios::CAxisGroup::has(id); 
     65      CTimer::get("XIOS").suspend() ; 
     66 
    5967   } 
    6068    

  • XIOS/trunk/src/interface/c/iccontext.cpp

    r346 r347  
    1515 
    1616#include "icutil.hpp" 
     17#include "timer.hpp" 
    1718 
    1819extern "C" 
    … …  
    3233      std::string id;  
    3334      if (!cstr2string(_id, _id_len, id)) return; 
    34  
    35       std::vector<boost::shared_ptr<xios::CContext> > def_vector = 
     35      CTimer::get("XIOS").resume() ; 
     36       
     37      std::vector<xios::CContext*> def_vector = 
    3638            xios::CContext::getRoot()->getChildList(); 
    3739 
    … …  
    3941           { 
    4042          if (def_vector[i]->getId().compare(id) == 0) 
    41           *_ret = def_vector[i].get(); 
     43          *_ret = def_vector[i]; 
     44           CTimer::get("XIOS").suspend() ; 
    4245          return; 
    4346      } 
     47       CTimer::get("XIOS").suspend() ; 
    4448      // Lever une exeception ici 
    4549   } 
    … …  
    4953   void cxios_context_set_current(XContextPtr context, bool withswap) 
    5054   { 
     55      CTimer::get("XIOS").resume() ; 
    5156      CContext::setCurrent(context->getId()); 
     57      CTimer::get("XIOS").suspend() ; 
    5258   } 
    5359    
    … …  
    5965      std::string id; 
    6066      if (!cstr2string(_id, _id_len, id)) return; 
    61  
    62       std::vector<boost::shared_ptr<xios::CContext> > def_vector = 
     67       
     68      CTimer::get("XIOS").resume() ; 
     69      std::vector<xios::CContext*> def_vector = 
    6370            xios::CContext::getRoot()->getChildList(); 
    6471 
    … …  
    6976      } 
    7077     *_ret = false; 
     78     CTimer::get("XIOS").suspend() ; 
    7179   } 
    7280} // extern "C" 

  • XIOS/trunk/src/interface/c/icdata.cpp

    r346 r347  
    2222#include "field_impl.hpp" 
    2323#include <mpi.h> 
     24#include "timer.hpp" 
    2425 
    2526extern "C" 
    … …  
    3637   void cxios_init_server(void) 
    3738   { 
     39     CTimer::get("XIOS").resume() ; 
    3840     CXios::initServerSide();       
     41     CTimer::get("XIOS").suspend() ; 
    3942   } 
    4043 
    … …  
    4649       
    4750      if (!cstr2string(client_id, len_client_id, str)) return; 
    48        
     51 
     52      CTimer::get("XIOS").resume() ; 
     53      CTimer::get("XIOS init").resume() ; 
    4954      int initialized ; 
    5055      MPI_Initialized(&initialized) ; 
    … …  
    5358      CXios::initClientSide(str,local_comm,return_comm); 
    5459      *f_return_comm=MPI_Comm_c2f(return_comm) ; 
     60      CTimer::get("XIOS init").suspend() ; 
     61      CTimer::get("XIOS").suspend() ; 
    5562   } 
    5663 
    … …  
    6168      
    6269     if (!cstr2string(context_id, len_context_id, str)) return; 
     70     CTimer::get("XIOS").resume() ; 
     71     CTimer::get("XIOS init context").resume() ; 
    6372     comm=MPI_Comm_f2c(*f_comm) ; 
    6473     CClient::registerContext(str,comm) ; 
     74     CTimer::get("XIOS init context").suspend() ; 
     75     CTimer::get("XIOS").suspend() ; 
    6576   } 
    6677  
    6778    void cxios_context_close_definition() 
    6879   { 
    69      boost::shared_ptr<CContext> context = CContext::getCurrent() ; 
     80     CTimer::get("XIOS").resume() ; 
     81     CTimer::get("XIOS close definition").resume() ; 
     82     CContext* context = CContext::getCurrent() ; 
    7083     context->closeDefinition() ; 
     84     CTimer::get("XIOS close definition").suspend() ; 
     85     CTimer::get("XIOS").suspend() ; 
    7186   }   
    7287 
    7388   void cxios_context_finalize() 
    7489   { 
    75      boost::shared_ptr<CContext> context = CContext::getCurrent() ; 
     90     CTimer::get("XIOS").resume() ; 
     91     CTimer::get("XIOS context finalize").resume() ; 
     92     CContext* context = CContext::getCurrent() ; 
    7693     context->finalize() ; 
     94     CTimer::get("XIOS context finalize").suspend() ; 
     95     CTimer::get("XIOS").suspend() ; 
    7796   } 
    7897    
    7998   void cxios_finalize() 
    8099   { 
     100     CTimer::get("XIOS").resume() ; 
     101     CTimer::get("XIOS finalize").resume() ; 
    81102     CXios::clientFinalize() ; 
     103     CTimer::get("XIOS finalize").suspend() ; 
     104     CTimer::get("XIOS").suspend() ; 
    82105   } 
    83106 
    … …  
    89112   { 
    90113      std::string fieldid_str; 
    91       boost::shared_ptr<CContext> context = CContext::getCurrent() ; 
    92       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
    93        
     114      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
     115       
     116      CTimer::get("XIOS").resume() ; 
     117      CTimer::get("XIOS send field").resume() ; 
     118      CContext* context = CContext::getCurrent() ; 
    94119//      boost::const_multi_array_ref<double, 1> array_(data_k8, 
    95120//          boost::extents [data_Xsize], 
    … …  
    100125//      dtreat->write_data(fieldid_str, data); 
    101126      CField::get(fieldid_str)->setData(data) ; 
     127      CTimer::get("XIOS send field").suspend() ; 
     128      CTimer::get("XIOS").suspend() ; 
    102129   } 
    103130    
    … …  
    105132   { 
    106133      std::string fieldid_str; 
    107       boost::shared_ptr<CContext> context = CContext::getCurrent() ; 
    108134      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
     135       
     136      CTimer::get("XIOS").resume() ; 
     137      CTimer::get("XIOS send field").resume() ; 
     138      CContext* context = CContext::getCurrent() ; 
    109139       
    110140//      boost::const_multi_array_ref<double, 2> array_(data_k8, 
    … …  
    115145//      dtreat->write_data(fieldid_str, data); 
    116146      CField::get(fieldid_str)->setData(data) ; 
     147      CTimer::get("XIOS send field").suspend() ; 
     148      CTimer::get("XIOS").suspend() ; 
    117149   } 
    118150    
    … …  
    120152   { 
    121153      std::string fieldid_str; 
    122       boost::shared_ptr<CContext> context = CContext::getCurrent() ; 
    123       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
    124        
     154      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
     155 
     156      CTimer::get("XIOS").resume() ; 
     157      CTimer::get("XIOS send field").resume() ; 
     158      CContext* context = CContext::getCurrent() ; 
    125159//      boost::const_multi_array_ref<double, 3> array_(data_k8, 
    126160//          boost::extents [data_Xsize][data_Ysize][data_Zsize], 
    … …  
    130164//      dtreat->write_data(fieldid_str, data); 
    131165      CField::get(fieldid_str)->setData(data) ; 
    132  
     166      CTimer::get("XIOS send field").suspend() ; 
     167      CTimer::get("XIOS").suspend() ; 
    133168   } 
    134169    
    … …  
    136171   { 
    137172      std::string fieldid_str; 
    138       boost::shared_ptr<CContext> context = CContext::getCurrent() ; 
    139       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
    140        
     173     if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
     174 
     175      CTimer::get("XIOS").resume() ; 
     176      CTimer::get("XIOS send field").resume() ; 
     177      CContext* context = CContext::getCurrent() ; 
    141178//      boost::const_multi_array_ref<float, 1> array_(data_k4, 
    142179//          boost::extents [data_Xsize], 
    … …  
    149186      for(int i=0;i<data->num_elements();i++) ptr_data[i]=data_k4[i]; 
    150187      CField::get(fieldid_str)->setData(data) ; 
     188      CTimer::get("XIOS send field").suspend() ; 
     189      CTimer::get("XIOS").suspend() ; 
    151190   } 
    152191    
    … …  
    154193   { 
    155194      std::string fieldid_str; 
    156       boost::shared_ptr<CContext> context = CContext::getCurrent() ; 
    157       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
    158        
     195      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
     196 
     197      CTimer::get("XIOS").resume() ; 
     198      CTimer::get("XIOS send field").resume() ; 
     199      CContext* context = CContext::getCurrent() ; 
    159200//      boost::const_multi_array_ref<float, 2> array_(data_k4, 
    160201//          boost::extents [data_Xsize][data_Ysize], 
    … …  
    167208      for(int i=0;i<data->num_elements();i++) ptr_data[i]=data_k4[i]; 
    168209      CField::get(fieldid_str)->setData(data) ; 
     210      CTimer::get("XIOS send field").suspend() ; 
     211      CTimer::get("XIOS").suspend() ; 
    169212   } 
    170213    
    … …  
    172215   { 
    173216      std::string fieldid_str; 
    174       boost::shared_ptr<CContext> context = CContext::getCurrent() ; 
    175       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
    176        
     217  
     218      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;  
     219  
     220      CTimer::get("XIOS").resume() ; 
     221      CTimer::get("XIOS send field").resume() ; 
     222      CContext* context = CContext::getCurrent() ; 
     223      
    177224//      boost::const_multi_array_ref<float, 3> array_(data_k4, 
    178225//          boost::extents [data_Xsize][data_Ysize][data_Zsize], 
    … …  
    185232      for(int i=0;i<data->num_elements();i++) ptr_data[i]=data_k4[i]; 
    186233      CField::get(fieldid_str)->setData(data) ; 
     234      CTimer::get("XIOS send field").suspend() ; 
     235      CTimer::get("XIOS").suspend() ; 
     236 
    187237    }  
    188238 

  • XIOS/trunk/src/interface/c/icdate.cpp

    r346 r347  
    1515 
    1616#include "icutil.hpp" 
     17#include "timer.hpp" 
    1718 
    1819extern "C" 
    … …  
    2526      try 
    2627      { 
     28         CTimer::get("XIOS").resume() ; 
    2729         CDuration dur = {ts_year, ts_month, ts_day, ts_hour, ts_minute, ts_second}; 
    28          boost::shared_ptr<xios::CContext> context = CContext::getCurrent() ; 
     30         xios::CContext* context = CContext::getCurrent() ; 
    2931          
    3032            context->timestep.setValue(dur.toString()); 
    3133            context->sendAttributToServer("timestep") ; 
     34          CTimer::get("XIOS").suspend() ; 
    3235      } 
    3336      catch (xios::CException & exc) 
    … …  
    4043   void cxios_update_calendar(int step) 
    4144   { 
    42       boost::shared_ptr<xios::CContext> context = CContext::getCurrent() ; 
     45      CTimer::get("XIOS").resume() ; 
     46      xios::CContext* context = CContext::getCurrent() ; 
    4347      context->updateCalendar(step) ; 
    4448      context->sendUpdateCalendar(step) ; 
     49      CTimer::get("XIOS").suspend() ; 
    4550       
    4651   } 

  • XIOS/trunk/src/interface/c/icdomain.cpp

    r346 r347  
    1313 
    1414#include "icutil.hpp" 
     15#include "timer.hpp" 
    1516 
    1617extern "C" 
    … …  
    2930      std::string id;  
    3031      if (!cstr2string(_id, _id_len, id)) return; 
    31  
    32       *_ret = CDomain::get(id).get(); 
     32      CTimer::get("XIOS").resume() ; 
     33      *_ret = CDomain::get(id); 
     34      CTimer::get("XIOS").suspend() ; 
    3335   } 
    3436    
    … …  
    3840      if (!cstr2string(_id, _id_len, id)) return; 
    3941 
    40       *_ret = CDomainGroup::get(id).get(); 
     42      CTimer::get("XIOS").resume() ; 
     43      *_ret = CDomainGroup::get(id); 
     44      CTimer::get("XIOS").suspend() ; 
    4145   } 
    4246 
    … …  
    4852      if (!cstr2string(_id, _id_len, id)) return; 
    4953 
     54      CTimer::get("XIOS").resume() ; 
    5055      *_ret = CDomain::has(id); 
     56      CTimer::get("XIOS").suspend() ; 
    5157   } 
    5258 
    … …  
    5561      std::string id; 
    5662      if (!cstr2string(_id, _id_len, id)) return; 
    57  
     63      CTimer::get("XIOS").resume() ; 
    5864      *_ret = CDomainGroup::has(id); 
     65      CTimer::get("XIOS").suspend() ; 
    5966   } 
    6067} // extern "C" 

  • XIOS/trunk/src/interface/c/icfield.cpp

    r346 r347  
    1313 
    1414#include "icutil.hpp" 
     15#include "timer.hpp" 
    1516 
    1617extern "C" 
    … …  
    3132      std::string id;  
    3233      if (!cstr2string(_id, _id_len, id)) return; 
    33  
    34       *_ret = CField::get(id).get(); 
     34      CTimer::get("XIOS").resume() ; 
     35      *_ret = CField::get(id); 
     36      CTimer::get("XIOS").suspend() ; 
    3537   } 
    3638    
    … …  
    3941      std::string id;  
    4042      if (!cstr2string(_id, _id_len, id)) return; 
    41  
    42       *_ret = CFieldGroup::get(id).get(); 
     43      CTimer::get("XIOS").resume() ; 
     44      *_ret = CFieldGroup::get(id); 
     45      CTimer::get("XIOS").suspend() ; 
    4346   } 
    4447 
    … …  
    5053      std::string id; 
    5154      if (!cstr2string(_id, _id_len, id)) return; 
    52  
     55      CTimer::get("XIOS").resume() ; 
    5356      *_ret = CField::has(id); 
     57      CTimer::get("XIOS").suspend() ; 
    5458   } 
    5559 
    … …  
    5862      std::string id; 
    5963      if (!cstr2string(_id, _id_len, id)) return; 
    60  
     64      CTimer::get("XIOS").resume() ; 
    6165      *_ret = CFieldGroup::has(id); 
     66      CTimer::get("XIOS").suspend() ; 
    6267   } 
    6368 
    … …  
    6873  void cxios_field_is_active (XFieldPtr field_hdl, bool* ret) 
    6974  { 
     75    CTimer::get("XIOS").resume() ; 
    7076    *ret = field_hdl->isActive(); 
     77    CTimer::get("XIOS").suspend() ; 
    7178  } 
    7279    

  • XIOS/trunk/src/interface/c/icfile.cpp

    r346 r347  
    1313 
    1414#include "icutil.hpp" 
     15#include "timer.hpp" 
    1516 
    1617extern "C" 
    … …  
    2930      std::string id;  
    3031      if (!cstr2string(_id, _id_len, id)) return; 
    31  
    32       *_ret = CFile::get(id).get(); 
     32      CTimer::get("XIOS").resume() ; 
     33      *_ret = CFile::get(id); 
     34      CTimer::get("XIOS").suspend() ; 
    3335   } 
    3436    
    … …  
    3739      std::string id;  
    3840      if (!cstr2string(_id, _id_len, id)) return; 
    39  
    40       *_ret = CFileGroup::get(id).get(); 
     41      CTimer::get("XIOS").resume() ; 
     42      *_ret = CFileGroup::get(id); 
     43      CTimer::get("XIOS").suspend() ; 
    4144   } 
    4245 
    … …  
    4750      std::string id; 
    4851      if (!cstr2string(_id, _id_len, id)) return; 
    49  
     52      CTimer::get("XIOS").resume() ; 
    5053      *_ret = CFile::has(id); 
     54      CTimer::get("XIOS").suspend() ; 
    5155   } 
    5256 
    … …  
    5559      std::string id; 
    5660      if (!cstr2string(_id, _id_len, id)) return; 
    57  
     61      CTimer::get("XIOS").resume() ; 
    5862      *_ret = CFileGroup::has(id); 
     63      CTimer::get("XIOS").suspend() ; 
    5964   } 
    6065} // extern "C" 

  • XIOS/trunk/src/interface/c/icgrid.cpp

    r346 r347  
    1313 
    1414#include "icutil.hpp" 
     15#include "timer.hpp" 
    1516 
    1617extern "C" 
    … …  
    2930      std::string id;  
    3031      if (!cstr2string(_id, _id_len, id)) return; 
    31  
    32       *_ret = CGrid::get(id).get(); 
     32      CTimer::get("XIOS").resume() ; 
     33      *_ret = CGrid::get(id); 
     34      CTimer::get("XIOS").suspend() ; 
    3335   } 
    3436    
    … …  
    3739      std::string id;  
    3840      if (!cstr2string(_id, _id_len, id)) return; 
    39  
    40       *_ret = CGridGroup::get(id).get(); 
     41      CTimer::get("XIOS").resume() ; 
     42      *_ret = CGridGroup::get(id); 
     43      CTimer::get("XIOS").suspend() ; 
    4144   } 
    4245 
    … …  
    4750      std::string id; 
    4851      if (!cstr2string(_id, _id_len, id)) return; 
    49  
     52      CTimer::get("XIOS").resume() ; 
    5053      *_ret = CGrid::has(id); 
     54      CTimer::get("XIOS").suspend() ; 
    5155   } 
    5256 
    … …  
    5559      std::string id; 
    5660      if (!cstr2string(_id, _id_len, id)) return; 
    57  
     61      CTimer::get("XIOS").resume() ; 
    5862      *_ret = CGridGroup::has(id); 
     63      CTimer::get("XIOS").suspend() ; 
    5964   } 
    6065} // extern "C" 

  • XIOS/trunk/src/interface/c/icxml_tree.cpp

    r346 r347  
    1313 
    1414#include "icutil.hpp" 
     15#include "timer.hpp" 
    1516 
    1617extern "C" 
    … …  
    4344   { 
    4445      std::string child_id_str;  
    45  
    46       if (cstr2string(child_id, child_id_size, child_id_str)) 
    47       { 
    48          *child_ = parent_->createChild(child_id_str).get() ; 
    49          parent_->sendCreateChild(child_id_str) ; 
    50       } 
    51       else 
    52       { 
    53          *child_ = parent_->createChild().get() ; 
    54          parent_->sendCreateChild() ; 
    55       } 
     46      CTimer::get("XIOS").resume() ; 
     47      if (cstr2string(child_id, child_id_size, child_id_str)) 
     48      { 
     49         *child_ = parent_->createChild(child_id_str) ; 
     50         parent_->sendCreateChild(child_id_str) ; 
     51      } 
     52      else 
     53      { 
     54         *child_ = parent_->createChild() ; 
     55         parent_->sendCreateChild() ; 
     56      } 
     57      CTimer::get("XIOS").suspend() ; 
    5658  } 
    5759    
    … …  
    6062   { 
    6163      std::string child_id_str;  
    62       if (cstr2string(child_id, child_id_size, child_id_str)) 
    63       { 
    64          *child_ = parent_->createChild(child_id_str).get() ; 
    65          parent_->sendCreateChild(child_id_str) ; 
    66       } 
    67       else 
    68       { 
    69          *child_ = parent_->createChild().get() ; 
    70          parent_->sendCreateChild() ; 
    71       } 
     64      CTimer::get("XIOS").resume() ; 
     65      if (cstr2string(child_id, child_id_size, child_id_str)) 
     66      { 
     67         *child_ = parent_->createChild(child_id_str) ; 
     68         parent_->sendCreateChild(child_id_str) ; 
     69      } 
     70      else 
     71      { 
     72         *child_ = parent_->createChild() ; 
     73         parent_->sendCreateChild() ; 
     74      } 
     75      CTimer::get("XIOS").suspend() ; 
    7276   } 
    7377    
    … …  
    7680   { 
    7781      std::string child_id_str;  
    78       if (cstr2string(child_id, child_id_size, child_id_str)) 
    79       { 
    80          *child_ = parent_->createChild(child_id_str).get() ; 
    81          parent_->sendCreateChild(child_id_str) ; 
    82       } 
    83       else 
    84       { 
    85          *child_ = parent_->createChild().get() ; 
    86          parent_->sendCreateChild() ; 
    87       } 
     82      CTimer::get("XIOS").resume() ; 
     83      if (cstr2string(child_id, child_id_size, child_id_str)) 
     84      { 
     85         *child_ = parent_->createChild(child_id_str) ; 
     86         parent_->sendCreateChild(child_id_str) ; 
     87      } 
     88      else 
     89      { 
     90         *child_ = parent_->createChild() ; 
     91         parent_->sendCreateChild() ; 
     92      } 
     93      CTimer::get("XIOS").suspend() ; 
    8894   } 
    8995    
    … …  
    9298   { 
    9399      std::string child_id_str;  
    94       if (cstr2string(child_id, child_id_size, child_id_str)) 
    95       { 
    96          *child_ = parent_->createChild(child_id_str).get() ; 
    97          parent_->sendCreateChild(child_id_str) ; 
    98       } 
    99       else 
    100       { 
    101          *child_ = parent_->createChild().get() ; 
    102          parent_->sendCreateChild() ; 
    103       } 
     100      CTimer::get("XIOS").resume() ; 
     101      if (cstr2string(child_id, child_id_size, child_id_str)) 
     102      { 
     103         *child_ = parent_->createChild(child_id_str) ; 
     104         parent_->sendCreateChild(child_id_str) ; 
     105      } 
     106      else 
     107      { 
     108         *child_ = parent_->createChild() ; 
     109         parent_->sendCreateChild() ; 
     110      } 
     111      CTimer::get("XIOS").suspend() ; 
    104112   } 
    105113    
    … …  
    107115      (XDomainGroupPtr parent_, XDomainPtr * child_, const char * child_id, int child_id_size) 
    108116   { 
    109       std::string child_id_str;  
    110       if (cstr2string(child_id, child_id_size, child_id_str)) 
    111       { 
    112          *child_ = parent_->createChild(child_id_str).get() ; 
    113          parent_->sendCreateChild(child_id_str) ; 
    114       } 
    115       else 
    116       { 
    117          *child_ = parent_->createChild().get() ; 
    118          parent_->sendCreateChild() ; 
    119       } 
     117      std::string child_id_str; 
     118      CTimer::get("XIOS").resume() ; 
     119      if (cstr2string(child_id, child_id_size, child_id_str)) 
     120      { 
     121         *child_ = parent_->createChild(child_id_str) ; 
     122         parent_->sendCreateChild(child_id_str) ; 
     123      } 
     124      else 
     125      { 
     126         *child_ = parent_->createChild() ; 
     127         parent_->sendCreateChild() ; 
     128      } 
     129      CTimer::get("XIOS").suspend() ; 
    120130   } 
    121131    
    … …  
    123133      (XFilePtr parent_, XFieldPtr * child_, const char * child_id, int child_id_size) 
    124134   { 
    125       std::string child_id_str;  
     135      std::string child_id_str; 
     136      CTimer::get("XIOS").resume() ; 
    126137  
    127138      if (cstr2string(child_id, child_id_size, child_id_str)) 
    128139      { 
    129          *child_ = parent_->addField(child_id_str).get(); 
     140         *child_ = parent_->addField(child_id_str); 
    130141         parent_->sendAddField(child_id_str) ; 
    131142      } 
    132143      else 
    133144      { 
    134          *child_ = parent_->addField().get(); 
     145         *child_ = parent_->addField(); 
    135146         parent_->sendAddField() ; 
    136147      } 
     148      CTimer::get("XIOS").suspend() ; 
    137149   } 
    138150 
    … …  
    143155   { 
    144156     std::string child_id_str;  
    145  
    146       if (cstr2string(child_id, child_id_size, child_id_str)) 
    147       { 
    148          *child_ = parent_->createChildGroup(child_id_str).get() ; 
    149          parent_->sendCreateChildGroup(child_id_str) ; 
    150       } 
    151       else 
    152       { 
    153          *child_ = parent_->createChildGroup().get() ; 
    154          parent_->sendCreateChildGroup(child_id_str) ; 
    155       } 
     157      CTimer::get("XIOS").resume() ; 
     158      if (cstr2string(child_id, child_id_size, child_id_str)) 
     159      { 
     160         *child_ = parent_->createChildGroup(child_id_str) ; 
     161         parent_->sendCreateChildGroup(child_id_str) ; 
     162      } 
     163      else 
     164      { 
     165         *child_ = parent_->createChildGroup() ; 
     166         parent_->sendCreateChildGroup(child_id_str) ; 
     167      } 
     168      CTimer::get("XIOS").suspend() ; 
    156169   } 
    157170 
    … …  
    160173   { 
    161174      std::string child_id_str; 
    162   
    163       if (cstr2string(child_id, child_id_size, child_id_str)) 
    164       { 
    165          *child_ = parent_->createChildGroup(child_id_str).get() ; 
    166          parent_->sendCreateChildGroup(child_id_str) ; 
    167       } 
    168       else 
    169       { 
    170          *child_ = parent_->createChildGroup().get() ; 
    171          parent_->sendCreateChildGroup(child_id_str) ; 
    172       } 
     175      CTimer::get("XIOS").resume() ; 
     176      if (cstr2string(child_id, child_id_size, child_id_str)) 
     177      { 
     178         *child_ = parent_->createChildGroup(child_id_str) ; 
     179         parent_->sendCreateChildGroup(child_id_str) ; 
     180      } 
     181      else 
     182      { 
     183         *child_ = parent_->createChildGroup() ; 
     184         parent_->sendCreateChildGroup(child_id_str) ; 
     185      } 
     186      CTimer::get("XIOS").suspend() ; 
    173187   } 
    174188 
    … …  
    177191   { 
    178192      std::string child_id_str; 
    179       if (cstr2string(child_id, child_id_size, child_id_str)) 
    180       { 
    181          *child_ = parent_->createChildGroup(child_id_str).get() ; 
    182          parent_->sendCreateChildGroup(child_id_str) ; 
    183       } 
    184       else 
    185       { 
    186          *child_ = parent_->createChildGroup().get() ; 
    187          parent_->sendCreateChildGroup(child_id_str) ; 
    188       } 
     193      CTimer::get("XIOS").resume() ; 
     194      if (cstr2string(child_id, child_id_size, child_id_str)) 
     195      { 
     196         *child_ = parent_->createChildGroup(child_id_str) ; 
     197         parent_->sendCreateChildGroup(child_id_str) ; 
     198      } 
     199      else 
     200      { 
     201         *child_ = parent_->createChildGroup() ; 
     202         parent_->sendCreateChildGroup(child_id_str) ; 
     203      } 
     204      CTimer::get("XIOS").suspend() ; 
    189205   } 
    190206 
    … …  
    193209   { 
    194210      std::string child_id_str; 
    195       if (cstr2string(child_id, child_id_size, child_id_str)) 
    196       { 
    197          *child_ = parent_->createChildGroup(child_id_str).get() ; 
    198          parent_->sendCreateChildGroup(child_id_str) ; 
    199       } 
    200       else 
    201       { 
    202          *child_ = parent_->createChildGroup().get() ; 
    203          parent_->sendCreateChildGroup(child_id_str) ; 
    204       } 
     211      CTimer::get("XIOS").resume() ; 
     212      if (cstr2string(child_id, child_id_size, child_id_str)) 
     213      { 
     214         *child_ = parent_->createChildGroup(child_id_str) ; 
     215         parent_->sendCreateChildGroup(child_id_str) ; 
     216      } 
     217      else 
     218      { 
     219         *child_ = parent_->createChildGroup() ; 
     220         parent_->sendCreateChildGroup(child_id_str) ; 
     221      } 
     222      CTimer::get("XIOS").suspend() ; 
    205223   } 
    206224 
    … …  
    209227   { 
    210228      std::string child_id_str; 
    211       if (cstr2string(child_id, child_id_size, child_id_str)) 
    212       { 
    213          *child_ = parent_->createChildGroup(child_id_str).get() ; 
    214          parent_->sendCreateChildGroup(child_id_str) ; 
    215       } 
    216       else 
    217       { 
    218          *child_ = parent_->createChildGroup().get() ; 
    219          parent_->sendCreateChildGroup(child_id_str) ; 
    220       } 
     229      CTimer::get("XIOS").resume() ; 
     230      if (cstr2string(child_id, child_id_size, child_id_str)) 
     231      { 
     232         *child_ = parent_->createChildGroup(child_id_str) ; 
     233         parent_->sendCreateChildGroup(child_id_str) ; 
     234      } 
     235      else 
     236      { 
     237         *child_ = parent_->createChildGroup() ; 
     238         parent_->sendCreateChildGroup(child_id_str) ; 
     239      } 
     240      CTimer::get("XIOS").suspend() ; 
    221241   } 
    222242 
    … …  
    225245   { 
    226246      std::string child_id_str;  
    227   
    228       if (cstr2string(child_id, child_id_size, child_id_str)) 
    229       { 
    230          *child_ = parent_->addFieldGroup(child_id_str).get(); 
     247      CTimer::get("XIOS").resume() ; 
     248      if (cstr2string(child_id, child_id_size, child_id_str)) 
     249      { 
     250         *child_ = parent_->addFieldGroup(child_id_str); 
    231251         parent_->sendAddFieldGroup(child_id_str) ; 
    232252      } 
    233253      else 
    234254      { 
    235          *child_ = parent_->addFieldGroup().get(); 
     255         *child_ = parent_->addFieldGroup(); 
    236256         parent_->sendAddFieldGroup() ; 
    237257      } 
     258      CTimer::get("XIOS").suspend() ; 
    238259   } 
    239260    

  • XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp

    r345 r347  
    1010#include "group_template_impl.hpp" 
    1111#include "icutil.hpp" 
     12#include "timer.hpp" 
    1213 
    1314extern "C" 
    … …  
    1920    std::string long_name_str; 
    2021    if(!cstr2string(long_name, long_name_size, long_name_str)) return; 
     22     CTimer::get("XIOS").resume(); 
    2123    axis_hdl->long_name.setValue(long_name_str); 
    2224    axis_hdl->sendAttributToServer(axis_hdl->long_name); 
     25     CTimer::get("XIOS").suspend(); 
    2326  } 
    2427   
    2528  void cxios_get_axis_long_name(axis_Ptr axis_hdl, char * long_name, int long_name_size) 
    2629  { 
     30     CTimer::get("XIOS").resume(); 
    2731    if(!string_copy(axis_hdl->long_name.getValue(),long_name , long_name_size)) 
    2832      ERROR("void cxios_get_axis_long_name(axis_Ptr axis_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
     33     CTimer::get("XIOS").suspend(); 
    2934  } 
    3035   
    … …  
    3439    std::string name_str; 
    3540    if(!cstr2string(name, name_size, name_str)) return; 
     41     CTimer::get("XIOS").resume(); 
    3642    axis_hdl->name.setValue(name_str); 
    3743    axis_hdl->sendAttributToServer(axis_hdl->name); 
     44     CTimer::get("XIOS").suspend(); 
    3845  } 
    3946   
    4047  void cxios_get_axis_name(axis_Ptr axis_hdl, char * name, int name_size) 
    4148  { 
     49     CTimer::get("XIOS").resume(); 
    4250    if(!string_copy(axis_hdl->name.getValue(),name , name_size)) 
    4351      ERROR("void cxios_get_axis_name(axis_Ptr axis_hdl, char * name, int name_size)", <<"Input string is to short"); 
     52     CTimer::get("XIOS").suspend(); 
    4453  } 
    4554   
    … …  
    4756  void cxios_set_axis_size(axis_Ptr axis_hdl, int size) 
    4857  { 
     58     CTimer::get("XIOS").resume(); 
    4959    axis_hdl->size.setValue(size); 
    5060    axis_hdl->sendAttributToServer(axis_hdl->size); 
     61     CTimer::get("XIOS").suspend(); 
    5162  } 
    5263   
    … …  
    6172    std::string standard_name_str; 
    6273    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
     74     CTimer::get("XIOS").resume(); 
    6375    axis_hdl->standard_name.setValue(standard_name_str); 
    6476    axis_hdl->sendAttributToServer(axis_hdl->standard_name); 
     77     CTimer::get("XIOS").suspend(); 
    6578  } 
    6679   
    6780  void cxios_get_axis_standard_name(axis_Ptr axis_hdl, char * standard_name, int standard_name_size) 
    6881  { 
     82     CTimer::get("XIOS").resume(); 
    6983    if(!string_copy(axis_hdl->standard_name.getValue(),standard_name , standard_name_size)) 
    7084      ERROR("void cxios_get_axis_standard_name(axis_Ptr axis_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
     85     CTimer::get("XIOS").suspend(); 
    7186  } 
    7287   
    … …  
    7691    std::string unit_str; 
    7792    if(!cstr2string(unit, unit_size, unit_str)) return; 
     93     CTimer::get("XIOS").resume(); 
    7894    axis_hdl->unit.setValue(unit_str); 
    7995    axis_hdl->sendAttributToServer(axis_hdl->unit); 
     96     CTimer::get("XIOS").suspend(); 
    8097  } 
    8198   
    8299  void cxios_get_axis_unit(axis_Ptr axis_hdl, char * unit, int unit_size) 
    83100  { 
     101     CTimer::get("XIOS").resume(); 
    84102    if(!string_copy(axis_hdl->unit.getValue(),unit , unit_size)) 
    85103      ERROR("void cxios_get_axis_unit(axis_Ptr axis_hdl, char * unit, int unit_size)", <<"Input string is to short"); 
     104     CTimer::get("XIOS").suspend(); 
    86105  } 
    87106   
    … …  
    89108  void cxios_set_axis_value(axis_Ptr axis_hdl, double* value, int extent1) 
    90109  { 
     110     CTimer::get("XIOS").resume(); 
    91111    ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1])); 
    92112    std::copy(value, &(value[array_tmp->num_elements()]), array_tmp->data()); 
    … …  
    99119    if (!array_copy(axis_hdl->value.getValue(), value, extent1)) 
    100120     ERROR("void cxios_set_axis_value(axis_Ptr axis_hdl, double* value, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     121     CTimer::get("XIOS").suspend(); 
    101122  } 
    102123   

  • XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp

    r345 r347  
    1010#include "group_template_impl.hpp" 
    1111#include "icutil.hpp" 
     12#include "timer.hpp" 
    1213 
    1314extern "C" 
    … …  
    1920    std::string group_ref_str; 
    2021    if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
     22     CTimer::get("XIOS").resume(); 
    2123    axisgroup_hdl->group_ref.setValue(group_ref_str); 
    2224    axisgroup_hdl->sendAttributToServer(axisgroup_hdl->group_ref); 
     25     CTimer::get("XIOS").suspend(); 
    2326  } 
    2427   
    2528  void cxios_get_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, char * group_ref, int group_ref_size) 
    2629  { 
     30     CTimer::get("XIOS").resume(); 
    2731    if(!string_copy(axisgroup_hdl->group_ref.getValue(),group_ref , group_ref_size)) 
    2832      ERROR("void cxios_get_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
     33     CTimer::get("XIOS").suspend(); 
    2934  } 
    3035   
    … …  
    3439    std::string long_name_str; 
    3540    if(!cstr2string(long_name, long_name_size, long_name_str)) return; 
     41     CTimer::get("XIOS").resume(); 
    3642    axisgroup_hdl->long_name.setValue(long_name_str); 
    3743    axisgroup_hdl->sendAttributToServer(axisgroup_hdl->long_name); 
     44     CTimer::get("XIOS").suspend(); 
    3845  } 
    3946   
    4047  void cxios_get_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, char * long_name, int long_name_size) 
    4148  { 
     49     CTimer::get("XIOS").resume(); 
    4250    if(!string_copy(axisgroup_hdl->long_name.getValue(),long_name , long_name_size)) 
    4351      ERROR("void cxios_get_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
     52     CTimer::get("XIOS").suspend(); 
    4453  } 
    4554   
    … …  
    4958    std::string name_str; 
    5059    if(!cstr2string(name, name_size, name_str)) return; 
     60     CTimer::get("XIOS").resume(); 
    5161    axisgroup_hdl->name.setValue(name_str); 
    5262    axisgroup_hdl->sendAttributToServer(axisgroup_hdl->name); 
     63     CTimer::get("XIOS").suspend(); 
    5364  } 
    5465   
    5566  void cxios_get_axisgroup_name(axisgroup_Ptr axisgroup_hdl, char * name, int name_size) 
    5667  { 
     68     CTimer::get("XIOS").resume(); 
    5769    if(!string_copy(axisgroup_hdl->name.getValue(),name , name_size)) 
    5870      ERROR("void cxios_get_axisgroup_name(axisgroup_Ptr axisgroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
     71     CTimer::get("XIOS").suspend(); 
    5972  } 
    6073   
    … …  
    6275  void cxios_set_axisgroup_size(axisgroup_Ptr axisgroup_hdl, int size) 
    6376  { 
     77     CTimer::get("XIOS").resume(); 
    6478    axisgroup_hdl->size.setValue(size); 
    6579    axisgroup_hdl->sendAttributToServer(axisgroup_hdl->size); 
     80     CTimer::get("XIOS").suspend(); 
    6681  } 
    6782   
    … …  
    7691    std::string standard_name_str; 
    7792    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
     93     CTimer::get("XIOS").resume(); 
    7894    axisgroup_hdl->standard_name.setValue(standard_name_str); 
    7995    axisgroup_hdl->sendAttributToServer(axisgroup_hdl->standard_name); 
     96     CTimer::get("XIOS").suspend(); 
    8097  } 
    8198   
    8299  void cxios_get_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, char * standard_name, int standard_name_size) 
    83100  { 
     101     CTimer::get("XIOS").resume(); 
    84102    if(!string_copy(axisgroup_hdl->standard_name.getValue(),standard_name , standard_name_size)) 
    85103      ERROR("void cxios_get_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
     104     CTimer::get("XIOS").suspend(); 
    86105  } 
    87106   
    … …  
    91110    std::string unit_str; 
    92111    if(!cstr2string(unit, unit_size, unit_str)) return; 
     112     CTimer::get("XIOS").resume(); 
    93113    axisgroup_hdl->unit.setValue(unit_str); 
    94114    axisgroup_hdl->sendAttributToServer(axisgroup_hdl->unit); 
     115     CTimer::get("XIOS").suspend(); 
    95116  } 
    96117   
    97118  void cxios_get_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, char * unit, int unit_size) 
    98119  { 
     120     CTimer::get("XIOS").resume(); 
    99121    if(!string_copy(axisgroup_hdl->unit.getValue(),unit , unit_size)) 
    100122      ERROR("void cxios_get_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, char * unit, int unit_size)", <<"Input string is to short"); 
     123     CTimer::get("XIOS").suspend(); 
    101124  } 
    102125   
    … …  
    104127  void cxios_set_axisgroup_value(axisgroup_Ptr axisgroup_hdl, double* value, int extent1) 
    105128  { 
     129     CTimer::get("XIOS").resume(); 
    106130    ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1])); 
    107131    std::copy(value, &(value[array_tmp->num_elements()]), array_tmp->data()); 
    … …  
    114138    if (!array_copy(axisgroup_hdl->value.getValue(), value, extent1)) 
    115139     ERROR("void cxios_set_axisgroup_value(axisgroup_Ptr axisgroup_hdl, double* value, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     140     CTimer::get("XIOS").suspend(); 
    116141  } 
    117142   

  • XIOS/trunk/src/interface/c_attr/iccontext_attr.cpp

    r345 r347  
    1010#include "group_template_impl.hpp" 
    1111#include "icutil.hpp" 
     12#include "timer.hpp" 
    1213 
    1314extern "C" 
    … …  
    1920    std::string calendar_type_str; 
    2021    if(!cstr2string(calendar_type, calendar_type_size, calendar_type_str)) return; 
     22     CTimer::get("XIOS").resume(); 
    2123    context_hdl->calendar_type.setValue(calendar_type_str); 
    2224    context_hdl->sendAttributToServer(context_hdl->calendar_type); 
     25     CTimer::get("XIOS").suspend(); 
    2326  } 
    2427   
    2528  void cxios_get_context_calendar_type(context_Ptr context_hdl, char * calendar_type, int calendar_type_size) 
    2629  { 
     30     CTimer::get("XIOS").resume(); 
    2731    if(!string_copy(context_hdl->calendar_type.getValue(),calendar_type , calendar_type_size)) 
    2832      ERROR("void cxios_get_context_calendar_type(context_Ptr context_hdl, char * calendar_type, int calendar_type_size)", <<"Input string is to short"); 
     33     CTimer::get("XIOS").suspend(); 
    2934  } 
    3035   
    … …  
    3439    std::string output_dir_str; 
    3540    if(!cstr2string(output_dir, output_dir_size, output_dir_str)) return; 
     41     CTimer::get("XIOS").resume(); 
    3642    context_hdl->output_dir.setValue(output_dir_str); 
    3743    context_hdl->sendAttributToServer(context_hdl->output_dir); 
     44     CTimer::get("XIOS").suspend(); 
    3845  } 
    3946   
    4047  void cxios_get_context_output_dir(context_Ptr context_hdl, char * output_dir, int output_dir_size) 
    4148  { 
     49     CTimer::get("XIOS").resume(); 
    4250    if(!string_copy(context_hdl->output_dir.getValue(),output_dir , output_dir_size)) 
    4351      ERROR("void cxios_get_context_output_dir(context_Ptr context_hdl, char * output_dir, int output_dir_size)", <<"Input string is to short"); 
     52     CTimer::get("XIOS").suspend(); 
    4453  } 
    4554   
    … …  
    4958    std::string start_date_str; 
    5059    if(!cstr2string(start_date, start_date_size, start_date_str)) return; 
     60     CTimer::get("XIOS").resume(); 
    5161    context_hdl->start_date.setValue(start_date_str); 
    5262    context_hdl->sendAttributToServer(context_hdl->start_date); 
     63     CTimer::get("XIOS").suspend(); 
    5364  } 
    5465   
    5566  void cxios_get_context_start_date(context_Ptr context_hdl, char * start_date, int start_date_size) 
    5667  { 
     68     CTimer::get("XIOS").resume(); 
    5769    if(!string_copy(context_hdl->start_date.getValue(),start_date , start_date_size)) 
    5870      ERROR("void cxios_get_context_start_date(context_Ptr context_hdl, char * start_date, int start_date_size)", <<"Input string is to short"); 
     71     CTimer::get("XIOS").suspend(); 
    5972  } 
    6073   
    … …  
    6477    std::string time_origin_str; 
    6578    if(!cstr2string(time_origin, time_origin_size, time_origin_str)) return; 
     79     CTimer::get("XIOS").resume(); 
    6680    context_hdl->time_origin.setValue(time_origin_str); 
    6781    context_hdl->sendAttributToServer(context_hdl->time_origin); 
     82     CTimer::get("XIOS").suspend(); 
    6883  } 
    6984   
    7085  void cxios_get_context_time_origin(context_Ptr context_hdl, char * time_origin, int time_origin_size) 
    7186  { 
     87     CTimer::get("XIOS").resume(); 
    7288    if(!string_copy(context_hdl->time_origin.getValue(),time_origin , time_origin_size)) 
    7389      ERROR("void cxios_get_context_time_origin(context_Ptr context_hdl, char * time_origin, int time_origin_size)", <<"Input string is to short"); 
     90     CTimer::get("XIOS").suspend(); 
    7491  } 
    7592   
    … …  
    7996    std::string timestep_str; 
    8097    if(!cstr2string(timestep, timestep_size, timestep_str)) return; 
     98     CTimer::get("XIOS").resume(); 
    8199    context_hdl->timestep.setValue(timestep_str); 
    82100    context_hdl->sendAttributToServer(context_hdl->timestep); 
     101     CTimer::get("XIOS").suspend(); 
    83102  } 
    84103   
    85104  void cxios_get_context_timestep(context_Ptr context_hdl, char * timestep, int timestep_size) 
    86105  { 
     106     CTimer::get("XIOS").resume(); 
    87107    if(!string_copy(context_hdl->timestep.getValue(),timestep , timestep_size)) 
    88108      ERROR("void cxios_get_context_timestep(context_Ptr context_hdl, char * timestep, int timestep_size)", <<"Input string is to short"); 
     109     CTimer::get("XIOS").suspend(); 
    89110  } 
    90111   

  • XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp

    r345 r347  
    1010#include "group_template_impl.hpp" 
    1111#include "icutil.hpp" 
     12#include "timer.hpp" 
    1213 
    1314extern "C" 
    … …  
    1718  void cxios_set_domain_data_dim(domain_Ptr domain_hdl, int data_dim) 
    1819  { 
     20     CTimer::get("XIOS").resume(); 
    1921    domain_hdl->data_dim.setValue(data_dim); 
    2022    domain_hdl->sendAttributToServer(domain_hdl->data_dim); 
     23     CTimer::get("XIOS").suspend(); 
    2124  } 
    2225   
    … …  
    2932  void cxios_set_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int extent1) 
    3033  { 
     34     CTimer::get("XIOS").resume(); 
    3135    ARRAY(int,1) array_tmp(new CArray<int,1>(boost::extents[extent1])); 
    3236    std::copy(data_i_index, &(data_i_index[array_tmp->num_elements()]), array_tmp->data()); 
    … …  
    3943    if (!array_copy(domain_hdl->data_i_index.getValue(), data_i_index, extent1)) 
    4044     ERROR("void cxios_set_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     45     CTimer::get("XIOS").suspend(); 
    4146  } 
    4247   
    … …  
    4449  void cxios_set_domain_data_ibegin(domain_Ptr domain_hdl, int data_ibegin) 
    4550  { 
     51     CTimer::get("XIOS").resume(); 
    4652    domain_hdl->data_ibegin.setValue(data_ibegin); 
    4753    domain_hdl->sendAttributToServer(domain_hdl->data_ibegin); 
     54     CTimer::get("XIOS").suspend(); 
    4855  } 
    4956   
    … …  
    5663  void cxios_set_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int extent1) 
    5764  { 
     65     CTimer::get("XIOS").resume(); 
    5866    ARRAY(int,1) array_tmp(new CArray<int,1>(boost::extents[extent1])); 
    5967    std::copy(data_j_index, &(data_j_index[array_tmp->num_elements()]), array_tmp->data()); 
    … …  
    6674    if (!array_copy(domain_hdl->data_j_index.getValue(), data_j_index, extent1)) 
    6775     ERROR("void cxios_set_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     76     CTimer::get("XIOS").suspend(); 
    6877  } 
    6978   
    … …  
    7180  void cxios_set_domain_data_jbegin(domain_Ptr domain_hdl, int data_jbegin) 
    7281  { 
     82     CTimer::get("XIOS").resume(); 
    7383    domain_hdl->data_jbegin.setValue(data_jbegin); 
    7484    domain_hdl->sendAttributToServer(domain_hdl->data_jbegin); 
     85     CTimer::get("XIOS").suspend(); 
    7586  } 
    7687   
    … …  
    8394  void cxios_set_domain_data_n_index(domain_Ptr domain_hdl, int data_n_index) 
    8495  { 
     96     CTimer::get("XIOS").resume(); 
    8597    domain_hdl->data_n_index.setValue(data_n_index); 
    8698    domain_hdl->sendAttributToServer(domain_hdl->data_n_index); 
     99     CTimer::get("XIOS").suspend(); 
    87100  } 
    88101   
    … …  
    95108  void cxios_set_domain_data_ni(domain_Ptr domain_hdl, int data_ni) 
    96109  { 
     110     CTimer::get("XIOS").resume(); 
    97111    domain_hdl->data_ni.setValue(data_ni); 
    98112    domain_hdl->sendAttributToServer(domain_hdl->data_ni); 
     113     CTimer::get("XIOS").suspend(); 
    99114  } 
    100115   
    … …  
    107122  void cxios_set_domain_data_nj(domain_Ptr domain_hdl, int data_nj) 
    108123  { 
     124     CTimer::get("XIOS").resume(); 
    109125    domain_hdl->data_nj.setValue(data_nj); 
    110126    domain_hdl->sendAttributToServer(domain_hdl->data_nj); 
     127     CTimer::get("XIOS").suspend(); 
    111128  } 
    112129   
    … …  
    121138    std::string domain_group_ref_str; 
    122139    if(!cstr2string(domain_group_ref, domain_group_ref_size, domain_group_ref_str)) return; 
     140     CTimer::get("XIOS").resume(); 
    123141    domain_hdl->domain_group_ref.setValue(domain_group_ref_str); 
    124142    domain_hdl->sendAttributToServer(domain_hdl->domain_group_ref); 
     143     CTimer::get("XIOS").suspend(); 
    125144  } 
    126145   
    127146  void cxios_get_domain_domain_group_ref(domain_Ptr domain_hdl, char * domain_group_ref, int domain_group_ref_size) 
    128147  { 
     148     CTimer::get("XIOS").resume(); 
    129149    if(!string_copy(domain_hdl->domain_group_ref.getValue(),domain_group_ref , domain_group_ref_size)) 
    130150      ERROR("void cxios_get_domain_domain_group_ref(domain_Ptr domain_hdl, char * domain_group_ref, int domain_group_ref_size)", <<"Input string is to short"); 
     151     CTimer::get("XIOS").suspend(); 
    131152  } 
    132153   
    … …  
    134155  void cxios_set_domain_ibegin(domain_Ptr domain_hdl, int ibegin) 
    135156  { 
     157     CTimer::get("XIOS").resume(); 
    136158    domain_hdl->ibegin.setValue(ibegin); 
    137159    domain_hdl->sendAttributToServer(domain_hdl->ibegin); 
     160     CTimer::get("XIOS").suspend(); 
    138161  } 
    139162   
    … …  
    146169  void cxios_set_domain_iend(domain_Ptr domain_hdl, int iend) 
    147170  { 
     171     CTimer::get("XIOS").resume(); 
    148172    domain_hdl->iend.setValue(iend); 
    149173    domain_hdl->sendAttributToServer(domain_hdl->iend); 
     174     CTimer::get("XIOS").suspend(); 
    150175  } 
    151176   
    … …  
    158183  void cxios_set_domain_jbegin(domain_Ptr domain_hdl, int jbegin) 
    159184  { 
     185     CTimer::get("XIOS").resume(); 
    160186    domain_hdl->jbegin.setValue(jbegin); 
    161187    domain_hdl->sendAttributToServer(domain_hdl->jbegin); 
     188     CTimer::get("XIOS").suspend(); 
    162189  } 
    163190   
    … …  
    170197  void cxios_set_domain_jend(domain_Ptr domain_hdl, int jend) 
    171198  { 
     199     CTimer::get("XIOS").resume(); 
    172200    domain_hdl->jend.setValue(jend); 
    173201    domain_hdl->sendAttributToServer(domain_hdl->jend); 
     202     CTimer::get("XIOS").suspend(); 
    174203  } 
    175204   
    … …  
    182211  void cxios_set_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1) 
    183212  { 
     213     CTimer::get("XIOS").resume(); 
    184214    ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1])); 
    185215    std::copy(latvalue, &(latvalue[array_tmp->num_elements()]), array_tmp->data()); 
    … …  
    192222    if (!array_copy(domain_hdl->latvalue.getValue(), latvalue, extent1)) 
    193223     ERROR("void cxios_set_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     224     CTimer::get("XIOS").suspend(); 
    194225  } 
    195226   
    … …  
    199230    std::string long_name_str; 
    200231    if(!cstr2string(long_name, long_name_size, long_name_str)) return; 
     232     CTimer::get("XIOS").resume(); 
    201233    domain_hdl->long_name.setValue(long_name_str); 
    202234    domain_hdl->sendAttributToServer(domain_hdl->long_name); 
     235     CTimer::get("XIOS").suspend(); 
    203236  } 
    204237   
    205238  void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size) 
    206239  { 
     240     CTimer::get("XIOS").resume(); 
    207241    if(!string_copy(domain_hdl->long_name.getValue(),long_name , long_name_size)) 
    208242      ERROR("void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
     243     CTimer::get("XIOS").suspend(); 
    209244  } 
    210245   
    … …  
    212247  void cxios_set_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1) 
    213248  { 
     249     CTimer::get("XIOS").resume(); 
    214250    ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1])); 
    215251    std::copy(lonvalue, &(lonvalue[array_tmp->num_elements()]), array_tmp->data()); 
    … …  
    222258    if (!array_copy(domain_hdl->lonvalue.getValue(), lonvalue, extent1)) 
    223259     ERROR("void cxios_set_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     260     CTimer::get("XIOS").suspend(); 
    224261  } 
    225262   
    … …  
    227264  void cxios_set_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2) 
    228265  { 
     266     CTimer::get("XIOS").resume(); 
    229267    ARRAY(bool,2) array_tmp(new CArray<bool,2>(boost::extents[extent1][extent2])); 
    230268    std::copy(mask, &(mask[array_tmp->num_elements()]), array_tmp->data()); 
    … …  
    237275    if (!array_copy(domain_hdl->mask.getValue(), mask, extent1, extent2)) 
    238276     ERROR("void cxios_set_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2)",<<"Output array size is not conform to array size attribute") ; 
     277     CTimer::get("XIOS").suspend(); 
    239278  } 
    240279   
    … …  
    244283    std::string name_str; 
    245284    if(!cstr2string(name, name_size, name_str)) return; 
     285     CTimer::get("XIOS").resume(); 
    246286    domain_hdl->name.setValue(name_str); 
    247287    domain_hdl->sendAttributToServer(domain_hdl->name); 
     288     CTimer::get("XIOS").suspend(); 
    248289  } 
    249290   
    250291  void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size) 
    251292  { 
     293     CTimer::get("XIOS").resume(); 
    252294    if(!string_copy(domain_hdl->name.getValue(),name , name_size)) 
    253295      ERROR("void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)", <<"Input string is to short"); 
     296     CTimer::get("XIOS").suspend(); 
    254297  } 
    255298   
    … …  
    257300  void cxios_set_domain_ni(domain_Ptr domain_hdl, int ni) 
    258301  { 
     302     CTimer::get("XIOS").resume(); 
    259303    domain_hdl->ni.setValue(ni); 
    260304    domain_hdl->sendAttributToServer(domain_hdl->ni); 
     305     CTimer::get("XIOS").suspend(); 
    261306  } 
    262307   
    … …  
    269314  void cxios_set_domain_ni_glo(domain_Ptr domain_hdl, int ni_glo) 
    270315  { 
     316     CTimer::get("XIOS").resume(); 
    271317    domain_hdl->ni_glo.setValue(ni_glo); 
    272318    domain_hdl->sendAttributToServer(domain_hdl->ni_glo); 
     319     CTimer::get("XIOS").suspend(); 
    273320  } 
    274321   
    … …  
    281328  void cxios_set_domain_nj(domain_Ptr domain_hdl, int nj) 
    282329  { 
     330     CTimer::get("XIOS").resume(); 
    283331    domain_hdl->nj.setValue(nj); 
    284332    domain_hdl->sendAttributToServer(domain_hdl->nj); 
     333     CTimer::get("XIOS").suspend(); 
    285334  } 
    286335   
    … …  
    293342  void cxios_set_domain_nj_glo(domain_Ptr domain_hdl, int nj_glo) 
    294343  { 
     344     CTimer::get("XIOS").resume(); 
    295345    domain_hdl->nj_glo.setValue(nj_glo); 
    296346    domain_hdl->sendAttributToServer(domain_hdl->nj_glo); 
     347     CTimer::get("XIOS").suspend(); 
    297348  } 
    298349   
    … …  
    307358    std::string standard_name_str; 
    308359    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
     360     CTimer::get("XIOS").resume(); 
    309361    domain_hdl->standard_name.setValue(standard_name_str); 
    310362    domain_hdl->sendAttributToServer(domain_hdl->standard_name); 
     363     CTimer::get("XIOS").suspend(); 
    311364  } 
    312365   
    313366  void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size) 
    314367  { 
     368     CTimer::get("XIOS").resume(); 
    315369    if(!string_copy(domain_hdl->standard_name.getValue(),standard_name , standard_name_size)) 
    316370      ERROR("void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
     371     CTimer::get("XIOS").suspend(); 
    317372  } 
    318373   
    … …  
    320375  void cxios_set_domain_zoom_ibegin(domain_Ptr domain_hdl, int zoom_ibegin) 
    321376  { 
     377     CTimer::get("XIOS").resume(); 
    322378    domain_hdl->zoom_ibegin.setValue(zoom_ibegin); 
    323379    domain_hdl->sendAttributToServer(domain_hdl->zoom_ibegin); 
     380     CTimer::get("XIOS").suspend(); 
    324381  } 
    325382   
    … …  
    332389  void cxios_set_domain_zoom_ibegin_loc(domain_Ptr domain_hdl, int zoom_ibegin_loc) 
    333390  { 
     391     CTimer::get("XIOS").resume(); 
    334392    domain_hdl->zoom_ibegin_loc.setValue(zoom_ibegin_loc); 
    335393    domain_hdl->sendAttributToServer(domain_hdl->zoom_ibegin_loc); 
     394     CTimer::get("XIOS").suspend(); 
    336395  } 
    337396   
    … …  
    344403  void cxios_set_domain_zoom_jbegin(domain_Ptr domain_hdl, int zoom_jbegin) 
    345404  { 
     405     CTimer::get("XIOS").resume(); 
    346406    domain_hdl->zoom_jbegin.setValue(zoom_jbegin); 
    347407    domain_hdl->sendAttributToServer(domain_hdl->zoom_jbegin); 
     408     CTimer::get("XIOS").suspend(); 
    348409  } 
    349410   
    … …  
    356417  void cxios_set_domain_zoom_jbegin_loc(domain_Ptr domain_hdl, int zoom_jbegin_loc) 
    357418  { 
     419     CTimer::get("XIOS").resume(); 
    358420    domain_hdl->zoom_jbegin_loc.setValue(zoom_jbegin_loc); 
    359421    domain_hdl->sendAttributToServer(domain_hdl->zoom_jbegin_loc); 
     422     CTimer::get("XIOS").suspend(); 
    360423  } 
    361424   
    … …  
    368431  void cxios_set_domain_zoom_ni(domain_Ptr domain_hdl, int zoom_ni) 
    369432  { 
     433     CTimer::get("XIOS").resume(); 
    370434    domain_hdl->zoom_ni.setValue(zoom_ni); 
    371435    domain_hdl->sendAttributToServer(domain_hdl->zoom_ni); 
     436     CTimer::get("XIOS").suspend(); 
    372437  } 
    373438   
    … …  
    380445  void cxios_set_domain_zoom_ni_loc(domain_Ptr domain_hdl, int zoom_ni_loc) 
    381446  { 
     447     CTimer::get("XIOS").resume(); 
    382448    domain_hdl->zoom_ni_loc.setValue(zoom_ni_loc); 
    383449    domain_hdl->sendAttributToServer(domain_hdl->zoom_ni_loc); 
     450     CTimer::get("XIOS").suspend(); 
    384451  } 
    385452   
    … …  
    392459  void cxios_set_domain_zoom_nj(domain_Ptr domain_hdl, int zoom_nj) 
    393460  { 
     461     CTimer::get("XIOS").resume(); 
    394462    domain_hdl->zoom_nj.setValue(zoom_nj); 
    395463    domain_hdl->sendAttributToServer(domain_hdl->zoom_nj); 
     464     CTimer::get("XIOS").suspend(); 
    396465  } 
    397466   
    … …  
    404473  void cxios_set_domain_zoom_nj_loc(domain_Ptr domain_hdl, int zoom_nj_loc) 
    405474  { 
     475     CTimer::get("XIOS").resume(); 
    406476    domain_hdl->zoom_nj_loc.setValue(zoom_nj_loc); 
    407477    domain_hdl->sendAttributToServer(domain_hdl->zoom_nj_loc); 
     478     CTimer::get("XIOS").suspend(); 
    408479  } 
    409480   

  • XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp

    r345 r347  
    1010#include "group_template_impl.hpp" 
    1111#include "icutil.hpp" 
     12#include "timer.hpp" 
    1213 
    1314extern "C" 
    … …  
    1718  void cxios_set_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl, int data_dim) 
    1819  { 
     20     CTimer::get("XIOS").resume(); 
    1921    domaingroup_hdl->data_dim.setValue(data_dim); 
    2022    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_dim); 
     23     CTimer::get("XIOS").suspend(); 
    2124  } 
    2225   
    … …  
    2932  void cxios_set_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl, int* data_i_index, int extent1) 
    3033  { 
     34     CTimer::get("XIOS").resume(); 
    3135    ARRAY(int,1) array_tmp(new CArray<int,1>(boost::extents[extent1])); 
    3236    std::copy(data_i_index, &(data_i_index[array_tmp->num_elements()]), array_tmp->data()); 
    … …  
    3943    if (!array_copy(domaingroup_hdl->data_i_index.getValue(), data_i_index, extent1)) 
    4044     ERROR("void cxios_set_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl, int* data_i_index, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     45     CTimer::get("XIOS").suspend(); 
    4146  } 
    4247   
    … …  
    4449  void cxios_set_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl, int data_ibegin) 
    4550  { 
     51     CTimer::get("XIOS").resume(); 
    4652    domaingroup_hdl->data_ibegin.setValue(data_ibegin); 
    4753    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_ibegin); 
     54     CTimer::get("XIOS").suspend(); 
    4855  } 
    4956   
    … …  
    5663  void cxios_set_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl, int* data_j_index, int extent1) 
    5764  { 
     65     CTimer::get("XIOS").resume(); 
    5866    ARRAY(int,1) array_tmp(new CArray<int,1>(boost::extents[extent1])); 
    5967    std::copy(data_j_index, &(data_j_index[array_tmp->num_elements()]), array_tmp->data()); 
    … …  
    6674    if (!array_copy(domaingroup_hdl->data_j_index.getValue(), data_j_index, extent1)) 
    6775     ERROR("void cxios_set_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl, int* data_j_index, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     76     CTimer::get("XIOS").suspend(); 
    6877  } 
    6978   
    … …  
    7180  void cxios_set_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl, int data_jbegin) 
    7281  { 
     82     CTimer::get("XIOS").resume(); 
    7383    domaingroup_hdl->data_jbegin.setValue(data_jbegin); 
    7484    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_jbegin); 
     85     CTimer::get("XIOS").suspend(); 
    7586  } 
    7687   
    … …  
    8394  void cxios_set_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl, int data_n_index) 
    8495  { 
     96     CTimer::get("XIOS").resume(); 
    8597    domaingroup_hdl->data_n_index.setValue(data_n_index); 
    8698    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_n_index); 
     99     CTimer::get("XIOS").suspend(); 
    87100  } 
    88101   
    … …  
    95108  void cxios_set_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl, int data_ni) 
    96109  { 
     110     CTimer::get("XIOS").resume(); 
    97111    domaingroup_hdl->data_ni.setValue(data_ni); 
    98112    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_ni); 
     113     CTimer::get("XIOS").suspend(); 
    99114  } 
    100115   
    … …  
    107122  void cxios_set_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl, int data_nj) 
    108123  { 
     124     CTimer::get("XIOS").resume(); 
    109125    domaingroup_hdl->data_nj.setValue(data_nj); 
    110126    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_nj); 
     127     CTimer::get("XIOS").suspend(); 
    111128  } 
    112129   
    … …  
    121138    std::string domain_group_ref_str; 
    122139    if(!cstr2string(domain_group_ref, domain_group_ref_size, domain_group_ref_str)) return; 
     140     CTimer::get("XIOS").resume(); 
    123141    domaingroup_hdl->domain_group_ref.setValue(domain_group_ref_str); 
    124142    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->domain_group_ref); 
     143     CTimer::get("XIOS").suspend(); 
    125144  } 
    126145   
    127146  void cxios_get_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl, char * domain_group_ref, int domain_group_ref_size) 
    128147  { 
     148     CTimer::get("XIOS").resume(); 
    129149    if(!string_copy(domaingroup_hdl->domain_group_ref.getValue(),domain_group_ref , domain_group_ref_size)) 
    130150      ERROR("void cxios_get_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl, char * domain_group_ref, int domain_group_ref_size)", <<"Input string is to short"); 
     151     CTimer::get("XIOS").suspend(); 
    131152  } 
    132153   
    … …  
    136157    std::string group_ref_str; 
    137158    if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
     159     CTimer::get("XIOS").resume(); 
    138160    domaingroup_hdl->group_ref.setValue(group_ref_str); 
    139161    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->group_ref); 
     162     CTimer::get("XIOS").suspend(); 
    140163  } 
    141164   
    142165  void cxios_get_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, char * group_ref, int group_ref_size) 
    143166  { 
     167     CTimer::get("XIOS").resume(); 
    144168    if(!string_copy(domaingroup_hdl->group_ref.getValue(),group_ref , group_ref_size)) 
    145169      ERROR("void cxios_get_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
     170     CTimer::get("XIOS").suspend(); 
    146171  } 
    147172   
    … …  
    149174  void cxios_set_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl, int ibegin) 
    150175  { 
     176     CTimer::get("XIOS").resume(); 
    151177    domaingroup_hdl->ibegin.setValue(ibegin); 
    152178    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ibegin); 
     179     CTimer::get("XIOS").suspend(); 
    153180  } 
    154181   
    … …  
    161188  void cxios_set_domaingroup_iend(domaingroup_Ptr domaingroup_hdl, int iend) 
    162189  { 
     190     CTimer::get("XIOS").resume(); 
    163191    domaingroup_hdl->iend.setValue(iend); 
    164192    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->iend); 
     193     CTimer::get("XIOS").suspend(); 
    165194  } 
    166195   
    … …  
    173202  void cxios_set_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl, int jbegin) 
    174203  { 
     204     CTimer::get("XIOS").resume(); 
    175205    domaingroup_hdl->jbegin.setValue(jbegin); 
    176206    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->jbegin); 
     207     CTimer::get("XIOS").suspend(); 
    177208  } 
    178209   
    … …  
    185216  void cxios_set_domaingroup_jend(domaingroup_Ptr domaingroup_hdl, int jend) 
    186217  { 
     218     CTimer::get("XIOS").resume(); 
    187219    domaingroup_hdl->jend.setValue(jend); 
    188220    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->jend); 
     221     CTimer::get("XIOS").suspend(); 
    189222  } 
    190223   
    … …  
    197230  void cxios_set_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1) 
    198231  { 
     232     CTimer::get("XIOS").resume(); 
    199233    ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1])); 
    200234    std::copy(latvalue, &(latvalue[array_tmp->num_elements()]), array_tmp->data()); 
    … …  
    207241    if (!array_copy(domaingroup_hdl->latvalue.getValue(), latvalue, extent1)) 
    208242     ERROR("void cxios_set_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     243     CTimer::get("XIOS").suspend(); 
    209244  } 
    210245   
    … …  
    214249    std::string long_name_str; 
    215250    if(!cstr2string(long_name, long_name_size, long_name_str)) return; 
     251     CTimer::get("XIOS").resume(); 
    216252    domaingroup_hdl->long_name.setValue(long_name_str); 
    217253    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->long_name); 
     254     CTimer::get("XIOS").suspend(); 
    218255  } 
    219256   
    220257  void cxios_get_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, char * long_name, int long_name_size) 
    221258  { 
     259     CTimer::get("XIOS").resume(); 
    222260    if(!string_copy(domaingroup_hdl->long_name.getValue(),long_name , long_name_size)) 
    223261      ERROR("void cxios_get_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
     262     CTimer::get("XIOS").suspend(); 
    224263  } 
    225264   
    … …  
    227266  void cxios_set_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1) 
    228267  { 
     268     CTimer::get("XIOS").resume(); 
    229269    ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1])); 
    230270    std::copy(lonvalue, &(lonvalue[array_tmp->num_elements()]), array_tmp->data()); 
    … …  
    237277    if (!array_copy(domaingroup_hdl->lonvalue.getValue(), lonvalue, extent1)) 
    238278     ERROR("void cxios_set_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1)",<<"Output array size is not conform to array size attribute") ; 
     279     CTimer::get("XIOS").suspend(); 
    239280  } 
    240281   
    … …  
    242283  void cxios_set_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2) 
    243284  { 
     285     CTimer::get("XIOS").resume(); 
    244286    ARRAY(bool,2) array_tmp(new CArray<bool,2>(boost::extents[extent1][extent2])); 
    245287    std::copy(mask, &(mask[array_tmp->num_elements()]), array_tmp->data()); 
    … …  
    252294    if (!array_copy(domaingroup_hdl->mask.getValue(), mask, extent1, extent2)) 
    253295     ERROR("void cxios_set_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2)",<<"Output array size is not conform to array size attribute") ; 
     296     CTimer::get("XIOS").suspend(); 
    254297  } 
    255298   
    … …  
    259302    std::string name_str; 
    260303    if(!cstr2string(name, name_size, name_str)) return; 
     304     CTimer::get("XIOS").resume(); 
    261305    domaingroup_hdl->name.setValue(name_str); 
    262306    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->name); 
     307     CTimer::get("XIOS").suspend(); 
    263308  } 
    264309   
    265310  void cxios_get_domaingroup_name(domaingroup_Ptr domaingroup_hdl, char * name, int name_size) 
    266311  { 
     312     CTimer::get("XIOS").resume(); 
    267313    if(!string_copy(domaingroup_hdl->name.getValue(),name , name_size)) 
    268314      ERROR("void cxios_get_domaingroup_name(domaingroup_Ptr domaingroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
     315     CTimer::get("XIOS").suspend(); 
    269316  } 
    270317   
    … …  
    272319  void cxios_set_domaingroup_ni(domaingroup_Ptr domaingroup_hdl, int ni) 
    273320  { 
     321     CTimer::get("XIOS").resume(); 
    274322    domaingroup_hdl->ni.setValue(ni); 
    275323    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ni); 
     324     CTimer::get("XIOS").suspend(); 
    276325  } 
    277326   
    … …  
    284333  void cxios_set_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl, int ni_glo) 
    285334  { 
     335     CTimer::get("XIOS").resume(); 
    286336    domaingroup_hdl->ni_glo.setValue(ni_glo); 
    287337    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ni_glo); 
     338     CTimer::get("XIOS").suspend(); 
    288339  } 
    289340   
    … …  
    296347  void cxios_set_domaingroup_nj(domaingroup_Ptr domaingroup_hdl, int nj) 
    297348  { 
     349     CTimer::get("XIOS").resume(); 
    298350    domaingroup_hdl->nj.setValue(nj); 
    299351    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->nj); 
     352     CTimer::get("XIOS").suspend(); 
    300353  } 
    301354   
    … …  
    308361  void cxios_set_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl, int nj_glo) 
    309362  { 
     363     CTimer::get("XIOS").resume(); 
    310364    domaingroup_hdl->nj_glo.setValue(nj_glo); 
    311365    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->nj_glo); 
     366     CTimer::get("XIOS").suspend(); 
    312367  } 
    313368   
    … …  
    322377    std::string standard_name_str; 
    323378    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
     379     CTimer::get("XIOS").resume(); 
    324380    domaingroup_hdl->standard_name.setValue(standard_name_str); 
    325381    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->standard_name); 
     382     CTimer::get("XIOS").suspend(); 
    326383  } 
    327384   
    328385  void cxios_get_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, char * standard_name, int standard_name_size) 
    329386  { 
     387     CTimer::get("XIOS").resume(); 
    330388    if(!string_copy(domaingroup_hdl->standard_name.getValue(),standard_name , standard_name_size)) 
    331389      ERROR("void cxios_get_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
     390     CTimer::get("XIOS").suspend(); 
    332391  } 
    333392   
    … …  
    335394  void cxios_set_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl, int zoom_ibegin) 
    336395  { 
     396     CTimer::get("XIOS").resume(); 
    337397    domaingroup_hdl->zoom_ibegin.setValue(zoom_ibegin); 
    338398    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ibegin); 
     399     CTimer::get("XIOS").suspend(); 
    339400  } 
    340401   
    … …  
    347408  void cxios_set_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl, int zoom_ibegin_loc) 
    348409  { 
     410     CTimer::get("XIOS").resume(); 
    349411    domaingroup_hdl->zoom_ibegin_loc.setValue(zoom_ibegin_loc); 
    350412    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ibegin_loc); 
     413     CTimer::get("XIOS").suspend(); 
    351414  } 
    352415   
    … …  
    359422  void cxios_set_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl, int zoom_jbegin) 
    360423  { 
     424     CTimer::get("XIOS").resume(); 
    361425    domaingroup_hdl->zoom_jbegin.setValue(zoom_jbegin); 
    362426    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_jbegin); 
     427     CTimer::get("XIOS").suspend(); 
    363428  } 
    364429   
    … …  
    371436  void cxios_set_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl, int zoom_jbegin_loc) 
    372437  { 
     438     CTimer::get("XIOS").resume(); 
    373439    domaingroup_hdl->zoom_jbegin_loc.setValue(zoom_jbegin_loc); 
    374440    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_jbegin_loc); 
     441     CTimer::get("XIOS").suspend(); 
    375442  } 
    376443   
    … …  
    383450  void cxios_set_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl, int zoom_ni) 
    384451  { 
     452     CTimer::get("XIOS").resume(); 
    385453    domaingroup_hdl->zoom_ni.setValue(zoom_ni); 
    386454    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ni); 
     455     CTimer::get("XIOS").suspend(); 
    387456  } 
    388457   
    … …  
    395464  void cxios_set_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl, int zoom_ni_loc) 
    396465  { 
     466     CTimer::get("XIOS").resume(); 
    397467    domaingroup_hdl->zoom_ni_loc.setValue(zoom_ni_loc); 
    398468    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ni_loc); 
     469     CTimer::get("XIOS").suspend(); 
    399470  } 
    400471   
    … …  
    407478  void cxios_set_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl, int zoom_nj) 
    408479  { 
     480     CTimer::get("XIOS").resume(); 
    409481    domaingroup_hdl->zoom_nj.setValue(zoom_nj); 
    410482    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_nj); 
     483     CTimer::get("XIOS").suspend(); 
    411484  } 
    412485   
    … …  
    419492  void cxios_set_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl, int zoom_nj_loc) 
    420493  { 
     494     CTimer::get("XIOS").resume(); 
    421495    domaingroup_hdl->zoom_nj_loc.setValue(zoom_nj_loc); 
    422496    domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_nj_loc); 
     497     CTimer::get("XIOS").suspend(); 
    423498  } 
    424499   

  • XIOS/trunk/src/interface/c_attr/icfield_attr.cpp

    r345 r347  
    1010#include "group_template_impl.hpp" 
    1111#include "icutil.hpp" 
     12#include "timer.hpp" 
    1213 
    1314extern "C" 
    … …  
    1920    std::string axis_ref_str; 
    2021    if(!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return; 
     22     CTimer::get("XIOS").resume(); 
    2123    field_hdl->axis_ref.setValue(axis_ref_str); 
    2224    field_hdl->sendAttributToServer(field_hdl->axis_ref); 
     25     CTimer::get("XIOS").suspend(); 
    2326  } 
    2427   
    2528  void cxios_get_field_axis_ref(field_Ptr field_hdl, char * axis_ref, int axis_ref_size) 
    2629  { 
     30     CTimer::get("XIOS").resume(); 
    2731    if(!string_copy(field_hdl->axis_ref.getValue(),axis_ref , axis_ref_size)) 
    2832      ERROR("void cxios_get_field_axis_ref(field_Ptr field_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short"); 
     33     CTimer::get("XIOS").suspend(); 
    2934  } 
    3035   
    … …  
    3237  void cxios_set_field_default_value(field_Ptr field_hdl, double default_value) 
    3338  { 
     39     CTimer::get("XIOS").resume(); 
    3440    field_hdl->default_value.setValue(default_value); 
    3541    field_hdl->sendAttributToServer(field_hdl->default_value); 
     42     CTimer::get("XIOS").suspend(); 
    3643  } 
    3744   
    … …  
    4653    std::string domain_ref_str; 
    4754    if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return; 
     55     CTimer::get("XIOS").resume(); 
    4856    field_hdl->domain_ref.setValue(domain_ref_str); 
    4957    field_hdl->sendAttributToServer(field_hdl->domain_ref); 
     58     CTimer::get("XIOS").suspend(); 
    5059  } 
    5160   
    5261  void cxios_get_field_domain_ref(field_Ptr field_hdl, char * domain_ref, int domain_ref_size) 
    5362  { 
     63     CTimer::get("XIOS").resume(); 
    5464    if(!string_copy(field_hdl->domain_ref.getValue(),domain_ref , domain_ref_size)) 
    5565      ERROR("void cxios_get_field_domain_ref(field_Ptr field_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short"); 
     66     CTimer::get("XIOS").suspend(); 
    5667  } 
    5768   
    … …  
    5970  void cxios_set_field_enabled(field_Ptr field_hdl, bool enabled) 
    6071  { 
     72     CTimer::get("XIOS").resume(); 
    6173    field_hdl->enabled.setValue(enabled); 
    6274    field_hdl->sendAttributToServer(field_hdl->enabled); 
     75     CTimer::get("XIOS").suspend(); 
    6376  } 
    6477   
    … …  
    7386    std::string field_ref_str; 
    7487    if(!cstr2string(field_ref, field_ref_size, field_ref_str)) return; 
     88     CTimer::get("XIOS").resume(); 
    7589    field_hdl->field_ref.setValue(field_ref_str); 
    7690    field_hdl->sendAttributToServer(field_hdl->field_ref); 
     91     CTimer::get("XIOS").suspend(); 
    7792  } 
    7893   
    7994  void cxios_get_field_field_ref(field_Ptr field_hdl, char * field_ref, int field_ref_size) 
    8095  { 
     96     CTimer::get("XIOS").resume(); 
    8197    if(!string_copy(field_hdl->field_ref.getValue(),field_ref , field_ref_size)) 
    8298      ERROR("void cxios_get_field_field_ref(field_Ptr field_hdl, char * field_ref, int field_ref_size)", <<"Input string is to short"); 
     99     CTimer::get("XIOS").suspend(); 
    83100  } 
    84101   
    … …  
    88105    std::string freq_offset_str; 
    89106    if(!cstr2string(freq_offset, freq_offset_size, freq_offset_str)) return; 
     107     CTimer::get("XIOS").resume(); 
    90108    field_hdl->freq_offset.setValue(freq_offset_str); 
    91109    field_hdl->sendAttributToServer(field_hdl->freq_offset); 
     110     CTimer::get("XIOS").suspend(); 
    92111  } 
    93112   
    94113  void cxios_get_field_freq_offset(field_Ptr field_hdl, char * freq_offset, int freq_offset_size) 
    95114  { 
     115     CTimer::get("XIOS").resume(); 
    96116    if(!string_copy(field_hdl->freq_offset.getValue(),freq_offset , freq_offset_size)) 
    97117      ERROR("void cxios_get_field_freq_offset(field_Ptr field_hdl, char * freq_offset, int freq_offset_size)", <<"Input string is to short"); 
     118     CTimer::get("XIOS").suspend(); 
    98119  } 
    99120   
    … …  
    103124    std::string freq_op_str; 
    104125    if(!cstr2string(freq_op, freq_op_size, freq_op_str)) return; 
     126     CTimer::get("XIOS").resume(); 
    105127    field_hdl->freq_op.setValue(freq_op_str); 
    106128    field_hdl->sendAttributToServer(field_hdl->freq_op); 
     129     CTimer::get("XIOS").suspend(); 
    107130  } 
    108131   
    109132  void cxios_get_field_freq_op(field_Ptr field_hdl, char * freq_op, int freq_op_size) 
    110133  { 
     134     CTimer::get("XIOS").resume(); 
    111135    if(!string_copy(field_hdl->freq_op.getValue(),freq_op , freq_op_size)) 
    112136      ERROR("void cxios_get_field_freq_op(field_Ptr field_hdl, char * freq_op, int freq_op_size)", <<"Input string is to short"); 
     137     CTimer::get("XIOS").suspend(); 
    113138  } 
    114139   
    … …  
    118143    std::string grid_ref_str; 
    119144    if(!cstr2string(grid_ref, grid_ref_size, grid_ref_str)) return; 
     145     CTimer::get("XIOS").resume(); 
    120146    field_hdl->grid_ref.setValue(grid_ref_str); 
    121147    field_hdl->sendAttributToServer(field_hdl->grid_ref); 
     148     CTimer::get("XIOS").suspend(); 
    122149  } 
    123150   
    124151  void cxios_get_field_grid_ref(field_Ptr field_hdl, char * grid_ref, int grid_ref_size) 
    125152  { 
     153     CTimer::get("XIOS").resume(); 
    126154    if(!string_copy(field_hdl->grid_ref.getValue(),grid_ref , grid_ref_size)) 
    127155      ERROR("void cxios_get_field_grid_ref(field_Ptr field_hdl, char * grid_ref, int grid_ref_size)", <<"Input string is to short"); 
     156     CTimer::get("XIOS").suspend(); 
    128157  } 
    129158   
    … …  
    131160  void cxios_set_field_level(field_Ptr field_hdl, int level) 
    132161  { 
     162     CTimer::get("XIOS").resume(); 
    133163    field_hdl->level.setValue(level); 
    134164    field_hdl->sendAttributToServer(field_hdl->level); 
     165     CTimer::get("XIOS").suspend(); 
    135166  } 
    136167   
    … …  
    145176    std::string long_name_str; 
    146177    if(!cstr2string(long_name, long_name_size, long_name_str)) return; 
     178     CTimer::get("XIOS").resume(); 
    147179    field_hdl->long_name.setValue(long_name_str); 
    148180    field_hdl->sendAttributToServer(field_hdl->long_name); 
     181     CTimer::get("XIOS").suspend(); 
    149182  } 
    150183   
    151184  void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size) 
    152185  { 
     186     CTimer::get("XIOS").resume(); 
    153187    if(!string_copy(field_hdl->long_name.getValue(),long_name , long_name_size)) 
    154188      ERROR("void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
     189     CTimer::get("XIOS").suspend(); 
    155190  } 
    156191   
    … …  
    160195    std::string name_str; 
    161196    if(!cstr2string(name, name_size, name_str)) return; 
     197     CTimer::get("XIOS").resume(); 
    162198    field_hdl->name.setValue(name_str); 
    163199    field_hdl->sendAttributToServer(field_hdl->name); 
     200     CTimer::get("XIOS").suspend(); 
    164201  } 
    165202   
    166203  void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size) 
    167204  { 
     205     CTimer::get("XIOS").resume(); 
    168206    if(!string_copy(field_hdl->name.getValue(),name , name_size)) 
    169207      ERROR("void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)", <<"Input string is to short"); 
     208     CTimer::get("XIOS").suspend(); 
    170209  } 
    171210   
    … …  
    175214    std::string operation_str; 
    176215    if(!cstr2string(operation, operation_size, operation_str)) return; 
     216     CTimer::get("XIOS").resume(); 
    177217    field_hdl->operation.setValue(operation_str); 
    178218    field_hdl->sendAttributToServer(field_hdl->operation); 
     219     CTimer::get("XIOS").suspend(); 
    179220  } 
    180221   
    181222  void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size) 
    182223  { 
     224     CTimer::get("XIOS").resume(); 
    183225    if(!string_copy(field_hdl->operation.getValue(),operation , operation_size)) 
    184226      ERROR("void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)", <<"Input string is to short"); 
     227     CTimer::get("XIOS").suspend(); 
    185228  } 
    186229   
    … …  
    188231  void cxios_set_field_prec(field_Ptr field_hdl, int prec) 
    189232  { 
     233     CTimer::get("XIOS").resume(); 
    190234    field_hdl->prec.setValue(prec); 
    191235    field_hdl->sendAttributToServer(field_hdl->prec); 
     236     CTimer::get("XIOS").suspend(); 
    192237  } 
    193238   
    … …  
    202247    std::string standard_name_str; 
    203248    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
     249     CTimer::get("XIOS").resume(); 
    204250    field_hdl->standard_name.setValue(standard_name_str); 
    205251    field_hdl->sendAttributToServer(field_hdl->standard_name); 
     252     CTimer::get("XIOS").suspend(); 
    206253  } 
    207254   
    208255  void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size) 
    209256  { 
     257     CTimer::get("XIOS").resume(); 
    210258    if(!string_copy(field_hdl->standard_name.getValue(),standard_name , standard_name_size)) 
    211259      ERROR("void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
     260     CTimer::get("XIOS").suspend(); 
    212261  } 
    213262   
    … …  
    217266    std::string unit_str; 
    218267    if(!cstr2string(unit, unit_size, unit_str)) return; 
     268     CTimer::get("XIOS").resume(); 
    219269    field_hdl->unit.setValue(unit_str); 
    220270    field_hdl->sendAttributToServer(field_hdl->unit); 
     271     CTimer::get("XIOS").suspend(); 
    221272  } 
    222273   
    223274  void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size) 
    224275  { 
     276     CTimer::get("XIOS").resume(); 
    225277    if(!string_copy(field_hdl->unit.getValue(),unit , unit_size)) 
    226278      ERROR("void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)", <<"Input string is to short"); 
     279     CTimer::get("XIOS").suspend(); 
    227280  } 
    228281   

  • XIOS/trunk/src/interface/c_attr/icfieldgroup_attr.cpp

    r345 r347  
    1010#include "group_template_impl.hpp" 
    1111#include "icutil.hpp" 
     12#include "timer.hpp" 
    1213 
    1314extern "C" 
    … …  
    1920    std::string axis_ref_str; 
    2021    if(!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return; 
     22     CTimer::get("XIOS").resume(); 
    2123    fieldgroup_hdl->axis_ref.setValue(axis_ref_str); 
    2224    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->axis_ref); 
     25     CTimer::get("XIOS").suspend(); 
    2326  } 
    2427   
    2528  void cxios_get_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, char * axis_ref, int axis_ref_size) 
    2629  { 
     30     CTimer::get("XIOS").resume(); 
    2731    if(!string_copy(fieldgroup_hdl->axis_ref.getValue(),axis_ref , axis_ref_size)) 
    2832      ERROR("void cxios_get_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short"); 
     33     CTimer::get("XIOS").suspend(); 
    2934  } 
    3035   
    … …  
    3237  void cxios_set_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl, double default_value) 
    3338  { 
     39     CTimer::get("XIOS").resume(); 
    3440    fieldgroup_hdl->default_value.setValue(default_value); 
    3541    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->default_value); 
     42     CTimer::get("XIOS").suspend(); 
    3643  } 
    3744   
    … …  
    4653    std::string domain_ref_str; 
    4754    if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return; 
     55     CTimer::get("XIOS").resume(); 
    4856    fieldgroup_hdl->domain_ref.setValue(domain_ref_str); 
    4957    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->domain_ref); 
     58     CTimer::get("XIOS").suspend(); 
    5059  } 
    5160   
    5261  void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, char * domain_ref, int domain_ref_size) 
    5362  { 
     63     CTimer::get("XIOS").resume(); 
    5464    if(!string_copy(fieldgroup_hdl->domain_ref.getValue(),domain_ref , domain_ref_size)) 
    5565      ERROR("void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short"); 
     66     CTimer::get("XIOS").suspend(); 
    5667  } 
    5768   
    … …  
    5970  void cxios_set_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl, bool enabled) 
    6071  { 
     72     CTimer::get("XIOS").resume(); 
    6173    fieldgroup_hdl->enabled.setValue(enabled); 
    6274    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->enabled); 
     75     CTimer::get("XIOS").suspend(); 
    6376  } 
    6477   
    … …  
    7386    std::string field_ref_str; 
    7487    if(!cstr2string(field_ref, field_ref_size, field_ref_str)) return; 
     88     CTimer::get("XIOS").resume(); 
    7589    fieldgroup_hdl->field_ref.setValue(field_ref_str); 
    7690    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->field_ref); 
     91     CTimer::get("XIOS").suspend(); 
    7792  } 
    7893   
    7994  void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, char * field_ref, int field_ref_size) 
    8095  { 
     96     CTimer::get("XIOS").resume(); 
    8197    if(!string_copy(fieldgroup_hdl->field_ref.getValue(),field_ref , field_ref_size)) 
    8298      ERROR("void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, char * field_ref, int field_ref_size)", <<"Input string is to short"); 
     99     CTimer::get("XIOS").suspend(); 
    83100  } 
    84101   
    … …  
    88105    std::string freq_offset_str; 
    89106    if(!cstr2string(freq_offset, freq_offset_size, freq_offset_str)) return; 
     107     CTimer::get("XIOS").resume(); 
    90108    fieldgroup_hdl->freq_offset.setValue(freq_offset_str); 
    91109    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->freq_offset); 
     110     CTimer::get("XIOS").suspend(); 
    92111  } 
    93112   
    94113  void cxios_get_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, char * freq_offset, int freq_offset_size) 
    95114  { 
     115     CTimer::get("XIOS").resume(); 
    96116    if(!string_copy(fieldgroup_hdl->freq_offset.getValue(),freq_offset , freq_offset_size)) 
    97117      ERROR("void cxios_get_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, char * freq_offset, int freq_offset_size)", <<"Input string is to short"); 
     118     CTimer::get("XIOS").suspend(); 
    98119  } 
    99120   
    … …  
    103124    std::string freq_op_str; 
    104125    if(!cstr2string(freq_op, freq_op_size, freq_op_str)) return; 
     126     CTimer::get("XIOS").resume(); 
    105127    fieldgroup_hdl->freq_op.setValue(freq_op_str); 
    106128    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->freq_op); 
     129     CTimer::get("XIOS").suspend(); 
    107130  } 
    108131   
    109132  void cxios_get_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, char * freq_op, int freq_op_size) 
    110133  { 
     134     CTimer::get("XIOS").resume(); 
    111135    if(!string_copy(fieldgroup_hdl->freq_op.getValue(),freq_op , freq_op_size)) 
    112136      ERROR("void cxios_get_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, char * freq_op, int freq_op_size)", <<"Input string is to short"); 
     137     CTimer::get("XIOS").suspend(); 
    113138  } 
    114139   
    … …  
    118143    std::string grid_ref_str; 
    119144    if(!cstr2string(grid_ref, grid_ref_size, grid_ref_str)) return; 
     145     CTimer::get("XIOS").resume(); 
    120146    fieldgroup_hdl->grid_ref.setValue(grid_ref_str); 
    121147    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->grid_ref); 
     148     CTimer::get("XIOS").suspend(); 
    122149  } 
    123150   
    124151  void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, char * grid_ref, int grid_ref_size) 
    125152  { 
     153     CTimer::get("XIOS").resume(); 
    126154    if(!string_copy(fieldgroup_hdl->grid_ref.getValue(),grid_ref , grid_ref_size)) 
    127155      ERROR("void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, char * grid_ref, int grid_ref_size)", <<"Input string is to short"); 
     156     CTimer::get("XIOS").suspend(); 
    128157  } 
    129158   
    … …  
    133162    std::string group_ref_str; 
    134163    if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
     164     CTimer::get("XIOS").resume(); 
    135165    fieldgroup_hdl->group_ref.setValue(group_ref_str); 
    136166    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->group_ref); 
     167     CTimer::get("XIOS").suspend(); 
    137168  } 
    138169   
    139170  void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size) 
    140171  { 
     172     CTimer::get("XIOS").resume(); 
    141173    if(!string_copy(fieldgroup_hdl->group_ref.getValue(),group_ref , group_ref_size)) 
    142174      ERROR("void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
     175     CTimer::get("XIOS").suspend(); 
    143176  } 
    144177   
    … …  
    146179  void cxios_set_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int level) 
    147180  { 
     181     CTimer::get("XIOS").resume(); 
    148182    fieldgroup_hdl->level.setValue(level); 
    149183    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->level); 
     184     CTimer::get("XIOS").suspend(); 
    150185  } 
    151186   
    … …  
    160195    std::string long_name_str; 
    161196    if(!cstr2string(long_name, long_name_size, long_name_str)) return; 
     197     CTimer::get("XIOS").resume(); 
    162198    fieldgroup_hdl->long_name.setValue(long_name_str); 
    163199    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->long_name); 
     200     CTimer::get("XIOS").suspend(); 
    164201  } 
    165202   
    166203  void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size) 
    167204  { 
     205     CTimer::get("XIOS").resume(); 
    168206    if(!string_copy(fieldgroup_hdl->long_name.getValue(),long_name , long_name_size)) 
    169207      ERROR("void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short"); 
     208     CTimer::get("XIOS").suspend(); 
    170209  } 
    171210   
    … …  
    175214    std::string name_str; 
    176215    if(!cstr2string(name, name_size, name_str)) return; 
     216     CTimer::get("XIOS").resume(); 
    177217    fieldgroup_hdl->name.setValue(name_str); 
    178218    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->name); 
     219     CTimer::get("XIOS").suspend(); 
    179220  } 
    180221   
    181222  void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size) 
    182223  { 
     224     CTimer::get("XIOS").resume(); 
    183225    if(!string_copy(fieldgroup_hdl->name.getValue(),name , name_size)) 
    184226      ERROR("void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
     227     CTimer::get("XIOS").suspend(); 
    185228  } 
    186229   
    … …  
    190233    std::string operation_str; 
    191234    if(!cstr2string(operation, operation_size, operation_str)) return; 
     235     CTimer::get("XIOS").resume(); 
    192236    fieldgroup_hdl->operation.setValue(operation_str); 
    193237    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->operation); 
     238     CTimer::get("XIOS").suspend(); 
    194239  } 
    195240   
    196241  void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size) 
    197242  { 
     243     CTimer::get("XIOS").resume(); 
    198244    if(!string_copy(fieldgroup_hdl->operation.getValue(),operation , operation_size)) 
    199245      ERROR("void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size)", <<"Input string is to short"); 
     246     CTimer::get("XIOS").suspend(); 
    200247  } 
    201248   
    … …  
    203250  void cxios_set_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl, int prec) 
    204251  { 
     252     CTimer::get("XIOS").resume(); 
    205253    fieldgroup_hdl->prec.setValue(prec); 
    206254    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->prec); 
     255     CTimer::get("XIOS").suspend(); 
    207256  } 
    208257   
    … …  
    217266    std::string standard_name_str; 
    218267    if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return; 
     268     CTimer::get("XIOS").resume(); 
    219269    fieldgroup_hdl->standard_name.setValue(standard_name_str); 
    220270    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->standard_name); 
     271     CTimer::get("XIOS").suspend(); 
    221272  } 
    222273   
    223274  void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size) 
    224275  { 
     276     CTimer::get("XIOS").resume(); 
    225277    if(!string_copy(fieldgroup_hdl->standard_name.getValue(),standard_name , standard_name_size)) 
    226278      ERROR("void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short"); 
     279     CTimer::get("XIOS").suspend(); 
    227280  } 
    228281   
    … …  
    232285    std::string unit_str; 
    233286    if(!cstr2string(unit, unit_size, unit_str)) return; 
     287     CTimer::get("XIOS").resume(); 
    234288    fieldgroup_hdl->unit.setValue(unit_str); 
    235289    fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->unit); 
     290     CTimer::get("XIOS").suspend(); 
    236291  } 
    237292   
    238293  void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size) 
    239294  { 
     295     CTimer::get("XIOS").resume(); 
    240296    if(!string_copy(fieldgroup_hdl->unit.getValue(),unit , unit_size)) 
    241297      ERROR("void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size)", <<"Input string is to short"); 
     298     CTimer::get("XIOS").suspend(); 
    242299  } 
    243300   

  • XIOS/trunk/src/interface/c_attr/icfile_attr.cpp

    r345 r347  
    1010#include "group_template_impl.hpp" 
    1111#include "icutil.hpp" 
     12#include "timer.hpp" 
    1213 
    1314extern "C" 
    … …  
    1920    std::string description_str; 
    2021    if(!cstr2string(description, description_size, description_str)) return; 
     22     CTimer::get("XIOS").resume(); 
    2123    file_hdl->description.setValue(description_str); 
    2224    file_hdl->sendAttributToServer(file_hdl->description); 
     25     CTimer::get("XIOS").suspend(); 
    2326  } 
    2427   
    2528  void cxios_get_file_description(file_Ptr file_hdl, char * description, int description_size) 
    2629  { 
     30     CTimer::get("XIOS").resume(); 
    2731    if(!string_copy(file_hdl->description.getValue(),description , description_size)) 
    2832      ERROR("void cxios_get_file_description(file_Ptr file_hdl, char * description, int description_size)", <<"Input string is to short"); 
     33     CTimer::get("XIOS").suspend(); 
    2934  } 
    3035   
    … …  
    3237  void cxios_set_file_enabled(file_Ptr file_hdl, bool enabled) 
    3338  { 
     39     CTimer::get("XIOS").resume(); 
    3440    file_hdl->enabled.setValue(enabled); 
    3541    file_hdl->sendAttributToServer(file_hdl->enabled); 
     42     CTimer::get("XIOS").suspend(); 
    3643  } 
    3744   
    … …  
    4653    std::string name_str; 
    4754    if(!cstr2string(name, name_size, name_str)) return; 
     55     CTimer::get("XIOS").resume(); 
    4856    file_hdl->name.setValue(name_str); 
    4957    file_hdl->sendAttributToServer(file_hdl->name); 
     58     CTimer::get("XIOS").suspend(); 
    5059  } 
    5160   
    5261  void cxios_get_file_name(file_Ptr file_hdl, char * name, int name_size) 
    5362  { 
     63     CTimer::get("XIOS").resume(); 
    5464    if(!string_copy(file_hdl->name.getValue(),name , name_size)) 
    5565      ERROR("void cxios_get_file_name(file_Ptr file_hdl, char * name, int name_size)", <<"Input string is to short"); 
     66     CTimer::get("XIOS").suspend(); 
    5667  } 
    5768   
    … …  
    6172    std::string name_suffix_str; 
    6273    if(!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return; 
     74     CTimer::get("XIOS").resume(); 
    6375    file_hdl->name_suffix.setValue(name_suffix_str); 
    6476    file_hdl->sendAttributToServer(file_hdl->name_suffix); 
     77     CTimer::get("XIOS").suspend(); 
    6578  } 
    6679   
    6780  void cxios_get_file_name_suffix(file_Ptr file_hdl, char * name_suffix, int name_suffix_size) 
    6881  { 
     82     CTimer::get("XIOS").resume(); 
    6983    if(!string_copy(file_hdl->name_suffix.getValue(),name_suffix , name_suffix_size)) 
    7084      ERROR("void cxios_get_file_name_suffix(file_Ptr file_hdl, char * name_suffix, int name_suffix_size)", <<"Input string is to short"); 
     85     CTimer::get("XIOS").suspend(); 
    7186  } 
    7287   
    … …  
    7691    std::string output_freq_str; 
    7792    if(!cstr2string(output_freq, output_freq_size, output_freq_str)) return; 
     93     CTimer::get("XIOS").resume(); 
    7894    file_hdl->output_freq.setValue(output_freq_str); 
    7995    file_hdl->sendAttributToServer(file_hdl->output_freq); 
     96     CTimer::get("XIOS").suspend(); 
    8097  } 
    8198   
    8299  void cxios_get_file_output_freq(file_Ptr file_hdl, char * output_freq, int output_freq_size) 
    83100  { 
     101     CTimer::get("XIOS").resume(); 
    84102    if(!string_copy(file_hdl->output_freq.getValue(),output_freq , output_freq_size)) 
    85103      ERROR("void cxios_get_file_output_freq(file_Ptr file_hdl, char * output_freq, int output_freq_size)", <<"Input string is to short"); 
     104     CTimer::get("XIOS").suspend(); 
    86105  } 
    87106   
    … …  
    89108  void cxios_set_file_output_level(file_Ptr file_hdl, int output_level) 
    90109  { 
     110     CTimer::get("XIOS").resume(); 
    91111    file_hdl->output_level.setValue(output_level); 
    92112    file_hdl->sendAttributToServer(file_hdl->output_level); 
     113     CTimer::get("XIOS").suspend(); 
    93114  } 
    94115   
    … …  
    103124    std::string par_access_str; 
    104125    if(!cstr2string(par_access, par_access_size, par_access_str)) return; 
     126     CTimer::get("XIOS").resume(); 
    105127    file_hdl->par_access.setValue(par_access_str); 
    106128    file_hdl->sendAttributToServer(file_hdl->par_access); 
     129     CTimer::get("XIOS").suspend(); 
    107130  } 
    108131   
    109132  void cxios_get_file_par_access(file_Ptr file_hdl, char * par_access, int par_access_size) 
    110133  { 
     134     CTimer::get("XIOS").resume(); 
    111135    if(!string_copy(file_hdl->par_access.getValue(),par_access , par_access_size)) 
    112136      ERROR("void cxios_get_file_par_access(file_Ptr file_hdl, char * par_access, int par_access_size)", <<"Input string is to short"); 
     137     CTimer::get("XIOS").suspend(); 
    113138  } 
    114139   
    … …  
    118143    std::string split_freq_str; 
    119144    if(!cstr2string(split_freq, split_freq_size, split_freq_str)) return; 
     145     CTimer::get("XIOS").resume(); 
    120146    file_hdl->split_freq.setValue(split_freq_str); 
    121147    file_hdl->sendAttributToServer(file_hdl->split_freq); 
     148     CTimer::get("XIOS").suspend(); 
    122149  } 
    123150   
    124151  void cxios_get_file_split_freq(file_Ptr file_hdl, char * split_freq, int split_freq_size) 
    125152  { 
     153     CTimer::get("XIOS").resume(); 
    126154    if(!string_copy(file_hdl->split_freq.getValue(),split_freq , split_freq_size)) 
    127155      ERROR("void cxios_get_file_split_freq(file_Ptr file_hdl, char * split_freq, int split_freq_size)", <<"Input string is to short"); 
     156     CTimer::get("XIOS").suspend(); 
    128157  } 
    129158   
    … …  
    133162    std::string sync_freq_str; 
    134163    if(!cstr2string(sync_freq, sync_freq_size, sync_freq_str)) return; 
     164     CTimer::get("XIOS").resume(); 
    135165    file_hdl->sync_freq.setValue(sync_freq_str); 
    136166    file_hdl->sendAttributToServer(file_hdl->sync_freq); 
     167     CTimer::get("XIOS").suspend(); 
    137168  } 
    138169   
    139170  void cxios_get_file_sync_freq(file_Ptr file_hdl, char * sync_freq, int sync_freq_size) 
    140171  { 
     172     CTimer::get("XIOS").resume(); 
    141173    if(!string_copy(file_hdl->sync_freq.getValue(),sync_freq , sync_freq_size)) 
    142174      ERROR("void cxios_get_file_sync_freq(file_Ptr file_hdl, char * sync_freq, int sync_freq_size)", <<"Input string is to short"); 
     175     CTimer::get("XIOS").suspend(); 
    143176  } 
    144177   
    … …  
    148181    std::string type_str; 
    149182    if(!cstr2string(type, type_size, type_str)) return; 
     183     CTimer::get("XIOS").resume(); 
    150184    file_hdl->type.setValue(type_str); 
    151185    file_hdl->sendAttributToServer(file_hdl->type); 
     186     CTimer::get("XIOS").suspend(); 
    152187  } 
    153188   
    154189  void cxios_get_file_type(file_Ptr file_hdl, char * type, int type_size) 
    155190  { 
     191     CTimer::get("XIOS").resume(); 
    156192    if(!string_copy(file_hdl->type.getValue(),type , type_size)) 
    157193      ERROR("void cxios_get_file_type(file_Ptr file_hdl, char * type, int type_size)", <<"Input string is to short"); 
     194     CTimer::get("XIOS").suspend(); 
    158195  } 
    159196   

  • XIOS/trunk/src/interface/c_attr/icfilegroup_attr.cpp

    r345 r347  
    1010#include "group_template_impl.hpp" 
    1111#include "icutil.hpp" 
     12#include "timer.hpp" 
    1213 
    1314extern "C" 
    … …  
    1920    std::string description_str; 
    2021    if(!cstr2string(description, description_size, description_str)) return; 
     22     CTimer::get("XIOS").resume(); 
    2123    filegroup_hdl->description.setValue(description_str); 
    2224    filegroup_hdl->sendAttributToServer(filegroup_hdl->description); 
     25     CTimer::get("XIOS").suspend(); 
    2326  } 
    2427   
    2528  void cxios_get_filegroup_description(filegroup_Ptr filegroup_hdl, char * description, int description_size) 
    2629  { 
     30     CTimer::get("XIOS").resume(); 
    2731    if(!string_copy(filegroup_hdl->description.getValue(),description , description_size)) 
    2832      ERROR("void cxios_get_filegroup_description(filegroup_Ptr filegroup_hdl, char * description, int description_size)", <<"Input string is to short"); 
     33     CTimer::get("XIOS").suspend(); 
    2934  } 
    3035   
    … …  
    3237  void cxios_set_filegroup_enabled(filegroup_Ptr filegroup_hdl, bool enabled) 
    3338  { 
     39     CTimer::get("XIOS").resume(); 
    3440    filegroup_hdl->enabled.setValue(enabled); 
    3541    filegroup_hdl->sendAttributToServer(filegroup_hdl->enabled); 
     42     CTimer::get("XIOS").suspend(); 
    3643  } 
    3744   
    … …  
    4653    std::string group_ref_str; 
    4754    if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
     55     CTimer::get("XIOS").resume(); 
    4856    filegroup_hdl->group_ref.setValue(group_ref_str); 
    4957    filegroup_hdl->sendAttributToServer(filegroup_hdl->group_ref); 
     58     CTimer::get("XIOS").suspend(); 
    5059  } 
    5160   
    5261  void cxios_get_filegroup_group_ref(filegroup_Ptr filegroup_hdl, char * group_ref, int group_ref_size) 
    5362  { 
     63     CTimer::get("XIOS").resume(); 
    5464    if(!string_copy(filegroup_hdl->group_ref.getValue(),group_ref , group_ref_size)) 
    5565      ERROR("void cxios_get_filegroup_group_ref(filegroup_Ptr filegroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
     66     CTimer::get("XIOS").suspend(); 
    5667  } 
    5768   
    … …  
    6172    std::string name_str; 
    6273    if(!cstr2string(name, name_size, name_str)) return; 
     74     CTimer::get("XIOS").resume(); 
    6375    filegroup_hdl->name.setValue(name_str); 
    6476    filegroup_hdl->sendAttributToServer(filegroup_hdl->name); 
     77     CTimer::get("XIOS").suspend(); 
    6578  } 
    6679   
    6780  void cxios_get_filegroup_name(filegroup_Ptr filegroup_hdl, char * name, int name_size) 
    6881  { 
     82     CTimer::get("XIOS").resume(); 
    6983    if(!string_copy(filegroup_hdl->name.getValue(),name , name_size)) 
    7084      ERROR("void cxios_get_filegroup_name(filegroup_Ptr filegroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
     85     CTimer::get("XIOS").suspend(); 
    7186  } 
    7287   
    … …  
    7691    std::string name_suffix_str; 
    7792    if(!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return; 
     93     CTimer::get("XIOS").resume(); 
    7894    filegroup_hdl->name_suffix.setValue(name_suffix_str); 
    7995    filegroup_hdl->sendAttributToServer(filegroup_hdl->name_suffix); 
     96     CTimer::get("XIOS").suspend(); 
    8097  } 
    8198   
    8299  void cxios_get_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, char * name_suffix, int name_suffix_size) 
    83100  { 
     101     CTimer::get("XIOS").resume(); 
    84102    if(!string_copy(filegroup_hdl->name_suffix.getValue(),name_suffix , name_suffix_size)) 
    85103      ERROR("void cxios_get_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, char * name_suffix, int name_suffix_size)", <<"Input string is to short"); 
     104     CTimer::get("XIOS").suspend(); 
    86105  } 
    87106   
    … …  
    91110    std::string output_freq_str; 
    92111    if(!cstr2string(output_freq, output_freq_size, output_freq_str)) return; 
     112     CTimer::get("XIOS").resume(); 
    93113    filegroup_hdl->output_freq.setValue(output_freq_str); 
    94114    filegroup_hdl->sendAttributToServer(filegroup_hdl->output_freq); 
     115     CTimer::get("XIOS").suspend(); 
    95116  } 
    96117   
    97118  void cxios_get_filegroup_output_freq(filegroup_Ptr filegroup_hdl, char * output_freq, int output_freq_size) 
    98119  { 
     120     CTimer::get("XIOS").resume(); 
    99121    if(!string_copy(filegroup_hdl->output_freq.getValue(),output_freq , output_freq_size)) 
    100122      ERROR("void cxios_get_filegroup_output_freq(filegroup_Ptr filegroup_hdl, char * output_freq, int output_freq_size)", <<"Input string is to short"); 
     123     CTimer::get("XIOS").suspend(); 
    101124  } 
    102125   
    … …  
    104127  void cxios_set_filegroup_output_level(filegroup_Ptr filegroup_hdl, int output_level) 
    105128  { 
     129     CTimer::get("XIOS").resume(); 
    106130    filegroup_hdl->output_level.setValue(output_level); 
    107131    filegroup_hdl->sendAttributToServer(filegroup_hdl->output_level); 
     132     CTimer::get("XIOS").suspend(); 
    108133  } 
    109134   
    … …  
    118143    std::string par_access_str; 
    119144    if(!cstr2string(par_access, par_access_size, par_access_str)) return; 
     145     CTimer::get("XIOS").resume(); 
    120146    filegroup_hdl->par_access.setValue(par_access_str); 
    121147    filegroup_hdl->sendAttributToServer(filegroup_hdl->par_access); 
     148     CTimer::get("XIOS").suspend(); 
    122149  } 
    123150   
    124151  void cxios_get_filegroup_par_access(filegroup_Ptr filegroup_hdl, char * par_access, int par_access_size) 
    125152  { 
     153     CTimer::get("XIOS").resume(); 
    126154    if(!string_copy(filegroup_hdl->par_access.getValue(),par_access , par_access_size)) 
    127155      ERROR("void cxios_get_filegroup_par_access(filegroup_Ptr filegroup_hdl, char * par_access, int par_access_size)", <<"Input string is to short"); 
     156     CTimer::get("XIOS").suspend(); 
    128157  } 
    129158   
    … …  
    133162    std::string split_freq_str; 
    134163    if(!cstr2string(split_freq, split_freq_size, split_freq_str)) return; 
     164     CTimer::get("XIOS").resume(); 
    135165    filegroup_hdl->split_freq.setValue(split_freq_str); 
    136166    filegroup_hdl->sendAttributToServer(filegroup_hdl->split_freq); 
     167     CTimer::get("XIOS").suspend(); 
    137168  } 
    138169   
    139170  void cxios_get_filegroup_split_freq(filegroup_Ptr filegroup_hdl, char * split_freq, int split_freq_size) 
    140171  { 
     172     CTimer::get("XIOS").resume(); 
    141173    if(!string_copy(filegroup_hdl->split_freq.getValue(),split_freq , split_freq_size)) 
    142174      ERROR("void cxios_get_filegroup_split_freq(filegroup_Ptr filegroup_hdl, char * split_freq, int split_freq_size)", <<"Input string is to short"); 
     175     CTimer::get("XIOS").suspend(); 
    143176  } 
    144177   
    … …  
    148181    std::string sync_freq_str; 
    149182    if(!cstr2string(sync_freq, sync_freq_size, sync_freq_str)) return; 
     183     CTimer::get("XIOS").resume(); 
    150184    filegroup_hdl->sync_freq.setValue(sync_freq_str); 
    151185    filegroup_hdl->sendAttributToServer(filegroup_hdl->sync_freq); 
     186     CTimer::get("XIOS").suspend(); 
    152187  } 
    153188   
    154189  void cxios_get_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, char * sync_freq, int sync_freq_size) 
    155190  { 
     191     CTimer::get("XIOS").resume(); 
    156192    if(!string_copy(filegroup_hdl->sync_freq.getValue(),sync_freq , sync_freq_size)) 
    157193      ERROR("void cxios_get_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, char * sync_freq, int sync_freq_size)", <<"Input string is to short"); 
     194     CTimer::get("XIOS").suspend(); 
    158195  } 
    159196   
    … …  
    163200    std::string type_str; 
    164201    if(!cstr2string(type, type_size, type_str)) return; 
     202     CTimer::get("XIOS").resume(); 
    165203    filegroup_hdl->type.setValue(type_str); 
    166204    filegroup_hdl->sendAttributToServer(filegroup_hdl->type); 
     205     CTimer::get("XIOS").suspend(); 
    167206  } 
    168207   
    169208  void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size) 
    170209  { 
     210     CTimer::get("XIOS").resume(); 
    171211    if(!string_copy(filegroup_hdl->type.getValue(),type , type_size)) 
    172212      ERROR("void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size)", <<"Input string is to short"); 
     213     CTimer::get("XIOS").suspend(); 
    173214  } 
    174215   

  • XIOS/trunk/src/interface/c_attr/icgrid_attr.cpp

    r345 r347  
    1010#include "group_template_impl.hpp" 
    1111#include "icutil.hpp" 
     12#include "timer.hpp" 
    1213 
    1314extern "C" 
    … …  
    1920    std::string axis_ref_str; 
    2021    if(!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return; 
     22     CTimer::get("XIOS").resume(); 
    2123    grid_hdl->axis_ref.setValue(axis_ref_str); 
    2224    grid_hdl->sendAttributToServer(grid_hdl->axis_ref); 
     25     CTimer::get("XIOS").suspend(); 
    2326  } 
    2427   
    2528  void cxios_get_grid_axis_ref(grid_Ptr grid_hdl, char * axis_ref, int axis_ref_size) 
    2629  { 
     30     CTimer::get("XIOS").resume(); 
    2731    if(!string_copy(grid_hdl->axis_ref.getValue(),axis_ref , axis_ref_size)) 
    2832      ERROR("void cxios_get_grid_axis_ref(grid_Ptr grid_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short"); 
     33     CTimer::get("XIOS").suspend(); 
    2934  } 
    3035   
    … …  
    3439    std::string description_str; 
    3540    if(!cstr2string(description, description_size, description_str)) return; 
     41     CTimer::get("XIOS").resume(); 
    3642    grid_hdl->description.setValue(description_str); 
    3743    grid_hdl->sendAttributToServer(grid_hdl->description); 
     44     CTimer::get("XIOS").suspend(); 
    3845  } 
    3946   
    4047  void cxios_get_grid_description(grid_Ptr grid_hdl, char * description, int description_size) 
    4148  { 
     49     CTimer::get("XIOS").resume(); 
    4250    if(!string_copy(grid_hdl->description.getValue(),description , description_size)) 
    4351      ERROR("void cxios_get_grid_description(grid_Ptr grid_hdl, char * description, int description_size)", <<"Input string is to short"); 
     52     CTimer::get("XIOS").suspend(); 
    4453  } 
    4554   
    … …  
    4958    std::string domain_ref_str; 
    5059    if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return; 
     60     CTimer::get("XIOS").resume(); 
    5161    grid_hdl->domain_ref.setValue(domain_ref_str); 
    5262    grid_hdl->sendAttributToServer(grid_hdl->domain_ref); 
     63     CTimer::get("XIOS").suspend(); 
    5364  } 
    5465   
    5566  void cxios_get_grid_domain_ref(grid_Ptr grid_hdl, char * domain_ref, int domain_ref_size) 
    5667  { 
     68     CTimer::get("XIOS").resume(); 
    5769    if(!string_copy(grid_hdl->domain_ref.getValue(),domain_ref , domain_ref_size)) 
    5870      ERROR("void cxios_get_grid_domain_ref(grid_Ptr grid_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short"); 
     71     CTimer::get("XIOS").suspend(); 
    5972  } 
    6073   
    … …  
    6477    std::string name_str; 
    6578    if(!cstr2string(name, name_size, name_str)) return; 
     79     CTimer::get("XIOS").resume(); 
    6680    grid_hdl->name.setValue(name_str); 
    6781    grid_hdl->sendAttributToServer(grid_hdl->name); 
     82     CTimer::get("XIOS").suspend(); 
    6883  } 
    6984   
    7085  void cxios_get_grid_name(grid_Ptr grid_hdl, char * name, int name_size) 
    7186  { 
     87     CTimer::get("XIOS").resume(); 
    7288    if(!string_copy(grid_hdl->name.getValue(),name , name_size)) 
    7389      ERROR("void cxios_get_grid_name(grid_Ptr grid_hdl, char * name, int name_size)", <<"Input string is to short"); 
     90     CTimer::get("XIOS").suspend(); 
    7491  } 
    7592   

  • XIOS/trunk/src/interface/c_attr/icgridgroup_attr.cpp

    r345 r347  
    1010#include "group_template_impl.hpp" 
    1111#include "icutil.hpp" 
     12#include "timer.hpp" 
    1213 
    1314extern "C" 
    … …  
    1920    std::string axis_ref_str; 
    2021    if(!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return; 
     22     CTimer::get("XIOS").resume(); 
    2123    gridgroup_hdl->axis_ref.setValue(axis_ref_str); 
    2224    gridgroup_hdl->sendAttributToServer(gridgroup_hdl->axis_ref); 
     25     CTimer::get("XIOS").suspend(); 
    2326  } 
    2427   
    2528  void cxios_get_gridgroup_axis_ref(gridgroup_Ptr gridgroup_hdl, char * axis_ref, int axis_ref_size) 
    2629  { 
     30     CTimer::get("XIOS").resume(); 
    2731    if(!string_copy(gridgroup_hdl->axis_ref.getValue(),axis_ref , axis_ref_size)) 
    2832      ERROR("void cxios_get_gridgroup_axis_ref(gridgroup_Ptr gridgroup_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short"); 
     33     CTimer::get("XIOS").suspend(); 
    2934  } 
    3035   
    … …  
    3439    std::string description_str; 
    3540    if(!cstr2string(description, description_size, description_str)) return; 
     41     CTimer::get("XIOS").resume(); 
    3642    gridgroup_hdl->description.setValue(description_str); 
    3743    gridgroup_hdl->sendAttributToServer(gridgroup_hdl->description); 
     44     CTimer::get("XIOS").suspend(); 
    3845  } 
    3946   
    4047  void cxios_get_gridgroup_description(gridgroup_Ptr gridgroup_hdl, char * description, int description_size) 
    4148  { 
     49     CTimer::get("XIOS").resume(); 
    4250    if(!string_copy(gridgroup_hdl->description.getValue(),description , description_size)) 
    4351      ERROR("void cxios_get_gridgroup_description(gridgroup_Ptr gridgroup_hdl, char * description, int description_size)", <<"Input string is to short"); 
     52     CTimer::get("XIOS").suspend(); 
    4453  } 
    4554   
    … …  
    4958    std::string domain_ref_str; 
    5059    if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return; 
     60     CTimer::get("XIOS").resume(); 
    5161    gridgroup_hdl->domain_ref.setValue(domain_ref_str); 
    5262    gridgroup_hdl->sendAttributToServer(gridgroup_hdl->domain_ref); 
     63     CTimer::get("XIOS").suspend(); 
    5364  } 
    5465   
    5566  void cxios_get_gridgroup_domain_ref(gridgroup_Ptr gridgroup_hdl, char * domain_ref, int domain_ref_size) 
    5667  { 
     68     CTimer::get("XIOS").resume(); 
    5769    if(!string_copy(gridgroup_hdl->domain_ref.getValue(),domain_ref , domain_ref_size)) 
    5870      ERROR("void cxios_get_gridgroup_domain_ref(gridgroup_Ptr gridgroup_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short"); 
     71     CTimer::get("XIOS").suspend(); 
    5972  } 
    6073   
    … …  
    6477    std::string group_ref_str; 
    6578    if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return; 
     79     CTimer::get("XIOS").resume(); 
    6680    gridgroup_hdl->group_ref.setValue(group_ref_str); 
    6781    gridgroup_hdl->sendAttributToServer(gridgroup_hdl->group_ref); 
     82     CTimer::get("XIOS").suspend(); 
    6883  } 
    6984   
    7085  void cxios_get_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl, char * group_ref, int group_ref_size) 
    7186  { 
     87     CTimer::get("XIOS").resume(); 
    7288    if(!string_copy(gridgroup_hdl->group_ref.getValue(),group_ref , group_ref_size)) 
    7389      ERROR("void cxios_get_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short"); 
     90     CTimer::get("XIOS").suspend(); 
    7491  } 
    7592   
    … …  
    7996    std::string name_str; 
    8097    if(!cstr2string(name, name_size, name_str)) return; 
     98     CTimer::get("XIOS").resume(); 
    8199    gridgroup_hdl->name.setValue(name_str); 
    82100    gridgroup_hdl->sendAttributToServer(gridgroup_hdl->name); 
     101     CTimer::get("XIOS").suspend(); 
    83102  } 
    84103   
    85104  void cxios_get_gridgroup_name(gridgroup_Ptr gridgroup_hdl, char * name, int name_size) 
    86105  { 
     106     CTimer::get("XIOS").resume(); 
    87107    if(!string_copy(gridgroup_hdl->name.getValue(),name , name_size)) 
    88108      ERROR("void cxios_get_gridgroup_name(gridgroup_Ptr gridgroup_hdl, char * name, int name_size)", <<"Input string is to short"); 
     109     CTimer::get("XIOS").suspend(); 
    89110  } 
    90111   
Note: See TracChangeset for help on using the changeset viewer.