WaitingTaskList.h

Go to the documentation of this file.

#ifndef FWCore_Concurrency_WaitingTaskList_h
#define FWCore_Concurrency_WaitingTaskList_h
// -*- C++ -*-
//
// Package:     Concurrency
// Class  :     WaitingTaskList
// 
//
// Original Author:  Chris Jones
//         Created:  Thu Feb 21 13:46:31 CST 2013
// $Id$
//

// system include files
#include <atomic>

// user include files
#include "FWCore/Concurrency/interface/WaitingTask.h"
#include "FWCore/Utilities/interface/thread_safety_macros.h"

// forward declarations

namespace edm {
   class EmptyWaitingTask : public WaitingTask {
   public:
      EmptyWaitingTask() = default;
      
      tbb::task* execute() override { return nullptr;}
   };

   namespace waitingtask {
      struct TaskDestroyer {
         void operator()(tbb::task* iTask) const {
            tbb::task::destroy(*iTask);
         }
      };
   }
   inline std::unique_ptr<edm::EmptyWaitingTask, waitingtask::TaskDestroyer> make_empty_waiting_task() {
      return std::unique_ptr<edm::EmptyWaitingTask, waitingtask::TaskDestroyer>( new (tbb::task::allocate_root()) edm::EmptyWaitingTask{});
   }

   class WaitingTaskList
   {
      
   public:

      explicit WaitingTaskList(unsigned int iInitialSize = 2);
      ~WaitingTaskList() = default;
      
      // ---------- member functions ---------------------------
      
      void presetTaskAsFailed(std::exception_ptr iExcept);


      void add(WaitingTask*);
      

      void doneWaiting(std::exception_ptr iPtr);
      

      void reset();
      
   private:
      WaitingTaskList(const WaitingTaskList&) = delete; // stop default
      const WaitingTaskList& operator=(const WaitingTaskList&) = delete; // stop default
      
      void announce();
      
      struct WaitNode {
         WaitingTask* m_task;
         std::atomic<WaitNode*> m_next;
         bool m_fromCache;
         
         void setNextNode(WaitNode* iNext){
            m_next = iNext;
         }
         
         WaitNode* nextNode() const {
            return m_next;
         }
      };
      
      WaitNode* createNode(WaitingTask* iTask);
      
      
      // ---------- member data --------------------------------
      std::atomic<WaitNode*> m_head;
      std::unique_ptr<WaitNode[]> m_nodeCache;
      CMS_THREAD_GUARD(m_waiting) std::exception_ptr m_exceptionPtr;
      unsigned int m_nodeCacheSize;
      std::atomic<unsigned int> m_lastAssignedCacheIndex;
      std::atomic<bool> m_waiting;    
   };
}

#endif