Standard tool to calculate cluster info (energy, transverse energy, pseudo-rapidity and azimuthal angle) and apply E/ET cuts on clusters if desired. More...

#include <BasicGPUClusterInfoCalculator.h>

Inheritance diagram for BasicGPUClusterInfoCalculator:

Collaboration diagram for BasicGPUClusterInfoCalculator:

Public Member Functions
	BasicGPUClusterInfoCalculator (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. More...

virtual StatusCode	initialize_CUDA () override
	Initialization that invokes CUDA functions. More...

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	~BasicGPUClusterInfoCalculator ()=default

virtual size_t	size_of_temporaries () const override

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. More...

std::vector< size_t > m_times	ATLAS_THREAD_SAFE
	Vector to hold execution times to be recorded if necessary. More...

std::vector< size_t > m_eventNumbers	ATLAS_THREAD_SAFE
	Vector to hold the event numbers to be recorded if necessary. More...

Gaudi::Property< bool >	m_measureTimes
	If `true`, times are recorded to the file given by `m_timeFileName`. More...

Gaudi::Property< std::string >	m_timeFileName
	File to which times should be saved. More...

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_preserveClusterMoments {this, "PreserveClusterMoments", false, "Do not use cluster moments array as temporary storage"}
	If set to `true`, allocates a temporary array to store some temporary intermediate results instead of using cluster moments. More...

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\). More...

Gaudi::Property< float >	m_clusterETThreshold {this, "ClusterEtorAbsEtCut", 0.*CLHEP::MeV, "Cluster E_t or Abs E_t cut"}
	\(E_\perp\) cut on the clusters. More...

ServiceHandle< IGPUKernelSizeOptimizerSvc >	m_kernelSizeOptimizer { this, "KernelSizeOptimizer", "GPUKernelSizeOptimizerSvc", "CUDA kernel size optimization service." }
	Handle to the CUDA kernel block and grid size optimization service. More...

Detailed Description

Standard tool to calculate cluster info (energy, transverse energy, pseudo-rapidity and azimuthal angle) and apply E/ET cuts on clusters if desired.

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: 11 August 2022

Definition at line 34 of file BasicGPUClusterInfoCalculator.h.

Constructor & Destructor Documentation

◆ BasicGPUClusterInfoCalculator()

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

Definition at line 16 of file BasicGPUClusterInfoCalculator.cxx.

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

◆ ~BasicGPUClusterInfoCalculator()

virtual BasicGPUClusterInfoCalculator::~BasicGPUClusterInfoCalculator ( )

virtualdefault

Member Function Documentation

◆ execute()

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

overridevirtual

Definition at line 34 of file BasicGPUClusterInfoCalculator.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();
  
   void * temp_store = (m_preserveClusterMoments ? temporary_buffer : (ClusterMomentsArr *) event_data.m_moments_dev);
  
   Helpers::CUDA_kernel_object<ClusterInfoCalculatorTemporaries> temporaries((ClusterInfoCalculatorTemporaries *) temp_store);
  
   const auto before_seed_properties = clock_type::now();
  
   updateSeedCellProperties(event_data, temporaries, constant_data, *(m_kernelSizeOptimizer.get()), m_measureTimes);
  
   const auto before_calculating = clock_type::now();
  
   calculateClusterProperties(event_data, temporaries, constant_data, *(m_kernelSizeOptimizer.get()), m_measureTimes, m_cutClustersInAbsE, m_clusterETThreshold);
  
   const auto end = clock_type::now();
  
  
   if (m_measureTimes)
     {
       record_times(ctx.evt(),
                    time_cast(start, before_seed_properties),
                    time_cast(before_seed_properties, before_calculating),
                    time_cast(before_calculating, end)
                   );
     }
  
  
   return StatusCode::SUCCESS;
  
 }

◆ finalize()

StatusCode BasicGPUClusterInfoCalculator::finalize ( )

overridevirtual

Definition at line 75 of file BasicGPUClusterInfoCalculator.cxx.

 {
   if (m_measureTimes)
     {
       print_times("Preprocessing Seed_Cell_Properties_Updating Cluster_Properties_Calculation", 3);
     }
   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 BasicGPUClusterInfoCalculator::initialize ( )

inlineoverridevirtual

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 41 of file BasicGPUClusterInfoCalculator.h.

   {
     return CaloGPUCUDAInitialization::initialize();
   }

◆ initialize_CUDA()

StatusCode BasicGPUClusterInfoCalculator::initialize_CUDA ( )

overridevirtual

Initialization that invokes CUDA functions.

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 28 of file BasicGPUClusterInfoCalculator.cxx.

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

◆ initialize_non_CUDA()

StatusCode BasicGPUClusterInfoCalculator::initialize_non_CUDA ( )

overridevirtual

Initialization that does not invoke CUDA functions.

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 22 of file BasicGPUClusterInfoCalculator.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)), ...);
   }

◆ size_of_temporaries()

virtual size_t BasicGPUClusterInfoCalculator::size_of_temporaries ( ) const

inlineoverridevirtual

Definition at line 59 of file BasicGPUClusterInfoCalculator.h.

   {
     if (m_preserveClusterMoments)
       {
         return sizeof(BasicClusterInfoCalculator::ClusterInfoCalculatorTemporaries);
       }
     else
       {
         return 0;
       }
   };

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> BasicGPUClusterInfoCalculator::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 93 of file BasicGPUClusterInfoCalculator.h.

◆ m_cutClustersInAbsE

Gaudi::Property<bool> BasicGPUClusterInfoCalculator::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 84 of file BasicGPUClusterInfoCalculator.h.

◆ m_kernelSizeOptimizer

ServiceHandle<IGPUKernelSizeOptimizerSvc> BasicGPUClusterInfoCalculator::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 96 of file BasicGPUClusterInfoCalculator.h.

◆ 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_preserveClusterMoments

Gaudi::Property<bool> BasicGPUClusterInfoCalculator::m_preserveClusterMoments {this, "PreserveClusterMoments", false, "Do not use cluster moments array as temporary storage"}

private

If set to true, allocates a temporary array to store some temporary intermediate results instead of using cluster moments.

Default is false.

Definition at line 78 of file BasicGPUClusterInfoCalculator.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:

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ BasicGPUClusterInfoCalculator()

◆ ~BasicGPUClusterInfoCalculator()

Member Function Documentation

◆ execute()

◆ finalize()

◆ handle()

◆ initialize()

◆ initialize_CUDA()

◆ initialize_non_CUDA()

◆ print_times()

◆ record_times() [1/3]

◆ record_times() [2/3]

◆ record_times() [3/3]

◆ record_times_helper() [1/3]

◆ record_times_helper() [2/3]

◆ record_times_helper() [3/3]

◆ size_of_temporaries()

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

◆ ATLAS_THREAD_SAFE [2/2]

◆ m_clusterETThreshold

◆ m_cutClustersInAbsE

◆ m_kernelSizeOptimizer

◆ m_measureTimes

◆ m_preserveClusterMoments

◆ m_timeFileName

◆ m_timeMutex