Index: XIOS/trunk/src/interface/c/icaxis.cpp
===================================================================
--- XIOS/trunk/src/interface/c/icaxis.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c/icaxis.cpp	(revision 347)
@@ -13,4 +13,5 @@
 
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -29,6 +30,7 @@
       std::string id; 
       if (!cstr2string(_id, _id_len, id)) return;
-
-      *_ret = xios::CAxis::get(id).get();
+      CTimer::get("XIOS").resume() ;
+      *_ret = xios::CAxis::get(id);
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -37,7 +39,8 @@
       std::string id; 
       if (!cstr2string(_id, _id_len, id)) return;
-
-      *_ret = xios::CAxisGroup::get(id).get();
-   }
+      CTimer::get("XIOS").resume() ;
+      *_ret = xios::CAxisGroup::get(id);
+      CTimer::get("XIOS").suspend() ;
+    }
 
    // -------------------- VÃ©rification des identifiants -----------------------
@@ -48,5 +51,7 @@
       if (!cstr2string(_id, _id_len, id)) return;
 
+      CTimer::get("XIOS").resume() ;
       *_ret = xios::CAxis::has(id);
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -56,5 +61,8 @@
       if (!cstr2string(_id, _id_len, id)) return;
 
+      CTimer::get("XIOS").resume() ;
       *_ret = xios::CAxisGroup::has(id);
+      CTimer::get("XIOS").suspend() ;
+
    }
    
Index: XIOS/trunk/src/interface/c/iccontext.cpp
===================================================================
--- XIOS/trunk/src/interface/c/iccontext.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c/iccontext.cpp	(revision 347)
@@ -15,4 +15,5 @@
 
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -32,6 +33,7 @@
       std::string id; 
       if (!cstr2string(_id, _id_len, id)) return;
-
-      std::vector<boost::shared_ptr<xios::CContext> > def_vector =
+      CTimer::get("XIOS").resume() ;
+      
+      std::vector<xios::CContext*> def_vector =
             xios::CContext::getRoot()->getChildList();
 
@@ -39,7 +41,9 @@
 	   {
           if (def_vector[i]->getId().compare(id) == 0)
-          *_ret = def_vector[i].get();
+          *_ret = def_vector[i];
+           CTimer::get("XIOS").suspend() ;
           return;
       }
+       CTimer::get("XIOS").suspend() ;
       // Lever une exeception ici
    }
@@ -49,5 +53,7 @@
    void cxios_context_set_current(XContextPtr context, bool withswap)
    {
+      CTimer::get("XIOS").resume() ;
       CContext::setCurrent(context->getId());
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -59,6 +65,7 @@
       std::string id;
       if (!cstr2string(_id, _id_len, id)) return;
-
-      std::vector<boost::shared_ptr<xios::CContext> > def_vector =
+      
+      CTimer::get("XIOS").resume() ;
+      std::vector<xios::CContext*> def_vector =
             xios::CContext::getRoot()->getChildList();
 
@@ -69,4 +76,5 @@
       }
      *_ret = false;
+     CTimer::get("XIOS").suspend() ;
    }
 } // extern "C"
Index: XIOS/trunk/src/interface/c/icdata.cpp
===================================================================
--- XIOS/trunk/src/interface/c/icdata.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c/icdata.cpp	(revision 347)
@@ -22,4 +22,5 @@
 #include "field_impl.hpp"
 #include <mpi.h>
+#include "timer.hpp"
 
 extern "C"
@@ -36,5 +37,7 @@
    void cxios_init_server(void)
    {
+     CTimer::get("XIOS").resume() ;
      CXios::initServerSide();      
+     CTimer::get("XIOS").suspend() ;
    }
 
@@ -46,5 +49,7 @@
       
       if (!cstr2string(client_id, len_client_id, str)) return;
-      
+
+      CTimer::get("XIOS").resume() ;
+      CTimer::get("XIOS init").resume() ;
       int initialized ;
       MPI_Initialized(&initialized) ;
@@ -53,4 +58,6 @@
       CXios::initClientSide(str,local_comm,return_comm);
       *f_return_comm=MPI_Comm_c2f(return_comm) ;
+      CTimer::get("XIOS init").suspend() ;
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -61,23 +68,39 @@
      
      if (!cstr2string(context_id, len_context_id, str)) return;
+     CTimer::get("XIOS").resume() ;
+     CTimer::get("XIOS init context").resume() ;
      comm=MPI_Comm_f2c(*f_comm) ;
      CClient::registerContext(str,comm) ;
+     CTimer::get("XIOS init context").suspend() ;
+     CTimer::get("XIOS").suspend() ;
    }
  
     void cxios_context_close_definition()
    {
-     boost::shared_ptr<CContext> context = CContext::getCurrent() ;
+     CTimer::get("XIOS").resume() ;
+     CTimer::get("XIOS close definition").resume() ;
+     CContext* context = CContext::getCurrent() ;
      context->closeDefinition() ;
+     CTimer::get("XIOS close definition").suspend() ;
+     CTimer::get("XIOS").suspend() ;
    }  
 
    void cxios_context_finalize()
    {
-     boost::shared_ptr<CContext> context = CContext::getCurrent() ;
+     CTimer::get("XIOS").resume() ;
+     CTimer::get("XIOS context finalize").resume() ;
+     CContext* context = CContext::getCurrent() ;
      context->finalize() ;
+     CTimer::get("XIOS context finalize").suspend() ;
+     CTimer::get("XIOS").suspend() ;
    }
    
    void cxios_finalize()
    {
+     CTimer::get("XIOS").resume() ;
+     CTimer::get("XIOS finalize").resume() ;
      CXios::clientFinalize() ;
+     CTimer::get("XIOS finalize").suspend() ;
+     CTimer::get("XIOS").suspend() ;
    }
 
