Merge branch 'AliceO2Group:dev' into onnxruntime-gpu

Author: ChSonnabend

Common/Constants/include/CommonConstants/MathConstants.h

@@ -22,7 +22,8 @@ namespace constants
 {
 namespace math
 {
-constexpr float Almost0 = 1.175494351e-38f;
+constexpr float Almost0 = 0x1.0p-126f;   // smallest non-denormal float
+constexpr float Epsilon = 0x0.000002p0f; // smallest float such that 1 != 1 + Epsilon
 constexpr float Almost1 = 1.f - 1.0e-6f;
 constexpr float VeryBig = 1.f / Almost0;
 

Common/Utils/include/CommonUtils/ConfigurableParam.h

@@ -321,17 +321,19 @@ class ConfigurableParam
 } // end namespace o2
 
 // a helper macro for boilerplate code in parameter classes
-#define O2ParamDef(classname, key)               \
- public:                                         \
-  classname(TRootIOCtor*) {}                     \
-  classname(classname const&) = delete;          \
-                                                 \
- private:                                        \
-  static constexpr char const* const sKey = key; \
-  static classname sInstance;                    \
-  classname() = default;                         \
-  template <typename T>                          \
-  friend class o2::conf::ConfigurableParamHelper;
+#define O2ParamDef(classname, key)                \
+ public:                                          \
+  classname(TRootIOCtor*) {}                      \
+  classname(classname const&) = delete;           \
+                                                  \
+ private:                                         \
+  static constexpr char const* const sKey = key;  \
+  static classname sInstance;                     \
+  classname() = default;                          \
+  template <typename T>                           \
+  friend class o2::conf::ConfigurableParamHelper; \
+  template <typename T, typename P>               \
+  friend class o2::conf::ConfigurableParamPromoter;
 
 // a helper macro to implement necessary symbols in source
 #define O2ParamImpl(classname) classname classname::sInstance;

Common/Utils/include/CommonUtils/ConfigurableParamHelper.h

@@ -45,18 +45,18 @@ class _ParamHelper
 {
  private:
   static std::vector<ParamDataMember>* getDataMembersImpl(std::string const& mainkey, TClass* cl, void*,
-                                                          std::map<std::string, ConfigurableParam::EParamProvenance> const* provmap);
+                                                          std::map<std::string, ConfigurableParam::EParamProvenance> const* provmap, size_t virtualoffset);
 
   static void fillKeyValuesImpl(std::string const& mainkey, TClass* cl, void*, boost::property_tree::ptree*,
                                 std::map<std::string, std::pair<std::type_info const&, void*>>*,
-                                EnumRegistry*);
+                                EnumRegistry*, size_t offset);
 
   static void printWarning(std::type_info const&);
 
   static void assignmentImpl(std::string const& mainkey, TClass* cl, void* to, void* from,
-                             std::map<std::string, ConfigurableParam::EParamProvenance>* provmap);
+                             std::map<std::string, ConfigurableParam::EParamProvenance>* provmap, size_t offset);
   static void syncCCDBandRegistry(std::string const& mainkey, TClass* cl, void* to, void* from,
-                                  std::map<std::string, ConfigurableParam::EParamProvenance>* provmap);
+                                  std::map<std::string, ConfigurableParam::EParamProvenance>* provmap, size_t offset);
 
   static void outputMembersImpl(std::ostream& out, std::string const& mainkey, std::vector<ParamDataMember> const* members, bool showProv, bool useLogger);
   static void printMembersImpl(std::string const& mainkey, std::vector<ParamDataMember> const* members, bool showProv, bool useLogger);
@@ -65,6 +65,9 @@ class _ParamHelper
 
   template <typename P>
   friend class ConfigurableParamHelper;
+
+  template <typename Base, typename P>
+  friend class ConfigurableParamPromoter;
 };
 
 // ----------------------------------------------------------------
@@ -140,7 +143,7 @@ class ConfigurableParamHelper : virtual public ConfigurableParam
       return nullptr;
     }
 
-    return _ParamHelper::getDataMembersImpl(getName(), cl, (void*)this, sValueProvenanceMap);
+    return _ParamHelper::getDataMembersImpl(getName(), cl, (void*)this, sValueProvenanceMap, 0);
   }
 
   // ----------------------------------------------------------------
@@ -153,7 +156,7 @@ class ConfigurableParamHelper : virtual public ConfigurableParam
       _ParamHelper::printWarning(typeid(P));
       return;
     }
-    _ParamHelper::fillKeyValuesImpl(getName(), cl, (void*)this, tree, sKeyToStorageMap, sEnumRegistry);
+    _ParamHelper::fillKeyValuesImpl(getName(), cl, (void*)this, tree, sKeyToStorageMap, sEnumRegistry, 0);
   }
 
   // ----------------------------------------------------------------
