Merge branch 'dev' into streamline-spawner

Author: aalkin

Common/ML/include/ML/OrtInterface.h

@@ -45,14 +45,10 @@ class OrtModel
 
  public:
   // Constructors & destructors
-  OrtModel() = default;
-  OrtModel(std::unordered_map<std::string, std::string> optionsMap) { init(optionsMap); }
-  void init(std::unordered_map<std::string, std::string> optionsMap)
-  {
-    initOptions(optionsMap);
-    initEnvironment();
-  }
-  virtual ~OrtModel() = default;
+  OrtModel();
+  OrtModel(std::unordered_map<std::string, std::string> optionsMap);
+  void init(std::unordered_map<std::string, std::string> optionsMap);
+  virtual ~OrtModel();
 
   // General purpose
   void initOptions(std::unordered_map<std::string, std::string> optionsMap);
@@ -113,7 +109,7 @@ class OrtModel
  private:
   // ORT variables -> need to be hidden as pImpl
   struct OrtVariables;
-  OrtVariables* mPImplOrt;
+  std::unique_ptr<OrtVariables> mPImplOrt;
 
   // Input & Output specifications of the loaded network
   std::vector<const char*> mInputNamesChar, mOutputNamesChar;

Common/ML/src/OrtInterface.cxx

@@ -27,11 +27,20 @@ namespace o2
 namespace ml
 {
 
+OrtModel::OrtModel() = default;
+OrtModel::OrtModel(std::unordered_map<std::string, std::string> optionsMap) { init(optionsMap); }
+OrtModel::~OrtModel() = default;
+void OrtModel::init(std::unordered_map<std::string, std::string> optionsMap)
+{
+  initOptions(optionsMap);
+  initEnvironment();
+}
+
 struct OrtModel::OrtVariables { // The actual implementation is hidden in the .cxx file
   // ORT runtime objects
   Ort::RunOptions runOptions;
-  std::shared_ptr<Ort::Env> env = nullptr;
-  std::shared_ptr<Ort::Session> session = nullptr; ///< ONNX session
+  std::unique_ptr<Ort::Env> env = nullptr;
+  std::unique_ptr<Ort::Session> session = nullptr; ///< ONNX session
   Ort::SessionOptions sessionOptions;
   Ort::AllocatorWithDefaultOptions allocator;
   Ort::MemoryInfo memoryInfo = Ort::MemoryInfo("Cpu", OrtAllocatorType::OrtDeviceAllocator, 0, OrtMemType::OrtMemTypeDefault);
@@ -41,7 +50,7 @@ struct OrtModel::OrtVariables { // The actual implementation is hidden in the .c
 // General purpose
 void OrtModel::initOptions(std::unordered_map<std::string, std::string> optionsMap)
 {
-  mPImplOrt = new OrtVariables();
+  mPImplOrt = std::make_unique<OrtVariables>();
 
   // Load from options map
   if (!optionsMap.contains("model-path")) {
@@ -101,7 +110,7 @@ void OrtModel::initOptions(std::unordered_map<std::string, std::string> optionsM
 
 void OrtModel::initEnvironment()
 {
-  mPImplOrt->env = std::make_shared<Ort::Env>(
+  mPImplOrt->env = std::make_unique<Ort::Env>(
     OrtLoggingLevel(mLoggingLevel),
     (mEnvName.empty() ? "ORT" : mEnvName.c_str()),
     // Integrate ORT logging into Fairlogger
@@ -129,7 +138,7 @@ void OrtModel::initSession()
   if (mAllocateDeviceMemory) {
     memoryOnDevice(mDeviceId);
   }
-  mPImplOrt->session = std::make_shared<Ort::Session>(*mPImplOrt->env, mModelPath.c_str(), mPImplOrt->sessionOptions);
+  mPImplOrt->session = std::make_unique<Ort::Session>(*mPImplOrt->env, mModelPath.c_str(), mPImplOrt->sessionOptions);
   mPImplOrt->ioBinding = std::make_unique<Ort::IoBinding>(*mPImplOrt->session);
 
   setIO();
@@ -147,12 +156,12 @@ void OrtModel::memoryOnDevice(int32_t deviceIndex)
     (mPImplOrt->sessionOptions).AddConfigEntry("session.use_env_allocators", "1");                    // This should enable to use the volatile memory allocation defined in O2/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx; not working yet: ONNX still assigns new memory at init time
     (mPImplOrt->sessionOptions).AddConfigEntry("session_options.enable_cpu_mem_arena", "0");          // This should enable to use the volatile memory allocation defined in O2/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx; not working yet: ONNX still assigns new memory at init time
     // Arena memory shrinkage comes at performance cost
-    /// For now prefer to use single allocation, enabled by O2/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu -> SetONNXGPUStream -> rocm_options.arena_extend_strategy = 0;
-    // (mPImplOrt->runOptions).AddConfigEntry("memory.enable_memory_arena_shrinkage", ("gpu:" + std::to_string(deviceIndex)).c_str()); // See kOrtRunOptionsConfigEnableMemoryArenaShrinkage, https://github.com/microsoft/onnxruntime/blob/90c263f471bbce724e77d8e62831d3a9fa838b2f/include/onnxruntime/core/session/onnxruntime_run_options_config_keys.h#L27
+    // For now prefer to use single allocation, enabled by O2/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu -> SetONNXGPUStream -> rocm_options.arena_extend_strategy = 0;
+    (mPImplOrt->runOptions).AddConfigEntry("memory.enable_memory_arena_shrinkage", ("gpu:" + std::to_string(deviceIndex)).c_str()); // See kOrtRunOptionsConfigEnableMemoryArenaShrinkage, https://github.com/microsoft/onnxruntime/blob/90c263f471bbce724e77d8e62831d3a9fa838b2f/include/onnxruntime/core/session/onnxruntime_run_options_config_keys.h#L27
 
     std::string dev_mem_str = "";
     if (mDeviceType == "ROCM") {
-      dev_mem_str = "Hip";
+      dev_mem_str = "HipPinned";
     }
     if (mDeviceType == "CUDA") {
       dev_mem_str = "Cuda";
@@ -166,7 +175,7 @@ void OrtModel::memoryOnDevice(int32_t deviceIndex)
 
 void OrtModel::resetSession()
 {
-  mPImplOrt->session = std::make_shared<Ort::Session>(*(mPImplOrt->env), mModelPath.c_str(), mPImplOrt->sessionOptions);
+  mPImplOrt->session = std::make_unique<Ort::Session>(*(mPImplOrt->env), mModelPath.c_str(), mPImplOrt->sessionOptions);
 }
 
 // Getters
@@ -252,7 +261,7 @@ void OrtModel::setIO()
 
 void OrtModel::setEnv(Ort::Env* env)
 {
-  mPImplOrt->env = std::shared_ptr<Ort::Env>(env);
+  mPImplOrt->env.reset(env);
 }
 
 // Inference
@@ -308,6 +317,14 @@ void OrtModel::inference(I* input, int64_t input_size, O* output)
   (mPImplOrt->ioBinding)->BindOutput(mOutputNames[0].c_str(), outputTensor);
 
   (mPImplOrt->session)->Run(mPImplOrt->runOptions, *mPImplOrt->ioBinding);
+  // mPImplOrt->session->Run(
+  //   mPImplOrt->runOptions,
+  //   mInputNamesChar.data(),
+  //   &inputTensor,
+  //   mInputNamesChar.size(),
+  //   mOutputNamesChar.data(),
+  //   &outputTensor,
+  //   mOutputNamesChar.size());
 }
 
 template void OrtModel::inference<OrtDataType::Float16_t, OrtDataType::Float16_t>(OrtDataType::Float16_t*, int64_t, OrtDataType::Float16_t*);
@@ -427,10 +444,7 @@ template std::vector<OrtDataType::Float16_t> OrtModel::inference<OrtDataType::Fl
 // Release session
 void OrtModel::release(bool profilingEnabled)
 {
-  // if (profilingEnabled) {
-  //   mPImplOrt->session->EndProfiling();
-  // }
-  LOG(info) << "(ORT) Size of mPImplOrt: " << sizeof(*mPImplOrt) << " bytes";
+  mPImplOrt.reset();
 }
 
 // private

DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/AlignParam.h

@@ -37,9 +37,12 @@ class AlignParam
   AlignParam(const char* symname, int algID,       // volume symbolic name and its alignable ID
              double x, double y, double z,         // delta translation
              double psi, double theta, double phi, // delta rotation
-             bool global = true);                  // global (preferable) or local delta definition
+             bool global = true,                   // global (preferable) or local delta definition
+             bool convertLocalToGlobal = true);    // if local is provided, convert it to global
 
-  AlignParam(const char* symname, int algID, TGeoMatrix& m, bool global = true);
+  AlignParam(const char* symname, int algID, TGeoMatrix& m,
+             bool global = true,                // global (preferable) or local delta definition
+             bool convertLocalToGlobal = true); // if local is provided, convert it to global
 
   /// return symbolic name of the volume
   const std::string& getSymName() const { return mSymName; }
@@ -70,6 +73,9 @@ class AlignParam
   void setAlignableID(int id) { mAlignableID = id; }
   /// ================ methods for direct setting of delta params
 
+  /// set parameters
+  void setParams(double x, double y, double z, double psi, double theta, double phi);
+
   /// set parameters of global delta
   void setGlobalParams(double x, double y, double z, double psi, double theta, double phi);
 
@@ -114,6 +120,9 @@ class AlignParam
 
   int rectify(double zero = 1e-13);
 
+  bool isGlobal() const { return mIsGlobal; }
+  void setIsGlobal(bool v) { mIsGlobal = v; }
+
  protected:
   bool matrixToAngles(const double* rot, double& psi, double& theta, double& phi) const;
   void anglesToMatrix(double psi, double theta, double phi, double* rot) const;
@@ -123,8 +132,8 @@ class AlignParam
  private:
   std::string mSymName{};
 
+  bool mIsGlobal = true; /// is this global delta?
   int mAlignableID = -1; /// alignable ID (set for sensors only)
-
   double mX = 0.; ///< X translation of global delta
   double mY = 0.; ///< Y translation of global delta
   double mZ = 0.; ///< Z translation of global delta
@@ -133,7 +142,7 @@ class AlignParam
   double mTheta = 0.; ///< "roll"  : Euler angle of rotation around Y axis after 1st rotation (radians)
   double mPhi = 0.;   ///< "yaw"   : Euler angle of rotation around Z axis (radians)
 
-  ClassDefNV(AlignParam, 1);
+  ClassDefNV(AlignParam, 2);
 };
 
 } // namespace detectors

DataFormats/Detectors/Common/src/AlignParam.cxx

@@ -26,32 +26,32 @@ using namespace o2::detectors;
 AlignParam::AlignParam(const char* symname, int algID,       // volume symbolic name and its alignable ID
                        double x, double y, double z,         // delta translation
                        double psi, double theta, double phi, // delta rotation
-                       bool global)                          // global (preferable) or local delta definition
-  : mSymName(symname), mAlignableID(algID)
+                       bool global,                          // global (preferable) or local delta definition
+                       bool convertLocalToGlobal)            // if local is provided, convert it to global
+  : mSymName(symname), mIsGlobal(global || convertLocalToGlobal), mAlignableID(algID)
 {
   /// standard constructor with 3 translation + 3 rotation parameters
   /// If the user explicitly sets the global variable to false then the
   /// parameters are interpreted as giving the local transformation.
   /// This requires to have a gGeoMenager active instance, otherwise the
   /// constructor will fail (no object created)
 
-  if (global) {
-    setGlobalParams(x, y, z, psi, theta, phi);
-  } else {
+  setParams(x, y, z, psi, theta, phi);
+  if (!global && convertLocalToGlobal) {
     setLocalParams(x, y, z, psi, theta, phi);
   }
 }
 
 //___________________________________________________
-AlignParam::AlignParam(const char* symname, int algID, TGeoMatrix& m, bool global)
-  : mSymName(symname), mAlignableID(algID)
+AlignParam::AlignParam(const char* symname, int algID, TGeoMatrix& m, bool global, bool convertLocalToGlobal)
+  : mSymName(symname), mIsGlobal(global || convertLocalToGlobal), mAlignableID(algID)
 {
   setTranslation(m);
   if (!setRotation(m)) {
     const double* rot = m.GetRotationMatrix();
     throw std::runtime_error(fmt::format("Failed to extract roll-pitch-yall angles from [[{},{},{}], [{},{},{}], [{},{},{}] for {}", rot[0], rot[1], rot[2], rot[3], rot[4], rot[5], rot[6], rot[7], rot[8], symname));
   }
-  if (!global && !setLocalParams(mX, mY, mZ, mPsi, mTheta, mPhi)) {
+  if (!global && convertLocalToGlobal && !setLocalParams(mX, mY, mZ, mPsi, mTheta, mPhi)) {
     throw std::runtime_error(fmt::format("Alignment creation for {} failed: geomManager is absent", symname));
   }
 }
@@ -223,6 +223,10 @@ bool AlignParam::createLocalMatrix(TGeoHMatrix& m) const
   // In case that the TGeo was not initialized or not closed,
   // returns false and the object parameters are not set.
   //
+  m = createMatrix();
+  if (!mIsGlobal) {
+    return true;
+  }
   if (!gGeoManager || !gGeoManager->IsClosed()) {
     LOG(error) << "Can't get the local alignment object parameters! gGeoManager doesn't exist or it is still open!";
     return false;
@@ -247,7 +251,6 @@ bool AlignParam::createLocalMatrix(TGeoHMatrix& m) const
     LOG(error) << "Volume name or path " << symname << " is not valid!";
     return false;
   }
-  m = createMatrix();
   TGeoHMatrix gprime, gprimeinv;
   gprime = *node->GetMatrix();
   gprimeinv = gprime.Inverse();
@@ -302,18 +305,15 @@ bool AlignParam::applyToGeometry() const
   }
 
   //  double threshold = 0.001;
-
-  TGeoHMatrix gprime = *node->GetMatrix();
-  TGeoHMatrix align = createMatrix();
-  gprime.MultiplyLeft(&align);
-  TGeoHMatrix* ginv = new TGeoHMatrix; // TGeoPhysicalNode takes and manages raw pointer, need naked new!
-  TGeoHMatrix* g = node->GetMatrix(node->GetLevel() - 1);
-  *ginv = g->Inverse();
-  *ginv *= gprime;
-
+  TGeoHMatrix* align = new TGeoHMatrix(createMatrix());
+  if (mIsGlobal) {
+    align->Multiply(node->GetMatrix());
+    TGeoHMatrix* g = node->GetMatrix(node->GetLevel() - 1);
+    align->MultiplyLeft(node->GetMatrix(node->GetLevel() - 1)->Inverse());
+  }
   LOG(debug) << "Aligning volume " << symname;
 
-  node->Align(ginv);
+  node->Align(align);
 
   return true;
 }
@@ -359,6 +359,14 @@ void AlignParam::setGlobalParams(double x, double y, double z, double psi, doubl
   setRotation(psi, theta, phi);
 }
 
+//_____________________________________________________________________________
+void AlignParam::setParams(double x, double y, double z, double psi, double theta, double phi)
+{
+  /// set parameters of global delta
+  setTranslation(x, y, z);
+  setRotation(psi, theta, phi);
+}
+
 //_____________________________________________________________________________
 void AlignParam::setRotation(double psi, double theta, double phi)
 {

Detectors/ITSMFT/common/reconstruction/src/RUDecodeData.cxx

@@ -125,7 +125,7 @@ bool RUDecodeData::checkLinkInSync(int icab, const o2::InteractionRecord ir)
     link->statistics.errorCounts[GBTLinkDecodingStat::ErrOldROF]++;
     linkHBFToDump[(uint64_t(link->subSpec) << 32) + link->hbfEntry] = link->irHBF.orbit;
     if (link->needToPrintError(link->statistics.errorCounts[GBTLinkDecodingStat::ErrOldROF]) && !ROFRampUpStage) {
-      LOGP(error, "{} (cable {}) has IR={} for current majority IR={} -> {}", link->describe(),
+      LOGP(critical, "{} (cable {}) has IR={} for current majority IR={} -> {}", link->describe(),
            cableHWID[icab], link->ir.asString(), ir.asString(), link->statistics.ErrNames[GBTLinkDecodingStat::ErrOldROF]);
     }
 #endif

Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx

@@ -202,7 +202,7 @@ void STFDecoder<Mapping>::run(ProcessingContext& pc)
     if ((expectedTFSize != nTriggersProcessed) && mROFErrRepIntervalMS > 0 && mTFCounter > 1 && nTriggersProcessed > 0) {
       long currTS = std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
       if (currTS - lastErrReportTS > mROFErrRepIntervalMS) {
-        LOGP(error, "Inconsistent number of ROF per TF. From parameters: {} from readout: {} (muting further reporting for {} ms)", expectedTFSize, nTriggersProcessed, mROFErrRepIntervalMS);
+        LOGP(critical, "Inconsistent number of ROF per TF. From parameters: {} from readout: {} (muting further reporting for {} ms)", expectedTFSize, nTriggersProcessed, mROFErrRepIntervalMS);
         lastErrReportTS = currTS;
       }
     }

Detectors/Vertexing/include/DetectorsVertexing/SVertexHypothesis.h

@@ -60,7 +60,7 @@ class SVertexHypothesis
 
   bool check(float p2Pos, float p2Neg, float p2V0, float ptV0) const
   { // check if given mass and pt is matching to hypothesis
-    return check(calcMass(p2Pos, p2Neg, p2V0), ptV0);
+    return mPars[SigmaM] > 0 && check(calcMass(p2Pos, p2Neg, p2V0), ptV0);
   }
   bool check(float mass, float pt) const
   { // check if given mass and pt is matching to hypothesis
@@ -151,7 +151,7 @@ class SVertex3Hypothesis
 
   bool check(float p2Pos, float p2Neg, float p2Bach, float p2Tot, float ptV0) const
   { // check if given mass and pt is matching to hypothesis
-    return check(calcMass(p2Pos, p2Neg, p2Bach, p2Tot), ptV0);
+    return mPars[SigmaM] > 0 && check(calcMass(p2Pos, p2Neg, p2Bach, p2Tot), ptV0);
   }
 
   bool check(float mass, float pt) const