@@ -89,7 +112,9 @@
    {
       std::string fieldid_str;
-      boost::shared_ptr<CContext> context = CContext::getCurrent() ;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
-      
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
+      
+      CTimer::get("XIOS").resume() ;
+      CTimer::get("XIOS send field").resume() ;
+      CContext* context = CContext::getCurrent() ;
 //      boost::const_multi_array_ref<double, 1> array_(data_k8,
 //          boost::extents [data_Xsize],
@@ -100,4 +125,6 @@
 //      dtreat->write_data(fieldid_str, data);
       CField::get(fieldid_str)->setData(data) ;
+      CTimer::get("XIOS send field").suspend() ;
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -105,6 +132,9 @@
    {
       std::string fieldid_str;
-      boost::shared_ptr<CContext> context = CContext::getCurrent() ;
       if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return;
+      
+      CTimer::get("XIOS").resume() ;
+      CTimer::get("XIOS send field").resume() ;
+      CContext* context = CContext::getCurrent() ;
       
 //      boost::const_multi_array_ref<double, 2> array_(data_k8,
@@ -115,4 +145,6 @@
 //      dtreat->write_data(fieldid_str, data);
       CField::get(fieldid_str)->setData(data) ;
+      CTimer::get("XIOS send field").suspend() ;
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -120,7 +152,9 @@
    {
       std::string fieldid_str;
-      boost::shared_ptr<CContext> context = CContext::getCurrent() ;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
-      
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
+
+      CTimer::get("XIOS").resume() ;
+      CTimer::get("XIOS send field").resume() ;
+      CContext* context = CContext::getCurrent() ;
 //      boost::const_multi_array_ref<double, 3> array_(data_k8,
 //          boost::extents [data_Xsize][data_Ysize][data_Zsize],
@@ -130,5 +164,6 @@
 //      dtreat->write_data(fieldid_str, data);
       CField::get(fieldid_str)->setData(data) ;
-
+      CTimer::get("XIOS send field").suspend() ;
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -136,7 +171,9 @@
    {
       std::string fieldid_str;
-      boost::shared_ptr<CContext> context = CContext::getCurrent() ;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
-      
+     if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
+
+      CTimer::get("XIOS").resume() ;
+      CTimer::get("XIOS send field").resume() ;
+      CContext* context = CContext::getCurrent() ;
 //      boost::const_multi_array_ref<float, 1> array_(data_k4,
 //          boost::extents [data_Xsize],
@@ -149,4 +186,6 @@
       for(int i=0;i<data->num_elements();i++) ptr_data[i]=data_k4[i];
       CField::get(fieldid_str)->setData(data) ;
+      CTimer::get("XIOS send field").suspend() ;
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -154,7 +193,9 @@
    {
       std::string fieldid_str;
-      boost::shared_ptr<CContext> context = CContext::getCurrent() ;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
-      
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
+
+      CTimer::get("XIOS").resume() ;
+      CTimer::get("XIOS send field").resume() ;
+      CContext* context = CContext::getCurrent() ;
 //      boost::const_multi_array_ref<float, 2> array_(data_k4,
 //          boost::extents [data_Xsize][data_Ysize],
@@ -167,4 +208,6 @@
       for(int i=0;i<data->num_elements();i++) ptr_data[i]=data_k4[i];
       CField::get(fieldid_str)->setData(data) ;
+      CTimer::get("XIOS send field").suspend() ;
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -172,7 +215,11 @@
    {
       std::string fieldid_str;
-      boost::shared_ptr<CContext> context = CContext::getCurrent() ;
-      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
-      
+ 
+      if (!cstr2string(fieldid, fieldid_size, fieldid_str)) return; 
+ 
+      CTimer::get("XIOS").resume() ;
+      CTimer::get("XIOS send field").resume() ;
+      CContext* context = CContext::getCurrent() ;
+     
 //      boost::const_multi_array_ref<float, 3> array_(data_k4,
 //          boost::extents [data_Xsize][data_Ysize][data_Zsize],
@@ -185,4 +232,7 @@
       for(int i=0;i<data->num_elements();i++) ptr_data[i]=data_k4[i];
       CField::get(fieldid_str)->setData(data) ;
+      CTimer::get("XIOS send field").suspend() ;
+      CTimer::get("XIOS").suspend() ;
+
     } 
 
Index: XIOS/trunk/src/interface/c/icdate.cpp
===================================================================
--- XIOS/trunk/src/interface/c/icdate.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c/icdate.cpp	(revision 347)
@@ -15,4 +15,5 @@
 
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -25,9 +26,11 @@
       try
       {
+         CTimer::get("XIOS").resume() ;
          CDuration dur = {ts_year, ts_month, ts_day, ts_hour, ts_minute, ts_second};
-         boost::shared_ptr<xios::CContext> context = CContext::getCurrent() ;
+         xios::CContext* context = CContext::getCurrent() ;
          
             context->timestep.setValue(dur.toString());
             context->sendAttributToServer("timestep") ;
+          CTimer::get("XIOS").suspend() ;
       }
       catch (xios::CException & exc)
@@ -40,7 +43,9 @@
    void cxios_update_calendar(int step)
    {
-      boost::shared_ptr<xios::CContext> context = CContext::getCurrent() ;
+      CTimer::get("XIOS").resume() ;
+      xios::CContext* context = CContext::getCurrent() ;
       context->updateCalendar(step) ;
       context->sendUpdateCalendar(step) ;
+      CTimer::get("XIOS").suspend() ;
       
    }
Index: XIOS/trunk/src/interface/c/icdomain.cpp
===================================================================
--- XIOS/trunk/src/interface/c/icdomain.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c/icdomain.cpp	(revision 347)
@@ -13,4 +13,5 @@
 
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -29,6 +30,7 @@
       std::string id; 
       if (!cstr2string(_id, _id_len, id)) return;
-
-      *_ret = CDomain::get(id).get();
+      CTimer::get("XIOS").resume() ;
+      *_ret = CDomain::get(id);
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -38,5 +40,7 @@
       if (!cstr2string(_id, _id_len, id)) return;
 
-      *_ret = CDomainGroup::get(id).get();
+      CTimer::get("XIOS").resume() ;
+      *_ret = CDomainGroup::get(id);
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -48,5 +52,7 @@
       if (!cstr2string(_id, _id_len, id)) return;
 
+      CTimer::get("XIOS").resume() ;
       *_ret = CDomain::has(id);
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -55,6 +61,7 @@
       std::string id;
       if (!cstr2string(_id, _id_len, id)) return;
-
+      CTimer::get("XIOS").resume() ;
       *_ret = CDomainGroup::has(id);
+      CTimer::get("XIOS").suspend() ;
    }
 } // extern "C"
Index: XIOS/trunk/src/interface/c/icfield.cpp
===================================================================
--- XIOS/trunk/src/interface/c/icfield.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c/icfield.cpp	(revision 347)
@@ -13,4 +13,5 @@
 
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -31,6 +32,7 @@
       std::string id; 
       if (!cstr2string(_id, _id_len, id)) return;
-
-      *_ret = CField::get(id).get();
+      CTimer::get("XIOS").resume() ;
+      *_ret = CField::get(id);
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -39,6 +41,7 @@
       std::string id; 
       if (!cstr2string(_id, _id_len, id)) return;
-
-      *_ret = CFieldGroup::get(id).get();
+      CTimer::get("XIOS").resume() ;
+      *_ret = CFieldGroup::get(id);
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -50,6 +53,7 @@
       std::string id;
       if (!cstr2string(_id, _id_len, id)) return;
-
+      CTimer::get("XIOS").resume() ;
       *_ret = CField::has(id);
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -58,6 +62,7 @@
       std::string id;
       if (!cstr2string(_id, _id_len, id)) return;
-
+      CTimer::get("XIOS").resume() ;
       *_ret = CFieldGroup::has(id);
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -68,5 +73,7 @@
   void cxios_field_is_active (XFieldPtr field_hdl, bool* ret)
   {
+    CTimer::get("XIOS").resume() ;
     *ret = field_hdl->isActive();
+    CTimer::get("XIOS").suspend() ;
   }
    
Index: XIOS/trunk/src/interface/c/icfile.cpp
===================================================================
--- XIOS/trunk/src/interface/c/icfile.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c/icfile.cpp	(revision 347)
@@ -13,4 +13,5 @@
 
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -29,6 +30,7 @@
       std::string id; 
       if (!cstr2string(_id, _id_len, id)) return;
-
-      *_ret = CFile::get(id).get();
+      CTimer::get("XIOS").resume() ;
+      *_ret = CFile::get(id);
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -37,6 +39,7 @@
       std::string id; 
       if (!cstr2string(_id, _id_len, id)) return;
-
-      *_ret = CFileGroup::get(id).get();
+      CTimer::get("XIOS").resume() ;
+      *_ret = CFileGroup::get(id);
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -47,6 +50,7 @@
       std::string id;
       if (!cstr2string(_id, _id_len, id)) return;
-
+      CTimer::get("XIOS").resume() ;
       *_ret = CFile::has(id);
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -55,6 +59,7 @@
       std::string id;
       if (!cstr2string(_id, _id_len, id)) return;
-
+      CTimer::get("XIOS").resume() ;
       *_ret = CFileGroup::has(id);
+      CTimer::get("XIOS").suspend() ;
    }
 } // extern "C"
Index: XIOS/trunk/src/interface/c/icgrid.cpp
===================================================================
--- XIOS/trunk/src/interface/c/icgrid.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c/icgrid.cpp	(revision 347)
@@ -13,4 +13,5 @@
 
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -29,6 +30,7 @@
       std::string id; 
       if (!cstr2string(_id, _id_len, id)) return;
-
-      *_ret = CGrid::get(id).get();
+      CTimer::get("XIOS").resume() ;
+      *_ret = CGrid::get(id);
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -37,6 +39,7 @@
       std::string id; 
       if (!cstr2string(_id, _id_len, id)) return;
-
-      *_ret = CGridGroup::get(id).get();
+      CTimer::get("XIOS").resume() ;
+      *_ret = CGridGroup::get(id);
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -47,6 +50,7 @@
       std::string id;
       if (!cstr2string(_id, _id_len, id)) return;
-
+      CTimer::get("XIOS").resume() ;
       *_ret = CGrid::has(id);
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -55,6 +59,7 @@
       std::string id;
       if (!cstr2string(_id, _id_len, id)) return;
-
+      CTimer::get("XIOS").resume() ;
       *_ret = CGridGroup::has(id);
+      CTimer::get("XIOS").suspend() ;
    }
 } // extern "C"
Index: XIOS/trunk/src/interface/c/icxml_tree.cpp
===================================================================
--- XIOS/trunk/src/interface/c/icxml_tree.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c/icxml_tree.cpp	(revision 347)
@@ -13,4 +13,5 @@
 
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -43,15 +44,16 @@
    {
       std::string child_id_str; 
-
-      if (cstr2string(child_id, child_id_size, child_id_str))
-      {
-         *child_ = parent_->createChild(child_id_str).get() ;
-         parent_->sendCreateChild(child_id_str) ;
-      }
-      else
-      {
-         *child_ = parent_->createChild().get() ;
-         parent_->sendCreateChild() ;
-      }
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         *child_ = parent_->createChild(child_id_str) ;
+         parent_->sendCreateChild(child_id_str) ;
+      }
+      else
+      {
+         *child_ = parent_->createChild() ;
+         parent_->sendCreateChild() ;
+      }
+      CTimer::get("XIOS").suspend() ;
   }
    
@@ -60,14 +62,16 @@
    {
       std::string child_id_str; 
-      if (cstr2string(child_id, child_id_size, child_id_str))
-      {
-         *child_ = parent_->createChild(child_id_str).get() ;
-         parent_->sendCreateChild(child_id_str) ;
-      }
-      else
-      {
-         *child_ = parent_->createChild().get() ;
-         parent_->sendCreateChild() ;
-      }
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         *child_ = parent_->createChild(child_id_str) ;
+         parent_->sendCreateChild(child_id_str) ;
+      }
+      else
+      {
+         *child_ = parent_->createChild() ;
+         parent_->sendCreateChild() ;
+      }
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -76,14 +80,16 @@
    {
       std::string child_id_str; 
-      if (cstr2string(child_id, child_id_size, child_id_str))
-      {
-         *child_ = parent_->createChild(child_id_str).get() ;
-         parent_->sendCreateChild(child_id_str) ;
-      }
-      else
-      {
-         *child_ = parent_->createChild().get() ;
-         parent_->sendCreateChild() ;
-      }
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         *child_ = parent_->createChild(child_id_str) ;
+         parent_->sendCreateChild(child_id_str) ;
+      }
+      else
+      {
+         *child_ = parent_->createChild() ;
+         parent_->sendCreateChild() ;
+      }
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -92,14 +98,16 @@
    {
       std::string child_id_str; 
-      if (cstr2string(child_id, child_id_size, child_id_str))
-      {
-         *child_ = parent_->createChild(child_id_str).get() ;
-         parent_->sendCreateChild(child_id_str) ;
-      }
-      else
-      {
-         *child_ = parent_->createChild().get() ;
-         parent_->sendCreateChild() ;
-      }
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         *child_ = parent_->createChild(child_id_str) ;
+         parent_->sendCreateChild(child_id_str) ;
+      }
+      else
+      {
+         *child_ = parent_->createChild() ;
+         parent_->sendCreateChild() ;
+      }
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -107,15 +115,17 @@
       (XDomainGroupPtr parent_, XDomainPtr * child_, const char * child_id, int child_id_size)
    {
-      std::string child_id_str; 
-      if (cstr2string(child_id, child_id_size, child_id_str))
-      {
-         *child_ = parent_->createChild(child_id_str).get() ;
-         parent_->sendCreateChild(child_id_str) ;
-      }
-      else
-      {
-         *child_ = parent_->createChild().get() ;
-         parent_->sendCreateChild() ;
-      }
+      std::string child_id_str;
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         *child_ = parent_->createChild(child_id_str) ;
+         parent_->sendCreateChild(child_id_str) ;
+      }
+      else
+      {
+         *child_ = parent_->createChild() ;
+         parent_->sendCreateChild() ;
+      }
+      CTimer::get("XIOS").suspend() ;
    }
    
