CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
List of all members | Public Member Functions | Static Public Member Functions | Private Types | Private Member Functions | Private Attributes
HcalRawToDigiGPU Class Reference
Inheritance diagram for HcalRawToDigiGPU:
edm::stream::EDProducer< edm::ExternalWork >

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 EDProduceroperator= (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< ProductTypef01digisF01HEToken_
 
edm::EDPutTokenT< ProductTypef3digisF3HBToken_
 
edm::EDPutTokenT< ProductTypef5digisF5HBToken_
 
edm::ESGetToken< hcal::raw::ElectronicsMappingGPU, HcalElectronicsMapRcdeMappingToken_
 
std::vector< int > fedsToUnpack_
 
hcal::raw::OutputDataCPU outputCPU_
 
hcal::raw::OutputDataGPU outputGPU_
 
edm::EDGetTokenT< FEDRawDataCollectionrawDataToken_
 

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

◆ ProductTypef01

Definition at line 34 of file HcalRawToDigiGPU.cc.

◆ ProductTypef3

Definition at line 38 of file HcalRawToDigiGPU.cc.

◆ ProductTypef5

Definition at line 36 of file HcalRawToDigiGPU.cc.

Constructor & Destructor Documentation

◆ HcalRawToDigiGPU()

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

Definition at line 73 of file HcalRawToDigiGPU.cc.

References deDxTools::esConsumes().

75  rawDataToken_{consumes<FEDRawDataCollection>(ps.getParameter<edm::InputTag>("InputLabel"))},
76  digisF01HEToken_{produces<ProductTypef01>(ps.getParameter<std::string>("digisLabelF01HE"))},
77  digisF5HBToken_{produces<ProductTypef5>(ps.getParameter<std::string>("digisLabelF5HB"))},
78  digisF3HBToken_{produces<ProductTypef3>(ps.getParameter<std::string>("digisLabelF3HB"))},
79  fedsToUnpack_{ps.getParameter<std::vector<int>>("FEDs")} {
80  config_.maxChannelsF01HE = ps.getParameter<uint32_t>("maxChannelsF01HE");
81  config_.maxChannelsF5HB = ps.getParameter<uint32_t>("maxChannelsF5HB");
82  config_.maxChannelsF3HB = ps.getParameter<uint32_t>("maxChannelsF3HB");
83  config_.nsamplesF01HE = ps.getParameter<uint32_t>("nsamplesF01HE");
84  config_.nsamplesF5HB = ps.getParameter<uint32_t>("nsamplesF5HB");
85  config_.nsamplesF3HB = ps.getParameter<uint32_t>("nsamplesF3HB");
86 }
ESGetTokenH3DDVariant esConsumes(std::string const &Record, edm::ConsumesCollector &)
Definition: DeDxTools.cc:283
edm::ESGetToken< hcal::raw::ElectronicsMappingGPU, HcalElectronicsMapRcd > eMappingToken_
edm::EDPutTokenT< ProductTypef5 > digisF5HBToken_
edm::EDGetTokenT< FEDRawDataCollection > rawDataToken_
edm::EDPutTokenT< ProductTypef01 > digisF01HEToken_
hcal::raw::ConfigurationParameters config_
edm::EDPutTokenT< ProductTypef3 > digisF3HBToken_
std::vector< int > fedsToUnpack_

◆ ~HcalRawToDigiGPU()

HcalRawToDigiGPU::~HcalRawToDigiGPU ( )
override

Definition at line 88 of file HcalRawToDigiGPU.cc.

88 {}

Member Function Documentation

◆ acquire()

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_, 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.

92  {
93  // raii
94  cms::cuda::ScopedContextAcquire ctx{event.streamID(), std::move(holder), cudaState_};
95 
96  // conditions
97  auto const& eMappingProduct = setup.getData(eMappingToken_).getProduct(ctx.stream());
98 
99  // bundle up conditions
100  hcal::raw::ConditionsProducts conditions{eMappingProduct};
101 
102  // event data
103  edm::Handle<FEDRawDataCollection> rawDataHandle;
104  event.getByToken(rawDataToken_, rawDataHandle);
105 
106  // scratch
107  hcal::raw::ScratchDataGPU scratchGPU = {
108  cms::cuda::make_device_unique<uint32_t[]>(hcal::raw::numOutputCollections, ctx.stream())};
109 
110  // input cpu data
111  hcal::raw::InputDataCPU inputCPU = {cms::cuda::make_host_unique<unsigned char[]>(
113  cms::cuda::make_host_unique<uint32_t[]>(hcal::raw::utca_nfeds_max, ctx.stream()),
115 
116  // input data gpu
117  hcal::raw::InputDataGPU inputGPU = {
118  cms::cuda::make_device_unique<unsigned char[]>(hcal::raw::utca_nfeds_max * hcal::raw::nbytes_per_fed_max,
119  ctx.stream()),
120  cms::cuda::make_device_unique<uint32_t[]>(hcal::raw::utca_nfeds_max, ctx.stream()),
122 
123  // output cpu
124  outputCPU_ = {cms::cuda::make_host_unique<uint32_t[]>(hcal::raw::numOutputCollections, ctx.stream())};
125 
126  // output gpu
127  outputGPU_.allocate(config_, ctx.stream());
128 
129  // iterate over feds
130  // TODO: another idea
131  // - loop over all feds to unpack and enqueue cuda memcpy
132  // - accumulate the sizes
133  // - after the loop launch cuda memcpy for sizes
134  // - enqueue the kernel
135  uint32_t currentCummOffset = 0;
136  uint32_t counter = 0;
137  for (auto const& fed : fedsToUnpack_) {
138  auto const& data = rawDataHandle->FEDData(fed);
139  auto const nbytes = data.size();
140 
141  // skip empty feds
142  if (nbytes < hcal::raw::empty_event_size)
143  continue;
144 
145 #ifdef HCAL_RAWDECODE_CPUDEBUG
146  printf("fed = %d nbytes = %lu\n", fed, nbytes);
147 #endif
148 
149  // copy raw data into plain buffer
150  std::memcpy(inputCPU.data.get() + currentCummOffset, data.data(), nbytes);
151  // set the offset in bytes from the start
152  inputCPU.offsets[counter] = currentCummOffset;
153  inputCPU.feds[counter] = fed;
154 
155  // this is the current offset into the vector
156  currentCummOffset += nbytes;
157  ++counter;
158  }
159 
160  hcal::raw::entryPoint(inputCPU,
161  inputGPU,
162  outputGPU_,
163  scratchGPU,
164  outputCPU_,
165  conditions,
166  config_,
167  ctx.stream(),
168  counter,
169  currentCummOffset);
170 }
hcal::raw::OutputDataGPU outputGPU_
constexpr uint32_t nbytes_per_fed_max
cms::cuda::ContextState cudaState_
constexpr int32_t empty_event_size
cms::cuda::host::unique_ptr< unsigned char[]> data
edm::ESGetToken< hcal::raw::ElectronicsMappingGPU, HcalElectronicsMapRcd > eMappingToken_
const FEDRawData & FEDData(int fedid) const
retrieve data for fed
edm::EDGetTokenT< FEDRawDataCollection > rawDataToken_
void entryPoint(InputDataCPU const &, InputDataGPU &, OutputDataGPU &, ScratchDataGPU &, OutputDataCPU &, ConditionsProducts const &, ConfigurationParameters const &, cudaStream_t cudaStream, uint32_t const, uint32_t const)
hcal::raw::OutputDataCPU outputCPU_
constexpr uint32_t numOutputCollections
hcal::raw::ConfigurationParameters config_
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:79
std::vector< int > fedsToUnpack_
static std::atomic< unsigned int > counter
device::impl::make_device_unique_selector< T >::non_array make_device_unique(cudaStream_t stream)
cms::cuda::host::unique_ptr< int[]> feds
host::impl::make_host_unique_selector< T >::non_array make_host_unique(cudaStream_t stream)
cms::cuda::host::unique_ptr< uint32_t[]> offsets
void allocate(ConfigurationParameters const &config, cudaStream_t cudaStream)
def move(src, dest)
Definition: eostools.py:511
constexpr uint32_t utca_nfeds_max

◆ fillDescriptions()

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

Definition at line 50 of file HcalRawToDigiGPU.cc.

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

50  {
52 
53  desc.add<edm::InputTag>("InputLabel", edm::InputTag("rawDataCollector"));
55  std::vector<int> feds(nFeds);
56  for (int i = 0; i < nFeds; ++i)
58  desc.add<std::vector<int>>("FEDs", feds);
59  desc.add<uint32_t>("maxChannelsF01HE", 10000u);
60  desc.add<uint32_t>("maxChannelsF5HB", 10000u);
61  desc.add<uint32_t>("maxChannelsF3HB", 10000u);
62  desc.add<uint32_t>("nsamplesF01HE", 8);
63  desc.add<uint32_t>("nsamplesF5HB", 8);
64  desc.add<uint32_t>("nsamplesF3HB", 8);
65  desc.add<std::string>("digisLabelF5HB", "f5HBDigisGPU");
66  desc.add<std::string>("digisLabelF01HE", "f01HEDigisGPU");
67  desc.add<std::string>("digisLabelF3HB", "f3HBDigisGPU");
68 
69  std::string label = "hcalRawToDigiGPU";
70  confDesc.add(label, desc);
71 }
char const * label
void add(std::string const &label, ParameterSetDescription const &psetDescription)

◆ produce()

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::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_.

172  {
174 
175 #ifdef HCAL_RAWDECODE_CPUDEBUG
176  printf("f01he channels = %u f5hb channesl = %u\n",
179 #endif
180 
181  // FIXME: use sizes of views directly for cuda mem cpy?
182  auto const nchannelsF01HE = outputCPU_.nchannels[hcal::raw::OutputF01HE];
183  auto const nchannelsF5HB = outputCPU_.nchannels[hcal::raw::OutputF5HB];
184  auto const nchannelsF3HB = outputCPU_.nchannels[hcal::raw::OutputF3HB];
185  outputGPU_.digisF01HE.size = nchannelsF01HE;
186  outputGPU_.digisF5HB.size = nchannelsF5HB;
187  outputGPU_.digisF3HB.size = nchannelsF3HB;
188  outputGPU_.digisF01HE.stride = hcal::compute_stride<hcal::Flavor1>(config_.nsamplesF01HE);
189  outputGPU_.digisF5HB.stride = hcal::compute_stride<hcal::Flavor5>(config_.nsamplesF5HB);
190  outputGPU_.digisF3HB.stride = hcal::compute_stride<hcal::Flavor3>(config_.nsamplesF3HB);
191 
195 
196  // reset ptrs that are carried as members
197  outputCPU_.nchannels.reset();
198 }
hcal::raw::OutputDataGPU outputGPU_
DigiCollection< Flavor5, ::calo::common::DevStoragePolicy > digisF5HB
constexpr uint8_t OutputF5HB
cms::cuda::ContextState cudaState_
edm::EDPutTokenT< ProductTypef5 > digisF5HBToken_
constexpr uint8_t OutputF3HB
DigiCollection< Flavor1, ::calo::common::DevStoragePolicy > digisF01HE
edm::EDPutTokenT< ProductTypef01 > digisF01HEToken_
hcal::raw::OutputDataCPU outputCPU_
cms::cuda::host::unique_ptr< uint32_t[]> nchannels
hcal::raw::ConfigurationParameters config_
edm::EDPutTokenT< ProductTypef3 > digisF3HBToken_
DigiCollection< Flavor3, ::calo::common::DevStoragePolicy > digisF3HB
def move(src, dest)
Definition: eostools.py:511
Definition: event.py:1
constexpr uint8_t OutputF01HE

Member Data Documentation

◆ config_

hcal::raw::ConfigurationParameters HcalRawToDigiGPU::config_
private

Definition at line 45 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

◆ cudaState_

cms::cuda::ContextState HcalRawToDigiGPU::cudaState_
private

Definition at line 41 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

◆ digisF01HEToken_

edm::EDPutTokenT<ProductTypef01> HcalRawToDigiGPU::digisF01HEToken_
private

Definition at line 35 of file HcalRawToDigiGPU.cc.

Referenced by produce().

◆ digisF3HBToken_

edm::EDPutTokenT<ProductTypef3> HcalRawToDigiGPU::digisF3HBToken_
private

Definition at line 39 of file HcalRawToDigiGPU.cc.

Referenced by produce().

◆ digisF5HBToken_

edm::EDPutTokenT<ProductTypef5> HcalRawToDigiGPU::digisF5HBToken_
private

Definition at line 37 of file HcalRawToDigiGPU.cc.

Referenced by produce().

◆ eMappingToken_

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

Definition at line 32 of file HcalRawToDigiGPU.cc.

Referenced by acquire().

◆ fedsToUnpack_

std::vector<int> HcalRawToDigiGPU::fedsToUnpack_
private

Definition at line 43 of file HcalRawToDigiGPU.cc.

Referenced by acquire().

◆ outputCPU_

hcal::raw::OutputDataCPU HcalRawToDigiGPU::outputCPU_
private

Definition at line 47 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

◆ outputGPU_

hcal::raw::OutputDataGPU HcalRawToDigiGPU::outputGPU_
private

Definition at line 46 of file HcalRawToDigiGPU.cc.

Referenced by acquire(), and produce().

◆ rawDataToken_

edm::EDGetTokenT<FEDRawDataCollection> HcalRawToDigiGPU::rawDataToken_
private

Definition at line 33 of file HcalRawToDigiGPU.cc.

Referenced by acquire().