#include <HeterogeneousHGCalHEBConditions.h>

Classes
struct	GPUData

Public Member Functions
const hgcal_conditions::HeterogeneousHEBConditionsESProduct *	getHeterogeneousConditionsESProductAsync (cudaStream_t stream) const

	HeterogeneousHGCalHEBConditionsWrapper (const HGCalParameters *)

	~HeterogeneousHGCalHEBConditionsWrapper ()

Private Member Functions
void	calculate_memory_bytes (const HGCalParameters *)

std::vector< double >	select_pointer_d (const HGCalParameters *, const unsigned int &) const

double *&	select_pointer_d (cp::HeterogeneousHGCalHEBParameters *, const unsigned int &) const

std::vector< int32_t >	select_pointer_i (const HGCalParameters *, const unsigned int &) const

int32_t *&	select_pointer_i (cp::HeterogeneousHGCalHEBParameters *, const unsigned int &) const

Private Attributes
size_t	chunk_

cms::cuda::ESProduct< GPUData >	gpuData_

cp::HeterogeneousHGCalHEBParameters	params_

std::vector< size_t >	sizes_

Detailed Description

Definition at line 19 of file HeterogeneousHGCalHEBConditions.h.

Constructor & Destructor Documentation

◆ HeterogeneousHGCalHEBConditionsWrapper()

HeterogeneousHGCalHEBConditionsWrapper::HeterogeneousHGCalHEBConditionsWrapper ( const HGCalParameters * cpuHGCalParameters )

Definition at line 3 of file HeterogeneousHGCalHEBConditions.cc.

                                                {
   calculate_memory_bytes(cpuHGCalParameters);
  
   chunk_ = std::accumulate(this->sizes_.begin(), this->sizes_.end(), 0);  //total memory required in bytes
   cudaCheck(cudaMallocHost(&this->params_.testD_, chunk_));
  
   //store cumulative sum in bytes and convert it to sizes in units of C++ typesHEB, i.e., number if items to be transferred to GPU
   std::vector<size_t> cumsum_sizes(this->sizes_.size() + 1, 0);  //starting with zero
   std::partial_sum(this->sizes_.begin(), this->sizes_.end(), cumsum_sizes.begin() + 1);
   for (unsigned int i = 1; i < cumsum_sizes.size(); ++i)  //start at second element (the first is zero)
   {
     unsigned int typesHEBize = 0;
     if (cp::typesHEB[i - 1] == cp::HeterogeneousHGCalHEBParametersType::Double)
       typesHEBize = sizeof(double);
     else if (cp::typesHEB[i - 1] == cp::HeterogeneousHGCalHEBParametersType::Int32_t)
       typesHEBize = sizeof(int32_t);
     else
       throw cms::Exception("HeterogeneousHGCalHEBConditionsWrapper") << "Wrong HeterogeneousHGCalParameters type";
     cumsum_sizes[i] /= typesHEBize;
   }
  
   for (unsigned int j = 0; j < this->sizes_.size(); ++j) {
     //setting the pointers
     if (j != 0) {
       const unsigned int jm1 = j - 1;
       if (cp::typesHEB[jm1] == cp::HeterogeneousHGCalHEBParametersType::Double and
           cp::typesHEB[j] == cp::HeterogeneousHGCalHEBParametersType::Double)
         select_pointer_d(&this->params_, j) = select_pointer_d(&this->params_, jm1) + this->sizes_[jm1];
       else if (cp::typesHEB[jm1] == cp::HeterogeneousHGCalHEBParametersType::Double and
                cp::typesHEB[j] == cp::HeterogeneousHGCalHEBParametersType::Int32_t)
         select_pointer_i(&this->params_, j) =
             reinterpret_cast<int32_t*>(select_pointer_d(&this->params_, jm1) + this->sizes_[jm1]);
     }
  
     //copying the pointers' content
     for (unsigned int i = cumsum_sizes[j]; i < cumsum_sizes[j + 1]; ++i) {
       unsigned int index = i - cumsum_sizes[j];
       if (cp::typesHEB[j] == cp::HeterogeneousHGCalHEBParametersType::Double) {
         select_pointer_d(&this->params_, j)[index] = select_pointer_d(cpuHGCalParameters, j)[index];
       } else if (cp::typesHEB[j] == cp::HeterogeneousHGCalHEBParametersType::Int32_t)
         select_pointer_i(&this->params_, j)[index] = select_pointer_i(cpuHGCalParameters, j)[index];
       else
         throw cms::Exception("HeterogeneousHGCalHEBConditionsWrapper") << "Wrong HeterogeneousHGCalParameters type";
     }
   }
 }

