Inheritance diagram for HcalRawToDigiGPU:

Public Member Functions
	HcalRawToDigiGPU (edm::ParameterSet const &ps)

	~HcalRawToDigiGPU () override

Public Member Functions inherited from edm::stream::EDProducer< edm::ExternalWork >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)

Private Types
using	ProductTypef01 = cms::cuda::Product< hcal::DigiCollection< hcal::Flavor1, calo::common::DevStoragePolicy >>

using	ProductTypef3 = cms::cuda::Product< hcal::DigiCollection< hcal::Flavor3, calo::common::DevStoragePolicy >>

using	ProductTypef5 = cms::cuda::Product< hcal::DigiCollection< hcal::Flavor5, calo::common::DevStoragePolicy >>

Private Member Functions
void	acquire (edm::Event const &, edm::EventSetup const &, edm::WaitingTaskWithArenaHolder) override

void	produce (edm::Event &, edm::EventSetup const &) override

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::ExternalWork >
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 21 of file HcalRawToDigiGPU.cc.

Member Typedef Documentation

using HcalRawToDigiGPU::ProductTypef01 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor1, calo::common::DevStoragePolicy>>

private

Definition at line 34 of file HcalRawToDigiGPU.cc.

using HcalRawToDigiGPU::ProductTypef3 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor3, calo::common::DevStoragePolicy>>

private

Definition at line 38 of file HcalRawToDigiGPU.cc.

using HcalRawToDigiGPU::ProductTypef5 = cms::cuda::Product<hcal::DigiCollection<hcal::Flavor5, calo::common::DevStoragePolicy>>

private

Definition at line 36 of file HcalRawToDigiGPU.cc.

Constructor & Destructor Documentation

HcalRawToDigiGPU::HcalRawToDigiGPU ( edm::ParameterSet const & ps )

explicit

Definition at line 73 of file HcalRawToDigiGPU.cc.

References DeDxTools::esConsumes().

     : eMappingToken_{esConsumes()},
       rawDataToken_{consumes<FEDRawDataCollection>(ps.getParameter<edm::InputTag>("InputLabel"))},
       digisF01HEToken_{produces<ProductTypef01>(ps.getParameter<std::string>("digisLabelF01HE"))},
       digisF5HBToken_{produces<ProductTypef5>(ps.getParameter<std::string>("digisLabelF5HB"))},
       digisF3HBToken_{produces<ProductTypef3>(ps.getParameter<std::string>("digisLabelF3HB"))},
       fedsToUnpack_{ps.getParameter<std::vector<int>>("FEDs")} {
   config_.maxChannelsF01HE = ps.getParameter<uint32_t>("maxChannelsF01HE");
   config_.maxChannelsF5HB = ps.getParameter<uint32_t>("maxChannelsF5HB");
   config_.maxChannelsF3HB = ps.getParameter<uint32_t>("maxChannelsF3HB");
   config_.nsamplesF01HE = ps.getParameter<uint32_t>("nsamplesF01HE");
   config_.nsamplesF5HB = ps.getParameter<uint32_t>("nsamplesF5HB");
   config_.nsamplesF3HB = ps.getParameter<uint32_t>("nsamplesF3HB");
 }

HcalRawToDigiGPU::~HcalRawToDigiGPU ( )

override

Definition at line 88 of file HcalRawToDigiGPU.cc.

88 {}

Member Function Documentation

void HcalRawToDigiGPU::acquire	(	edm::Event const &	event,
		edm::EventSetup const &	setup,
		edm::WaitingTaskWithArenaHolder	holder
	)

overrideprivate

Definition at line 90 of file HcalRawToDigiGPU.cc.

