AlgResourcePool.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 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.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/IAlgManager.h>
#include <GaudiKernel/IAlgResourcePool.h>
#include <GaudiKernel/IAlgorithm.h>
#include <GaudiKernel/Service.h>
#include <atomic>
#include <bitset>
#include <boost/dynamic_bitset.hpp>
#include <list>
#include <map>
#include <mutex>
#include <string>
#include <string_view>
#include <tbb/concurrent_queue.h>
#include <unordered_map>
#include <vector>

class AlgResourcePool : public extends<Service, IAlgResourcePool> {
public:
  // Standard constructor
  using extends::extends;
  // Standard destructor
  ~AlgResourcePool() override;
 
  StatusCode start() override;
  StatusCode initialize() override;
  StatusCode acquireAlgorithm( std::string_view name, IAlgorithm*& algo, bool blocking = false ) override;
  StatusCode releaseAlgorithm( std::string_view name, IAlgorithm*& algo ) override;
  StatusCode acquireResource( std::string_view name ) override;
  StatusCode releaseResource( std::string_view name ) override;
 
  std::list<IAlgorithm*> getFlatAlgList() override;
  std::list<IAlgorithm*> getTopAlgList() override;
 
  StatusCode stop() override;
  StatusCode finalize() override;
 
private:
  typedef tbb::concurrent_bounded_queue<IAlgorithm*> concurrentQueueIAlgPtr;
  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_view, unsigned int>  m_resource_indices;

  StatusCode decodeTopAlgs();

  StatusCode flattenSequencer( IAlgorithm* sequencer, std::list<IAlgorithm*>& alglist,
                               unsigned int recursionDepth = 0 );

  void dumpInstanceMisses() const;
  std::unordered_map<std::string_view, unsigned int> m_algInstanceMisses;
 
  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!" };
  Gaudi::Property<bool> m_countAlgInstMisses{
      this, "CountAlgorithmInstanceMisses", false,
      "Count and print out algorithm instance misses. Useful for finding ways to improve throughput scalability." };

  std::list<IAlgorithm*> m_algList;

  std::list<IAlgorithm*> m_topAlgList;

  std::list<IAlgorithm*> m_flatUniqueAlgList;
};