References calculate_memory_bytes(), chunk_, cudaCheck, hgcal_conditions::parameters::Double, Exception, mps_fire::i, dqmiolumiharvest::j, params_, select_pointer_d(), select_pointer_i(), sizes_, hgcal_conditions::parameters::HeterogeneousHGCalHEBParameters::testD_, and hgcal_conditions::parameters::typesHEB.

◆ ~HeterogeneousHGCalHEBConditionsWrapper()

HeterogeneousHGCalHEBConditionsWrapper::~HeterogeneousHGCalHEBConditionsWrapper ( )

Definition at line 74 of file HeterogeneousHGCalHEBConditions.cc.

                                                                                 {
   cudaCheck(cudaFreeHost(this->params_.testD_));
 }

References cudaCheck, params_, and hgcal_conditions::parameters::HeterogeneousHGCalHEBParameters::testD_.

Member Function Documentation

◆ calculate_memory_bytes()

void HeterogeneousHGCalHEBConditionsWrapper::calculate_memory_bytes ( const HGCalParameters * cpuHGCalParameters )

private

Definition at line 51 of file HeterogeneousHGCalHEBConditions.cc.

                                                                                                              {
   size_t npointers = hgcal_conditions::parameters::typesHEB.size();
   std::vector<size_t> sizes(npointers);
   for (unsigned int i = 0; i < npointers; ++i) {
     if (cp::typesHEB[i] == cp::HeterogeneousHGCalHEBParametersType::Double)
       sizes[i] = select_pointer_d(cpuHGCalParameters, i).size();
     else
       sizes[i] = select_pointer_i(cpuHGCalParameters, i).size();
   }
  
   std::vector<size_t> sizes_units(npointers);
   for (unsigned int i = 0; i < npointers; ++i) {
     if (cp::typesHEB[i] == cp::HeterogeneousHGCalHEBParametersType::Double)
       sizes_units[i] = sizeof(double);
     else if (cp::typesHEB[i] == cp::HeterogeneousHGCalHEBParametersType::Int32_t)
       sizes_units[i] = sizeof(int32_t);
   }
  
   //element by element multiplication
   this->sizes_.resize(npointers);
   std::transform(sizes.begin(), sizes.end(), sizes_units.begin(), this->sizes_.begin(), std::multiplies<size_t>());
 }

References hgcal_conditions::parameters::Double, mps_fire::i, select_pointer_d(), select_pointer_i(), sizes_, HcalDetIdTransform::transform(), and hgcal_conditions::parameters::typesHEB.

Referenced by HeterogeneousHGCalHEBConditionsWrapper().

◆ getHeterogeneousConditionsESProductAsync()

hgcal_conditions::HeterogeneousHEBConditionsESProduct const * HeterogeneousHGCalHEBConditionsWrapper::getHeterogeneousConditionsESProductAsync ( cudaStream_t stream ) const

Definition at line 125 of file HeterogeneousHGCalHEBConditions.cc.

                                                                                                           {
   // cms::cuda::ESProduct<T> essentially holds an array of GPUData objects,
   // one per device. If the data have already been transferred to the
   // current device (or the transfer has been queued), the helper just
   // returns a reference to that GPUData object. Otherwise, i.e. data are
   // not yet on the current device, the helper calls the lambda to do the
   // necessary memory allocations and to queue the transfers.
   auto const& data = gpuData_.dataForCurrentDeviceAsync(stream, [this](GPUData& data, cudaStream_t stream) {
     // Allocate the payload object on pinned host memory.
     cudaCheck(cudaMallocHost(&data.host, sizeof(hgcal_conditions::HeterogeneousHEBConditionsESProduct)));
     // Allocate the payload array(s) on device memory.
     cudaCheck(cudaMalloc(&(data.host->params.testD_), chunk_));
  
     // Allocate the payload object on the device memory.
     cudaCheck(cudaMalloc(&data.device, sizeof(hgcal_conditions::HeterogeneousHEBConditionsESProduct)));
     // Transfer the payload, first the array(s) ...
     cudaCheck(cudaMemcpyAsync(data.host->params.testD_, this->params_.testD_, chunk_, cudaMemcpyHostToDevice, stream));
  
     for (unsigned int j = 0; j < this->sizes_.size() - 1; ++j) {
       if (cp::typesHEB[j] == cp::HeterogeneousHGCalHEBParametersType::Double and
           cp::typesHEB[j + 1] == cp::HeterogeneousHGCalHEBParametersType::Double)
         select_pointer_d(&(data.host->params), j + 1) = select_pointer_d(&(data.host->params), j) + this->sizes_[j];
       else if (cp::typesHEB[j] == cp::HeterogeneousHGCalHEBParametersType::Double and
                cp::typesHEB[j + 1] == cp::HeterogeneousHGCalHEBParametersType::Int32_t)
         select_pointer_i(&(data.host->params), j + 1) =
             reinterpret_cast<int32_t*>(select_pointer_d(&(data.host->params), j) + this->sizes_[j]);
       else
         throw cms::Exception("HeterogeneousHGCalHEBConditionsWrapper")
             << "compare this functions' logic with hgcal_conditions::parameters::typesHEB";
     }
  
     // ... and then the payload object
     cudaCheck(cudaMemcpyAsync(data.device,
                               data.host,
                               sizeof(hgcal_conditions::HeterogeneousHEBConditionsESProduct),
                               cudaMemcpyHostToDevice,
                               stream));
   });  //gpuData_.dataForCurrentDeviceAsync
  
   // Returns the payload object on the memory of the current device
   return data.device;
 }