@@ -123,16 +133,18 @@
       (XFilePtr parent_, XFieldPtr * child_, const char * child_id, int child_id_size)
    {
-      std::string child_id_str; 
+      std::string child_id_str;
+      CTimer::get("XIOS").resume() ;
  
       if (cstr2string(child_id, child_id_size, child_id_str))
       {
-         *child_ = parent_->addField(child_id_str).get();
+         *child_ = parent_->addField(child_id_str);
          parent_->sendAddField(child_id_str) ;
       }
       else
       {
-         *child_ = parent_->addField().get();
+         *child_ = parent_->addField();
          parent_->sendAddField() ;
       }
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -143,15 +155,16 @@
    {
      std::string child_id_str; 
-
-      if (cstr2string(child_id, child_id_size, child_id_str))
-      {
-         *child_ = parent_->createChildGroup(child_id_str).get() ;
-         parent_->sendCreateChildGroup(child_id_str) ;
-      }
-      else
-      {
-         *child_ = parent_->createChildGroup().get() ;
-         parent_->sendCreateChildGroup(child_id_str) ;
-      }
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         *child_ = parent_->createChildGroup(child_id_str) ;
+         parent_->sendCreateChildGroup(child_id_str) ;
+      }
+      else
+      {
+         *child_ = parent_->createChildGroup() ;
+         parent_->sendCreateChildGroup(child_id_str) ;
+      }
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -160,15 +173,16 @@
    {
       std::string child_id_str;
- 
-      if (cstr2string(child_id, child_id_size, child_id_str))
-      {
-         *child_ = parent_->createChildGroup(child_id_str).get() ;
-         parent_->sendCreateChildGroup(child_id_str) ;
-      }
-      else
-      {
-         *child_ = parent_->createChildGroup().get() ;
-         parent_->sendCreateChildGroup(child_id_str) ;
-      }
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         *child_ = parent_->createChildGroup(child_id_str) ;
+         parent_->sendCreateChildGroup(child_id_str) ;
+      }
+      else
+      {
+         *child_ = parent_->createChildGroup() ;
+         parent_->sendCreateChildGroup(child_id_str) ;
+      }
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -177,14 +191,16 @@
    {
       std::string child_id_str;
-      if (cstr2string(child_id, child_id_size, child_id_str))
-      {
-         *child_ = parent_->createChildGroup(child_id_str).get() ;
-         parent_->sendCreateChildGroup(child_id_str) ;
-      }
-      else
-      {
-         *child_ = parent_->createChildGroup().get() ;
-         parent_->sendCreateChildGroup(child_id_str) ;
-      }
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         *child_ = parent_->createChildGroup(child_id_str) ;
+         parent_->sendCreateChildGroup(child_id_str) ;
+      }
+      else
+      {
+         *child_ = parent_->createChildGroup() ;
+         parent_->sendCreateChildGroup(child_id_str) ;
+      }
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -193,14 +209,16 @@
    {
       std::string child_id_str;
-      if (cstr2string(child_id, child_id_size, child_id_str))
-      {
-         *child_ = parent_->createChildGroup(child_id_str).get() ;
-         parent_->sendCreateChildGroup(child_id_str) ;
-      }
-      else
-      {
-         *child_ = parent_->createChildGroup().get() ;
-         parent_->sendCreateChildGroup(child_id_str) ;
-      }
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         *child_ = parent_->createChildGroup(child_id_str) ;
+         parent_->sendCreateChildGroup(child_id_str) ;
+      }
+      else
+      {
+         *child_ = parent_->createChildGroup() ;
+         parent_->sendCreateChildGroup(child_id_str) ;
+      }
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -209,14 +227,16 @@
    {
       std::string child_id_str;
-      if (cstr2string(child_id, child_id_size, child_id_str))
-      {
-         *child_ = parent_->createChildGroup(child_id_str).get() ;
-         parent_->sendCreateChildGroup(child_id_str) ;
-      }
-      else
-      {
-         *child_ = parent_->createChildGroup().get() ;
-         parent_->sendCreateChildGroup(child_id_str) ;
-      }
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         *child_ = parent_->createChildGroup(child_id_str) ;
+         parent_->sendCreateChildGroup(child_id_str) ;
+      }
+      else
+      {
+         *child_ = parent_->createChildGroup() ;
+         parent_->sendCreateChildGroup(child_id_str) ;
+      }
+      CTimer::get("XIOS").suspend() ;
    }
 
