AlgResourcePool.h

Go to the documentation of this file.

#ifndef GAUDIHIVE_ALGRESOURCEPOOL_H
#define GAUDIHIVE_ALGRESOURCEPOOL_H

// Include files
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/IAlgManager.h"
#include "GaudiKernel/IAlgResourcePool.h"
#include "GaudiKernel/IAlgorithm.h"
#include "GaudiKernel/Service.h"

// TODO: include here is only a workaround
#include "ExecutionFlowGraph.h"

// std includes
#include <atomic>
#include <bitset>
#include <list>
#include <mutex>
#include <string>
#include <vector>

// External libs
#include "boost/dynamic_bitset.hpp"
#include "tbb/concurrent_queue.h"

class AlgResourcePool : public extends<Service, IAlgResourcePool>
{
public:
  // Standard constructor
  using extends::extends;
  // Standard destructor
  ~AlgResourcePool() override;

  StatusCode start() override;
  StatusCode initialize() override;
  StatusCode acquireAlgorithm( const std::string& name, IAlgorithm*& algo, bool blocking = false ) override;
  StatusCode releaseAlgorithm( const std::string& name, IAlgorithm*& algo ) override;
  StatusCode acquireResource( const std::string& name ) override;
  StatusCode releaseResource( const std::string& name ) override;

  std::list<IAlgorithm*> getFlatAlgList() override;
  std::list<IAlgorithm*> getTopAlgList() override;

  StatusCode beginRun() override;
  StatusCode endRun() override;

  StatusCode stop() override;

  virtual concurrency::ExecutionFlowGraph* getExecutionFlowGraph() const { return m_EFGraph; }

private:
  typedef tbb::concurrent_bounded_queue<IAlgorithm*> concurrentQueueIAlgPtr;
  typedef std::list<SmartIF<IAlgorithm>> ListAlg;
  typedef boost::dynamic_bitset<> state_type;

  std::mutex m_resource_mutex;

  state_type m_available_resources{0};
  std::map<size_t, concurrentQueueIAlgPtr*> m_algqueue_map;
  std::map<size_t, state_type> m_resource_requirements;
  std::map<size_t, size_t> m_n_of_allowed_instances;
  std::map<size_t, unsigned int> m_n_of_created_instances;
  std::map<std::string, unsigned int> m_resource_indices;

  StatusCode decodeTopAlgs();

  StatusCode flattenSequencer( Algorithm* sequencer, ListAlg& alglist, const std::string& parentName,
                               unsigned int recursionDepth = 0 );

  Gaudi::Property<bool> m_lazyCreation{this, "CreateLazily", false, ""};
  Gaudi::Property<std::vector<std::string>> m_topAlgNames{
      this, "TopAlg", {}, "names of the algorithms to be passed to the algorithm manager"};

  ListAlg m_algList;

  ListAlg m_topAlgList;

  ListAlg m_flatUniqueAlgList;

  std::list<IAlgorithm*> m_flatUniqueAlgPtrList;

  std::list<IAlgorithm*> m_topAlgPtrList;

  concurrency::ExecutionFlowGraph* m_EFGraph = nullptr;
};

#endif // GAUDIHIVE_ALGRESOURCEPOOL_H