Extend caching and improve performance of timestamp task (#121)

Author: njacazio

Common/TableProducer/timestamp.cxx

@@ -9,11 +9,13 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-//
-// A task to fill the timestamp table from run number.
-// Uses headers from CCDB
-//
-// Author: Nicolo' Jacazio on 2020-06-22
+///
+/// \file   timestamp.cxx
+/// \author Nicolò Jacazio
+/// \since  2020-06-22
+/// \brief  A task to fill the timestamp table from run number.
+///         Uses headers from CCDB
+///
 
 #include "Framework/runDataProcessing.h"
 #include "Framework/AnalysisTask.h"
@@ -27,19 +29,23 @@ using namespace o2::header;
 using namespace o2;
 
 struct TimestampTask {
-  Produces<aod::Timestamps> ts_table;          /// Table with SOR timestamps produced by the task
+  Produces<aod::Timestamps> timestampTable;    /// Table with SOR timestamps produced by the task
   Service<o2::ccdb::BasicCCDBManager> ccdb;    /// Object manager in CCDB
   o2::ccdb::CcdbApi ccdb_api;                  /// API to access CCDB
   std::map<int, int>* mapStartOrbit = nullptr; /// Map of the starting orbit for the run
-  std::pair<int, long> lastCall;               /// Last run number processed and its timestamp, needed for caching
   std::map<int, long> mapRunToTimestamp;       /// Cache of processed run numbers
+  int lastRunNumber = 0;                       /// Last run number processed
+  long runNumberTimeStamp = 0;                 /// Timestamp of the run number, used in the process function to work out the timestamp of the BC
+  uint32_t initialOrbit = 0;                   /// Index of the first orbit of the run number, used in the process function to evaluate the offset with respect to the starting of the run
+  static constexpr uint16_t initialBC = 0;     /// Index of the initial bc, exact bc number not relevant due to ms precision of timestamps
+  InteractionRecord initialIR;                 /// Initial interaction record, used to compute the delta with respect to the start of the run
 
   // Configurables
   Configurable<bool> verbose{"verbose", false, "verbose mode"};
   Configurable<std::string> rct_path{"rct-path", "RCT/RunInformation/", "path to the ccdb RCT objects for the SOR timestamps"};
   Configurable<std::string> start_orbit_path{"start-orbit-path", "GRP/StartOrbit", "path to the ccdb SOR orbit objects"};
   Configurable<std::string> url{"ccdb-url", "http://alice-ccdb.cern.ch", "URL of the CCDB database"};
-  Configurable<bool> isMC{"isMC", 0, "0 - data, 1 - MC"};
+  Configurable<bool> isMC{"isMC", false, "Running mode: enabled for MC. If enabled this flag is used to compute the timestamp according to the input data. The timestamp of the BC is computed from initialBC and initialOrbit"};
 
   void init(o2::framework::InitContext&)
   {
@@ -56,15 +62,30 @@ struct TimestampTask {
     }
   }
 
+  void makeInitialOrbit(aod::BC const& bunchCrossing)
+  {
+    if (!mapStartOrbit->count(bunchCrossing.runNumber())) {
+      LOGF(fatal, "Cannot find run %i in mapStartOrbit map", bunchCrossing.runNumber());
+    }
+    initialOrbit = mapStartOrbit->at(bunchCrossing.runNumber());
+    initialIR.bc = initialBC;
+    initialIR.orbit = initialOrbit;
+    // Setting lastCall
+    LOGF(debug, "Setting the last call of the timestamp for run %i to %llu", bunchCrossing.runNumber(), runNumberTimeStamp);
+    lastRunNumber = bunchCrossing.runNumber(); // Setting latest run number information
+  }
+
   void process(aod::BC const& bc)
   {
-    long ts = 0;
-    if (bc.runNumber() == lastCall.first) { // The run number coincides to the last run processed
-      LOGF(debug, "Getting timestamp from last call");
-      ts = lastCall.second;
+    // First: we need to set the timestamp from the run number.
+    // This is done with caching if the run number of the BC was already processed before
+    // If not the timestamp of the run number from BC is queried from CCDB and added to the cache
+    if (bc.runNumber() == lastRunNumber) { // The run number coincides to the last run processed
+      LOGF(debug, "Using timestamp from last call");
     } else if (mapRunToTimestamp.count(bc.runNumber())) { // The run number was already requested before: getting it from cache!
       LOGF(debug, "Getting timestamp from cache");
-      ts = mapRunToTimestamp[bc.runNumber()];
+      runNumberTimeStamp = mapRunToTimestamp[bc.runNumber()];
+      makeInitialOrbit(bc);
     } else { // The run was not requested before: need to acccess CCDB!
       LOGF(debug, "Getting timestamp from CCDB");
       std::map<std::string, std::string> metadata, headers;
@@ -73,34 +94,25 @@ struct TimestampTask {
       if (headers.count("SOR") == 0) {
         LOGF(fatal, "Cannot find run-number to timestamp in path '%s'.", run_path.data());
       }
-      ts = atol(headers["SOR"].c_str()); // timestamp of the SOR in ms
+      runNumberTimeStamp = atol(headers["SOR"].c_str()); // timestamp of the SOR in ms
 
       // Adding the timestamp to the cache map
       std::pair<std::map<int, long>::iterator, bool> check;
-      check = mapRunToTimestamp.insert(std::pair<int, long>(bc.runNumber(), ts));
+      check = mapRunToTimestamp.insert(std::pair<int, long>(bc.runNumber(), runNumberTimeStamp));
       if (!check.second) {
         LOGF(fatal, "Run number %i already existed with a timestamp of %llu", bc.runNumber(), check.first->second);
       }
-      LOGF(info, "Add new run %i with timestamp %llu to cache", bc.runNumber(), ts);
+      makeInitialOrbit(bc);
+      LOGF(info, "Add new run number %i with timestamp %llu to cache", bc.runNumber(), runNumberTimeStamp);
     }
 
-    // Setting latest run information
-    lastCall = std::make_pair(bc.runNumber(), ts);
-
     if (verbose.value) {
-      LOGF(info, "Run-number to timestamp found! %i %llu ms", bc.runNumber(), ts);
-    }
-    const uint16_t initialBC = 0; // exact bc number not relevant due to ms precision of timestamps
-    if (!mapStartOrbit->count(bc.runNumber())) {
-      LOGF(fatal, "Cannot find run %i in mapStartOrbit map", bc.runNumber());
+      LOGF(info, "Run-number to timestamp found! %i %llu ms", bc.runNumber(), runNumberTimeStamp);
     }
-    const uint32_t initialOrbit = mapStartOrbit->at(bc.runNumber());
-    const uint16_t currentBC = isMC ? initialBC : bc.globalBC() % o2::constants::lhc::LHCMaxBunches;
-    const uint32_t currentOrbit = isMC ? initialOrbit : bc.globalBC() / o2::constants::lhc::LHCMaxBunches;
-    const InteractionRecord current(currentBC, currentOrbit);
-    const InteractionRecord initial(initialBC, initialOrbit);
-    ts += (current - initial).bc2ns() / 1000000;
-    ts_table(ts);
+    const uint16_t currentBC = isMC ? initialBC : (bc.globalBC() % o2::constants::lhc::LHCMaxBunches);
+    const uint32_t currentOrbit = isMC ? initialOrbit : (bc.globalBC() / o2::constants::lhc::LHCMaxBunches);
+    const InteractionRecord currentIR(currentBC, currentOrbit);
+    timestampTable(runNumberTimeStamp + (currentIR - initialIR).bc2ns() * 1e-6);
   }
 };