Holds the mutable per-event information (clusters and cells) and provides utilities to convert between this representation and the Athena data structures (i. More...

#include <DataHolders.h>

Collaboration diagram for CaloRecGPU::EventDataHolder:

Public Member Functions
void	returnAndExportClusters (void cluster_collection, const void cell_collection_link, const MomentsOptionsArray &moments_to_add, const bool sort_clusters=true, const bool save_uncalibrated=true, const bool output_extra_moments=false, const std::vector< int > &extra_cells_to_fill={}, size_t *time_measurements=nullptr, CaloRecGPU::CUDA_Helpers::CUDAStreamPtrHolder stream={})
	We are using a void* for API to make this able to compile on the GPU without Athena-specific dependencies.
void	allocate (const bool also_GPU=true)
void	clear_GPU ()

Public Attributes
CaloRecGPU::Helpers::CUDA_pinned_CPU_object< CaloRecGPU::CellInfoArr >	m_cell_info
CaloRecGPU::Helpers::CUDA_pinned_CPU_object< CaloRecGPU::ClusterInfoArr >	m_clusters
CaloRecGPU::Helpers::CUDA_object< CaloRecGPU::CellInfoArr >	m_cell_info_dev
CaloRecGPU::Helpers::CUDA_object< CaloRecGPU::ClusterInfoArr >	m_clusters_dev

Detailed Description

Holds the mutable per-event information (clusters and cells) and provides utilities to convert between this representation and the Athena data structures (i.

e. xAOD::CaloClusterContainer).

Definition at line 72 of file DataHolders.h.

Member Function Documentation

◆ allocate()

void CaloRecGPU::EventDataHolder::allocate ( const bool also_GPU = true )

Definition at line 1340 of file DataHolders.cxx.

{
  m_cell_info.allocate();
  m_clusters.allocate();
 
  if (also_GPU)
    {
      m_cell_info_dev.allocate();
      m_clusters_dev.allocate();
    }
}

◆ clear_GPU()

void CaloRecGPU::EventDataHolder::clear_GPU ( )

Definition at line 1352 of file DataHolders.cxx.

{
  m_cell_info_dev.clear();
  m_clusters_dev.clear();
}

◆ returnAndExportClusters()

void CaloRecGPU::EventDataHolder::returnAndExportClusters	(	void *	cluster_collection,
		const void *	cell_collection_link,
		const MomentsOptionsArray &	moments_to_add,
		const bool	sort_clusters = true,
		const bool	save_uncalibrated = true,
		const bool	output_extra_moments = false,
		const std::vector< int > &	extra_cells_to_fill = {},
		size_t *	time_measurements = nullptr,
		CaloRecGPU::CUDA_Helpers::CUDAStreamPtrHolder	stream = {} )

We are using a void* for API to make this able to compile on the GPU without Athena-specific dependencies.

The user should pass a const CaloCellCollection *. void importCells(const void * cell_collection, const std::vector<int> & extra_cells_to_fill = {});

/We are using a void* for API to make this able to compile on the GPU /without Athena-specific dependencies. The user should pass a /const xAOD::CaloClusterContainer *. /moments_to_add specifies which moments we will import. void importClusters(const void * cluster_collection, const MomentsOptionsArray & moments_to_add, const bool output_tags = true, const bool consider_shared_cells = true, const bool output_moments = false, const bool output_extra_moments = false, const std::vector<int> & extra_cells_to_fill = {});

/This function is asynchronous if clear_CPU and synchronize are false. /moments_to_add specifies which moments we will transfer to the GPU. /If full_copy is true, we will memcopy the whole structure /in bulk instead of enqueuing separate transfers up to the necessary size /(this will also ignore the moments_to_add). /If clear_CPU is true, we will wait until the transfers are finished /before deallocating. If synchronize is true, we will synchronize anyway. void sendToGPU(const MomentsOptionsArray & moments_to_add, const bool full_copy = false, const bool clear_CPU = false, const bool synchronize = false, CaloRecGPU::CUDA_Helpers::CUDAStreamPtrHolder stream = {});

/moments_to_add specifies which moments we will transfer from the GPU. /If full_copy is true, we will memcopy the whole structure /in bulk instead of enqueuing separate transfers up to the necessary size /(this will also ignore the moments_to_add). /If full_copy is false, we will have a synchronization point before /enqueuing the transfers to know the sizes. /If clear_GPU is true, we will wait until the transfers are finished /before deallocating. If synchronize is true, we will synchronize anyway. void returnToCPU(const MomentsOptionsArray & moments_to_add, const bool full_copy = false, const bool clear_GPU = false, const bool synchronize = false, CaloRecGPU::CUDA_Helpers::CUDAStreamPtrHolder stream = {}, const bool also_return_cells = false);

/We are using a void* for API to make this able to compile on the GPU /without Athena-specific dependencies. The user should pass a /xAOD::CaloClusterContainer * and a const DataLink<CaloCellContainer> *. /moments_to_add specifies which moments we will import. /If sort_clusters is true, the clusters will be sorted based on /the transverse energy, otherwise the same order will be kept. /If save_uncalibrated, the basic cluster information will be saved /as raw. /If time_measurements is not null, separate time measurements /for the five stages (cell link creation, cell assignment, /sorting, basic info filling and moments filling) will be stored. void exportClusters(void * cluster_collection, const void * cell_collection_link, const MomentsOptionsArray & moments_to_add, const bool sort_clusters = true, const bool save_uncalibrated = true, const bool output_extra_moments = false, const std::vector<int> & extra_cells_to_fill = {}, size_t * time_measurements = nullptr);

/We are using a void* for API to make this able to compile on the GPU /without Athena-specific dependencies. The user should pass a /xAOD::CaloClusterContainer * and a const DataLink<CaloCellContainer> *. moments_to_add specifies which moments we will import. If sort_clusters is true, the clusters will be sorted based on the transverse energy, otherwise the same order will be kept. If save_uncalibrated, the basic cluster information will be saved as raw. If time_measurements is not null, separate time measurements for the six stages (initial transfer, cell link creation, cell assignment, sorting, basic info filling and moments filling) will be stored.

Definition at line 1262 of file DataHolders.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();
  };
 
  xAOD::CaloClusterContainer * cluster_collection = static_cast<xAOD::CaloClusterContainer *>(p_cluster_collection);
  const DataLink<CaloCellContainer> & cell_collection_link = *(static_cast<const DataLink<CaloCellContainer> *>(p_cell_collection_link));
 
  const auto start = clock_type::now();
 
  m_clusters.allocate();
 
  CaloRecGPU::CUDA_Helpers::GPU_to_CPU_async(static_cast<ClusterBaseInfo *>(m_clusters),
                                             static_cast<const ClusterBaseInfo *>(m_clusters_dev),
                                             sizeof(ClusterBaseInfo), stream);
 
  CaloRecGPU::CUDA_Helpers::GPU_synchronize(stream);
 
  const auto after_first_transfer = clock_type::now();
 
  cluster_transfer_helper_cell_assignment(m_clusters, m_clusters, m_clusters_dev, CaloRecGPU::CUDA_Helpers::GPU_to_CPU_async, stream, cluster_collection->size());
 
  std::vector<std::unique_ptr<CaloClusterCellLink>> cell_links;
 
  export_cluster_initialize_links(m_clusters, cell_links, cell_collection_link, true);
 
  const auto after_link_creation = clock_type::now();
 
  CaloRecGPU::CUDA_Helpers::GPU_synchronize(stream);
 
  cluster_transfer_helper_basic_info(m_clusters, m_clusters, m_clusters_dev, CaloRecGPU::CUDA_Helpers::GPU_to_CPU_async, stream);
 
  export_cluster_process_cells(m_clusters, m_cell_info, cell_links, extra_cells_to_fill);
 
  const auto after_cell_processing = clock_type::now();
 
  std::vector<int> cluster_order;
 
  export_cluster_sort(m_clusters, cluster_order, sort_clusters);
 
  const auto after_sorting = clock_type::now();
 
  CaloRecGPU::CUDA_Helpers::GPU_synchronize(stream);
 
  cluster_transfer_helper_moments(m_clusters, m_clusters, m_clusters_dev, moments_to_add, CaloRecGPU::CUDA_Helpers::GPU_to_CPU_async, stream);
 
  export_cluster_fill_cells_and_basic_info(m_clusters, cluster_collection, cell_links, cluster_order, save_uncalibrated);
 
  const auto after_basic_info = clock_type::now();
 
  CaloRecGPU::CUDA_Helpers::GPU_synchronize(stream);
 
  export_cluster_fill_moments(m_clusters, cluster_collection, cluster_order, moments_to_add, output_extra_moments);
 
  const auto after_moments = clock_type::now();
 
  if (time_measurements)
    {
      time_measurements[0] = time_cast(start, after_first_transfer);
      time_measurements[1] = time_cast(after_first_transfer, after_link_creation);
      time_measurements[2] = time_cast(after_link_creation, after_cell_processing);
      time_measurements[3] = time_cast(after_cell_processing, after_sorting);
      time_measurements[4] = time_cast(after_sorting, after_basic_info);
      time_measurements[5] = time_cast(after_basic_info, after_moments);
    }
}