Changeset 347


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

YM

Location:
XIOS/trunk/src
Files:
4 added
2 deleted
55 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/src/buffer_client.cpp

    r335 r347  
    55#include "cxios.hpp" 
    66#include <mpi.h> 
     7#include "tracer.hpp" 
    78 
    89namespace xios 
     
    7071    if (pending) 
    7172    { 
     73      traceOff() ; 
    7274      MPI_Test(&request,&flag,&status) ; 
     75      traceOn() ; 
    7376      if (flag==true) pending=false ; 
    7477    } 
  • XIOS/trunk/src/client.cpp

    r346 r347  
    66#include "context.hpp" 
    77#include "context_client.hpp" 
    8 #include "tree_manager.hpp" 
    98#include "oasis_cinterface.hpp" 
    109#include <mpi.h> 
     10#include "timer.hpp" 
    1111 
    1212namespace xios 
     
    130130    { 
    131131      CContext::setCurrent(id) ; 
    132       shared_ptr<CContext> context=CContext::create(id) ; 
     132      CContext* context=CContext::create(id) ; 
    133133         
    134134      if (!CXios::isServer) 
     
    193193      } 
    194194      info(20) << "Client side context is finalized"<<endl ; 
     195      report(0) <<" Performance report : total time spent for XIOS : "<< CTimer::get("XIOS").getCumulatedTime()<<" s"<<endl ;  
     196      report(0)<< " Performance report : time spent for waiting free buffer : "<< CTimer::get("Blocking time").getCumulatedTime()<<" s"<<endl ; 
     197      report(0)<< " Performance report : Ratio : "<< CTimer::get("Blocking time").getCumulatedTime()/CTimer::get("XIOS").getCumulatedTime()*100.<<" %"<<endl ; 
     198      report(0)<< " Performance report : This ratio must be close to zero. Otherwise it may be usefull to increase buffer size or numbers of server"<<endl ; 
    195199    } 
    196200} 
  • XIOS/trunk/src/context_client.cpp

    r345 r347  
    1010#include "context.hpp" 
    1111#include <mpi.h> 
     12#include "timer.hpp" 
    1213 
    1314namespace xios 
     
    9293      } 
    9394      free=false ; 
     95 
     96      CTimer::get("Blocking time").resume(); 
    9497      while(!free) 
    9598      { 
     
    101104        } 
    102105      } 
     106      CTimer::get("Blocking time").suspend(); 
     107 
    103108      for(itBuffer=bufferList.begin(),itSize=sizeList.begin(); itBuffer!=bufferList.end();itBuffer++,itSize++) 
    104109      { 
     
    185190     } 
    186191     sendEvent(event) ; 
    187         
     192  
     193     CTimer::get("Blocking time").resume(); 
    188194     while(stop) 
    189195     { 
     
    192198       for(itBuff=buffers.begin();itBuff!=buffers.end();itBuff++) stop|=itBuff->second->hasPendingRequest() ; 
    193199     } 
    194           
     200     CTimer::get("Blocking time").suspend(); 
     201      
    195202     releaseBuffers() ; 
    196203   } 
  • XIOS/trunk/src/context_server.cpp

    r346 r347  
    66#include "group_template_impl.hpp" 
    77#include "attribute_template_impl.hpp" 
    8 #include "tree_manager.hpp" 
    98#include "domain.hpp" 
    109 
    1110#include <mpi.h> 
     11#include "tracer.hpp" 
     12#include "timer.hpp" 
    1213 
    1314 
     
    6162      if (pendingRequest.find(rank)==pendingRequest.end()) 
    6263      { 
     64        traceOff() ; 
    6365        MPI_Iprobe(rank,20,interComm,&flag,&status);      
     66        traceOn() ; 
    6467        if (flag==true) 
    6568        { 
     
    9295    { 
    9396      rank=it->first ; 
     97      traceOff() ; 
    9498      MPI_Test(& it->second, &flag, &status) ; 
     99      traceOn() ; 
    95100      if (flag==true) 
    96101      { 
     
    144149      if (event->isFull()) 
    145150      { 
     151         CTimer::get("Process events").resume() ; 
    146152         dispatchEvent(*event) ; 
     153         CTimer::get("Process events").suspend() ; 
    147154         pendingEvent=false ; 
    148155         delete event ; 
  • XIOS/trunk/src/cxios.cpp

    r346 r347  
    44#include "client.hpp" 
    55#include "server.hpp" 
    6 //#include "tree_manager.hpp" 
    76#include "xml_parser.hpp" 
    87#include <boost/functional/hash.hpp> 
  • XIOS/trunk/src/data_output.cpp

    r346 r347  
    1414      //---------------------------------------------------------------- 
    1515 
    16       void CDataOutput::writeGrid 
    17          (const boost::shared_ptr<CGrid> grid) 
     16      void CDataOutput::writeGrid(CGrid* grid) 
    1817      { 
    1918         if (grid->domain_ref.isEmpty()) 
     
    3433      //---------------------------------------------------------------- 
    3534 
    36       void CDataOutput::writeFile 
    37          (const boost::shared_ptr<CFile>  file) 
     35      void CDataOutput::writeFile(CFile*  file) 
    3836      { 
    3937         this->writeFile_(file); 
     
    5250      //---------------------------------------------------------------- 
    5351 
    54       void CDataOutput::writeGrid 
    55          (const boost::shared_ptr<CDomain> domain, 
    56           const boost::shared_ptr<CAxis> axis) 
     52      void CDataOutput::writeGrid(CDomain* domain,CAxis* axis) 
    5753      { 
    5854         this->writeDomain_(domain); 
     
    6258      //---------------------------------------------------------------- 
    6359 
    64       void CDataOutput::writeGrid 
    65          (const boost::shared_ptr<CDomain> domain) 
     60      void CDataOutput::writeGrid(CDomain* domain) 
    6661      { 
    6762         this->writeDomain_(domain); 
     
    7065      //---------------------------------------------------------------- 
    7166 
    72       void CDataOutput::writeField 
    73          (const boost::shared_ptr<CField> field) 
     67      void CDataOutput::writeField(CField* field) 
    7468      { 
    75          boost::shared_ptr<CContext> context = CContext::getCurrent() ; 
     69         CContext* context = CContext::getCurrent() ; 
    7670         boost::shared_ptr<CCalendar> calendar = context->getCalendar(); 
    7771          
     
    8276      //---------------------------------------------------------------- 
    8377 
    84       void CDataOutput::writeFieldGrid 
    85          (const boost::shared_ptr<CField> field) 
     78      void CDataOutput::writeFieldGrid(CField* field) 
    8679      { 
    8780         this->writeGrid(field->getRelGrid()); 
     
    9083      //---------------------------------------------------------------- 
    9184       
    92       void CDataOutput::writeFieldData(const boost::shared_ptr<CField> field) 
     85      void CDataOutput::writeFieldData(CField* field) 
    9386      { 
    94          boost::shared_ptr<CGrid> grid = CGrid::get(field->grid_ref.getValue()); 
    95          boost::shared_ptr<CDomain> domain = CDomain::get(grid->domain_ref.getValue()); 
     87         CGrid* grid = CGrid::get(field->grid_ref.getValue()); 
     88         CDomain* domain = CDomain::get(grid->domain_ref.getValue()); 
    9689             
    9790//         if (domain->isEmpty()) return; 
  • XIOS/trunk/src/data_output.hpp

    r345 r347  
    2323 
    2424            /// Ecriture /// 
    25             void writeFile     (const boost::shared_ptr<CFile>  file); 
     25            void writeFile     (CFile*  file); 
    2626            void syncFile     (void); 
    2727            void closeFile     (void); 
    28             void writeField    (const boost::shared_ptr<CField> field); 
    29             void writeFieldGrid(const boost::shared_ptr<CField> field); 
    30             void writeFieldData(const boost::shared_ptr<CField> field); 
     28            void writeField    (CField* field); 
     29            void writeFieldGrid(CField* field); 
     30            void writeFieldData(CField* field); 
    3131 
    3232            virtual void definition_start(void) = 0; 
     
    3838 
    3939            /// Ecriture /// 
    40             void writeGrid(const boost::shared_ptr<CGrid>  grid); 
    41             void writeGrid(const boost::shared_ptr<CDomain> domain, 
    42                            const boost::shared_ptr<CAxis>   axis); 
    43             void writeGrid(const boost::shared_ptr<CDomain> domain); 
     40            void writeGrid(CGrid* grid); 
     41            void writeGrid(CDomain* domain, 
     42                           CAxis*   axis); 
     43            void writeGrid(CDomain* domain); 
    4444 
    45             virtual void writeFile_       (const boost::shared_ptr<CFile>     file)   = 0; 
     45            virtual void writeFile_       (CFile*     file)   = 0; 
    4646            virtual void closeFile_       (void)                                            = 0; 
    4747            virtual void syncFile_       (void)                                            = 0; 
    48             virtual void writeField_      (const boost::shared_ptr<CField>    field)  = 0; 
    49             virtual void writeFieldData_  (const boost::shared_ptr<CField>    field)  = 0; 
    50             virtual void writeDomain_     (const boost::shared_ptr<CDomain>   domain) = 0; 
    51             virtual void writeAxis_       (const boost::shared_ptr<CAxis>     axis)   = 0; 
    52             virtual void writeTimeAxis_   (const boost::shared_ptr<CField>    field, 
    53                                            const boost::shared_ptr<CCalendar> cal)    = 0; 
     48            virtual void writeField_      (CField*    field)  = 0; 
     49            virtual void writeFieldData_  (CField*    field)  = 0; 
     50            virtual void writeDomain_     (CDomain*   domain) = 0; 
     51            virtual void writeAxis_       (CAxis*     axis)   = 0; 
     52            virtual void writeTimeAxis_   (CField*    field, 
     53                                           const shared_ptr<CCalendar> cal)    = 0; 
    5454 
    5555            /// Propriétés protégées /// 
  • XIOS/trunk/src/field_impl.hpp

    r346 r347  
    77#include "context.hpp" 
    88#include "grid.hpp" 
     9#include "timer.hpp" 
    910 
    1011 
     
    1415   void CField::setData(const ARRAY(double, N) _data) 
    1516   { 
    16      const std::vector<boost::shared_ptr<CField> > & refField=getAllReference(); 
    17      std::vector<boost::shared_ptr<CField> >::const_iterator  it = refField.begin(), end = refField.end(); 
     17     const std::vector<CField*>& refField=getAllReference(); 
     18     std::vector<CField*>::const_iterator  it = refField.begin(), end = refField.end(); 
    1819      
    1920     for (; it != end; it++) (*it)->updateData(_data) ; 
     
    2324      bool CField::updateData(const ARRAY(double, N) _data) 
    2425   {         
    25       shared_ptr<CContext> context=CContext::getCurrent(); 
     26      CContext* context=CContext::getCurrent(); 
    2627      const CDate & currDate = context->getCalendar()->getCurrentDate(); 
    2728      const CDate opeDate      = *last_operation + freq_operation; 
     
    5253         *last_Write = writeDate; 
    5354         info(50) << "(*last_Write = currDate) : " << *last_Write << " = " << currDate  << std::endl; 
     55         CTimer::get("XIOS Send Data").resume() ; 
    5456         sendUpdateData() ; 
     57         CTimer::get("XIOS Send Data").suspend() ; 
    5558         return (true);         
    5659      } 
  • XIOS/trunk/src/generate_fortran_interface.cpp

    r346 r347  
    1111  string path="./interface/" ; 
    1212   
    13   CContext* context=CContext::create("interface").get(); 
     13  CContext* context=CContext::create("interface") ; 
    1414  CAxis axis ; 
    1515  CAxisGroup axisgroup ; 
  • XIOS/trunk/src/generate_interface_impl.hpp

    r335 r347  
    2222    oss<<"void cxios_set_"<<className<<"_"<<name<<"("<<className<<"_Ptr "<<className<<"_hdl, "<< typeName<<" "<<name<<")"<<iendl ; 
    2323    oss<<"{"<<iendl ; 
     24    oss<<"   CTimer::get(\"XIOS\").resume();"<<iendl ; 
    2425    oss<<"  "<<className<<"_hdl->"<<name<<".setValue("<<name<<");"<<iendl ; 
    2526    oss<<"  "<<className<<"_hdl->sendAttributToServer("<<className<<"_hdl->"<<name<<");"<<iendl ; 
     27    oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ; 
    2628    oss<<"}"<<iendl ; 
    2729     
     
    4143    oss<<"  std::string "<<name<<"_str;"<<iendl; 
    4244    oss<<"  if(!cstr2string("<<name<<", "<<name<<"_size, "<<name<<"_str)) return;"<<iendl ; 
     45    oss<<"   CTimer::get(\"XIOS\").resume();"<<iendl ; 
    4346    oss<<"  "<<className<<"_hdl->"<<name<<".setValue("<<name<<"_str);"<<iendl ; 
    4447    oss<<"  "<<className<<"_hdl->sendAttributToServer("<<className<<"_hdl->"<<name<<");"<<iendl ; 
     48    oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ; 
    4549    oss<<"}"<<iendl ; 
    4650     
     
    4953    oss<<"void cxios_get_"<<className<<"_"<<name<<"("<<className<<"_Ptr "<<className<<"_hdl, char * "<<name<<", int "<<name<<"_size)"<<iendl ; 
    5054    oss<<"{"<<iendl ; 
     55    oss<<"   CTimer::get(\"XIOS\").resume();"<<iendl ; 
    5156    oss<<"  if(!string_copy("<<className<<"_hdl->"<<name<<".getValue(),"<<name<<" , "<<name<<"_size))"<<iendl ; 
    5257    oss<<"    ERROR(\"void cxios_get_"<<className<<"_"<<name<<"("<<className<<"_Ptr "<<className<<"_hdl, char * "<<name<<", int " 
    5358       <<name<<"_size)\", <<\"Input string is to short\");"<<iendl ; 
    54  
     59    oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ; 
    5560    oss<<"}"<<iendl ; 
    5661   
     
    6974    oss<<"void cxios_set_"<<className<<"_"<<name<<"("<<className<<"_Ptr "<<className<<"_hdl, "<< typeName<<"* "<<name<<", int extent1)"<<iendl ;\ 
    7075    oss<<"{"<<iendl ;\ 
     76    oss<<"   CTimer::get(\"XIOS\").resume();"<<iendl ; \ 
    7177    oss<<"  ARRAY("<<typeName<<",1) array_tmp(new CArray<"<<typeName<<",1>(boost::extents[extent1]));"<<iendl ;\ 
    7278    oss<<"  std::copy("<<name<<", &("<<name<<"[array_tmp->num_elements()]), array_tmp->data());"<<iendl ;\ 
     
    8086    oss<<"   ERROR(\"void cxios_set_"<<className<<"_"<<name<<"("<<className<<"_Ptr "<<className<<"_hdl, "<< typeName<<"* "<<name<<", int extent1)\",<<" \ 
    8187       <<"\"Output array size is not conform to array size attribute\") ;"<<iendl; \ 
     88    oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ;\ 
    8289    oss<<"}"<<iendl ;\ 
    8390  }\ 
     
    9097    oss<<"void cxios_set_"<<className<<"_"<<name<<"("<<className<<"_Ptr "<<className<<"_hdl, "<< typeName<<"* "<<name<<", int extent1, int extent2)"<<iendl ;\ 
    9198    oss<<"{"<<iendl ;\ 
     99    oss<<"   CTimer::get(\"XIOS\").resume();"<<iendl ; \ 
    92100    oss<<"  ARRAY("<<typeName<<",2) array_tmp(new CArray<"<<typeName<<",2>(boost::extents[extent1][extent2]));"<<iendl ;\ 
    93101    oss<<"  std::copy("<<name<<", &("<<name<<"[array_tmp->num_elements()]), array_tmp->data());"<<iendl ;\ 
     
    101109    oss<<"   ERROR(\"void cxios_set_"<<className<<"_"<<name<<"("<<className<<"_Ptr "<<className<<"_hdl, "<< typeName<<"* "<<name<<", int extent1, int extent2)\",<<" \ 
    102110       <<"\"Output array size is not conform to array size attribute\") ;"<<iendl; \ 
     111    oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ;\ 
    103112    oss<<"}"<<iendl ;\ 
    104113  }\ 
     
    111120    oss<<"void cxios_set_"<<className<<"_"<<name<<"("<<className<<"_Ptr "<<className<<"_hdl, "<< typeName<<"* "<<name<<", int extent1, int extent2, int extent3)"<<iendl ;\ 
    112121    oss<<"{"<<iendl ;\ 
     122    oss<<"   CTimer::get(\"XIOS\").resume();"<<iendl ; \ 
    113123    oss<<"  ARRAY("<<typeName<<",3) array_tmp(new CArray<"<<typeName<<",3>(boost::extents[extent1][extent2][extent3]));"<<iendl ;\ 
    114124    oss<<"  std::copy("<<name<<", &("<<name<<"[array_tmp->num_elements()]), array_tmp->data());"<<iendl ;\ 
     
    122132    oss<<"   ERROR(\"void cxios_set_"<<className<<"_"<<name<<"("<<className<<"_Ptr "<<className<<"_hdl, "<< typeName<<"* "<<name<<", int extent1, int extent2, int extent3)\",<<" \ 
    123133       <<"\"Output array size is not conform to array size attribute\") ;"<<iendl; \ 
     134    oss<<"   CTimer::get(\"XIOS\").suspend();"<<iendl ;\ 
    124135    oss<<"}"<<iendl ;\ 
    125136  } 
  • XIOS/trunk/src/group_factory_impl.hpp

    r335 r347  
    3030               << " pgroup or cgroup NULL !"); 
    3131      if (!child->hasId()) 
    32          group->childList.insert(group->childList.end(), child); 
     32         group->childList.insert(group->childList.end(), child.get()); 
    3333      else 
    3434      { 
    35          group->childList.insert(group->childList.end(), child); 
    36          group->childMap.insert(std::make_pair(child->getId(), child)); 
     35         group->childList.insert(group->childList.end(), child.get()); 
     36         group->childMap.insert(std::make_pair(child->getId(), child.get())); 
    3737      } 
    3838   } 
     
    4747      { 
    4848         boost::shared_ptr<U> value = CObjectFactory::CreateObject<U>(CObjectFactory::GenUId<U>()); 
    49          group->groupList.insert(group->groupList.end(), value); 
    50          group->groupMap.insert(std::make_pair(value->getId(), value)); 
     49         group->groupList.insert(group->groupList.end(), value.get()); 
     50         group->groupMap.insert(std::make_pair(value->getId(), value.get())); 
    5151         return (value); 
    5252      } 
     
    5656      { 
    5757         boost::shared_ptr<U> value = CObjectFactory::CreateObject<U>(id); 
    58          group->groupList.insert(group->groupList.end(), value); 
    59          group->groupMap.insert(std::make_pair(id, value)); 
     58         group->groupList.insert(group->groupList.end(), value.get()); 
     59         group->groupMap.insert(std::make_pair(id, value.get())); 
    6060         return (value); 
    6161      } 
     
    7272         boost::shared_ptr<typename U::RelChild> value = 
    7373               CObjectFactory::CreateObject<typename U::RelChild>(); 
    74          group->childList.insert(group->childList.end(), value); 
    75          group->childMap.insert(std::make_pair(value->getId(), value)); 
     74         group->childList.insert(group->childList.end(), value.get()); 
     75         group->childMap.insert(std::make_pair(value->getId(), value.get())); 
    7676         return (value); 
    7777      } 
     
    8282         boost::shared_ptr<typename U::RelChild> value = 
    8383               CObjectFactory::CreateObject<typename U::RelChild>(id); 
    84          group->childList.insert(group->childList.end(), value); 
    85          group->childMap.insert(std::make_pair(id, value)); 
     84         group->childList.insert(group->childList.end(), value.get()); 
     85         group->childMap.insert(std::make_pair(id, value.get())); 
    8686         return (value); 
    8787      } 
     
    120120               << "[ id = " << id << ", U = " << U::GetName() << " ] " 
    121121               << " group is not referenced !"); 
    122       return (group->groupMap[id]); 
     122      return (group->groupMap[id]->getShared()); 
    123123   } 
    124124 
     
    131131               << "[ id = " << id << ", U = " << U::GetName() << " ] " 
    132132               << " child is not referenced !"); 
    133       return (group->childMap[id]); 
     133      return (group->childMap[id]->getShared()); 
    134134   } 
    135135 
  • XIOS/trunk/src/group_parser.hpp

    r346 r347  
    2828 
    2929      // PARSING POUR GESTION DES ENFANTS 
    30       boost::shared_ptr<V> group_ptr = (this->hasId()) 
    31          ? CObjectFactory::GetObject<V>(this->getId()) 
    32          : CObjectFactory::GetObject(boost::polymorphic_downcast<V*>(this)); 
     30           V* group_ptr = (this->hasId())  
     31         ? V::get(this->getId()) 
     32         : boost::polymorphic_downcast<V*>(this); 
    3333 
    3434      if (!(node.goToChildElement())) 
     
    5252            { 
    5353               if (attributes.end() == attributes.find("id")) 
    54                   CGroupFactory::CreateGroup(group_ptr)->parse(node); 
     54                  CGroupFactory::CreateGroup(group_ptr->getShared())->parse(node); 
    5555               else 
    56                   CGroupFactory::CreateGroup(group_ptr, attributes["id"])->parse(node); 
     56                  CGroupFactory::CreateGroup(group_ptr->getShared(), attributes["id"])->parse(node); 
    5757               continue; 
    5858            } 
     
    6161            { 
    6262               if (attributes.end() == attributes.find("id")) 
    63                   CGroupFactory::CreateChild(group_ptr)->parse(node); 
     63                  CGroupFactory::CreateChild(group_ptr->getShared())->parse(node); 
    6464               else 
    65                   CGroupFactory::CreateChild(group_ptr, attributes["id"])->parse(node); 
     65                  CGroupFactory::CreateChild(group_ptr->getShared(), attributes["id"])->parse(node); 
    6666               continue; 
    6767            } 
  • XIOS/trunk/src/group_template.hpp

    r346 r347  
    3535 
    3636         /// Accesseurs /// 
    37          const xios_map<StdString, 
    38                            boost::shared_ptr<Group> >& getGroupMap(void) const; 
    39          const std::vector<boost::shared_ptr<Child> >& getChildList(void) const; 
     37         const xios_map<StdString,Group*>& getGroupMap(void) const; 
     38         const vector<Child*>& getChildList(void) const; 
    4039 
    41          void getAllChildren(std::vector<boost::shared_ptr<Child> > & allc) const; 
    42          std::vector<boost::shared_ptr<Child> > getAllChildren(void) const; 
     40         void getAllChildren(vector<Child*> & allc) const; 
     41         vector<Child*> getAllChildren(void) const; 
    4342 
    4443         /// Autres /// 
     
    6564//         static boost::shared_ptr<V> get(const string& id) ; 
    6665//         static boost::shared_ptr<V> create(const string& id=string("")) ; 
    67          boost::shared_ptr<U> createChild(const string& id="") ;  
    68          void addChild(shared_ptr<U> child) ;  
    69          boost::shared_ptr<V> createChildGroup(const string& id="") ;  
    70          void addChildGroup(shared_ptr<V> childGroup) ;  
     66         U* createChild(const string& id="") ; 
     67           
     68         void addChild(U* child) ;  
     69         V* createChildGroup(const string& id="") ;  
     70         void addChildGroup(V* childGroup) ;  
    7171         static bool dispatchEvent(CEventServer& event) ; 
    7272         void sendCreateChild(const string& id="") ; 
     
    9292 
    9393         /// Propriétés /// 
    94          xios_map<StdString, 
    95                      boost::shared_ptr<Child> > childMap; 
    96          std::vector<boost::shared_ptr<Child> > childList; 
     94         xios_map<StdString, Child* > childMap; 
     95         vector<Child*> childList; 
    9796 
    98          xios_map<StdString, 
    99                      boost::shared_ptr<Group> > groupMap; 
    100          std::vector<boost::shared_ptr<Group> > groupList; 
     97         xios_map<StdString,Group* > groupMap; 
     98         vector<Group* > groupList; 
    10199 
    102100   }; // class CGroupTemplate 
  • XIOS/trunk/src/group_template_impl.hpp

    r346 r347  
    4949      os.write (reinterpret_cast<const char*>(&chdnb) , sizeof(StdSize));       
    5050       
    51       typename std::vector<boost::shared_ptr<V> >::const_iterator  
     51      typename std::vector<V*>::const_iterator  
    5252         itg = this->groupList.begin(), endg = this->groupList.end(); 
    53       typename std::vector<boost::shared_ptr<U> >::const_iterator  
     53      typename std::vector<U*>::const_iterator  
    5454         itc = this->childList.begin(), endc = this->childList.end(); 
    5555             
    5656      for (; itg != endg; itg++) 
    5757      {  
    58          boost::shared_ptr<V> group = *itg; 
     58         V* group = *itg; 
    5959         bool hid = group->hasId(); 
    6060          
     
    7575      for (; itc != endc; itc++) 
    7676      {  
    77          boost::shared_ptr<U> child = *itc; 
     77         U* child = *itc; 
    7878         bool hid = child->hasId(); 
    7979          
     
    9999      SuperClass::fromBinary(is); 
    100100       
    101       boost::shared_ptr<V> group_ptr = (this->hasId()) 
    102          ? CObjectFactory::GetObject<V>(this->getId()) 
    103          : CObjectFactory::GetObject(boost::polymorphic_downcast<V*>(this)); 
     101      V* group_ptr = (this->hasId()) 
     102         ? V::get(this->getId()) 
     103         : V::get((V*)this); 
    104104       
    105105      StdSize grpnb = 0; 
     
    126126            StdString id(size, ' '); 
    127127            is.read (const_cast<char *>(id.data()), size * sizeof(char)); 
    128             CGroupFactory::CreateGroup(group_ptr, id)->fromBinary(is); 
     128            CGroupFactory::CreateGroup(group_ptr->getShared(), id)->fromBinary(is); 
    129129         } 
    130130         else 
    131131         { 
    132             CGroupFactory::CreateGroup(group_ptr)->fromBinary(is); 
     132            CGroupFactory::CreateGroup(group_ptr->getShared())->fromBinary(is); 
    133133         } 
    134134      } 
     
    150150            StdString id(size, ' '); 
    151151            is.read (const_cast<char *>(id.data()), size * sizeof(char)); 
    152             CGroupFactory::CreateChild(group_ptr, id)->fromBinary(is);             
     152            CGroupFactory::CreateChild(group_ptr->getShared(), id)->fromBinary(is);             
    153153         } 
    154154         else 
    155155         { 
    156             CGroupFactory::CreateChild(group_ptr)->fromBinary(is); 
     156            CGroupFactory::CreateChild(group_ptr->getShared())->fromBinary(is); 
    157157         }    
    158158      } 
     
    176176         oss << SuperClassAttribute::toString() << ">" << std::endl; 
    177177          
    178          typename std::vector<boost::shared_ptr<V> >::const_iterator  
     178         typename std::vector<V*>::const_iterator  
    179179            itg = this->groupList.begin(), endg = this->groupList.end(); 
    180          typename std::vector<boost::shared_ptr<U> >::const_iterator  
     180         typename std::vector<U*>::const_iterator  
    181181            itc = this->childList.begin(), endc = this->childList.end(); 
    182182             
    183183         for (; itg != endg; itg++) 
    184184         {  
    185             boost::shared_ptr<V> group = *itg; 
     185            V* group = *itg; 
    186186            oss << *group << std::endl; 
    187187         } 
     
    189189         for (; itc != endc; itc++) 
    190190         {  
    191             boost::shared_ptr<U> child = *itc; 
     191            U* child = *itc; 
    192192            oss << *child << std::endl; 
    193193         } 
     
    226226 
    227227   template <class U, class V, class W> 
    228       const std::vector<boost::shared_ptr<U> >& 
     228      const std::vector<U*>& 
    229229         CGroupTemplate<U, V, W>::getChildList(void) const 
    230230   {  
     
    235235 
    236236   template <class U, class V, class W> 
    237       const xios_map<StdString, boost::shared_ptr<V> >& 
     237      const xios_map<StdString, V*>& 
    238238         CGroupTemplate<U, V, W>::getGroupMap(void) const 
    239239   {  
     
    265265         SuperClassAttribute::setAttributes(parent); 
    266266          
    267       typename std::vector<boost::shared_ptr<U> >::const_iterator  
     267      typename std::vector<U*>::const_iterator  
    268268         itc = this->childList.begin(), endc = this->childList.end(); 
    269       typename std::vector<boost::shared_ptr<V> >::const_iterator  
     269      typename std::vector<V*>::const_iterator  
    270270         itg = this->groupList.begin(), endg = this->groupList.end(); 
    271271              
    272272      for (; itc != endc; itc++) 
    273273      {  
    274          boost::shared_ptr<U> child = *itc; 
     274         U* child = *itc; 
    275275         child->solveDescInheritance(this); 
    276276      } 
     
    278278      for (; itg != endg; itg++) 
    279279      {  
    280          boost::shared_ptr<V> group = *itg; 
     280         V* group = *itg; 
    281281         group->solveRefInheritance(); 
    282282         group->solveDescInheritance(this); 
     
    287287 
    288288   template <class U, class V, class W> 
    289       void CGroupTemplate<U, V, W>::getAllChildren(std::vector<boost::shared_ptr<U> > & allc) const 
     289      void CGroupTemplate<U, V, W>::getAllChildren(std::vector<U*>& allc) const 
    290290   { 
    291291      allc.insert (allc.end(), childList.begin(), childList.end()); 
    292       typename std::vector<boost::shared_ptr<V> >::const_iterator  
     292      typename std::vector<V*>::const_iterator  
    293293         itg = this->groupList.begin(), endg = this->groupList.end(); 
    294294          
    295295      for (; itg != endg; itg++) 
    296296      {  
    297          boost::shared_ptr<V> group = *itg; 
     297         V* group = *itg; 
    298298         group->getAllChildren(allc); 
    299299      } 
     
    303303 
    304304   template <class U, class V, class W> 
    305       std::vector<boost::shared_ptr<U> > CGroupTemplate<U, V, W>::getAllChildren(void) const 
    306    {  
    307       std::vector<boost::shared_ptr<U> > allc; 
     305      std::vector<U*> CGroupTemplate<U, V, W>::getAllChildren(void) const 
     306   {  
     307      std::vector<U*> allc; 
    308308      this->getAllChildren(allc); 
    309309      return (allc); 
     
    343343   
    344344   template <class U, class V, class W> 
    345    boost::shared_ptr<U> CGroupTemplate<U, V, W>::createChild(const string& id)  
     345   U* CGroupTemplate<U, V, W>::createChild(const string& id)  
    346346  { 
    347     return CGroupFactory::CreateChild<V>(this->get(), id) ; 
     347    return CGroupFactory::CreateChild<V>(this->getShared(), id).get() ; 
    348348  } 
    349349 
    350350   template <class U, class V, class W> 
    351    void CGroupTemplate<U, V, W>::addChild(shared_ptr<U> child)  
     351   void CGroupTemplate<U, V, W>::addChild(U* child)  
    352352  { 
    353     return CGroupFactory::AddChild<V>(this->get(),child) ; 
     353    return CGroupFactory::AddChild<V>(this->getShared,child->getShared()) ; 
    354354  } 
    355355   
    356356   template <class U, class V, class W> 
    357    boost::shared_ptr<V> CGroupTemplate<U, V, W>::createChildGroup(const string& id)  
     357   V* CGroupTemplate<U, V, W>::createChildGroup(const string& id)  
    358358  { 
    359     return CGroupFactory::CreateGroup<V>(this->get(), id) ; 
     359    return CGroupFactory::CreateGroup<V>(this->getShared(), id).get() ; 
    360360  } 
    361361 
    362362   template <class U, class V, class W> 
    363    void CGroupTemplate<U, V, W>::addChildGroup(shared_ptr<V> childGroup)  
     363   void CGroupTemplate<U, V, W>::addChildGroup(V* childGroup)  
    364364  { 
    365     return CGroupFactory::AddGroup<V>(this->get(), childGroup) ; 
     365    return CGroupFactory::AddGroup<V>(this->getShared(), childGroup->getShared()) ; 
    366366  } 
    367367 
     
    370370   void CGroupTemplate<U, V, W>::sendCreateChild(const string& id) 
    371371   { 
    372     shared_ptr<CContext> context=CContext::getCurrent() ; 
     372    CContext* context=CContext::getCurrent() ; 
    373373     
    374374    if (! context->hasServer ) 
     
    393393   void CGroupTemplate<U, V, W>::sendCreateChildGroup(const string& id) 
    394394   { 
    395     shared_ptr<CContext> context=CContext::getCurrent() ; 
     395    CContext* context=CContext::getCurrent() ; 
    396396    if (! context->hasServer ) 
    397397    { 
  • XIOS/trunk/src/interface/c/icaxis.cpp

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    r335 r347  
    33namespace xios 
    44{ 
    5   CLog info ; 
     5  CLog info("info") ; 
     6  CLog report("report") ; 
    67} 
  • XIOS/trunk/src/log.hpp

    r335 r347  
    1010  { 
    1111    public : 
    12     CLog(void) : ostream(cout.rdbuf()),level(0) {} 
     12    CLog(const string& name_) : ostream(cout.rdbuf()),level(0),name(name_) {} 
    1313    CLog& operator()(int l)  
    1414    {   
     
    1616      { 
    1717        rdbuf(cout.rdbuf()) ; 
    18         *this<<"-> info : " ; 
     18        *this<<"-> "<<name<<" : " ; 
    1919      } 
    2020      else rdbuf(NULL) ; 
     
    2828    private : 
    2929    int level ; 
     30    string name ; 
    3031  }; 
    3132 
    3233  extern CLog info; 
     34  extern CLog report; 
    3335} 
    3436#endif 
  • XIOS/trunk/src/node/context.cpp

    r346 r347  
    11#include "context.hpp" 
    2 #include "tree_manager.hpp" 
    3  
    42#include "attribute_template_impl.hpp" 
    53#include "object_template_impl.hpp" 
     
    4442   //---------------------------------------------------------------- 
    4543 
    46    boost::shared_ptr<CContextGroup> CContext::getRoot(void) 
     44   CContextGroup* CContext::getRoot(void) 
    4745   {   
    4846      if (root.get()==NULL) root=shared_ptr<CContextGroup>(new CContextGroup(xml::CXMLNode::GetRootName())) ; 
    49       return root;  
     47      return root.get();  
    5048   } 
    5149    
     
    155153   { 
    156154      StdString currentContextId = CContext::getCurrent() -> getId() ; 
    157       std::vector<boost::shared_ptr<CContext> > def_vector = 
     155      std::vector<CContext*> def_vector = 
    158156         CContext::getRoot()->getChildList(); 
    159       std::vector<boost::shared_ptr<CContext> >::iterator 
     157      std::vector<CContext*>::iterator 
    160158         it = def_vector.begin(), end = def_vector.end(); 
    161159 
     
    165163      for (; it != end; it++) 
    166164      { 
    167          boost::shared_ptr<CContext> context = *it;          
     165         CContext* context = *it;          
    168166         CContext::setCurrent(context->getId());          
    169167         out << *context << std::endl; 
     
    270268   { 
    271269      if (!this->hasId()) return; 
    272       std::vector<boost::shared_ptr<CField> >& allField 
    273                = CObjectTemplate<CField>::GetAllVectobject(this->getId()); 
    274       std::vector<boost::shared_ptr<CField> >::iterator  
     270      vector<CField*> allField = CField::getAll() ; 
     271//              = CObjectTemplate<CField>::GetAllVectobject(this->getId()); 
     272      std::vector<CField*>::iterator  
    275273         it = allField.begin(), end = allField.end(); 
    276274             
    277275      for (; it != end; it++) 
    278276      { 
    279          boost::shared_ptr<CField> field = *it; 
     277         CField* field = *it; 
    280278         field->solveRefInheritance(); 
    281279      } 
     
    376374 
    377375     // Résolution des héritages par référence au niveau des fichiers. 
    378       const std::vector<boost::shared_ptr<CFile> > & allFiles=CFile::getAll() ; 
     376      const vector<CFile*> allFiles=CFile::getAll() ; 
    379377 
    380378      for (unsigned int i = 0; i < allFiles.size(); i++) 
     
    384382   void CContext::findEnabledFiles(void) 
    385383   { 
    386       const std::vector<boost::shared_ptr<CFile> > & allFiles = CFile::getAll(); 
     384      const std::vector<CFile*> allFiles = CFile::getAll(); 
    387385 
    388386      for (unsigned int i = 0; i < allFiles.size(); i++) 
     
    398396   void CContext::closeAllFile(void) 
    399397   { 
    400      std::vector<boost::shared_ptr<CFile> >::const_iterator 
     398     std::vector<CFile*>::const_iterator 
    401399            it = this->enabledFiles.begin(), end = this->enabledFiles.end(); 
    402400          
     
    528526   void CContext::createFileHeader(void ) 
    529527   { 
    530       vector<shared_ptr<CFile> >::const_iterator it ; 
     528      vector<CFile*>::const_iterator it ; 
    531529          
    532530      for (it=enabledFiles.begin(); it != enabledFiles.end(); it++) 
     
    536534   }  
    537535    
    538    shared_ptr<CContext> CContext::getCurrent(void) 
    539    { 
    540      return CObjectFactory::GetObject<CContext>(CObjectFactory::GetCurrentContextId()) ; 
     536   CContext* CContext::getCurrent(void) 
     537   { 
     538     return CObjectFactory::GetObject<CContext>(CObjectFactory::GetCurrentContextId()).get() ; 
    541539   } 
    542540    
     
    547545   } 
    548546    
    549   boost::shared_ptr<CContext> CContext::create(const StdString& id) 
     547  CContext* CContext::create(const StdString& id) 
    550548  { 
    551549    CContext::setCurrent(id) ; 
    552550  
    553551    bool hasctxt = CContext::has(id); 
    554     boost::shared_ptr<CContext> context = CObjectFactory::CreateObject<CContext>(id); 
    555     if (!hasctxt) CGroupFactory::AddChild(getRoot(), context); 
     552    CContext* context = CObjectFactory::CreateObject<CContext>(id).get(); 
     553    getRoot() ; 
     554    if (!hasctxt) CGroupFactory::AddChild(root, context->getShared()); 
    556555 
    557556#define DECLARE_NODE(Name_, name_) \ 
  • XIOS/trunk/src/node/context.hpp

    r346 r347  
    8282         static ENodeType GetType(void);          
    8383 
    84          static boost::shared_ptr<CContextGroup> GetContextGroup(void); 
     84         static CContextGroup* GetContextGroup(void); 
    8585 
    8686      public : 
     
    127127         static void recvCreateFileHeader(CEventServer& event) ; 
    128128         void recvCreateFileHeader(CBufferIn& buffer) ; 
    129          static shared_ptr<CContext> getCurrent(void) ; 
    130          static shared_ptr<CContextGroup> getRoot(void) ; 
     129         static CContext* getCurrent(void) ; 
     130         static CContextGroup* getRoot(void) ; 
    131131         static void setCurrent(const string& id) ; 
    132          static shared_ptr<CContext> create(const string& id = "") ; 
     132         static CContext* create(const string& id = "") ; 
    133133          
    134134      public : 
     
    145145         boost::shared_ptr<CCalendar>      calendar; 
    146146  
    147          std::vector<boost::shared_ptr<CFile> > enabledFiles; 
     147         std::vector<CFile*> enabledFiles; 
    148148         static shared_ptr<CContextGroup> root ; 
    149149 
  • XIOS/trunk/src/node/domain.cpp

    r346 r347  
    55#include "group_template_impl.hpp" 
    66 
    7 #include "tree_manager.hpp" 
    87#include "xmlioserver_spl.hpp" 
    98#include "event_client.hpp" 
     
    635634   { 
    636635      if (this->isChecked) return; 
    637       shared_ptr<CContext> context=CContext::getCurrent() ; 
     636      CContext* context=CContext::getCurrent() ; 
    638637 
    639638      this->checkGlobalDomain(); 
     
    696695    int jend_srv ; 
    697696     
    698     shared_ptr<CContext> context=CContext::getCurrent() ; 
     697    CContext* context=CContext::getCurrent() ; 
    699698    CContextClient* client=context->client ; 
    700699    int nbServer=client->serverSize ; 
     
    738737    jbegin_client=jbegin.getValue() ; jend_client=jend.getValue() ; nj_client=nj.getValue() ; 
    739738      
    740     shared_ptr<CContext> context = CContext::getCurrent() ; 
     739    CContext* context = CContext::getCurrent() ; 
    741740    CContextClient* client=context->client ; 
    742741    int nbServer=client->serverSize ; 
     
    847846  void CDomain::sendLonLat(void) 
    848847  { 
    849     shared_ptr<CContext> context = CContext::getCurrent() ; 
     848    CContext* context = CContext::getCurrent() ; 
    850849    CContextClient* client=context->client ; 
    851850    // send lon lat for each connected server 
  • XIOS/trunk/src/node/field.cpp

    r346 r347  
    3636   CField::~CField(void) 
    3737   { 
    38       this->grid.reset() ; 
    39       this->file.reset() ; 
     38//      this->grid.reset() ; 
     39//      this->file.reset() ; 
    4040      this->foperation.reset() ; 
    4141      this->data.reset() ; 
     
    9494  void CField::sendUpdateData(void) 
    9595  { 
    96     shared_ptr<CContext> context = CContext::getCurrent() ; 
     96    CContext* context = CContext::getCurrent() ; 
    9797    CContextClient* client=context->client ; 
    9898     
     
    150150    } 
    151151 
    152     shared_ptr<CContext> context = CContext::getCurrent() ; 
     152    CContext* context = CContext::getCurrent() ; 
    153153    const CDate & currDate = context->getCalendar()->getCurrentDate(); 
    154154    const CDate opeDate      = *last_operation_srv + freq_operation_srv; 
     
    192192   //---------------------------------------------------------------- 
    193193 
    194    void CField::setRelFile(const boost::shared_ptr<CFile> _file) 
     194   void CField::setRelFile(CFile* _file) 
    195195   {  
    196196      this->file = _file;  
     
    205205   //---------------------------------------------------------------- 
    206206 
    207    boost::shared_ptr<CGrid> CField::getRelGrid(void) const 
     207   CGrid* CField::getRelGrid(void) const 
    208208   {  
    209209      return (this->grid);  
     
    212212   //---------------------------------------------------------------- 
    213213 
    214    boost::shared_ptr<CFile> CField::getRelFile(void) const 
     214   CFile* CField::getRelFile(void) const 
    215215   {  
    216216      return (this->file); 
     
    234234   //---------------------------------------------------------------- 
    235235 
    236    boost::shared_ptr<CField> CField::getDirectFieldReference(void) const 
     236   CField* CField::getDirectFieldReference(void) const 
    237237   { 
    238238      if (this->field_ref.isEmpty()) 
     
    249249   //---------------------------------------------------------------- 
    250250 
    251    const boost::shared_ptr<CField> CField::getBaseFieldReference(void) const 
     251   CField* CField::getBaseFieldReference(void) const 
    252252   {  
    253253      return (baseRefObject);  
     
    256256   //---------------------------------------------------------------- 
    257257 
    258    const std::vector<boost::shared_ptr<CField> > & CField::getAllReference(void) const  
     258   const std::vector<CField*>& CField::getAllReference(void) const  
    259259   {  
    260260      return (refObject); 
     
    325325   { 
    326326      std::set<CField *> sset; 
    327       boost::shared_ptr<CField> refer_sptr; 
     327      CField* refer_sptr; 
    328328      CField * refer_ptr = this; 
    329329       
     
    333333      { 
    334334         refer_sptr = refer_ptr->getDirectFieldReference(); 
    335          refer_ptr  = refer_sptr.get(); 
     335         refer_ptr  = refer_sptr; 
    336336 
    337337         if(sset.end() != sset.find(refer_ptr)) 
     
    356356        
    357357      StdString id = this->getBaseFieldReference()->getId(); 
    358       boost::shared_ptr<CContext> context = CContext::getCurrent(); 
     358      CContext* context = CContext::getCurrent(); 
    359359 
    360360      if (operation.isEmpty() || freq_op.isEmpty() || this->file->output_freq.isEmpty()) 
     
    442442   void CField::solveGridReference(void) 
    443443   { 
    444       boost::shared_ptr<CDomain> domain; 
    445       boost::shared_ptr<CAxis> axis; 
     444      CDomain* domain; 
     445      CAxis* axis; 
    446446 
    447447      if (!domain_ref.isEmpty()) 
     
    486486            if (!axis_ref.isEmpty()) 
    487487            { 
    488                this->grid = CGrid::CreateGrid(domain, axis) ; 
     488               this->grid = CGrid::createGrid(domain, axis) ; 
    489489               this->grid_ref.setValue(this->grid->getId()); 
    490490            } 
    491491            else 
    492492            { 
    493                this->grid = CGrid::CreateGrid(domain) ; 
     493               this->grid = CGrid::createGrid(domain) ; 
    494494               this->grid_ref.setValue(this->grid->getId()); 
    495495            } 
     
    518518               << " invalid group name !"); 
    519519 
    520       boost::shared_ptr<CFieldGroup> group = CFieldGroup::get(gref); 
    521       boost::shared_ptr<CFieldGroup> owner = CFieldGroup::get(boost::polymorphic_downcast<CFieldGroup*>(this)); 
    522  
    523       std::vector<boost::shared_ptr<CField> > allChildren  = group->getAllChildren(); 
    524       std::vector<boost::shared_ptr<CField> >::iterator  
     520      CFieldGroup* group = CFieldGroup::get(gref); 
     521      CFieldGroup* owner = CFieldGroup::get(boost::polymorphic_downcast<CFieldGroup*>(this)); 
     522 
     523      std::vector<CField*> allChildren  = group->getAllChildren(); 
     524      std::vector<CField*>::iterator  
    525525         it = allChildren.begin(), end = allChildren.end(); 
    526526       
    527527      for (; it != end; it++) 
    528528      { 
    529          boost::shared_ptr<CField> child = *it; 
     529         CField* child = *it; 
    530530         if (child->hasId()) owner->createChild()->field_ref.setValue(child->getId()) ; 
    531531             
  • XIOS/trunk/src/node/field.hpp

    r345 r347  
    6161 
    6262         /// Accesseurs /// 
    63                boost::shared_ptr<CField> getDirectFieldReference(void) const; 
    64          const boost::shared_ptr<CField> getBaseFieldReference(void)   const; 
    65          const std::vector<boost::shared_ptr<CField> > & getAllReference(void) const; 
     63         CField* getDirectFieldReference(void) const; 
     64         CField* getBaseFieldReference(void)   const; 
     65         const std::vector<CField*> & getAllReference(void) const; 
    6666 
    67          boost::shared_ptr<CGrid> getRelGrid(void) const ; 
    68          boost::shared_ptr<CFile> getRelFile(void) const ; 
     67         CGrid* getRelGrid(void) const ; 
     68         CFile* getRelFile(void) const ; 
    6969 
    7070      public : 
     
    8585 
    8686         /// Mutateur /// 
    87          void setRelFile(const boost::shared_ptr<CFile> _file); 
     87         void setRelFile(CFile* _file); 
    8888         void incrementNStep(void); 
    8989         void resetNStep() ; 
     
    130130         /// Propriétés privées /// 
    131131          
    132          std::vector<boost::shared_ptr<CField> > refObject; 
    133          boost::shared_ptr<CField> baseRefObject; 
    134          boost::shared_ptr<CGrid>  grid ; 
    135          boost::shared_ptr<CFile>  file; 
     132         std::vector<CField*> refObject; 
     133         CField* baseRefObject; 
     134         CGrid*  grid ; 
     135         CFile*  file; 
    136136 
    137137         CDuration freq_operation, freq_write; 
  • XIOS/trunk/src/node/file.cpp

    r346 r347  
    4545   } 
    4646 
    47    boost::shared_ptr<CFieldGroup> CFile::getVirtualFieldGroup(void) const 
     47   CFieldGroup* CFile::getVirtualFieldGroup(void) const 
    4848   { 
    4949      return (this->vFieldGroup); 
    5050   } 
    5151 
    52    std::vector<boost::shared_ptr<CField> > CFile::getAllFields(void) const 
     52   std::vector<CField*> CFile::getAllFields(void) const 
    5353   { 
    5454      return (this->vFieldGroup->getAllChildren()); 
     
    5757   //---------------------------------------------------------------- 
    5858 
    59    std::vector<boost::shared_ptr<CField> > CFile::getEnabledFields 
    60       (int default_outputlevel, int default_level, bool default_enabled) 
     59   std::vector<CField*> CFile::getEnabledFields(int default_outputlevel,  
     60                                                int default_level, 
     61                                                bool default_enabled) 
    6162   { 
    6263      if (!this->enabledFields.empty()) 
     
    6566      const int _outputlevel = 
    6667         (!output_level.isEmpty()) ? output_level.getValue() : default_outputlevel; 
    67       std::vector<boost::shared_ptr<CField> >::iterator it; 
     68      std::vector<CField*>::iterator it; 
    6869      this->enabledFields = this->getAllFields(); 
    6970 
    70       std::vector<boost::shared_ptr<CField> > newEnabledFields; 
     71      std::vector<CField*> newEnabledFields; 
    7172       
    7273      for ( it = this->enabledFields.begin() ; it != this->enabledFields.end(); it++ ) 
     
    112113   //---------------------------------------------------------------- 
    113114 
    114    void CFile::setVirtualFieldGroup(boost::shared_ptr<CFieldGroup> newVFieldGroup) 
     115   void CFile::setVirtualFieldGroup(CFieldGroup* newVFieldGroup) 
    115116   {  
    116117      this->vFieldGroup = newVFieldGroup;  
     
    127128   bool CFile::isSyncTime(void) 
    128129   { 
    129      shared_ptr<CContext> context = CContext::getCurrent() ; 
     130     CContext* context = CContext::getCurrent() ; 
    130131     CDate& currentDate=context->calendar->getCurrentDate() ; 
    131132     if (! sync_freq.isEmpty()) 
     
    142143   void CFile::initFile(void) 
    143144   { 
    144       shared_ptr<CContext> context = CContext::getCurrent() ; 
     145      CContext* context = CContext::getCurrent() ; 
    145146      CDate& currentDate=context->calendar->getCurrentDate() ; 
    146147       
     
    163164   bool CFile::checkSync(void) 
    164165   { 
    165      shared_ptr<CContext> context = CContext::getCurrent() ; 
     166     CContext* context = CContext::getCurrent() ; 
    166167     CDate& currentDate=context->calendar->getCurrentDate() ; 
    167168     if (! sync_freq.isEmpty()) 
     
    180181    bool CFile::checkSplit(void) 
    181182    { 
    182       shared_ptr<CContext> context = CContext::getCurrent() ; 
     183      CContext* context = CContext::getCurrent() ; 
    183184      CDate& currentDate=context->calendar->getCurrentDate() ; 
    184185      if (! split_freq.isEmpty()) 
     
    188189          *lastSplit=currentDate-outputFreq ; 
    189190         
    190           std::vector<boost::shared_ptr<CField> >::iterator it, end = this->enabledFields.end(); 
     191          std::vector<CField*>::iterator it, end = this->enabledFields.end(); 
    191192          for (it = this->enabledFields.begin() ;it != end; it++)  (*it)->resetNStep() ; 
    192193          createHeader() ; 
     
    199200   void CFile::createHeader(void) 
    200201   { 
    201       shared_ptr<CContext> context = CContext::getCurrent() ; 
     202      CContext* context = CContext::getCurrent() ; 
    202203      CDate& currentDate=context->calendar->getCurrentDate() ; 
    203204       
    204       std::vector<boost::shared_ptr<CField> >::iterator it, end = this->enabledFields.end(); 
     205      std::vector<CField*>::iterator it, end = this->enabledFields.end(); 
    205206 
    206207      AllDomainEmpty=true ; 
     
    208209      for (it = this->enabledFields.begin() ;it != end; it++) 
    209210      { 
    210          boost::shared_ptr<CField> field = *it; 
     211         CField* field = *it; 
    211212         AllDomainEmpty&=field->grid->domain->isEmpty() ; 
    212          setDomain.insert(field->grid->domain.get()) ; 
     213         setDomain.insert(field->grid->domain) ; 
    213214      } 
    214215      nbDomain=setDomain.size() ; 
     
    260261         for (it = this->enabledFields.begin() ;it != end; it++) 
    261262         { 
    262             boost::shared_ptr<CField> field = *it; 
     263            CField* field = *it; 
    263264            this->data_out->writeFieldGrid(field); 
    264265         } 
     
    266267         for (it = this->enabledFields.begin() ;it != end; it++) 
    267268         { 
    268             boost::shared_ptr<CField> field = *it; 
     269            CField* field = *it; 
    269270            this->data_out->writeField(field); 
    270271         } 
     
    306307         oss << " id=\"" << this->getId() << "\" "; 
    307308      oss << SuperClassAttribute::toString() << ">" << std::endl; 
    308       if (this->getVirtualFieldGroup().get() != NULL) 
     309      if (this->getVirtualFieldGroup() != NULL) 
    309310         oss << *this->getVirtualFieldGroup() << std::endl; 
    310311      oss << "</" << CFile::GetName() << " >"; 
     
    325326   { 
    326327      // Résolution des héritages par référence de chacun des champs contenus dans le fichier. 
    327       std::vector<boost::shared_ptr<CField> > allF = this->getAllFields(); 
     328      std::vector<CField*> allF = this->getAllFields(); 
    328329      for (unsigned int i = 0; i < allF.size(); i++) 
    329330         allF[i]->solveRefInheritance(); 
     
    351352   { 
    352353      ENodeType genum = CFileGroup::GetType(); 
    353       bool hasVFG = (this->getVirtualFieldGroup().get() != NULL); 
     354      bool hasVFG = (this->getVirtualFieldGroup() != NULL); 
    354355      SuperClass::toBinary(os); 
    355356       
     
    381382   } 
    382383    
    383    shared_ptr<CField> CFile::addField(const string& id) 
     384   CField* CFile::addField(const string& id) 
    384385   { 
    385386     return vFieldGroup->createChild(id) ; 
    386387   } 
    387388 
    388    shared_ptr<CFieldGroup> CFile::addFieldGroup(const string& id) 
     389   CFieldGroup* CFile::addFieldGroup(const string& id) 
    389390   { 
    390391     return vFieldGroup->createChildGroup(id) ; 
     
    394395   void CFile::sendAddField(const string& id) 
    395396   { 
    396     shared_ptr<CContext> context=CContext::getCurrent() ; 
     397    CContext* context=CContext::getCurrent() ; 
    397398     
    398399    if (! context->hasServer ) 
     
    416417   void CFile::sendAddFieldGroup(const string& id) 
    417418   { 
    418     shared_ptr<CContext> context=CContext::getCurrent() ; 
     419    CContext* context=CContext::getCurrent() ; 
    419420    if (! context->hasServer ) 
    420421    { 
  • XIOS/trunk/src/node/file.hpp

    r345 r347  
    5353         /// Accesseurs /// 
    5454         boost::shared_ptr<CDataOutput> getDataOutput(void) const; 
    55          boost::shared_ptr<CFieldGroup> getVirtualFieldGroup(void) const; 
    56          std::vector<boost::shared_ptr<CField> > getAllFields(void) const; 
     55         CFieldGroup* getVirtualFieldGroup(void) const; 
     56         std::vector<CField*> getAllFields(void) const; 
    5757 
    58          std::vector<boost::shared_ptr<CField> > 
    59             getEnabledFields(int default_outputlevel = 5, 
    60                              int default_level = 1, 
    61                              bool default_enabled = true); 
     58         std::vector<CField* > getEnabledFields(int default_outputlevel = 5, 
     59                                                int default_level = 1, 
     60                                                bool default_enabled = true); 
    6261 
    6362      public : 
    6463 
    6564         /// Mutateurs /// 
    66          void setVirtualFieldGroup(boost::shared_ptr<CFieldGroup> newVFieldGroup); 
     65         void setVirtualFieldGroup(CFieldGroup* newVFieldGroup); 
    6766         void setVirtualFieldGroup(void); 
    6867 
     
    9392          
    9493         bool AllDomainEmpty ; 
    95          shared_ptr<CField> addField(const string& id="") ; 
    96          shared_ptr<CFieldGroup> addFieldGroup(const string& id="") ; 
     94         CField* addField(const string& id="") ; 
     95         CFieldGroup* addFieldGroup(const string& id="") ; 
    9796         void sendAddField(const string& id="") ; 
    9897         void sendAddFieldGroup(const string& id="") ; 
     
    117116 
    118117         /// Propriétés privées /// 
    119          boost::shared_ptr<CFieldGroup> vFieldGroup; 
     118         CFieldGroup* vFieldGroup; 
    120119         boost::shared_ptr<CDataOutput> data_out; 
    121          std::vector<boost::shared_ptr<CField> > enabledFields; 
     120         std::vector<CField*> enabledFields; 
    122121 
    123122   }; // class CFile 
  • XIOS/trunk/src/node/grid.cpp

    r346 r347  
    2525   CGrid::~CGrid(void) 
    2626   {  
    27       this->axis.reset() ; 
    28       this->domain.reset() ; 
     27 //     this->axis.reset() ; 
     28//      this->domain.reset() ; 
    2929       
    3030      for (StdSize i = 0; i < this->storeIndex.size(); i++) 
     
    7373   //--------------------------------------------------------------- 
    7474 
    75    const boost::shared_ptr<CAxis>   CGrid::getRelAxis  (void) const 
     75   const CAxis*   CGrid::getRelAxis  (void) const 
    7676   {  
    7777      return (this->axis );  
     
    8080   //--------------------------------------------------------------- 
    8181 
    82    const boost::shared_ptr<CDomain> CGrid::getRelDomain(void) const 
     82   const CDomain* CGrid::getRelDomain(void) const 
    8383   {  
    8484      return (this->domain );  
     
    158158   { 
    159159      if (this->isChecked) return; 
    160       shared_ptr<CContext> context = CContext::getCurrent() ; 
     160      CContext* context = CContext::getCurrent() ; 
    161161      CContextClient* client=context->client ; 
    162162       
     
    306306   //---------------------------------------------------------------- 
    307307 
    308    boost::shared_ptr<CGrid> 
    309       CGrid::CreateGrid(boost::shared_ptr<CDomain> domain) 
     308   CGrid* CGrid::createGrid(CDomain* domain) 
    310309   { 
    311310      StdString new_id = StdString("__") + domain->getId() + StdString("__") ; 
    312       boost::shared_ptr<CGrid> grid = CGridGroup::get("grid_definition")->createChild(new_id) ; 
     311      CGrid* grid = CGridGroup::get("grid_definition")->createChild(new_id) ; 
    313312      grid->domain_ref.setValue(domain->getId()); 
    314313      return (grid); 
    315314   } 
    316315 
    317    boost::shared_ptr<CGrid> 
    318       CGrid::CreateGrid(boost::shared_ptr<CDomain> domain, boost::shared_ptr<CAxis> axis) 
     316   CGrid* CGrid::createGrid(CDomain* domain, CAxis* axis) 
    319317   { 
    320318      StdString new_id = StdString("__") + domain->getId() + 
    321319                         StdString("_") + axis->getId() + StdString("__") ; 
    322       boost::shared_ptr<CGrid> grid = CGridGroup::get("grid_definition")->createChild(new_id) ; 
     320      CGrid* grid = CGridGroup::get("grid_definition")->createChild(new_id) ; 
    323321      grid->domain_ref.setValue(domain->getId()); 
    324322      grid->axis_ref.setValue(axis->getId()); 
     
    416414  void CGrid::sendIndex(void) 
    417415  { 
    418     shared_ptr<CContext> context = CContext::getCurrent() ; 
     416    CContext* context = CContext::getCurrent() ; 
    419417    CContextClient* client=context->client ; 
    420418     
  • XIOS/trunk/src/node/grid.hpp

    r345 r347  
    6868         const std::deque<ARRAY(int, 1)> & getOutLIndex(void)  const; 
    6969 
    70          const boost::shared_ptr<CAxis>   getRelAxis  (void) const; 
    71          const boost::shared_ptr<CDomain> getRelDomain(void) const; 
     70         const CAxis*   getRelAxis  (void) const; 
     71         const CDomain* getRelDomain(void) const; 
    7272 
    7373         StdSize getDimension(void) const; 
     
    105105 
    106106         /// Instanciateurs Statiques /// 
    107          static boost::shared_ptr<CGrid> 
    108             CreateGrid(boost::shared_ptr<CDomain> domain); 
    109          static boost::shared_ptr<CGrid> 
    110             CreateGrid(boost::shared_ptr<CDomain> domain, boost::shared_ptr<CAxis> axis); 
     107         static CGrid* createGrid(CDomain* domain); 
     108         static CGrid* createGrid(CDomain* domain, CAxis* axis); 
    111109 
    112110      public : 
     
    133131         bool isChecked; 
    134132 
    135          boost::shared_ptr<CAxis>   axis ; 
    136          boost::shared_ptr<CDomain> domain ; 
     133         CAxis*   axis ; 
     134         CDomain* domain ; 
    137135 
    138136         std::deque<ARRAY(int, 1)> storeIndex ; 
  • XIOS/trunk/src/node/variable.cpp

    r346 r347  
    8282   void CVariableGroup::parse(xml::CXMLNode & node, bool withAttr) 
    8383   { 
    84       boost::shared_ptr<CVariableGroup> group_ptr = (this->hasId()) 
     84      CVariableGroup* group_ptr = (this->hasId()) 
    8585         ? CVariableGroup::get(this->getId()) : CVariableGroup::get(this); 
    8686 
  • XIOS/trunk/src/object_template.hpp

    r346 r347  
    6868         static bool has(const string& id) ; 
    6969         static bool has(const string& contextId, const string& id) ; 
    70          static boost::shared_ptr<T> get(const string& id) ; 
    71          static boost::shared_ptr<T> get(const T* ptr) ; 
    72          static boost::shared_ptr<T> get(const string& contextId, const string& id) ; 
    73          boost::shared_ptr<T> get(void) ; 
    74          static boost::shared_ptr<T> create(const string& id=string("")) ; 
    75          static const vector< boost::shared_ptr<T> >& getAll() ; 
    76          static const vector< boost::shared_ptr<T> >& getAll(const string& contextId) ; 
     70         static T* get(const string& id) ; 
     71         static T* get(const T* ptr) ; 
     72         static T* get(const string& contextId, const string& id) ; 
     73         T* get(void) ; 
     74         shared_ptr<T> getShared(void) ; 
     75         static shared_ptr<T> getShared(const T* ptr) ; 
     76          
     77         static T* create(const string& id=string("")) ; 
     78         static const vector<T*> getAll() ; 
     79         static const vector<T*> getAll(const string& contextId) ; 
    7780         
    7881         void generateCInterface(ostream& oss) ; 
  • XIOS/trunk/src/object_template_impl.hpp

    r346 r347  
    145145      void CObjectTemplate<T>::ClearAllAttributes(void) 
    146146   { 
    147       std::vector<boost::shared_ptr<T> > & avect = 
    148          CObjectTemplate<T>::GetAllVectobject(CContext::getCurrent()->getId()); 
    149       typename std::vector<boost::shared_ptr<T> >::iterator 
     147      vector<T*> avect = CObjectTemplate<T>::getAll() ; 
     148      typename vector<T*>::iterator 
    150149            it = avect.begin(), end = avect.end(); 
    151150 
     
    165164   } 
    166165 
    167    template <class T> 
    168    void CObjectTemplate<T>::sendAttributToServer(CAttribute& attr) 
    169    { 
    170      shared_ptr<CContext> context=CContext::getCurrent() ; 
    171       
     166  template <class T> 
     167  void CObjectTemplate<T>::sendAttributToServer(CAttribute& attr) 
     168  { 
     169    CContext* context=CContext::getCurrent() ; 
     170     
    172171    if (!context->hasServer) 
    173172    { 
     
    187186    } 
    188187       
    189    } 
    190     
    191    template <class T> 
    192    void CObjectTemplate<T>::recvAttributFromClient(CEventServer& event) 
    193    { 
     188  } 
     189    
     190  template <class T> 
     191  void CObjectTemplate<T>::recvAttributFromClient(CEventServer& event) 
     192  { 
    194193       
    195       CBufferIn* buffer=event.subEvents.begin()->buffer; 
    196       string id,attrId; 
    197       *buffer>>id ; 
    198       CAttributeMap & attrMap = *get(id); 
    199       *buffer>>attrId ; 
    200       CAttribute* attr=attrMap[attrId] ; 
    201       info(50)<<"attribut recu "<<attrId<<"  " ; 
    202       if (attr->isEmpty()) info(50)<<"--> empty"<<endl ; 
    203       else info(50) /*<attr->getValue()*/<<endl ; 
    204       *buffer>>*attr ; 
    205        info(50)<<"attribut recu "<<attrId<<"  " ; 
    206       if (attr->isEmpty()) info(50)<<"--> empty"<<endl ; 
    207       else info(50) /*attr->getValue()*/<<endl ; 
     194    CBufferIn* buffer=event.subEvents.begin()->buffer; 
     195    string id,attrId; 
     196    *buffer>>id ; 
     197    CAttributeMap & attrMap = *get(id); 
     198    *buffer>>attrId ; 
     199    CAttribute* attr=attrMap[attrId] ; 
     200    info(50)<<"attribut recu "<<attrId<<"  " ; 
     201    if (attr->isEmpty()) info(50)<<"--> empty"<<endl ; 
     202    else info(50) /*<attr->getValue()*/<<endl ; 
     203    *buffer>>*attr ; 
     204     info(50)<<"attribut recu "<<attrId<<"  " ; 
     205    if (attr->isEmpty()) info(50)<<"--> empty"<<endl ; 
     206    else info(50) /*attr->getValue()*/<<endl ; 
    208207  } 
    209208 
     
    238237 
    239238   template <typename T> 
    240    boost::shared_ptr<T> CObjectTemplate<T>::get(const string & id) 
    241    { 
    242      return CObjectFactory::GetObject<T>(id) ; 
    243    } 
    244  
    245    template <typename T> 
    246    boost::shared_ptr<T> CObjectTemplate<T>::get(const T* ptr) 
     239   T* CObjectTemplate<T>::get(const string & id) 
     240   { 
     241     return CObjectFactory::GetObject<T>(id).get() ; 
     242   } 
     243 
     244   template <typename T> 
     245   T* CObjectTemplate<T>::get(const T* ptr) 
     246   { 
     247     return CObjectFactory::GetObject<T>(ptr).get() ; 
     248   } 
     249    
     250   template <typename T> 
     251   shared_ptr<T> CObjectTemplate<T>::getShared(const T* ptr) 
    247252   { 
    248253     return CObjectFactory::GetObject<T>(ptr) ; 
    249254   } 
    250     
    251     
    252    template <typename T> 
    253    const vector<boost::shared_ptr<T> >& CObjectTemplate<T>::getAll() 
    254    { 
    255      return CObjectFactory::GetObjectVector<T>() ; 
    256    } 
    257  
    258    template <typename T> 
    259    const vector<boost::shared_ptr<T> >& CObjectTemplate<T>::getAll(const string & id) 
    260    { 
    261      return CObjectFactory::GetObjectVector<T>(id) ; 
    262    } 
    263  
    264    template <typename T> 
    265    boost::shared_ptr<T> CObjectTemplate<T>::get(const string& contextId, const string & id) 
    266    { 
    267      return CObjectFactory::GetObject<T>(contextId,id) ; 
    268    } 
    269  
    270    template <typename T> 
    271    boost::shared_ptr<T> CObjectTemplate<T>::create(const string & id) 
    272    { 
    273      return CObjectFactory::CreateObject<T>(id) ; 
     255 
     256   template <typename T> 
     257   shared_ptr<T> CObjectTemplate<T>::getShared(void) 
     258   { 
     259     return CObjectFactory::GetObject<T>((T*)this) ; 
     260   } 
     261    
     262   template <typename T> 
     263   const vector<T*> CObjectTemplate<T>::getAll() 
     264   { 
     265     const vector< shared_ptr<T> >& shared_vect= CObjectFactory::GetObjectVector<T>(); 
     266     vector<T*> vect ; 
     267     
     268     typename vector<shared_ptr<T> >::const_iterator it; 
     269     for(it=shared_vect.begin();it!=shared_vect.end();++it) vect.push_back(it->get()) ; 
     270     return vect ; 
     271   } 
     272 
     273   template <typename T> 
     274   const vector<T*> CObjectTemplate<T>::getAll(const string & id) 
     275   { 
     276     const vector< shared_ptr<T> >& shared_vect= CObjectFactory::GetObjectVector<T>(id); 
     277     vector<T*> vect ; 
     278     
     279     typename vector<shared_ptr<T> >::const_iterator it; 
     280     for(it=shared_vect.begin();it!=shared_vect.end();++it) vect.push_back(it->get()) ; 
     281     return vect ; 
     282   } 
     283 
     284   template <typename T> 
     285   T* CObjectTemplate<T>::get(const string& contextId, const string & id) 
     286   { 
     287     return CObjectFactory::GetObject<T>(contextId,id).get() ; 
     288   } 
     289 
     290   template <typename T> 
     291   T* CObjectTemplate<T>::create(const string & id) 
     292   { 
     293     return CObjectFactory::CreateObject<T>(id).get() ; 
    274294   }   ///-------------------------------------------------------------- 
    275295 
    276296  template <typename T> 
    277   boost::shared_ptr<T> CObjectTemplate<T>::get(void) 
     297  T* CObjectTemplate<T>::get(void) 
    278298  { 
    279     return CObjectFactory::GetObject<T>((T*)this) ; 
    280 //      return shared_ptr<T>((T*)this) ; 
     299    return CObjectFactory::GetObject<T>((T*)this).get() ; 
    281300  } 
    282301   
     
    299318     oss<<"#include \"group_template_impl.hpp\""<<iendl ; 
    300319     oss<<"#include \"icutil.hpp\""<<iendl ; 
     320     oss<<"#include \"timer.hpp\""<<iendl ; 
    301321     oss<<iendl ; 
    302322     oss<<"extern \"C\""<<iendl ; 
  • XIOS/trunk/src/output/nc4_data_output.cpp

    r346 r347  
    5555      //--------------------------------------------------------------- 
    5656 
    57       void CNc4DataOutput::writeDomain_(const boost::shared_ptr<CDomain> domain) 
    58       { 
    59          shared_ptr<CContext> context = CContext::getCurrent() ; 
     57      void CNc4DataOutput::writeDomain_(CDomain* domain) 
     58      { 
     59         CContext* context = CContext::getCurrent() ; 
    6060         CContextServer* server=context->server ; 
    6161          
     
    221221      //-------------------------------------------------------------- 
    222222 
    223       void CNc4DataOutput::writeAxis_(const boost::shared_ptr<CAxis> axis) 
     223      void CNc4DataOutput::writeAxis_(CAxis* axis) 
    224224      { 
    225225         if (axis->IsWritten(this->filename)) return; 
     
    269269      //-------------------------------------------------------------- 
    270270 
    271       void CNc4DataOutput::writeField_(const boost::shared_ptr<CField> field) 
    272       { 
    273          shared_ptr<CContext> context = CContext::getCurrent() ; 
     271      void CNc4DataOutput::writeField_(CField* field) 
     272      { 
     273         CContext* context = CContext::getCurrent() ; 
    274274         CContextServer* server=context->server ; 
    275275 
    276276         std::vector<StdString> dims, coodinates; 
    277          boost::shared_ptr<CGrid> grid = field->grid; 
    278          boost::shared_ptr<CDomain> domain = grid->domain; 
     277         CGrid* grid = field->grid; 
     278         CDomain* domain = grid->domain; 
    279279            
    280280         if (domain->isEmpty())  
     
    319319         if (!grid->axis_ref.isEmpty()) 
    320320         { 
    321             boost::shared_ptr<CAxis> axis = grid->axis ; 
     321            CAxis* axis = grid->axis ; 
    322322            StdString axisid = (!axis->name.isEmpty()) ? axis->name.getValue() : axis->getId(); 
    323323            dims.push_back(axisid); 
     
    418418      //-------------------------------------------------------------- 
    419419 
    420       void CNc4DataOutput::writeFile_ (const boost::shared_ptr<CFile> file) 
     420      void CNc4DataOutput::writeFile_ (CFile* file) 
    421421      { 
    422422         StdString filename = (!file->name.isEmpty()) 
     
    461461      //--------------------------------------------------------------- 
    462462       
    463       void CNc4DataOutput::writeFieldData_ (const boost::shared_ptr<CField>  field) 
    464       { 
    465          shared_ptr<CContext> context = CContext::getCurrent() ; 
     463      void CNc4DataOutput::writeFieldData_ (CField*  field) 
     464      { 
     465         CContext* context = CContext::getCurrent() ; 
    466466//          if (field->getRelFile()->isSyncTime()) SuperClassWriter::sync() ; 
    467467 
    468          boost::shared_ptr<CGrid> grid = field->grid ; 
    469          boost::shared_ptr<CDomain> domain = grid->domain ; 
     468         CGrid* grid = field->grid ; 
     469         CDomain* domain = grid->domain ; 
    470470          
    471471         if(SuperClass::type==MULTI_FILE || !isCollective) if (domain->isEmpty()) return; 
     
    489489         if (grid->hasAxis()) // 3D 
    490490         { 
    491             boost::shared_ptr<CAxis> axis = grid->axis ; 
     491            CAxis* axis = grid->axis ; 
    492492            ARRAY_CREATE(field_data3D,double,3,[domain->zoom_ni_srv][domain->zoom_nj_srv][axis->size.getValue()]) ; 
    493493            field->outputField(field_data3D); 
     
    561561 
    562562      void CNc4DataOutput::writeTimeAxis_ 
    563                   (const boost::shared_ptr<CField>    field, 
     563                  (CField*    field, 
    564564                   const boost::shared_ptr<CCalendar> cal) 
    565565      { 
  • XIOS/trunk/src/output/nc4_data_output.hpp

    r345 r347  
    4040 
    4141            /// Ecriture /// 
    42             virtual void writeDomain_    (const boost::shared_ptr<CDomain>  domain); 
    43             virtual void writeAxis_      (const boost::shared_ptr<CAxis>    axis); 
    44             virtual void writeField_     (const boost::shared_ptr<CField>    field); 
    45             virtual void writeFieldData_ (const boost::shared_ptr<CField>    field); 
    46             virtual void writeFile_      (const boost::shared_ptr<CFile>    file); 
     42            virtual void writeDomain_    (CDomain* domain); 
     43            virtual void writeAxis_      (CAxis* axis); 
     44            virtual void writeField_     (CField* field); 
     45            virtual void writeFieldData_ (CField* field); 
     46            virtual void writeFile_      (CFile* file); 
    4747            virtual void closeFile_      (void); 
    4848            virtual void syncFile_      (void); 
    49             virtual void writeTimeAxis_  (const boost::shared_ptr<CField>    field, 
     49            virtual void writeTimeAxis_  (CField* field, 
    5050                                          const boost::shared_ptr<CCalendar> cal); 
    5151 
  • XIOS/trunk/src/output/onetcdf4.hpp

    r345 r347  
    8383 
    8484            /// Ecriture /// 
    85             virtual void writeField_ (const boost::shared_ptr<CField>  field)  = 0; 
    86             virtual void writeDomain_(const boost::shared_ptr<CDomain> domain) = 0; 
    87             virtual void writeAxis_  (const boost::shared_ptr<CAxis>   axis)   = 0; 
     85            virtual void writeField_ (CField*  field)  = 0; 
     86            virtual void writeDomain_(CDomain* domain) = 0; 
     87            virtual void writeAxis_  (CAxis*   axis)   = 0; 
    8888 
    8989            /// Accesseurs /// 
  • XIOS/trunk/src/server.cpp

    r346 r347  
    55#include "context.hpp" 
    66#include "object_template_impl.hpp" 
    7 #include "tree_manager.hpp" 
    87#include "oasis_cinterface.hpp" 
    98#include <boost/functional/hash.hpp> 
    109#include <boost/algorithm/string.hpp> 
    1110#include <mpi.h> 
     11#include "tracer.hpp" 
     12#include "timer.hpp" 
    1213 
    1314namespace xios 
     
    132133        else MPI_Finalize() ; 
    133134      } 
     135      report(0)<<"Performance report : Time spent for XIOS : "<<CTimer::get("XIOS server").getCumulatedTime()<<endl  ; 
     136      report(0)<<"Performance report : Time spent in processing events : "<<CTimer::get("Process events").getCumulatedTime()<<endl  ; 
     137      report(0)<<"Performance report : Ratio : "<<CTimer::get("Process events").getCumulatedTime()/CTimer::get("XIOS server").getCumulatedTime()*100.<<"%"<<endl  ; 
    134138    } 
    135139     
     
    138142       bool stop=false ; 
    139143        
     144       CTimer::get("XIOS server").resume() ; 
    140145       while(!stop) 
    141146       { 
     
    154159         if (finished && contextList.empty()) stop=true ; 
    155160       } 
    156       
     161       CTimer::get("XIOS server").suspend() ; 
    157162     } 
    158163      
     
    166171        { 
    167172           MPI_Status status ; 
     173           traceOff() ; 
    168174           MPI_Iprobe(0,0,*it,&flag,&status) ; 
     175           traceOn() ; 
    169176           if (flag==true) 
    170177           { 
     
    199206        int msg ; 
    200207         
     208        traceOff() ; 
    201209        MPI_Iprobe(0,4,intraComm, &flag, &status) ; 
     210        traceOn() ; 
    202211        if (flag==true) 
    203212        { 
     
    220229       if (recept==false) 
    221230       { 
     231         traceOff() ; 
    222232         MPI_Iprobe(MPI_ANY_SOURCE,1,CXios::globalComm, &flag, &status) ; 
     233         traceOn() ; 
    223234         if (flag==true)  
    224235         { 
     
    232243       else 
    233244       { 
     245         traceOff() ; 
    234246         MPI_Test(&request,&flag,&status) ; 
     247         traceOn() ; 
    235248         if (flag==true) 
    236249         { 
     
    304317       if (recept==false) 
    305318       { 
     319         traceOff() ; 
    306320         MPI_Iprobe(root,2,intraComm, &flag, &status) ; 
     321         traceOn() ; 
    307322         if (flag==true)  
    308323         { 
     
    346361              <<"Context has already been registred") ; 
    347362       
    348       shared_ptr<CContext> context=CContext::create(contextId) ; 
    349       contextList[contextId]=context.get() ; 
     363      CContext* context=CContext::create(contextId) ; 
     364      contextList[contextId]=context ; 
    350365      context->initServer(intraComm,contextIntercomm) ; 
    351366              
  • XIOS/trunk/src/test/test_cs.f90

    r327 r347  
    3131  TYPE(xios_time)      :: dtime 
    3232  TYPE(xios_context) :: ctx_hdl 
    33   INTEGER,PARAMETER :: ni_glo=10  
    34   INTEGER,PARAMETER :: nj_glo=10  
     33  INTEGER,PARAMETER :: ni_glo=100  
     34  INTEGER,PARAMETER :: nj_glo=100  
    3535  TYPE(xios_field) :: field_hdl 
    3636  TYPE(xios_fieldgroup) :: fieldgroup_hdl 
     
    8080  CALL xios_set_context_attr("test",calendar_type="Gregorian")  
    8181  CALL xios_set_domain_attr("domain_A",ni_glo=ni_glo, nj_glo=nj_glo, ibegin=ibegin, ni=ni,jbegin=jbegin,nj=nj) 
    82   CALL xios_set_domain_attr("domain_A",zoom_ni=3,zoom_ibegin=3,zoom_nj=3,zoom_jbegin=6) 
     82  !CALL xios_set_domain_attr("domain_A",zoom_ni=3,zoom_ibegin=3,zoom_nj=3,zoom_jbegin=6) 
    8383  CALL xios_set_domain_attr("domain_A",data_dim=2, data_ibegin=-1, data_ni=ni+2, data_jbegin=-2, data_nj=nj+4) 
    8484  CALL xios_set_domain_attr("domain_A",lonvalue=RESHAPE(lon,(/ni*nj/)),latvalue=RESHAPE(lat,(/ni*nj/))) 
     
    106106     
    107107    PRINT*,"field field_A is active ? ",xios_field_is_active("field_A") 
    108     DO ts=1,96 
     108    DO ts=1,96*200 
    109109      CALL xios_update_calendar(ts) 
    110110      CALL xios_send_field("field_A",field_A) 
  • XIOS/trunk/src/xml_parser.cpp

    r346 r347  
    5252               do 
    5353               { 
    54                   boost::shared_ptr<CContextGroup> group_context = CContext::getRoot() ; 
     54                  CContextGroup* group_context = CContext::getRoot() ; 
    5555  
    5656                  attributes = node.getAttributes(); 
     
    7373                  } 
    7474 
    75                   boost::shared_ptr<CContext> context = CContext::create(attributes["id"]); 
     75                  CContext* context = CContext::create(attributes["id"]); 
    7676//                  if (!hasctxt)  group_context->addChild(context); 
    7777      &n