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
	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

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_

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 16 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 29 of file HcalRawToDigiGPU.cc.

ProductTypef3

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

private

Definition at line 33 of file HcalRawToDigiGPU.cc.

ProductTypef5

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

private

Definition at line 31 of file HcalRawToDigiGPU.cc.

Constructor & Destructor Documentation

HcalRawToDigiGPU()

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

explicit

Definition at line 68 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::~HcalRawToDigiGPU ( )

override

Definition at line 83 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 85 of file HcalRawToDigiGPU.cc.

References hcal::raw::OutputDataGPU::allocate(), submitPVValidationJobs::conditions, config_, counter, cudaState_, hcal::raw::InputDataCPU::data, data, eMappingToken_, hcal::raw::empty_event_size, hcal::raw::entryPoint(), FEDRawDataCollection::FEDData(), hcal::raw::InputDataCPU::feds, fedsToUnpack_, 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.

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

fillDescriptions()

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

static

Definition at line 45 of file HcalRawToDigiGPU.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, l1tstage2emulator_dqm_sourceclient-live_cfg::feds, mps_fire::i, ProducerED_cfi::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);
}

produce()

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

overrideprivate

Definition at line 167 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::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_.

                                                                          {
  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

config_

hcal::raw::ConfigurationParameters HcalRawToDigiGPU::config_

private

Definition at line 40 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

cudaState_

cms::cuda::ContextState HcalRawToDigiGPU::cudaState_

private

Definition at line 36 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

digisF01HEToken_

edm::EDPutTokenT<ProductTypef01> HcalRawToDigiGPU::digisF01HEToken_

private

Definition at line 30 of file HcalRawToDigiGPU.cc.

Referenced by produce().

digisF3HBToken_

edm::EDPutTokenT<ProductTypef3> HcalRawToDigiGPU::digisF3HBToken_

private

Definition at line 34 of file HcalRawToDigiGPU.cc.

Referenced by produce().

digisF5HBToken_

edm::EDPutTokenT<ProductTypef5> HcalRawToDigiGPU::digisF5HBToken_

private

Definition at line 32 of file HcalRawToDigiGPU.cc.

Referenced by produce().

eMappingToken_

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

private

Definition at line 27 of file HcalRawToDigiGPU.cc.

Referenced by acquire().

fedsToUnpack_

std::vector<int> HcalRawToDigiGPU::fedsToUnpack_

private

Definition at line 38 of file HcalRawToDigiGPU.cc.

Referenced by acquire().

outputCPU_

hcal::raw::OutputDataCPU HcalRawToDigiGPU::outputCPU_

private

Definition at line 42 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

outputGPU_

hcal::raw::OutputDataGPU HcalRawToDigiGPU::outputGPU_

private

Definition at line 41 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

rawDataToken_

edm::EDGetTokenT<FEDRawDataCollection> HcalRawToDigiGPU::rawDataToken_

private

Definition at line 28 of file HcalRawToDigiGPU.cc.

Referenced by acquire().