Removed unused Worker related APIs

Worker API no longer build modules on demand.

Author: Dr15Jones

FWCore/Framework/interface/WorkerManager.h

@@ -42,14 +42,6 @@ namespace edm {
 
     void addToUnscheduledWorkers(ModuleDescription const& iDescription);
 
-    void addToUnscheduledWorkers(ParameterSet& pset,
-                                 SignallingProductRegistryFiller& preg,
-                                 PreallocationConfiguration const* prealloc,
-                                 std::shared_ptr<ProcessConfiguration const> processConfiguration,
-                                 std::string label,
-                                 std::set<std::string>& unscheduledLabels,
-                                 std::vector<std::string>& shouldBeUsedLabels);
-
     template <typename T, typename U>
     void processOneOccurrenceAsync(WaitingTaskHolder,
                                    typename T::TransitionInfoType&,
@@ -76,13 +68,6 @@ namespace edm {
 
     ExceptionToActionTable const& actionTable() const { return *actionTable_; }
 
-    Worker* getWorker(ParameterSet& pset,
-                      SignallingProductRegistryFiller& preg,
-                      PreallocationConfiguration const* prealloc,
-                      std::shared_ptr<ProcessConfiguration const> processConfiguration,
-                      std::string const& label,
-                      bool addToAllWorkers = true);
-
     template <typename T>
       requires requires(T const& x) { x.moduleDescription(); }
     Worker* getWorkerForModule(T const& module) {

FWCore/Framework/interface/WorkerRegistry.h

@@ -20,7 +20,6 @@ namespace edm {
 
   class Worker;
   class ActivityRegistry;
-  struct WorkerParams;
   class ModuleRegistry;
   class ModuleTypeResolverMaker;
   class ParameterSet;
@@ -46,17 +45,13 @@ namespace edm {
     WorkerRegistry(WorkerRegistry const&) = delete;             // Disallow copying and moving
     WorkerRegistry& operator=(WorkerRegistry const&) = delete;  // Disallow copying and moving
 
-    /// Retrieve the particular instance of the worker
-    /** If the worker with that set of parameters does not exist,
-        create it
-        @note Workers are owned by this class, do not delete them*/
-    Worker* getWorker(WorkerParams const& p, std::string const& moduleLabel);
-
     /// Retrieve particular instance of the worker without creating it
     /// If one doesn't exist, returns nullptr
     Worker const* get(std::string const& moduleLabel) const;
 
-    //Creates worker if needed
+    /** Creates worker if doesn't already exist
+     * @note Workers are owned by this class, do not delete them
+     */
     Worker* getWorkerFromExistingModule(std::string const& moduleLabel, ExceptionToActionTable const* actions);
 
     /// Deletes the module of the Worker, but the Worker continues to exist.

FWCore/Framework/src/WorkerManager.cc

@@ -38,20 +38,6 @@ namespace edm {
     }
   }
 
-  Worker* WorkerManager::getWorker(ParameterSet& pset,
-                                   SignallingProductRegistryFiller& preg,
-                                   PreallocationConfiguration const* prealloc,
-                                   std::shared_ptr<ProcessConfiguration const> processConfiguration,
-                                   std::string const& label,
-                                   bool addToAll) {
-    WorkerParams params(&pset, preg, prealloc, processConfiguration, *actionTable_);
-    auto worker = workerReg_.getWorker(params, label);
-    if (nullptr != worker and addToAll) {
-      addToAllWorkers(worker);
-    }
-    return worker;
-  }
-
   Worker* WorkerManager::getWorkerForExistingModule(std::string const& label) {
     auto worker = workerReg_.getWorkerFromExistingModule(label, actionTable_);
     if (nullptr != worker) {
@@ -69,29 +55,6 @@ namespace edm {
     addToAllWorkers(newWorker);
   }
 
-  void WorkerManager::addToUnscheduledWorkers(ParameterSet& pset,
-                                              SignallingProductRegistryFiller& preg,
-                                              PreallocationConfiguration const* prealloc,
-                                              std::shared_ptr<ProcessConfiguration const> processConfiguration,
-                                              std::string label,
-                                              std::set<std::string>& unscheduledLabels,
-                                              std::vector<std::string>& shouldBeUsedLabels) {
-    //Need to
-    // 1) create worker
-    // 2) if it is a WorkerT<EDProducer>, add it to our list
-    auto modType = pset.getParameter<std::string>("@module_edm_type");
-    if (modType == kProducerType || modType == kFilterType) {
-      Worker* newWorker = getWorker(pset, preg, prealloc, processConfiguration, label);
-      assert(newWorker->moduleType() == Worker::kProducer || newWorker->moduleType() == Worker::kFilter);
-      unscheduledLabels.insert(label);
-      unscheduled_.addWorker(newWorker);
-      //add to list so it gets reset each new event
-      addToAllWorkers(newWorker);
-    } else {
-      shouldBeUsedLabels.push_back(label);
-    }
-  }
-
   void WorkerManager::resetAll() { for_all(allWorkers_, std::bind(&Worker::reset, std::placeholders::_1)); }
 
   void WorkerManager::addToAllWorkers(Worker* w) {

FWCore/Framework/src/WorkerRegistry.cc

@@ -22,26 +22,6 @@ namespace edm {
 
   void WorkerRegistry::clear() { m_workerMap.clear(); }
 
-  Worker* WorkerRegistry::getWorker(WorkerParams const& p, std::string const& moduleLabel) {
-    WorkerMap::iterator workerIt = m_workerMap.find(moduleLabel);
-
-    // if the worker is not there, make it
-    if (workerIt == m_workerMap.end()) {
-      MakeModuleParams mmp(p.pset_, *p.reg_, p.preallocate_, p.processConfiguration_);
-      auto modulePtr = modRegistry_->getModule(
-          mmp, moduleLabel, actReg_->preModuleConstructionSignal_, actReg_->postModuleConstructionSignal_);
-      auto workerPtr = modulePtr->makeWorker(p.actions_);
-
-      workerPtr->setActivityRegistry(actReg_);
-
-      // Transfer ownership of worker to the registry
-      m_workerMap[moduleLabel] =
-          std::shared_ptr<Worker>(workerPtr.release());  // propagate_const<T> has no reset() function
-      return m_workerMap[moduleLabel].get();
-    }
-    return (workerIt->second.get());
-  }
-
   Worker const* WorkerRegistry::get(std::string const& moduleLabel) const {
     WorkerMap::const_iterator workerIt = m_workerMap.find(moduleLabel);
     if (workerIt != m_workerMap.end()) {