|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
#ifndef FWCore_Framework_WorkerT_h
#define FWCore_Framework_WorkerT_h
/*----------------------------------------------------------------------
WorkerT: Code common to all workers.
----------------------------------------------------------------------*/
#include "FWCore/Common/interface/FWCoreCommonFwd.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/TransitionInfoTypes.h"
#include "FWCore/Framework/interface/maker/Worker.h"
#include "FWCore/Framework/interface/maker/WorkerParams.h"
#include "FWCore/ServiceRegistry/interface/ServiceRegistryfwd.h"
#include "FWCore/Utilities/interface/BranchType.h"
#include "FWCore/Utilities/interface/propagate_const.h"
#include "FWCore/Utilities/interface/Transition.h"
#include <array>
#include <map>
#include <memory>
#include <string>
#include <vector>
namespace edm {
class ProductResolverIndexAndSkipBit;
class ThinnedAssociationsHelper;
namespace eventsetup {
struct ComponentDescription;
} // namespace eventsetup
template <typename T>
class WorkerT : public Worker {
public:
typedef T ModuleType;
typedef WorkerT<T> WorkerType;
WorkerT(std::shared_ptr<T>, ModuleDescription const&, ExceptionToActionTable const* actions);
~WorkerT() override;
void setModule(std::shared_ptr<T> iModule) {
module_ = iModule;
resetModuleDescription(&(module_->moduleDescription()));
}
Types moduleType() const override;
ConcurrencyTypes moduleConcurrencyType() const override;
bool wantsProcessBlocks() const noexcept final;
bool wantsInputProcessBlocks() const noexcept final;
bool wantsGlobalRuns() const noexcept final;
bool wantsGlobalLuminosityBlocks() const noexcept final;
bool wantsStreamRuns() const noexcept final;
bool wantsStreamLuminosityBlocks() const noexcept final;
SerialTaskQueue* globalRunsQueue() final;
SerialTaskQueue* globalLuminosityBlocksQueue() final;
void updateLookup(BranchType iBranchType, ProductResolverIndexHelper const&) final;
void updateLookup(eventsetup::ESRecordsToProductResolverIndices const&) final;
void releaseMemoryPostLookupSignal() final;
void selectInputProcessBlocks(ProductRegistry const&, ProcessBlockHelperBase const&) final;
void resolvePutIndicies(
BranchType iBranchType,
std::unordered_multimap<std::string, std::tuple<TypeID const*, const char*, edm::ProductResolverIndex>> const&
iIndicies) final;
template <typename D>
void callWorkerBeginStream(D, StreamID);
template <typename D>
void callWorkerEndStream(D, StreamID);
template <typename D>
void callWorkerStreamBegin(D, StreamID, RunTransitionInfo const&, ModuleCallingContext const*);
template <typename D>
void callWorkerStreamEnd(D, StreamID, RunTransitionInfo const&, ModuleCallingContext const*);
template <typename D>
void callWorkerStreamBegin(D, StreamID, LumiTransitionInfo const&, ModuleCallingContext const*);
template <typename D>
void callWorkerStreamEnd(D, StreamID, LumiTransitionInfo const&, ModuleCallingContext const*);
protected:
T& module() { return *module_; }
T const& module() const { return *module_; }
private:
void doClearModule() override { get_underlying_safe(module_).reset(); }
bool implDo(EventTransitionInfo const&, ModuleCallingContext const*) override;
void itemsToGetForSelection(std::vector<ProductResolverIndexAndSkipBit>&) const final;
bool implNeedToRunSelection() const noexcept final;
void implDoAcquire(EventTransitionInfo const&, ModuleCallingContext const*, WaitingTaskHolder&&) final;
size_t transformIndex(edm::ProductDescription const&) const noexcept final;
void implDoTransformAsync(WaitingTaskHolder,
size_t iTransformIndex,
EventPrincipal const&,
ParentContext const&,
ServiceWeakToken const&) noexcept final;
ProductResolverIndex itemToGetForTransform(size_t iTransformIndex) const noexcept final;
bool implDoPrePrefetchSelection(StreamID, EventPrincipal const&, ModuleCallingContext const*) override;
bool implDoBeginProcessBlock(ProcessBlockPrincipal const&, ModuleCallingContext const*) override;
bool implDoAccessInputProcessBlock(ProcessBlockPrincipal const&, ModuleCallingContext const*) override;
bool implDoEndProcessBlock(ProcessBlockPrincipal const&, ModuleCallingContext const*) override;
bool implDoBegin(RunTransitionInfo const&, ModuleCallingContext const*) override;
bool implDoStreamBegin(StreamID, RunTransitionInfo const&, ModuleCallingContext const*) override;
bool implDoStreamEnd(StreamID, RunTransitionInfo const&, ModuleCallingContext const*) override;
bool implDoEnd(RunTransitionInfo const&, ModuleCallingContext const*) override;
bool implDoBegin(LumiTransitionInfo const&, ModuleCallingContext const*) override;
bool implDoStreamBegin(StreamID, LumiTransitionInfo const&, ModuleCallingContext const*) override;
bool implDoStreamEnd(StreamID, LumiTransitionInfo const&, ModuleCallingContext const*) override;
bool implDoEnd(LumiTransitionInfo const&, ModuleCallingContext const*) override;
void implBeginJob() override;
void implEndJob() override;
void implBeginStream(StreamID) override;
void implEndStream(StreamID) override;
void implRespondToOpenInputFile(FileBlock const& fb) override;
void implRespondToCloseInputFile(FileBlock const& fb) override;
void implRespondToCloseOutputFile() override;
void implRegisterThinnedAssociations(ProductRegistry const&, ThinnedAssociationsHelper&) override;
std::string workerType() const override;
TaskQueueAdaptor serializeRunModule() override;
void modulesWhoseProductsAreConsumed(
std::array<std::vector<ModuleDescription const*>*, NumBranchTypes>& modules,
ProductRegistry const& preg,
std::map<std::string, ModuleDescription const*> const& labelsToDesc) const override {
module_->modulesWhoseProductsAreConsumed(modules, preg, labelsToDesc, module_->moduleDescription().processName());
}
void esModulesWhoseProductsAreConsumed(
std::array<std::vector<eventsetup::ComponentDescription const*>*, kNumberOfEventSetupTransitions>& esModules,
eventsetup::ESRecordsToProductResolverIndices const& iPI) const override {
module_->esModulesWhoseProductsAreConsumed(esModules, iPI);
}
void convertCurrentProcessAlias(std::string const& processName) override {
module_->convertCurrentProcessAlias(processName);
}
std::vector<ModuleConsumesInfo> moduleConsumesInfos() const override;
std::vector<ModuleConsumesESInfo> moduleConsumesESInfos(
eventsetup::ESRecordsToProductResolverIndices const& iPI) const override;
void itemsToGet(BranchType branchType, std::vector<ProductResolverIndexAndSkipBit>& indexes) const override {
module_->itemsToGet(branchType, indexes);
}
void itemsMayGet(BranchType branchType, std::vector<ProductResolverIndexAndSkipBit>& indexes) const override {
module_->itemsMayGet(branchType, indexes);
}
std::vector<ProductResolverIndexAndSkipBit> const& itemsToGetFrom(BranchType iType) const final {
return module_->itemsToGetFrom(iType);
}
std::vector<ESResolverIndex> const& esItemsToGetFrom(Transition iTransition) const override {
return module_->esGetTokenIndicesVector(iTransition);
}
std::vector<ESRecordIndex> const& esRecordsToGetFrom(Transition iTransition) const override {
return module_->esGetTokenRecordIndicesVector(iTransition);
}
void preActionBeforeRunEventAsync(WaitingTaskHolder iTask,
ModuleCallingContext const& iModuleCallingContext,
Principal const& iPrincipal) const noexcept override {
module_->preActionBeforeRunEventAsync(iTask, iModuleCallingContext, iPrincipal);
}
bool hasAcquire() const noexcept override { return module_->hasAcquire(); }
bool hasAccumulator() const noexcept override { return module_->hasAccumulator(); }
edm::propagate_const<std::shared_ptr<T>> module_;
};
} // namespace edm
#endif
|