References hcal::raw::OutputDataGPU::allocate(), submitPVValidationJobs::conditions, config_, counter, cudaState_, data, eMappingToken_, hcal::raw::empty_event_size, hcal::raw::entryPoint(), fedsToUnpack_, edm::EventSetup::getData(), cms::cuda::make_device_unique(), cms::cuda::make_host_unique(), eostools::move(), hcal::raw::nbytes_per_fed_max, hcal::raw::numOutputCollections, outputCPU_, outputGPU_, gpuVertexFinder::printf(), rawDataToken_, and hcal::raw::utca_nfeds_max.

                                                                      {
   // raii
   cms::cuda::ScopedContextAcquire ctx{event.streamID(), std::move(holder), cudaState_};
 
   // conditions
   auto const& eMappingProduct = setup.getData(eMappingToken_).getProduct(ctx.stream());
 
   // bundle up conditions
   hcal::raw::ConditionsProducts conditions{eMappingProduct};
 
   // event data
   edm::Handle<FEDRawDataCollection> rawDataHandle;
   event.getByToken(rawDataToken_, rawDataHandle);
 
   // scratch
   hcal::raw::ScratchDataGPU scratchGPU = {
       cms::cuda::make_device_unique<uint32_t[]>(hcal::raw::numOutputCollections, ctx.stream())};
 
   // input cpu data
   hcal::raw::InputDataCPU inputCPU = {cms::cuda::make_host_unique<unsigned char[]>(
                                           hcal::raw::utca_nfeds_max * hcal::raw::nbytes_per_fed_max, ctx.stream()),
                                       cms::cuda::make_host_unique<uint32_t[]>(hcal::raw::utca_nfeds_max, ctx.stream()),
                                       cms::cuda::make_host_unique<int[]>(hcal::raw::utca_nfeds_max, ctx.stream())};
 
   // input data gpu
   hcal::raw::InputDataGPU inputGPU = {
       cms::cuda::make_device_unique<unsigned char[]>(hcal::raw::utca_nfeds_max * hcal::raw::nbytes_per_fed_max,
                                                      ctx.stream()),
       cms::cuda::make_device_unique<uint32_t[]>(hcal::raw::utca_nfeds_max, ctx.stream()),
       cms::cuda::make_device_unique<int[]>(hcal::raw::utca_nfeds_max, ctx.stream())};
 
   // output cpu
   outputCPU_ = {cms::cuda::make_host_unique<uint32_t[]>(hcal::raw::numOutputCollections, ctx.stream())};
 
   // output gpu
   outputGPU_.allocate(config_, ctx.stream());
 
   // iterate over feds
   // TODO: another idea
   //   - loop over all feds to unpack and enqueue cuda memcpy
   //   - accumulate the sizes
   //   - after the loop launch cuda memcpy for sizes
   //   - enqueue the kernel
   uint32_t currentCummOffset = 0;
   uint32_t counter = 0;
   for (auto const& fed : fedsToUnpack_) {
     auto const& data = rawDataHandle->FEDData(fed);
     auto const nbytes = data.size();
 
     // skip empty feds
     if (nbytes < hcal::raw::empty_event_size)
       continue;
 
 #ifdef HCAL_RAWDECODE_CPUDEBUG
     printf("fed = %d nbytes = %lu\n", fed, nbytes);
 #endif
 
     // copy raw data into plain buffer
     std::memcpy(inputCPU.data.get() + currentCummOffset, data.data(), nbytes);
     // set the offset in bytes from the start
     inputCPU.offsets[counter] = currentCummOffset;
     inputCPU.feds[counter] = fed;
 
     // this is the current offset into the vector
     currentCummOffset += nbytes;
     ++counter;
   }
 
   hcal::raw::entryPoint(inputCPU,
                         inputGPU,
                         outputGPU_,
                         scratchGPU,
                         outputCPU_,
                         conditions,
                         config_,
                         ctx.stream(),
                         counter,
                         currentCummOffset);
 }

void HcalRawToDigiGPU::fillDescriptions ( edm::ConfigurationDescriptions & confDesc )

static

Definition at line 50 of file HcalRawToDigiGPU.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, unpackBuffers-CaloStage1::feds, mps_fire::i, HLT_FULL_cff::InputTag, label, FEDNumbering::MAXHCALuTCAFEDID, FEDNumbering::MINHCALuTCAFEDID, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                               {
   edm::ParameterSetDescription desc;
 
   desc.add<edm::InputTag>("InputLabel", edm::InputTag("rawDataCollector"));
   auto nFeds = FEDNumbering::MAXHCALuTCAFEDID - FEDNumbering::MINHCALuTCAFEDID + 1;
   std::vector<int> feds(nFeds);
   for (int i = 0; i < nFeds; ++i)
     feds[i] = i + FEDNumbering::MINHCALuTCAFEDID;
   desc.add<std::vector<int>>("FEDs", feds);
   desc.add<uint32_t>("maxChannelsF01HE", 10000u);
   desc.add<uint32_t>("maxChannelsF5HB", 10000u);
   desc.add<uint32_t>("maxChannelsF3HB", 10000u);
   desc.add<uint32_t>("nsamplesF01HE", 8);
   desc.add<uint32_t>("nsamplesF5HB", 8);
   desc.add<uint32_t>("nsamplesF3HB", 8);
   desc.add<std::string>("digisLabelF5HB", "f5HBDigisGPU");
   desc.add<std::string>("digisLabelF01HE", "f01HEDigisGPU");
   desc.add<std::string>("digisLabelF3HB", "f3HBDigisGPU");
 
   std::string label = "hcalRawToDigiGPU";
   confDesc.add(label, desc);
 }

void HcalRawToDigiGPU::produce	(	edm::Event &	event,
		edm::EventSetup const &	setup
	)

overrideprivate

Definition at line 172 of file HcalRawToDigiGPU.cc.