@@ -225,15 +245,16 @@
    {
       std::string child_id_str; 
- 
-      if (cstr2string(child_id, child_id_size, child_id_str))
-      {
-         *child_ = parent_->addFieldGroup(child_id_str).get();
+      CTimer::get("XIOS").resume() ;
+      if (cstr2string(child_id, child_id_size, child_id_str))
+      {
+         *child_ = parent_->addFieldGroup(child_id_str);
          parent_->sendAddFieldGroup(child_id_str) ;
       }
       else
       {
-         *child_ = parent_->addFieldGroup().get();
+         *child_ = parent_->addFieldGroup();
          parent_->sendAddFieldGroup() ;
       }
+      CTimer::get("XIOS").suspend() ;
    }
    
Index: XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c_attr/icaxis_attr.cpp	(revision 347)
@@ -10,4 +10,5 @@
 #include "group_template_impl.hpp"
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -19,12 +20,16 @@
     std::string long_name_str;
     if(!cstr2string(long_name, long_name_size, long_name_str)) return;
+     CTimer::get("XIOS").resume();
     axis_hdl->long_name.setValue(long_name_str);
     axis_hdl->sendAttributToServer(axis_hdl->long_name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_axis_long_name(axis_Ptr axis_hdl, char * long_name, int long_name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(axis_hdl->long_name.getValue(),long_name , long_name_size))
       ERROR("void cxios_get_axis_long_name(axis_Ptr axis_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -34,12 +39,16 @@
     std::string name_str;
     if(!cstr2string(name, name_size, name_str)) return;
+     CTimer::get("XIOS").resume();
     axis_hdl->name.setValue(name_str);
     axis_hdl->sendAttributToServer(axis_hdl->name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_axis_name(axis_Ptr axis_hdl, char * name, int name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(axis_hdl->name.getValue(),name , name_size))
       ERROR("void cxios_get_axis_name(axis_Ptr axis_hdl, char * name, int name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -47,6 +56,8 @@
   void cxios_set_axis_size(axis_Ptr axis_hdl, int size)
   {
+     CTimer::get("XIOS").resume();
     axis_hdl->size.setValue(size);
     axis_hdl->sendAttributToServer(axis_hdl->size);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -61,12 +72,16 @@
     std::string standard_name_str;
     if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
+     CTimer::get("XIOS").resume();
     axis_hdl->standard_name.setValue(standard_name_str);
     axis_hdl->sendAttributToServer(axis_hdl->standard_name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_axis_standard_name(axis_Ptr axis_hdl, char * standard_name, int standard_name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(axis_hdl->standard_name.getValue(),standard_name , standard_name_size))
       ERROR("void cxios_get_axis_standard_name(axis_Ptr axis_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -76,12 +91,16 @@
     std::string unit_str;
     if(!cstr2string(unit, unit_size, unit_str)) return;
+     CTimer::get("XIOS").resume();
     axis_hdl->unit.setValue(unit_str);
     axis_hdl->sendAttributToServer(axis_hdl->unit);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_axis_unit(axis_Ptr axis_hdl, char * unit, int unit_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(axis_hdl->unit.getValue(),unit , unit_size))
       ERROR("void cxios_get_axis_unit(axis_Ptr axis_hdl, char * unit, int unit_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -89,4 +108,5 @@
   void cxios_set_axis_value(axis_Ptr axis_hdl, double* value, int extent1)
   {
+     CTimer::get("XIOS").resume();
     ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1]));
     std::copy(value, &(value[array_tmp->num_elements()]), array_tmp->data());
@@ -99,4 +119,5 @@
     if (!array_copy(axis_hdl->value.getValue(), value, extent1))
      ERROR("void cxios_set_axis_value(axis_Ptr axis_hdl, double* value, int extent1)",<<"Output array size is not conform to array size attribute") ;
+     CTimer::get("XIOS").suspend();
   }
   
Index: XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c_attr/icaxisgroup_attr.cpp	(revision 347)
@@ -10,4 +10,5 @@
 #include "group_template_impl.hpp"
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -19,12 +20,16 @@
     std::string group_ref_str;
     if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
+     CTimer::get("XIOS").resume();
     axisgroup_hdl->group_ref.setValue(group_ref_str);
     axisgroup_hdl->sendAttributToServer(axisgroup_hdl->group_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, char * group_ref, int group_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(axisgroup_hdl->group_ref.getValue(),group_ref , group_ref_size))
       ERROR("void cxios_get_axisgroup_group_ref(axisgroup_Ptr axisgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -34,12 +39,16 @@
     std::string long_name_str;
     if(!cstr2string(long_name, long_name_size, long_name_str)) return;
+     CTimer::get("XIOS").resume();
     axisgroup_hdl->long_name.setValue(long_name_str);
     axisgroup_hdl->sendAttributToServer(axisgroup_hdl->long_name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, char * long_name, int long_name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(axisgroup_hdl->long_name.getValue(),long_name , long_name_size))
       ERROR("void cxios_get_axisgroup_long_name(axisgroup_Ptr axisgroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -49,12 +58,16 @@
     std::string name_str;
     if(!cstr2string(name, name_size, name_str)) return;
+     CTimer::get("XIOS").resume();
     axisgroup_hdl->name.setValue(name_str);
     axisgroup_hdl->sendAttributToServer(axisgroup_hdl->name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_axisgroup_name(axisgroup_Ptr axisgroup_hdl, char * name, int name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(axisgroup_hdl->name.getValue(),name , name_size))
       ERROR("void cxios_get_axisgroup_name(axisgroup_Ptr axisgroup_hdl, char * name, int name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -62,6 +75,8 @@
   void cxios_set_axisgroup_size(axisgroup_Ptr axisgroup_hdl, int size)
   {
+     CTimer::get("XIOS").resume();
     axisgroup_hdl->size.setValue(size);
     axisgroup_hdl->sendAttributToServer(axisgroup_hdl->size);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -76,12 +91,16 @@
     std::string standard_name_str;
     if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
+     CTimer::get("XIOS").resume();
     axisgroup_hdl->standard_name.setValue(standard_name_str);
     axisgroup_hdl->sendAttributToServer(axisgroup_hdl->standard_name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, char * standard_name, int standard_name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(axisgroup_hdl->standard_name.getValue(),standard_name , standard_name_size))
       ERROR("void cxios_get_axisgroup_standard_name(axisgroup_Ptr axisgroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -91,12 +110,16 @@
     std::string unit_str;
     if(!cstr2string(unit, unit_size, unit_str)) return;
+     CTimer::get("XIOS").resume();
     axisgroup_hdl->unit.setValue(unit_str);
     axisgroup_hdl->sendAttributToServer(axisgroup_hdl->unit);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, char * unit, int unit_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(axisgroup_hdl->unit.getValue(),unit , unit_size))
       ERROR("void cxios_get_axisgroup_unit(axisgroup_Ptr axisgroup_hdl, char * unit, int unit_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -104,4 +127,5 @@
   void cxios_set_axisgroup_value(axisgroup_Ptr axisgroup_hdl, double* value, int extent1)
   {
+     CTimer::get("XIOS").resume();
     ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1]));
     std::copy(value, &(value[array_tmp->num_elements()]), array_tmp->data());
@@ -114,4 +138,5 @@
     if (!array_copy(axisgroup_hdl->value.getValue(), value, extent1))
      ERROR("void cxios_set_axisgroup_value(axisgroup_Ptr axisgroup_hdl, double* value, int extent1)",<<"Output array size is not conform to array size attribute") ;
+     CTimer::get("XIOS").suspend();
   }
   
Index: XIOS/trunk/src/interface/c_attr/iccontext_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/iccontext_attr.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c_attr/iccontext_attr.cpp	(revision 347)
@@ -10,4 +10,5 @@
 #include "group_template_impl.hpp"
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -19,12 +20,16 @@
     std::string calendar_type_str;
     if(!cstr2string(calendar_type, calendar_type_size, calendar_type_str)) return;
+     CTimer::get("XIOS").resume();
     context_hdl->calendar_type.setValue(calendar_type_str);
     context_hdl->sendAttributToServer(context_hdl->calendar_type);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_context_calendar_type(context_Ptr context_hdl, char * calendar_type, int calendar_type_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(context_hdl->calendar_type.getValue(),calendar_type , calendar_type_size))
       ERROR("void cxios_get_context_calendar_type(context_Ptr context_hdl, char * calendar_type, int calendar_type_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -34,12 +39,16 @@
     std::string output_dir_str;
     if(!cstr2string(output_dir, output_dir_size, output_dir_str)) return;
+     CTimer::get("XIOS").resume();
     context_hdl->output_dir.setValue(output_dir_str);
     context_hdl->sendAttributToServer(context_hdl->output_dir);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_context_output_dir(context_Ptr context_hdl, char * output_dir, int output_dir_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(context_hdl->output_dir.getValue(),output_dir , output_dir_size))
       ERROR("void cxios_get_context_output_dir(context_Ptr context_hdl, char * output_dir, int output_dir_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -49,12 +58,16 @@
     std::string start_date_str;
     if(!cstr2string(start_date, start_date_size, start_date_str)) return;
+     CTimer::get("XIOS").resume();
     context_hdl->start_date.setValue(start_date_str);
     context_hdl->sendAttributToServer(context_hdl->start_date);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_context_start_date(context_Ptr context_hdl, char * start_date, int start_date_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(context_hdl->start_date.getValue(),start_date , start_date_size))
       ERROR("void cxios_get_context_start_date(context_Ptr context_hdl, char * start_date, int start_date_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -64,12 +77,16 @@
     std::string time_origin_str;
     if(!cstr2string(time_origin, time_origin_size, time_origin_str)) return;
+     CTimer::get("XIOS").resume();
     context_hdl->time_origin.setValue(time_origin_str);
     context_hdl->sendAttributToServer(context_hdl->time_origin);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_context_time_origin(context_Ptr context_hdl, char * time_origin, int time_origin_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(context_hdl->time_origin.getValue(),time_origin , time_origin_size))
       ERROR("void cxios_get_context_time_origin(context_Ptr context_hdl, char * time_origin, int time_origin_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -79,12 +96,16 @@
     std::string timestep_str;
     if(!cstr2string(timestep, timestep_size, timestep_str)) return;
+     CTimer::get("XIOS").resume();
     context_hdl->timestep.setValue(timestep_str);
     context_hdl->sendAttributToServer(context_hdl->timestep);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_context_timestep(context_Ptr context_hdl, char * timestep, int timestep_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(context_hdl->timestep.getValue(),timestep , timestep_size))
       ERROR("void cxios_get_context_timestep(context_Ptr context_hdl, char * timestep, int timestep_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
Index: XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c_attr/icdomain_attr.cpp	(revision 347)
@@ -10,4 +10,5 @@
 #include "group_template_impl.hpp"
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -17,6 +18,8 @@
   void cxios_set_domain_data_dim(domain_Ptr domain_hdl, int data_dim)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->data_dim.setValue(data_dim);
     domain_hdl->sendAttributToServer(domain_hdl->data_dim);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -29,4 +32,5 @@
   void cxios_set_domain_data_i_index(domain_Ptr domain_hdl, int* data_i_index, int extent1)
   {
+     CTimer::get("XIOS").resume();
     ARRAY(int,1) array_tmp(new CArray<int,1>(boost::extents[extent1]));
     std::copy(data_i_index, &(data_i_index[array_tmp->num_elements()]), array_tmp->data());
@@ -39,4 +43,5 @@
     if (!array_copy(domain_hdl->data_i_index.getValue(), data_i_index, extent1))
      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") ;
+     CTimer::get("XIOS").suspend();
   }
   
@@ -44,6 +49,8 @@
   void cxios_set_domain_data_ibegin(domain_Ptr domain_hdl, int data_ibegin)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->data_ibegin.setValue(data_ibegin);
     domain_hdl->sendAttributToServer(domain_hdl->data_ibegin);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -56,4 +63,5 @@
   void cxios_set_domain_data_j_index(domain_Ptr domain_hdl, int* data_j_index, int extent1)
   {
+     CTimer::get("XIOS").resume();
     ARRAY(int,1) array_tmp(new CArray<int,1>(boost::extents[extent1]));
     std::copy(data_j_index, &(data_j_index[array_tmp->num_elements()]), array_tmp->data());
@@ -66,4 +74,5 @@
     if (!array_copy(domain_hdl->data_j_index.getValue(), data_j_index, extent1))
      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") ;
+     CTimer::get("XIOS").suspend();
   }
   
@@ -71,6 +80,8 @@
   void cxios_set_domain_data_jbegin(domain_Ptr domain_hdl, int data_jbegin)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->data_jbegin.setValue(data_jbegin);
     domain_hdl->sendAttributToServer(domain_hdl->data_jbegin);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -83,6 +94,8 @@
   void cxios_set_domain_data_n_index(domain_Ptr domain_hdl, int data_n_index)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->data_n_index.setValue(data_n_index);
     domain_hdl->sendAttributToServer(domain_hdl->data_n_index);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -95,6 +108,8 @@
   void cxios_set_domain_data_ni(domain_Ptr domain_hdl, int data_ni)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->data_ni.setValue(data_ni);
     domain_hdl->sendAttributToServer(domain_hdl->data_ni);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -107,6 +122,8 @@
   void cxios_set_domain_data_nj(domain_Ptr domain_hdl, int data_nj)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->data_nj.setValue(data_nj);
     domain_hdl->sendAttributToServer(domain_hdl->data_nj);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -121,12 +138,16 @@
     std::string domain_group_ref_str;
     if(!cstr2string(domain_group_ref, domain_group_ref_size, domain_group_ref_str)) return;
+     CTimer::get("XIOS").resume();
     domain_hdl->domain_group_ref.setValue(domain_group_ref_str);
     domain_hdl->sendAttributToServer(domain_hdl->domain_group_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_domain_domain_group_ref(domain_Ptr domain_hdl, char * domain_group_ref, int domain_group_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(domain_hdl->domain_group_ref.getValue(),domain_group_ref , domain_group_ref_size))
       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");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -134,6 +155,8 @@
   void cxios_set_domain_ibegin(domain_Ptr domain_hdl, int ibegin)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->ibegin.setValue(ibegin);
     domain_hdl->sendAttributToServer(domain_hdl->ibegin);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -146,6 +169,8 @@
   void cxios_set_domain_iend(domain_Ptr domain_hdl, int iend)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->iend.setValue(iend);
     domain_hdl->sendAttributToServer(domain_hdl->iend);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -158,6 +183,8 @@
   void cxios_set_domain_jbegin(domain_Ptr domain_hdl, int jbegin)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->jbegin.setValue(jbegin);
     domain_hdl->sendAttributToServer(domain_hdl->jbegin);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -170,6 +197,8 @@
   void cxios_set_domain_jend(domain_Ptr domain_hdl, int jend)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->jend.setValue(jend);
     domain_hdl->sendAttributToServer(domain_hdl->jend);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -182,4 +211,5 @@
   void cxios_set_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1)
   {
+     CTimer::get("XIOS").resume();
     ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1]));
     std::copy(latvalue, &(latvalue[array_tmp->num_elements()]), array_tmp->data());
@@ -192,4 +222,5 @@
     if (!array_copy(domain_hdl->latvalue.getValue(), latvalue, extent1))
      ERROR("void cxios_set_domain_latvalue(domain_Ptr domain_hdl, double* latvalue, int extent1)",<<"Output array size is not conform to array size attribute") ;
+     CTimer::get("XIOS").suspend();
   }
   
@@ -199,12 +230,16 @@
     std::string long_name_str;
     if(!cstr2string(long_name, long_name_size, long_name_str)) return;
+     CTimer::get("XIOS").resume();
     domain_hdl->long_name.setValue(long_name_str);
     domain_hdl->sendAttributToServer(domain_hdl->long_name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(domain_hdl->long_name.getValue(),long_name , long_name_size))
       ERROR("void cxios_get_domain_long_name(domain_Ptr domain_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -212,4 +247,5 @@
   void cxios_set_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1)
   {
+     CTimer::get("XIOS").resume();
     ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1]));
     std::copy(lonvalue, &(lonvalue[array_tmp->num_elements()]), array_tmp->data());
@@ -222,4 +258,5 @@
     if (!array_copy(domain_hdl->lonvalue.getValue(), lonvalue, extent1))
      ERROR("void cxios_set_domain_lonvalue(domain_Ptr domain_hdl, double* lonvalue, int extent1)",<<"Output array size is not conform to array size attribute") ;
+     CTimer::get("XIOS").suspend();
   }
   
@@ -227,4 +264,5 @@
   void cxios_set_domain_mask(domain_Ptr domain_hdl, bool* mask, int extent1, int extent2)
   {
+     CTimer::get("XIOS").resume();
     ARRAY(bool,2) array_tmp(new CArray<bool,2>(boost::extents[extent1][extent2]));
     std::copy(mask, &(mask[array_tmp->num_elements()]), array_tmp->data());
@@ -237,4 +275,5 @@
     if (!array_copy(domain_hdl->mask.getValue(), mask, extent1, extent2))
      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") ;
+     CTimer::get("XIOS").suspend();
   }
   
@@ -244,12 +283,16 @@
     std::string name_str;
     if(!cstr2string(name, name_size, name_str)) return;
+     CTimer::get("XIOS").resume();
     domain_hdl->name.setValue(name_str);
     domain_hdl->sendAttributToServer(domain_hdl->name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(domain_hdl->name.getValue(),name , name_size))
       ERROR("void cxios_get_domain_name(domain_Ptr domain_hdl, char * name, int name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -257,6 +300,8 @@
   void cxios_set_domain_ni(domain_Ptr domain_hdl, int ni)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->ni.setValue(ni);
     domain_hdl->sendAttributToServer(domain_hdl->ni);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -269,6 +314,8 @@
   void cxios_set_domain_ni_glo(domain_Ptr domain_hdl, int ni_glo)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->ni_glo.setValue(ni_glo);
     domain_hdl->sendAttributToServer(domain_hdl->ni_glo);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -281,6 +328,8 @@
   void cxios_set_domain_nj(domain_Ptr domain_hdl, int nj)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->nj.setValue(nj);
     domain_hdl->sendAttributToServer(domain_hdl->nj);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -293,6 +342,8 @@
   void cxios_set_domain_nj_glo(domain_Ptr domain_hdl, int nj_glo)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->nj_glo.setValue(nj_glo);
     domain_hdl->sendAttributToServer(domain_hdl->nj_glo);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -307,12 +358,16 @@
     std::string standard_name_str;
     if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
+     CTimer::get("XIOS").resume();
     domain_hdl->standard_name.setValue(standard_name_str);
     domain_hdl->sendAttributToServer(domain_hdl->standard_name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(domain_hdl->standard_name.getValue(),standard_name , standard_name_size))
       ERROR("void cxios_get_domain_standard_name(domain_Ptr domain_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -320,6 +375,8 @@
   void cxios_set_domain_zoom_ibegin(domain_Ptr domain_hdl, int zoom_ibegin)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->zoom_ibegin.setValue(zoom_ibegin);
     domain_hdl->sendAttributToServer(domain_hdl->zoom_ibegin);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -332,6 +389,8 @@
   void cxios_set_domain_zoom_ibegin_loc(domain_Ptr domain_hdl, int zoom_ibegin_loc)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->zoom_ibegin_loc.setValue(zoom_ibegin_loc);
     domain_hdl->sendAttributToServer(domain_hdl->zoom_ibegin_loc);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -344,6 +403,8 @@
   void cxios_set_domain_zoom_jbegin(domain_Ptr domain_hdl, int zoom_jbegin)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->zoom_jbegin.setValue(zoom_jbegin);
     domain_hdl->sendAttributToServer(domain_hdl->zoom_jbegin);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -356,6 +417,8 @@
   void cxios_set_domain_zoom_jbegin_loc(domain_Ptr domain_hdl, int zoom_jbegin_loc)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->zoom_jbegin_loc.setValue(zoom_jbegin_loc);
     domain_hdl->sendAttributToServer(domain_hdl->zoom_jbegin_loc);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -368,6 +431,8 @@
   void cxios_set_domain_zoom_ni(domain_Ptr domain_hdl, int zoom_ni)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->zoom_ni.setValue(zoom_ni);
     domain_hdl->sendAttributToServer(domain_hdl->zoom_ni);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -380,6 +445,8 @@
   void cxios_set_domain_zoom_ni_loc(domain_Ptr domain_hdl, int zoom_ni_loc)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->zoom_ni_loc.setValue(zoom_ni_loc);
     domain_hdl->sendAttributToServer(domain_hdl->zoom_ni_loc);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -392,6 +459,8 @@
   void cxios_set_domain_zoom_nj(domain_Ptr domain_hdl, int zoom_nj)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->zoom_nj.setValue(zoom_nj);
     domain_hdl->sendAttributToServer(domain_hdl->zoom_nj);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -404,6 +473,8 @@
   void cxios_set_domain_zoom_nj_loc(domain_Ptr domain_hdl, int zoom_nj_loc)
   {
+     CTimer::get("XIOS").resume();
     domain_hdl->zoom_nj_loc.setValue(zoom_nj_loc);
     domain_hdl->sendAttributToServer(domain_hdl->zoom_nj_loc);
+     CTimer::get("XIOS").suspend();
   }
   
Index: XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c_attr/icdomaingroup_attr.cpp	(revision 347)
@@ -10,4 +10,5 @@
 #include "group_template_impl.hpp"
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -17,6 +18,8 @@
   void cxios_set_domaingroup_data_dim(domaingroup_Ptr domaingroup_hdl, int data_dim)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->data_dim.setValue(data_dim);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_dim);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -29,4 +32,5 @@
   void cxios_set_domaingroup_data_i_index(domaingroup_Ptr domaingroup_hdl, int* data_i_index, int extent1)
   {
+     CTimer::get("XIOS").resume();
     ARRAY(int,1) array_tmp(new CArray<int,1>(boost::extents[extent1]));
     std::copy(data_i_index, &(data_i_index[array_tmp->num_elements()]), array_tmp->data());
@@ -39,4 +43,5 @@
     if (!array_copy(domaingroup_hdl->data_i_index.getValue(), data_i_index, extent1))
      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") ;
+     CTimer::get("XIOS").suspend();
   }
   
@@ -44,6 +49,8 @@
   void cxios_set_domaingroup_data_ibegin(domaingroup_Ptr domaingroup_hdl, int data_ibegin)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->data_ibegin.setValue(data_ibegin);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_ibegin);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -56,4 +63,5 @@
   void cxios_set_domaingroup_data_j_index(domaingroup_Ptr domaingroup_hdl, int* data_j_index, int extent1)
   {
+     CTimer::get("XIOS").resume();
     ARRAY(int,1) array_tmp(new CArray<int,1>(boost::extents[extent1]));
     std::copy(data_j_index, &(data_j_index[array_tmp->num_elements()]), array_tmp->data());
@@ -66,4 +74,5 @@
     if (!array_copy(domaingroup_hdl->data_j_index.getValue(), data_j_index, extent1))
      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") ;
+     CTimer::get("XIOS").suspend();
   }
   
@@ -71,6 +80,8 @@
   void cxios_set_domaingroup_data_jbegin(domaingroup_Ptr domaingroup_hdl, int data_jbegin)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->data_jbegin.setValue(data_jbegin);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_jbegin);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -83,6 +94,8 @@
   void cxios_set_domaingroup_data_n_index(domaingroup_Ptr domaingroup_hdl, int data_n_index)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->data_n_index.setValue(data_n_index);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_n_index);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -95,6 +108,8 @@
   void cxios_set_domaingroup_data_ni(domaingroup_Ptr domaingroup_hdl, int data_ni)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->data_ni.setValue(data_ni);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_ni);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -107,6 +122,8 @@
   void cxios_set_domaingroup_data_nj(domaingroup_Ptr domaingroup_hdl, int data_nj)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->data_nj.setValue(data_nj);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->data_nj);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -121,12 +138,16 @@
     std::string domain_group_ref_str;
     if(!cstr2string(domain_group_ref, domain_group_ref_size, domain_group_ref_str)) return;
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->domain_group_ref.setValue(domain_group_ref_str);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->domain_group_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_domaingroup_domain_group_ref(domaingroup_Ptr domaingroup_hdl, char * domain_group_ref, int domain_group_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(domaingroup_hdl->domain_group_ref.getValue(),domain_group_ref , domain_group_ref_size))
       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");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -136,12 +157,16 @@
     std::string group_ref_str;
     if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->group_ref.setValue(group_ref_str);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->group_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, char * group_ref, int group_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(domaingroup_hdl->group_ref.getValue(),group_ref , group_ref_size))
       ERROR("void cxios_get_domaingroup_group_ref(domaingroup_Ptr domaingroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -149,6 +174,8 @@
   void cxios_set_domaingroup_ibegin(domaingroup_Ptr domaingroup_hdl, int ibegin)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->ibegin.setValue(ibegin);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ibegin);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -161,6 +188,8 @@
   void cxios_set_domaingroup_iend(domaingroup_Ptr domaingroup_hdl, int iend)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->iend.setValue(iend);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->iend);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -173,6 +202,8 @@
   void cxios_set_domaingroup_jbegin(domaingroup_Ptr domaingroup_hdl, int jbegin)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->jbegin.setValue(jbegin);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->jbegin);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -185,6 +216,8 @@
   void cxios_set_domaingroup_jend(domaingroup_Ptr domaingroup_hdl, int jend)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->jend.setValue(jend);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->jend);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -197,4 +230,5 @@
   void cxios_set_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1)
   {
+     CTimer::get("XIOS").resume();
     ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1]));
     std::copy(latvalue, &(latvalue[array_tmp->num_elements()]), array_tmp->data());
