]>
Commit | Line | Data |
---|---|---|
30338a30 | 1 | //-*- Mode: C++ -*- |
f23a6e1a | 2 | // @(#) $Id$ |
3 | ||
4 | #ifndef ALIHLTSYSTEM_H | |
5 | #define ALIHLTSYSTEM_H | |
c5123824 | 6 | //* This file is property of and copyright by the ALICE HLT Project * |
7 | //* ALICE Experiment at CERN, All rights reserved. * | |
8 | //* See cxx source for full Copyright notice * | |
f23a6e1a | 9 | |
b22e91eb | 10 | /** @file AliHLTSystem.h |
11 | @author Matthias Richter | |
12 | @date | |
13 | @brief Global HLT module management and AliRoot integration. | |
14 | @note The class is used in Offline (AliRoot) context | |
15 | */ | |
f23a6e1a | 16 | |
b22e91eb | 17 | /** |
18 | * @defgroup alihlt_system HLT integration into AliRoot | |
19 | * This section describes the HLT integration into AliRoot. | |
20 | */ | |
f23a6e1a | 21 | |
5ec8e281 | 22 | #include "AliHLTLogging.h" |
23 | #include <TList.h> | |
c043fa2c | 24 | #include <TString.h> |
f23a6e1a | 25 | |
5ec8e281 | 26 | class AliHLTComponentHandler; |
27 | class AliHLTConfiguration; | |
85465857 | 28 | class AliHLTConfigurationHandler; |
5ec8e281 | 29 | class AliHLTTask; |
c5123824 | 30 | class AliHLTOUT; |
242bb794 | 31 | class AliRunLoader; |
32 | class AliRawReader; | |
af885e0f | 33 | class AliESDEvent; |
90ebac25 | 34 | class TObjArray; |
35 | class TStopwatch; | |
f23a6e1a | 36 | |
bfccbf68 | 37 | /** |
38 | * @class AliHLTSystem | |
39 | * Main class for the HLT integration into AliRoot. | |
40 | * The class handles a list of configurations. Configurations are translated | |
41 | * into task lists which can be executed. | |
42 | * | |
b22e91eb | 43 | * @note This class is only used for the @ref alihlt_system. |
44 | * | |
45 | * @ingroup alihlt_system | |
bfccbf68 | 46 | */ |
5ec8e281 | 47 | class AliHLTSystem : public AliHLTLogging { |
48 | public: | |
bfccbf68 | 49 | /** default constructor */ |
83cb7e1d | 50 | AliHLTSystem(AliHLTComponentLogSeverity loglevel=kHLTLogDefault); |
bfccbf68 | 51 | /** destructor */ |
f23a6e1a | 52 | virtual ~AliHLTSystem(); |
53 | ||
bfccbf68 | 54 | /** |
55 | * Pointer to an instance of @ref AliHLTComponentHandler. | |
3b35e87c | 56 | */ |
70ed7d01 | 57 | AliHLTComponentHandler* fpComponentHandler; //! transient |
bfccbf68 | 58 | |
59 | /** | |
60 | * Pointer to an instance of @ref AliHLTConfigurationHandler. | |
61 | */ | |
70ed7d01 | 62 | AliHLTConfigurationHandler* fpConfigurationHandler; //! transient |
f23a6e1a | 63 | |
bfccbf68 | 64 | /** |
65 | * Add a configuration to the end of the list. | |
66 | * @param pConf pointer to configuration to add | |
5ec8e281 | 67 | */ |
68 | int AddConfiguration(AliHLTConfiguration* pConf); | |
69 | ||
bfccbf68 | 70 | /** |
70ed7d01 | 71 | * Insert a configuration to the end of the list after the specified |
72 | * configuration. | |
bfccbf68 | 73 | * @param pConf pointer to configuration to insert |
74 | * @param pPrec pointer to configuration to insert the new one after | |
5ec8e281 | 75 | */ |
76 | int InsertConfiguration(AliHLTConfiguration* pConf, AliHLTConfiguration* pPrec); | |
77 | ||
bfccbf68 | 78 | /** |
79 | * Remove a configuration from the list. | |
80 | * @param pConf pointer to configuration to delete | |
5ec8e281 | 81 | */ |
82 | int DeleteConfiguration(AliHLTConfiguration* pConf); | |
83 | ||
bfccbf68 | 84 | /** |
a742f6f8 | 85 | * Build a task list |
3b35e87c | 86 | * This method is used to build the tasks from the 'master' configuration |
87 | * objects which are added to the HLT system handler. This is an iterative | |
88 | * process since the task might depend upon other configurations. For each | |
89 | * configuration object which has not yet been converted into a task, the | |
90 | * method will be called iteratively. Finally, after building all tasks which | |
91 | * the current one depends on have been created, the task is inserted to the | |
92 | * list of tasks with the InsertTask method. | |
a742f6f8 | 93 | * @param pConf configuration name/id |
94 | */ | |
95 | int BuildTaskList(const char* pConf); | |
96 | ||
97 | /** | |
98 | * Build task list from a configuration object. | |
99 | * This method is kept for backward compatibility. Use the version | |
100 | * with the configuration name. | |
bfccbf68 | 101 | * @param pConf pointer to configuration to build the task list from |
5ec8e281 | 102 | */ |
103 | int BuildTaskList(AliHLTConfiguration* pConf); | |
104 | ||
bfccbf68 | 105 | /** |
106 | * Clean the list of tasks and delete all the task objects. | |
3b35e87c | 107 | */ |
5ec8e281 | 108 | int CleanTaskList(); |
109 | ||
bfccbf68 | 110 | /** |
111 | * Insert a task to the task list. | |
112 | * The method first checks whether all dependencies are resolved (i.e. exist | |
70ed7d01 | 113 | * already in the task list). During this iteration the cross links between |
114 | * the tasks are set as well. If all dependencies are resolved, the task is | |
115 | * added at the end of the list. | |
bfccbf68 | 116 | * @param pTask pointer to task to add |
3b35e87c | 117 | */ |
5ec8e281 | 118 | int InsertTask(AliHLTTask* pTask); |
119 | ||
bfccbf68 | 120 | /** |
121 | * Find a task with an id. | |
122 | * @param id CONFIGURATION id (not a COMPONENT id!) | |
3b35e87c | 123 | */ |
5ec8e281 | 124 | AliHLTTask* FindTask(const char* id); |
125 | ||
bfccbf68 | 126 | /** |
127 | * Print the task list. | |
3b35e87c | 128 | */ |
5ec8e281 | 129 | void PrintTaskList(); |
130 | ||
53feaef5 | 131 | /** |
132 | * Run the task list. | |
9ce4bf4a | 133 | * The method checks whether the task list has already been build. If not, |
134 | * or the configuration list has been changed, the @ref BuildTaskList | |
dee38f1b | 135 | * method is called. <br> |
53feaef5 | 136 | * All tasks of the list will be subsequently processed for each event. |
dee38f1b | 137 | * The system can remain started if the \em bStop parameter is 0. In that |
138 | * case the system just waits for the next event. A specific call with | |
139 | * nofEvents==0 is needed to execute the stop sequence. | |
53feaef5 | 140 | * @param iNofEvents number of events |
dee38f1b | 141 | * @param bStop stop the chain after processing |
242bb794 | 142 | * @return number of reconstructed events, neg error code if failed |
53feaef5 | 143 | */ |
dee38f1b | 144 | int Run(Int_t iNofEvents=1, int bStop=1); |
53feaef5 | 145 | |
9ce4bf4a | 146 | /** |
147 | * Init all tasks from the list. | |
148 | * The @ref AliHLTTask::Init method is called for each task, the components | |
149 | * will be created. | |
150 | * @return neg error code if failed | |
151 | */ | |
152 | int InitTasks(); | |
153 | ||
90ebac25 | 154 | /** |
155 | * Init the stopwatches for all tasks. | |
156 | * @param pStopwatches object array of stopwatches, for types | |
157 | * @see AliHLTComponent::AliHLTStopwatchType | |
158 | * @return neg error code if failed | |
159 | */ | |
160 | int InitBenchmarking(TObjArray* pStopwatches); | |
161 | ||
032c5e5e | 162 | /** |
163 | * Stop the stopwatches for all tasks. | |
164 | * @param pStopwatches object array of stopwatches, for types | |
165 | * @see AliHLTComponent::AliHLTStopwatchType | |
166 | * @return neg error code if failed | |
167 | */ | |
168 | int PauseBenchmarking(TObjArray* pStopwatches) const; | |
169 | ||
170 | /** | |
171 | * Continue the stopwatches for all tasks. | |
172 | * @param pStopwatches object array of stopwatches, for types | |
173 | * @see AliHLTComponent::AliHLTStopwatchType | |
174 | * @return neg error code if failed | |
175 | */ | |
176 | int ResumeBenchmarking(TObjArray* pStopwatches) const; | |
177 | ||
dee38f1b | 178 | /** |
179 | * Print benchmarking summary. | |
180 | * Optionak: clean up stop watches. | |
181 | * @param pStopwatches object array of stopwatches | |
182 | * @param bClean delete stop watches if 1 | |
183 | * @return neg error code if failed | |
184 | */ | |
032c5e5e | 185 | int PrintBenchmarking(TObjArray* pStopwatches, int bClean=0) const; |
dee38f1b | 186 | |
53feaef5 | 187 | /** |
188 | * Start task list. | |
70ed7d01 | 189 | * The @ref AliHLTTask::StartRun method is called for each task, the |
190 | * components will be prepared for event processing. | |
53feaef5 | 191 | * @return neg error code if failed |
192 | */ | |
193 | int StartTasks(); | |
194 | ||
195 | /** | |
196 | * Process task list. | |
197 | * The @ref AliHLTTask::ProcessTask method is called for each task. | |
198 | * @return neg error code if failed | |
199 | */ | |
200 | int ProcessTasks(Int_t eventNo); | |
201 | ||
202 | /** | |
203 | * Stop task list. | |
204 | * The @ref AliHLTTask::EndRun method is called for each task, the components | |
205 | * will be cleaned after event processing. | |
206 | * @return neg error code if failed | |
5ec8e281 | 207 | */ |
53feaef5 | 208 | int StopTasks(); |
5ec8e281 | 209 | |
457ec821 | 210 | /** |
211 | * Send a control event trough the chain. | |
212 | * All data sources in the chain are switched to publish a control event like | |
213 | * SOR or EOR. The event is propagated in the same way as a normal event. | |
214 | * @param dt type of the event | |
215 | */ | |
216 | int SendControlEvent(AliHLTComponentDataType dt); | |
217 | ||
9ce4bf4a | 218 | /** |
219 | * De-init all tasks from the list. | |
220 | * The @ref AliHLTTask::Deinit method is called for each task, the components | |
221 | * will be deleted. | |
222 | * @return neg error code if failed | |
223 | */ | |
224 | int DeinitTasks(); | |
225 | ||
226 | /** | |
227 | * The memory allocation function for components. | |
228 | * This function is part of the running environment of the components. | |
229 | */ | |
230 | static void* AllocMemory( void* param, unsigned long size ); | |
231 | ||
242bb794 | 232 | /** |
dee38f1b | 233 | * AliRoot embedded reconstruction. |
234 | * Main entry point to execute the HLT reconstruction from AliRoot. Called | |
235 | * either by the AliHLTReconstructor plugin during AliRoot reconstruction | |
236 | * of raw data, or AliHLTSimulation during simulation of data. | |
237 | * | |
238 | * The two cases are distinguished by the availablility of the run loader | |
239 | * and raw reader. | |
240 | * - AliRoot simulation: run loader is available and is propagated to the | |
241 | * module agents (AliHLTModuleAgent) to generate the corresponding | |
242 | * configurations and chains, and to the AliHLTOfflineSource components. | |
243 | * - AliRoot reconstruction: raw reader is available and is propagated to | |
244 | * the agents and AliHLTOfflineSource components. | |
245 | * | |
246 | * The system remains started after the processing and just waits for the | |
247 | * next event. A specific call with nofEvents==0 is needed to execute the | |
248 | * stop sequence. | |
249 | * | |
242bb794 | 250 | * The 'runLoader' and 'rawReader' parameters are set to all active |
251 | * AliHLTOfflineDataSource's and the HLT chain is processed for the given | |
252 | * number of events. If the rawReader is NULL, reconstruction is done on | |
253 | * simulated data, from real data if a RawReader is specified. | |
254 | * @param nofEvents number of events | |
255 | * @param runLoader the AliRoot runloader | |
256 | * @param rawReader the AliRoot RawReader | |
257 | * @return number of reconstructed events, neg. error code if failed | |
258 | */ | |
259 | int Reconstruct(int nofEvents, AliRunLoader* runLoader, | |
260 | AliRawReader* rawReader=NULL); | |
261 | ||
262 | /** | |
263 | * Fill ESD for one event. | |
264 | * To be called by the AliHLTReconstructor plugin during the event loop | |
265 | * and FillESD method of the AliRoot reconstruction. | |
c5123824 | 266 | * |
267 | * The method is most likely deprecated as the scheme has been slightly | |
268 | * changed. The ESD is filled by the HLTOUT handlers u=implemented by the | |
269 | * HLT modules rather than by components within the reconstruction chain. | |
270 | * Still, HLT reconstruction chains can be run during the AliRoot | |
271 | * reconstruction, data produced by such chains is automatically added | |
272 | * to the HLTOUT stream in order to be equivalent to the online HLT. | |
273 | * The HLTOUT is processed during AliReconstruction at the end of the | |
274 | * HLT event processing, literally during the FillESD method of the AliRoot | |
275 | * reconstruction interface. The HLT module must implement HLTOUT handlers | |
276 | * and provide those through the module agent. | |
277 | * | |
242bb794 | 278 | * This method is called on event basis, and thus must copy the previously |
279 | * reconstructed data of the event from the 'ESD' recorder. The FillESD | |
280 | * method of all active AliHLTOfflineDataSink's is called. | |
281 | * @param eventNo current event no (Note: this event number is just a | |
282 | * processing counter and is not related to the nature/ | |
283 | * origin of the event | |
284 | * @param runLoader the AliRoot runloader | |
af885e0f | 285 | * @param esd an AliESDEvent instance |
242bb794 | 286 | * @return neg. error code if failed |
287 | */ | |
af885e0f | 288 | int FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd); |
242bb794 | 289 | |
c5123824 | 290 | /** |
291 | * Process the HLTOUT data. | |
292 | */ | |
293 | int ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd); | |
294 | ||
0f1882a7 | 295 | /** |
296 | * Process all kChain-type data blocks of the HLTOUT data. | |
297 | * The function is involed from ProcessHLTOUT as the first step in | |
298 | * the processing. | |
299 | */ | |
300 | int ProcessHLTOUTkChain(AliHLTOUT* pHLTOUT); | |
301 | ||
242bb794 | 302 | /** |
303 | * Load component libraries. | |
304 | * @param libs string of blank separated library names | |
305 | * @return neg. error code if failed | |
306 | */ | |
307 | int LoadComponentLibraries(const char* libs); | |
308 | ||
85f0cede | 309 | /** |
310 | * Find a symbol in a dynamically loaded library. | |
311 | * @param library library | |
312 | * @param symbol the symbol to find | |
313 | * @return void pointer to function | |
314 | */ | |
315 | void* FindDynamicSymbol(const char* library, const char* symbol); | |
316 | ||
242bb794 | 317 | /** |
318 | * Prepare the HLT system for running. | |
319 | * - module agents are requested to register configurations | |
320 | * - task lists are built from the top configurations of the modules | |
c043fa2c | 321 | * |
dee38f1b | 322 | * @param rawReader instance of the raw reader or NULL |
c043fa2c | 323 | * @param runloader optional instance of the run loader |
242bb794 | 324 | * @return neg. error code if failed <br> |
325 | * -EBUSY system is in kRunning state <br> | |
326 | */ | |
dee38f1b | 327 | int Configure(AliRawReader* rawReader, AliRunLoader* runloader=NULL); |
242bb794 | 328 | |
dee38f1b | 329 | /** |
330 | * Old method kept for backward compatibilty. | |
331 | * | |
332 | * @param runloader optional instance of the run loader | |
333 | * @return neg. error code if failed <br> | |
334 | * -EBUSY system is in kRunning state <br> | |
335 | */ | |
336 | int Configure(AliRunLoader* runloader=NULL); | |
c043fa2c | 337 | |
338 | /** | |
b005ef92 | 339 | * Scan options and load component libraries. |
340 | * The options consist of blank separated tokens. Libraries can be just | |
341 | * specified by their name. Further options | |
1ac82ce6 | 342 | * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting --> |
c043fa2c | 343 | * \li loglevel=<i>level</i> <br> |
344 | * logging level for this processing | |
dba03d72 | 345 | * \li frameworklog=<i>level</i> <br> |
346 | * logging level for framework classes | |
c043fa2c | 347 | * \li alilog=off |
348 | * disable redirection of log messages to AliLog class | |
349 | * \li config=<i>macro</i> | |
350 | * configuration macro | |
dee38f1b | 351 | * \li chains=<i>configuration</i> |
c043fa2c | 352 | * comma separated list of configurations to be run during local |
353 | * reconstruction | |
dba03d72 | 354 | * \li libmode=<i>static,dynamic(default)</i> |
355 | * libraries are persistent if loaded in mode <i>static</i>, i.e. they | |
356 | * can't be unloaded | |
c043fa2c | 357 | */ |
358 | int ScanOptions(const char* options); | |
359 | ||
242bb794 | 360 | /** |
361 | * Reset the HLT system. | |
362 | * Reset is not possible while the system is in running state. | |
363 | * @param bForce force the reset | |
364 | * @return neg. error code if failed <br> | |
365 | * -EBUSY system is in kRunning state <br> | |
366 | */ | |
367 | int Reset(int bForce=0); | |
368 | ||
369 | /** | |
370 | * Load the configurations specified by the module agents. | |
371 | * The runLoader is passed to the agent and allows configuration | |
372 | * selection. | |
dee38f1b | 373 | * @param rawReader instance of the raw reader or NULL |
374 | * @param runloader optional instance of the run loader | |
242bb794 | 375 | * @return neg. error code if failed |
376 | */ | |
dee38f1b | 377 | int LoadConfigurations(AliRawReader* rawReader, AliRunLoader* runloader=NULL); |
242bb794 | 378 | |
379 | /** | |
380 | * Get the top configurations of all agents and build the task lists. | |
dee38f1b | 381 | * @param rawReader instance of the raw reader or NULL |
382 | * @param runloader optional instance of the run loader | |
242bb794 | 383 | * @return neg. error code if failed |
384 | */ | |
f3506ea2 | 385 | int BuildTaskListsFromReconstructionChains(AliRawReader* rawReader, |
386 | AliRunLoader* runloader=NULL); | |
242bb794 | 387 | |
6a8e0bb4 | 388 | enum AliHLTSystemState { |
242bb794 | 389 | kUninitialized = 0x0, |
390 | kLibrariesLoaded = 0x1, | |
391 | kConfigurationLoaded = 0x2, | |
392 | kTaskListCreated = 0x4, | |
393 | kReady = 0x7, | |
dee38f1b | 394 | kStarted = 0x8, |
395 | kRunning = 0x10, | |
242bb794 | 396 | kError = 0x1000 |
9253e11b | 397 | }; |
242bb794 | 398 | |
399 | /** | |
400 | * Check status of the system. | |
6a8e0bb4 | 401 | * @param flag AliHLTSystemState value to check for |
242bb794 | 402 | * @return 1 if set, 0 if not |
403 | */ | |
404 | int CheckStatus(int flag); | |
405 | ||
406 | /** | |
407 | * Get the current status. | |
6a8e0bb4 | 408 | * @return status flags of @ref AliHLTSystemState |
242bb794 | 409 | */ |
410 | int GetStatusFlags(); | |
411 | ||
e642a402 | 412 | /** |
413 | * Set logging level for framework classes. | |
414 | * This sets the local logging level of this instance and all subsequent | |
415 | * framework classes to \em level. | |
416 | * @param level local logging level for the framework classes | |
417 | */ | |
418 | void SetFrameworkLog(AliHLTComponentLogSeverity level); | |
419 | ||
5ec8e281 | 420 | protected: |
5ec8e281 | 421 | |
422 | private: | |
c043fa2c | 423 | /** copy constructor prohibited */ |
424 | AliHLTSystem(const AliHLTSystem&); | |
425 | /** assignment operator prohibited */ | |
426 | AliHLTSystem& operator=(const AliHLTSystem&); | |
427 | ||
242bb794 | 428 | /** |
429 | * Set status flags. | |
430 | */ | |
431 | int SetStatusFlags(int flags); | |
432 | ||
433 | /** | |
434 | * clear status flags. | |
435 | */ | |
436 | int ClearStatusFlags(int flags); | |
437 | ||
85869391 | 438 | /* TList fConfList; */ |
439 | /* int fbListChanged; */ | |
5ec8e281 | 440 | |
242bb794 | 441 | /** list of tasks */ |
70ed7d01 | 442 | TList fTaskList; // see above |
f23a6e1a | 443 | |
fc455fba | 444 | /** the number of instances of AliHLTSystem */ |
445 | static int fgNofInstances; // see above | |
446 | ||
242bb794 | 447 | /** state of the object */ |
448 | int fState; // see above | |
449 | ||
dee38f1b | 450 | /** chains to be run during reconstruction */ |
451 | TString fChains; //!transient | |
452 | ||
6a8e0bb4 | 453 | /** array of stopwatches */ |
dee38f1b | 454 | TObjArray* fStopwatches; //!transient |
455 | ||
6a8e0bb4 | 456 | /** number of events processed in total */ |
dee38f1b | 457 | int fEventCount; //!transient |
458 | ||
6a8e0bb4 | 459 | /** number of events processed successfully */ |
dee38f1b | 460 | int fGoodEvents; //!transient |
c043fa2c | 461 | |
6a8e0bb4 | 462 | /** array of default libraries */ |
463 | static const char* fgkHLTDefaultLibs[]; //!transient | |
464 | ||
b005ef92 | 465 | /** active kChain handlers (AliHLTOUT::AliHLTOUTHandlerListEntryVector*) */ |
466 | void* fpChainHandlers; //!transient | |
467 | ||
468 | /** active kEsd handlers (AliHLTOUT::AliHLTOUTHandlerListEntryVector*) */ | |
469 | void* fpEsdHandlers; //!transient | |
470 | ||
471 | /** active kProprietary handlers (AliHLTOUT::AliHLTOUTHandlerListEntryVector*) */ | |
472 | void* fpProprietaryHandlers; //!transient | |
473 | ||
474 | ClassDef(AliHLTSystem, 8); | |
f23a6e1a | 475 | }; |
f23a6e1a | 476 | |
c043fa2c | 477 | #endif |