References config_, cudaState_, hcal::raw::OutputDataGPU::digisF01HE, digisF01HEToken_, hcal::raw::OutputDataGPU::digisF3HB, digisF3HBToken_, hcal::raw::OutputDataGPU::digisF5HB, digisF5HBToken_, eostools::move(), hcal::raw::ConfigurationParameters::nsamplesF01HE, hcal::raw::ConfigurationParameters::nsamplesF3HB, hcal::raw::ConfigurationParameters::nsamplesF5HB, hcal::raw::OutputF01HE, hcal::raw::OutputF3HB, hcal::raw::OutputF5HB, outputGPU_, and gpuVertexFinder::printf().

                                                                           {
   cms::cuda::ScopedContextProduce ctx{cudaState_};
 
 #ifdef HCAL_RAWDECODE_CPUDEBUG
   printf("f01he channels = %u f5hb channesl = %u\n",
          outputCPU_.nchannels[hcal::raw::OutputF01HE],
          outputCPU_.nchannels[hcal::raw::OutputF5HB]);
 #endif
 
   // FIXME: use sizes of views directly for cuda mem cpy?
   auto const nchannelsF01HE = outputCPU_.nchannels[hcal::raw::OutputF01HE];
   auto const nchannelsF5HB = outputCPU_.nchannels[hcal::raw::OutputF5HB];
   auto const nchannelsF3HB = outputCPU_.nchannels[hcal::raw::OutputF3HB];
   outputGPU_.digisF01HE.size = nchannelsF01HE;
   outputGPU_.digisF5HB.size = nchannelsF5HB;
   outputGPU_.digisF3HB.size = nchannelsF3HB;
   outputGPU_.digisF01HE.stride = hcal::compute_stride<hcal::Flavor1>(config_.nsamplesF01HE);
   outputGPU_.digisF5HB.stride = hcal::compute_stride<hcal::Flavor5>(config_.nsamplesF5HB);
   outputGPU_.digisF3HB.stride = hcal::compute_stride<hcal::Flavor3>(config_.nsamplesF3HB);
 
   ctx.emplace(event, digisF01HEToken_, std::move(outputGPU_.digisF01HE));
   ctx.emplace(event, digisF5HBToken_, std::move(outputGPU_.digisF5HB));
   ctx.emplace(event, digisF3HBToken_, std::move(outputGPU_.digisF3HB));
 
   // reset ptrs that are carried as members
   outputCPU_.nchannels.reset();
 }

Member Data Documentation

hcal::raw::ConfigurationParameters HcalRawToDigiGPU::config_

private

Definition at line 45 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

cms::cuda::ContextState HcalRawToDigiGPU::cudaState_

private

Definition at line 41 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

edm::EDPutTokenT<ProductTypef01> HcalRawToDigiGPU::digisF01HEToken_

private

Definition at line 35 of file HcalRawToDigiGPU.cc.

Referenced by produce().

edm::EDPutTokenT<ProductTypef3> HcalRawToDigiGPU::digisF3HBToken_

private

Definition at line 39 of file HcalRawToDigiGPU.cc.

Referenced by produce().

edm::EDPutTokenT<ProductTypef5> HcalRawToDigiGPU::digisF5HBToken_

private

Definition at line 37 of file HcalRawToDigiGPU.cc.

Referenced by produce().

edm::ESGetToken<hcal::raw::ElectronicsMappingGPU, HcalElectronicsMapRcd> HcalRawToDigiGPU::eMappingToken_

private

Definition at line 32 of file HcalRawToDigiGPU.cc.

Referenced by acquire().

std::vector<int> HcalRawToDigiGPU::fedsToUnpack_

private

Definition at line 43 of file HcalRawToDigiGPU.cc.

Referenced by acquire().

hcal::raw::OutputDataCPU HcalRawToDigiGPU::outputCPU_

private

Definition at line 47 of file HcalRawToDigiGPU.cc.

Referenced by acquire().

hcal::raw::OutputDataGPU HcalRawToDigiGPU::outputGPU_

private

Definition at line 46 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

edm::EDGetTokenT<FEDRawDataCollection> HcalRawToDigiGPU::rawDataToken_

private

Definition at line 33 of file HcalRawToDigiGPU.cc.

Referenced by acquire().

Private Attributes
hcal::raw::ConfigurationParameters	config_

cms::cuda::ContextState	cudaState_

edm::EDPutTokenT< ProductTypef01 >	digisF01HEToken_

edm::EDPutTokenT< ProductTypef3 >	digisF3HBToken_

edm::EDPutTokenT< ProductTypef5 >	digisF5HBToken_

edm::ESGetToken < hcal::raw::ElectronicsMappingGPU, HcalElectronicsMapRcd >	eMappingToken_

std::vector< int >	fedsToUnpack_

hcal::raw::OutputDataCPU	outputCPU_

hcal::raw::OutputDataGPU	outputGPU_

edm::EDGetTokenT < FEDRawDataCollection >	rawDataToken_

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation