Changeset 2628

Timestamp:

04/03/24 10:33:55 (4 weeks ago)

Author:

jderouillat

Message:

New timers integration/reporting

Location:

XIOS3/trunk/src

Files:

• client.cpp (modified) (3 diffs)
• client.hpp (modified) (1 diff)
• distribution/grid_scatterer_connector.hpp (modified) (2 diffs)
• distribution/grid_transform_connector.hpp (modified) (3 diffs)
• filter/client_to_server_store_filter.cpp (modified) (2 diffs)
• filter/file_reader_source_filter.cpp (modified) (3 diffs)
• filter/filter.cpp (modified) (2 diffs)
• filter/model_to_client_source_filter.cpp (modified) (3 diffs)
• filter/server_from_client_source_filter.cpp (modified) (3 diffs)
• filter/server_to_client_store_filter.cpp (modified) (2 diffs)
• filter/temporal_filter.cpp (modified) (3 diffs)
• interface/c/icdata.cpp (modified) (1 diff)
• io/nc4_data_input.cpp (modified) (3 diffs)
• io/nc4_data_output.cpp (modified) (5 diffs)
• io/onetcdf4.cpp (modified) (4 diffs)
• log_type.cpp (modified) (1 diff)
• manager/contexts_manager.cpp (modified) (3 diffs)
• manager/pool_ressource.cpp (modified) (6 diffs)
• manager/ressources_manager.cpp (modified) (4 diffs)
• manager/server_context.cpp (modified) (6 diffs)
• manager/servers_ressource.cpp (modified) (6 diffs)
• manager/services.cpp (modified) (7 diffs)
• manager/services_manager.cpp (modified) (3 diffs)
• node/context.cpp (modified) (5 diffs)
• node/field.cpp (modified) (3 diffs)
• node/file.cpp (modified) (3 diffs)
• server.cpp (modified) (3 diffs)
• server.hpp (modified) (1 diff)
• transformation/grid_algorithm_generic.cpp (modified) (2 diffs)
• transport/legacy_context_client.cpp (modified) (3 diffs)
• transport/legacy_context_server.cpp (modified) (9 diffs)
• transport/one_sided_client_buffer.cpp (modified) (3 diffs)
• transport/one_sided_context_server.cpp (modified) (4 diffs)
• transport/one_sided_server_buffer.cpp (modified) (3 diffs)
• transport/p2p_client_buffer.cpp (modified) (3 diffs)
• transport/p2p_context_server.cpp (modified) (4 diffs)
• transport/p2p_server_buffer.cpp (modified) (3 diffs)

XIOS3/trunk/src/client.cpp

@@ -36 +36 @@
     StdOFStream CClient::m_errorStream;
     CPoolRessource* CClient::poolRessource_=nullptr ;
+    extern CLogType logTimers ;
 
     MPI_Comm& CClient::getInterComm(void)   { return (interComm_); }
@@ -543 +544 @@
       report(0)<< " Memory report : Minimum buffer size required : " << CClientBuffer::maxRequestSize << " bytes" << endl ;
       report(0)<< " Memory report : increasing it by a factor will increase performance, depending of the volume of data wrote in file at each time step of the file"<<endl ;
-      report(100)<<CTimer::getAllCumulatedTime()<<endl ;
+
+      if (info.isActive(logProfile))
+      {
+        printProfile();
+      }
+        
+      if (info.isActive(logTimers)) report(0)<<"\n"<<CTimer::getAllCumulatedTime()<<endl ;
       if (CXios::reportMemory)
       {
@@ -552 +559 @@
       xios::releaseStaticAllocation() ;
 
+    }
+
+    void CClient::printProfile()
+    {
+      list< pair<string,int> > timer_name;
+      timer_name.push_back({"XIOS init",0});
+      timer_name.push_back({"XIOS init context",0});
+      timer_name.push_back({"XIOS close definition",0});
+      timer_name.push_back({"XIOS solve inheritance",0});
+      timer_name.push_back({"XIOS update calendar",0});
+      timer_name.push_back({"Check late data (read)",1});
+      timer_name.push_back({"XIOS recv field",0});
+      timer_name.push_back({"XIOS send field",0});
+      timer_name.push_back({"Context event loop",1});
+      timer_name.push_back({"Model to client",1});
+      timer_name.push_back({"Client workflow",1});
+      timer_name.push_back({"Applying filters",2});
+      timer_name.push_back({"Transformation transfers",3});
+      timer_name.push_back({"Transformation MPI",4});
+      timer_name.push_back({"Temporal filters",3});
+      timer_name.push_back({"Scatter event",3});
+      timer_name.push_back({"Field : send data",4});
+      timer_name.push_back({"Blocking time",0});
+      timer_name.push_back({"XIOS context finalize",0});
+      timer_name.push_back({"XIOS finalize",0});
+      
+      report(0)<< endl;
+      double total_time = CTimer::get("XIOS").getCumulatedTime();
+      for(auto it_timer_name = timer_name.begin(); it_timer_name != timer_name.end(); it_timer_name++)
+      {
+        double timer_time = CTimer::get(it_timer_name->first).getCumulatedTime();
+        if ( timer_time / total_time > 0.001 )
+        {
+          ostringstream printed_line;
+          printed_line << setprecision(3) << std::fixed;
+          for(int itab=0;itab<it_timer_name->second;itab++)
+              printed_line << "  ";
+          printed_line << it_timer_name->first << " : " << timer_time <<endl;
+          string string_line = printed_line.str();
+          report(0)<< string_line;
+        }
+      }
     }
     

XIOS3/trunk/src/client.hpp

@@ -15 +15 @@
         static void xiosGlobalCommByPublishing(MPI_Comm clientComm, const string& codeId) ;
         static void finalize(void);
+        static void printProfile(void);
         static void registerContext(const string& id, MPI_Comm contextComm);
         static void registerContext_old(const string& id, MPI_Comm contextComm);

XIOS3/trunk/src/distribution/grid_scatterer_connector.hpp

@@ -10 +10 @@
 #include "context_client.hpp"
 #include "scatterer_connector.hpp"
-
+#include "timer.hpp"
 
 namespace xios
 {
+  extern CLogType logProfile ;
  
   class CGridScattererConnector
@@ -78 +79 @@
           event.push(rank, nbSenders_[rank], messages.back());
         }
+        if (info.isActive(logProfile)) CTimer::get("Scatter event").resume();
         client->sendEvent(event) ;
+        if (info.isActive(logProfile)) CTimer::get("Scatter event").suspend();
       } 
       

XIOS3/trunk/src/distribution/grid_transform_connector.hpp

@@ -10 +10 @@
 #include "reduction_types.hpp"
 #include "mpi.hpp"
+#include "timer.hpp"
 
 namespace xios
 {
  
-  
+  extern CLogType logProfile ;
+
   class CGridTransformConnector
   {
@@ -41 +43 @@
         map<int,CArray<T,1>> tmpArrayIn ;
         gridScattererConnector_->transfer(dataIn, tmpArrayIn) ;
+        if (info.isActive(logProfile)) CTimer::get("Transformation MPI").resume();
         vector<MPI_Request> requests ;
         MPI_Request request ;
@@ -61 +64 @@
         vector<MPI_Status> status(requests.size()) ;
         MPI_Waitall(requests.size(), requests.data(),status.data()) ;
+        if (info.isActive(logProfile)) CTimer::get("Transformation MPI").suspend();
         
         const double nanValue = std::numeric_limits<double>::quiet_NaN();

XIOS3/trunk/src/filter/client_to_server_store_filter.cpp

@@ -11 +11 @@
 namespace xios
 {
+  extern CLogType logProfile ;
   CClientToServerStoreFilter::CClientToServerStoreFilter(CGarbageCollector& gc, CField* field, CContextClient* client)
     : CInputPin(gc, 1)
@@ -24 +25 @@
     buildWorkflowGraph(data);
 
-    CTimer::get("Field : send data").resume();
+    if (info.isActive(logProfile)) CTimer::get("Field : send data").resume();
     CEventClient event(field_->getType(), CField::EVENT_ID_UPDATE_DATA);
     CMessage message ;
     message<<field_->getId() << data[0]->timestamp ;
     field_->getSentGrid()->getClientToServerConnector(client_)->transfer(data[0]->data, client_, event, message) ;
-    CTimer::get("Field : send data").suspend();
+    if (info.isActive(logProfile)) CTimer::get("Field : send data").suspend();
   }
 

XIOS3/trunk/src/filter/file_reader_source_filter.cpp

@@ -11 +11 @@
 namespace xios
 {
+  extern CLogType logProfile ;
   CFileReaderSourceFilter::CFileReaderSourceFilter(CGarbageCollector& gc, CField* field)
     : COutputPin(gc)
@@ -24 +25 @@
   void CFileReaderSourceFilter::streamData()
   {
+    if (info.isActive(logProfile)) CTimer::get("Reader workflow data entry").resume();
     Time timeStamp ;
     CDataPacketPtr packet(new CDataPacket);
@@ -51 +53 @@
       CWorkflowGraph::addNode("File Reader Source filter", 1, false, 0, packet);
     }
+    if (info.isActive(logProfile)) CTimer::get("Reader workflow data entry").suspend();
            
     onOutputReady(packet);

XIOS3/trunk/src/filter/filter.cpp

@@ -1 +1 @@
 #include "filter.hpp"
+#include "timer.hpp"
 
 namespace xios
 {
+  extern CLogType logProfile ;
   CFilter::CFilter(CGarbageCollector& gc, size_t inputSlotsCount, IFilterEngine* engine)
     : CInputPin(gc, inputSlotsCount)
@@ -12 +14 @@
   void CFilter::onInputReady(std::vector<CDataPacketPtr> data)
   {
+    if (info.isActive(logProfile)) CTimer::get("Applying filters").resume() ;
     CDataPacketPtr outputPacket = engine->apply(data);
+    if (info.isActive(logProfile)) CTimer::get("Applying filters").suspend() ;
     if (outputPacket)
       onOutputReady(outputPacket);

XIOS3/trunk/src/filter/model_to_client_source_filter.cpp

@@ -6 +6 @@
 #include "workflow_graph.hpp"
 #include "mem_checker.hpp"
+#include "timer.hpp"
 
 namespace xios
 {
+  extern CLogType logProfile ;
   CModelToClientSourceFilter::CModelToClientSourceFilter(CGarbageCollector& gc, CGrid* grid, bool hasMissingValue, double defaultValue)
     : COutputPin(gc)
@@ -37 +39 @@
     const double nanValue = std::numeric_limits<double>::quiet_NaN();
     packet->data.resize(connector->getDstSize()) ;
+    if (info.isActive(logProfile)) CTimer::get("Model to client").resume();
     connector->transfer(data, packet->data, nanValue) ;
+    if (info.isActive(logProfile)) CTimer::get("Model to client").suspend();
 
     CMemChecker::logMem( "CModelToClientSourceFilter::streamData" );
@@ -50 +54 @@
     
     buildWorkflowGraph(packet);
+    if (info.isActive(logProfile)) CTimer::get("Client workflow").resume();
     onOutputReady(packet);
+    if (info.isActive(logProfile)) CTimer::get("Client workflow").suspend();
   }
   

XIOS3/trunk/src/filter/server_from_client_source_filter.cpp

@@ -8 +8 @@
 namespace xios
 {
+  extern CLogType logProfile ;
   CServerFromClientSourceFilter::CServerFromClientSourceFilter(CGarbageCollector& gc, CGrid* grid)
     : COutputPin(gc)
@@ -25 +26 @@
     packet->timestamp = timeStamp;
     packet->status = CDataPacket::NO_ERROR;
+    if (info.isActive(logProfile)) CTimer::get("Server workflow data entry").resume();
     grid_->getServerFromClientConnector()->transfer(event,packet->data) ;
+    if (info.isActive(logProfile)) CTimer::get("Server workflow data entry").suspend();
 
     if(this->graphEnabled)
@@ -35 +38 @@
       CWorkflowGraph::addNode("Server from Client Source filter", 1, false, 0, packet);
     }
+    if (info.isActive(logProfile)) CTimer::get("Server workflow").resume();
     onOutputReady(packet);
+    if (info.isActive(logProfile)) CTimer::get("Server workflow").suspend();
   }
 

XIOS3/trunk/src/filter/server_to_client_store_filter.cpp

@@ -34 +34 @@
     }
 
+    //if (info.isActive(logProfile)) CTimer::get("Field : send data (read)").resume();
     if (isEOF) 
     {
@@ -46 +47 @@
       info(20)<<"Send Data from server to client: FieldId : "<<field_->getId()<<"  step : "<<nStep_<<endl; 
     }
+    //if (info.isActive(logProfile)) CTimer::get("Field : send data (read)").suspend();
 
     nStep_++ ;

XIOS3/trunk/src/filter/temporal_filter.cpp

@@ -4 +4 @@
 #include "workflow_graph.hpp"
 #include "mem_checker.hpp"
+#include "timer.hpp"
 
 namespace xios
 {
+  extern CLogType logProfile ;
   static func::CFunctor* createFunctor(const std::string& opId, bool ignoreMissingValue, CArray<double, 1>& tmpData);
 
@@ -76 +78 @@
     if (data[0]->status != CDataPacket::END_OF_STREAM)
     {
+      if (info.isActive(logProfile)) CTimer::get("Temporal filters").resume() ;
       bool usePacket, outputResult, copyLess;
       if (isOnceOperation)
@@ -123 +126 @@
         graphCycleCompleted = true;
      }
+     if (info.isActive(logProfile)) CTimer::get("Temporal filters").suspend() ;
     }
 

XIOS3/trunk/src/interface/c/icdata.cpp

@@ -167 +167 @@
    {
      CTimer::get("XIOS").resume();
+     CTimer::get("XIOS solve inheritance").resume();
      CContext* context = CContext::getCurrent();
      context->solveAllInheritance(false);
+     CTimer::get("XIOS solve inheritance").suspend();
      CTimer::get("XIOS").suspend();
    }

XIOS3/trunk/src/io/nc4_data_input.cpp

@@ -10 +10 @@
 namespace xios
 {
+  extern CLogType logProfile ;
   CNc4DataInput::CNc4DataInput(const StdString& filename, MPI_Comm comm_file, bool multifile, bool isCollective /*= true*/,
                                bool readMetaDataPar /*= false*/, bool ugridConvention /*= false*/, const StdString& timeCounterName /*= "time_counter"*/)
@@ -57 +58 @@
     {
       case MULTI_FILE:
+        if (info.isActive(logProfile)) CTimer::get("Files : reading data").resume();
         SuperClassWriter::getData(dataOut, fieldId, isCollective, record );
+        if (info.isActive(logProfile)) CTimer::get("Files : reading data").suspend();
         break;
       case ONE_FILE:
@@ -106 +109 @@
         }
 
+        if (info.isActive(logProfile)) CTimer::get("Files : reading data").resume();
         SuperClassWriter::getData(dataOut, fieldId, isCollective, record, &start, &count);
+        if (info.isActive(logProfile)) CTimer::get("Files : reading data").suspend();
         break;
       }

XIOS3/trunk/src/io/nc4_data_output.cpp

@@ -21 +21 @@
 namespace xios
 {
+      extern CLogType logProfile ;
       /// ////////////////////// Dfinitions ////////////////////// ///
       CNc4DataOutput::CNc4DataOutput
@@ -2277 +2278 @@
               case (MULTI_FILE) :
               {
-                 CTimer::get("Files : writing data").resume();
+                 if (info.isActive(logProfile)) CTimer::get("Files : writing data").resume();
                  writeAndConvertData(field, data, nstep - 1);
-                 CTimer::get("Files : writing data").suspend();
+                 if (info.isActive(logProfile)) CTimer::get("Files : writing data").suspend();
                  if (wtime)
                  {
-                   CTimer::get("Files : writing time axis").resume();
+                   if (info.isActive(logProfile)) CTimer::get("Files : writing time axis").resume();
                    if ( wtimeData)
                    {
@@ -2293 +2294 @@
                      if (timeCounterType!=record) SuperClassWriter::writeTimeAxisDataBounds(time_counter_bound, timeBoundId, isCollective, nstep - 1, isRoot);
                    }
-                   CTimer::get("Files : writing time axis").suspend();
+                   if (info.isActive(logProfile)) CTimer::get("Files : writing time axis").suspend();
                  }
                  break;
@@ -2441 +2442 @@
 
 
-                CTimer::get("Files : writing data").resume();
+                if (info.isActive(logProfile)) CTimer::get("Files : writing data").resume();
                 writeAndConvertData(field, data, nstep - 1, &start, &count);
-                CTimer::get("Files : writing data").suspend();
+                if (info.isActive(logProfile)) CTimer::get("Files : writing data").suspend();
 
                  if (wtime)
                  {
-                   CTimer::get("Files : writing time axis").resume();
+                   if (info.isActive(logProfile)) CTimer::get("Files : writing time axis").resume();
                    if ( wtimeData)
                    {
@@ -2459 +2460 @@
 
                    }
-                   CTimer::get("Files : writing time axis").suspend();  
+                   if (info.isActive(logProfile)) CTimer::get("Files : writing time axis").suspend();  
                  }
 

XIOS3/trunk/src/io/onetcdf4.cpp

@@ -13 +13 @@
 namespace xios
 {
+      extern CLogType logProfile ;
       /// ////////////////////// Définitions ////////////////////// ///
 
@@ -58 +59 @@
          if (!append || !std::ifstream(filename.c_str()))
          {
-            CTimer::get("Files : create").resume();
+            if (info.isActive(logProfile)) CTimer::get("Files : create").resume();
             if (wmpi)
                CNetCdfInterface::createPar(filename, mode, *comm, MPI_INFO_NULL, this->ncidp);
             else
                CNetCdfInterface::create(filename, mode, this->ncidp);
-            CTimer::get("Files : create").suspend();
+            if (info.isActive(logProfile)) CTimer::get("Files : create").suspend();
  
             this->appendMode = false;
@@ -70 +71 @@
          {
             mode |= NC_WRITE;
-            CTimer::get("Files : open").resume();
+            if (info.isActive(logProfile)) CTimer::get("Files : open").resume();
             if (wmpi)
                CNetCdfInterface::openPar(filename, mode, *comm, MPI_INFO_NULL, this->ncidp);
             else
                CNetCdfInterface::open(filename, mode, this->ncidp);
-            CTimer::get("Files : open").suspend();
+            if (info.isActive(logProfile)) CTimer::get("Files : open").suspend();
             this->appendMode = true;
          }
@@ -89 +90 @@
       void CONetCDF4::close()
       {
-        CTimer::get("Files : close").resume();
+        if (info.isActive(logProfile)) CTimer::get("Files : close").resume();
         CNetCdfInterface::close(this->ncidp);
-        CTimer::get("Files : close").suspend();
+        if (info.isActive(logProfile)) CTimer::get("Files : close").suspend();
       }
 

XIOS3/trunk/src/log_type.cpp

@@ -5 +5 @@
 {
   using namespace std ;
+  CLogType logProtocol("log_protocol") ;
+  CLogType logTimers("log_timers") ;
+  CLogType logProfile("log_profile") ;
   
   int CLogType::globalBitPos_ = 0 ;

XIOS3/trunk/src/manager/contexts_manager.cpp

@@ -14 +14 @@
 {
   using namespace std ;
+  extern CLogType logTimers ;
 
   CContextsManager::CContextsManager(bool isXiosServer)
@@ -153 +154 @@
   void CContextsManager::eventLoop(void)
   {
-    CTimer::get("CContextsManager::eventLoop").resume();
+    if (info.isActive(logTimers)) CTimer::get("CContextsManager::eventLoop").resume();
     int flag ;
     MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, MPI_STATUS_IGNORE);
@@ -162 +163 @@
       lastEventLoop_=time ;
     }
-    CTimer::get("CContextsManager::eventLoop").suspend();
+    if (info.isActive(logTimers)) CTimer::get("CContextsManager::eventLoop").suspend();
   }
   

XIOS3/trunk/src/manager/pool_ressource.cpp

@@ -12 +12 @@
 namespace xios
 {
+  extern CLogType logTimers ;
+  
   CPoolRessource::CPoolRessource(MPI_Comm poolComm, shared_ptr<CEventScheduler> eventScheduler, const std::string& Id, bool isServer) : Id_(Id), finalizeSignal_(false)
   {
@@ -237 +239 @@
   bool CPoolRessource::eventLoop(bool serviceOnly)
   {
-    CTimer::get("CPoolRessource::eventLoop").resume();
+    if (info.isActive(logTimers)) CTimer::get("CPoolRessource::eventLoop").resume();
    
     double time=MPI_Wtime() ;
@@ -259 +261 @@
       }
     }
-    CTimer::get("CPoolRessource::eventLoop").suspend();
+    if (info.isActive(logTimers)) CTimer::get("CPoolRessource::eventLoop").suspend();
     if (services_.empty() && finalizeSignal_) finished_=true ;
     return finished_ ;
@@ -266 +268 @@
   void CPoolRessource::threadEventLoop(void)
   {
-    CTimer::get("CPoolRessource::eventLoop").resume();
+    if (info.isActive(logTimers)) CTimer::get("CPoolRessource::eventLoop").resume();
     info(100)<<"Launch Thread for  CPoolRessource::threadEventLoop, pool id = "<<Id_<<endl ;
     CThreadManager::threadInitialize() ; 
@@ -294 +296 @@
       }
 
-      CTimer::get("CPoolRessource::eventLoop").suspend();
       if (services_.empty() && finalizeSignal_) finished_=true ;
       
@@ -302 +303 @@
 
     CThreadManager::threadFinalize() ;
+    if (info.isActive(logTimers)) CTimer::get("CPoolRessource::eventLoop").suspend();
     info(100)<<"Close thread for  CPoolRessource::threadEventLoop, pool id = "<<Id_<<endl ;
   }

XIOS3/trunk/src/manager/ressources_manager.cpp

@@ -12 +12 @@
 {
   using namespace std;
+  extern CLogType logTimers ;
 
   CRessourcesManager::CRessourcesManager(bool isXiosServer) 
@@ -112 +113 @@
   void CRessourcesManager::eventLoop(void)
   {
-    CTimer::get("CRessourcesManager::eventLoop").resume();
+    if (info.isActive(logTimers)) CTimer::get("CRessourcesManager::eventLoop").resume();
     int flag ;
     MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, MPI_STATUS_IGNORE);
@@ -122 +123 @@
     }
 
-    CTimer::get("CRessourcesManager::eventLoop").suspend();
+    if (info.isActive(logTimers)) CTimer::get("CRessourcesManager::eventLoop").suspend();
   }
   
@@ -129 +130 @@
     int commRank ;
     MPI_Comm_rank(xiosComm_, &commRank) ;
-    CTimer::get("CRessourcesManager::checkNotifications lock").resume();
+    if (info.isActive(logTimers)) CTimer::get("CRessourcesManager::checkNotifications lock").resume();
     winNotify_->lockWindowExclusive(commRank) ;
-    CTimer::get("CRessourcesManager::checkNotifications lock").suspend();
-    CTimer::get("CRessourcesManager::checkNotifications pop").resume();
+    if (info.isActive(logTimers)) CTimer::get("CRessourcesManager::checkNotifications lock").suspend();
+    if (info.isActive(logTimers)) CTimer::get("CRessourcesManager::checkNotifications pop").resume();
     winNotify_->popFromLockedWindow(commRank, this, &CRessourcesManager::notificationsDumpIn) ;
-    CTimer::get("CRessourcesManager::checkNotifications pop").suspend();
-    CTimer::get("CRessourcesManager::checkNotifications unlock").resume();
+    if (info.isActive(logTimers)) CTimer::get("CRessourcesManager::checkNotifications pop").suspend();
+    if (info.isActive(logTimers)) CTimer::get("CRessourcesManager::checkNotifications unlock").resume();
     winNotify_->unlockWindowExclusive(commRank) ;
-    CTimer::get("CRessourcesManager::checkNotifications unlock").suspend();
+    if (info.isActive(logTimers)) CTimer::get("CRessourcesManager::checkNotifications unlock").suspend();
     if (notifyType_==NOTIFY_CREATE_POOL) createPool() ;
     else if (notifyType_==NOTIFY_FINALIZE) finalizeSignal() ;

XIOS3/trunk/src/manager/server_context.cpp

@@ -13 +13 @@
 {
   using namespace std ;
+  extern CLogType logTimers ;
 
   map<string, tuple<bool,MPI_Comm,MPI_Comm> > CServerContext::overlapedComm_ ;
@@ -233 +234 @@
   bool CServerContext::eventLoop(bool serviceOnly)
   {
-    CTimer::get("CServerContext::eventLoop").resume();
+    if (info.isActive(logTimers)) CTimer::get("CServerContext::eventLoop").resume();
     bool finished=false ;
     int flag ;
@@ -256 +257 @@
       }
     }
-    CTimer::get("CServerContext::eventLoop").suspend();
+    if (info.isActive(logTimers)) CTimer::get("CServerContext::eventLoop").suspend();
     if (context_==nullptr && finalizeSignal_) finished=true ;
     return finished ;
@@ -264 +265 @@
   {
     
+    if (info.isActive(logTimers)) CTimer::get("CServerContext::eventLoop").resume();
     info(100)<<"Launch Thread for CServerContext::threadEventLoop, context id = "<<context_->getId()<<endl ;
     CThreadManager::threadInitialize() ; 
     do
     {
-      CTimer::get("CServerContext::eventLoop").resume();
       int flag ;
       MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, MPI_STATUS_IGNORE);
@@ -285 +286 @@
         }
       }
-      CTimer::get("CServerContext::eventLoop").suspend();
       if (context_==nullptr && finalizeSignal_) finished_=true ;
  
@@ -294 +294 @@
     CThreadManager::threadFinalize() ;
     info(100)<<"Close thread for CServerContext::threadEventLoop"<<endl ;
+    if (info.isActive(logTimers)) CTimer::get("CServerContext::eventLoop").suspend();
   }
 

XIOS3/trunk/src/manager/servers_ressource.cpp

@@ -18 +18 @@
 {
   using namespace std ;
+  extern CLogType logTimers ;
 
   CServersRessource::CServersRessource(MPI_Comm serverComm) : poolRessource_(nullptr), finalizeSignal_(false)
@@ -122 +123 @@
   bool CServersRessource::eventLoop(bool serviceOnly)
   {
-    CTimer::get("CServersRessource::eventLoop").resume();
+    if (info.isActive(logTimers)) CTimer::get("CServersRessource::eventLoop").resume();
     double time=MPI_Wtime() ;
     int flag ;
@@ -143 +144 @@
       } 
     }
-    CTimer::get("CServersRessource::eventLoop").suspend();
+    if (info.isActive(logTimers)) CTimer::get("CServersRessource::eventLoop").suspend();
     if (poolRessource_==nullptr && finalizeSignal_) finished_=true ;
     return finished_ ;
@@ -150 +151 @@
   void CServersRessource::threadEventLoop(void)
   {
-    CTimer::get("CServersRessource::eventLoop").resume();
+    if (info.isActive(logTimers)) CTimer::get("CServersRessource::eventLoop").resume();
     info(100)<<"Launch Thread for  CServersRessource::threadEventLoop"<<endl ;
     CThreadManager::threadInitialize() ; 
@@ -175 +176 @@
         } 
       }
-      CTimer::get("CServersRessource::eventLoop").suspend();
       if (poolRessource_==nullptr && finalizeSignal_) finished_=true ;
       if (!finished_) CThreadManager::yield() ;
@@ -182 +182 @@
 
     CThreadManager::threadFinalize() ;
+    if (info.isActive(logTimers)) CTimer::get("CServersRessource::eventLoop").suspend();
     info(100)<<"Close thread for CServersRessource::threadEventLoop"<<endl ; ;
   }

XIOS3/trunk/src/manager/services.cpp

@@ -10 +10 @@
 namespace xios
 {
+  extern CLogType logTimers ;
+
   CService::CService(MPI_Comm serviceComm, shared_ptr<CEventScheduler> eventScheduler, const std::string& poolId, const std::string& serviceId, const int& partitionId, 
                      int type, int nbPartitions) 
@@ -115 +117 @@
   {
     //checkCreateContextNotification() ;
-    CTimer::get("CService::eventLoop").resume();
+    if (info.isActive(logTimers)) CTimer::get("CService::eventLoop").resume();
     int flag ;
     MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, MPI_STATUS_IGNORE);
@@ -140 +142 @@
     }
   
-    CTimer::get("CService::eventLoop").suspend();
+    if (info.isActive(logTimers)) CTimer::get("CService::eventLoop").suspend();
     if (contexts_.empty() && finalizeSignal_) return true ;
     else return false ;
@@ -147 +149 @@
   void CService::threadEventLoop(void)
   {
+    if (info.isActive(logTimers)) CTimer::get("CService::eventLoop").resume();
     info(100)<<"Launch Thread for  CService::threadEventLoop, service id = "<<name_<<endl ;
     CThreadManager::threadInitialize() ; 
@@ -152 +155 @@
     do
     {
-      CTimer::get("CService::eventLoop").resume();
       int flag ;
       MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, MPI_STATUS_IGNORE);
@@ -177 +179 @@
       }
 
-      CTimer::get("CService::eventLoop").suspend();
       if (contexts_.empty() && finalizeSignal_) finished_=true ;
       if (!finished_) CThreadManager::yield() ;
@@ -184 +185 @@
     CThreadManager::threadFinalize() ;
     info(100)<<"Close thread for  CService::threadEventLoop, service id = "<<name_<<endl ;
+    if (info.isActive(logTimers)) CTimer::get("CService::eventLoop").suspend();
   }
 

XIOS3/trunk/src/manager/services_manager.cpp

@@ -11 +11 @@
 namespace xios
 {
-
+  extern CLogType logTimers ;
   
 
@@ -123 +123 @@
   void CServicesManager::eventLoop(void)
   {
-    CTimer::get("CServicesManager::eventLoop").resume();
+    if (info.isActive(logTimers)) CTimer::get("CServicesManager::eventLoop").resume();
     int flag ;
     MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, MPI_STATUS_IGNORE);
@@ -132 +132 @@
       lastEventLoop_=time ;
     }
-    CTimer::get("CServicesManager::eventLoop").suspend();
+    if (info.isActive(logTimers)) CTimer::get("CServicesManager::eventLoop").suspend();
   }
 

XIOS3/trunk/src/node/context.cpp

@@ -42 +42 @@
 
   std::shared_ptr<CContextGroup> CContext::root;
+  extern CLogType logProfile ;
 
    /// ////////////////////// Définitions ////////////////////// ///
@@ -818 +819 @@
     bool  finished(true); 
     if (isLockedContext()) enableEventsProcessing=false;
+    else if (info.isActive(logProfile)) CTimer::get("Context event loop").resume();
     
     setCurrent(getId()) ;
@@ -839 +841 @@
     }
     setCurrent(getId()) ;
+    if (!isLockedContext()) if (info.isActive(logProfile)) CTimer::get("Context event loop").suspend();
     return finalized && finished ;
   }
@@ -1113 +1116 @@
      CMemChecker::logMem( "CContext::closeDefinition" );
 
-     CTimer::get("Context : close definition").resume() ;
+     if (info.isActive(logProfile)) CTimer::get("Context : close definition").resume() ;
 
      onlineContextClient_=CContextClient::getNew<CContextClient::online>(this,intraComm_, intraComm_);
@@ -1409 +1412 @@
 
 
-     CTimer::get("Context : close definition").suspend() ;
+     if (info.isActive(logProfile)) CTimer::get("Context : close definition").suspend() ;
      CMemChecker::logMem( "CContext::closeDefinition_END" );
   }

