EcalRawToDigiGPU Class Reference

Inheritance diagram for EcalRawToDigiGPU:

Public Member Functions
	EcalRawToDigiGPU (edm::ParameterSet const &ps)
	~EcalRawToDigiGPU () 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	OutputProduct = cms::cuda::Product< ecal::DigisCollection< 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
ecal::raw::ConfigurationParameters	config_
cms::cuda::ContextState	cudaState_
edm::EDPutTokenT< OutputProduct >	digisEBToken_
edm::EDPutTokenT< OutputProduct >	digisEEToken_
edm::ESGetToken< ecal::raw::ElectronicsMappingGPU, EcalMappingElectronicsRcd >	eMappingToken_
std::vector< int >	fedsToUnpack_
ecal::raw::OutputDataCPU	outputCPU_
ecal::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 18 of file EcalRawToDigiGPU.cc.

Member Typedef Documentation

OutputProduct

using EcalRawToDigiGPU::OutputProduct = cms::cuda::Product<ecal::DigisCollection<calo::common::DevStoragePolicy> >

private

Definition at line 30 of file EcalRawToDigiGPU.cc.

Constructor & Destructor Documentation

EcalRawToDigiGPU()

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

explicit

Definition at line 60 of file EcalRawToDigiGPU.cc.

    : rawDataToken_{consumes<FEDRawDataCollection>(ps.getParameter<edm::InputTag>("InputLabel"))},
      digisEBToken_{produces<OutputProduct>(ps.getParameter<std::string>("digisLabelEB"))},
      digisEEToken_{produces<OutputProduct>(ps.getParameter<std::string>("digisLabelEE"))},
      eMappingToken_{esConsumes<ecal::raw::ElectronicsMappingGPU, EcalMappingElectronicsRcd>()},
      fedsToUnpack_{ps.getParameter<std::vector<int>>("FEDs")} {
  config_.maxChannelsEB = ps.getParameter<uint32_t>("maxChannelsEB");
  config_.maxChannelsEE = ps.getParameter<uint32_t>("maxChannelsEE");
}

References edm::ParameterSet::getParameter().

~EcalRawToDigiGPU()

EcalRawToDigiGPU::~EcalRawToDigiGPU ( )

override

Definition at line 70 of file EcalRawToDigiGPU.cc.

{}

Member Function Documentation

acquire()

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

overrideprivate

Definition at line 72 of file EcalRawToDigiGPU.cc.

                                                                     {
  // raii
  cms::cuda::ScopedContextAcquire ctx{event.streamID(), std::move(holder), cudaState_};
 
  // conditions
  edm::ESHandle<ecal::raw::ElectronicsMappingGPU> eMappingHandle = setup.getHandle(eMappingToken_);
  auto const& eMappingProduct = eMappingHandle->getProduct(ctx.stream());
 
  // bundle up conditions
  ecal::raw::ConditionsProducts conditions{eMappingProduct};
 
  // event data
  edm::Handle<FEDRawDataCollection> rawDataHandle;
  event.getByToken(rawDataToken_, rawDataHandle);
 
  // scratch
  ecal::raw::ScratchDataGPU scratchGPU = {cms::cuda::make_device_unique<uint32_t[]>(2, ctx.stream())};
 
  // input cpu data
  ecal::raw::InputDataCPU inputCPU = {
      cms::cuda::make_host_unique<unsigned char[]>(ecal::raw::nfeds_max * ecal::raw::nbytes_per_fed_max, ctx.stream()),
      cms::cuda::make_host_unique<uint32_t[]>(ecal::raw::nfeds_max, ctx.stream()),
      cms::cuda::make_host_unique<int[]>(ecal::raw::nfeds_max, ctx.stream())};
 
  // input data gpu
  ecal::raw::InputDataGPU inputGPU = {cms::cuda::make_device_unique<unsigned char[]>(
                                          ecal::raw::nfeds_max * ecal::raw::nbytes_per_fed_max, ctx.stream()),
                                      cms::cuda::make_device_unique<uint32_t[]>(ecal::raw::nfeds_max, ctx.stream()),
                                      cms::cuda::make_device_unique<int[]>(ecal::raw::nfeds_max, ctx.stream())};
 
  // output cpu
  outputCPU_ = {cms::cuda::make_host_unique<uint32_t[]>(2, ctx.stream())};
  // initialize the number of channels
  outputCPU_.nchannels[0] = 0;
  outputCPU_.nchannels[1] = 0;
 
  // 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 < ecal::raw::empty_event_size)
      continue;
 
    // 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;
  }
 
  // unpack if at least one FED has data
  if (counter > 0) {
    ecal::raw::entryPoint(
        inputCPU, inputGPU, outputGPU_, scratchGPU, outputCPU_, conditions, ctx.stream(), counter, currentCummOffset);
  }
}

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

