Merge branch 'dev' into add-df-offset-option

Author: aalkin

CCDB/include/CCDB/BasicCCDBManager.h

@@ -102,6 +102,10 @@ class CCDBManagerInstance
   template <typename T>
   T* getForTimeStamp(std::string const& path, long timestamp);
 
+  /// retrieve an object of type T from CCDB as stored under path and using the timestamp in the middle of the run
+  template <typename T>
+  T* getForRun(std::string const& path, int runNumber, bool setRunMetadata = false);
+
   /// retrieve an object of type T from CCDB as stored under path, timestamp and metaData
   template <typename T>
   T* getSpecific(std::string const& path, long timestamp = -1, MD metaData = MD())
@@ -111,6 +115,10 @@ class CCDBManagerInstance
     return getForTimeStamp<T>(path, timestamp);
   }
 
+  /// retrieve an object of type T from CCDB as stored under path and using the timestamp in the middle of the run + metadata. The run number is provided separately to conform to typical analysis use (in which case metadata does not include runNumber)
+  template <typename T>
+  T* getSpecificForRun(std::string const& path, int runNumber, MD metaData = MD());
+
   /// detect online processing modes (i.e. CCDB objects may be updated in the lifetime of the manager)
   bool isOnline() const { return mDeplMode == o2::framework::DeploymentMode::OnlineAUX || mDeplMode == o2::framework::DeploymentMode::OnlineDDS || mDeplMode == o2::framework::DeploymentMode::OnlineECS; }
 
@@ -186,7 +194,7 @@ class CCDBManagerInstance
   /// On error it fatals (if fatal == true) or else returns the pair -1, -1.
   std::pair<int64_t, int64_t> getRunDuration(int runnumber, bool fatal = true);
   static std::pair<int64_t, int64_t> getRunDuration(o2::ccdb::CcdbApi const& api, int runnumber, bool fatal = true);
-
+  static std::pair<int64_t, int64_t> getRunDuration(const MD& headers);
   std::string getSummaryString() const;
 
   size_t getFetchedSize() const { return mFetchedSize; }
@@ -311,6 +319,27 @@ T* CCDBManagerInstance::getForTimeStamp(std::string const& path, long timestamp)
   return ptr;
 }
 
+template <typename T>
+T* CCDBManagerInstance::getForRun(std::string const& path, int runNumber, bool setRunMetadata)
+{
+  auto metaData = setRunMetadata ? MD{{"runNumber", std::to_string(runNumber)}} : MD{};
+  mMetaData = metaData;
+  return getSpecificForRun<T>(path, runNumber, metaData);
+}
+
+template <typename T>
+T* CCDBManagerInstance::getSpecificForRun(std::string const& path, int runNumber, MD metaData)
+{
+  auto [start, stop] = getRunDuration(runNumber);
+  if (start < 0 || stop < 0) {
+    if (mFatalWhenNull) {
+      reportFatal(std::string("Failed to get run duration for run ") + std::to_string(runNumber));
+    }
+    return nullptr;
+  }
+  return getSpecific<T>(path, start / 2 + stop / 2, metaData);
+}
+
 class BasicCCDBManager : public CCDBManagerInstance
 {
  public:

CCDB/include/CCDB/CcdbApi.h

@@ -392,6 +392,9 @@ class CcdbApi //: public DatabaseInterface
   // Loads files from alien and cvmfs into given destination.
   bool loadLocalContentToMemory(o2::pmr::vector<char>& dest, std::string& url) const;
 
+  // add annotated flattened headers in the end of the blob
+  static void appendFlatHeader(o2::pmr::vector<char>& dest, const std::map<std::string, std::string>& headers);
+
   // the failure to load the file to memory is signaled by 0 size and non-0 capacity
   static bool isMemoryFileInvalid(const o2::pmr::vector<char>& v) { return v.size() == 0 && v.capacity() > 0; }
   template <typename T>
@@ -610,6 +613,16 @@ class CcdbApi //: public DatabaseInterface
     return getSnapshotDir(topdir, path) + '/' + sfile;
   }
 
+  template <typename MAP> // can be either std::map or std::multimap
+  static size_t getFlatHeaderSize(const MAP& Headers)
+  {
+    size_t hsize = sizeof(int) + sizeof(FlatHeaderAnnot); // annotation size
+    for (auto& h : Headers) {
+      hsize += h.first.length() + h.second.length() + 2; // 2*(string_buffer + terminating null character)
+    }
+    return hsize;
+  }
+
   // tmp helper and single point of entry for a CURL perform call
   // helps to switch between easy handle perform and multi handles in a single place
   CURLcode CURL_perform(CURL* handle) const;
@@ -632,6 +645,8 @@ class CcdbApi //: public DatabaseInterface
   size_t mCurlTimeoutDownload = 15; // download timeout in seconds, can be configured via ALICEO2_CCDB_CURL_TIMEOUT_DOWNLOAD, updated according to the deployment mode
   size_t mCurlTimeoutUpload = 15;   // upload timeout in seconds, can be configured via ALICEO2_CCDB_CURL_TIMEOUT_UPLOAD, updated according to the deployment mode
 