XIOS3/trunk/src/node/field.cpp

@@ -28 +28 @@
 namespace xios
 {
+  extern CLogType logProfile ;
 
   /// ////////////////////// Définitions ////////////////////// ///
@@ -320 +321 @@
   TRY
   {
+    if (info.isActive(logProfile)) CTimer::get("Check late data (read)").resume();
     if (hasFileIn()) 
     {
@@ -331 +333 @@
       clientFromClientSourceFilter_->trigger(CContext::getCurrent()->getCalendar()->getCurrentDate()) ;
     }
+    if (info.isActive(logProfile)) CTimer::get("Check late data (read)").suspend();
   }
   CATCH_DUMP_ATTR

XIOS3/trunk/src/node/file.cpp

@@ -21 +21 @@
 namespace xios {
 
+   extern CLogType logProfile ;
    /// ////////////////////// Dfinitions ////////////////////// ///
 
@@ -329 +330 @@
       if (mode.isEmpty() || mode.getValue() == mode_attr::write)
       {
-        CTimer::get("Files : create headers").resume();
+        if (info.isActive(logProfile)) CTimer::get("Files : create headers").resume();
         if (!isOpen) createHeader();
-        CTimer::get("Files : create headers").suspend();
+        if (info.isActive(logProfile)) CTimer::get("Files : create headers").suspend();
         checkSync();
       }        
@@ -357 +358 @@
         if (!mode.isEmpty() && mode.getValue() == mode_attr::read)
         {
-          CTimer::get("Files : open headers").resume();
+          if (info.isActive(logProfile)) CTimer::get("Files : open headers").resume();
           
           if (!isOpen) openInReadMode();
 
-          CTimer::get("Files : open headers").suspend();
+          if (info.isActive(logProfile)) CTimer::get("Files : open headers").suspend();
         }
         //checkSplit(); // Really need for reading?

XIOS3/trunk/src/server.cpp

@@ -52 +52 @@
     CServersRessource* CServer::serversRessource_=nullptr ;
     CThirdPartyDriver* CServer::driver_ =nullptr ;
-
+    extern CLogType logTimers ;
        
     void CServer::initialize(void)
@@ -622 +622 @@
       report(0)<<"Performance report : Time spent in processing events : "<<CTimer::get("Process events").getCumulatedTime()<<endl  ;
       report(0)<<"Performance report : Ratio : "<<CTimer::get("Process events").getCumulatedTime()/CTimer::get("XIOS server").getCumulatedTime()*100.<<"%"<<endl  ;
-      report(100)<<CTimer::getAllCumulatedTime()<<endl ;
+
+      if (info.isActive(logProfile))
+      {
+        printProfile();
+      }
+      
+      if (info.isActive(logTimers)) report(0)<<"\n"<<CTimer::getAllCumulatedTime()<<endl ;
       if (CXios::reportMemory)
       {
@@ -630 +636 @@
       CWorkflowGraph::drawWorkFlowGraph_server();
       xios::releaseStaticAllocation() ; // free memory from static allocation
+    }
+    
+    void CServer::printProfile()
+    {
+      list< pair<string,int> > timer_name;
+      timer_name.push_back({"XIOS server",0});
+      timer_name.push_back({"XIOS initialize",0});
+      timer_name.push_back({"XIOS event loop",0});
+      //timer_name.push_back({"Recv event loop (p2p)",1});      // timer concerned by yield and thread (if reader embedded)
+      //timer_name.push_back({"Recv event loop (legacy)",1});   // timer concerned by yield and thread
+      timer_name.push_back({"Process events",2});
+      timer_name.push_back({"Context : close definition",3});
+      timer_name.push_back({"Reader workflow data entry",3});
+      timer_name.push_back({"Files : reading data",4});
+      //timer_name.push_back({"Field : send data (read)",4});   // timer concerned by yield and thread
+      timer_name.push_back({"Server workflow data entry",3});
+      timer_name.push_back({"Server workflow",3});
+      timer_name.push_back({"Applying filters",4});
+      timer_name.push_back({"Transformation transfers",5});
+      timer_name.push_back({"Transformation MPI",6});
+      timer_name.push_back({"Temporal filters",5});
+      timer_name.push_back({"Field : send data",4});
+      //timer_name.push_back({"Scatter event",5});              // timer concerned by yield and thread
+      //timer_name.push_back({"Blocking time",6});              // timer concerned by yield and thread
+      timer_name.push_back({"Files : create headers",4});
+      timer_name.push_back({"Files : writing data",4});
+      timer_name.push_back({"Context finalize",3});             // timer concerned by yield and thread
+      timer_name.push_back({"Files : close",4});
+      
+      report(0)<< endl;
+      double total_time = CTimer::get("Process events").getCumulatedTime();
+      for(auto it_timer_name = timer_name.begin(); it_timer_name != timer_name.end(); it_timer_name++)
+      {
+        double timer_time = CTimer::get(it_timer_name->first).getCumulatedTime();
+        if ( timer_time / total_time > 0.001 )
+        {
+          ostringstream printed_line;
+          printed_line << setprecision(3) << std::fixed;
+          for(int itab=0;itab<it_timer_name->second;itab++)
+              printed_line << "  ";
+          printed_line << it_timer_name->first << " : " << timer_time <<endl;
+          string string_line = printed_line.str();
+          report(0)<< string_line;
+        }
+      }
     }
 

XIOS3/trunk/src/server.hpp

@@ -46 +46 @@
         
         static void finalize(void);
+        static void printProfile(void);
         static void eventLoop(void);
         

XIOS3/trunk/src/transformation/grid_algorithm_generic.cpp

@@ -6 +6 @@
 #include "context.hpp"
 #include "transform_filter.hpp"
+#include "timer.hpp"
 
 namespace xios
 {
+  extern CLogType logProfile ;
 
   CGridAlgorithmGeneric::CGridAlgorithmGeneric(CGrid* gridSrc, CGrid* gridDst, int pos,  shared_ptr<CGenericAlgorithmTransformation> algo)
@@ -54 +56 @@
   {
     CArray<double,1> dataOutTmp ;
+    if (info.isActive(logProfile)) CTimer::get("Transformation transfers").resume() ;
     gridTransformConnector_->transfer(dataIn, dataOutTmp) ;
+    if (info.isActive(logProfile)) CTimer::get("Transformation transfers").suspend() ;
     algorithm_->apply(dimBefore_, dimAfter_, dataOutTmp, dataOut) ;
   }

XIOS3/trunk/src/transport/legacy_context_client.cpp

@@ -20 +20 @@
 namespace xios
 {
+    extern CLogType logTimers ;
+  
     /*!
     \param [in] parent Pointer to context on client side
@@ -218 +220 @@
            // create windows dynamically for one-sided
           /*
-          CTimer::get("create Windows").resume() ;
+          if (info.isActive(logTimers)) CTimer::get("create Windows").resume() ;
           MPI_Comm interComm ;
           int tag = 0 ;
@@ -241 +243 @@
           if (flag)
           {
-            CTimer::get("create Windows").resume() ;
+            if (info.isActive(logTimers)) CTimer::get("create Windows").resume() ;
             MPI_Comm interComm ;
             int tag = 0 ;

XIOS3/trunk/src/transport/legacy_context_server.cpp

@@ -30 +30 @@
 {
   using namespace std ;
+  extern CLogType logTimers ;
+  extern CLogType logProfile ;
 
   CLegacyContextServer::CLegacyContextServer(CContext* parent,MPI_Comm intraComm_,MPI_Comm interComm_) 
@@ -70 +72 @@
   bool CLegacyContextServer::eventLoop(bool enableEventsProcessing /*= true*/)
   {
-    CTimer::get("listen request").resume();
+    if (info.isActive(logProfile)) CTimer::get("Recv event loop (legacy)").resume();
+    if (info.isActive(logTimers)) CTimer::get("listen request").resume();
     listen();
-    CTimer::get("listen request").suspend();
-    CTimer::get("check pending request").resume();
+    if (info.isActive(logTimers)) CTimer::get("listen request").suspend();
+    if (info.isActive(logTimers)) CTimer::get("check pending request").resume();
     checkPendingRequest();
     checkPendingProbe() ;
-    CTimer::get("check pending request").suspend();
-    CTimer::get("check event process").resume();
+    if (info.isActive(logTimers)) CTimer::get("check pending request").suspend();
+    if (info.isActive(logTimers)) CTimer::get("check event process").resume();
     processEvents(enableEventsProcessing);
-    CTimer::get("check event process").suspend();
+    if (info.isActive(logTimers)) CTimer::get("check event process").suspend();
+    if (info.isActive(logProfile)) CTimer::get("Recv event loop (legacy)").suspend();
     return finished;
   }
@@ -121 +125 @@
       int dummy ;
       MPI_Send(&dummy, 0, MPI_INT, rank, 21,interCommMerged_) ;
-      CTimer::get("create Windows").resume() ;
+      if (info.isActive(logTimers)) CTimer::get("create Windows").resume() ;
       MPI_Comm interComm ;
       int tag = 0 ;
@@ -138 +142 @@
       windows_[rank][0] -> setWinBufferAddress(winBufferAddress[0],0) ;
       windows_[rank][1] -> setWinBufferAddress(winBufferAddress[1],0) ;
-      CTimer::get("create Windows").suspend() ;
+      if (info.isActive(logTimers)) CTimer::get("create Windows").suspend() ;
       CXios::getMpiGarbageCollector().registerCommunicator(winComm_[rank]) ;
       MPI_Barrier(winComm_[rank]) ;
@@ -200 +204 @@
     MPI_Status status;
    
-    if (!pendingRequest.empty()) CTimer::get("receiving requests").resume();
-    else CTimer::get("receiving requests").suspend();
+    if (!pendingRequest.empty()) if (info.isActive(logTimers)) CTimer::get("receiving requests").resume();
+    else if (info.isActive(logTimers)) CTimer::get("receiving requests").suspend();
 
     for(it=pendingRequest.begin();it!=pendingRequest.end();it++)
@@ -227 +231 @@
   void CLegacyContextServer::getBufferFromClient(size_t timeLine)
   {
-    CTimer::get("CLegacyContextServer::getBufferFromClient").resume() ;
+    if (info.isActive(logTimers)) CTimer::get("CLegacyContextServer::getBufferFromClient").resume() ;
 
     int rank ;
@@ -244 +248 @@
       }
     }
-    CTimer::get("CLegacyContextServer::getBufferFromClient").suspend() ;
+    if (info.isActive(logTimers)) CTimer::get("CLegacyContextServer::getBufferFromClient").suspend() ;
   }
          
@@ -423 +427 @@
     if (event.classId==CContext::GetType() && event.type==CContext::EVENT_ID_CONTEXT_FINALIZE)
     {
+      if (info.isActive(logProfile)) CTimer::get("Context finalize").resume();
       finished=true;
       info(20)<<" CLegacyContextServer: Receive context <"<<context->getId()<<"> finalize."<<endl;
       notifyClientsFinalize() ;
-      CTimer::get("receiving requests").suspend();
+      if (info.isActive(logTimers)) CTimer::get("receiving requests").suspend();
       context->finalize();
       
@@ -439 +444 @@
       }
       report(0)<< " Memory report : Context <"<<ctxId<<"> : server side : total memory used for buffer "<<totalBuf<<" bytes"<<endl;
+      if (info.isActive(logProfile)) CTimer::get("Context finalize").suspend();
     }
     else if (event.classId==CContext::GetType()) CContext::dispatchEvent(event);

