Added noexcept to methods called by async functions

The frameworks internal async functions assume that no exceptions
happen during the call. By adding noexcept to methods they call
the C++ runtime will enforce this requirement.

FWCore/Concurrency/interface/TaskBase.h

@@ -33,13 +33,13 @@ namespace edm {
     friend class TaskSentry;
 
     ///Constructor
-    TaskBase() : m_refCount{0} {}
-    virtual ~TaskBase() = default;
+    TaskBase() noexcept : m_refCount{0} {}
+    virtual ~TaskBase() noexcept = default;
 
     virtual void execute() = 0;
 
-    void increment_ref_count() { ++m_refCount; }
-    unsigned int decrement_ref_count() { return --m_refCount; }
+    void increment_ref_count() noexcept { ++m_refCount; }
+    unsigned int decrement_ref_count() noexcept { return --m_refCount; }
 
   private:
     virtual void recycle() { delete this; }
@@ -49,7 +49,7 @@ namespace edm {
 
   class TaskSentry {
   public:
-    TaskSentry(TaskBase* iTask) : m_task{iTask} {}
+    TaskSentry(TaskBase* iTask) noexcept : m_task{iTask} {}
     ~TaskSentry() { m_task->recycle(); }
     TaskSentry() = delete;
     TaskSentry(TaskSentry const&) = delete;

FWCore/Concurrency/interface/WaitingTask.h

@@ -40,23 +40,23 @@ namespace edm {
     friend class WaitingTaskWithArenaHolder;
 
     ///Constructor
-    WaitingTask() : m_ptr{} {}
-    ~WaitingTask() override{};
+    WaitingTask() noexcept : m_ptr{} {}
+    ~WaitingTask() noexcept override{};
 
     // ---------- const member functions ---------------------------
 
     ///Returns exception thrown by dependent task
     /** If the value evalutes to true then the dependent task failed.
     */
-    std::exception_ptr exceptionPtr() const {
+    std::exception_ptr exceptionPtr() const noexcept {
       if (m_ptrSet == static_cast<unsigned char>(State::kSet)) {
         return m_ptr;
       }
       return std::exception_ptr{};
     }
 
   protected:
-    std::exception_ptr const& uncheckedExceptionPtr() const { return m_ptr; }
+    std::exception_ptr const& uncheckedExceptionPtr() const noexcept { return m_ptr; }
 
   private:
     enum class State : unsigned char { kUnset = 0, kSetting = 1, kSet = 2 };
@@ -65,7 +65,7 @@ namespace edm {
      * moved to another thread.
      * This method should only be called by WaitingTaskList
      */
-    void dependentTaskFailed(std::exception_ptr iPtr) {
+    void dependentTaskFailed(std::exception_ptr iPtr) noexcept {
       unsigned char isSet = static_cast<unsigned char>(State::kUnset);
       if (iPtr and m_ptrSet.compare_exchange_strong(isSet, static_cast<unsigned char>(State::kSetting))) {
         m_ptr = iPtr;

FWCore/Concurrency/interface/WaitingTaskHolder.h

@@ -36,32 +36,32 @@ namespace edm {
 
     WaitingTaskHolder() : m_task(nullptr), m_group(nullptr) {}
 
-    explicit WaitingTaskHolder(oneapi::tbb::task_group& iGroup, edm::WaitingTask* iTask)
+    explicit WaitingTaskHolder(oneapi::tbb::task_group& iGroup, edm::WaitingTask* iTask) noexcept
         : m_task(iTask), m_group(&iGroup) {
       m_task->increment_ref_count();
     }
-    ~WaitingTaskHolder() {
+    ~WaitingTaskHolder() noexcept {
       if (m_task) {
         doneWaiting(std::exception_ptr{});
       }
     }
 
-    WaitingTaskHolder(const WaitingTaskHolder& iHolder) : m_task(iHolder.m_task), m_group(iHolder.m_group) {
+    WaitingTaskHolder(const WaitingTaskHolder& iHolder) noexcept : m_task(iHolder.m_task), m_group(iHolder.m_group) {
       m_task->increment_ref_count();
     }
 
-    WaitingTaskHolder(WaitingTaskHolder&& iOther) : m_task(iOther.m_task), m_group(iOther.m_group) {
+    WaitingTaskHolder(WaitingTaskHolder&& iOther) noexcept : m_task(iOther.m_task), m_group(iOther.m_group) {
       iOther.m_task = nullptr;
     }
 
-    WaitingTaskHolder& operator=(const WaitingTaskHolder& iRHS) {
+    WaitingTaskHolder& operator=(const WaitingTaskHolder& iRHS) noexcept {
       WaitingTaskHolder tmp(iRHS);
       std::swap(m_task, tmp.m_task);
       std::swap(m_group, tmp.m_group);
       return *this;
     }
 
-    WaitingTaskHolder& operator=(WaitingTaskHolder&& iRHS) {
+    WaitingTaskHolder& operator=(WaitingTaskHolder&& iRHS) noexcept {
       WaitingTaskHolder tmp(std::move(iRHS));
       std::swap(m_task, tmp.m_task);
       std::swap(m_group, tmp.m_group);
@@ -85,13 +85,13 @@ namespace edm {
      a different, but related failure. You must later call doneWaiting
      in the same thread passing the same exceptoin.
      */
-    void presetTaskAsFailed(std::exception_ptr iExcept) {
+    void presetTaskAsFailed(std::exception_ptr iExcept) noexcept {
       if (iExcept) {
         m_task->dependentTaskFailed(iExcept);
       }
     }
 
-    void doneWaiting(std::exception_ptr iExcept) {
+    void doneWaiting(std::exception_ptr iExcept) noexcept {
       if (iExcept) {
         m_task->dependentTaskFailed(iExcept);
       }

FWCore/Framework/interface/Callback.h

@@ -56,7 +56,7 @@ namespace edm {
                          EventSetupRecordImpl const* iRecord,
                          EventSetupImpl const* iEventSetupImpl,
                          ServiceToken const& token,
-                         ESParentContext const& iParent) {
+                         ESParentContext const& iParent) noexcept {
         return Base::prefetchAsyncImpl(
             [this](auto&& group, auto&& token, auto&& record, auto&& es) {
               constexpr bool emitPostPrefetchingSignal = true;

FWCore/Framework/interface/CallbackBase.h

@@ -165,7 +165,7 @@ namespace edm {
                              EventSetupRecordImpl const* iRecord,
                              EventSetupImpl const* iEventSetupImpl,
                              ServiceToken const& token,
-                             ESParentContext const& iParent) {
+                             ESParentContext const& iParent) noexcept {
         bool expected = false;
         auto doPrefetch = wasCalledForThisRecord_.compare_exchange_strong(expected, true);
         taskList_.add(iTask);
@@ -221,16 +221,16 @@ namespace edm {
         taskList_.reset();
       }
 
-      unsigned int transitionID() const { return id_; }
-      ESResolverIndex const* getTokenIndices() const { return producer_->getTokenIndices(id_); }
+      unsigned int transitionID() const noexcept { return id_; }
+      ESResolverIndex const* getTokenIndices() const noexcept { return producer_->getTokenIndices(id_); }
 
       std::optional<std::vector<ESResolverIndex>> const& postMayGetResolvers() const { return postMayGetResolvers_; }
-      T* producer() { return producer_.get(); }
-      ESModuleCallingContext& callingContext() { return callingContext_; }
-      WaitingTaskList& taskList() { return taskList_; }
-      std::shared_ptr<TProduceFunc> const& produceFunction() { return produceFunction_; }
-      TDecorator const& decorator() const { return decorator_; }
-      SerialTaskQueueChain& queue() { return producer_->queue(); }
+      T* producer() noexcept { return producer_.get(); }
+      ESModuleCallingContext& callingContext() noexcept { return callingContext_; }
+      WaitingTaskList& taskList() noexcept { return taskList_; }
+      std::shared_ptr<TProduceFunc> const& produceFunction() noexcept { return produceFunction_; }
+      TDecorator const& decorator() const noexcept { return decorator_; }
+      SerialTaskQueueChain& queue() noexcept { return producer_->queue(); }
 
     protected:
       ~CallbackBase() = default;
@@ -244,7 +244,7 @@ namespace edm {
       void prefetchNeededDataAsync(WaitingTaskHolder task,
                                    EventSetupImpl const* iImpl,
                                    ESResolverIndex const* proxies,
-                                   ServiceToken const& token) const {
+                                   ServiceToken const& token) const noexcept {
         auto recs = producer_->getTokenRecordIndices(id_);
         auto n = producer_->numberOfTokenIndices(id_);
         for (size_t i = 0; i != n; ++i) {

FWCore/Framework/interface/CallbackExternalWork.h

@@ -101,7 +101,7 @@ namespace edm {
                          EventSetupRecordImpl const* iRecord,
                          EventSetupImpl const* iEventSetupImpl,
                          ServiceToken const& token,
-                         ESParentContext const& iParent) {
+                         ESParentContext const& iParent) noexcept {
         return Base::prefetchAsyncImpl(
             [this](auto&& group, auto&& token, auto&& record, auto&& es) {
               constexpr bool emitPostPrefetchingSignal = false;

FWCore/Framework/interface/CallbackProductResolver.h

@@ -59,7 +59,7 @@ namespace edm::eventsetup {
                            const DataKey&,
                            EventSetupImpl const* iEventSetupImpl,
                            ServiceToken const& iToken,
-                           edm::ESParentContext const& iParent) final {
+                           edm::ESParentContext const& iParent) noexcept final {
       assert(iRecord.key() == RecordT::keyForClass());
       callback_->prefetchAsync(iWaitTask, &iRecord, iEventSetupImpl, iToken, iParent);
     }

FWCore/Framework/interface/EDLooperBase.h

@@ -107,12 +107,12 @@ namespace edm {
                        ServiceToken const& token,
                        Transition iTrans,
                        Principal const& iPrincipal,
-                       EventSetupImpl const& iImpl) const;
+                       EventSetupImpl const& iImpl) const noexcept;
 
     void esPrefetchAsync(WaitingTaskHolder iTask,
                          EventSetupImpl const& iImpl,
                          Transition iTrans,
-                         ServiceToken const& iToken) const;
+                         ServiceToken const& iToken) const noexcept;
 
     ///Override this method if you need to monitor the state of the processing
     virtual void attachTo(ActivityRegistry&);
@@ -159,7 +159,9 @@ namespace edm {
     ///Called after all event modules have processed the end of a LuminosityBlock
     virtual void endLuminosityBlock(LuminosityBlock const&, EventSetup const&);
 
-    void edPrefetchAsync(WaitingTaskHolder iTask, ServiceToken const& token, Principal const& iPrincipal) const;
+    void edPrefetchAsync(WaitingTaskHolder iTask,
+                         ServiceToken const& token,
+                         Principal const& iPrincipal) const noexcept;
 
     unsigned int iCounter_;
     ExceptionToActionTable const* act_table_;

FWCore/Framework/interface/ESProductResolver.h

@@ -52,7 +52,7 @@ namespace edm {
                          DataKey const&,
                          EventSetupImpl const*,
                          ServiceToken const&,
-                         ESParentContext const&) const;
+                         ESParentContext const&) const noexcept;
 
       void const* getAfterPrefetch(const EventSetupRecordImpl& iRecord, const DataKey& iKey, bool iTransiently) const;
 
@@ -83,7 +83,7 @@ namespace edm {
                                      DataKey const& iKey,
                                      EventSetupImpl const*,
                                      ServiceToken const&,
-                                     ESParentContext const&) = 0;
+                                     ESParentContext const&) noexcept = 0;
 
       /** indicates that the Resolver should invalidate any cached information
           as that information has 'expired' (i.e. we have moved to a new IOV)

FWCore/Framework/interface/ESProductResolverTemplate.h

@@ -62,7 +62,7 @@ namespace edm {
                              const DataKey& iKey,
                              EventSetupImpl const* iEventSetupImpl,
                              edm::ServiceToken const& iToken,
-                             edm::ESParentContext const& iParent) override {
+                             edm::ESParentContext const& iParent) noexcept override {
         assert(iRecord.key() == RecordT::keyForClass());
         bool expected = false;
         bool doPrefetch = prefetching_.compare_exchange_strong(expected, true);

FWCore/Framework/interface/ESSourceProductResolverConcurrentBase.h

@@ -39,7 +39,7 @@ namespace edm::eventsetup {
                            edm::eventsetup::DataKey const& iKey,
                            edm::EventSetupImpl const*,
                            edm::ServiceToken const&,
-                           edm::ESParentContext const&) final;
+                           edm::ESParentContext const&) noexcept final;
 
     // ---------- member data --------------------------------
   };

FWCore/Framework/interface/ESSourceProductResolverNonConcurrentBase.h

@@ -47,7 +47,7 @@ namespace edm::eventsetup {
                            edm::eventsetup::DataKey const& iKey,
                            edm::EventSetupImpl const*,
                            edm::ServiceToken const&,
-                           edm::ESParentContext const&) final;
+                           edm::ESParentContext const&) noexcept final;
 
     // ---------- member data --------------------------------
 

FWCore/Framework/interface/EventForTransformer.h

@@ -28,13 +28,13 @@ namespace edm {
 
   class EventForTransformer {
   public:
-    EventForTransformer(EventPrincipal const&, ModuleCallingContext);
+    EventForTransformer(EventPrincipal const&, ModuleCallingContext) noexcept;
 
     BasicHandle get(edm::TypeID const& iTypeID, ProductResolverIndex iIndex) const;
 
     void put(ProductResolverIndex index, std::unique_ptr<WrapperBase> edp, BasicHandle const& iGetHandle);
 
-    ModuleCallingContext const& moduleCallingContext() const { return mcc_; }
+    ModuleCallingContext const& moduleCallingContext() const noexcept { return mcc_; }
 
   private:
     EventPrincipal const& eventPrincipal_;

FWCore/Framework/interface/EventSetupRecordImpl.h

@@ -87,7 +87,7 @@ namespace edm {
                          ESResolverIndex iResolverIndex,
                          EventSetupImpl const*,
                          ServiceToken const&,
-                         ESParentContext) const;
+                         ESParentContext) const noexcept;
 
       /**returns true only if someone has already requested data for this key
           and the data was retrieved

FWCore/Framework/interface/OutputModuleCommunicator.h

@@ -57,18 +57,18 @@ namespace edm {
     virtual void writeProcessBlockAsync(WaitingTaskHolder iTask,
                                         ProcessBlockPrincipal const&,
                                         ProcessContext const*,
-                                        ActivityRegistry*) = 0;
+                                        ActivityRegistry*) noexcept = 0;
 
     virtual void writeRunAsync(WaitingTaskHolder iTask,
                                RunPrincipal const&,
                                ProcessContext const*,
                                ActivityRegistry*,
-                               MergeableRunProductMetadata const*) = 0;
+                               MergeableRunProductMetadata const*) noexcept = 0;
 
     virtual void writeLumiAsync(WaitingTaskHolder iTask,
                                 LuminosityBlockPrincipal const&,
                                 ProcessContext const*,
-                                ActivityRegistry*) = 0;
+                                ActivityRegistry*) noexcept = 0;
 
     ///\return true if OutputModule has reached its limit on maximum number of events it wants to see
     virtual bool limitReached() const = 0;

FWCore/Framework/interface/OutputModuleCommunicatorT.h

@@ -46,18 +46,18 @@ namespace edm {
     void writeProcessBlockAsync(WaitingTaskHolder iTask,
                                 ProcessBlockPrincipal const&,
                                 ProcessContext const*,
-                                ActivityRegistry*) override;
+                                ActivityRegistry*) noexcept override;
 
     void writeRunAsync(WaitingTaskHolder iTask,
                        edm::RunPrincipal const& rp,
                        ProcessContext const*,
                        ActivityRegistry*,
-                       MergeableRunProductMetadata const*) override;
+                       MergeableRunProductMetadata const*) noexcept override;
 
     void writeLumiAsync(WaitingTaskHolder iTask,
                         edm::LuminosityBlockPrincipal const& lbp,
                         ProcessContext const*,
-                        ActivityRegistry*) override;
+                        ActivityRegistry*) noexcept override;
 
     ///\return true if OutputModule has reached its limit on maximum number of events it wants to see
     bool limitReached() const override;
@@ -81,7 +81,7 @@ namespace edm {
     }
 
   private:
-    inline T& module() const { return *module_; }
+    inline T& module() const noexcept { return *module_; }
     T* module_;
   };
 }  // namespace edm

FWCore/Framework/interface/OutputModuleCore.h

@@ -217,8 +217,8 @@ namespace edm {
 
       void registerProductsAndCallbacks(OutputModuleCore const*, ProductRegistry*);
 
-      bool needToRunSelection() const;
-      std::vector<ProductResolverIndexAndSkipBit> productsUsedBySelection() const;
+      bool needToRunSelection() const noexcept;
+      std::vector<ProductResolverIndexAndSkipBit> productsUsedBySelection() const noexcept;
       bool prePrefetchSelection(StreamID id, EventPrincipal const&, ModuleCallingContext const*);
 
       // Do the end-of-file tasks; this is only called internally, after
@@ -247,7 +247,7 @@ namespace edm {
 
       virtual void setProcessesWithSelectedMergeableRunProducts(std::set<std::string> const&) {}
 
-      bool hasAccumulator() const { return false; }
+      bool hasAccumulator() const noexcept { return false; }
 
       void keepThisBranch(BranchDescription const& desc,
                           std::map<BranchID, BranchDescription const*>& trueBranchIDToKeptBranchDesc,

FWCore/Framework/interface/ProductProvenanceRetriever.h

@@ -31,7 +31,7 @@ namespace edm {
     virtual void readProvenanceAsync(WaitingTaskHolder task,
                                      ModuleCallingContext const* moduleCallingContext,
                                      unsigned int transitionIndex,
-                                     std::atomic<const std::set<ProductProvenance>*>& writeTo) const = 0;
+                                     std::atomic<const std::set<ProductProvenance>*>& writeTo) const noexcept = 0;
   };
 
   class ProductProvenanceRetriever : public ProductProvenanceLookup {
@@ -50,7 +50,7 @@ namespace edm {
 
     void reset();
 
-    void readProvenanceAsync(WaitingTaskHolder task, ModuleCallingContext const* moduleCallingContext) const;
+    void readProvenanceAsync(WaitingTaskHolder task, ModuleCallingContext const* moduleCallingContext) const noexcept;
 
   private:
     std::unique_ptr<const std::set<ProductProvenance>> readProvenance() const final;

FWCore/Framework/interface/ProductResolverBase.h

@@ -71,7 +71,7 @@ namespace edm {
                        bool skipCurrentProcess,
                        ServiceToken const& token,
                        SharedResourcesAcquirer* sra,
-                       ModuleCallingContext const* mcc) const {
+                       ModuleCallingContext const* mcc) const noexcept {
       return prefetchAsync_(waitTask, principal, skipCurrentProcess, token, sra, mcc);
     }
 
@@ -172,7 +172,7 @@ namespace edm {
                                 bool skipCurrentProcess,
                                 ServiceToken const& token,
                                 SharedResourcesAcquirer* sra,
-                                ModuleCallingContext const* mcc) const = 0;
+                                ModuleCallingContext const* mcc) const noexcept = 0;
 
     virtual void retrieveAndMerge_(Principal const& principal,
                                    MergeableRunProductMetadata const* mergeableRunProductMetadata) const;