CaloRecGPU::EventDataHolder Class Reference

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	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.
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={})
	We are using a void* for API to make this able to compile on the GPU without Athena-specific dependencies.
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={})
	This function is asynchronous if clear_CPU and synchronize are false.
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)
	moments_to_add specifies which moments we will transfer from the GPU.
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.
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 1347 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 1359 of file DataHolders.cxx.

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

exportClusters()

void CaloRecGPU::EventDataHolder::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 five stages (cell link creation, cell assignment, sorting, basic info filling and moments filling) will be stored.

Definition at line 1214 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();
 
  std::vector<std::unique_ptr<CaloClusterCellLink>> cell_links;
 
  export_cluster_initialize_links(m_clusters, cell_links, cell_collection_link, false);
 
  const auto after_link_creation = clock_type::now();
 
  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();
 
  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();
 
  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_link_creation);
      time_measurements[1] = time_cast(after_link_creation, after_cell_processing);
      time_measurements[2] = time_cast(after_cell_processing, after_sorting);
      time_measurements[3] = time_cast(after_sorting, after_basic_info);
      time_measurements[4] = time_cast(after_basic_info, after_moments);
    }
}

importCells()

void CaloRecGPU::EventDataHolder::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 CaloCellCollection *.

Definition at line 210 of file DataHolders.cxx.

{
  const CaloCellContainer * cell_collection = static_cast<const CaloCellContainer *>(p_cell_collection);
 
  m_cell_info.allocate();
 
  auto export_cell = [&](const CaloCell * cell, const int hash_ID, const int index_inside)
  {
    const float energy = cell->energy();
    const unsigned int gain = GainConversion::from_standard_gain(cell->gain());
    m_cell_info->energy[index_inside] = energy;
    m_cell_info->gain[index_inside] = gain;
    m_cell_info->time[index_inside] = cell->time();
 
    if (CaloRecGPU::GeometryArr::is_tile(hash_ID))
      {
        const TileCell * tile_cell = static_cast<const TileCell *>(cell);
 
        m_cell_info->qualityProvenance[index_inside] = QualityProvenance{tile_cell->qual1(),
                                                                         tile_cell->qual2(),
                                                                         tile_cell->qbit1(),
                                                                         tile_cell->qbit2()};
      }
    else
      {
        m_cell_info->qualityProvenance[index_inside] = QualityProvenance{cell->quality(), cell->provenance()};
      }
 
    m_cell_info->hashID[index_inside] = hash_ID;
    m_cell_info->hashIDToCollection[hash_ID] = index_inside;
  };
 
  if (cell_collection->isOrderedAndComplete())
    //Fast path: cell indices within the collection and identifierHashes match!
    {
      int cell_index = 0;
      for (auto cell_it = cell_collection->begin(); cell_it != cell_collection->end(); ++cell_it, ++cell_index)
        {
          const CaloCell * cell = (*cell_it);
          export_cell(cell, cell_index, cell_index);
        }
      
      m_cell_info->number = CaloRecGPU::NCaloCells;
      m_cell_info->complete = true;
      m_cell_info->all_cells_valid = true;
    }
  else if (cell_collection->isOrdered() && extra_cells_to_fill.size() > 0)
    //Remediated: we know the missing cells, force them to be invalid.
    //(Tests so far, on samples both oldish and newish, had 186986 and 187352 missing...)
    {
      int cell_index = 0;
      size_t missing_cell_count = 0;
 
      for (CaloCellContainer::const_iterator cell_it = cell_collection->begin(); cell_it != cell_collection->end(); ++cell_it, ++cell_index)
        {
          const CaloCell * cell = (*cell_it);
 
          if (missing_cell_count < extra_cells_to_fill.size() && cell_index == extra_cells_to_fill[missing_cell_count])
            {
              --cell_it;
              m_cell_info->gain[cell_index] = GainConversion::invalid_gain();
              ++missing_cell_count;
              m_cell_info->hashID[cell_index] = cell_index;
              m_cell_info->hashIDToCollection[cell_index] = -1;
              continue;
            }
          else
            {
              export_cell(cell, cell_index, cell_index);
            }
        }
 
      m_cell_info->number = CaloRecGPU::NCaloCells;
      m_cell_info->complete = true;
      m_cell_info->all_cells_valid = false;
    }
  else
    {
      for (unsigned int cell_index = 0; cell_index < CaloRecGPU::NCaloCells; ++cell_index)
        {
          m_cell_info->hashIDToCollection[cell_index] = -1;
        }
 
      int index_inside = 0;
 
      const auto cells_end = cell_collection->end();
      
      for (CaloCellContainer::const_iterator cell_it = cell_collection->begin(); cell_it != cells_end; ++cell_it, ++index_inside)
        {
          CaloPrefetch::nextDDE(cell_it, cells_end, 2);
          //May be adjusted later...
          
          const CaloCell * cell = (*cell_it);
          
          const int cell_index = cell->caloDDE()->calo_hash();
          export_cell(cell, cell_index, index_inside);
        }
 
      m_cell_info->number = cell_collection->size();
      m_cell_info->complete = false;
      m_cell_info->all_cells_valid = true;
    }
}