@@ -207,4 +241,5 @@
     if (!array_copy(domaingroup_hdl->latvalue.getValue(), latvalue, extent1))
      ERROR("void cxios_set_domaingroup_latvalue(domaingroup_Ptr domaingroup_hdl, double* latvalue, int extent1)",<<"Output array size is not conform to array size attribute") ;
+     CTimer::get("XIOS").suspend();
   }
   
@@ -214,12 +249,16 @@
     std::string long_name_str;
     if(!cstr2string(long_name, long_name_size, long_name_str)) return;
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->long_name.setValue(long_name_str);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->long_name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, char * long_name, int long_name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(domaingroup_hdl->long_name.getValue(),long_name , long_name_size))
       ERROR("void cxios_get_domaingroup_long_name(domaingroup_Ptr domaingroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -227,4 +266,5 @@
   void cxios_set_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1)
   {
+     CTimer::get("XIOS").resume();
     ARRAY(double,1) array_tmp(new CArray<double,1>(boost::extents[extent1]));
     std::copy(lonvalue, &(lonvalue[array_tmp->num_elements()]), array_tmp->data());
@@ -237,4 +277,5 @@
     if (!array_copy(domaingroup_hdl->lonvalue.getValue(), lonvalue, extent1))
      ERROR("void cxios_set_domaingroup_lonvalue(domaingroup_Ptr domaingroup_hdl, double* lonvalue, int extent1)",<<"Output array size is not conform to array size attribute") ;
+     CTimer::get("XIOS").suspend();
   }
   
@@ -242,4 +283,5 @@
   void cxios_set_domaingroup_mask(domaingroup_Ptr domaingroup_hdl, bool* mask, int extent1, int extent2)
   {
+     CTimer::get("XIOS").resume();
     ARRAY(bool,2) array_tmp(new CArray<bool,2>(boost::extents[extent1][extent2]));
     std::copy(mask, &(mask[array_tmp->num_elements()]), array_tmp->data());
@@ -252,4 +294,5 @@
     if (!array_copy(domaingroup_hdl->mask.getValue(), mask, extent1, extent2))
      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") ;
+     CTimer::get("XIOS").suspend();
   }
   
