GPUClusterSorter Class Reference

Sorts clusters by ET (with possible cut) and creates the list of cells per cluster. More...

#include <GPUClusterSorter.h>

Inheritance diagram for GPUClusterSorter:

Collaboration diagram for GPUClusterSorter:

Public Member Functions
	GPUClusterSorter (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	initialize_non_CUDA () override
	Initialization that does not invoke CUDA functions.
virtual StatusCode	initialize_CUDA () override
	Initialization that invokes CUDA functions.
virtual StatusCode	execute (const EventContext &ctx, const CaloRecGPU::ConstantDataHolder &constant_data, CaloRecGPU::EventDataHolder &event_data, void *temporary_buffer) const override
virtual StatusCode	finalize () override
virtual	~GPUClusterSorter ()=default
void	handle (const Incident &incident) override

Protected Member Functions
void	record_times (const size_t event_num, const std::vector< size_t > &times) const
template<class ... Args>
void	record_times (const size_t event_num, const size_t &value) const
template<class ... Args>
void	record_times (const size_t event_num, const size_t &value, Args &&... args) const
void	print_times (const std::string &header, const size_t time_size) const

Protected Attributes
std::shared_mutex	m_timeMutex
	Mutex that is locked when recording times.
std::vector< size_t > m_times	ATLAS_THREAD_SAFE
	Vector to hold execution times to be recorded if necessary.
std::vector< size_t > m_eventNumbers	ATLAS_THREAD_SAFE
	Vector to hold the event numbers to be recorded if necessary.
Gaudi::Property< bool >	m_measureTimes
	If true, times are recorded to the file given by m_timeFileName.
Gaudi::Property< std::string >	m_timeFileName
	File to which times should be saved.

Private Member Functions
void	record_times_helper (const size_t) const
template<class Arg>
void	record_times_helper (const size_t index, Arg &&arg) const
template<class ... Args>
void	record_times_helper (size_t index, Args &&... args) const

Private Attributes
Gaudi::Property< bool >	m_cutClustersInAbsE {this, "ClusterCutsInAbsEt", true, "Do cluster cuts in Abs Et instead of Et"}
	if set to true cluster cuts are on \(|E|_\perp\), if false on \(E_\perp\).
Gaudi::Property< float >	m_clusterETThreshold {this, "ClusterEtorAbsEtCut", 0.*CLHEP::MeV, "Cluster E_t or Abs E_t cut"}
	\(E_\perp\) cut on the clusters.
ServiceHandle< IGPUKernelSizeOptimizerSvc >	m_kernelSizeOptimizer { this, "KernelSizeOptimizer", "GPUKernelSizeOptimizerSvc", "CUDA kernel size optimization service." }
	Handle to the CUDA kernel block and grid size optimization service.

Detailed Description

Sorts clusters by ET (with possible cut) and creates the list of cells per cluster.

Author

Nuno Fernandes nuno..nosp@m.dos..nosp@m.santo.nosp@m.s.fe.nosp@m.rnand.nosp@m.es@c.nosp@m.ern.c.nosp@m.h

Date

26 October 2025

Definition at line 33 of file GPUClusterSorter.h.

Constructor & Destructor Documentation

GPUClusterSorter()

GPUClusterSorter::GPUClusterSorter	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 16 of file GPUClusterSorter.cxx.

                                                                                                           :
  base_class(type, name, parent),
  CaloGPUTimed(this)
{
}

~GPUClusterSorter()

virtual GPUClusterSorter::~GPUClusterSorter ( )

virtualdefault

Member Function Documentation

execute()

StatusCode GPUClusterSorter::execute ( const EventContext & ctx, const CaloRecGPU::ConstantDataHolder & constant_data, CaloRecGPU::EventDataHolder & event_data, void * temporary_buffer ) const

overridevirtual

Definition at line 34 of file GPUClusterSorter.cxx.

{
  using clock_type = boost::chrono::thread_clock;
  auto time_cast = [](const auto & before, const auto & after)
  {
    return boost::chrono::duration_cast<boost::chrono::microseconds>(after - before).count();
  };
  
  const auto start = clock_type::now();
  
  const auto before_properties = clock_type::now();
  
  initialPropertiesCalculation(event_data, constant_data, *(m_kernelSizeOptimizer.get()), m_measureTimes, m_cutClustersInAbsE, m_clusterETThreshold);
  
  const auto before_sort = clock_type::now();
  
  sortClusters(event_data, constant_data, *(m_kernelSizeOptimizer.get()), m_measureTimes);
  
  const auto before_finalize = clock_type::now();
  
  finalizeClusterAssignment(event_data, constant_data, *(m_kernelSizeOptimizer.get()), m_measureTimes);
  
  const auto end = clock_type::now();
  
  if (m_measureTimes)
    {
      record_times(ctx.evt(),
                   time_cast(start, before_properties),
                   time_cast(before_properties, before_sort),
                   time_cast(before_sort, before_finalize),
                   time_cast(before_finalize, end)
                  );
    }
 
 
  return StatusCode::SUCCESS;
 
}

finalize()

StatusCode GPUClusterSorter::finalize ( )

overridevirtual

Definition at line 74 of file GPUClusterSorter.cxx.

{
  if (m_measureTimes)
    {
      print_times("Preprocessing Calculating_ET Sorting_Clusters Finalizing_Clusters", 4);
    }
  return StatusCode::SUCCESS;
}

handle()

void CaloGPUCUDAInitialization::handle ( const Incident & incident )

inlineoverrideinherited

Definition at line 66 of file CaloGPUCUDAInitialization.h.

  {
    const bool is_multiprocess = (Gaudi::Concurrency::ConcurrencyFlags::numProcs() > 0);
    if (is_multiprocess && incident.type() == AthenaInterprocess::UpdateAfterFork::type())
      {
        if (!this->initialize_CUDA().isSuccess())
        {
          throw GaudiException("Failed to perform the CUDA initialization!",
                               "CaloGPUCUDAInitialization::handle",
                               StatusCode::FAILURE);
        }
      }
  }

initialize()

virtual StatusCode GPUClusterSorter::initialize ( )

inlineoverridevirtual

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 40 of file GPUClusterSorter.h.

  {
    return CaloGPUCUDAInitialization::initialize();
  }

initialize_CUDA()

StatusCode GPUClusterSorter::initialize_CUDA ( )

overridevirtual

Initialization that invokes CUDA functions.

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 28 of file GPUClusterSorter.cxx.

{ 
  register_kernels( *(m_kernelSizeOptimizer.get()) );
  return StatusCode::SUCCESS;
}

initialize_non_CUDA()

StatusCode GPUClusterSorter::initialize_non_CUDA ( )

overridevirtual

Initialization that does not invoke CUDA functions.

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 22 of file GPUClusterSorter.cxx.

{ 
  ATH_CHECK( m_kernelSizeOptimizer.retrieve() );
  return StatusCode::SUCCESS;
}

print_times()

void CaloGPUTimed::print_times ( const std::string & header, const size_t time_size ) const

inlineprotectedinherited

Definition at line 143 of file CaloGPUTimed.h.

  {
    std::shared_lock<std::shared_mutex> lock(m_timeMutex);
    
    if (m_timeFileName.size() == 0)
      {
        return;
      }
    
    std::vector<size_t> indices(m_eventNumbers.size());
    
    std::iota(indices.begin(), indices.end(), 0);
    std::sort(indices.begin(), indices.end(), [&](size_t a, size_t b)
    {
      return m_eventNumbers[a] < m_eventNumbers[b];
    }
             );
    std::ofstream out(m_timeFileName);
 
    out << "Event_Number Total " << header << "\n";
 
    for (const size_t idx : indices)
      {
        out << m_eventNumbers[idx] << " ";
 
        size_t total = 0;
 
        for (size_t i = 0; i < time_size; ++i)
          {
            total += m_times[idx * time_size + i];
          }
 
        out << total << " ";
 
        for (size_t i = 0; i < time_size; ++i)
          {
            out << m_times[idx * time_size + i] << " ";
          }
        out << "\n";
      }
 
    out << std::endl;
 
    out.close();
  }

record_times() [1/3]

template<class ... Args>

void CaloGPUTimed::record_times ( const size_t event_num, const size_t & value ) const

inlineprotectedinherited

Definition at line 105 of file CaloGPUTimed.h.

  {
    const size_t time_size = 1;
 
    size_t old_size;
 
    {
      std::unique_lock<std::shared_mutex> lock(m_timeMutex);
      old_size = m_times.size();
      m_times.resize(old_size + time_size);
      m_eventNumbers.push_back(event_num);
    }
    {
      std::shared_lock<std::shared_mutex> lock(m_timeMutex);
      record_times_helper(old_size, value);
    }
  }

record_times() [2/3]

template<class ... Args>

void CaloGPUTimed::record_times ( const size_t event_num, const size_t & value, Args &&... args ) const

inlineprotectedinherited

Definition at line 124 of file CaloGPUTimed.h.

  {
    const size_t time_size = sizeof...(args) + 1;
 
    size_t old_size;
 
    {
      std::unique_lock<std::shared_mutex> lock(m_timeMutex);
      old_size = m_times.size();
      m_times.resize(old_size + time_size);
      m_eventNumbers.push_back(event_num);
    }
    {
      std::shared_lock<std::shared_mutex> lock(m_timeMutex);
      record_times_helper(old_size, value, std::forward<Args>(args)...);
    }
 
  }

record_times() [3/3]

void CaloGPUTimed::record_times ( const size_t event_num, const std::vector< size_t > & times ) const

inlineprotectedinherited

Definition at line 86 of file CaloGPUTimed.h.

  {
    size_t old_size;
    {
      std::unique_lock<std::shared_mutex> lock(m_timeMutex);
      old_size = m_times.size();
      m_times.resize(old_size + times.size());
      m_eventNumbers.push_back(event_num);
    }
    {
      std::shared_lock<std::shared_mutex> lock(m_timeMutex);
      for (size_t i = 0; i < times.size(); ++i)
        {
          m_times[old_size + i] = times[i];
        }
    }
  }

record_times_helper() [1/3]

template<class Arg>

void CaloGPUTimed::record_times_helper ( const size_t index, Arg && arg ) const

inlineprivateinherited

Definition at line 70 of file CaloGPUTimed.h.

  {
    // coverity[missing_lock]
    m_times[index] = std::forward<Arg>(arg);
    
    //This is called within a function that holds the lock itself.
  }

record_times_helper() [2/3]

void CaloGPUTimed::record_times_helper ( const size_t ) const

inlineprivateinherited

Definition at line 64 of file CaloGPUTimed.h.

  {
    //Do nothing
  }

record_times_helper() [3/3]

template<class ... Args>

void CaloGPUTimed::record_times_helper ( size_t index, Args &&... args ) const

inlineprivateinherited

Definition at line 79 of file CaloGPUTimed.h.

  {
    (record_times_helper(index++, std::forward<Args>(args)), ...);
  }

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

std::vector<size_t> m_times CaloGPUTimed::ATLAS_THREAD_SAFE

mutableprotectedinherited

Vector to hold execution times to be recorded if necessary.

Definition at line 35 of file CaloGPUTimed.h.

ATLAS_THREAD_SAFE [2/2]

std::vector<size_t> m_eventNumbers CaloGPUTimed::ATLAS_THREAD_SAFE

mutableprotectedinherited

Vector to hold the event numbers to be recorded if necessary.

Definition at line 40 of file CaloGPUTimed.h.

m_clusterETThreshold

Gaudi::Property<float> GPUClusterSorter::m_clusterETThreshold {this, "ClusterEtorAbsEtCut", 0.*CLHEP::MeV, "Cluster E_t or Abs E_t cut"}

private

\(E_\perp\) cut on the clusters.

The clusters have to pass this cut (which is on \(E_\perp\) or \(|E|_\perp\) of the cluster depending on the above switch) in order to be inserted into the CaloClusterContainer.

Definition at line 73 of file GPUClusterSorter.h.

{this, "ClusterEtorAbsEtCut", 0.*CLHEP::MeV, "Cluster E_t or Abs E_t cut"};

m_cutClustersInAbsE

Gaudi::Property<bool> GPUClusterSorter::m_cutClustersInAbsE {this, "ClusterCutsInAbsEt", true, "Do cluster cuts in Abs Et instead of Et"}

private

if set to true cluster cuts are on \(|E|_\perp\), if false on \(E_\perp\).

Default is true.

Definition at line 64 of file GPUClusterSorter.h.

{this, "ClusterCutsInAbsEt", true, "Do cluster cuts in Abs Et instead of Et"};

m_kernelSizeOptimizer

ServiceHandle<IGPUKernelSizeOptimizerSvc> GPUClusterSorter::m_kernelSizeOptimizer { this, "KernelSizeOptimizer", "GPUKernelSizeOptimizerSvc", "CUDA kernel size optimization service." }

private

Handle to the CUDA kernel block and grid size optimization service.

Definition at line 76 of file GPUClusterSorter.h.

{ this, "KernelSizeOptimizer", "GPUKernelSizeOptimizerSvc", "CUDA kernel size optimization service." };

m_measureTimes

Gaudi::Property<bool> CaloGPUTimed::m_measureTimes

protectedinherited

If true, times are recorded to the file given by m_timeFileName.

Defaults to false.

Definition at line 46 of file CaloGPUTimed.h.

m_timeFileName

Gaudi::Property<std::string> CaloGPUTimed::m_timeFileName

protectedinherited

File to which times should be saved.

Definition at line 50 of file CaloGPUTimed.h.

m_timeMutex

std::shared_mutex CaloGPUTimed::m_timeMutex

mutableprotectedinherited

Mutex that is locked when recording times.

Definition at line 32 of file CaloGPUTimed.h.

---

The documentation for this class was generated from the following files:

• GPUClusterSorter.h
• GPUClusterSorter.cxx