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_
const uint32_t	maxFedSize_
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

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 ( edm::ParameterSet const &  ps )

explicit

Definition at line 62 of file EcalRawToDigiGPU.cc.

References edm::ParameterSet::getParameter().

    : 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>()},
      maxFedSize_{ps.getParameter<uint32_t>("maxFedSize")},
      fedsToUnpack_{ps.getParameter<std::vector<int>>("FEDs")} {
  config_.maxChannelsEB = ps.getParameter<uint32_t>("maxChannelsEB");
  config_.maxChannelsEE = ps.getParameter<uint32_t>("maxChannelsEE");
}

EcalRawToDigiGPU::~EcalRawToDigiGPU ( )

override

Definition at line 73 of file EcalRawToDigiGPU.cc.

{}

Member Function Documentation

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

overrideprivate

Definition at line 75 of file EcalRawToDigiGPU.cc.

References ecal::raw::OutputDataGPU::allocate(), submitPVValidationJobs::conditions, config_, counter, cudaState_, data, eMappingToken_, ecal::raw::empty_event_size, ecal::raw::entryPoint(), fedsToUnpack_, edm::EventSetup::getHandle(), cms::cuda::make_device_unique(), cms::cuda::make_host_unique(), maxFedSize_, eostools::move(), ecal::raw::OutputDataCPU::nchannels, ecal::raw::nfeds_max, outputCPU_, outputGPU_, and rawDataToken_.

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

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

static

Definition at line 44 of file EcalRawToDigiGPU.cc.

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

                                                                              {
  edm::ParameterSetDescription desc;

  desc.add<edm::InputTag>("InputLabel", edm::InputTag("rawDataCollector"));
  desc.add<uint32_t>("maxFedSize", ecal::raw::nbytes_per_fed_max);
  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);
}

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

overrideprivate

Definition at line 150 of file EcalRawToDigiGPU.cc.

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

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

Member Data Documentation

ecal::raw::ConfigurationParameters EcalRawToDigiGPU::config_

private

Definition at line 39 of file EcalRawToDigiGPU.cc.

Referenced by acquire().

cms::cuda::ContextState EcalRawToDigiGPU::cudaState_

private

Definition at line 34 of file EcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

edm::EDPutTokenT<OutputProduct> EcalRawToDigiGPU::digisEBToken_

private

Definition at line 31 of file EcalRawToDigiGPU.cc.

Referenced by produce().

edm::EDPutTokenT<OutputProduct> EcalRawToDigiGPU::digisEEToken_

private

Definition at line 31 of file EcalRawToDigiGPU.cc.

Referenced by produce().

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

private

Definition at line 32 of file EcalRawToDigiGPU.cc.

Referenced by acquire().

std::vector<int> EcalRawToDigiGPU::fedsToUnpack_

private

Definition at line 37 of file EcalRawToDigiGPU.cc.

Referenced by acquire().

const uint32_t EcalRawToDigiGPU::maxFedSize_

private

Definition at line 36 of file EcalRawToDigiGPU.cc.

Referenced by acquire().

ecal::raw::OutputDataCPU EcalRawToDigiGPU::outputCPU_

private

Definition at line 41 of file EcalRawToDigiGPU.cc.

Referenced by acquire().

ecal::raw::OutputDataGPU EcalRawToDigiGPU::outputGPU_

private

Definition at line 40 of file EcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

edm::EDGetTokenT<FEDRawDataCollection> EcalRawToDigiGPU::rawDataToken_

private

Definition at line 29 of file EcalRawToDigiGPU.cc.

Referenced by acquire().