WaitingTaskWithArenaHolder.h

Go to the documentation of this file.

#ifndef FWCore_Concurrency_WaitingTaskWithArenaHolder_h
#define FWCore_Concurrency_WaitingTaskWithArenaHolder_h
// -*- C++ -*-
//
// Package:     FWCore/Concurrency
// Class  :     WaitingTaskWithArenaHolder
//
//
// Original Author:  W. David Dagenhart
//         Created:  9 November 2017
//

#include <exception>
#include <memory>

#include "oneapi/tbb/task_arena.h"
#include "oneapi/tbb/task_group.h"

#include "FWCore/Utilities/interface/thread_safety_macros.h"

namespace edm {
  class WaitingTask;
  class WaitingTaskHolder;

  class WaitingTaskWithArenaHolder {
  public:
    WaitingTaskWithArenaHolder();

    // Note that the arena will be the one containing the thread
    // that runs this constructor. This is the arena where you
    // eventually intend for the task to be spawned.
    explicit WaitingTaskWithArenaHolder(oneapi::tbb::task_group&, WaitingTask* iTask);

    // Takes ownership of the underlying task and uses the current
    // arena.
    explicit WaitingTaskWithArenaHolder(WaitingTaskHolder&& iTask);

    ~WaitingTaskWithArenaHolder();

    WaitingTaskWithArenaHolder(WaitingTaskWithArenaHolder const& iHolder);

    WaitingTaskWithArenaHolder(WaitingTaskWithArenaHolder&& iOther);

    WaitingTaskWithArenaHolder& operator=(const WaitingTaskWithArenaHolder& iRHS);

    WaitingTaskWithArenaHolder& operator=(WaitingTaskWithArenaHolder&& iRHS);

    // This spawns the task. The arena is needed to get the task spawned
    // into the correct arena of threads. Use of the arena allows doneWaiting
    // to be called from a thread outside the arena of threads that will manage
    // the task. doneWaiting can be called from a non-TBB thread.
    void doneWaiting(std::exception_ptr iExcept);

    // Use in the case where you need to inform the parent task of a
    // failure before some other child task which may be run later
    // reports a different, but related failure. You must later call
    // doneWaiting in the same thread passing the same exception.
    void presetTaskAsFailed(std::exception_ptr iExcept) noexcept;

    // This next function is useful if you know from the context that
    // m_arena (which is set when the constructor was executes) is the
    // same arena in which you want to execute the doneWaiting function.
    // It allows an optimization which avoids the enqueue step in the
    // doneWaiting function.
    //
    // Be warned though that in general this function cannot be used.
    // Spawning a task outside the correct arena could create a new separate
    // arena with its own extra TBB worker threads if this function is used
    // in an inappropriate context (and silently such that you might not notice
    // the problem quickly).
    WaitingTaskHolder makeWaitingTaskHolderAndRelease();

    bool taskHasFailed() const noexcept;

    bool hasTask() const noexcept;

    CMS_SA_ALLOW oneapi::tbb::task_group* group() const { return m_group; }

  private:
    // ---------- member data --------------------------------
    WaitingTask* m_task;
    oneapi::tbb::task_group* m_group;
    std::shared_ptr<oneapi::tbb::task_arena> m_arena;
  };

  template <typename F>
  auto make_lambda_with_holder(WaitingTaskWithArenaHolder h, F&& f) {
    return [holder = std::move(h), func = std::forward<F>(f)]() mutable {
      try {
        func(holder);
      } catch (...) {
        holder.doneWaiting(std::current_exception());
      }
    };
  }

  template <typename F>
  auto make_waiting_task_with_holder(WaitingTaskWithArenaHolder h, F&& f) {
    return make_waiting_task(
        [holder = h, func = make_lambda_with_holder(h, std::forward<F>(f))](std::exception_ptr const* excptr) mutable {
          if (excptr) {
            holder.doneWaiting(*excptr);
            return;
          }
          func();
        });
  }
}  // namespace edm
#endif