@@ -259,12 +302,16 @@
     std::string name_str;
     if(!cstr2string(name, name_size, name_str)) return;
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->name.setValue(name_str);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_domaingroup_name(domaingroup_Ptr domaingroup_hdl, char * name, int name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(domaingroup_hdl->name.getValue(),name , name_size))
       ERROR("void cxios_get_domaingroup_name(domaingroup_Ptr domaingroup_hdl, char * name, int name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -272,6 +319,8 @@
   void cxios_set_domaingroup_ni(domaingroup_Ptr domaingroup_hdl, int ni)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->ni.setValue(ni);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ni);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -284,6 +333,8 @@
   void cxios_set_domaingroup_ni_glo(domaingroup_Ptr domaingroup_hdl, int ni_glo)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->ni_glo.setValue(ni_glo);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->ni_glo);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -296,6 +347,8 @@
   void cxios_set_domaingroup_nj(domaingroup_Ptr domaingroup_hdl, int nj)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->nj.setValue(nj);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->nj);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -308,6 +361,8 @@
   void cxios_set_domaingroup_nj_glo(domaingroup_Ptr domaingroup_hdl, int nj_glo)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->nj_glo.setValue(nj_glo);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->nj_glo);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -322,12 +377,16 @@
     std::string standard_name_str;
     if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->standard_name.setValue(standard_name_str);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->standard_name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, char * standard_name, int standard_name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(domaingroup_hdl->standard_name.getValue(),standard_name , standard_name_size))
       ERROR("void cxios_get_domaingroup_standard_name(domaingroup_Ptr domaingroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -335,6 +394,8 @@
   void cxios_set_domaingroup_zoom_ibegin(domaingroup_Ptr domaingroup_hdl, int zoom_ibegin)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->zoom_ibegin.setValue(zoom_ibegin);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ibegin);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -347,6 +408,8 @@
   void cxios_set_domaingroup_zoom_ibegin_loc(domaingroup_Ptr domaingroup_hdl, int zoom_ibegin_loc)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->zoom_ibegin_loc.setValue(zoom_ibegin_loc);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ibegin_loc);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -359,6 +422,8 @@
   void cxios_set_domaingroup_zoom_jbegin(domaingroup_Ptr domaingroup_hdl, int zoom_jbegin)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->zoom_jbegin.setValue(zoom_jbegin);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_jbegin);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -371,6 +436,8 @@
   void cxios_set_domaingroup_zoom_jbegin_loc(domaingroup_Ptr domaingroup_hdl, int zoom_jbegin_loc)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->zoom_jbegin_loc.setValue(zoom_jbegin_loc);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_jbegin_loc);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -383,6 +450,8 @@
   void cxios_set_domaingroup_zoom_ni(domaingroup_Ptr domaingroup_hdl, int zoom_ni)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->zoom_ni.setValue(zoom_ni);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ni);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -395,6 +464,8 @@
   void cxios_set_domaingroup_zoom_ni_loc(domaingroup_Ptr domaingroup_hdl, int zoom_ni_loc)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->zoom_ni_loc.setValue(zoom_ni_loc);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_ni_loc);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -407,6 +478,8 @@
   void cxios_set_domaingroup_zoom_nj(domaingroup_Ptr domaingroup_hdl, int zoom_nj)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->zoom_nj.setValue(zoom_nj);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_nj);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -419,6 +492,8 @@
   void cxios_set_domaingroup_zoom_nj_loc(domaingroup_Ptr domaingroup_hdl, int zoom_nj_loc)
   {
+     CTimer::get("XIOS").resume();
     domaingroup_hdl->zoom_nj_loc.setValue(zoom_nj_loc);
     domaingroup_hdl->sendAttributToServer(domaingroup_hdl->zoom_nj_loc);
+     CTimer::get("XIOS").suspend();
   }
   
