| The Gaudi Framework v27r1

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

AlgResourcePool.cpp
Go to the documentation of this file.
1 // Include Files
2
3 // Framework
4 #include "AlgResourcePool.h"
5 #include "GaudiKernel/ISvcLocator.h"
6 #include "GaudiKernel/SvcFactory.h"
7 #include "GaudiKernel/ThreadGaudi.h"
8
9 // C++
10 #include <functional>
11 #include <queue>
12
13 // DP TODO: Manage smartifs and not pointers to algos
14
15 // Instantiation of a static factory class used by clients to create instances of this service
16 DECLARE_SERVICE_FACTORY(AlgResourcePool)
17
18 // constructor
19 AlgResourcePool::AlgResourcePool( const std::string& name, ISvcLocator* svc ) :
20 base_class(name,svc), m_available_resources(0), m_EFGraph(0)
21 {
22 declareProperty("CreateLazily", m_lazyCreation = false );
23 declareProperty("TopAlg", m_topAlgNames );
24 }
25
26 //---------------------------------------------------------------------------
27
28 // destructor
29 AlgResourcePool::~AlgResourcePool() {
30
31 for (auto& algoId_algoQueue : m_algqueue_map){
32 auto* queue = algoId_algoQueue.second;
33 delete queue;
34 }
35
36 delete m_EFGraph;
37 }
38
39 //---------------------------------------------------------------------------
40
41 // initialize the pool with the list of algos known to the IAlgManager
42 StatusCode AlgResourcePool::initialize(){
43
44 StatusCode sc(Service::initialize());
45 if (!sc.isSuccess())
46 warning () << "Base class could not be started" << endmsg;
47
48 // Try to recover the topAlgList from the ApplicationManager for backward-compatibility
49 if (m_topAlgNames.value().empty()){
50 info() << "TopAlg list empty. Recovering the one of Application Manager" << endmsg;
51 const Gaudi::Utils::TypeNameString appMgrName("ApplicationMgr/ApplicationMgr");
52 SmartIF<IProperty> appMgrProps (serviceLocator()->service(appMgrName));
53 m_topAlgNames.assign(appMgrProps->getProperty("TopAlg"));
54 }
55
56 // XXX: Prepare empty Control Flow graph
57 const std::string& name = "ExecutionFlowGraph";
58 SmartIF<ISvcLocator> svc = serviceLocator();
59 m_EFGraph = new concurrency::ExecutionFlowGraph(name, svc);
60
61 sc = decodeTopAlgs();
62 if (sc.isFailure())
63 warning() << "Algorithms could not be properly decoded." << endmsg;
64
65 // let's assume all resources are there
66 m_available_resources.set();
67 return StatusCode::SUCCESS;
68 }
69
70 //---------------------------------------------------------------------------
71
72 StatusCode AlgResourcePool::start(){
73
74 StatusCode startSc = Service::start();
75 if ( ! startSc.isSuccess() ) return startSc;
76
77 // sys-Start the algos
78 for (auto& ialgo : m_algList){
79 startSc = ialgo->sysStart();
80 if (startSc.isFailure()){
81 error() << "Unable to start Algorithm: " << ialgo->name() << endmsg;
82 return startSc;
83 }
84 }
85 return StatusCode::SUCCESS;
86 }
87
88 //---------------------------------------------------------------------------
89
90 StatusCode AlgResourcePool::acquireAlgorithm(const std::string& name, IAlgorithm*& algo, bool blocking){
91
92 std::hash<std::string> hash_function;
93 size_t algo_id = hash_function(name);
94 auto itQueueIAlgPtr = m_algqueue_map.find(algo_id);
95
96 if (itQueueIAlgPtr == m_algqueue_map.end()) {
97 error() << "Algorithm " << name << " requested, but not recognised"
98 << endmsg;
99 algo = nullptr;
100 return StatusCode::FAILURE;
101 }
102
103 StatusCode sc;
104 if (blocking) {
105 itQueueIAlgPtr->second->pop(algo);
106 sc = StatusCode::SUCCESS;
107 } else {
108 sc = itQueueIAlgPtr->second->try_pop(algo);
109 }
110
111 if(sc.isFailure())
112 if (msgLevel(MSG::DEBUG))
113 debug() << "No instance of algorithm " << name << " could be retrieved in non-blocking mode" << endmsg;
114
115 // if (m_lazyCreation ) {
116 // TODO: fill the lazyCreation part
117 //}
118 if (sc.isSuccess()){
119 algo->resetExecuted();
120 state_type requirements = m_resource_requirements[algo_id];
121 m_resource_mutex.lock();
122 if (requirements.is_subset_of(m_available_resources)) {
123 m_available_resources^=requirements;
124 } else {
125 sc = StatusCode::FAILURE;
126 error() << "Failure to allocate resources of algorithm " << name << endmsg;
127 itQueueIAlgPtr->second->push(algo);
128 }
129 m_resource_mutex.unlock();
130 }
131 return sc;
132 }
133
134 //---------------------------------------------------------------------------
135
136 StatusCode AlgResourcePool::releaseAlgorithm(const std::string& name, IAlgorithm*& algo){
137
138 std::hash<std::string> hash_function;
139 size_t algo_id = hash_function(name);
140
141 // release resources used by the algorithm
142 m_resource_mutex.lock();
143 m_available_resources|= m_resource_requirements[algo_id];
144 m_resource_mutex.unlock();
145
146 //release algorithm itself
147 m_algqueue_map[algo_id]->push(algo);
148 return StatusCode::SUCCESS;
149 }
150
151 //---------------------------------------------------------------------------
152
153 StatusCode AlgResourcePool::acquireResource(const std::string& name){
154 m_resource_mutex.lock();
155 m_available_resources[m_resource_indices[name]] = false;
156 m_resource_mutex.unlock();
157 return StatusCode::SUCCESS;
158 }
159
160 //---------------------------------------------------------------------------
161
162 StatusCode AlgResourcePool::releaseResource(const std::string& name){
163 m_resource_mutex.lock();
164 m_available_resources[m_resource_indices[name]] = true;
165 m_resource_mutex.unlock();
166 return StatusCode::SUCCESS;
167 }
168
169 //---------------------------------------------------------------------------
170
171 StatusCode AlgResourcePool::flattenSequencer(Algorithm* algo, ListAlg& alglist, const std::string& parentName, unsigned int recursionDepth){
172
173 StatusCode sc = StatusCode::SUCCESS;
174
175 std::vector<Algorithm*>* subAlgorithms = algo->subAlgorithms();
176 if ( //we only want to add basic algorithms -> have no subAlgs
177 // and exclude the case of empty GaudiSequencers
178 (subAlgorithms->empty() and not (algo->type() == "GaudiSequencer"))
179 // we want to add non-empty GaudiAtomicSequencers
180 or (algo->type() == "GaudiAtomicSequencer" and not subAlgorithms->empty())){
181
182 debug() << std::string(recursionDepth, ' ') << algo->name() << " is " <<
183 (algo->type() != "GaudiAtomicSequencer" ? "not a sequencer" : "an atomic sequencer")
184 << ". Appending it" << endmsg;
185
186 alglist.emplace_back(algo);
187 m_EFGraph->addAlgorithmNode(algo,parentName,false,false);
188 return sc;
189 }
190
191 // Recursively unroll
192 ++recursionDepth;
193 debug() << std::string(recursionDepth, ' ') << algo->name() << " is a sequencer. Flattening it." << endmsg;
194 bool modeOR = false;
195 bool allPass = false;
196 bool isLazy = false;
197 if ("GaudiSequencer" == algo->type()) {
198 modeOR = (algo->getProperty("ModeOR").toString() == "True")? true : false;
199 allPass = (algo->getProperty("IgnoreFilterPassed").toString() == "True")? true : false;
200 isLazy = (algo->getProperty("ShortCircuit").toString() == "True")? true : false;
201 if (allPass) isLazy = false; // standard GaudiSequencer behavior on all pass is to execute everything
202 }
203 sc = m_EFGraph->addDecisionHubNode(algo,parentName,modeOR,allPass,isLazy);
204 if (sc.isFailure()) {
205 error() << "Failed to add DecisionHub " << algo->name() << " to execution flow graph" << endmsg;
206 return sc;
207 }
208
209 for (Algorithm* subalgo : *subAlgorithms ) {
210 sc = flattenSequencer(subalgo,alglist,algo->name(),recursionDepth);
211 if (sc.isFailure()) {
212 error() << "Algorithm " << subalgo->name() << " could not be flattened" << endmsg;
213 return sc;
214 }
215 }
216 return sc;
217 }
218
219 //---------------------------------------------------------------------------
220
221 StatusCode AlgResourcePool::decodeTopAlgs() {
222
223 SmartIF<IAlgManager> algMan ( serviceLocator() );
224 if (!algMan.isValid()){
225 error() << "Algorithm manager could not be properly fetched." << endmsg;
226 return StatusCode::FAILURE;
227 }
228
229 // Useful lambda not to repeat ourselves --------------------------
230 auto createAlg = [&algMan,this] (const std::string& item_type,
231 const std::string& item_name,
232 IAlgorithm*& algo){
233 StatusCode createAlgSc = algMan->createAlgorithm(item_type,
234 item_name,
235 algo,
236 true,
237 false);
238 if (createAlgSc.isFailure())
239 this->warning() << "Algorithm " << item_type << "/" << item_name
240 << " could not be created." << endmsg;
241 };
242 // End of lambda --------------------------------------------------
243
244 StatusCode sc = StatusCode::SUCCESS;
245
246 // Fill the top alg list ----
247 const std::vector<std::string>& topAlgNames = m_topAlgNames.value();
248 for (auto& name : topAlgNames) {
249 IAlgorithm* algo(nullptr);
250
251 Gaudi::Utils::TypeNameString item(name);
252 const std::string& item_name = item.name();
253 const std::string& item_type = item.type();
254 SmartIF<IAlgorithm> algoSmartIF (algMan->algorithm(item_name,false));
255
256 if (!algoSmartIF.isValid()){
257 createAlg(item_type,item_name,algo);
258 algoSmartIF = algo;
259 }
260 // Init and start
261 algoSmartIF->sysInitialize();
262 m_topAlgList.push_back(algoSmartIF);
263 }
264 // Top Alg list filled ----
265
266 // start forming the control flow graph by adding the head node
267 m_EFGraph->addHeadNode("EVENT LOOP",true,true,false);
268
269 // Now we unroll it ----
270 for (auto& algoSmartIF : m_topAlgList){
271 Algorithm* algorithm = dynamic_cast<Algorithm*> (algoSmartIF.get());
272 if (!algorithm) fatal() << "Conversion from IAlgorithm to Algorithm failed" << endmsg;
273 sc = flattenSequencer(algorithm, m_flatUniqueAlgList, "EVENT LOOP");
274 }
275 if (msgLevel(MSG::DEBUG)){
276 debug() << "List of algorithms is: " << endmsg;
277 for (auto& algo : m_flatUniqueAlgList)
278 debug() << " o " << algo->type() << "/" << algo->name() << " @ " << algo << endmsg;
279 }
280
281 // Unrolled ---
282
283 // Now let's manage the clones
284 unsigned int resource_counter(0);
285 std::hash<std::string> hash_function;
286 for (auto& ialgoSmartIF : m_flatUniqueAlgList) {
287
288 const std::string& item_name = ialgoSmartIF->name();
289
290 verbose() << "Treating resource management and clones of " << item_name << endmsg;
291
292 Algorithm* algo = dynamic_cast<Algorithm*> ( ialgoSmartIF.get() );
293 if (!algo) fatal() << "Conversion from IAlgorithm to Algorithm failed" << endmsg;
294 const std::string& item_type = algo->type();
295
296 size_t algo_id = hash_function(item_name);
297 concurrentQueueIAlgPtr* queue = new concurrentQueueIAlgPtr();
298 m_algqueue_map[algo_id] = queue;
299
300 // DP TODO Do it properly with SmartIFs, also in the queues
301 IAlgorithm* ialgo(ialgoSmartIF.get());
302
303 queue->push(ialgo);
304 m_algList.push_back(ialgo);
305 m_n_of_allowed_instances[algo_id] = ialgo->cardinality();
306 m_n_of_created_instances[algo_id] = 1;
307
308 state_type requirements(0);
309
310 for (auto& resource_name : ialgo->neededResources()){
311 auto ret = m_resource_indices.insert(std::pair<std::string, unsigned int>(resource_name,resource_counter));
312 // insert successful means == wasn't known before. So increment counter
313 if (ret.second==true) {
314 ++resource_counter;
315 }
316 // Resize for every algo according to the found resources
317 requirements.resize(resource_counter);
318 // in any case the return value holds the proper product index
319 requirements[ret.first->second] = true;
320
321 }
322
323 m_resource_requirements[algo_id] = requirements;
324
325 // potentially create clones; if not lazy creation we have to do it now
326 if (!m_lazyCreation) {
327 for (unsigned int i =1, end =ialgo->cardinality();i<end; ++i){
328 debug() << "type/name to create clone of: " << item_type << "/"
329 << item_name << endmsg;
330 IAlgorithm* ialgoClone(nullptr);
331 createAlg(item_type,item_name,ialgoClone);
332 ialgoClone->setIndex(i);
333 if (ialgoClone->sysInitialize().isFailure()) {
334 error() << "unable to initialize Algorithm clone "
335 << ialgoClone->name() << endmsg;
336 sc = StatusCode::FAILURE;
337 // FIXME: should we delete this failed clone?
338 } else {
339 queue->push(ialgoClone);
340 m_n_of_created_instances[algo_id]+=1;
341 }
342 }
343 }
344
345 m_EFGraph->attachAlgorithmsToNodes<concurrentQueueIAlgPtr>(item_name,*queue);
346
347 }
348
349 // Now resize all the requirement bitsets to the same size
350 for (auto& kv : m_resource_requirements) {
351 kv.second.resize(resource_counter);
352 }
353
354 // Set all resources to be available
355 m_available_resources.resize(resource_counter);
356 m_available_resources.set();
357
358 return sc;
359 }
360
361 //---------------------------------------------------------------------------
362
363 std::list<IAlgorithm*> AlgResourcePool::getFlatAlgList(){
364 m_flatUniqueAlgPtrList.clear();
365 for (auto algoSmartIF :m_flatUniqueAlgList )
366 m_flatUniqueAlgPtrList.push_back(const_cast<IAlgorithm*>(algoSmartIF.get()));
367 return m_flatUniqueAlgPtrList;
368 }
369
370 //---------------------------------------------------------------------------
371
372 std::list<IAlgorithm*> AlgResourcePool::getTopAlgList(){
373 m_topAlgPtrList.clear();
374 for (auto algoSmartIF :m_topAlgList )
375 m_topAlgPtrList.push_back(const_cast<IAlgorithm*>(algoSmartIF.get()));
376 return m_topAlgPtrList;
377 }
378
379 //---------------------------------------------------------------------------
380
381 StatusCode AlgResourcePool::beginRun(){
382 auto algBeginRun = [&] (SmartIF<IAlgorithm>& algoSmartIF) -> StatusCode {
383 StatusCode sc = algoSmartIF->sysBeginRun();
384 if (!sc.isSuccess()) {
385 warning() << "beginRun() of algorithm " << algoSmartIF->name() << " failed" << endmsg;
386 return StatusCode::FAILURE;
387 }
388 return StatusCode::SUCCESS;
389 };
390 // Call the beginRun() method of all algorithms
391 for (auto& algoSmartIF : m_flatUniqueAlgList ) {
392 if (algBeginRun(algoSmartIF).isFailure())
393 return StatusCode::FAILURE;
394 }
395
396 return StatusCode::SUCCESS;
397 }
398
399 //---------------------------------------------------------------------------
400
401 StatusCode AlgResourcePool::endRun() {
402
403 auto algEndRun = [&] (SmartIF<IAlgorithm>& algoSmartIF) -> StatusCode {
404 StatusCode sc = algoSmartIF->sysEndRun();
405 if (!sc.isSuccess()) {
406 warning() << "endRun() of algorithm " << algoSmartIF->name() << " failed" << endmsg;
407 return StatusCode::FAILURE;
408 }
409 return StatusCode::SUCCESS;
410 };
411 // Call the beginRun() method of all top algorithms
412 for (auto& algoSmartIF : m_flatUniqueAlgList ) {
413 if (algEndRun(algoSmartIF).isFailure())
414 return StatusCode::FAILURE;
415 }
416 for (auto& algoSmartIF : m_topAlgList ) {
417 if (algEndRun(algoSmartIF).isFailure())
418 return StatusCode::FAILURE;
419 }
420 return StatusCode::SUCCESS;
421 }
422
423 //---------------------------------------------------------------------------
424
425 StatusCode AlgResourcePool::stop(){
426
427 StatusCode stopSc = Service::stop();
428 if ( ! stopSc.isSuccess() ) return stopSc;
429
430 // sys-Stop the algos
431 for (auto& ialgo : m_algList){
432 stopSc = ialgo->sysStop();
433 if (stopSc.isFailure()){
434 error() << "Unable to stop Algorithm: " << ialgo->name() << endmsg;
435 return stopSc;
436 }
437 }
438 return StatusCode::SUCCESS;
439 }
AlgResourcePool::m_flatUniqueAlgList
ListAlg m_flatUniqueAlgList
The flat list of algorithms w/o clones.
Definition: AlgResourcePool.h:93
IAlgManager::algorithm
virtual SmartIF< IAlgorithm > & algorithm(const Gaudi::Utils::TypeNameString &typeName, const bool createIf=true)=0
Returns a smart pointer to a service.
AlgResourcePool::releaseResource
virtual StatusCode releaseResource(const std::string &name)
Release a certrain resource.
Definition: AlgResourcePool.cpp:162
AlgResourcePool::m_topAlgNames
StringArrayProperty m_topAlgNames
The names of the algorithms to be passed to the algorithm manager.
Definition: AlgResourcePool.h:84
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:68
SmartIF< IProperty >
Service::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Retrieve pointer to service locator.
Definition: Service.cpp:324
std::mutex::unlock
T unlock(T...args)
std::vector::empty
T empty(T...args)
ISvcLocator
The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to loc...
Definition: ISvcLocator.h:25
AlgResourcePool::getTopAlgList
virtual std::list< IAlgorithm * > getTopAlgList()
Definition: AlgResourcePool.cpp:372
IProperty::getProperty
virtual StatusCode getProperty(Property *p) const =0
Get the property by property.
AlgResourcePool::m_algqueue_map
std::map< size_t, concurrentQueueIAlgPtr * > m_algqueue_map
Definition: AlgResourcePool.h:71
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:28
concurrency::ExecutionFlowGraph::addDecisionHubNode
StatusCode addDecisionHubNode(Algorithm *daughterAlgo, const std::string &parentName, bool modeOR, bool allPass, bool isLazy)
Add a node, which aggregates decisions of direct daughter nodes.
Definition: ExecutionFlowGraph.cpp:647
CommonMessagingBase::info
MsgStream & info() const
shortcut for the method msgStream(MSG::INFO)
Definition: CommonMessaging.h:124
Service::start
StatusCode start() override
Definition: Service.cpp:152
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:76
CommonMessagingBase::verbose
MsgStream & verbose() const
shortcut for the method msgStream(MSG::VERBOSE)
Definition: CommonMessaging.h:130
MSG::DEBUG
Definition: IMessageSvc.h:18
AlgResourcePool::m_resource_mutex
std::mutex m_resource_mutex
Definition: AlgResourcePool.h:68
IAlgManager::createAlgorithm
virtual StatusCode createAlgorithm(const std::string &algtype, const std::string &algname, IAlgorithm *&alg, bool managed=false, bool checkIfExists=true)=0
Create an instance of a algorithm type that has been declared beforehand and assigns to it a name...
std
STL namespace.
std::map::end
T end(T...args)
AlgResourcePool::initialize
virtual StatusCode initialize()
Definition: AlgResourcePool.cpp:42
Algorithm::type
const std::string & type() const override
The type of the algorithm object.
Definition: Algorithm.h:168
IAlgorithm::resetExecuted
virtual void resetExecuted()=0
Reset the Algorithm executed state for the current event.
merge_files.sc
int sc
Definition: merge_files.py:167
AlgResourcePool
The AlgResourcePool is a concrete implementation of the IAlgResourcePool interface.
Definition: AlgResourcePool.h:34
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:86
ThreadGaudi.h
AlgResourcePool::m_available_resources
state_type m_available_resources
Definition: AlgResourcePool.h:70
IAlgorithm::sysInitialize
virtual StatusCode sysInitialize()=0
Initialization method invoked by the framework.
std::string
STL class.
Algorithm::name
const std::string & name() const override
The identifying name of the algorithm object.
Definition: Algorithm.cpp:820
AlgResourcePool::state_type
boost::dynamic_bitset state_type
Definition: AlgResourcePool.h:66
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:319
std::list::push_back
T push_back(T...args)
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:118
SvcFactory.h
Gaudi::Utils::TypeNameString
Helper class to parse a string of format "type/name".
Definition: TypeNameString.h:9
AlgResourcePool::m_n_of_allowed_instances
std::map< size_t, size_t > m_n_of_allowed_instances
Definition: AlgResourcePool.h:73
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:121
Algorithm::getProperty
StatusCode getProperty(Property *p) const override
Implementation of IProperty::getProperty.
Definition: Algorithm.cpp:989
StatusCode::FAILURE
Definition: StatusCode.h:29
AlgResourcePool::concurrentQueueIAlgPtr
tbb::concurrent_bounded_queue< IAlgorithm * > concurrentQueueIAlgPtr
Definition: AlgResourcePool.h:64
AlgResourcePool::m_flatUniqueAlgPtrList
std::list< IAlgorithm * > m_flatUniqueAlgPtrList
The flat list of algorithms w/o clones which is returned.
Definition: AlgResourcePool.h:96
std::hash
StatusCode::SUCCESS
Definition: StatusCode.h:30
AlgResourcePool::acquireResource
virtual StatusCode acquireResource(const std::string &name)
Acquire a certain resource.
Definition: AlgResourcePool.cpp:153
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
AlgResourcePool::m_EFGraph
concurrency::ExecutionFlowGraph * m_EFGraph
OMG yet another hack.
Definition: AlgResourcePool.h:102
AlgResourcePool::m_lazyCreation
bool m_lazyCreation
Definition: AlgResourcePool.h:69
std::mutex::lock
T lock(T...args)
AlgResourcePool::m_topAlgPtrList
std::list< IAlgorithm * > m_topAlgPtrList
The top list of algorithms.
Definition: AlgResourcePool.h:99
end
auto end(reverse_wrapper< T > &w)
Definition: reverse.h:47
IAlgorithm::setIndex
virtual void setIndex(const unsigned int &idx)=0
Set instantiation index of Alg.
DECLARE_SERVICE_FACTORY
#define DECLARE_SERVICE_FACTORY(x)
Definition: Service.h:361
Service::stop
StatusCode stop() override
Definition: Service.cpp:146
std::list::clear
T clear(T...args)
std::list< SmartIF< IAlgorithm > >
IAlgorithm
The IAlgorithm is the interface implemented by the Algorithm base class.
Definition: IAlgorithm.h:25
AlgResourcePool::start
virtual StatusCode start()
Definition: AlgResourcePool.cpp:72
PropertyWithValue::value
const TYPE & value() const
explicit conversion
Definition: Property.h:341
std::pair
std::map::insert
T insert(T...args)
AlgResourcePool::endRun
virtual StatusCode endRun()
Definition: AlgResourcePool.cpp:401
Algorithm::subAlgorithms
const std::vector< Algorithm * > * subAlgorithms() const
List of sub-algorithms. Returns a pointer to a vector of (sub) Algorithms.
Definition: Algorithm.cpp:865
Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:74
std::map::find
T find(T...args)
PropertyWithValue::assign
bool assign(const Property &source) override
get the value from another property
Definition: Property.h:269
std::vector< Algorithm * >
concurrency::ExecutionFlowGraph::addAlgorithmNode
StatusCode addAlgorithmNode(Algorithm *daughterAlgo, const std::string &parentName, bool inverted, bool allPass)
Add algorithm node.
Definition: ExecutionFlowGraph.cpp:581
AlgResourcePool::decodeTopAlgs
StatusCode decodeTopAlgs()
Decode the top alg list.
Definition: AlgResourcePool.cpp:221
CommonMessagingBase::debug
MsgStream & debug() const
shortcut for the method msgStream(MSG::DEBUG)
Definition: CommonMessaging.h:127
SmartIF::isValid
bool isValid() const
Allow for check if smart pointer is valid.
Definition: SmartIF.h:62
AlgResourcePool::getFlatAlgList
virtual std::list< IAlgorithm * > getFlatAlgList()
Definition: AlgResourcePool.cpp:363
Gaudi::Utils::TypeNameString::type
const std::string & type() const
Definition: TypeNameString.h:22
AlgResourcePool::flattenSequencer
StatusCode flattenSequencer(Algorithm *sequencer, ListAlg &alglist, const std::string &parentName, unsigned int recursionDepth=0)
Recursively flatten an algList.
Definition: AlgResourcePool.cpp:171
concurrency::ExecutionFlowGraph
Definition: ExecutionFlowGraph.h:271
AlgResourcePool::m_resource_requirements
std::map< size_t, state_type > m_resource_requirements
Definition: AlgResourcePool.h:72
ana.item
tuple item
print s1,s2
Definition: ana.py:146
CommonMessaging
Definition: CommonMessaging.h:58
concurrency::ExecutionFlowGraph::addHeadNode
void addHeadNode(const std::string &headName, bool modeOR, bool allPass, bool isLazy)
Add a node, which has no parents.
Definition: ExecutionFlowGraph.cpp:679
AlgResourcePool::releaseAlgorithm
virtual StatusCode releaseAlgorithm(const std::string &name, IAlgorithm *&algo)
Release a certain algorithm.
Definition: AlgResourcePool.cpp:136
Service::service
StatusCode service(const std::string &name, const T *&psvc, bool createIf=true) const
Access a service by name, creating it if it doesn't already exist.
Definition: Service.h:144
AlgResourcePool.h
Gaudi::Utils::TypeNameString::name
const std::string & name() const
Definition: TypeNameString.h:23
CommonMessagingBase::fatal
MsgStream & fatal() const
shortcut for the method msgStream(MSG::FATAL)
Definition: CommonMessaging.h:112
AlgResourcePool::m_topAlgList
ListAlg m_topAlgList
The list of top algorithms.
Definition: AlgResourcePool.h:90
AlgResourcePool::stop
virtual StatusCode stop()
Definition: AlgResourcePool.cpp:425
AlgResourcePool::m_resource_indices
std::map< std::string, unsigned int > m_resource_indices
Definition: AlgResourcePool.h:75
CommonMessagingBase::msgLevel
MSG::Level msgLevel() const
get the output level from the embedded MsgStream
Definition: CommonMessaging.h:136
AlgResourcePool::~AlgResourcePool
~AlgResourcePool()
Definition: AlgResourcePool.cpp:29
concurrency::ExecutionFlowGraph::attachAlgorithmsToNodes
void attachAlgorithmsToNodes(const std::string &algo_name, const T &container)
Attach pointers to real Algorithms (and their clones) to Algorithm nodes of the graph.
Definition: ExecutionFlowGraph.h:298
ana.i
list i
Definition: ana.py:128
AlgResourcePool::beginRun
virtual StatusCode beginRun()
Definition: AlgResourcePool.cpp:381
AlgResourcePool::m_n_of_created_instances
std::map< size_t, unsigned int > m_n_of_created_instances
Definition: AlgResourcePool.h:74
ISvcLocator.h
AlgResourcePool::m_algList
ListAlg m_algList
The list of all algorithms created withing the Pool which are not top.
Definition: AlgResourcePool.h:87
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244
AlgResourcePool::acquireAlgorithm
virtual StatusCode acquireAlgorithm(const std::string &name, IAlgorithm *&algo, bool blocking=false)
Acquire a certain algorithm using its name.
Definition: AlgResourcePool.cpp:90
std::list::emplace_back
T emplace_back(T...args)