importClusters()

void CaloRecGPU::EventDataHolder::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 = {} )

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.

Definition at line 315 of file DataHolders.cxx.

{
  const xAOD::CaloClusterContainer * cluster_collection = static_cast<const xAOD::CaloClusterContainer *>(p_cluster_collection);
 
  m_clusters.allocate();
 
  if (cluster_collection->size() > 0)
    {
      std::vector<int> real_cells_to_fill;
 
      if (m_cell_info->number == CaloRecGPU::NCaloCells && !m_cell_info->all_cells_valid)
        {
          real_cells_to_fill.reserve(extra_cells_to_fill.size());
 
          for (const int cell : extra_cells_to_fill)
            {
              if (m_cell_info->hashIDToCollection[cell] <= 0)
                {
                  real_cells_to_fill.push_back(cell);
                }
            }
        }
 
      auto index_to_corrected_index = [&](const int index)
      {
        if (m_cell_info->all_cells_valid)
          {
            return index;
          }
 
        int ret = index;
 
        for (const int cell : real_cells_to_fill)
          {
            ret += (index > cell);
          }
 
        return ret;
      };
 
      auto get_cell_tag = [&](const int index) -> tag_type &
      {
        if (output_tags)
          {
            return m_clusters->cells.tags[index];
          }
        else
          {
            return m_clusters->get_extra_cell_info(index);
          }
          
      };
      
      for (int i = 0; i < CaloRecGPU::NCaloCells; ++i)
        {
          get_cell_tag(i) = ClusterTag::make_invalid_tag();
        }
      
      if (output_tags)
        {
          m_clusters->state = ClusterInformationState::TagsWithBasicInfo;
        }
      else
        {
          m_clusters->state = (output_moments ?
                               (output_extra_moments ? ClusterInformationState::WithExtraMoments : ClusterInformationState::WithMoments) :
                               ClusterInformationState::WithBasicInfo);
          m_clusters->cellsPrefixSum[0] = 0;
        }
 
      m_clusters->has_deleted_clusters = false;
 
      const auto cluster_end = cluster_collection->end();
      auto cluster_iter = cluster_collection->begin();
 
      int overall_cell_index = 0;
 
      for (int cluster_number = 0; cluster_iter != cluster_end; ++cluster_iter, ++cluster_number)
        {
          const xAOD::CaloCluster * cluster = (*cluster_iter);
          const CaloClusterCellLink * cell_links = cluster->getCellLinks();
 
          m_clusters->clusterEnergy[cluster_number] = cluster->e();
          m_clusters->clusterEt[cluster_number] = cluster->et();
          m_clusters->clusterEta[cluster_number] = cluster->eta();
          m_clusters->clusterPhi[cluster_number] = cluster->phi();
 
          const int seed_cell_index = (cluster->cell_begin() != cluster->cell_end() ? cluster->cell_begin().index() : -1);
 
          if (cluster->cell_begin() == cluster->cell_end())
            {
              m_clusters->has_deleted_clusters = true;
              m_clusters->seedCellIndex[cluster_number] = -1;
            }
          else
            {
              m_clusters->seedCellIndex[cluster_number] = index_to_corrected_index(seed_cell_index);
            }
 
          for (auto it = cell_links->begin(); it != cell_links->end(); ++it)
            {
              const int cell_index_in_collection = index_to_corrected_index(it.index());
              if (consider_shared_cells)
                {
                  const float weight = it.weight();
                  
                  uint32_t weight_as_int = 0;
                  std::memcpy(&weight_as_int, &weight, sizeof(float));
                  //On the platforms we expect to be running this, it should be fine.
                  //Still UB.
                  //With C++20, we could do that bit-cast thing.
                  
                  if (weight_as_int == 0)
                    {
                      weight_as_int = 1;
                      //Subnormal,
                      //but just to distinguish from
                      //a non-shared cluster.
                    }
                  
                  const ClusterTag other_tag = get_cell_tag(cell_index_in_collection);
 
                  const int other_index = other_tag.is_part_of_cluster() ? other_tag.cluster_index() : -1;
 
                  if (other_index < 0)
                    {
                      if (weight < 0.5f)
                        {
                          get_cell_tag(cell_index_in_collection) = ClusterTag::make_tag(cluster_number, weight_as_int, 0);
                        }
                      else
                        {
                          get_cell_tag(cell_index_in_collection) = ClusterTag::make_tag(cluster_number);
                        }
                    }
                  else if (weight > 0.5f)
                    {
                      get_cell_tag(cell_index_in_collection) = ClusterTag::make_tag(cluster_number, other_tag.secondary_cluster_weight(), other_index);
                    }
                  else if (weight == 0.5f)
                    //Unlikely, but...
                    {
                      const int max_cluster = cluster_number > other_index ? cluster_number : other_index;
                      const int min_cluster = cluster_number > other_index ? other_index : cluster_number;
                      get_cell_tag(cell_index_in_collection) = ClusterTag::make_tag(max_cluster, weight_as_int, min_cluster);
                    }
                  else /*if (weight < 0.5f)*/
                    {
                      get_cell_tag(cell_index_in_collection) = ClusterTag::make_tag(other_index, weight_as_int, cluster_number);
                    }
                        
                  //All of this logic assumes a cell is shared by at most two clusters
                  //with weights such that w_1 + w_2 = 1.
                  //This is not necessarily valid with local calibrations.
                      
                }
              else
                {
                  get_cell_tag(cell_index_in_collection) = ClusterTag::make_tag(cluster_number);
                }
            }
          
          if (!output_tags)
            {
              for (auto it = cell_links->begin(); it != cell_links->end(); ++it, ++overall_cell_index)
                {
                  m_clusters->cells.indices[overall_cell_index] = index_to_corrected_index(it.index());
                  m_clusters->clusterIndices[overall_cell_index] = cluster_number;
                  m_clusters->cellWeights[overall_cell_index] = it.weight();
                }
 
              m_clusters->cellsPrefixSum[cluster_number + 1] = overall_cell_index;
            }
 
          if (output_moments)
            {
              for (int s = 0; s < NumSamplings; ++s)
                {
                  m_clusters->moments.nCellSampling[s][cluster_number] = cluster->numberCellsInSampling(static_cast<CaloSampling::CaloSample>(s), false);
                }
 
              m_clusters->moments.nExtraCellSampling[cluster_number] = cluster->numberCellsInSampling(CaloSampling::EME2, true);
 
              for (int s = 0; s < NumSamplings; ++s)
                {
                  m_clusters->moments.energyPerSample[s][cluster_number] = cluster->eSample(static_cast<CaloSampling::CaloSample>(s));
                }
              for (int s = 0; s < NumSamplings; ++s)
                {
                  m_clusters->moments.maxEPerSample[s][cluster_number] = cluster->energy_max(static_cast<CaloSampling::CaloSample>(s));
                }
              for (int s = 0; s < NumSamplings; ++s)
                {
                  m_clusters->moments.maxEtaPerSample[s][cluster_number] = cluster->etamax(static_cast<CaloSampling::CaloSample>(s));
                }
              for (int s = 0; s < NumSamplings; ++s)
                {
                  m_clusters->moments.maxPhiPerSample[s][cluster_number] = cluster->phimax(static_cast<CaloSampling::CaloSample>(s));
                }
              for (int s = 0; s < NumSamplings; ++s)
                {
                  m_clusters->moments.etaPerSample[s][cluster_number] = cluster->etaSample(static_cast<CaloSampling::CaloSample>(s));
                }
              for (int s = 0; s < NumSamplings; ++s)
                {
                  m_clusters->moments.phiPerSample[s][cluster_number] = cluster->phiSample(static_cast<CaloSampling::CaloSample>(s));
                }
 
              m_clusters->moments.time[cluster_number] = cluster->time();
 
#define CALORECGPU_MOMENTS_INPUT_HELPER(VAR_NAME, PROPER_MOMENT, NORMAL_ASSIGN, IS_CALCULATED, MOMENT_NAME, ...) \
  CRGPU_CONCAT(CRGPU_CONCAT(CALORECGPU_MOMENTS_INPUT_HELPER_, NORMAL_ASSIGN), IS_CALCULATED) (VAR_NAME, MOMENT_NAME)
 
#define CALORECGPU_MOMENTS_INPUT_HELPER_11(VAR_NAME, MOMENT_NAME)                                                 \
  if (moments_to_add[xAOD::CaloCluster:: MOMENT_NAME])                                                            \
    {                                                                                                             \
      m_clusters->moments. VAR_NAME [cluster_number] = cluster->getMomentValue(xAOD::CaloCluster:: MOMENT_NAME ); \
    }
 
#define CALORECGPU_MOMENTS_INPUT_HELPER_10(VAR_NAME, MOMENT_NAME)                                                 \
  if (output_extra_moments && moments_to_add[xAOD::CaloCluster:: MOMENT_NAME])                                    \
    {                                                                                                             \
      m_clusters->moments. VAR_NAME [cluster_number] = cluster->getMomentValue(xAOD::CaloCluster:: MOMENT_NAME ); \
    }
 
#define CALORECGPU_MOMENTS_INPUT_HELPER_00(...)
#define CALORECGPU_MOMENTS_INPUT_HELPER_01(...)
 
              CALORECGPU_FORALLMOMENTS_INSTANTIATE(CALORECGPU_MOMENTS_INPUT_HELPER)
 
              double second_time_retriever = 0;
 
              if (!cluster->retrieveMoment(xAOD::CaloCluster::SECOND_TIME, second_time_retriever))
                {
                  m_clusters->moments.secondTime[cluster_number] = cluster->secondTime();
                  //Special casing for SECOND_TIME as it comes from CalculateKine instead,
                  //thus stored in a member variable instead of the moment.
                }
              else
                {
                  m_clusters->moments.secondTime[cluster_number] = second_time_retriever;
                }
            }
        }
 
      m_clusters->number = cluster_collection->size();
      m_clusters->number_cells = (output_tags ? m_cell_info->number : overall_cell_index);
    }
  else
    {
      m_clusters->state = CaloRecGPU::ClusterInformationState::None;
      m_clusters->has_deleted_clusters = false;
      m_clusters->number = 0;
      m_clusters->number_cells = 0;
    }
}

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 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 1269 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);
    }
}

