HcalRawToDigiGPU Class Reference

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
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final

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

Private Attributes
hcal::raw::ConfigurationParameters	config_
cms::cuda::ContextState	cudaState_
edm::EDPutTokenT< ProductTypef01 >	digisF01HEToken_
edm::EDPutTokenT< ProductTypef3 >	digisF3HBToken_
edm::EDPutTokenT< ProductTypef5 >	digisF5HBToken_
std::vector< int >	fedsToUnpack_
hcal::raw::OutputDataCPU	outputCPU_
hcal::raw::OutputDataGPU	outputGPU_
edm::EDGetTokenT< FEDRawDataCollection >	rawDataToken_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::ExternalWork >
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 21 of file HcalRawToDigiGPU.cc.

Member Typedef Documentation

ProductTypef01

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

private

Definition at line 33 of file HcalRawToDigiGPU.cc.

ProductTypef3

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

private

Definition at line 37 of file HcalRawToDigiGPU.cc.

ProductTypef5

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

private

Definition at line 35 of file HcalRawToDigiGPU.cc.

Constructor & Destructor Documentation

HcalRawToDigiGPU()

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

explicit

Definition at line 72 of file HcalRawToDigiGPU.cc.

    : 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");
}

References edm::ParameterSet::getParameter().

~HcalRawToDigiGPU()

HcalRawToDigiGPU::~HcalRawToDigiGPU ( )

override

Definition at line 86 of file HcalRawToDigiGPU.cc.

{}

Member Function Documentation

acquire()

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

overrideprivate

Definition at line 88 of file HcalRawToDigiGPU.cc.

                                                                     {
  // raii
  cms::cuda::ScopedContextAcquire ctx{event.streamID(), std::move(holder), cudaState_};
 
  // conditions
  edm::ESHandle<hcal::raw::ElectronicsMappingGPU> eMappingHandle;
  setup.get<HcalElectronicsMapRcd>().get(eMappingHandle);
  auto const& eMappingProduct = eMappingHandle->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);
}

References hcal::raw::OutputDataGPU::allocate(), submitPVValidationJobs::conditions, config_, counter, cudaState_, hcal::raw::InputDataCPU::data, data, hcal::raw::empty_event_size, hcal::raw::entryPoint(), FEDRawDataCollection::FEDData(), hcal::raw::InputDataCPU::feds, fedsToUnpack_, get, hcal::raw::ElectronicsMappingGPU::getProduct(), cms::cuda::make_device_unique(), cms::cuda::make_host_unique(), eostools::move(), hcal::raw::nbytes_per_fed_max, hcal::raw::numOutputCollections, hcal::raw::InputDataCPU::offsets, outputCPU_, outputGPU_, rawDataToken_, singleTopDQM_cfi::setup, and hcal::raw::utca_nfeds_max.

fillDescriptions()

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

static

Definition at line 49 of file HcalRawToDigiGPU.cc.

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

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

produce()

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

overrideprivate

Definition at line 172 of file HcalRawToDigiGPU.cc.

                                                                          {
  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();
}

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

Member Data Documentation

config_

hcal::raw::ConfigurationParameters HcalRawToDigiGPU::config_

private

Definition at line 44 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

cudaState_

cms::cuda::ContextState HcalRawToDigiGPU::cudaState_

private

Definition at line 40 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

digisF01HEToken_

edm::EDPutTokenT<ProductTypef01> HcalRawToDigiGPU::digisF01HEToken_

private

Definition at line 34 of file HcalRawToDigiGPU.cc.

Referenced by produce().

digisF3HBToken_

edm::EDPutTokenT<ProductTypef3> HcalRawToDigiGPU::digisF3HBToken_

private

Definition at line 38 of file HcalRawToDigiGPU.cc.

Referenced by produce().

digisF5HBToken_

edm::EDPutTokenT<ProductTypef5> HcalRawToDigiGPU::digisF5HBToken_

private

Definition at line 36 of file HcalRawToDigiGPU.cc.

Referenced by produce().

fedsToUnpack_

std::vector<int> HcalRawToDigiGPU::fedsToUnpack_

private

Definition at line 42 of file HcalRawToDigiGPU.cc.

Referenced by acquire().

outputCPU_

hcal::raw::OutputDataCPU HcalRawToDigiGPU::outputCPU_

private

Definition at line 46 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

outputGPU_

hcal::raw::OutputDataGPU HcalRawToDigiGPU::outputGPU_

private

Definition at line 45 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

rawDataToken_

edm::EDGetTokenT<FEDRawDataCollection> HcalRawToDigiGPU::rawDataToken_

private

Definition at line 32 of file HcalRawToDigiGPU.cc.

Referenced by acquire().