Introduce TritonService and workflows

Configuration/ProcessModifiers/python/allSonicTriton_cff.py

@@ -0,0 +1,6 @@
+import FWCore.ParameterSet.Config as cms
+
+from Configuration.ProcessModifiers.enableSonicTriton_cff import enableSonicTriton
+
+# collect all SonicTriton-related process modifiers here
+allSonicTriton = cms.ModifierChain(enableSonicTriton)

Configuration/ProcessModifiers/python/enableSonicTriton_cff.py

@@ -0,0 +1,3 @@
+import FWCore.ParameterSet.Config as cms
+
+enableSonicTriton = cms.Modifier()

Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py

@@ -919,6 +919,41 @@ def condition(self, fragment, stepList, key, hasHarvest):
 )
 upgradeWFs['DD4hep'].allowReuse = False
 
+class UpgradeWorkflow_SonicTriton(UpgradeWorkflow):
+    def setup_(self, step, stepName, stepDict, k, properties):
+        stepDict[stepName][k] = merge([{'--procModifiers': 'allSonicTriton'}, stepDict[step][k]])
+    def condition(self, fragment, stepList, key, hasHarvest):
+        return (fragment=='TTbar_13' and '2021' in key) \
+            or (fragment=='TTbar_14TeV' and '2026' in key)
+upgradeWFs['SonicTriton'] = UpgradeWorkflow_SonicTriton(
+    steps = [
+        'GenSim',
+        'GenSimHLBeamSpot',
+        'GenSimHLBeamSpot14',
+        'Digi',
+        'DigiTrigger',
+        'Reco',
+        'RecoGlobal',
+        'HARVEST',
+        'HARVESTGlobal',
+        'ALCA',
+    ],
+    PU = [
+        'GenSim',
+        'GenSimHLBeamSpot',
+        'GenSimHLBeamSpot14',
+        'Digi',
+        'DigiTrigger',
+        'Reco',
+        'RecoGlobal',
+        'HARVEST',
+        'HARVESTGlobal',
+        'ALCA',
+    ],
+    suffix = '_SonicTriton',
+    offset = 0.9001,
+)
+
 # check for duplicate offsets
 offsets = [specialWF.offset for specialType,specialWF in six.iteritems(upgradeWFs)]
 seen = set()

Configuration/StandardSequences/python/Services_cff.py

@@ -14,3 +14,9 @@ def _addCUDAServices(process):
 
 from Configuration.ProcessModifiers.gpu_cff import gpu
 modifyConfigurationStandardSequencesServicesAddCUDAServices_ = gpu.makeProcessModifier(_addCUDAServices)
+
+# load TritonService when SONIC workflow is enabled
+def _addTritonService(process):
+	process.load("HeterogeneousCore.SonicTriton.TritonService_cff")
+from Configuration.ProcessModifiers.enableSonicTriton_cff import enableSonicTriton
+modifyConfigurationStandardSequencesServicesAddTritonService_ = enableSonicTriton.makeProcessModifier(_addTritonService)

HeterogeneousCore/SonicCore/README.md

