CMS 3D CMS Logo

ProducingModuleAdaptor.h
Go to the documentation of this file.
1 #ifndef FWCore_Framework_stream_ProducingModuleAdaptor_h
2 #define FWCore_Framework_stream_ProducingModuleAdaptor_h
3 // -*- C++ -*-
4 //
5 // Package: FWCore/Framework
6 // Class : ProducingModuleAdaptor
7 //
16 //
17 // Original Author: Chris Jones
18 // Created: Fri, 02 Aug 2013 18:09:18 GMT
19 //
20 
21 // system include files
22 
23 // user include files
35 // forward declarations
36 
37 namespace edm {
39  namespace stream {
40 
41  template <typename T, typename M, typename B>
42  class ProducingModuleAdaptor : public B {
43  public:
45  m_runs.resize(1);
46  m_lumis.resize(1);
47  m_runSummaries.resize(1);
48  m_lumiSummaries.resize(1);
49  typename T::GlobalCache const* dummy = nullptr;
50  m_global = impl::makeGlobal<T>(iPSet, dummy);
51  typename T::InputProcessBlockCache const* dummyInputProcessBlockCacheImpl = nullptr;
52  m_inputProcessBlocks = impl::makeInputProcessBlockCacheImpl(dummyInputProcessBlockCacheImpl);
53  }
54  ProducingModuleAdaptor(const ProducingModuleAdaptor&) = delete; // stop default
55  const ProducingModuleAdaptor& operator=(const ProducingModuleAdaptor&) = delete; // stop default
56  ~ProducingModuleAdaptor() override { this->deleteModulesEarly(); }
57 
58  static void fillDescriptions(ConfigurationDescriptions& descriptions) { T::fillDescriptions(descriptions); }
59  static void prevalidate(ConfigurationDescriptions& descriptions) { T::prevalidate(descriptions); }
60 
61  bool wantsProcessBlocks() const final {
62  return T::HasAbility::kWatchProcessBlock or T::HasAbility::kBeginProcessBlockProducer or
63  T::HasAbility::kEndProcessBlockProducer;
64  }
65  bool wantsInputProcessBlocks() const final { return T::HasAbility::kInputProcessBlockCache; }
66  bool wantsGlobalRuns() const final {
69  }
72  T::HasAbility::kBeginLuminosityBlockProducer or T::HasAbility::kEndLuminosityBlockProducer;
73  }
74 
75  bool hasAcquire() const final { return T::HasAbility::kExternalWork; }
76 
77  bool hasAccumulator() const final { return T::HasAbility::kAccumulator; }
78 
79  private:
93 
94  void setupStreamModules() final {
95  this->createStreamModules([this](unsigned int iStreamModule) -> M* {
96  auto tmp = impl::makeStreamModule<T>(*m_pset, m_global.get());
97  MyGlobal::set(tmp, m_global.get());
99  return tmp;
100  });
101  m_pset = nullptr;
102  }
103 
104  void preallocLumis(unsigned int iNLumis) final {
105  m_lumis.resize(iNLumis);
106  m_lumiSummaries.resize(iNLumis);
107  }
108  void doBeginJob() final { MyGlobal::beginJob(m_global.get()); }
109  void doEndJob() final { MyGlobal::endJob(m_global.get()); }
110  void setupRun(M* iProd, RunIndex iIndex) final { MyGlobalRun::set(iProd, m_runs[iIndex].get()); }
111  void streamEndRunSummary(M* iProd, edm::Run const& iRun, edm::EventSetup const& iES) final {
112  auto s = m_runSummaries[iRun.index()].get();
113  std::lock_guard<decltype(m_runSummaryLock)> guard(m_runSummaryLock);
114  MyGlobalRunSummary::streamEndRunSummary(iProd, iRun, iES, s);
115  }
116 
117  void setupLuminosityBlock(M* iProd, LuminosityBlockIndex iIndex) final {
118  MyGlobalLuminosityBlock::set(iProd, m_lumis[iIndex].get());
119  }
121  edm::LuminosityBlock const& iLumi,
122  edm::EventSetup const& iES) final {
123  auto s = m_lumiSummaries[iLumi.index()].get();
124  std::lock_guard<decltype(m_lumiSummaryLock)> guard(m_lumiSummaryLock);
126  }
127 
129  if constexpr (T::HasAbility::kWatchProcessBlock or T::HasAbility::kBeginProcessBlockProducer) {
130  ProcessBlock processBlock(pbp, this->moduleDescription(), mcc, false);
131  ProcessBlock const& cnstProcessBlock = processBlock;
132  processBlock.setConsumer(this->consumer());
133  MyWatchProcessBlock::beginProcessBlock(cnstProcessBlock, m_global.get());
134  if constexpr (T::HasAbility::kBeginProcessBlockProducer) {
135  processBlock.setProducer(this->producer());
136  MyBeginProcessBlockProduce::produce(processBlock, m_global.get());
137  this->commit(processBlock);
138  }
139  }
140  }
141 
143  if constexpr (T::HasAbility::kInputProcessBlockCache) {
144  ProcessBlock processBlock(pbp, this->moduleDescription(), mcc, false);
145  ProcessBlock const& cnstProcessBlock = processBlock;
146  processBlock.setConsumer(this->consumer());
148  }
149  }
150 
151  void doEndProcessBlock(ProcessBlockPrincipal const& pbp, ModuleCallingContext const* mcc) final {
152  if constexpr (T::HasAbility::kWatchProcessBlock or T::HasAbility::kEndProcessBlockProducer) {
153  ProcessBlock processBlock(pbp, this->moduleDescription(), mcc, true);
154  ProcessBlock const& cnstProcessBlock = processBlock;
155  processBlock.setConsumer(this->consumer());
156  MyWatchProcessBlock::endProcessBlock(cnstProcessBlock, m_global.get());
157  if constexpr (T::HasAbility::kEndProcessBlockProducer) {
158  processBlock.setProducer(this->producer());
159  MyEndProcessBlockProduce::produce(processBlock, m_global.get());
160  this->commit(processBlock);
161  }
162  }
163  }
164 
165  void doBeginRun(RunTransitionInfo const& info, ModuleCallingContext const* mcc) final {
167  RunPrincipal const& rp = info.principal();
168  Run r(rp, this->moduleDescription(), mcc, false);
169  r.setConsumer(this->consumer());
170  r.setProducer(this->producer());
171  Run const& cnstR = r;
172  RunIndex ri = rp.index();
173  ESParentContext parentC(mcc);
174  const EventSetup c{info,
175  static_cast<unsigned int>(Transition::BeginRun),
176  this->consumer()->esGetTokenIndices(Transition::BeginRun),
177  parentC};
178  MyGlobalRun::beginRun(cnstR, c, m_global.get(), m_runs[ri]);
179  typename T::RunContext rc(m_runs[ri].get(), m_global.get());
181  if constexpr (T::HasAbility::kBeginRunProducer) {
183  this->commit(r);
184  }
185  }
186  }
187 
188  void doEndRun(RunTransitionInfo const& info, ModuleCallingContext const* mcc) final {
190  RunPrincipal const& rp = info.principal();
191  Run r(rp, this->moduleDescription(), mcc, true);
192  r.setConsumer(this->consumer());
193  r.setProducer(this->producer());
194 
195  RunIndex ri = rp.index();
196  typename T::RunContext rc(m_runs[ri].get(), m_global.get());
197  ESParentContext parentC(mcc);
198  const EventSetup c{info,
199  static_cast<unsigned int>(Transition::EndRun),
200  this->consumer()->esGetTokenIndices(Transition::EndRun),
201  parentC};
203  if constexpr (T::HasAbility::kEndRunProducer) {
204  MyEndRunProduce::produce(r, c, &rc, m_runSummaries[ri].get());
205  this->commit(r);
206  }
207  MyGlobalRun::endRun(r, c, &rc);
208  }
209  }
210 
213  T::HasAbility::kBeginLuminosityBlockProducer) {
214  LuminosityBlockPrincipal const& lbp = info.principal();
215  LuminosityBlock lb(lbp, this->moduleDescription(), mcc, false);
216  lb.setConsumer(this->consumer());
217  lb.setProducer(this->producer());
218  LuminosityBlock const& cnstLb = lb;
219  LuminosityBlockIndex li = lbp.index();
220  RunIndex ri = lbp.runPrincipal().index();
221  typename T::RunContext rc(m_runs[ri].get(), m_global.get());
222  ESParentContext parentC(mcc);
223  const EventSetup c{info,
224  static_cast<unsigned int>(Transition::BeginLuminosityBlock),
225  this->consumer()->esGetTokenIndices(Transition::BeginLuminosityBlock),
226  parentC};
227 
229  typename T::LuminosityBlockContext lc(m_lumis[li].get(), m_runs[ri].get(), m_global.get());
231  if constexpr (T::HasAbility::kBeginLuminosityBlockProducer) {
233  this->commit(lb);
234  }
235  }
236  }
239  T::HasAbility::kEndLuminosityBlockProducer) {
240  LuminosityBlockPrincipal const& lbp = info.principal();
241  LuminosityBlock lb(lbp, this->moduleDescription(), mcc, true);
242  lb.setConsumer(this->consumer());
243  lb.setProducer(this->producer());
244 
245  LuminosityBlockIndex li = lbp.index();
246  RunIndex ri = lbp.runPrincipal().index();
247  typename T::LuminosityBlockContext lc(m_lumis[li].get(), m_runs[ri].get(), m_global.get());
248  ESParentContext parentC(mcc);
249  const EventSetup c{info,
250  static_cast<unsigned int>(Transition::EndLuminosityBlock),
251  this->consumer()->esGetTokenIndices(Transition::EndLuminosityBlock),
252  parentC};
254  if constexpr (T::HasAbility::kEndLuminosityBlockProducer) {
256  this->commit(lb);
257  }
259  }
260  }
261 
263 
264  using B::consumer;
265 
266  void selectInputProcessBlocks(ProductRegistry const& productRegistry,
267  ProcessBlockHelperBase const& processBlockHelperBase) final {
269  m_inputProcessBlocks, productRegistry, processBlockHelperBase, *consumer());
270  }
271 
272  // ---------- member data --------------------------------
282  };
283  } // namespace stream
284 } // namespace edm
285 
286 #endif
static void endLuminosityBlock(edm::LuminosityBlock const &Lumi, edm::EventSetup const &iES, typename T::LuminosityBlockContext const *iContext)
static void beginProcessBlock(edm::ProcessBlock const &iProcessBlock, typename T::GlobalCache *iGC)
static void beginRun(edm::Run const &iRun, edm::EventSetup const &iES, typename T::RunContext const *iRC, std::shared_ptr< typename T::RunSummaryCache > &oCache)
void setProducer(ProducerBase const *iProducer)
Definition: Run.cc:79
void doBeginProcessBlock(ProcessBlockPrincipal const &pbp, ModuleCallingContext const *mcc) final
static const TGPicture * info(bool iBackgroundIsBlack)
void setConsumer(EDConsumerBase const *iConsumer)
std::unique_ptr< G > makeInputProcessBlockCacheImpl(G const *)
Definition: makeGlobal.h:49
static void endRun(edm::Run const &iRun, edm::EventSetup const &iES, typename T::RunContext const *iContext)
Definition: APVGainStruct.h:7
impl::choose_unique_ptr< typename T::GlobalCache >::type m_global
void selectInputProcessBlocks(ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase) final
void doEndLuminosityBlock(LumiTransitionInfo const &info, ModuleCallingContext const *mcc) final
static void beginRun(edm::Run const &iRun, edm::EventSetup const &iES, typename T::GlobalCache const *iGC, std::shared_ptr< typename T::RunCache const > &oCache)
static void produce(edm::LuminosityBlock &Lumi, edm::EventSetup const &iES, typename T::LuminosityBlockContext const *iRC)
static void produce(edm::LuminosityBlock &, edm::EventSetup const &, typename T::LuminosityBlockContext const *, typename T::LuminosityBlockSummaryCache const *)
void streamEndLuminosityBlockSummary(M *iProd, edm::LuminosityBlock const &iLumi, edm::EventSetup const &iES) final
RunPrincipal const & runPrincipal() const
void doEndProcessBlock(ProcessBlockPrincipal const &pbp, ModuleCallingContext const *mcc) final
static void set(T *iProd, typename impl::choose_unique_ptr< typename T::InputProcessBlockCache >::type const *iCaches, unsigned int iStreamModule)
Definition: callAbilities.h:76
static void selectInputProcessBlocks(typename impl::choose_unique_ptr< typename T::InputProcessBlockCache >::type &iCaches, ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase, EDConsumerBase const &edConsumerBase)
Definition: callAbilities.h:86
void preallocLumis(unsigned int iNLumis) final
impl::choose_mutex< typename T::LuminosityBlockSummaryCache >::type m_lumiSummaryLock
static void clearCaches(typename impl::choose_unique_ptr< typename T::InputProcessBlockCache >::type &iCaches)
static void prevalidate(ConfigurationDescriptions &descriptions)
void streamEndRunSummary(M *iProd, edm::Run const &iRun, edm::EventSetup const &iES) final
static void streamEndRunSummary(B *iProd, edm::Run const &iRun, edm::EventSetup const &iES, typename T::RunSummaryCache *iCache)
const ProducingModuleAdaptor & operator=(const ProducingModuleAdaptor &)=delete
uint32_t T const *__restrict__ uint32_t const *__restrict__ int32_t int Histo::index_type cudaStream_t stream
void doAccessInputProcessBlock(ProcessBlockPrincipal const &pbp, ModuleCallingContext const *mcc) final
static void accessInputProcessBlock(edm::ProcessBlock const &processBlock, typename T::GlobalCache *iGC, typename impl::choose_unique_ptr< typename T::InputProcessBlockCache >::type &iCaches)
Definition: callAbilities.h:94
void doBeginRun(RunTransitionInfo const &info, ModuleCallingContext const *mcc) final
static void set(B *iProd, typename T::RunCache const *iCache)
impl::choose_mutex< typename T::RunSummaryCache >::type m_runSummaryLock
static void produce(edm::ProcessBlock &processBlock, typename T::GlobalCache *globalCache)
static void beginLuminosityBlock(edm::LuminosityBlock const &Lumi, edm::EventSetup const &iES, typename T::RunContext const *iRC, std::shared_ptr< typename T::LuminosityBlockCache const > &oCache)
static void beginLuminosityBlock(edm::LuminosityBlock const &Lumi, edm::EventSetup const &iES, typename T::LuminosityBlockContext const *iRC, std::shared_ptr< typename T::LuminosityBlockSummaryCache > &oCache)
static void produce(edm::Run &iRun, edm::EventSetup const &iES, typename T::RunContext const *iRC)
void setConsumer(EDConsumerBase const *iConsumer)
Definition: ProcessBlock.h:53
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
impl::choose_shared_vec< typename T::RunSummaryCache >::type m_runSummaries
RunIndex index() const
Definition: RunPrincipal.h:57
void doEndRun(RunTransitionInfo const &info, ModuleCallingContext const *mcc) final
impl::choose_shared_vec< typename T::LuminosityBlockSummaryCache >::type m_lumiSummaries
static void set(B *iProd, typename T::LuminosityBlockCache const *iCache)
void setupLuminosityBlock(M *iProd, LuminosityBlockIndex iIndex) final
void setupRun(M *iProd, RunIndex iIndex) final
impl::choose_unique_ptr< typename T::InputProcessBlockCache >::type m_inputProcessBlocks
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
void setProducer(ProducerBase const *iProducer)
Definition: ProcessBlock.cc:13
static void endJob(typename T::GlobalCache *iCache)
Definition: callAbilities.h:59
static void streamEndLuminosityBlockSummary(B *iProd, edm::LuminosityBlock const &iLumi, edm::EventSetup const &iES, typename T::LuminosityBlockSummaryCache *iCache)
static void globalEndRun(edm::Run const &iRun, edm::EventSetup const &iES, typename T::RunContext const *iContext, typename T::RunSummaryCache *iCache)
void setProducer(ProducerBase const *iProducer)
void doBeginLuminosityBlock(LumiTransitionInfo const &info, ModuleCallingContext const *mcc) final
impl::choose_shared_vec< typename T::RunCache const >::type m_runs
HLT enums.
ProducingModuleAdaptor(edm::ParameterSet const &iPSet)
LuminosityBlockIndex index() const
static void fillDescriptions(ConfigurationDescriptions &descriptions)
static void produce(edm::Run &, edm::EventSetup const &, typename T::RunContext const *, typename T::RunSummaryCache const *)
impl::choose_shared_vec< typename T::LuminosityBlockCache const >::type m_lumis
static void beginJob(typename T::GlobalCache *iCache)
Definition: callAbilities.h:54
std::vector< std::shared_ptr< T > > type
Definition: dummy_helpers.h:64
static void globalEndLuminosityBlock(edm::LuminosityBlock const &Lumi, edm::EventSetup const &iES, typename T::LuminosityBlockContext const *iContext, typename T::LuminosityBlockSummaryCache *iCache)
tmp
align.sh
Definition: createJobs.py:716
static void produce(edm::ProcessBlock &processBlock, typename T::GlobalCache *globalCache)
static void set(B *iProd, typename T::GlobalCache const *iCache)
Definition: callAbilities.h:51
Definition: Run.h:45
static void endProcessBlock(edm::ProcessBlock const &iProcessBlock, typename T::GlobalCache *iGC)