returnToCPU()

void CaloRecGPU::EventDataHolder::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 )

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.

Definition at line 842 of file DataHolders.cxx.

{
  if (also_return_cells)
    {
      m_cell_info.allocate();
    }
  m_clusters.allocate();
 
  if (!full_copy)
    {
      if (also_return_cells)
        {
          CaloRecGPU::CUDA_Helpers::GPU_to_CPU_async(static_cast<CellBaseInfo *>(m_cell_info),
                                                     static_cast<CellBaseInfo *>(m_cell_info_dev),
                                                     sizeof(CellBaseInfo), stream);
        }
 
      CaloRecGPU::CUDA_Helpers::GPU_to_CPU_async(static_cast<ClusterBaseInfo *>(m_clusters),
                                                 static_cast<ClusterBaseInfo *>(m_clusters_dev),
                                                 sizeof(ClusterBaseInfo), stream);
 
      CaloRecGPU::CUDA_Helpers::GPU_synchronize(stream);
 
    }
 
  if (also_return_cells)
    {
      cell_transfer_helper(m_cell_info, m_cell_info, m_cell_info_dev,
                           CaloRecGPU::CUDA_Helpers::GPU_to_CPU_async, full_copy, stream);
    }
 
  cluster_transfer_helper(m_clusters, m_clusters, m_clusters_dev, moments_to_add,
                          CaloRecGPU::CUDA_Helpers::GPU_to_CPU_async, full_copy, stream);
 
  if (clear_GPU)
    {
      CaloRecGPU::CUDA_Helpers::GPU_synchronize(stream);
 
      m_clusters_dev.clear();
      m_cell_info_dev.clear();
    }
  else if (synchronize)
    {
      CaloRecGPU::CUDA_Helpers::GPU_synchronize(stream);
    }
}