@@ -167,7 +170,7 @@ class ConfigurableParamHelper : virtual public ConfigurableParam
     file->GetObject(getName().c_str(), readback);
     if (readback != nullptr) {
       _ParamHelper::assignmentImpl(getName(), TClass::GetClass(typeid(P)), (void*)this, (void*)readback,
-                                   sValueProvenanceMap);
+                                   sValueProvenanceMap, 0);
       delete readback;
     }
     setRegisterMode(true);
@@ -185,7 +188,146 @@ class ConfigurableParamHelper : virtual public ConfigurableParam
     //
     setRegisterMode(false);
     _ParamHelper::syncCCDBandRegistry(getName(), TClass::GetClass(typeid(P)), (void*)this, (void*)externalobj,
-                                      sValueProvenanceMap);
+                                      sValueProvenanceMap, 0);
+    setRegisterMode(true);
+  }
+
+  // ----------------------------------------------------------------
+
+  void serializeTo(TFile* file) const final
+  {
+    file->WriteObjectAny((void*)this, TClass::GetClass(typeid(P)), getName().c_str());
+  }
+};
+
+// Promotes a simple struct Base to a configurable parameter class
+// Aka implements all interfaces for a ConfigurableParam P, which shares or
+// takes the fields from a Base struct
+template <typename P, typename Base>
+class ConfigurableParamPromoter : public Base, virtual public ConfigurableParam
+{
+ public:
+  using ConfigurableParam::ConfigurableParam;
+
+  static const P& Instance()
+  {
+    return P::sInstance;
+  }
+
+  // extracts a copy of the underlying data struct
+  Base detach() const
+  {
+    static_assert(std::copyable<Base>, "Base type must be copyable.");
+    return static_cast<Base>(*this);
+  }
+
+  // ----------------------------------------------------------------
+  std::string getName() const final
+  {
+    return P::sKey;
+  }
+
+  // ----------------------------------------------------------------
+  // get the provenace of the member with given key
+  EParamProvenance getMemberProvenance(const std::string& key) const final
+  {
+    return getProvenance(getName() + '.' + key);
+  }
+
+  // ----------------------------------------------------------------
+
+  // one of the key methods, using introspection to print itself
+  void printKeyValues(bool showProv = true, bool useLogger = false) const final
+  {
+    if (!isInitialized()) {
+      initialize();
+    }
+    auto members = getDataMembers();
+    _ParamHelper::printMembersImpl(getName(), members, showProv, useLogger);
+  }
+
+  //
+  size_t getHash() const final
+  {
+    return _ParamHelper::getHashImpl(getName(), getDataMembers());
+  }
+
+  // ----------------------------------------------------------------
+
+  void output(std::ostream& out) const final
+  {
+    auto members = getDataMembers();
+    _ParamHelper::outputMembersImpl(out, getName(), members, true, false);
+  }
+
+  // ----------------------------------------------------------------
+
+  // Grab the list of ConfigurableParam data members
+  // Returns a nullptr if the TClass of the P template class cannot be created.
+  std::vector<ParamDataMember>* getDataMembers() const
+  {
+    // just a helper line to make sure P::sInstance is looked-up
+    // and that compiler complains about missing static sInstance of type P
+    // volatile void* ptr = (void*)&P::sInstance;
+    // static assert on type of sInstance:
+    static_assert(std::is_same<decltype(P::sInstance), P>::value,
+                  "static instance must of same type as class");
+
+    // obtain the TClass for the Base type and delegate further
+    auto cl = TClass::GetClass(typeid(Base));
+    if (!cl) {
+      _ParamHelper::printWarning(typeid(Base));
+      return nullptr;
+    }
+
+    // we need to put an offset of 8 bytes since internally this is using data members of the Base class
+    // which doesn't account for the virtual table of P
+    return _ParamHelper::getDataMembersImpl(getName(), cl, (void*)this, sValueProvenanceMap, 8);
+  }
+
+  // ----------------------------------------------------------------
+
+  // fills the data structures with the initial default values
+  void putKeyValues(boost::property_tree::ptree* tree) final
+  {
+    auto cl = TClass::GetClass(typeid(Base));
+    if (!cl) {
+      _ParamHelper::printWarning(typeid(Base));
+      return;
+    }
+    _ParamHelper::fillKeyValuesImpl(getName(), cl, (void*)this, tree, sKeyToStorageMap, sEnumRegistry, 8);
+  }
+
+  // ----------------------------------------------------------------
+
+  void initFrom(TFile* file) final
+  {
+    // switch off auto registering since the readback object is
+    // only a "temporary" singleton
+    setRegisterMode(false);
+    P* readback = nullptr;
+    file->GetObject(getName().c_str(), readback);
+    if (readback != nullptr) {
+      _ParamHelper::assignmentImpl(getName(), TClass::GetClass(typeid(Base)), (void*)this, (void*)readback,
+                                   sValueProvenanceMap, 8);
+      delete readback;
+    }
+    setRegisterMode(true);
+  }
+
+  // ----------------------------------------------------------------
+
+  void syncCCDBandRegistry(void* externalobj) final
+  {
+    // We may be getting an external copy from CCDB which is passed as externalobj.
+    // The task of this function is to
+    // a) update the internal registry with fields coming from CCDB
+    //    but only if keys have not been modified via RT == command line / ini file
+    // b) update the external object with with fields having RT provenance
+    //
+    setRegisterMode(false);
+    _ParamHelper::syncCCDBandRegistry(getName(), TClass::GetClass(typeid(Base)), (void*)this, (void*)externalobj,
+                                      sValueProvenanceMap, 8);
     setRegisterMode(true);
   }
 

Common/Utils/src/ConfigurableParamHelper.cxx

@@ -182,19 +182,19 @@ std::string asString(TDataMember const& dm, char* pointer)
   // potentially other cases to be added here
 
   LOG(error) << "COULD NOT REPRESENT AS STRING";
-  return nullptr;
+  return std::string();
 }
 
 // ----------------------------------------------------------------------
 
 std::vector<ParamDataMember>* _ParamHelper::getDataMembersImpl(std::string const& mainkey, TClass* cl, void* obj,
-                                                               std::map<std::string, ConfigurableParam::EParamProvenance> const* provmap)
+                                                               std::map<std::string, ConfigurableParam::EParamProvenance> const* provmap, size_t globaloffset)
 {
   std::vector<ParamDataMember>* members = new std::vector<ParamDataMember>;
 
-  auto toDataMember = [&members, obj, mainkey, provmap](const TDataMember* dm, int index, int size) {
+  auto toDataMember = [&members, obj, mainkey, provmap, globaloffset](const TDataMember* dm, int index, int size) {
     auto TS = getSizeOfUnderlyingType(*dm);
-    char* pointer = ((char*)obj) + dm->GetOffset() + index * TS;
+    char* pointer = ((char*)obj) + dm->GetOffset() + index * TS + globaloffset;
     const std::string name = getName(dm, index, size);
     auto value = asString(*dm, pointer);
 
@@ -280,14 +280,14 @@ std::type_info const& nameToTypeInfo(const char* tname, TDataType const* dt)
 
 void _ParamHelper::fillKeyValuesImpl(std::string const& mainkey, TClass* cl, void* obj, boost::property_tree::ptree* tree,
                                      std::map<std::string, std::pair<std::type_info const&, void*>>* keytostoragemap,
-                                     EnumRegistry* enumRegistry)
+                                     EnumRegistry* enumRegistry, size_t globaloffset)
 {
   boost::property_tree::ptree localtree;
-  auto fillMap = [obj, &mainkey, &localtree, &keytostoragemap, &enumRegistry](const TDataMember* dm, int index, int size) {
+  auto fillMap = [obj, &mainkey, &localtree, &keytostoragemap, &enumRegistry, globaloffset](const TDataMember* dm, int index, int size) {
     const auto name = getName(dm, index, size);
     auto dt = dm->GetDataType();
     auto TS = getSizeOfUnderlyingType(*dm);
-    char* pointer = ((char*)obj) + dm->GetOffset() + index * TS;
+    char* pointer = ((char*)obj) + dm->GetOffset() + index * TS + globaloffset;
     localtree.put(name, asString(*dm, pointer));
 
     auto key = mainkey + "." + name;
@@ -355,14 +355,14 @@ bool isMemblockDifferent(char const* block1, char const* block2, int sizeinbytes
 // ----------------------------------------------------------------------
 
 void _ParamHelper::assignmentImpl(std::string const& mainkey, TClass* cl, void* to, void* from,
-                                  std::map<std::string, ConfigurableParam::EParamProvenance>* provmap)
+                                  std::map<std::string, ConfigurableParam::EParamProvenance>* provmap, size_t globaloffset)
 {
-  auto assignifchanged = [to, from, &mainkey, provmap](const TDataMember* dm, int index, int size) {
+  auto assignifchanged = [to, from, &mainkey, provmap, globaloffset](const TDataMember* dm, int index, int size) {
     const auto name = getName(dm, index, size);
     auto dt = dm->GetDataType();
     auto TS = getSizeOfUnderlyingType(*dm);
-    char* pointerto = ((char*)to) + dm->GetOffset() + index * TS;
-    char* pointerfrom = ((char*)from) + dm->GetOffset() + index * TS;
+    char* pointerto = ((char*)to) + dm->GetOffset() + index * TS + globaloffset;
+    char* pointerfrom = ((char*)from) + dm->GetOffset() + index * TS + globaloffset;
 
     // lambda to update the provenance
     auto updateProv = [&mainkey, name, provmap]() {
@@ -402,14 +402,14 @@ void _ParamHelper::assignmentImpl(std::string const& mainkey, TClass* cl, void*
 // ----------------------------------------------------------------------
 
 void _ParamHelper::syncCCDBandRegistry(const std::string& mainkey, TClass* cl, void* to, void* from,
-                                       std::map<std::string, ConfigurableParam::EParamProvenance>* provmap)
+                                       std::map<std::string, ConfigurableParam::EParamProvenance>* provmap, size_t globaloffset)
 {
-  auto sync = [to, from, &mainkey, provmap](const TDataMember* dm, int index, int size) {
+  auto sync = [to, from, &mainkey, provmap, globaloffset](const TDataMember* dm, int index, int size) {
     const auto name = getName(dm, index, size);
     auto dt = dm->GetDataType();
     auto TS = getSizeOfUnderlyingType(*dm);
-    char* pointerto = ((char*)to) + dm->GetOffset() + index * TS;
-    char* pointerfrom = ((char*)from) + dm->GetOffset() + index * TS;
+    char* pointerto = ((char*)to) + dm->GetOffset() + index * TS + globaloffset;
+    char* pointerfrom = ((char*)from) + dm->GetOffset() + index * TS + globaloffset;
 
     // check current provenance
     auto key = mainkey + "." + name;

DataFormats/Detectors/CTP/include/DataFormatsCTP/TriggerOffsetsParam.h

@@ -24,9 +24,10 @@ namespace ctp
 struct TriggerOffsetsParam : public o2::conf::ConfigurableParamHelper<TriggerOffsetsParam> {
   static constexpr int MaxNDet = 32; // take with margin to account for possible changes / upgrades
   int64_t LM_L0 = 15;
-  int64_t L0_L1 = 280;
+  int64_t L0_L1 = 281;           // trigger input latency
   int64_t globalInputsShift = 0; // Global shift of inps; customOffset[CTP] is global shift of classes
   int64_t customOffset[MaxNDet] = {};
+  int64_t L0_L1_classes = 280;                            // trigger input latency
   O2ParamDef(TriggerOffsetsParam, "TriggerOffsetsParam"); // boilerplate stuff + make principal key
 };
 } // namespace ctp

DataFormats/Detectors/TPC/CMakeLists.txt

@@ -63,7 +63,8 @@ o2_target_root_dictionary(
           include/DataFormatsTPC/VDriftCorrFact.h
           include/DataFormatsTPC/CalibdEdxCorrection.h
           include/DataFormatsTPC/BetheBlochAleph.h
-          include/DataFormatsTPC/PIDResponse.h)
+          include/DataFormatsTPC/PIDResponse.h
+          include/DataFormatsTPC/AltroSyncSignal.h)
 
 o2_add_test(
   ClusterNative

DataFormats/Detectors/TPC/include/DataFormatsTPC/AltroSyncSignal.h

@@ -0,0 +1,30 @@
+// 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.
+
+/// \file AltroSyncSignal.h
+/// \brief Definition of the timebin from which syncronization starts
+
+#include "GPUCommonRtypes.h"
+
+namespace o2::tpc
+{
+struct AltroSyncSignal {
+  int periodTF = 10;     // signal repeats every period-th TF
+  int timebin = 14192;   // every 10 TF, orbit 31, Time bin 384, BC 4 -> 14195, but clusters can be affected before that
+
+  int getTB2Cut(uint32_t tfCounter) const
+  {
+    return periodTF > 0 && (tfCounter % periodTF) == 1 && tfCounter > periodTF ? timebin : -1;
+  }
+
+  ClassDefNV(AltroSyncSignal, 1);
+};
+} // namespace o2::tpc

DataFormats/Detectors/TPC/include/DataFormatsTPC/CompressedClusters.h

@@ -29,7 +29,7 @@ struct CompressedClustersCounters {
   unsigned int nUnattachedClusters = 0;
   unsigned int nAttachedClustersReduced = 0;
   unsigned int nSliceRows = 36 * 152;
-  unsigned char nComppressionModes = 0;
+  unsigned char nComppressionModes = 0; // Don't fix this name due to ROOT dictionaries!
   float solenoidBz = -1e6f;
   int maxTimeBin = -1e6;
 

DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h

@@ -73,5 +73,6 @@
 #pragma link C++ class o2::tpc::TriggerWordDLBZS + ;
 #pragma link C++ class o2::tpc::TriggerInfoDLBZS + ;
 #pragma link C++ class std::vector < o2::tpc::TriggerInfoDLBZS> + ;
+#pragma link C++ class o2::tpc::AltroSyncSignal + ;
 
 #endif