SerialTaskQueue.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
/*
 * SerialTaskQueue.h
 *
 * @date   2012-10-21
 * @author Marco Clemencic
 */

#ifndef SERIALTASKQUEUE_H_
#define SERIALTASKQUEUE_H_

#include <atomic>
#include <memory>

#include <tbb/concurrent_queue.h>
#include <tbb/task.h>

namespace Gaudi {

  class SerialTaskQueue {
  public:
    class WorkItem {
    public:
      virtual ~WorkItem();
      virtual void run() = 0;
    };

    SerialTaskQueue();

    virtual ~SerialTaskQueue();

    void add( WorkItem* item );

    void noteCompletion();

    void wait() const;

  private:
    class SerialWorkItem {
    public:
      SerialWorkItem( WorkItem* item, SerialTaskQueue* serializer ) : m_item( item ), m_serializer( serializer ) {}
      void run();

    private:
      std::unique_ptr<WorkItem> m_item;
      SerialTaskQueue* m_serializer;
    };

    class SerialWorkItemRunner : public tbb::task {
    public:
      SerialWorkItemRunner( SerialWorkItem* item ) : m_item( item ) {}
      tbb::task* execute() override {
        m_item->run();
        return NULL;
      }

    private:
      SerialWorkItem* m_item;
    };

    void i_startNextItem();

    std::atomic<int> m_count;
    tbb::concurrent_queue<SerialWorkItem*> m_queue;
  };

  inline void SerialTaskQueue::SerialWorkItem::run() {
    // run the wrapped task
    m_item->run();

    // We need to keep the pointer on the stack because we are going to delete
    // ourselves.
    SerialTaskQueue* serializer = m_serializer;

    // We call the delete before returning the control to the serialized so that
    // possible complex code in the task destructor is executed serially.
    delete this;

    // Notify the queue of the completion, so that it can schedule the next task.
    serializer->noteCompletion();
  }

} /* namespace Gaudi */
#endif /* SERIALTASKQUEUE_H_ */