AlgResourcePool.h

Go to the documentation of this file.

#ifndef GAUDIHIVE_ALGRESOURCEPOOL_H
#define GAUDIHIVE_ALGRESOURCEPOOL_H

#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 "ControlFlowGraph.h"

#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;

  concurrency::recursive_CF::ControlFlowGraph* getCFGraph() const { return m_CFGraph; }

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"};
  Gaudi::Property<bool> m_overrideUnClonable{this, "OverrideUnClonable", false,
                                             "override the Un-Clonability of Algorithms. Use with caution!"};

  ListAlg m_algList;

  ListAlg m_topAlgList;

  ListAlg m_flatUniqueAlgList;

  std::list<IAlgorithm*> m_flatUniqueAlgPtrList;

  std::list<IAlgorithm*> m_topAlgPtrList;

  concurrency::recursive_CF::ControlFlowGraph* m_CFGraph = nullptr;
};

#endif // GAUDIHIVE_ALGRESOURCEPOOL_H