Index: XIOS/trunk/src/interface/c_attr/icfield_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icfield_attr.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c_attr/icfield_attr.cpp	(revision 347)
@@ -10,4 +10,5 @@
 #include "group_template_impl.hpp"
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -19,12 +20,16 @@
     std::string axis_ref_str;
     if(!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return;
+     CTimer::get("XIOS").resume();
     field_hdl->axis_ref.setValue(axis_ref_str);
     field_hdl->sendAttributToServer(field_hdl->axis_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_field_axis_ref(field_Ptr field_hdl, char * axis_ref, int axis_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(field_hdl->axis_ref.getValue(),axis_ref , axis_ref_size))
       ERROR("void cxios_get_field_axis_ref(field_Ptr field_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -32,6 +37,8 @@
   void cxios_set_field_default_value(field_Ptr field_hdl, double default_value)
   {
+     CTimer::get("XIOS").resume();
     field_hdl->default_value.setValue(default_value);
     field_hdl->sendAttributToServer(field_hdl->default_value);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -46,12 +53,16 @@
     std::string domain_ref_str;
     if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return;
+     CTimer::get("XIOS").resume();
     field_hdl->domain_ref.setValue(domain_ref_str);
     field_hdl->sendAttributToServer(field_hdl->domain_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_field_domain_ref(field_Ptr field_hdl, char * domain_ref, int domain_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(field_hdl->domain_ref.getValue(),domain_ref , domain_ref_size))
       ERROR("void cxios_get_field_domain_ref(field_Ptr field_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -59,6 +70,8 @@
   void cxios_set_field_enabled(field_Ptr field_hdl, bool enabled)
   {
+     CTimer::get("XIOS").resume();
     field_hdl->enabled.setValue(enabled);
     field_hdl->sendAttributToServer(field_hdl->enabled);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -73,12 +86,16 @@
     std::string field_ref_str;
     if(!cstr2string(field_ref, field_ref_size, field_ref_str)) return;
+     CTimer::get("XIOS").resume();
     field_hdl->field_ref.setValue(field_ref_str);
     field_hdl->sendAttributToServer(field_hdl->field_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_field_field_ref(field_Ptr field_hdl, char * field_ref, int field_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(field_hdl->field_ref.getValue(),field_ref , field_ref_size))
       ERROR("void cxios_get_field_field_ref(field_Ptr field_hdl, char * field_ref, int field_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -88,12 +105,16 @@
     std::string freq_offset_str;
     if(!cstr2string(freq_offset, freq_offset_size, freq_offset_str)) return;
+     CTimer::get("XIOS").resume();
     field_hdl->freq_offset.setValue(freq_offset_str);
     field_hdl->sendAttributToServer(field_hdl->freq_offset);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_field_freq_offset(field_Ptr field_hdl, char * freq_offset, int freq_offset_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(field_hdl->freq_offset.getValue(),freq_offset , freq_offset_size))
       ERROR("void cxios_get_field_freq_offset(field_Ptr field_hdl, char * freq_offset, int freq_offset_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -103,12 +124,16 @@
     std::string freq_op_str;
     if(!cstr2string(freq_op, freq_op_size, freq_op_str)) return;
+     CTimer::get("XIOS").resume();
     field_hdl->freq_op.setValue(freq_op_str);
     field_hdl->sendAttributToServer(field_hdl->freq_op);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_field_freq_op(field_Ptr field_hdl, char * freq_op, int freq_op_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(field_hdl->freq_op.getValue(),freq_op , freq_op_size))
       ERROR("void cxios_get_field_freq_op(field_Ptr field_hdl, char * freq_op, int freq_op_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -118,12 +143,16 @@
     std::string grid_ref_str;
     if(!cstr2string(grid_ref, grid_ref_size, grid_ref_str)) return;
+     CTimer::get("XIOS").resume();
     field_hdl->grid_ref.setValue(grid_ref_str);
     field_hdl->sendAttributToServer(field_hdl->grid_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_field_grid_ref(field_Ptr field_hdl, char * grid_ref, int grid_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(field_hdl->grid_ref.getValue(),grid_ref , grid_ref_size))
       ERROR("void cxios_get_field_grid_ref(field_Ptr field_hdl, char * grid_ref, int grid_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -131,6 +160,8 @@
   void cxios_set_field_level(field_Ptr field_hdl, int level)
   {
+     CTimer::get("XIOS").resume();
     field_hdl->level.setValue(level);
     field_hdl->sendAttributToServer(field_hdl->level);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -145,12 +176,16 @@
     std::string long_name_str;
     if(!cstr2string(long_name, long_name_size, long_name_str)) return;
+     CTimer::get("XIOS").resume();
     field_hdl->long_name.setValue(long_name_str);
     field_hdl->sendAttributToServer(field_hdl->long_name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(field_hdl->long_name.getValue(),long_name , long_name_size))
       ERROR("void cxios_get_field_long_name(field_Ptr field_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -160,12 +195,16 @@
     std::string name_str;
     if(!cstr2string(name, name_size, name_str)) return;
+     CTimer::get("XIOS").resume();
     field_hdl->name.setValue(name_str);
     field_hdl->sendAttributToServer(field_hdl->name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(field_hdl->name.getValue(),name , name_size))
       ERROR("void cxios_get_field_name(field_Ptr field_hdl, char * name, int name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -175,12 +214,16 @@
     std::string operation_str;
     if(!cstr2string(operation, operation_size, operation_str)) return;
+     CTimer::get("XIOS").resume();
     field_hdl->operation.setValue(operation_str);
     field_hdl->sendAttributToServer(field_hdl->operation);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(field_hdl->operation.getValue(),operation , operation_size))
       ERROR("void cxios_get_field_operation(field_Ptr field_hdl, char * operation, int operation_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -188,6 +231,8 @@
   void cxios_set_field_prec(field_Ptr field_hdl, int prec)
   {
+     CTimer::get("XIOS").resume();
     field_hdl->prec.setValue(prec);
     field_hdl->sendAttributToServer(field_hdl->prec);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -202,12 +247,16 @@
     std::string standard_name_str;
     if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
+     CTimer::get("XIOS").resume();
     field_hdl->standard_name.setValue(standard_name_str);
     field_hdl->sendAttributToServer(field_hdl->standard_name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(field_hdl->standard_name.getValue(),standard_name , standard_name_size))
       ERROR("void cxios_get_field_standard_name(field_Ptr field_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -217,12 +266,16 @@
     std::string unit_str;
     if(!cstr2string(unit, unit_size, unit_str)) return;
+     CTimer::get("XIOS").resume();
     field_hdl->unit.setValue(unit_str);
     field_hdl->sendAttributToServer(field_hdl->unit);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(field_hdl->unit.getValue(),unit , unit_size))
       ERROR("void cxios_get_field_unit(field_Ptr field_hdl, char * unit, int unit_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
Index: XIOS/trunk/src/interface/c_attr/icfieldgroup_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icfieldgroup_attr.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c_attr/icfieldgroup_attr.cpp	(revision 347)
@@ -10,4 +10,5 @@
 #include "group_template_impl.hpp"
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -19,12 +20,16 @@
     std::string axis_ref_str;
     if(!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return;
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->axis_ref.setValue(axis_ref_str);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->axis_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, char * axis_ref, int axis_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(fieldgroup_hdl->axis_ref.getValue(),axis_ref , axis_ref_size))
       ERROR("void cxios_get_fieldgroup_axis_ref(fieldgroup_Ptr fieldgroup_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -32,6 +37,8 @@
   void cxios_set_fieldgroup_default_value(fieldgroup_Ptr fieldgroup_hdl, double default_value)
   {
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->default_value.setValue(default_value);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->default_value);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -46,12 +53,16 @@
     std::string domain_ref_str;
     if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return;
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->domain_ref.setValue(domain_ref_str);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->domain_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, char * domain_ref, int domain_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(fieldgroup_hdl->domain_ref.getValue(),domain_ref , domain_ref_size))
       ERROR("void cxios_get_fieldgroup_domain_ref(fieldgroup_Ptr fieldgroup_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -59,6 +70,8 @@
   void cxios_set_fieldgroup_enabled(fieldgroup_Ptr fieldgroup_hdl, bool enabled)
   {
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->enabled.setValue(enabled);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->enabled);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -73,12 +86,16 @@
     std::string field_ref_str;
     if(!cstr2string(field_ref, field_ref_size, field_ref_str)) return;
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->field_ref.setValue(field_ref_str);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->field_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, char * field_ref, int field_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(fieldgroup_hdl->field_ref.getValue(),field_ref , field_ref_size))
       ERROR("void cxios_get_fieldgroup_field_ref(fieldgroup_Ptr fieldgroup_hdl, char * field_ref, int field_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -88,12 +105,16 @@
     std::string freq_offset_str;
     if(!cstr2string(freq_offset, freq_offset_size, freq_offset_str)) return;
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->freq_offset.setValue(freq_offset_str);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->freq_offset);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, char * freq_offset, int freq_offset_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(fieldgroup_hdl->freq_offset.getValue(),freq_offset , freq_offset_size))
       ERROR("void cxios_get_fieldgroup_freq_offset(fieldgroup_Ptr fieldgroup_hdl, char * freq_offset, int freq_offset_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -103,12 +124,16 @@
     std::string freq_op_str;
     if(!cstr2string(freq_op, freq_op_size, freq_op_str)) return;
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->freq_op.setValue(freq_op_str);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->freq_op);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, char * freq_op, int freq_op_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(fieldgroup_hdl->freq_op.getValue(),freq_op , freq_op_size))
       ERROR("void cxios_get_fieldgroup_freq_op(fieldgroup_Ptr fieldgroup_hdl, char * freq_op, int freq_op_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -118,12 +143,16 @@
     std::string grid_ref_str;
     if(!cstr2string(grid_ref, grid_ref_size, grid_ref_str)) return;
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->grid_ref.setValue(grid_ref_str);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->grid_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, char * grid_ref, int grid_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(fieldgroup_hdl->grid_ref.getValue(),grid_ref , grid_ref_size))
       ERROR("void cxios_get_fieldgroup_grid_ref(fieldgroup_Ptr fieldgroup_hdl, char * grid_ref, int grid_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -133,12 +162,16 @@
     std::string group_ref_str;
     if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->group_ref.setValue(group_ref_str);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->group_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(fieldgroup_hdl->group_ref.getValue(),group_ref , group_ref_size))
       ERROR("void cxios_get_fieldgroup_group_ref(fieldgroup_Ptr fieldgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -146,6 +179,8 @@
   void cxios_set_fieldgroup_level(fieldgroup_Ptr fieldgroup_hdl, int level)
   {
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->level.setValue(level);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->level);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -160,12 +195,16 @@
     std::string long_name_str;
     if(!cstr2string(long_name, long_name_size, long_name_str)) return;
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->long_name.setValue(long_name_str);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->long_name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(fieldgroup_hdl->long_name.getValue(),long_name , long_name_size))
       ERROR("void cxios_get_fieldgroup_long_name(fieldgroup_Ptr fieldgroup_hdl, char * long_name, int long_name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -175,12 +214,16 @@
     std::string name_str;
     if(!cstr2string(name, name_size, name_str)) return;
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->name.setValue(name_str);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(fieldgroup_hdl->name.getValue(),name , name_size))
       ERROR("void cxios_get_fieldgroup_name(fieldgroup_Ptr fieldgroup_hdl, char * name, int name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -190,12 +233,16 @@
     std::string operation_str;
     if(!cstr2string(operation, operation_size, operation_str)) return;
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->operation.setValue(operation_str);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->operation);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(fieldgroup_hdl->operation.getValue(),operation , operation_size))
       ERROR("void cxios_get_fieldgroup_operation(fieldgroup_Ptr fieldgroup_hdl, char * operation, int operation_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -203,6 +250,8 @@
   void cxios_set_fieldgroup_prec(fieldgroup_Ptr fieldgroup_hdl, int prec)
   {
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->prec.setValue(prec);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->prec);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -217,12 +266,16 @@
     std::string standard_name_str;
     if(!cstr2string(standard_name, standard_name_size, standard_name_str)) return;
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->standard_name.setValue(standard_name_str);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->standard_name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(fieldgroup_hdl->standard_name.getValue(),standard_name , standard_name_size))
       ERROR("void cxios_get_fieldgroup_standard_name(fieldgroup_Ptr fieldgroup_hdl, char * standard_name, int standard_name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -232,12 +285,16 @@
     std::string unit_str;
     if(!cstr2string(unit, unit_size, unit_str)) return;
+     CTimer::get("XIOS").resume();
     fieldgroup_hdl->unit.setValue(unit_str);
     fieldgroup_hdl->sendAttributToServer(fieldgroup_hdl->unit);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(fieldgroup_hdl->unit.getValue(),unit , unit_size))
       ERROR("void cxios_get_fieldgroup_unit(fieldgroup_Ptr fieldgroup_hdl, char * unit, int unit_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
Index: XIOS/trunk/src/interface/c_attr/icfile_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icfile_attr.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c_attr/icfile_attr.cpp	(revision 347)
@@ -10,4 +10,5 @@
 #include "group_template_impl.hpp"
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -19,12 +20,16 @@
     std::string description_str;
     if(!cstr2string(description, description_size, description_str)) return;
+     CTimer::get("XIOS").resume();
     file_hdl->description.setValue(description_str);
     file_hdl->sendAttributToServer(file_hdl->description);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_file_description(file_Ptr file_hdl, char * description, int description_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(file_hdl->description.getValue(),description , description_size))
       ERROR("void cxios_get_file_description(file_Ptr file_hdl, char * description, int description_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -32,6 +37,8 @@
   void cxios_set_file_enabled(file_Ptr file_hdl, bool enabled)
   {
+     CTimer::get("XIOS").resume();
     file_hdl->enabled.setValue(enabled);
     file_hdl->sendAttributToServer(file_hdl->enabled);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -46,12 +53,16 @@
     std::string name_str;
     if(!cstr2string(name, name_size, name_str)) return;
+     CTimer::get("XIOS").resume();
     file_hdl->name.setValue(name_str);
     file_hdl->sendAttributToServer(file_hdl->name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_file_name(file_Ptr file_hdl, char * name, int name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(file_hdl->name.getValue(),name , name_size))
       ERROR("void cxios_get_file_name(file_Ptr file_hdl, char * name, int name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -61,12 +72,16 @@
     std::string name_suffix_str;
     if(!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return;
+     CTimer::get("XIOS").resume();
     file_hdl->name_suffix.setValue(name_suffix_str);
     file_hdl->sendAttributToServer(file_hdl->name_suffix);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_file_name_suffix(file_Ptr file_hdl, char * name_suffix, int name_suffix_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(file_hdl->name_suffix.getValue(),name_suffix , name_suffix_size))
       ERROR("void cxios_get_file_name_suffix(file_Ptr file_hdl, char * name_suffix, int name_suffix_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -76,12 +91,16 @@
     std::string output_freq_str;
     if(!cstr2string(output_freq, output_freq_size, output_freq_str)) return;
+     CTimer::get("XIOS").resume();
     file_hdl->output_freq.setValue(output_freq_str);
     file_hdl->sendAttributToServer(file_hdl->output_freq);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_file_output_freq(file_Ptr file_hdl, char * output_freq, int output_freq_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(file_hdl->output_freq.getValue(),output_freq , output_freq_size))
       ERROR("void cxios_get_file_output_freq(file_Ptr file_hdl, char * output_freq, int output_freq_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -89,6 +108,8 @@
   void cxios_set_file_output_level(file_Ptr file_hdl, int output_level)
   {
+     CTimer::get("XIOS").resume();
     file_hdl->output_level.setValue(output_level);
     file_hdl->sendAttributToServer(file_hdl->output_level);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -103,12 +124,16 @@
     std::string par_access_str;
     if(!cstr2string(par_access, par_access_size, par_access_str)) return;
+     CTimer::get("XIOS").resume();
     file_hdl->par_access.setValue(par_access_str);
     file_hdl->sendAttributToServer(file_hdl->par_access);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_file_par_access(file_Ptr file_hdl, char * par_access, int par_access_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(file_hdl->par_access.getValue(),par_access , par_access_size))
       ERROR("void cxios_get_file_par_access(file_Ptr file_hdl, char * par_access, int par_access_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -118,12 +143,16 @@
     std::string split_freq_str;
     if(!cstr2string(split_freq, split_freq_size, split_freq_str)) return;
+     CTimer::get("XIOS").resume();
     file_hdl->split_freq.setValue(split_freq_str);
     file_hdl->sendAttributToServer(file_hdl->split_freq);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_file_split_freq(file_Ptr file_hdl, char * split_freq, int split_freq_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(file_hdl->split_freq.getValue(),split_freq , split_freq_size))
       ERROR("void cxios_get_file_split_freq(file_Ptr file_hdl, char * split_freq, int split_freq_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -133,12 +162,16 @@
     std::string sync_freq_str;
     if(!cstr2string(sync_freq, sync_freq_size, sync_freq_str)) return;
+     CTimer::get("XIOS").resume();
     file_hdl->sync_freq.setValue(sync_freq_str);
     file_hdl->sendAttributToServer(file_hdl->sync_freq);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_file_sync_freq(file_Ptr file_hdl, char * sync_freq, int sync_freq_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(file_hdl->sync_freq.getValue(),sync_freq , sync_freq_size))
       ERROR("void cxios_get_file_sync_freq(file_Ptr file_hdl, char * sync_freq, int sync_freq_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -148,12 +181,16 @@
     std::string type_str;
     if(!cstr2string(type, type_size, type_str)) return;
+     CTimer::get("XIOS").resume();
     file_hdl->type.setValue(type_str);
     file_hdl->sendAttributToServer(file_hdl->type);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_file_type(file_Ptr file_hdl, char * type, int type_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(file_hdl->type.getValue(),type , type_size))
       ERROR("void cxios_get_file_type(file_Ptr file_hdl, char * type, int type_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
Index: XIOS/trunk/src/interface/c_attr/icfilegroup_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icfilegroup_attr.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c_attr/icfilegroup_attr.cpp	(revision 347)
@@ -10,4 +10,5 @@
 #include "group_template_impl.hpp"
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -19,12 +20,16 @@
     std::string description_str;
     if(!cstr2string(description, description_size, description_str)) return;
+     CTimer::get("XIOS").resume();
     filegroup_hdl->description.setValue(description_str);
     filegroup_hdl->sendAttributToServer(filegroup_hdl->description);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_filegroup_description(filegroup_Ptr filegroup_hdl, char * description, int description_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(filegroup_hdl->description.getValue(),description , description_size))
       ERROR("void cxios_get_filegroup_description(filegroup_Ptr filegroup_hdl, char * description, int description_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -32,6 +37,8 @@
   void cxios_set_filegroup_enabled(filegroup_Ptr filegroup_hdl, bool enabled)
   {
+     CTimer::get("XIOS").resume();
     filegroup_hdl->enabled.setValue(enabled);
     filegroup_hdl->sendAttributToServer(filegroup_hdl->enabled);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -46,12 +53,16 @@
     std::string group_ref_str;
     if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
+     CTimer::get("XIOS").resume();
     filegroup_hdl->group_ref.setValue(group_ref_str);
     filegroup_hdl->sendAttributToServer(filegroup_hdl->group_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_filegroup_group_ref(filegroup_Ptr filegroup_hdl, char * group_ref, int group_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(filegroup_hdl->group_ref.getValue(),group_ref , group_ref_size))
       ERROR("void cxios_get_filegroup_group_ref(filegroup_Ptr filegroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -61,12 +72,16 @@
     std::string name_str;
     if(!cstr2string(name, name_size, name_str)) return;
+     CTimer::get("XIOS").resume();
     filegroup_hdl->name.setValue(name_str);
     filegroup_hdl->sendAttributToServer(filegroup_hdl->name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_filegroup_name(filegroup_Ptr filegroup_hdl, char * name, int name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(filegroup_hdl->name.getValue(),name , name_size))
       ERROR("void cxios_get_filegroup_name(filegroup_Ptr filegroup_hdl, char * name, int name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -76,12 +91,16 @@
     std::string name_suffix_str;
     if(!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return;
+     CTimer::get("XIOS").resume();
     filegroup_hdl->name_suffix.setValue(name_suffix_str);
     filegroup_hdl->sendAttributToServer(filegroup_hdl->name_suffix);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, char * name_suffix, int name_suffix_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(filegroup_hdl->name_suffix.getValue(),name_suffix , name_suffix_size))
       ERROR("void cxios_get_filegroup_name_suffix(filegroup_Ptr filegroup_hdl, char * name_suffix, int name_suffix_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -91,12 +110,16 @@
     std::string output_freq_str;
     if(!cstr2string(output_freq, output_freq_size, output_freq_str)) return;
+     CTimer::get("XIOS").resume();
     filegroup_hdl->output_freq.setValue(output_freq_str);
     filegroup_hdl->sendAttributToServer(filegroup_hdl->output_freq);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_filegroup_output_freq(filegroup_Ptr filegroup_hdl, char * output_freq, int output_freq_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(filegroup_hdl->output_freq.getValue(),output_freq , output_freq_size))
       ERROR("void cxios_get_filegroup_output_freq(filegroup_Ptr filegroup_hdl, char * output_freq, int output_freq_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -104,6 +127,8 @@
   void cxios_set_filegroup_output_level(filegroup_Ptr filegroup_hdl, int output_level)
   {
+     CTimer::get("XIOS").resume();
     filegroup_hdl->output_level.setValue(output_level);
     filegroup_hdl->sendAttributToServer(filegroup_hdl->output_level);
+     CTimer::get("XIOS").suspend();
   }
   
@@ -118,12 +143,16 @@
     std::string par_access_str;
     if(!cstr2string(par_access, par_access_size, par_access_str)) return;
+     CTimer::get("XIOS").resume();
     filegroup_hdl->par_access.setValue(par_access_str);
     filegroup_hdl->sendAttributToServer(filegroup_hdl->par_access);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_filegroup_par_access(filegroup_Ptr filegroup_hdl, char * par_access, int par_access_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(filegroup_hdl->par_access.getValue(),par_access , par_access_size))
       ERROR("void cxios_get_filegroup_par_access(filegroup_Ptr filegroup_hdl, char * par_access, int par_access_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -133,12 +162,16 @@
     std::string split_freq_str;
     if(!cstr2string(split_freq, split_freq_size, split_freq_str)) return;
+     CTimer::get("XIOS").resume();
     filegroup_hdl->split_freq.setValue(split_freq_str);
     filegroup_hdl->sendAttributToServer(filegroup_hdl->split_freq);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_filegroup_split_freq(filegroup_Ptr filegroup_hdl, char * split_freq, int split_freq_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(filegroup_hdl->split_freq.getValue(),split_freq , split_freq_size))
       ERROR("void cxios_get_filegroup_split_freq(filegroup_Ptr filegroup_hdl, char * split_freq, int split_freq_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -148,12 +181,16 @@
     std::string sync_freq_str;
     if(!cstr2string(sync_freq, sync_freq_size, sync_freq_str)) return;
+     CTimer::get("XIOS").resume();
     filegroup_hdl->sync_freq.setValue(sync_freq_str);
     filegroup_hdl->sendAttributToServer(filegroup_hdl->sync_freq);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, char * sync_freq, int sync_freq_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(filegroup_hdl->sync_freq.getValue(),sync_freq , sync_freq_size))
       ERROR("void cxios_get_filegroup_sync_freq(filegroup_Ptr filegroup_hdl, char * sync_freq, int sync_freq_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -163,12 +200,16 @@
     std::string type_str;
     if(!cstr2string(type, type_size, type_str)) return;
+     CTimer::get("XIOS").resume();
     filegroup_hdl->type.setValue(type_str);
     filegroup_hdl->sendAttributToServer(filegroup_hdl->type);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(filegroup_hdl->type.getValue(),type , type_size))
       ERROR("void cxios_get_filegroup_type(filegroup_Ptr filegroup_hdl, char * type, int type_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
Index: XIOS/trunk/src/interface/c_attr/icgrid_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icgrid_attr.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c_attr/icgrid_attr.cpp	(revision 347)
@@ -10,4 +10,5 @@
 #include "group_template_impl.hpp"
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -19,12 +20,16 @@
     std::string axis_ref_str;
     if(!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return;
+     CTimer::get("XIOS").resume();
     grid_hdl->axis_ref.setValue(axis_ref_str);
     grid_hdl->sendAttributToServer(grid_hdl->axis_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_grid_axis_ref(grid_Ptr grid_hdl, char * axis_ref, int axis_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(grid_hdl->axis_ref.getValue(),axis_ref , axis_ref_size))
       ERROR("void cxios_get_grid_axis_ref(grid_Ptr grid_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -34,12 +39,16 @@
     std::string description_str;
     if(!cstr2string(description, description_size, description_str)) return;
+     CTimer::get("XIOS").resume();
     grid_hdl->description.setValue(description_str);
     grid_hdl->sendAttributToServer(grid_hdl->description);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_grid_description(grid_Ptr grid_hdl, char * description, int description_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(grid_hdl->description.getValue(),description , description_size))
       ERROR("void cxios_get_grid_description(grid_Ptr grid_hdl, char * description, int description_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -49,12 +58,16 @@
     std::string domain_ref_str;
     if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return;
+     CTimer::get("XIOS").resume();
     grid_hdl->domain_ref.setValue(domain_ref_str);
     grid_hdl->sendAttributToServer(grid_hdl->domain_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_grid_domain_ref(grid_Ptr grid_hdl, char * domain_ref, int domain_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(grid_hdl->domain_ref.getValue(),domain_ref , domain_ref_size))
       ERROR("void cxios_get_grid_domain_ref(grid_Ptr grid_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -64,12 +77,16 @@
     std::string name_str;
     if(!cstr2string(name, name_size, name_str)) return;
+     CTimer::get("XIOS").resume();
     grid_hdl->name.setValue(name_str);
     grid_hdl->sendAttributToServer(grid_hdl->name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_grid_name(grid_Ptr grid_hdl, char * name, int name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(grid_hdl->name.getValue(),name , name_size))
       ERROR("void cxios_get_grid_name(grid_Ptr grid_hdl, char * name, int name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
Index: XIOS/trunk/src/interface/c_attr/icgridgroup_attr.cpp
===================================================================
--- XIOS/trunk/src/interface/c_attr/icgridgroup_attr.cpp	(revision 346)
+++ XIOS/trunk/src/interface/c_attr/icgridgroup_attr.cpp	(revision 347)
@@ -10,4 +10,5 @@
 #include "group_template_impl.hpp"
 #include "icutil.hpp"
+#include "timer.hpp"
 
 extern "C"
@@ -19,12 +20,16 @@
     std::string axis_ref_str;
     if(!cstr2string(axis_ref, axis_ref_size, axis_ref_str)) return;
+     CTimer::get("XIOS").resume();
     gridgroup_hdl->axis_ref.setValue(axis_ref_str);
     gridgroup_hdl->sendAttributToServer(gridgroup_hdl->axis_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_gridgroup_axis_ref(gridgroup_Ptr gridgroup_hdl, char * axis_ref, int axis_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(gridgroup_hdl->axis_ref.getValue(),axis_ref , axis_ref_size))
       ERROR("void cxios_get_gridgroup_axis_ref(gridgroup_Ptr gridgroup_hdl, char * axis_ref, int axis_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -34,12 +39,16 @@
     std::string description_str;
     if(!cstr2string(description, description_size, description_str)) return;
+     CTimer::get("XIOS").resume();
     gridgroup_hdl->description.setValue(description_str);
     gridgroup_hdl->sendAttributToServer(gridgroup_hdl->description);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_gridgroup_description(gridgroup_Ptr gridgroup_hdl, char * description, int description_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(gridgroup_hdl->description.getValue(),description , description_size))
       ERROR("void cxios_get_gridgroup_description(gridgroup_Ptr gridgroup_hdl, char * description, int description_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -49,12 +58,16 @@
     std::string domain_ref_str;
     if(!cstr2string(domain_ref, domain_ref_size, domain_ref_str)) return;
+     CTimer::get("XIOS").resume();
     gridgroup_hdl->domain_ref.setValue(domain_ref_str);
     gridgroup_hdl->sendAttributToServer(gridgroup_hdl->domain_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_gridgroup_domain_ref(gridgroup_Ptr gridgroup_hdl, char * domain_ref, int domain_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(gridgroup_hdl->domain_ref.getValue(),domain_ref , domain_ref_size))
       ERROR("void cxios_get_gridgroup_domain_ref(gridgroup_Ptr gridgroup_hdl, char * domain_ref, int domain_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -64,12 +77,16 @@
     std::string group_ref_str;
     if(!cstr2string(group_ref, group_ref_size, group_ref_str)) return;
+     CTimer::get("XIOS").resume();
     gridgroup_hdl->group_ref.setValue(group_ref_str);
     gridgroup_hdl->sendAttributToServer(gridgroup_hdl->group_ref);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl, char * group_ref, int group_ref_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(gridgroup_hdl->group_ref.getValue(),group_ref , group_ref_size))
       ERROR("void cxios_get_gridgroup_group_ref(gridgroup_Ptr gridgroup_hdl, char * group_ref, int group_ref_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
@@ -79,12 +96,16 @@
     std::string name_str;
     if(!cstr2string(name, name_size, name_str)) return;
+     CTimer::get("XIOS").resume();
     gridgroup_hdl->name.setValue(name_str);
     gridgroup_hdl->sendAttributToServer(gridgroup_hdl->name);
+     CTimer::get("XIOS").suspend();
   }
   
   void cxios_get_gridgroup_name(gridgroup_Ptr gridgroup_hdl, char * name, int name_size)
   {
+     CTimer::get("XIOS").resume();
     if(!string_copy(gridgroup_hdl->name.getValue(),name , name_size))
       ERROR("void cxios_get_gridgroup_name(gridgroup_Ptr gridgroup_hdl, char * name, int name_size)", <<"Input string is to short");
+     CTimer::get("XIOS").suspend();
   }
   
