| The Gaudi Framework v30r0 (c919700c)

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

- File List
- File Members

AlgorithmManager.cpp
Go to the documentation of this file.
1 // Include files
2 #include "AlgorithmManager.h"
3 #include "GaudiKernel/Algorithm.h"
4 #include "GaudiKernel/IAlgExecStateSvc.h"
5 #include "GaudiKernel/IAlgorithm.h"
6 #include "GaudiKernel/ISvcLocator.h"
7 #include "GaudiKernel/MsgStream.h"
8 #include "GaudiKernel/System.h"
9 #include "GaudiKernel/TypeNameString.h"
10 #include <iostream>
11 #ifndef _WIN32
12 #include <errno.h>
13 #endif
14
16 static SmartIF<IAlgorithm> no_algorithm;
17
18 // constructor
19 AlgorithmManager::AlgorithmManager( IInterface* application ) : base_class( application, IAlgorithm::interfaceID() )
20 {
21 addRef(); // Initial count set to 1
22 }
23
24 // addAlgorithm
25 StatusCode AlgorithmManager::addAlgorithm( IAlgorithm* alg )
26 {
27 m_algs.push_back( alg );
28 return StatusCode::SUCCESS;
29 }
30
31 // removeAlgorithm
32 StatusCode AlgorithmManager::removeAlgorithm( IAlgorithm* alg )
33 {
34 auto it = std::find( m_algs.begin(), m_algs.end(), alg );
35 if ( it != m_algs.end() ) {
36 m_algs.erase( it );
37 return StatusCode::SUCCESS;
38 }
39 return StatusCode::FAILURE;
40 }
41
42 // createService
43 StatusCode AlgorithmManager::createAlgorithm( const std::string& algtype, const std::string& algname,
44 IAlgorithm*& algorithm, bool managed, bool checkIfExists )
45 {
46 // Check is the algorithm is already existing
47 if ( checkIfExists ) {
48 if ( existsAlgorithm( algname ) ) {
49 // return an error because an algorithm with that name already exists
50 return StatusCode::FAILURE;
51 }
52 }
53 std::string actualalgtype( algtype );
54 // a '\' in front of the type name prevents alias replacement
55 if ( ( actualalgtype.size() > 8 ) && ( actualalgtype.compare( 0, 8, "unalias:" ) == 0 ) ) {
56 actualalgtype = actualalgtype.substr( 8 );
57 } else {
58 auto typeAlias = m_algTypeAliases.find( algtype );
59 if ( typeAlias != m_algTypeAliases.end() ) {
60 actualalgtype = typeAlias->second;
61 }
62 }
63 algorithm = Algorithm::Factory::create( actualalgtype, algname, serviceLocator().get() );
64 if ( !algorithm ) {
65 this->error() << "Algorithm of type " << actualalgtype << " is unknown (No factory available)." << endmsg;
66 #ifndef _WIN32
67 errno =
68 0xAFFEDEAD; // code used by Gaudi for library load errors: forces getLastErrorString do use dlerror (on Linux)
69 #endif
70 std::string err = System::getLastErrorString();
71 if ( !err.empty() ) this->error() << err << endmsg;
72 this->error() << "More information may be available by setting the global jobOpt \"PluginDebugLevel\" to 1"
73 << endmsg;
74 return StatusCode::FAILURE;
75 }
76 // Check the compatibility of the version of the interface obtained
77 if ( !isValidInterface( algorithm ) ) {
78 fatal() << "Incompatible interface IAlgorithm version for " << actualalgtype << endmsg;
79 return StatusCode::FAILURE;
80 }
81 m_algs.emplace_back( algorithm, managed );
82 // let the algorithm know its type
83 algorithm->setType( algtype );
84 // this is needed to keep the reference count correct, since isValidInterface(algorithm)
85 // implies an increment of the counter by 1
86 algorithm->release();
87 StatusCode rc;
88 if ( managed ) {
89 // Bring the created algorithm to the same state of the ApplicationMgr
90 if ( FSMState() >= Gaudi::StateMachine::INITIALIZED ) {
91 rc = algorithm->sysInitialize();
92 if ( rc.isSuccess() && FSMState() >= Gaudi::StateMachine::RUNNING ) {
93 rc = algorithm->sysStart();
94 }
95 }
96 if ( !rc.isSuccess() ) {
97 this->error() << "Failed to initialize algorithm: [" << algname << "]" << endmsg;
98 }
99 }
100 return rc;
101 }
102
103 SmartIF<IAlgorithm>& AlgorithmManager::algorithm( const Gaudi::Utils::TypeNameString& typeName, const bool createIf )
104 {
105 auto it = std::find( m_algs.begin(), m_algs.end(), typeName.name() );
106 if ( it != m_algs.end() ) { // found
107 return it->algorithm;
108 }
109 if ( createIf ) {
110 IAlgorithm* alg;
111 if ( createAlgorithm( typeName.type(), typeName.name(), alg, true ).isSuccess() ) {
112 return algorithm( typeName, false );
113 }
114 }
115 return no_algorithm;
116 }
117
118 // existsAlgorithm
119 bool AlgorithmManager::existsAlgorithm( const std::string& name ) const
120 {
121 return m_algs.end() != std::find( m_algs.begin(), m_algs.end(), name );
122 }
123
124 // Return the list of Algorithms
125 const std::vector<IAlgorithm*>& AlgorithmManager::getAlgorithms() const
126 {
127 m_listOfPtrs.clear();
128 m_listOfPtrs.reserve( m_algs.size() );
129 std::transform( std::begin( m_algs ), std::end( m_algs ), std::back_inserter( m_listOfPtrs ),
130 []( const AlgorithmItem& alg ) { return const_cast<IAlgorithm*>( alg.algorithm.get() ); } );
131 return m_listOfPtrs;
132 }
133
134 StatusCode AlgorithmManager::initialize()
135 {
136 StatusCode rc;
137 for ( auto& it : m_algs ) {
138 if ( !it.managed ) continue;
139 rc = it.algorithm->sysInitialize();
140 if ( rc.isFailure() ) return rc;
141 }
142 return rc;
143 }
144
145 StatusCode AlgorithmManager::start()
146 {
147 StatusCode rc;
148 for ( auto& it : m_algs ) {
149 if ( !it.managed ) continue;
150 rc = it.algorithm->sysStart();
151 if ( rc.isFailure() ) return rc;
152 }
153 return rc;
154 }
155
156 StatusCode AlgorithmManager::stop()
157 {
158 StatusCode rc;
159 for ( auto& it : m_algs ) {
160 if ( !it.managed ) continue;
161 rc = it.algorithm->sysStop();
162 if ( rc.isFailure() ) return rc;
163 }
164 return rc;
165 }
166
167 StatusCode AlgorithmManager::finalize()
168 {
169 StatusCode rc;
170 auto it = m_algs.begin();
171 while ( it != m_algs.end() ) { // finalize and remove from the list the managed algorithms
172 if ( it->managed ) {
173 rc = it->algorithm->sysFinalize();
174 if ( rc.isFailure() ) return rc;
175 it = m_algs.erase( it );
176 } else {
177 ++it;
178 }
179 }
180 return rc;
181 }
182
183 StatusCode AlgorithmManager::reinitialize()
184 {
185 StatusCode rc;
186 for ( auto& it : m_algs ) {
187 if ( !it.managed ) continue;
188 rc = it.algorithm->sysReinitialize();
189 if ( rc.isFailure() ) {
190 this->error() << "Unable to re-initialize algorithm: " << it.algorithm->name() << endmsg;
191 return rc;
192 }
193 }
194 return rc;
195 }
196
197 StatusCode AlgorithmManager::restart()
198 {
199 SmartIF<IAlgExecStateSvc> m_aess;
200 m_aess = serviceLocator()->service( "AlgExecStateSvc" );
201 if ( !m_aess.isValid() ) {
202 fatal() << "Error retrieving AlgExecStateSvc" << endmsg;
203 return StatusCode::FAILURE;
204 }
205
206 StatusCode rc;
207
208 for ( auto& it : m_algs ) {
209 if ( !it.managed ) continue;
210 rc = it.algorithm->sysRestart();
211 m_aess->resetErrorCount( it.algorithm );
212 if ( rc.isFailure() ) {
213 this->error() << "Unable to re-initialize algorithm: " << it.algorithm->name() << endmsg;
214 return rc;
215 }
216 }
217 return rc;
218 }
219
220 void AlgorithmManager::outputLevelUpdate()
221 {
222 resetMessaging();
223 for ( auto& algItem : m_algs ) {
224 const auto alg = dynamic_cast<Algorithm*>( algItem.algorithm.get() );
225 if ( alg ) alg->resetMessaging();
226 }
227 }
AlgorithmManager::outputLevelUpdate
void outputLevelUpdate() override
Function to call to update the outputLevel of the components (after a change in MessageSvc).
Definition: AlgorithmManager.cpp:220
System.h
AlgorithmManager::initialize
StatusCode initialize() override
Initialization (from CONFIGURED to INITIALIZED).
Definition: AlgorithmManager.cpp:134
StatusCode::SUCCESS
Definition: StatusCode.h:29
Gaudi::StateMachine::INITIALIZED
Definition: StateMachine.h:17
Algorithm.h
SmartIF< IAlgorithm >
std::string::empty
T empty(T...args)
AlgorithmManager::addAlgorithm
StatusCode addAlgorithm(IAlgorithm *alg) override
implementation of IAlgManager::addAlgorithm
Definition: AlgorithmManager.cpp:25
AlgorithmManager::start
StatusCode start() override
Start (from INITIALIZED to RUNNING).
Definition: AlgorithmManager.cpp:145
AlgorithmManager::name
const std::string & name() const override
Return the name of the manager (implementation of INamedInterface)
Definition: AlgorithmManager.h:78
AlgorithmManager::getAlgorithms
const std::vector< IAlgorithm * > & getAlgorithms() const override
implementation of IAlgManager::getAlgorithms
Definition: AlgorithmManager.cpp:125
IAlgExecStateSvc.h
IAlgorithm::sysStart
virtual StatusCode sysStart()=0
Startup method invoked by the framework.
AlgorithmManager::m_algTypeAliases
AlgTypeAliasesMap m_algTypeAliases
Definition: AlgorithmManager.h:98
MsgStream.h
AlgorithmManager::m_algs
std::vector< AlgorithmItem > m_algs
algorithms maintained by AlgorithmManager
Definition: AlgorithmManager.h:93
IAlgorithm.h
CommonMessaging< implements< IComponentManager > >::resetMessaging
MSG::Level resetMessaging()
Reinitialize internal states.
Definition: CommonMessaging.h:181
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:50
AlgorithmManager::m_listOfPtrs
std::vector< IAlgorithm * > m_listOfPtrs
List of pointers to the know services used to implement getAlgorithms()
Definition: AlgorithmManager.h:96
AlgorithmManager::AlgorithmItem
Definition: AlgorithmManager.h:34
ComponentManager::FSMState
Gaudi::StateMachine::State FSMState() const override
Get the current state.
Definition: ComponentManager.h:61
std::map::end
T end(T...args)
AlgorithmManager::reinitialize
StatusCode reinitialize() override
Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED).
Definition: AlgorithmManager.cpp:183
isValidInterface
bool isValidInterface(I *i)
Templated function that throws an exception if the version if the interface implemented by the object...
Definition: IInterface.h:374
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:61
ComponentManager::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
Definition: ComponentManager.h:30
AlgorithmManager::stop
StatusCode stop() override
Stop (from RUNNING to INITIALIZED).
Definition: AlgorithmManager.cpp:156
CommonMessagingBase::err
MsgStream & err() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:103
AlgorithmManager::finalize
StatusCode finalize() override
Finalize (from INITIALIZED to CONFIGURED).
Definition: AlgorithmManager.cpp:167
IAlgorithm::sysInitialize
virtual StatusCode sysInitialize()=0
Initialization method invoked by the framework.
std::string
STL class.
SmartIF::get
TYPE * get() const
Get interface pointer.
Definition: SmartIF.h:82
ISvcLocator::service
StatusCode service(const Gaudi::Utils::TypeNameString &name, T *&svc, bool createIf=true)
Templated method to access a service by name.
Definition: ISvcLocator.h:79
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:106
Gaudi::Utils::TypeNameString
Helper class to parse a string of format "type/name".
Definition: TypeNameString.h:12
AlgorithmManager.h
AlgorithmManager::existsAlgorithm
bool existsAlgorithm(const std::string &name) const override
implementation of IAlgManager::existsAlgorithm
Definition: AlgorithmManager.cpp:119
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
IInterface
Definition of the basic interface.
Definition: IInterface.h:277
IOTest.rc
rc
Definition: IOTest.py:103
AlgorithmManager::removeAlgorithm
StatusCode removeAlgorithm(IAlgorithm *alg) override
implementation of IAlgManager::removeAlgorithm
Definition: AlgorithmManager.cpp:32
std::vector::clear
T clear(T...args)
IAlgorithm
The IAlgorithm is the interface implemented by the Algorithm base class.
Definition: IAlgorithm.h:28
IAlgorithm::setType
virtual void setType(const std::string &)=0
Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:79
std::find
T find(T...args)
std::string::size
T size(T...args)
Gaudi::StateMachine::RUNNING
Definition: StateMachine.h:18
std::vector< IAlgorithm * >
SmartIF::isValid
bool isValid() const
Allow for check if smart pointer is valid.
Definition: SmartIF.h:68
std::begin
T begin(T...args)
std::back_inserter
T back_inserter(T...args)
Gaudi::Utils::TypeNameString::type
const std::string & type() const
Definition: TypeNameString.h:39
TypeNameString.h
CommonMessaging
Definition: CommonMessaging.h:62
std::string::substr
T substr(T...args)
AlgorithmManager::AlgorithmManager
AlgorithmManager(IInterface *iface)
default creator
Definition: AlgorithmManager.cpp:19
AlgorithmManager::algorithm
SmartIF< IAlgorithm > & algorithm(const Gaudi::Utils::TypeNameString &typeName, const bool createIf=true) override
Definition: AlgorithmManager.cpp:103
std::transform
T transform(T...args)
StatusCode::FAILURE
Definition: StatusCode.h:29
System::getLastErrorString
GAUDI_API const std::string getLastErrorString()
Get last system error as string.
Definition: System.cpp:298
Gaudi::Utils::TypeNameString::name
const std::string & name() const
Definition: TypeNameString.h:40
CommonMessagingBase::fatal
MsgStream & fatal() const
shortcut for the method msgStream(MSG::FATAL)
Definition: CommonMessaging.h:100
GaudiDict::typeName
std::string typeName(const std::type_info &typ)
Definition: Dictionary.cpp:23
ISvcLocator.h
IAlgExecStateSvc::resetErrorCount
virtual void resetErrorCount(const IAlgorithm *iAlg)=0
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209
std::string::compare
T compare(T...args)
AlgorithmManager::createAlgorithm
StatusCode createAlgorithm(const std::string &algtype, const std::string &algname, IAlgorithm *&algorithm, bool managed=false, bool checkIfExists=true) override
implementation of IAlgManager::createAlgorithm
Definition: AlgorithmManager.cpp:43
AlgorithmManager::AlgorithmItem::algorithm
SmartIF< IAlgorithm > algorithm
Definition: AlgorithmManager.h:36
std::vector::reserve
T reserve(T...args)
AlgorithmManager::restart
StatusCode restart() override
Initialization (from RUNNING to RUNNING, via INITIALIZED).
Definition: AlgorithmManager.cpp:197