diff --git a/FWCore/AbstractServices/interface/TimingServiceBase.h b/FWCore/AbstractServices/interface/TimingServiceBase.h index 1e02e0ffc1cac..57432c708fe4a 100644 --- a/FWCore/AbstractServices/interface/TimingServiceBase.h +++ b/FWCore/AbstractServices/interface/TimingServiceBase.h @@ -41,8 +41,14 @@ namespace edm { virtual double getTotalCPU() const = 0; static void jobStarted(); + static void pythonStarting(); + static void pythonFinished(); + static void servicesStarting(); static std::chrono::steady_clock::time_point jobStartTime(); + static std::chrono::steady_clock::time_point pythonStartTime(); + static std::chrono::steady_clock::time_point pythonEndTime(); + static std::chrono::steady_clock::time_point servicesStartTime(); }; } // namespace edm diff --git a/FWCore/AbstractServices/src/TimingServiceBase.cc b/FWCore/AbstractServices/src/TimingServiceBase.cc index 625d327dd0a55..d069865241122 100644 --- a/FWCore/AbstractServices/src/TimingServiceBase.cc +++ b/FWCore/AbstractServices/src/TimingServiceBase.cc @@ -24,6 +24,26 @@ std::chrono::steady_clock::time_point TimingServiceBase::jobStartTime() { return s_jobStartTime; } +void TimingServiceBase::pythonStarting() { (void)pythonStartTime(); } +void TimingServiceBase::pythonFinished() { (void)pythonEndTime(); } + +void TimingServiceBase::servicesStarting() { (void)servicesStartTime(); } + +std::chrono::steady_clock::time_point TimingServiceBase::pythonStartTime() { + static const std::chrono::steady_clock::time_point s_pythonStartTime = std::chrono::steady_clock::now(); + return s_pythonStartTime; +} + +std::chrono::steady_clock::time_point TimingServiceBase::pythonEndTime() { + static const std::chrono::steady_clock::time_point s_pythonEndTime = std::chrono::steady_clock::now(); + return s_pythonEndTime; +} + +std::chrono::steady_clock::time_point TimingServiceBase::servicesStartTime() { + static const std::chrono::steady_clock::time_point s_servicesStartTime = std::chrono::steady_clock::now(); + return s_servicesStartTime; +} + // // constructors and destructor // diff --git a/FWCore/Framework/bin/cmsRun.cpp b/FWCore/Framework/bin/cmsRun.cpp index 5e50c3443e5ed..c828e6db03345 100644 --- a/FWCore/Framework/bin/cmsRun.cpp +++ b/FWCore/Framework/bin/cmsRun.cpp @@ -189,11 +189,13 @@ int main(int argc, const char* argv[]) { } std::shared_ptr processDesc; try { + edm::TimingServiceBase::pythonStarting(); std::unique_ptr parameterSet; if (!fileName.empty()) parameterSet = edm::readConfig(fileName, pythonOptValues); else edm::makeParameterSets(cmdString, parameterSet); + edm::TimingServiceBase::pythonFinished(); processDesc = std::make_shared(std::move(parameterSet)); } catch (edm::Exception const&) { throw; diff --git a/FWCore/Framework/interface/Schedule.h b/FWCore/Framework/interface/Schedule.h index 9b15ecee73bab..e15247644b997 100644 --- a/FWCore/Framework/interface/Schedule.h +++ b/FWCore/Framework/interface/Schedule.h @@ -82,6 +82,7 @@ #include "FWCore/Utilities/interface/get_underlying_safe.h" #include "FWCore/Utilities/interface/propagate_const.h" #include "FWCore/Utilities/interface/Transition.h" +#include "FWCore/Utilities/interface/Signal.h" #include #include @@ -323,6 +324,8 @@ namespace edm { std::vector const* pathNames_; std::vector const* endPathNames_; + edm::signalslot::Signal preModulesInitializationFinalizedSignal_; + edm::signalslot::Signal postModulesInitializationFinalizedSignal_; bool wantSummary_; }; diff --git a/FWCore/Framework/src/EventProcessor.cc b/FWCore/Framework/src/EventProcessor.cc index 221fcc035514c..75e8d564166f8 100644 --- a/FWCore/Framework/src/EventProcessor.cc +++ b/FWCore/Framework/src/EventProcessor.cc @@ -53,6 +53,7 @@ #include "FWCore/AbstractServices/interface/RandomNumberGenerator.h" #include "FWCore/AbstractServices/interface/RootHandlers.h" +#include "FWCore/AbstractServices/interface/TimingServiceBase.h" #include "FWCore/ServiceRegistry/interface/ServiceRegistry.h" #include "FWCore/ServiceRegistry/interface/Service.h" @@ -109,6 +110,18 @@ namespace { private: edm::SerialTaskQueue& queue_; }; + + template + requires std::is_invocable_v + struct Guard { + Guard(T&& signal) : final_(std::forward(signal)) {} + ~Guard() { final_(); } + T final_; + }; + template + Guard makeGuard(T&& signal) { + return Guard{std::forward(signal)}; + } } // namespace namespace edm { @@ -423,9 +436,11 @@ namespace edm { ScheduleItems items; //initialize the services + edm::TimingServiceBase::servicesStarting(); auto& serviceSets = processDesc->getServicesPSets(); ServiceToken token = items.initServices(serviceSets, *parameterSet, iToken, iLegacy); serviceToken_ = items.addTNS(*parameterSet, token); + items.actReg_->postServicesConstructionSignal_(); //make the services available ServiceRegistry::Operate operate(serviceToken_); @@ -440,9 +455,13 @@ namespace edm { std::shared_ptr common(items.initMisc(*parameterSet)); // intialize the event setup provider - ParameterSet const& eventSetupPset(optionsPset.getUntrackedParameterSet("eventSetup")); - esp_ = espController_->makeProvider( - *parameterSet, items.actReg_.get(), &eventSetupPset, maxConcurrentIOVs, dumpOptions); + items.actReg_->preEventSetupModulesConstructionSignal_(); + { + auto guard = makeGuard([&items]() { items.actReg_->postEventSetupModulesConstructionSignal_(); }); + ParameterSet const& eventSetupPset(optionsPset.getUntrackedParameterSet("eventSetup")); + esp_ = espController_->makeProvider( + *parameterSet, items.actReg_.get(), &eventSetupPset, maxConcurrentIOVs, dumpOptions); + } // initialize the looper, if any if (!loopers.empty()) { @@ -497,6 +516,8 @@ namespace edm { group.wait(); items.preg()->addFromInput(input_->productRegistry()); { + items.actReg_->preFinishScheduleSignal_(); + auto guard = makeGuard([&items]() { items.actReg_->postFinishScheduleSignal_(); }); auto const& tns = ServiceRegistry::instance().get(); schedule_ = items.finishSchedule( std::move(*madeModules), *parameterSet, tns, preallocations_, &processContext_, *processBlockHelper_); @@ -524,44 +545,48 @@ namespace edm { FDEBUG(2) << parameterSet << std::endl; - principalCache_.setNumberOfConcurrentPrincipals(preallocations_); - for (unsigned int index = 0; index < preallocations_.numberOfStreams(); ++index) { - // Reusable event principal - auto ep = std::make_shared(preg(), + { + actReg_->prePrincipalsCreationSignal_(); + auto guard = makeGuard([this]() { actReg_->postPrincipalsCreationSignal_(); }); + principalCache_.setNumberOfConcurrentPrincipals(preallocations_); + for (unsigned int index = 0; index < preallocations_.numberOfStreams(); ++index) { + // Reusable event principal + auto ep = std::make_shared(preg(), + productResolversFactory::makePrimary, + branchIDListHelper(), + thinnedAssociationsHelper(), + *processConfiguration_, + historyAppender_.get(), + index, + &*processBlockHelper_); + principalCache_.insert(std::move(ep)); + } + + for (unsigned int index = 0; index < preallocations_.numberOfRuns(); ++index) { + auto rp = std::make_unique(preg(), productResolversFactory::makePrimary, - branchIDListHelper(), - thinnedAssociationsHelper(), *processConfiguration_, historyAppender_.get(), index, - &*processBlockHelper_); - principalCache_.insert(std::move(ep)); - } - - for (unsigned int index = 0; index < preallocations_.numberOfRuns(); ++index) { - auto rp = std::make_unique(preg(), - productResolversFactory::makePrimary, - *processConfiguration_, - historyAppender_.get(), - index, - &mergeableRunProductProcesses_); - principalCache_.insert(std::move(rp)); - } + &mergeableRunProductProcesses_); + principalCache_.insert(std::move(rp)); + } - for (unsigned int index = 0; index < preallocations_.numberOfLuminosityBlocks(); ++index) { - auto lp = std::make_unique( - preg(), productResolversFactory::makePrimary, *processConfiguration_, historyAppender_.get(), index); - principalCache_.insert(std::move(lp)); - } + for (unsigned int index = 0; index < preallocations_.numberOfLuminosityBlocks(); ++index) { + auto lp = std::make_unique( + preg(), productResolversFactory::makePrimary, *processConfiguration_, historyAppender_.get(), index); + principalCache_.insert(std::move(lp)); + } - { - auto pb = std::make_unique( - preg(), productResolversFactory::makePrimary, *processConfiguration_); - principalCache_.insert(std::move(pb)); + { + auto pb = std::make_unique( + preg(), productResolversFactory::makePrimary, *processConfiguration_); + principalCache_.insert(std::move(pb)); - auto pbForInput = std::make_unique( - preg(), productResolversFactory::makePrimary, *processConfiguration_); - principalCache_.insertForInput(std::move(pbForInput)); + auto pbForInput = std::make_unique( + preg(), productResolversFactory::makePrimary, *processConfiguration_); + principalCache_.insertForInput(std::move(pbForInput)); + } } } catch (...) { //in case of an exception, make sure Services are available @@ -617,43 +642,47 @@ namespace edm { schedule_->convertCurrentProcessAlias(processConfiguration_->processName()); PathsAndConsumesOfModules pathsAndConsumesOfModules; - pathsAndConsumesOfModules.initialize(schedule_.get(), preg()); - - // Note: all these may throw - checkForModuleDependencyCorrectness(pathsAndConsumesOfModules, printDependencies_); - if (deleteNonConsumedUnscheduledModules_) { - if (auto const unusedModules = nonConsumedUnscheduledModules(pathsAndConsumesOfModules); - not unusedModules.empty()) { - pathsAndConsumesOfModules.removeModules(unusedModules); - - edm::LogInfo("DeleteModules").log([&unusedModules](auto& l) { - l << "The following modules are not in any Path or EndPath, nor is their output consumed by any other " - "module, " - "and therefore they are deleted before the beginJob transition."; + { + actReg_->preScheduleConsistencyCheckSignal_(); + auto guard = makeGuard([this]() { actReg_->postScheduleConsistencyCheckSignal_(); }); + pathsAndConsumesOfModules.initialize(schedule_.get(), preg()); + + // Note: all these may throw + checkForModuleDependencyCorrectness(pathsAndConsumesOfModules, printDependencies_); + if (deleteNonConsumedUnscheduledModules_) { + if (auto const unusedModules = nonConsumedUnscheduledModules(pathsAndConsumesOfModules); + not unusedModules.empty()) { + pathsAndConsumesOfModules.removeModules(unusedModules); + + edm::LogInfo("DeleteModules").log([&unusedModules](auto& l) { + l << "The following modules are not in any Path or EndPath, nor is their output consumed by any other " + "module, " + "and therefore they are deleted before the beginJob transition."; + for (auto const& description : unusedModules) { + l << "\n " << description->moduleLabel(); + } + }); for (auto const& description : unusedModules) { - l << "\n " << description->moduleLabel(); + schedule_->deleteModule(description->moduleLabel(), actReg_.get()); } - }); - for (auto const& description : unusedModules) { - schedule_->deleteModule(description->moduleLabel(), actReg_.get()); } } - } - // Initialize after the deletion of non-consumed unscheduled - // modules to avoid non-consumed non-run modules to keep the - // products unnecessarily alive - if (not branchesToDeleteEarly_.empty()) { - auto modulesToSkip = std::move(modulesToIgnoreForDeleteEarly_); - auto branchesToDeleteEarly = std::move(branchesToDeleteEarly_); - auto referencesToBranches = std::move(referencesToBranches_); - schedule_->initializeEarlyDelete(branchesToDeleteEarly, referencesToBranches, modulesToSkip, *preg_); - } + // Initialize after the deletion of non-consumed unscheduled + // modules to avoid non-consumed non-run modules to keep the + // products unnecessarily alive + if (not branchesToDeleteEarly_.empty()) { + auto modulesToSkip = std::move(modulesToIgnoreForDeleteEarly_); + auto branchesToDeleteEarly = std::move(branchesToDeleteEarly_); + auto referencesToBranches = std::move(referencesToBranches_); + schedule_->initializeEarlyDelete(branchesToDeleteEarly, referencesToBranches, modulesToSkip, *preg_); + } - if (preallocations_.numberOfLuminosityBlocks() > 1) { - throwAboutModulesRequiringLuminosityBlockSynchronization(); - } - if (preallocations_.numberOfRuns() > 1) { - warnAboutModulesRequiringRunSynchronization(); + if (preallocations_.numberOfLuminosityBlocks() > 1) { + throwAboutModulesRequiringLuminosityBlockSynchronization(); + } + if (preallocations_.numberOfRuns() > 1) { + warnAboutModulesRequiringRunSynchronization(); + } } //NOTE: This implementation assumes 'Job' means one call @@ -670,8 +699,11 @@ namespace edm { //if(looper_) { // looper_->beginOfJob(es); //} - espController_->finishConfiguration(); - + { + actReg_->preEventSetupConfigurationFinalizedSignal_(); + auto guard = makeGuard([this]() { actReg_->postEventSetupConfigurationFinalizedSignal_(); }); + espController_->finishConfiguration(); + } eventsetup::ESRecordsToProductResolverIndices esRecordsToProductResolverIndices = esp_->recordsToResolverIndices(); actReg_->eventSetupConfigurationSignal_(esRecordsToProductResolverIndices, processContext_); diff --git a/FWCore/Framework/src/Schedule.cc b/FWCore/Framework/src/Schedule.cc index 93fbcb9bcad64..f71bb73b5991d 100644 --- a/FWCore/Framework/src/Schedule.cc +++ b/FWCore/Framework/src/Schedule.cc @@ -237,6 +237,8 @@ namespace edm { pathNames_(&tns.getTrigPaths()), endPathNames_(&tns.getEndPaths()), wantSummary_(tns.wantSummary()) { + preModulesInitializationFinalizedSignal_.connect(std::cref(areg->preModulesInitializationFinalizedSignal_)); + postModulesInitializationFinalizedSignal_.connect(std::cref(areg->postModulesInitializationFinalizedSignal_)); ScheduleBuilder builder( *moduleRegistry_, proc_pset, *pathNames_, *endPathNames_, prealloc, preg, *areg, processConfiguration); resultsInserter_ = std::move(builder.resultsInserter_); @@ -900,6 +902,9 @@ namespace edm { eventsetup::ESRecordsToProductResolverIndices const& iESIndices, ProcessBlockHelperBase const& processBlockHelperBase, std::string const& iProcessName) { + preModulesInitializationFinalizedSignal_(); + auto post = [this](void*) { postModulesInitializationFinalizedSignal_(); }; + std::unique_ptr const postGuard(this, post); finishModulesInitialization(*moduleRegistry_, iRegistry, iESIndices, processBlockHelperBase, iProcessName); globalSchedule_->beginJob(*moduleRegistry_); } diff --git a/FWCore/ServiceRegistry/interface/ActivityRegistry.h b/FWCore/ServiceRegistry/interface/ActivityRegistry.h index ccebbdcad7029..11d4b832dc96b 100644 --- a/FWCore/ServiceRegistry/interface/ActivityRegistry.h +++ b/FWCore/ServiceRegistry/interface/ActivityRegistry.h @@ -146,12 +146,98 @@ namespace edm { ActivityRegistry& operator=(ActivityRegistry const&) = delete; // Disallow copying and moving // ---------- signals ------------------------------------ + using PostServicesConstruction = signalslot::Signal; + /// signal is emitted after all services have been constructed + PostServicesConstruction postServicesConstructionSignal_; + void watchPostServicesConstruction(PostServicesConstruction::slot_type const& iSlot) { + postServicesConstructionSignal_.connect(iSlot); + } + AR_WATCH_USING_METHOD_0(watchPostServicesConstruction) + + using PreEventSetupModulesConstruction = signalslot::Signal; + /// signal is emitted before any EventSetup modules have been constructed + PreEventSetupModulesConstruction preEventSetupModulesConstructionSignal_; + void watchPreEventSetupModulesConstruction(PreEventSetupModulesConstruction::slot_type const& iSlot) { + preEventSetupModulesConstructionSignal_.connect(iSlot); + } + AR_WATCH_USING_METHOD_0(watchPreEventSetupModulesConstruction) + + using PostEventSetupModulesConstruction = signalslot::Signal; + /// signal is emitted after all EventSetup modules have been constructed + PostEventSetupModulesConstruction postEventSetupModulesConstructionSignal_; + void watchPostEventSetupModulesConstruction(PostEventSetupModulesConstruction::slot_type const& iSlot) { + postEventSetupModulesConstructionSignal_.connect(iSlot); + } + AR_WATCH_USING_METHOD_0(watchPostEventSetupModulesConstruction) + + using PreFinishSchedule = signalslot::Signal; + /// signal is emitted before the call to EventSetup::finishSchedule + PreFinishSchedule preFinishScheduleSignal_; + void watchPreFinishSchedule(PreFinishSchedule::slot_type const& iSlot) { preFinishScheduleSignal_.connect(iSlot); } + AR_WATCH_USING_METHOD_0(watchPreFinishSchedule) + + using PostFinishSchedule = signalslot::Signal; + /// signal is emitted after the call to EventSetup::finishSchedule + PostFinishSchedule postFinishScheduleSignal_; + void watchPostFinishSchedule(PostFinishSchedule::slot_type const& iSlot) { + postFinishScheduleSignal_.connect(iSlot); + } + AR_WATCH_USING_METHOD_0(watchPostFinishSchedule) + + using PrePrincipalsCreation = signalslot::Signal; + /// signal is emitted before the creation of the Run, LuminosityBlock, and Event Principals + PrePrincipalsCreation prePrincipalsCreationSignal_; + void watchPrePrincipalsCreation(PrePrincipalsCreation::slot_type const& iSlot) { + prePrincipalsCreationSignal_.connect(iSlot); + } + AR_WATCH_USING_METHOD_0(watchPrePrincipalsCreation) + + using PostPrincipalsCreation = signalslot::Signal; + /// signal is emitted after the creation of the Run, LuminosityBlock, and Event Principals + PostPrincipalsCreation postPrincipalsCreationSignal_; + void watchPostPrincipalsCreation(PostPrincipalsCreation::slot_type const& iSlot) { + postPrincipalsCreationSignal_.connect(iSlot); + } + AR_WATCH_USING_METHOD_0(watchPostPrincipalsCreation) + + using PreScheduleConsistencyCheck = signalslot::Signal; + /// signal is emitted before the call to Schedule::consistencyCheck + PreScheduleConsistencyCheck preScheduleConsistencyCheckSignal_; + void watchPreScheduleConsistencyCheck(PreScheduleConsistencyCheck::slot_type const& iSlot) { + preScheduleConsistencyCheckSignal_.connect(iSlot); + } + AR_WATCH_USING_METHOD_0(watchPreScheduleConsistencyCheck) + + using PostScheduleConsistencyCheck = signalslot::Signal; + /// signal is emitted after the call to Schedule::consistencyCheck + PostScheduleConsistencyCheck postScheduleConsistencyCheckSignal_; + void watchPostScheduleConsistencyCheck(PostScheduleConsistencyCheck::slot_type const& iSlot) { + postScheduleConsistencyCheckSignal_.connect(iSlot); + } + AR_WATCH_USING_METHOD_0(watchPostScheduleConsistencyCheck) + typedef signalslot::Signal Preallocate; ///signal is emitted before beginJob Preallocate preallocateSignal_; void watchPreallocate(Preallocate::slot_type const& iSlot) { preallocateSignal_.connect(iSlot); } AR_WATCH_USING_METHOD_1(watchPreallocate) + using PreEventSetupConfigurationFinalized = signalslot::Signal; + /// signal is emitted just before the EventSetup configuration has been finalized + PreEventSetupConfigurationFinalized preEventSetupConfigurationFinalizedSignal_; + void watchPreEventSetupConfigurationFinalized(PreEventSetupConfigurationFinalized::slot_type const& iSlot) { + preEventSetupConfigurationFinalizedSignal_.connect(iSlot); + } + AR_WATCH_USING_METHOD_0(watchPreEventSetupConfigurationFinalized) + + using PostEventSetupConfigurationFinalized = signalslot::Signal; + /// signal is emitted just after the EventSetup configuration has been finalized + PostEventSetupConfigurationFinalized postEventSetupConfigurationFinalizedSignal_; + void watchPostEventSetupConfigurationFinalized(PostEventSetupConfigurationFinalized::slot_type const& iSlot) { + postEventSetupConfigurationFinalizedSignal_.connect(iSlot); + } + AR_WATCH_USING_METHOD_0(watchPostEventSetupConfigurationFinalized) + typedef signalslot::Signal EventSetupConfiguration; ///signal is emitted before beginJob @@ -161,6 +247,22 @@ namespace edm { } AR_WATCH_USING_METHOD_2(watchEventSetupConfiguration) + using PreModulesInitializationFinalized = signalslot::Signal; + /// signal is emitted just before all module initialization has been finalized + PreModulesInitializationFinalized preModulesInitializationFinalizedSignal_; + void watchPreModulesInitializationFinalized(PreModulesInitializationFinalized::slot_type const& iSlot) { + preModulesInitializationFinalizedSignal_.connect(iSlot); + } + AR_WATCH_USING_METHOD_0(watchPreModulesInitializationFinalized) + + using PostModulesInitializationFinalized = signalslot::Signal; + /// signal is emitted just after all module initialization has been finalized + PostModulesInitializationFinalized postModulesInitializationFinalizedSignal_; + void watchPostModulesInitializationFinalized(PostModulesInitializationFinalized::slot_type const& iSlot) { + postModulesInitializationFinalizedSignal_.connect(iSlot); + } + AR_WATCH_USING_METHOD_0(watchPostModulesInitializationFinalized) + typedef signalslot::Signal PreBeginJob; ///signal is emitted before all modules have gotten their beginJob called PreBeginJob preBeginJobSignal_; diff --git a/FWCore/ServiceRegistry/src/ActivityRegistry.cc b/FWCore/ServiceRegistry/src/ActivityRegistry.cc index 7d0360bf85916..2a2b975a6d03c 100644 --- a/FWCore/ServiceRegistry/src/ActivityRegistry.cc +++ b/FWCore/ServiceRegistry/src/ActivityRegistry.cc @@ -54,8 +54,21 @@ namespace edm { } // namespace signalslot void ActivityRegistry::connect(ActivityRegistry& iOther) { + postServicesConstructionSignal_.connect(std::cref(iOther.postServicesConstructionSignal_)); + preEventSetupModulesConstructionSignal_.connect(std::cref(iOther.preEventSetupModulesConstructionSignal_)); + postEventSetupModulesConstructionSignal_.connect(std::cref(iOther.postEventSetupModulesConstructionSignal_)); + preFinishScheduleSignal_.connect(std::cref(iOther.preFinishScheduleSignal_)); + postFinishScheduleSignal_.connect(std::cref(iOther.postFinishScheduleSignal_)); + prePrincipalsCreationSignal_.connect(std::cref(iOther.prePrincipalsCreationSignal_)); + postPrincipalsCreationSignal_.connect(std::cref(iOther.postPrincipalsCreationSignal_)); + preScheduleConsistencyCheckSignal_.connect(std::cref(iOther.preScheduleConsistencyCheckSignal_)); + postScheduleConsistencyCheckSignal_.connect(std::cref(iOther.postScheduleConsistencyCheckSignal_)); preallocateSignal_.connect(std::cref(iOther.preallocateSignal_)); + preEventSetupConfigurationFinalizedSignal_.connect(std::cref(iOther.preEventSetupConfigurationFinalizedSignal_)); + postEventSetupConfigurationFinalizedSignal_.connect(std::cref(iOther.postEventSetupConfigurationFinalizedSignal_)); eventSetupConfigurationSignal_.connect(std::cref(iOther.eventSetupConfigurationSignal_)); + preModulesInitializationFinalizedSignal_.connect(std::cref(iOther.preModulesInitializationFinalizedSignal_)); + postModulesInitializationFinalizedSignal_.connect(std::cref(iOther.postModulesInitializationFinalizedSignal_)); beginProcessingSignal_.connect(std::cref(iOther.beginProcessingSignal_)); endProcessingSignal_.connect(std::cref(iOther.endProcessingSignal_)); postBeginJobSignal_.connect(std::cref(iOther.postBeginJobSignal_)); @@ -259,8 +272,22 @@ namespace edm { } void ActivityRegistry::copySlotsFrom(ActivityRegistry& iOther) { + copySlotsToFrom(postServicesConstructionSignal_, iOther.postServicesConstructionSignal_); + copySlotsToFrom(preEventSetupModulesConstructionSignal_, iOther.preEventSetupModulesConstructionSignal_); + copySlotsToFromReverse(postEventSetupModulesConstructionSignal_, iOther.postEventSetupModulesConstructionSignal_); + copySlotsToFrom(preFinishScheduleSignal_, iOther.preFinishScheduleSignal_); + copySlotsToFromReverse(postFinishScheduleSignal_, iOther.postFinishScheduleSignal_); + copySlotsToFrom(prePrincipalsCreationSignal_, iOther.prePrincipalsCreationSignal_); + copySlotsToFromReverse(postPrincipalsCreationSignal_, iOther.postPrincipalsCreationSignal_); + copySlotsToFrom(preScheduleConsistencyCheckSignal_, iOther.preScheduleConsistencyCheckSignal_); + copySlotsToFromReverse(postScheduleConsistencyCheckSignal_, iOther.postScheduleConsistencyCheckSignal_); copySlotsToFrom(preallocateSignal_, iOther.preallocateSignal_); + copySlotsToFrom(preEventSetupConfigurationFinalizedSignal_, iOther.preEventSetupConfigurationFinalizedSignal_); + copySlotsToFromReverse(postEventSetupConfigurationFinalizedSignal_, + iOther.postEventSetupConfigurationFinalizedSignal_); copySlotsToFrom(eventSetupConfigurationSignal_, iOther.eventSetupConfigurationSignal_); + copySlotsToFrom(preModulesInitializationFinalizedSignal_, iOther.preModulesInitializationFinalizedSignal_); + copySlotsToFromReverse(postModulesInitializationFinalizedSignal_, iOther.postModulesInitializationFinalizedSignal_); copySlotsToFrom(beginProcessingSignal_, iOther.beginProcessingSignal_); copySlotsToFrom(endProcessingSignal_, iOther.endProcessingSignal_); copySlotsToFrom(preBeginJobSignal_, iOther.preBeginJobSignal_);