@@ -15,9 +15,8 @@ To implement a concrete derived producer class, the following skeleton can be us
 class MyProducer : public SonicEDProducer<Client>
 {
 public:
-  explicit MyProducer(edm::ParameterSet const& cfg) : SonicEDProducer<Client>(cfg) {
-    //for debugging
-    setDebugName("MyProducer");
+  explicit MyProducer(edm::ParameterSet const& cfg) : SonicEDProducer<Client>(cfg, "MyProducer") {
+    //do any necessary operations
   }
   void acquire(edm::Event const& iEvent, edm::EventSetup const& iSetup, Input& iInput) override {
     //convert event data to client input format
@@ -65,7 +64,7 @@ To add a new communication protocol for SONIC, follow these steps:
 2. Set up the concrete client(s) that use the communication protocol in a new package in the `HeterogeneousCore` subsystem
 3. Add a test producer (see above) to make sure it works
 
-To implement a concrete client, the following skeleton can be used for the `.h` file, with the function implementations in an associated `.cc` file:
+To implement a concrete client, the following skeleton can be used for the `.h` file:
 ```cpp
 #ifndef HeterogeneousCore_MyPackage_MyClient
 #define HeterogeneousCore_MyPackage_MyClient
@@ -75,7 +74,7 @@ To implement a concrete client, the following skeleton can be used for the `.h`
 
 class MyClient : public SonicClient<Input,Output> {
 public:
-  MyClient(const edm::ParameterSet& params);
+  MyClient(const edm::ParameterSet& params, const std::string& debugName);
 
   static void fillPSetDescription(edm::ParameterSetDescription& iDesc);
 
@@ -86,6 +85,14 @@ protected:
 #endif
 ```
 
+The concrete client member function implementations, in an associated `.cc` file, should include the following:
+```cpp
+MyClient::MyClient(const edm::ParameterSet& params, const std::string& debugName)
+    : SonicClient(params, debugName, "MyClient") {
+  //do any necessary operations
+}
+```
+
 The `SonicClient` has three available modes:
 * `Sync`: synchronous call, blocks until the result is returned.
 * `Async`: asynchronous, non-blocking call.

HeterogeneousCore/SonicCore/interface/SonicAcquirer.h

@@ -8,33 +8,43 @@
 #include "HeterogeneousCore/SonicCore/interface/sonic_utils.h"
 
 #include <chrono>
+#include <memory>
+#include <string>
 
 template <typename Client, typename Module>
 class SonicAcquirer : public Module {
 public:
   //typedef to simplify usage
   typedef typename Client::Input Input;
   //constructor
-  SonicAcquirer(edm::ParameterSet const& cfg) : client_(cfg.getParameter<edm::ParameterSet>("Client")) {}
+  SonicAcquirer(edm::ParameterSet const& cfg, const std::string& debugName = "")
+      : clientPset_(cfg.getParameterSet("Client")), debugName_(debugName) {}
   //destructor
   ~SonicAcquirer() override = default;
 
-  //derived classes use a dedicated acquire() interface that incorporates client_.input()
+  //construct client at beginning of job
+  //in case client constructor depends on operations happening in derived module constructors
+  void beginStream(edm::StreamID) override { makeClient(); }
+
+  //derived classes use a dedicated acquire() interface that incorporates client_->input()
   //(no need to interact with callback holder)
   void acquire(edm::Event const& iEvent, edm::EventSetup const& iSetup, edm::WaitingTaskWithArenaHolder holder) final {
     auto t0 = std::chrono::high_resolution_clock::now();
-    acquire(iEvent, iSetup, client_.input());
-    sonic_utils::printDebugTime(client_.debugName(), "acquire() time: ", t0);
+    acquire(iEvent, iSetup, client_->input());
+    sonic_utils::printDebugTime(debugName_, "acquire() time: ", t0);
     t_dispatch_ = std::chrono::high_resolution_clock::now();
-    client_.dispatch(holder);
+    client_->dispatch(holder);
   }
   virtual void acquire(edm::Event const& iEvent, edm::EventSetup const& iSetup, Input& iInput) = 0;
 
 protected:
-  //for debugging
-  void setDebugName(const std::string& debugName) { client_.setDebugName(debugName); }
+  //helper
+  void makeClient() { client_ = std::make_unique<Client>(clientPset_, debugName_); }
+
   //members
-  Client client_;
+  edm::ParameterSet clientPset_;
+  std::unique_ptr<Client> client_;
+  std::string debugName_;
   std::chrono::time_point<std::chrono::high_resolution_clock> t_dispatch_;
 };
 

HeterogeneousCore/SonicCore/interface/SonicClient.h

@@ -9,7 +9,8 @@ template <typename InputT, typename OutputT = InputT>
 class SonicClient : public SonicClientBase, public SonicClientTypes<InputT, OutputT> {
 public:
   //constructor
-  SonicClient(const edm::ParameterSet& params) : SonicClientBase(params), SonicClientTypes<InputT, OutputT>() {}
+  SonicClient(const edm::ParameterSet& params, const std::string& debugName, const std::string& clientName)
+      : SonicClientBase(params, debugName, clientName), SonicClientTypes<InputT, OutputT>() {}
 };
 
 #endif

HeterogeneousCore/SonicCore/interface/SonicClientBase.h

@@ -19,12 +19,11 @@ enum class SonicMode { Sync = 1, Async = 2, PseudoAsync = 3 };
 class SonicClientBase {
 public:
   //constructor
-  SonicClientBase(const edm::ParameterSet& params);
+  SonicClientBase(const edm::ParameterSet& params, const std::string& debugName, const std::string& clientName);
 
   //destructor
   virtual ~SonicClientBase() = default;
 
-  void setDebugName(const std::string& debugName);
   const std::string& debugName() const { return debugName_; }
   const std::string& clientName() const { return clientName_; }
   SonicMode mode() const { return mode_; }
@@ -42,6 +41,8 @@ class SonicClientBase {
   static void fillBasePSetDescription(edm::ParameterSetDescription& desc, bool allowRetry = true);
 
 protected:
+  void setMode(SonicMode mode);
+
   virtual void evaluate() = 0;
 
   void start(edm::WaitingTaskWithArenaHolder holder);
@@ -57,7 +58,7 @@ class SonicClientBase {
   std::optional<edm::WaitingTaskWithArenaHolder> holder_;
 
   //for logging/debugging
-  std::string clientName_, debugName_, fullDebugName_;
+  std::string debugName_, clientName_, fullDebugName_;
   std::chrono::time_point<std::chrono::high_resolution_clock> t0_;
 
   friend class SonicDispatcher;

HeterogeneousCore/SonicCore/interface/SonicEDFilter.h

@@ -16,22 +16,22 @@ class SonicEDFilter : public SonicAcquirer<Client, edm::stream::EDFilter<edm::Ex
   //typedef to simplify usage
   typedef typename Client::Output Output;
   //constructor
-  SonicEDFilter(edm::ParameterSet const& cfg)
-      : SonicAcquirer<Client, edm::stream::EDFilter<edm::ExternalWork, Capabilities...>>(cfg) {}
+  SonicEDFilter(edm::ParameterSet const& cfg, const std::string& debugName)
+      : SonicAcquirer<Client, edm::stream::EDFilter<edm::ExternalWork, Capabilities...>>(cfg, debugName) {}
   //destructor
   ~SonicEDFilter() override = default;
 
-  //derived classes use a dedicated produce() interface that incorporates client_.output()
+  //derived classes use a dedicated produce() interface that incorporates client_->output()
   bool filter(edm::Event& iEvent, edm::EventSetup const& iSetup) final {
     //measure time between acquire and produce
-    sonic_utils::printDebugTime(this->client_.debugName(), "dispatch() time: ", this->t_dispatch_);
+    sonic_utils::printDebugTime(this->debugName_, "dispatch() time: ", this->t_dispatch_);
 
     auto t0 = std::chrono::high_resolution_clock::now();
-    bool result = filter(iEvent, iSetup, this->client_.output());
-    sonic_utils::printDebugTime(this->client_.debugName(), "filter() time: ", t0);
+    bool result = filter(iEvent, iSetup, this->client_->output());
+    sonic_utils::printDebugTime(this->debugName_, "filter() time: ", t0);
 
     //reset client data
-    this->client_.reset();
+    this->client_->reset();
 
     return result;
   }

HeterogeneousCore/SonicCore/interface/SonicEDProducer.h

@@ -16,22 +16,22 @@ class SonicEDProducer : public SonicAcquirer<Client, edm::stream::EDProducer<edm
   //typedef to simplify usage
   typedef typename Client::Output Output;
   //constructor
-  SonicEDProducer(edm::ParameterSet const& cfg)
-      : SonicAcquirer<Client, edm::stream::EDProducer<edm::ExternalWork, Capabilities...>>(cfg) {}
+  SonicEDProducer(edm::ParameterSet const& cfg, const std::string& debugName)
+      : SonicAcquirer<Client, edm::stream::EDProducer<edm::ExternalWork, Capabilities...>>(cfg, debugName) {}
   //destructor
   ~SonicEDProducer() override = default;
 
-  //derived classes use a dedicated produce() interface that incorporates client_.output()
+  //derived classes use a dedicated produce() interface that incorporates client_->output()
   void produce(edm::Event& iEvent, edm::EventSetup const& iSetup) final {
     //measure time between acquire and produce
-    sonic_utils::printDebugTime(this->client_.debugName(), "dispatch() time: ", this->t_dispatch_);
+    sonic_utils::printDebugTime(this->debugName_, "dispatch() time: ", this->t_dispatch_);
 
     auto t0 = std::chrono::high_resolution_clock::now();
-    produce(iEvent, iSetup, this->client_.output());
-    sonic_utils::printDebugTime(this->client_.debugName(), "produce() time: ", t0);
+    produce(iEvent, iSetup, this->client_->output());
+    sonic_utils::printDebugTime(this->debugName_, "produce() time: ", t0);
 
     //reset client data
-    this->client_.reset();
+    this->client_->reset();
   }
   virtual void produce(edm::Event& iEvent, edm::EventSetup const& iSetup, Output const& iOutput) = 0;
 };

HeterogeneousCore/SonicCore/interface/SonicOneEDAnalyzer.h

@@ -21,43 +21,53 @@ class SonicOneEDAnalyzer : public edm::one::EDAnalyzer<Capabilities...> {
   typedef typename Client::Input Input;
   typedef typename Client::Output Output;
   //constructor
-  SonicOneEDAnalyzer(edm::ParameterSet const& cfg) : client_(cfg.getParameter<edm::ParameterSet>("Client")) {
+  SonicOneEDAnalyzer(edm::ParameterSet const& cfg, const std::string& debugName)
+      : clientPset_(cfg.getParameterSet("Client")), debugName_(debugName) {
     //ExternalWork is not compatible with one modules, so Sync mode is enforced
-    if (client_.mode() != SonicMode::Sync)
-      throw cms::Exception("UnsupportedMode") << "SonicOneEDAnalyzer can only use Sync mode for clients";
+    if (clientPset_.getParameter<std::string>("mode") != "Sync") {
+      edm::LogWarning("ResetClientMode") << "Resetting client mode to Sync for SonicOneEDAnalyzer";
+      clientPset_.addParameter<std::string>("mode", "Sync");
+    }
   }
   //destructor
   ~SonicOneEDAnalyzer() override = default;
 
-  //derived classes still use a dedicated acquire() interface that incorporates client_.input() for consistency
+  //construct client at beginning of job
+  //in case client constructor depends on operations happening in derived module constructors
+  void beginJob() override { makeClient(); }
+
+  //derived classes still use a dedicated acquire() interface that incorporates client_->input() for consistency
   virtual void acquire(edm::Event const& iEvent, edm::EventSetup const& iSetup, Input& iInput) = 0;
-  //derived classes use a dedicated analyze() interface that incorporates client_.output()
+  //derived classes use a dedicated analyze() interface that incorporates client_->output()
   void analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup) final {
     auto t0 = std::chrono::high_resolution_clock::now();
-    acquire(iEvent, iSetup, client_.input());
-    sonic_utils::printDebugTime(client_.debugName(), "acquire() time: ", t0);
+    acquire(iEvent, iSetup, client_->input());
+    sonic_utils::printDebugTime(debugName_, "acquire() time: ", t0);
 
     //pattern similar to ExternalWork, but blocking
     auto t1 = std::chrono::high_resolution_clock::now();
-    client_.dispatch();
+    client_->dispatch();
 
     //measure time between acquire and produce
-    sonic_utils::printDebugTime(client_.debugName(), "dispatch() time: ", t1);
+    sonic_utils::printDebugTime(debugName_, "dispatch() time: ", t1);
 
     auto t2 = std::chrono::high_resolution_clock::now();
-    analyze(iEvent, iSetup, client_.output());
-    sonic_utils::printDebugTime(client_.debugName(), "analyze() time: ", t2);
+    analyze(iEvent, iSetup, client_->output());
+    sonic_utils::printDebugTime(debugName_, "analyze() time: ", t2);
 
     //reset client data
-    client_.reset();
+    client_->reset();
   }
   virtual void analyze(edm::Event const& iEvent, edm::EventSetup const& iSetup, Output const& iOutput) = 0;
 
 protected:
-  //for debugging
-  void setDebugName(const std::string& debugName) { client_.setDebugName(debugName); }
+  //helper
+  void makeClient() { client_ = std::make_unique<Client>(clientPset_, debugName_); }
+
   //members
-  Client client_;
+  edm::ParameterSet clientPset_;
+  std::unique_ptr<Client> client_;
+  std::string debugName_;
 };
 
 #endif

HeterogeneousCore/SonicCore/src/SonicClientBase.cc

@@ -2,17 +2,31 @@
 #include "FWCore/Utilities/interface/Exception.h"
 #include "FWCore/ParameterSet/interface/allowedValues.h"
 
-SonicClientBase::SonicClientBase(const edm::ParameterSet& params)
-    : allowedTries_(params.getUntrackedParameter<unsigned>("allowedTries", 0)) {
+SonicClientBase::SonicClientBase(const edm::ParameterSet& params,
+                                 const std::string& debugName,
+                                 const std::string& clientName)
+    : allowedTries_(params.getUntrackedParameter<unsigned>("allowedTries", 0)),
+      debugName_(debugName),
+      clientName_(clientName),
+      fullDebugName_(debugName_) {
+  if (!clientName_.empty())
+    fullDebugName_ += ":" + clientName_;
+
   std::string modeName(params.getParameter<std::string>("mode"));
   if (modeName == "Sync")
-    mode_ = SonicMode::Sync;
+    setMode(SonicMode::Sync);
   else if (modeName == "Async")
-    mode_ = SonicMode::Async;
+    setMode(SonicMode::Async);
   else if (modeName == "PseudoAsync")
-    mode_ = SonicMode::PseudoAsync;
+    setMode(SonicMode::PseudoAsync);
   else
     throw cms::Exception("Configuration") << "Unknown mode for SonicClient: " << modeName;
+}
+
+void SonicClientBase::setMode(SonicMode mode) {
+  if (mode_ == mode)
+    return;
+  mode_ = mode;
 
   //get correct dispatcher for mode
   if (mode_ == SonicMode::Sync or mode_ == SonicMode::Async)
@@ -21,13 +35,6 @@ SonicClientBase::SonicClientBase(const edm::ParameterSet& params)
     dispatcher_ = std::make_unique<SonicDispatcherPseudoAsync>(this);
 }
 
-void SonicClientBase::setDebugName(const std::string& debugName) {
-  debugName_ = debugName;
-  fullDebugName_ = debugName_;
-  if (!clientName_.empty())
-    fullDebugName_ += ":" + clientName_;
-}
-
 void SonicClientBase::start(edm::WaitingTaskWithArenaHolder holder) {
   start();
   holder_ = std::move(holder);

HeterogeneousCore/SonicCore/test/DummyClient.h

@@ -12,8 +12,8 @@
 class DummyClient : public SonicClient<int> {
 public:
   //constructor
-  DummyClient(const edm::ParameterSet& params)
-      : SonicClient<int>(params),
+  DummyClient(const edm::ParameterSet& params, const std::string& debugName)
+      : SonicClient<int>(params, debugName, "DummyClient"),
         factor_(params.getParameter<int>("factor")),
         wait_(params.getParameter<int>("wait")),
         fails_(params.getParameter<unsigned>("fails")) {}