fillDescriptions()

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

static

Definition at line 43 of file EcalRawToDigiGPU.cc.

                                                                              {
  edm::ParameterSetDescription desc;
 
  desc.add<edm::InputTag>("InputLabel", edm::InputTag("rawDataCollector"));
  std::vector<int> feds(54);
  for (uint32_t i = 0; i < 54; ++i)
    feds[i] = i + 601;
  desc.add<std::vector<int>>("FEDs", feds);
  desc.add<uint32_t>("maxChannelsEB", 61200);
  desc.add<uint32_t>("maxChannelsEE", 14648);
  desc.add<std::string>("digisLabelEB", "ebDigis");
  desc.add<std::string>("digisLabelEE", "eeDigis");
 
  std::string label = "ecalRawToDigiGPU";
  confDesc.add(label, desc);
}

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

produce()

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

overrideprivate

Definition at line 147 of file EcalRawToDigiGPU.cc.

                                                                          {
  cms::cuda::ScopedContextProduce ctx{cudaState_};
 
  // get the number of channels
  outputGPU_.digisEB.size = outputCPU_.nchannels[0];
  outputGPU_.digisEE.size = outputCPU_.nchannels[1];
 
  ctx.emplace(event, digisEBToken_, std::move(outputGPU_.digisEB));
  ctx.emplace(event, digisEEToken_, std::move(outputGPU_.digisEE));
 
  // reset ptrs that are carried as members
  outputCPU_.nchannels.reset();
}

References cudaState_, ecal::raw::OutputDataGPU::digisEB, digisEBToken_, ecal::raw::OutputDataGPU::digisEE, digisEEToken_, eostools::move(), ecal::raw::OutputDataCPU::nchannels, outputCPU_, and outputGPU_.

Member Data Documentation

config_

ecal::raw::ConfigurationParameters EcalRawToDigiGPU::config_

private

Definition at line 38 of file EcalRawToDigiGPU.cc.

Referenced by acquire().

cudaState_

cms::cuda::ContextState EcalRawToDigiGPU::cudaState_

private

Definition at line 34 of file EcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

digisEBToken_

edm::EDPutTokenT<OutputProduct> EcalRawToDigiGPU::digisEBToken_

private

Definition at line 31 of file EcalRawToDigiGPU.cc.

Referenced by produce().

digisEEToken_

edm::EDPutTokenT<OutputProduct> EcalRawToDigiGPU::digisEEToken_

private

Definition at line 31 of file EcalRawToDigiGPU.cc.

Referenced by produce().

eMappingToken_

edm::ESGetToken<ecal::raw::ElectronicsMappingGPU, EcalMappingElectronicsRcd> EcalRawToDigiGPU::eMappingToken_

private

Definition at line 32 of file EcalRawToDigiGPU.cc.

Referenced by acquire().

fedsToUnpack_

std::vector<int> EcalRawToDigiGPU::fedsToUnpack_

private

Definition at line 36 of file EcalRawToDigiGPU.cc.

Referenced by acquire().

outputCPU_

ecal::raw::OutputDataCPU EcalRawToDigiGPU::outputCPU_

private

Definition at line 40 of file EcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

outputGPU_

ecal::raw::OutputDataGPU EcalRawToDigiGPU::outputGPU_

private

Definition at line 39 of file EcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

rawDataToken_

edm::EDGetTokenT<FEDRawDataCollection> EcalRawToDigiGPU::rawDataToken_

private

Definition at line 29 of file EcalRawToDigiGPU.cc.

Referenced by acquire().