+  static constexpr char FlatHeaderAnnot[] = "$HEADER$"; // annotation for flat header
+
   ClassDefNV(CcdbApi, 1);
 };
 

CCDB/src/BasicCCDBManager.cxx

@@ -32,44 +32,47 @@ void CCDBManagerInstance::reportFatal(std::string_view err)
   LOG(fatal) << err;
 }
 
-std::pair<int64_t, int64_t> CCDBManagerInstance::getRunDuration(o2::ccdb::CcdbApi const& api, int runnumber, bool fatal)
+std::pair<int64_t, int64_t> CCDBManagerInstance::getRunDuration(const std::map<std::string, std::string>& headers)
 {
-  auto response = api.retrieveHeaders("RCT/Info/RunInformation", std::map<std::string, std::string>(), runnumber);
-  if (response.size() != 0) {
+  if (headers.size() != 0) {
     std::string report{};
-    auto strt = response.find("STF");
-    auto stop = response.find("ETF");
-    long valStrt = (strt == response.end()) ? -1L : boost::lexical_cast<int64_t>(strt->second);
-    long valStop = (stop == response.end()) ? -1L : boost::lexical_cast<int64_t>(stop->second);
+    auto strt = headers.find("STF");
+    auto stop = headers.find("ETF");
+    long valStrt = (strt == headers.end()) ? -1L : boost::lexical_cast<int64_t>(strt->second);
+    long valStop = (stop == headers.end()) ? -1L : boost::lexical_cast<int64_t>(stop->second);
     if (valStrt < 0 || valStop < 0) {
       report += "Missing STF/EFT -> use SOX/EOX;";
-      strt = response.find("SOX");
-      valStrt = (strt == response.end()) ? -1L : boost::lexical_cast<int64_t>(strt->second);
+      strt = headers.find("SOX");
+      valStrt = (strt == headers.end()) ? -1L : boost::lexical_cast<int64_t>(strt->second);
       if (valStrt < 1) {
         report += fmt::format(" Missing/invalid SOX -> use SOR");
-        strt = response.find("SOR");
-        valStrt = (strt == response.end()) ? -1L : boost::lexical_cast<int64_t>(strt->second);
+        strt = headers.find("SOR");
+        valStrt = (strt == headers.end()) ? -1L : boost::lexical_cast<int64_t>(strt->second);
       }
-      stop = response.find("EOX");
-      valStop = (stop == response.end()) ? -1L : boost::lexical_cast<int64_t>(stop->second);
+      stop = headers.find("EOX");
+      valStop = (stop == headers.end()) ? -1L : boost::lexical_cast<int64_t>(stop->second);
       if (valStop < 1) {
         report += fmt::format(" | Missing/invalid EOX -> use EOR");
-        stop = response.find("EOR");
-        valStop = (stop == response.end()) ? -1L : boost::lexical_cast<int64_t>(stop->second);
+        stop = headers.find("EOR");
+        valStop = (stop == headers.end()) ? -1L : boost::lexical_cast<int64_t>(stop->second);
       }
       if (!report.empty()) {
         LOGP(warn, "{}", report);
       }
     }
-    if (valStrt > 0 && valStop >= valStrt) {
-      return std::make_pair(valStrt, valStop);
-    }
+    return std::make_pair(valStrt, valStop);
   }
-  // failure
-  if (fatal) {
+  return std::make_pair(-1L, -1L);
+}
+
+std::pair<int64_t, int64_t> CCDBManagerInstance::getRunDuration(o2::ccdb::CcdbApi const& api, int runnumber, bool fatal)
+{
+  auto headers = api.retrieveHeaders("RCT/Info/RunInformation", std::map<std::string, std::string>(), runnumber);
+  auto response = getRunDuration(headers);
+  if ((response.first <= 0 || response.second < response.first) && fatal) {
     LOG(fatal) << "Empty, missing or invalid response from query to RCT/Info/RunInformation for run " << runnumber;
   }
-  return std::make_pair(-1L, -1L);
+  return response;
 }
 
 std::pair<int64_t, int64_t> CCDBManagerInstance::getRunDuration(int runnumber, bool fatal)

CCDB/src/CcdbApi.cxx

@@ -1687,12 +1687,15 @@ void CcdbApi::scheduleDownload(RequestContext& requestContext, size_t* requestCo
     ho.counter++;
     try {
       if (chunk.capacity() < chunk.size() + realsize) {
+        // estimate headers size when converted to annotated text string
+        const char hannot[] = "header";
+        size_t hsize = getFlatHeaderSize(ho.header);
         auto cl = ho.header.find("Content-Length");
         if (cl != ho.header.end()) {
           size_t sizeFromHeader = std::stol(cl->second);
-          sz = std::max(chunk.size() * (sizeFromHeader ? 1 : 2) + realsize, sizeFromHeader);
+          sz = hsize + std::max(chunk.size() * (sizeFromHeader ? 1 : 2) + realsize, sizeFromHeader);
         } else {
-          sz = std::max(chunk.size() * 2, chunk.size() + realsize);
+          sz = hsize + std::max(chunk.size() * 2, chunk.size() + realsize);
           // LOGP(debug, "SIZE IS NOT IN HEADER, allocate {}", sz);
         }
         chunk.reserve(sz);
@@ -1885,6 +1888,25 @@ void CcdbApi::loadFileToMemory(o2::pmr::vector<char>& dest, std::string const& p
   vectoredLoadFileToMemory(contexts);
 }
 
+void CcdbApi::appendFlatHeader(o2::pmr::vector<char>& dest, const std::map<std::string, std::string>& headers)
+{
+  size_t hsize = getFlatHeaderSize(headers), cnt = dest.size();
+  dest.resize(cnt + hsize);
+  auto addString = [&dest, &cnt](const std::string& s) {
+    for (char c : s) {
+      dest[cnt++] = c;
+    }
+    dest[cnt++] = 0;
+  };
+
+  for (auto& h : headers) {
+    addString(h.first);
+    addString(h.second);
+  }
+  *reinterpret_cast<int*>(&dest[cnt]) = hsize;                                     // store size
+  std::memcpy(&dest[cnt + sizeof(int)], FlatHeaderAnnot, sizeof(FlatHeaderAnnot)); // annotate the flattened headers map
+}
+
 void CcdbApi::navigateSourcesAndLoadFile(RequestContext& requestContext, int& fromSnapshot, size_t* requestCounter) const
 {
   LOGP(debug, "loadFileToMemory {} ETag=[{}]", requestContext.path, requestContext.etag);

Common/Constants/include/CommonConstants/PhysicsConstants.h

@@ -48,6 +48,7 @@ enum Pdg {
   kDPlus = 411,
   kDS = 431,
   kDSBar = -431,
+  kDSStar = 433,
   kDS1 = 10433,
   kDS2Star = 435,
   kDStar = 413,
@@ -95,6 +96,7 @@ constexpr double MassDMinus = 1.86966;
 constexpr double MassDPlus = 1.86966;
 constexpr double MassDS = 1.96835;
 constexpr double MassDSBar = 1.96835;
+constexpr double MassDSStar = 2.1122;
 constexpr double MassDS1 = 2.53511;
 constexpr double MassDS2Star = 2.5691;
 constexpr double MassDStar = 2.01026;

Common/Constants/include/CommonConstants/make_pdg_header.py

@@ -103,6 +103,7 @@ class Pdg(Enum):
     kDPlus = 411
     kDS = 431
     kDSBar = -431
+    kDSStar = 433
     kDS1 = 10433
     kDS2Star = 435
     kDStar = 413

Common/DCAFitter/GPU/DeviceInterface/GPUInterface.h

@@ -0,0 +1,71 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \brief Helper interface to the GPU device, meant to be compatible with manual allocation/streams and GPUReconstruction ones.
+/// \author matteo.concas@cern.ch
+
+#ifndef DCAFITTER_GPU_INTERFACE
+#define DCAFITTER_GPU_INTERFACE
+
+#include <thread>
+#include <vector>
+#include <atomic>
+
+namespace o2
+{
+namespace vertexing
+{
+namespace device
+{
+
+#if !defined(__HIPCC__) && !defined(__CUDACC__)
+typedef struct _dummyStream {
+} Stream;
+#else
+#ifdef __HIPCC__
+typedef hipStream_t Stream;
+#else
+typedef cudaStream_t Stream;
+#endif
+#endif
+
+class GPUInterface
+{
+ public:
+  GPUInterface(GPUInterface& other) = delete;
+  void operator=(const GPUInterface&) = delete;
+
+  static GPUInterface* Instance();
+
+  // APIs
+  void registerBuffer(void*, size_t);
+  void unregisterBuffer(void* addr);
+  void allocDevice(void**, size_t);
+  void freeDevice(void*);
+  Stream& getStream(unsigned short N = 0);
+  Stream& getNextStream();
+
+ protected:
+  GPUInterface(size_t N = 1);
+  ~GPUInterface();
+
+  void resize(size_t);
+
+  std::atomic<unsigned short> mLastUsedStream{0};
+  static GPUInterface* sGPUInterface;
+  std::vector<std::thread> mPool{};
+  std::vector<Stream> mStreams{};
+};
+
+} // namespace device
+} // namespace vertexing
+} // namespace o2
+#endif

Common/DCAFitter/GPU/cuda/CMakeLists.txt

@@ -12,12 +12,15 @@
 o2_add_library(DCAFitterCUDA
                TARGETVARNAME targetName
                SOURCES DCAFitterN.cu
+                       GPUInterface.cu
                PUBLIC_INCLUDE_DIRECTORIES ../../include
+               PUBLIC_INCLUDE_DIRECTORIES ../
                PUBLIC_LINK_LIBRARIES O2::MathUtils
                                      O2::ReconstructionDataFormats
                                      O2::DetectorsBase
                PRIVATE_LINK_LIBRARIES O2::GPUTrackingCUDAExternalProvider)
 set_property(TARGET ${targetName} PROPERTY CUDA_SEPARABLE_COMPILATION ON)
+# add_compile_options(-lineinfo)
 
 o2_add_test(DCAFitterNCUDA
             SOURCES test/testDCAFitterNGPU.cxx