References chunk_, cudaCheck, data, hgcal_conditions::parameters::Double, Exception, gpuData_, dqmiolumiharvest::j, select_pointer_d(), select_pointer_i(), sizes_, cms::cuda::stream, and hgcal_conditions::parameters::typesHEB.

◆ select_pointer_d() [1/2]

std::vector< double > HeterogeneousHGCalHEBConditionsWrapper::select_pointer_d	(	const HGCalParameters *	cpuObject,
		const unsigned int &	item
	)		const

private

Definition at line 91 of file HeterogeneousHGCalHEBConditions.cc.

                                                                                                              {
   switch (item) {
     case 0:
       return cpuObject->cellFineX_;
     default:
       throw cms::Exception("HeterogeneousHGCalHEBConditionsWrapper") << "select_pointer_d(non-heterogeneous): no item.";
       return cpuObject->cellFineX_;
   }
 }

References HGCalParameters::cellFineX_, Exception, and B2GTnPMonitor_cfi::item.

◆ select_pointer_d() [2/2]

double *& HeterogeneousHGCalHEBConditionsWrapper::select_pointer_d	(	cp::HeterogeneousHGCalHEBParameters *	cpuObject,
		const unsigned int &	item
	)		const

private

Definition at line 80 of file HeterogeneousHGCalHEBConditions.cc.

                                                                                                   {
   switch (item) {
     case 0:
       return cpuObject->testD_;
     default:
       throw cms::Exception("HeterogeneousHGCalHEBConditionsWrapper") << "select_pointer_d(heterogeneous): no item.";
       return cpuObject->testD_;
   }
 }

References Exception, B2GTnPMonitor_cfi::item, and hgcal_conditions::parameters::HeterogeneousHGCalHEBParameters::testD_.

Referenced by calculate_memory_bytes(), getHeterogeneousConditionsESProductAsync(), and HeterogeneousHGCalHEBConditionsWrapper().

◆ select_pointer_i() [1/2]

std::vector< int32_t > HeterogeneousHGCalHEBConditionsWrapper::select_pointer_i	(	const HGCalParameters *	cpuObject,
		const unsigned int &	item
	)		const

private

Definition at line 113 of file HeterogeneousHGCalHEBConditions.cc.

                                                                                                               {
   switch (item) {
     case 4:
       return cpuObject->waferTypeL_;
     default:
       throw cms::Exception("HeterogeneousHGCalHEBConditionsWrapper") << "select_pointer_i(non-heterogeneous): no item.";
       return cpuObject->waferTypeL_;
   }
 }

References Exception, B2GTnPMonitor_cfi::item, and HGCalParameters::waferTypeL_.

◆ select_pointer_i() [2/2]

int32_t *& HeterogeneousHGCalHEBConditionsWrapper::select_pointer_i	(	cp::HeterogeneousHGCalHEBParameters *	cpuObject,
		const unsigned int &	item
	)		const

private

Definition at line 102 of file HeterogeneousHGCalHEBConditions.cc.

                                                                                                    {
   switch (item) {
     case 1:
       return cpuObject->testI_;
     default:
       throw cms::Exception("HeterogeneousHGCalHEBConditionsWrapper") << "select_pointer_i(heterogeneous): no item.";
       return cpuObject->testI_;
   }
 }