Use HardwareResourcesDescription in ProcessConfiguration

DQM/SiStripMonitorHardware/src/SiStripSpyEventMatcher.cc

@@ -19,7 +19,6 @@
 #include "FWCore/Framework/interface/ProductResolversFactory.h"
 #include "FWCore/ServiceRegistry/interface/ActivityRegistry.h"
 #include "FWCore/Utilities/interface/Exception.h"
-#include "FWCore/Utilities/interface/GetPassID.h"
 #include "FWCore/Version/interface/GetReleaseVersion.h"
 #include "DQM/SiStripMonitorHardware/interface/SiStripSpyUtilities.h"
 #include <algorithm>
@@ -57,8 +56,9 @@ namespace sistrip {
         counterDiffMax_(config.getParameter<uint32_t>("CounterDiffMaxAllowed")),
         productRegistry_(new edm::SignallingProductRegistry),
         source_(constructSource(config.getParameter<edm::ParameterSet>("SpySource"))),
-        processConfiguration_(
-            new edm::ProcessConfiguration(std::string("@MIXING"), edm::getReleaseVersion(), edm::getPassID())),
+        // hardware information is not needed for the "overlay"
+        processConfiguration_(std::make_unique<edm::ProcessConfiguration>(
+            "@MIXING", edm::getReleaseVersion(), edm::HardwareResourcesDescription())),
         eventPrincipal_() {
     // Use the empty parameter set for the parameter set ID of our "@MIXING" process.
     processConfiguration_->setParameterSetID(edm::ParameterSet::emptyParameterSetID());

DQMServices/FwkIO/plugins/DQMRootOutputModule.cc

@@ -528,8 +528,8 @@ void DQMRootOutputModule::startEndFile() {
   processHistoryTree->Branch(kProcessConfigurationParameterSetIDBranch, &parameterSetID);
   std::string releaseVersion;
   processHistoryTree->Branch(kProcessConfigurationReleaseVersion, &releaseVersion);
-  std::string passID;
-  processHistoryTree->Branch(kProcessConfigurationPassID, &passID);
+  std::string hardwareResourcesSerialized;
+  processHistoryTree->Branch(kProcessConfigurationHardwareResources, &hardwareResourcesSerialized);
 
   for (std::vector<edm::ProcessHistoryID>::iterator it = m_seenHistories.begin(), itEnd = m_seenHistories.end();
        it != itEnd;
@@ -542,7 +542,7 @@ void DQMRootOutputModule::startEndFile() {
          ++itPC, ++index) {
       processName = itPC->processName();
       releaseVersion = itPC->releaseVersion();
-      passID = itPC->passID();
+      hardwareResourcesSerialized = itPC->hardwareResourcesDescriptionSerialized();
       parameterSetID = itPC->parameterSetID().compactForm();
       tbb::this_task_arena::isolate([&] { processHistoryTree->Fill(); });
     }

DQMServices/FwkIO/plugins/format.h

@@ -81,7 +81,8 @@ static const char* const kPHIndexBranch = "Index";
 static const char* const kProcessConfigurationProcessNameBranch = "ProcessName";
 static const char* const kProcessConfigurationParameterSetIDBranch = "ParameterSetID";
 static const char* const kProcessConfigurationReleaseVersion = "ReleaseVersion";
-static const char* const kProcessConfigurationPassID = "PassID";
+// misnomer, but kept for backwards (and forwards) compatibility
+static const char* const kProcessConfigurationHardwareResources = "PassID";
 
 static const char* const kParameterSetTree = "ParameterSets";
 static const char* const kParameterSetBranch = "ParameterSetBlob";

DataFormats/Provenance/interface/HardwareResourcesDescription.h

@@ -7,6 +7,15 @@
 #include <vector>
 
 namespace edm {
+  /**
+   * Description of various hardware details stored as part of
+   * ProcessConfiguration
+   *
+   * An object can be serialized as a string. An object with empty
+   * content will be serialized as an empty string (this was a simple
+   * way to preserve backwards (and forwards) compatibility in
+   * ProcessHistory for the ID checksum)
+   */
   struct HardwareResourcesDescription {
     HardwareResourcesDescription() = default;
     explicit HardwareResourcesDescription(std::string_view serialized);

DataFormats/Provenance/interface/ModuleDescription.h

@@ -48,7 +48,6 @@ namespace edm {
 
     std::string const& processName() const;
     std::string const& releaseVersion() const;
-    std::string const& passID() const;
     ParameterSetID const& mainParameterSetID() const;
 
     // compiler-written copy c'tor, assignment, and d'tor are correct.

DataFormats/Provenance/interface/ProcessConfiguration.h

@@ -1,8 +1,8 @@
 #ifndef DataFormats_Provenance_ProcessConfiguration_h
 #define DataFormats_Provenance_ProcessConfiguration_h
 
+#include "DataFormats/Provenance/interface/HardwareResourcesDescription.h"
 #include "DataFormats/Provenance/interface/ParameterSetID.h"
-#include "DataFormats/Provenance/interface/PassID.h"
 #include "DataFormats/Provenance/interface/ProcessConfigurationID.h"
 #include "DataFormats/Provenance/interface/ReleaseVersion.h"
 
@@ -14,18 +14,22 @@ namespace edm {
   class ProcessConfiguration {
   public:
     ProcessConfiguration();
-    ProcessConfiguration(std::string const& procName, ReleaseVersion const& relVersion, PassID const& pass);
+    ProcessConfiguration(std::string const& procName,
+                         ReleaseVersion const& relVersion,
+                         HardwareResourcesDescription const& hwDescription);
 
     ProcessConfiguration(std::string const& procName,
                          ParameterSetID const& pSetID,
                          ReleaseVersion const& relVersion,
-                         PassID const& pass);
+                         HardwareResourcesDescription const& hwDescription);
 
     std::string const& processName() const { return processName_; }
     ParameterSetID const& parameterSetID() const;
     bool isParameterSetValid() const { return parameterSetID_.isValid(); }
     ReleaseVersion const& releaseVersion() const { return releaseVersion_; }
-    PassID const& passID() const { return passID_; }
+    /// Note: this function parses the string on every call, so it should be called rarely
+    HardwareResourcesDescription hardwareResourcesDescription() const { return HardwareResourcesDescription(passID_); }
+    std::string const& hardwareResourcesDescriptionSerialized() const { return passID_; }
     ProcessConfigurationID id() const;
 
     void setParameterSetID(ParameterSetID const& pSetID);
@@ -55,7 +59,12 @@ namespace edm {
     std::string processName_;
     ParameterSetID parameterSetID_;
     ReleaseVersion releaseVersion_;
-    PassID passID_;
+    // The passID_ really holds the HardwareResourcesDescription in a
+    // serialized form. Therefore the passID name is a complete
+    // misnomer, but was kept to make forward-compabitility easier
+    // (even if that not formally not supported, this construct is a
+    // precaution in case a further Run3 use case would surface)
+    std::string passID_;
     Transients transient_;
   };
 
@@ -65,7 +74,8 @@ namespace edm {
 
   inline bool operator==(ProcessConfiguration const& a, ProcessConfiguration const& b) {
     return a.processName() == b.processName() && a.parameterSetID() == b.parameterSetID() &&
-           a.releaseVersion() == b.releaseVersion() && a.passID() == b.passID();
+           a.releaseVersion() == b.releaseVersion() &&
+           a.hardwareResourcesDescriptionSerialized() == b.hardwareResourcesDescriptionSerialized();
   }
 
   inline bool operator!=(ProcessConfiguration const& a, ProcessConfiguration const& b) { return !(a == b); }

DataFormats/Provenance/src/HardwareResourcesDescription.cc

@@ -23,6 +23,8 @@ namespace edm {
   }
 
   std::string HardwareResourcesDescription::serialize() const {
+    if (microarchitecture.empty() and cpuModels.empty() and selectedAccelerators.empty() and gpuModels.empty())
+      return "";
     return edm::compactString::serialize(microarchitecture, cpuModels, selectedAccelerators, gpuModels);
   }
 

DataFormats/Provenance/src/ModuleDescription.cc

@@ -48,8 +48,6 @@ namespace edm {
 
   std::string const& ModuleDescription::releaseVersion() const { return processConfiguration().releaseVersion(); }
 
-  std::string const& ModuleDescription::passID() const { return processConfiguration().passID(); }
-
   ParameterSetID const& ModuleDescription::mainParameterSetID() const {
     return processConfiguration().parameterSetID();
   }
@@ -75,7 +73,8 @@ namespace edm {
       return true;
     if (rh.releaseVersion() < releaseVersion())
       return false;
-    if (passID() < rh.passID())
+    if (processConfiguration().hardwareResourcesDescriptionSerialized() <
+        rh.processConfiguration().hardwareResourcesDescriptionSerialized())
       return true;
     return false;
   }

DataFormats/Provenance/src/ProcessConfiguration.cc

@@ -13,18 +13,21 @@
 
 namespace edm {
 
-  ProcessConfiguration::ProcessConfiguration() : processName_(), parameterSetID_(), releaseVersion_(), passID_() {}
+  ProcessConfiguration::ProcessConfiguration() = default;
 
   ProcessConfiguration::ProcessConfiguration(std::string const& procName,
                                              ParameterSetID const& pSetID,
                                              ReleaseVersion const& relVersion,
-                                             PassID const& pass)
-      : processName_(procName), parameterSetID_(pSetID), releaseVersion_(relVersion), passID_(pass) {}
+                                             HardwareResourcesDescription const& hwDescription)
+      : processName_(procName),
+        parameterSetID_(pSetID),
+        releaseVersion_(relVersion),
+        passID_(hwDescription.serialize()) {}
 
   ProcessConfiguration::ProcessConfiguration(std::string const& procName,
                                              ReleaseVersion const& relVersion,
-                                             PassID const& pass)
-      : processName_(procName), parameterSetID_(), releaseVersion_(relVersion), passID_(pass) {
+                                             HardwareResourcesDescription const& hwDescription)
+      : processName_(procName), parameterSetID_(), releaseVersion_(relVersion), passID_(hwDescription.serialize()) {
     setCurrentProcess();
   }
 
@@ -83,6 +86,7 @@ namespace edm {
       return;
     transient_.pcid_ = ProcessConfigurationID();
     releaseVersion_.erase(iter, iEnd);
+    passID_ = edm::HardwareResourcesDescription().serialize();
   }
 
   bool operator<(ProcessConfiguration const& a, ProcessConfiguration const& b) {
@@ -98,13 +102,14 @@ namespace edm {
       return true;
     if (b.releaseVersion() < a.releaseVersion())
       return false;
-    if (a.passID() < b.passID())
+    if (a.hardwareResourcesDescriptionSerialized() < b.hardwareResourcesDescriptionSerialized())
       return true;
     return false;
   }
 
   std::ostream& operator<<(std::ostream& os, ProcessConfiguration const& pc) {
-    os << pc.processName() << ' ' << pc.parameterSetID() << ' ' << pc.releaseVersion() << ' ' << pc.passID();
+    os << pc.processName() << ' ' << pc.parameterSetID() << ' ' << pc.releaseVersion() << ' '
+       << pc.hardwareResourcesDescription();
     return os;
   }
 }  // namespace edm

DataFormats/Provenance/src/ProcessHistory.cc

@@ -15,8 +15,8 @@ namespace edm {
     // We do not use operator<< because it does not write out everything.
     std::ostringstream oss;
     for (auto const& item : *this) {
-      oss << item.processName() << ' ' << item.parameterSetID() << ' ' << item.releaseVersion() << ' ' << item.passID()
-          << ' ';
+      oss << item.processName() << ' ' << item.parameterSetID() << ' ' << item.releaseVersion() << ' '
+          << item.hardwareResourcesDescriptionSerialized() << ' ';
     }
     std::string stringrep = oss.str();
     cms::Digest md5alg(stringrep);

DataFormats/Provenance/test/HardwareResourcesDescription_t.cpp

@@ -11,6 +11,7 @@ TEST_CASE("HardwareResourcesDescription", "[HardwareResourcesDescription]") {
   SECTION("Default construction") {
     edm::HardwareResourcesDescription resources;
     CHECK(edm::HardwareResourcesDescription(resources.serialize()) == resources);
+    CHECK(resources.serialize().empty());
   }
 
   SECTION("Microarchitecture") {

FWCore/AbstractServices/BuildFile.xml

@@ -1,3 +1,5 @@
+<use name="DataFormats/Provenance"/>
+<use name="FWCore/Utilities"/>
 <export>
   <lib name="1"/>
 </export>

FWCore/AbstractServices/interface/ResourceInformation.h

@@ -13,6 +13,8 @@
 #include <string>
 #include <vector>
 
+#include "DataFormats/Provenance/interface/HardwareResourcesDescription.h"
+
 namespace edm {
 
   class ResourceInformation {
@@ -22,6 +24,8 @@ namespace edm {
     ResourceInformation const& operator=(ResourceInformation const&) = delete;
     virtual ~ResourceInformation();
 
+    virtual HardwareResourcesDescription hardwareResourcesDescription() const = 0;
+
     virtual std::vector<std::string> const& selectedAccelerators() const = 0;
     virtual std::vector<std::string> const& cpuModels() const = 0;
     virtual std::vector<std::string> const& gpuModels() const = 0;

FWCore/Framework/src/ScheduleItems.cc

@@ -19,7 +19,6 @@
 #include "FWCore/ServiceRegistry/interface/Service.h"
 #include "FWCore/ServiceRegistry/interface/ServiceRegistry.h"
 #include "FWCore/Utilities/interface/BranchType.h"
-#include "FWCore/Utilities/interface/GetPassID.h"
 #include "FWCore/Version/interface/GetReleaseVersion.h"
 
 #include <memory>
@@ -120,10 +119,14 @@ namespace edm {
 
   std::shared_ptr<CommonParams> ScheduleItems::initMisc(ParameterSet& parameterSet) {
     edm::Service<edm::ResourceInformation> resourceInformationService;
+    edm::HardwareResourcesDescription hwResources;
     if (resourceInformationService.isAvailable()) {
       auto const& selectedAccelerators =
           parameterSet.getUntrackedParameter<std::vector<std::string>>("@selected_accelerators");
       resourceInformationService->setSelectedAccelerators(selectedAccelerators);
+      // HardwareResourcesDescription is optional here in order to not
+      // require ResourceInformationService in TestProcessor
+      hwResources = resourceInformationService->hardwareResourcesDescription();
     }
 
     act_table_ = std::make_unique<ExceptionToActionTable>(parameterSet);
@@ -136,7 +139,7 @@ namespace edm {
       releaseVersion = getReleaseVersion();
     }
     // propagate_const<T> has no reset() function
-    processConfiguration_ = std::make_shared<ProcessConfiguration>(processName, releaseVersion, getPassID());
+    processConfiguration_ = std::make_shared<ProcessConfiguration>(processName, releaseVersion, hwResources);
     auto common = std::make_shared<CommonParams>(
         parameterSet.getUntrackedParameterSet("maxEvents").getUntrackedParameter<int>("input"),
         parameterSet.getUntrackedParameterSet("maxLuminosityBlocks").getUntrackedParameter<int>("input"),

FWCore/Framework/test/Event_t.cpp

@@ -34,13 +34,11 @@ Test program for edm::Event.
 #include "FWCore/ServiceRegistry/interface/ModuleCallingContext.h"
 #include "FWCore/Utilities/interface/Algorithms.h"
 #include "FWCore/Utilities/interface/EDMException.h"
-#include "FWCore/Utilities/interface/GetPassID.h"
 #include "FWCore/Utilities/interface/GlobalIdentifier.h"
 #include "FWCore/Utilities/interface/InputTag.h"
 #include "FWCore/Utilities/interface/ProductKindOfType.h"
 #include "FWCore/Utilities/interface/TypeID.h"
 #include "FWCore/Reflection/interface/TypeWithDict.h"
-#include "FWCore/Version/interface/GetReleaseVersion.h"
 #include "Utilities/Testing/interface/CppUnit_testdriver.icpp"
 
 #include "cppunit/extensions/HelperMacros.h"
@@ -55,6 +53,8 @@ Test program for edm::Event.
 #include <typeinfo>
 #include <vector>
 
+#include "makeDummyProcessConfiguration.h"
+
 using namespace edm;
 
 // This is a gross hack, to allow us to test the event
@@ -209,7 +209,7 @@ void testEvent::registerProduct(std::string const& tag,
   processParams.template addParameter<ParameterSet>(moduleLabel, moduleParams);
   processParams.registerIt();
 
-  ProcessConfiguration process(processName, processParams.id(), getReleaseVersion(), getPassID());
+  auto process = edmtest::makeDummyProcessConfiguration(processName, processParams.id());
 
   auto processX = std::make_shared<ProcessConfiguration>(process);
   processConfigurations_.push_back(processX);
@@ -352,7 +352,7 @@ testEvent::testEvent()
   processParams.addParameter(moduleLabel, moduleParams);
   processParams.registerIt();
 
-  ProcessConfiguration process(processName, processParams.id(), getReleaseVersion(), getPassID());
+  auto process = edmtest::makeDummyProcessConfiguration(processName, processParams.id());
 
   TypeWithDict product_type(typeid(prod_t));
 
@@ -398,7 +398,7 @@ void testEvent::setUp() {
   processParamsEarly.addParameter(moduleLabelEarly, moduleParamsEarly);
   processParamsEarly.registerIt();
 
-  ProcessConfiguration processEarly("EARLY", processParamsEarly.id(), getReleaseVersion(), getPassID());
+  auto processEarly = edmtest::makeDummyProcessConfiguration("EARLY", processParamsEarly.id());
 
   ParameterSet moduleParamsLate;
   std::string moduleLabelLate("currentModule");
@@ -413,7 +413,7 @@ void testEvent::setUp() {
   processParamsLate.addParameter(moduleLabelLate, moduleParamsLate);
   processParamsLate.registerIt();
 
-  ProcessConfiguration processLate("LATE", processParamsLate.id(), getReleaseVersion(), getPassID());
+  auto processLate = edmtest::makeDummyProcessConfiguration("LATE", processParamsLate.id());
 
   auto processHistory = std::make_unique<ProcessHistory>();
   ProcessHistory& ph = *processHistory;

FWCore/Framework/test/checkForModuleDependencyCorrectness_t.cppunit.cc

@@ -24,6 +24,8 @@
 #include "DataFormats/Provenance/interface/ProcessConfiguration.h"
 #include "cppunit/extensions/HelperMacros.h"
 
+#include "makeDummyProcessConfiguration.h"
+
 namespace edm {
   class ESProducer;
 
@@ -117,7 +119,7 @@ namespace {
     std::unordered_map<std::string, unsigned int> modsToIndex;
     std::unordered_map<unsigned int, std::string> indexToMods;
 
-    const edm::ProcessConfiguration pc("TEST", edm::ParameterSetID{}, "CMSSW_x_y_z", "??");
+    const edm::ProcessConfiguration pc = edmtest::makeDummyProcessConfiguration("TEST");
 
     //In actual configuration building, the source is always assigned id==0
     m_cache.emplace_back(