| The Gaudi Framework v30r0 (c919700c)

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

- File List
- File Members

TimingAuditor.cpp
Go to the documentation of this file.
1 #include "GaudiKernel/Auditor.h"
2 #include "GaudiKernel/HashMap.h"
3 #include "GaudiKernel/IIncidentListener.h"
4 #include "GaudiKernel/IIncidentSvc.h"
5 #include "GaudiKernel/IToolSvc.h"
6 #include "GaudiKernel/MsgStream.h"
7 #include "GaudiKernel/VectorMap.h"
8 // ============================================================================
9 // GaudiAlg
10 // ============================================================================
11 #include "GaudiAlg/ISequencerTimerTool.h"
12 // ============================================================================
13 #ifdef __ICC
14 // disable icc warning #654: overloaded virtual function "B::Y" is only partially overridden in class "C"
15 // TODO: there is only a partial overload of IAuditor::before and IAuditor::after
16 #pragma warning( disable : 654 )
17 #endif
18
27 class TimingAuditor : public extends<Auditor, IIncidentListener>
28 {
29 public:
30 void before( StandardEventType evt, INamedInterface* alg ) override;
31 void after( StandardEventType evt, INamedInterface* alg, const StatusCode& sc ) override;
32
33 using Auditor::before; // avoid hiding base-class methods
34 void before( CustomEventTypeRef evt, const std::string& name ) override;
35 using Auditor::after; // avoid hiding base-class methods
36 void after( CustomEventTypeRef evt, const std::string& name, const StatusCode& sc ) override;
37
38 private:
39 void i_beforeInitialize( INamedInterface* alg );
40 void i_afterInitialize( INamedInterface* alg );
41 void i_beforeFinalize( INamedInterface* alg );
42 void i_beforeExecute( INamedInterface* alg );
43 void i_afterExecute( INamedInterface* alg );
44
45 public:
47 void handle( const Incident& ) override;
48
49 public:
50 StatusCode initialize() override;
51 StatusCode finalize() override;
52
53 public:
54 using extends::extends;
56 ~TimingAuditor() override = default;
57
58 // delete default/copy constructor and assignment
59 TimingAuditor() = delete;
60 TimingAuditor( const TimingAuditor& ) = delete;
61 TimingAuditor& operator=( const TimingAuditor& ) = delete;
62
63 private:
64 // tool service
65 SmartIF<IToolSvc> m_toolSvc = nullptr;
66 // incident service
67 SmartIF<IIncidentSvc> m_incSvc = nullptr;
68 // the timer tool
69 ISequencerTimerTool* m_timer = nullptr;
70 // ApplicationManager
71 SmartIF<INamedInterface> m_appMgr = nullptr;
72 //
73 GaudiUtils::VectorMap<const INamedInterface*, int> m_map;
74 // indentation level
75 int m_indent = 0;
76 // "in event"
77 bool m_inEvent = false;
78 //
79 GaudiUtils::HashMap<std::string, int> m_mapUser;
80
81 // Whether the timing has been saved already
82 bool m_histoSaved = false;
83
84 Gaudi::Property<bool> m_goodForDOD{this, "OptimizedForDOD", false, "enable optimization for Data-On-Demand Service"};
85 };
86 // ============================================================================
88 // ============================================================================
89 DECLARE_COMPONENT( TimingAuditor )
90 // ============================================================================
91 StatusCode TimingAuditor::initialize()
92 {
93 StatusCode sc = Auditor::initialize();
94 if ( sc.isFailure() ) {
95 return sc;
96 } // RETURN
97
98 // get tool service
99 if ( !m_toolSvc ) {
100 m_toolSvc = Auditor::service( "ToolSvc" );
101 if ( !m_toolSvc ) {
102 error() << "Could not retrieve 'ToolSvc' " << endmsg;
103 return StatusCode::FAILURE; // RETURN
104 }
105 if ( !m_timer ) {
106 sc = m_toolSvc->retrieveTool( "SequencerTimerTool/TIMER", m_timer, this, true );
107 if ( sc.isFailure() ) {
108 error() << "Could not retrieve ISequencerTimerTool" << endmsg;
109 return sc;
110 }
111 }
112 }
113 // get incident service
114 if ( !m_incSvc ) {
115 m_incSvc = Auditor::service( "IncidentSvc" );
116 if ( !m_incSvc ) {
117 error() << "Could not retrieve 'IncidentSvc'" << endmsg;
118 return StatusCode::FAILURE;
119 }
120 m_incSvc->addListener( this, IncidentType::BeginEvent );
121 m_incSvc->addListener( this, IncidentType::EndEvent );
122 }
123 // get the application manager
124 if ( !m_appMgr ) {
125 m_appMgr = Auditor::service( "ApplicationMgr" );
126 if ( !m_appMgr ) {
127 error() << "Could not retrieve 'ApplicationMgr'" << endmsg;
128 return sc;
129 }
130 if ( m_map.end() == m_map.find( m_appMgr.get() ) ) {
131 m_map.insert( m_appMgr.get(), m_timer->addTimer( "EVENT LOOP" ) );
132 }
133 }
134 //
135 return StatusCode::SUCCESS;
136 }
137 // ============================================================================
138 StatusCode TimingAuditor::finalize()
139 {
140 if ( m_incSvc ) {
141 m_incSvc->removeListener( this, IncidentType::BeginEvent );
142 m_incSvc->removeListener( this, IncidentType::EndEvent );
143 m_incSvc.reset();
144 }
145 if ( m_toolSvc ) {
146 // the 2 following line are commented out: it is
147 // is a temporary hack which prevent a crash due to a problem in
148 // the reference counting
149 // if ( 0 != m_timer )
150 // { m_toolSvc -> releaseTool ( m_timer ) . ignore() ; m_timer = 0 ; }
151 m_toolSvc.reset();
152 }
153 m_appMgr.reset();
154 // clear the map
155 m_map.clear();
156 // finalize the base class
157 return Auditor::finalize();
158 }
159 // ============================================================================
160 void TimingAuditor::before( StandardEventType evt, INamedInterface* alg )
161 {
162 switch ( evt ) {
163 case IAuditor::Initialize:
164 i_beforeInitialize( alg );
165 break;
166 case IAuditor::Execute:
167 i_beforeExecute( alg );
168 break;
169 case IAuditor::Finalize:
170 i_beforeFinalize( alg );
171 break;
172 default:
173 break;
174 }
175 }
176 // ============================================================================
177 void TimingAuditor::after( StandardEventType evt, INamedInterface* alg, const StatusCode& )
178 {
179 switch ( evt ) {
180 case IAuditor::Initialize:
181 i_afterInitialize( alg );
182 break;
183 case IAuditor::Execute:
184 i_afterExecute( alg );
185 break;
186 default:
187 break;
188 }
189 }
190 // ============================================================================
191 void TimingAuditor::i_beforeFinalize( INamedInterface* /*alg*/ )
192 {
193 if ( !m_histoSaved ) {
194 m_timer->saveHistograms();
195 m_histoSaved = true;
196 }
197 }
198
199 // ============================================================================
200 void TimingAuditor::i_beforeInitialize( INamedInterface* alg )
201 {
202 if ( m_goodForDOD ) {
203 return;
204 }
205 //
206 if ( !alg ) {
207 return;
208 }
209 auto found = m_map.find( alg );
210 if ( m_map.end() != found ) {
211 return;
212 }
213 ++m_indent;
214 std::string nick = alg->name();
215 if ( 0 < m_indent ) {
216 nick = std::string( m_indent, ' ' ) + nick;
217 }
218 if ( m_inEvent ) {
219 nick[0] = '*';
220 debug() << "Insert non-structural component '" << alg->name() << "' of type '"
221 << System::typeinfoName( typeid( *alg ) ) << "' at level " << m_indent << endmsg;
222 }
223 int timer = m_timer->addTimer( nick );
224 m_map.insert( alg, timer );
225 m_timer->start( timer );
226 }
227 // ============================================================================
228 void TimingAuditor::i_afterInitialize( INamedInterface* alg )
229 {
230 if ( m_goodForDOD || !alg ) {
231 return;
232 }
233 --m_indent;
234 }
235 // ============================================================================
236 void TimingAuditor::i_beforeExecute( INamedInterface* alg )
237 {
238 if ( !alg ) {
239 return;
240 }
241 ++m_indent;
242 auto found = m_map.find( alg );
243 if ( m_map.end() == found ) {
244 debug() << "Insert non-structural component '" << alg->name() << "' of type '"
245 << System::typeinfoName( typeid( *alg ) ) << "' at level " << m_indent << endmsg;
246 std::string nick = alg->name();
247 if ( 0 < m_indent ) {
248 nick = std::string( m_indent, ' ' ) + nick;
249 }
250 if ( !m_goodForDOD ) {
251 nick[0] = '*';
252 }
253 int timer = m_timer->addTimer( nick );
254 m_map.insert( alg, timer );
255 m_timer->start( timer );
256 return;
257 }
258 m_timer->start( found->second );
259 }
260 // ============================================================================
261 void TimingAuditor::i_afterExecute( INamedInterface* alg )
262 {
263 if ( !alg ) {
264 return;
265 }
266 auto found = m_map.find( alg );
267 if ( m_map.end() == found ) {
268 return;
269 }
270 m_timer->stop( found->second );
271 --m_indent;
272 }
273 // ============================================================================
274 void TimingAuditor::before( CustomEventTypeRef evt, const std::string& name )
275 {
276 // Ignore obvious mistakes
277 if ( name.empty() && evt.empty() ) {
278 return;
279 }
280
281 // look for the user timer in the map
282 int timer = 0;
283 std::string nick = name + ":" + evt;
284 auto found = m_mapUser.find( nick );
285
286 if ( m_mapUser.end() == found ) {
287 // add a new timer if not yet available
288 timer = m_timer->addTimer( nick );
289 m_mapUser[nick] = timer;
290 } else {
291 timer = found->second;
292 }
293 m_timer->start( timer );
294 }
295 // ============================================================================
296 void TimingAuditor::after( CustomEventTypeRef evt, const std::string& name, const StatusCode& )
297 {
298 // Ignore obvious mistakes
299 if ( name.empty() && evt.empty() ) {
300 return;
301 }
302
303 // look for the user timer in the map
304 std::string nick = name + ":" + evt;
305 auto found = m_mapUser.find( nick );
306
307 // We cannot do much if the timer is not available
308 if ( m_mapUser.end() == found ) {
309 warning() << "Trying to stop the measure of the timing for '" << nick
310 << "' but it was never started. Check the code" << endmsg;
311 return;
312 }
313 m_timer->stop( found->second );
314 }
315 // ============================================================================
316 void TimingAuditor::handle( const Incident& i )
317 {
318 if ( IncidentType::BeginEvent == i.type() ) {
319 m_timer->start( m_map[m_appMgr.get()] );
320 ++m_indent;
321 m_inEvent = true;
322 } else if ( IncidentType::EndEvent == i.type() ) {
323 m_timer->stop( m_map[m_appMgr.get()] );
324 --m_indent;
325 m_inEvent = false;
326 }
327 }
328 // ============================================================================
329 // The END
330 // ============================================================================
TimingAuditor::i_afterInitialize
void i_afterInitialize(INamedInterface *alg)
Definition: TimingAuditor.cpp:228
TimingAuditor::i_beforeInitialize
void i_beforeInitialize(INamedInterface *alg)
Definition: TimingAuditor.cpp:200
TimingAuditor::m_mapUser
GaudiUtils::HashMap< std::string, int > m_mapUser
map used to record user timing events
Definition: TimingAuditor.cpp:79
StatusCode::SUCCESS
Definition: StatusCode.h:29
GaudiUtils::VectorMap< const INamedInterface *, int >
TimingAuditor::operator=
TimingAuditor & operator=(const TimingAuditor &)=delete
SmartIF< IToolSvc >
Auditor::finalize
virtual StatusCode finalize()
Definition: Auditor.cpp:200
std::string::empty
T empty(T...args)
Auditor::service
StatusCode service(const std::string &name, T *&svc, bool createIf=false) const
Access a service by name, creating it if it doesn&#39;t already exist.
Definition: Auditor.h:109
Incident::type
const std::string & type() const
Access to the incident type.
Definition: Incident.h:41
Gaudi::Property
Implementation of property with value of concrete type.
Definition: Property.h:319
MsgStream.h
System::typeinfoName
GAUDI_API const std::string typeinfoName(const std::type_info &)
Get platform independent information about the class type.
Definition: System.cpp:336
ISequencerTimerTool::addTimer
virtual int addTimer(const std::string &name)=0
add a timer entry with the specified name
TimingAuditor::m_inEvent
bool m_inEvent
"In event" flag
Definition: TimingAuditor.cpp:77
TimingAuditor::m_map
GaudiUtils::VectorMap< const INamedInterface *, int > m_map
Definition: TimingAuditor.cpp:73
TimingAuditor::finalize
StatusCode finalize() override
Definition: TimingAuditor.cpp:138
TimingAuditor::i_beforeExecute
void i_beforeExecute(INamedInterface *alg)
Definition: TimingAuditor.cpp:236
HashMap.h
GaudiUtils::VectorMap::insert
result_type insert(const key_type &key, const mapped_type &mapped)
insert the (key,value) pair into the container
Definition: VectorMap.h:312
TimingAuditor::after
void after(StandardEventType evt, INamedInterface *alg, const StatusCode &sc) override
Definition: TimingAuditor.cpp:177
IToolSvc.h
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:61
IToolSvc::retrieveTool
StatusCode retrieveTool(const std::string &type, T *&tool, const IInterface *parent=nullptr, bool createIf=true)
Retrieve specified tool sub-type with tool dependent part of the name automatically assigned...
Definition: IToolSvc.h:139
DECLARE_COMPONENT
#define DECLARE_COMPONENT(type)
Definition: PluginService.h:33
std::string
STL class.
TimingAuditor::initialize
StatusCode initialize() override
factory:
Definition: TimingAuditor.cpp:91
GaudiUtils::VectorMap::find
iterator find(const key_type &key) const
find the element by key
Definition: VectorMap.h:449
SmartIF::get
TYPE * get() const
Get interface pointer.
Definition: SmartIF.h:82
TimingAuditor::m_indent
int m_indent
indentation level
Definition: TimingAuditor.cpp:75
GaudiUtils::VectorMap::end
iterator end() const
"end" iterator for sequential access (const-only version!)
Definition: VectorMap.h:191
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:106
GaudiUtils::Map::end
iterator end()
Definition: Map.h:134
TimingAuditor::m_appMgr
SmartIF< INamedInterface > m_appMgr
ApplicationManager.
Definition: TimingAuditor.cpp:71
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:109
VectorMap.h
IIncidentSvc.h
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
TimingAuditor::m_incSvc
SmartIF< IIncidentSvc > m_incSvc
incident service
Definition: TimingAuditor.cpp:67
TimingAuditor::before
void before(StandardEventType evt, INamedInterface *alg) override
Definition: TimingAuditor.cpp:160
IAuditor::Finalize
Definition: IAuditor.h:25
ISequencerTimerTool::saveHistograms
virtual void saveHistograms()=0
prepares and saves the timing histograms
GaudiUtils::Map::find
iterator find(const key_type &key)
Definition: Map.h:151
Auditor::after
void after(StandardEventType, INamedInterface *, const StatusCode &) override
Definition: Auditor.cpp:110
TimingAuditor::~TimingAuditor
~TimingAuditor() override=default
destructor
IAuditor::Initialize
Definition: IAuditor.h:25
TimingAuditor::i_beforeFinalize
void i_beforeFinalize(INamedInterface *alg)
Definition: TimingAuditor.cpp:191
ISequencerTimerTool::start
virtual void start(int index)=0
start the counter, i.e.
INamedInterface
IInterface compliant class extending IInterface with the name() method.
Definition: INamedInterface.h:15
TimingAuditor::TimingAuditor
TimingAuditor()=delete
CommonMessagingBase::debug
MsgStream & debug() const
shortcut for the method msgStream(MSG::DEBUG)
Definition: CommonMessaging.h:115
extends
Base class used to extend a class implementing other interfaces.
Definition: extends.h:10
Incident
Base class for all Incidents (computing events).
Definition: Incident.h:17
IIncidentSvc::addListener
virtual void addListener(IIncidentListener *lis, const std::string &type="", long priority=0, bool rethrow=false, bool singleShot=false)=0
Add listener.
IAuditor::Execute
Definition: IAuditor.h:25
ISequencerTimerTool
Implements the time measurement inside a sequencer.
Definition: ISequencerTimerTool.h:14
GaudiUtils::HashMap< std::string, int >
ISequencerTimerTool.h
GaudiUtils::VectorMap::clear
void clear()
clear the container
Definition: VectorMap.h:488
TimingAuditor::m_toolSvc
SmartIF< IToolSvc > m_toolSvc
tool service
Definition: TimingAuditor.cpp:65
IIncidentListener.h
SmartIF::reset
void reset(TYPE *ptr=nullptr)
Set the internal pointer to the passed one disposing of the old one.
Definition: SmartIF.h:92
TimingAuditor::m_timer
ISequencerTimerTool * m_timer
the timer tool
Definition: TimingAuditor.cpp:69
Auditor::initialize
virtual StatusCode initialize()
Definition: Auditor.cpp:70
IIncidentSvc::removeListener
virtual void removeListener(IIncidentListener *lis, const std::string &type="")=0
Remove listener.
StatusCode::FAILURE
Definition: StatusCode.h:29
TimingAuditor::handle
void handle(const Incident &) override
Inform that a new incident has occurred.
Definition: TimingAuditor.cpp:316
TimingAuditor::m_histoSaved
bool m_histoSaved
Definition: TimingAuditor.cpp:82
ISequencerTimerTool::stop
virtual double stop(int index)=0
stop the counter, return the elapsed time
Auditor.h
TimingAuditor::m_goodForDOD
Gaudi::Property< bool > m_goodForDOD
Definition: TimingAuditor.cpp:84
Auditor::before
void before(StandardEventType, INamedInterface *) override
The following methods are meant to be implemented by the child class...
Definition: Auditor.cpp:73
Auditor::name
const std::string & name() const override
Definition: Auditor.cpp:202
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209
INamedInterface::name
virtual const std::string & name() const =0
Retrieve the name of the instance.
IOTest.evt
evt
Definition: IOTest.py:96
TimingAuditor::i_afterExecute
void i_afterExecute(INamedInterface *alg)
Definition: TimingAuditor.cpp:261
TimingAuditor
Simple auditor which uses SequencerTimerTool for ALL algorithms, including the algorithm from main Ga...
Definition: TimingAuditor.cpp:27