XIOS3/trunk/src/transport/one_sided_client_buffer.cpp

@@ -7 +7 @@
   
   extern CLogType logProtocol;
+  extern CLogType logTimers ;
 
   COneSidedClientBuffer::COneSidedClientBuffer(MPI_Comm& interComm, int serverRank, MPI_Comm& commSelf, MPI_Comm& interCommMerged, int intraServerRank) : interComm_(interComm), serverRank_(serverRank), interCommMerged_(interCommMerged), intraServerRank_(intraServerRank)
@@ -20 +21 @@
   void COneSidedClientBuffer::createWindow(MPI_Comm& commSelf, MPI_Comm& interCommMerged, int intraServerRank )
   {
-    CTimer::get("create Windows").resume() ;
+    if (info.isActive(logTimers)) CTimer::get("create Windows").resume() ;
     MPI_Comm interComm ;
     xios::MPI_Intercomm_create(commSelf, 0, interCommMerged, intraServerRank, 0, &interComm) ;
@@ -46 +47 @@
     MPI_Win_attach(winControl_, control_, controlSize_*sizeof(MPI_Aint)) ;
     MPI_Barrier(winComm_) ;
-    CTimer::get("create Windows").suspend() ;
+    if (info.isActive(logTimers)) CTimer::get("create Windows").suspend() ;
  
  //   MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, winControl_) ;

XIOS3/trunk/src/transport/one_sided_context_server.cpp

@@ -30 +30 @@
 {
   using namespace std ;
+  extern CLogType logTimers ;
+  extern CLogType logProfile ;
 
   COneSidedContextServer::COneSidedContextServer(CContext* parent,MPI_Comm intraComm_,MPI_Comm interComm_)
@@ -71 +73 @@
   bool COneSidedContextServer::eventLoop(bool enableEventsProcessing /*= true*/)
   {
-    CTimer::get("listen request").resume();
+    if (info.isActive(logTimers)) CTimer::get("listen request").resume();
     listen();
-    CTimer::get("listen request").suspend();
-
-    CTimer::get("listen pending request").resume();
+    if (info.isActive(logTimers)) CTimer::get("listen request").suspend();
+
+    if (info.isActive(logTimers)) CTimer::get("listen pending request").resume();
     listenPendingRequest() ;
-    CTimer::get("listen pending request").suspend();
-
-    CTimer::get("check server Buffers").resume();
+    if (info.isActive(logTimers)) CTimer::get("listen pending request").suspend();
+
+    if (info.isActive(logTimers)) CTimer::get("check server Buffers").resume();
     checkBuffers() ;
-    CTimer::get("check server Buffers").suspend();
-
-    CTimer::get("check event process").resume();
+    if (info.isActive(logTimers)) CTimer::get("check server Buffers").suspend();
+
+    if (info.isActive(logTimers)) CTimer::get("check event process").resume();
     processEvents(enableEventsProcessing);
-    CTimer::get("check event process").suspend();
+    if (info.isActive(logTimers)) CTimer::get("check event process").suspend();
     return finished;
 
@@ -265 +267 @@
     if (event.classId==CContext::GetType() && event.type==CContext::EVENT_ID_CONTEXT_FINALIZE)
     {
+      if (info.isActive(logProfile)) CTimer::get("Context finalize").resume();
       finished=true;
       info(20)<<" COneSidedContextServer: Receive context <"<<context->getId()<<"> finalize."<<endl;
       notifyClientsFinalize() ;
-      CTimer::get("receiving requests").suspend();
+      if (info.isActive(logTimers)) CTimer::get("receiving requests").suspend();
       context->finalize();
       
@@ -281 +284 @@
       }
       report(0)<< " Memory report : Context <"<<ctxId<<"> : server side : total memory used for buffer "<<totalBuf<<" bytes"<<endl;
+      if (info.isActive(logProfile)) CTimer::get("Context finalize").suspend();
     }
     else if (event.classId==CContext::GetType()) CContext::dispatchEvent(event);

XIOS3/trunk/src/transport/one_sided_server_buffer.cpp

@@ -9 +9 @@
 namespace xios
 {
-  CLogType logProtocol("log_protocol") ;
+  extern CLogType logProtocol ;
+  extern CLogType logTimers ;
 
   COneSidedServerBuffer::COneSidedServerBuffer(int clientRank, const MPI_Comm& commSelf, const MPI_Comm& interCommMerged, map<size_t, SPendingEvent>& pendingEvents, 
@@ -23 +24 @@
   void COneSidedServerBuffer::createWindow(const MPI_Comm& commSelf, const MPI_Comm& interCommMerged)
   {
-    CTimer::get("create Windows").resume() ;
+    if (info.isActive(logTimers)) CTimer::get("create Windows").resume() ;
     MPI_Comm interComm ;
     xios::MPI_Intercomm_create(commSelf, 0, interCommMerged, clientRank_, 0 , &interComm) ;
@@ -40 +41 @@
     MPI_Win_create_dynamic(MPI_INFO_NULL, winComm_, &winControl_);
     CXios::getMpiGarbageCollector().registerWindow(winControl_) ;
-    CTimer::get("create Windows").suspend() ;
+    if (info.isActive(logTimers)) CTimer::get("create Windows").suspend() ;
     MPI_Barrier(winComm_) ;
     MPI_Barrier(winComm_) ;

XIOS3/trunk/src/transport/p2p_client_buffer.cpp

@@ -7 +7 @@
   
   extern CLogType logProtocol;
+  extern CLogType logTimers ;
 
   CP2pClientBuffer::CP2pClientBuffer(MPI_Comm& interComm, int serverRank, MPI_Comm& commSelf, MPI_Comm& interCommMerged, int intraServerRank) : interComm_(interComm), serverRank_(serverRank), interCommMerged_(interCommMerged), intraServerRank_(intraServerRank)
@@ -22 +23 @@
   void CP2pClientBuffer::createWindow(MPI_Comm& commSelf, MPI_Comm& interCommMerged, int intraServerRank )
   {
-    CTimer::get("create Windows").resume() ;
+    if (info.isActive(logTimers)) CTimer::get("create Windows").resume() ;
     //MPI_Comm interComm ;
     //xios::MPI_Intercomm_create(commSelf, 0, interCommMerged, intraServerRank, 0, &interComm) ;
@@ -49 +50 @@
     //MPI_Win_attach(winControl_, control_, controlSize_*sizeof(MPI_Aint)) ;
     //MPI_Barrier(winComm_) ;
-    CTimer::get("create Windows").suspend() ;
+    if (info.isActive(logTimers)) CTimer::get("create Windows").suspend() ;
  
  //   MPI_Win_lock(MPI_LOCK_EXCLUSIVE, 0, 0, winControl_) ;

XIOS3/trunk/src/transport/p2p_context_server.cpp

@@ -30 +30 @@
 {
   using namespace std ;
+  extern CLogType logTimers ;
+  extern CLogType logProfile ;
 
   CP2pContextServer::CP2pContextServer(CContext* parent,MPI_Comm intraComm_,MPI_Comm interComm_)
@@ -71 +73 @@
   bool CP2pContextServer::eventLoop(bool enableEventsProcessing /*= true*/)
   {
-    CTimer::get("listen request").resume();
+    if (info.isActive(logProfile)) CTimer::get("Recv event loop (p2p)").resume();
+    if (info.isActive(logTimers)) CTimer::get("listen request").resume();
     listen();
-    CTimer::get("listen request").suspend();
-
-    CTimer::get("listen pending request").resume();
+    if (info.isActive(logTimers)) CTimer::get("listen request").suspend();
+
+    if (info.isActive(logTimers)) CTimer::get("listen pending request").resume();
     listenPendingRequest() ;
-    CTimer::get("listen pending request").suspend();
-
-    CTimer::get("check server Buffers").resume();
+    if (info.isActive(logTimers)) CTimer::get("listen pending request").suspend();
+
+    if (info.isActive(logTimers)) CTimer::get("check server Buffers").resume();
     checkBuffers() ;
-    CTimer::get("check server Buffers").suspend();
-
-    CTimer::get("check event process").resume();
+    if (info.isActive(logTimers)) CTimer::get("check server Buffers").suspend();
+
+    if (info.isActive(logTimers)) CTimer::get("check event process").resume();
     processEvents(enableEventsProcessing);
-    CTimer::get("check event process").suspend();
+    if (info.isActive(logTimers)) CTimer::get("check event process").suspend();
+    if (info.isActive(logProfile)) CTimer::get("Recv event loop (p2p)").suspend();
     return finished;
 
@@ -269 +273 @@
     if (event.classId==CContext::GetType() && event.type==CContext::EVENT_ID_CONTEXT_FINALIZE)
     {
+      CTimer::get("Context finalize").resume();
       finished=true;
       info(20)<<" CP2pContextServer: Receive context <"<<context->getId()<<"> finalize."<<endl;
       notifyClientsFinalize() ;
-      CTimer::get("receiving requests").suspend();
+      if (info.isActive(logTimers)) CTimer::get("receiving requests").suspend();
       context->finalize();
       
@@ -285 +290 @@
       }
       report(0)<< " Memory report : Context <"<<ctxId<<"> : server side : total memory used for buffer "<<totalBuf<<" bytes"<<endl;
+      CTimer::get("Context finalize").suspend();
     }
     else if (event.classId==CContext::GetType()) CContext::dispatchEvent(event);

XIOS3/trunk/src/transport/p2p_server_buffer.cpp

@@ -10 +10 @@
 {
   extern CLogType logProtocol ;
+  extern CLogType logTimers ;
 
   CP2pServerBuffer::CP2pServerBuffer(int clientRank, const MPI_Comm& commSelf, const MPI_Comm& interCommMerged, map<size_t, SPendingEvent>& pendingEvents, 
@@ -24 +25 @@
   void CP2pServerBuffer::createWindow(const MPI_Comm& commSelf, const MPI_Comm& interCommMerged)
   {
-    CTimer::get("create Windows").resume() ;
+    if (info.isActive(logTimers)) CTimer::get("create Windows").resume() ;
     //MPI_Comm interComm ;
     //xios::MPI_Intercomm_create(commSelf, 0, interCommMerged, clientRank_, 0 , &interComm) ;
@@ -41 +42 @@
     //MPI_Win_create_dynamic(MPI_INFO_NULL, winComm_, &winControl_);
     //CXios::getMpiGarbageCollector().registerWindow(winControl_) ;
-    CTimer::get("create Windows").suspend() ;
+    if (info.isActive(logTimers)) CTimer::get("create Windows").suspend() ;
     //MPI_Barrier(winComm_) ;
     //MPI_Barrier(winComm_) ;