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"

#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 stop() override;

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, 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;
};

#endif // GAUDIHIVE_ALGRESOURCEPOOL_H