sendToGPU()

void CaloRecGPU::EventDataHolder::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 = {} )

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.

Definition at line 801 of file DataHolders.cxx.

{  
  m_cell_info_dev.allocate();
  m_clusters_dev.allocate();
 
  if (!full_copy)
    {
      CaloRecGPU::CUDA_Helpers::CPU_to_GPU_async(static_cast<CellBaseInfo *>(m_cell_info_dev),
                                                 static_cast<const CellBaseInfo *>(m_cell_info),
                                                 sizeof(CellBaseInfo), stream);
 
      CaloRecGPU::CUDA_Helpers::CPU_to_GPU_async(static_cast<ClusterBaseInfo *>(m_clusters_dev),
                                                 static_cast<const ClusterBaseInfo *>(m_clusters),
                                                 sizeof(ClusterBaseInfo), stream);
 
    }
 
  cell_transfer_helper(m_cell_info, m_cell_info_dev, m_cell_info,
                       CaloRecGPU::CUDA_Helpers::CPU_to_GPU_async, full_copy, stream);
 
  cluster_transfer_helper(m_clusters, m_clusters_dev, m_clusters, moments_to_add,
                          CaloRecGPU::CUDA_Helpers::CPU_to_GPU_async, full_copy, stream,
                          m_cell_info->number);
  
  if (clear_CPU)
    {
      CaloRecGPU::CUDA_Helpers::GPU_synchronize(stream);
 
      m_clusters.clear();
      m_cell_info.clear();
    }
  else if (synchronize)
    {
      CaloRecGPU::CUDA_Helpers::GPU_synchronize(stream);
    }
}

Member Data Documentation

m_cell_info

CaloRecGPU::Helpers::CUDA_pinned_CPU_object<CaloRecGPU::CellInfoArr> CaloRecGPU::EventDataHolder::m_cell_info

Definition at line 168 of file DataHolders.h.

m_cell_info_dev

CaloRecGPU::Helpers::CUDA_object<CaloRecGPU::CellInfoArr> CaloRecGPU::EventDataHolder::m_cell_info_dev

Definition at line 178 of file DataHolders.h.

m_clusters

CaloRecGPU::Helpers::CUDA_pinned_CPU_object<CaloRecGPU::ClusterInfoArr> CaloRecGPU::EventDataHolder::m_clusters

Definition at line 169 of file DataHolders.h.

m_clusters_dev

CaloRecGPU::Helpers::CUDA_object<CaloRecGPU::ClusterInfoArr> CaloRecGPU::EventDataHolder::m_clusters_dev

Definition at line 179 of file DataHolders.h.

---

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

• DataHolders.h
• DataHolders.cxx