]>
Commit | Line | Data |
---|---|---|
1 | //-*- Mode: C++ -*- | |
2 | // $Id$ | |
3 | ||
4 | #ifndef ALIHLTSYSTEM_H | |
5 | #define ALIHLTSYSTEM_H | |
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 * | |
9 | ||
10 | // @file AliHLTSystem.h | |
11 | // @author Matthias Richter | |
12 | // @date 2007 | |
13 | // @brief Global HLT module management and AliRoot integration. | |
14 | // @note The class is used in Offline (AliRoot) context | |
15 | // | |
16 | ||
17 | /** | |
18 | * @defgroup alihlt_system HLT integration into AliRoot | |
19 | * This section describes the HLT integration into AliRoot. | |
20 | * | |
21 | * @section alihlt_system_intro General Remarks | |
22 | * The HLT analysis is organized in components which can also be used | |
23 | * in off-line processing. Two different types of off-line applications | |
24 | * can be distinguished: | |
25 | * - AliRoot simulation (AliSimulation) | |
26 | * - AliRoot reconstruction (AliReconstruction) | |
27 | * | |
28 | * In either case an HLT chain described by means of AliHLTConfiguration | |
29 | * builds the core of any HLT application. Special components exist, which | |
30 | * emulate the behavior of the components of the HLT on-line data | |
31 | * transportation framework. Together with the analysis components, this | |
32 | * allows the full emulation of the behavoir of HLT analysis chain off-line. | |
33 | * | |
34 | * More details how to setup up such a chain can be found: | |
35 | * - The examples page under @ref tut_hltsystem | |
36 | * | |
37 | * @section alihlt_system_simulation AliRoot simulation | |
38 | * HLT has a special role in the normal data flow of simulation and | |
39 | * reconstruction. Since the HLT reconstruction and analysis runs on-line | |
40 | * on the HLT farm, the raw data produced by HLT as a detector contains | |
41 | * already reconstructed events. Consequently, the HLT response has to be | |
42 | * simulated as well as the data of all other detectors. | |
43 | * | |
44 | * Since the detector data is needed, the HLT simulation is run at the | |
45 | * end of AliSimulation. | |
46 | * | |
47 | * As a matter of fact, HLT always reconstructs data, <em><b>HLT simulation | |
48 | * </b></em> means <em><b>HLT reconstruction embedded into AliRoot</b></em>. | |
49 | * | |
50 | * More Details an be found in the module: | |
51 | * - @ref alihlt_aliroot_simulation | |
52 | * | |
53 | * @section alihlt_system_reconstruction AliRoot reconstruction | |
54 | * | |
55 | * Like all other ALICE detectors, HLT utilizes the AliReconstruction interface | |
56 | * to implement a plugin for the AliRoot reconstruction. The reconstructor can be | |
57 | * used to | |
58 | * - run HLT analysis chains in the AliRoot reconstruction <br> | |
59 | * This option is mainly intended for the development and debugging cycle. HLT | |
60 | * chains can be defined by means of AliHLTConfiguration and can be run either | |
61 | * stand-alone or embedded into the AliReconstruction cycle. | |
62 | * - run the default analysis chains <br> | |
63 | * HLT modules can define default analysis chains to be run during AliRoot | |
64 | * reconstruction. | |
65 | * - handle the HLTOUT data<br> | |
66 | * The HLT output stream contains multiple data blocks produced by the various | |
67 | * components of the HLT chain. Each block might need different and even | |
68 | * detector specific processing, like e.g. the processing of ESD objects or the | |
69 | * handling of compressed data. | |
70 | * | |
71 | * More Details an be found in the module: | |
72 | * - @ref alihlt_aliroot_reconstruction | |
73 | * | |
74 | */ | |
75 | ||
76 | #include "AliHLTLogging.h" | |
77 | #include <TList.h> | |
78 | #include <TString.h> | |
79 | ||
80 | class AliHLTComponentHandler; | |
81 | class AliHLTConfiguration; | |
82 | class AliHLTConfigurationHandler; | |
83 | class AliHLTTask; | |
84 | class AliHLTOUT; | |
85 | class AliHLTOUTTask; | |
86 | class AliHLTControlTask; | |
87 | class AliRunLoader; | |
88 | class AliRawReader; | |
89 | class AliESDEvent; | |
90 | class TObjArray; | |
91 | class TStopwatch; | |
92 | ||
93 | /** | |
94 | * @class AliHLTSystem | |
95 | * Main class for the HLT integration into AliRoot. | |
96 | * @note This class is only used for the @ref alihlt_system. | |
97 | * | |
98 | * @section alihltsystem_overview Main functionality | |
99 | * The class implements the main binding functionality to run HLT | |
100 | * embedded in AliRoot: | |
101 | * - creates handlers for HLT components (AliHLTComponentHandler) | |
102 | * and configurations (AliHLTConfigurationHandler). | |
103 | * - implements the creation of a task list from configurations | |
104 | * - runs the tasks of the task list | |
105 | * - implements the interface to AliHLTReconstructor and AliHLTSimulation | |
106 | * - manages the registered module agents (AliHLTModuleAgent) | |
107 | * | |
108 | * @section alihltsystem_functions Main functions | |
109 | * The following list gives the most important functions, see documentation | |
110 | * of functions for details. | |
111 | * - ScanOptions(const char*) initialize the system from arguments | |
112 | * - BuildTaskList(const char*) build task list for a reconstruction chain | |
113 | * - Run() processing loop for task list | |
114 | * - Reconstruct() interface to AliHLTReconstructor | |
115 | * - ProcessHLTOUT() process an HLTOUT colection | |
116 | * | |
117 | * @section alihltsystem_initialization Initialization | |
118 | * AliHLTSystem is initialized with a list of component libraries which determine | |
119 | * the actual functionality. See ScanOptions() for description of options. | |
120 | * | |
121 | * @section alihltsystem_usage Usage | |
122 | * The class AliHLTPluginBase handles the global instance of AliHLTSystem, | |
123 | * the instance is created and fetched like | |
124 | * <pre> | |
125 | * // setup the HLT system | |
126 | * AliHLTSystem* pHLT=AliHLTPluginBase::GetInstance(); | |
127 | * </pre> | |
128 | * | |
129 | * @ingroup alihlt_system | |
130 | */ | |
131 | class AliHLTSystem : public AliHLTLogging { | |
132 | public: | |
133 | /** default constructor */ | |
134 | AliHLTSystem(AliHLTComponentLogSeverity loglevel=kHLTLogDefault, | |
135 | const char* name="", | |
136 | AliHLTComponentHandler* pCompHandler=NULL, | |
137 | AliHLTConfigurationHandler* pConfHandler=NULL | |
138 | ); | |
139 | /** destructor */ | |
140 | virtual ~AliHLTSystem(); | |
141 | ||
142 | /** | |
143 | * Build a task list | |
144 | * This method is used to build the list of tasks from the configuration | |
145 | * id of a single 'master' configuration. | |
146 | * | |
147 | * Configuration entries might depend upon other configurations. For each | |
148 | * configuration which has not yet been converted into an AliHLTTask, the | |
149 | * method will be called iteratively. Finally, after building all tasks | |
150 | * providing the input for the current one, the task is inserted to the | |
151 | * list of tasks with the InsertTask() method. | |
152 | * | |
153 | * The function can be called multiple times in order to add more than one | |
154 | * chain to the system. | |
155 | * | |
156 | * @param pConf configuration name/id | |
157 | */ | |
158 | int BuildTaskList(const char* pConf); | |
159 | ||
160 | /** | |
161 | * Clean the list of tasks and delete all the task objects. | |
162 | */ | |
163 | int CleanTaskList(); | |
164 | ||
165 | /** | |
166 | * Insert a task to the task list. | |
167 | * The method first checks whether all dependencies are resolved (i.e. exist | |
168 | * already in the task list). During this iteration the cross links between | |
169 | * the tasks are set as well. If all dependencies are resolved, the task is | |
170 | * added at the end of the list. | |
171 | * @param pTask pointer to task to add | |
172 | */ | |
173 | int InsertTask(AliHLTTask* pTask); | |
174 | ||
175 | /** | |
176 | * Add HLTOUT task to the end of the task list. | |
177 | * If one of the specified chains has output, an AliHLTOUTTask is | |
178 | * added which controls the output. All other chains are removed from the | |
179 | * AliHLTOUTTask input. | |
180 | * @return 0 if no task has been added, 1 if task has been added | |
181 | */ | |
182 | int AddHLTOUTTask(const char* chains); | |
183 | ||
184 | AliHLTOUTTask* GetHLTOUTTask() const {return fpHLTOUTTask;} | |
185 | AliHLTComponentHandler* GetComponentHandler() const {return fpComponentHandler;} | |
186 | AliHLTConfigurationHandler* GetConfigurationHandler() const {return fpConfigurationHandler;} | |
187 | ||
188 | /** | |
189 | * Find a task with an id. | |
190 | * @param id CONFIGURATION id (not a COMPONENT id!) | |
191 | */ | |
192 | AliHLTTask* FindTask(const char* id); | |
193 | ||
194 | /** | |
195 | * Print the task list. | |
196 | */ | |
197 | void PrintTaskList(); | |
198 | ||
199 | /** | |
200 | * Run one or more events. | |
201 | * Core of the processing loop. The method expects the task list to be | |
202 | * already created by a previous call to BuildTaskList(const char*) | |
203 | * | |
204 | * All tasks of the list will be subsequently processed for each event. | |
205 | * The system can remain started if the \em bStop parameter is 0. In that | |
206 | * case the system just waits for the next event. A specific call with | |
207 | * nofEvents==0 is needed to execute the stop sequence. | |
208 | * @param iNofEvents number of events | |
209 | * @param bStop stop the chain after processing | |
210 | * @param trgMask ctp trigger mask from the rawreader | |
211 | * @param timestamp timestamp of the event, read from the rawreader | |
212 | * @param eventtype event type, read from the rawreader | |
213 | * @param participatingDetectors the bit flags of the participating detectors | |
214 | * as will we inserted into the Common Data Header. This should only | |
215 | * be used for software event types. | |
216 | * @return number of reconstructed events, neg error code if failed | |
217 | */ | |
218 | int Run(Int_t iNofEvents, int bStop, AliHLTUInt64_t trgMask, | |
219 | AliHLTUInt32_t timestamp, AliHLTUInt32_t eventtype, | |
220 | AliHLTUInt32_t participatingDetectors = 0); | |
221 | ||
222 | /** | |
223 | * Run the tasklist | |
224 | * Somehow the 64bit variable/default value did not work out on mac. | |
225 | * Re-introducing the original function, and forwarding it. | |
226 | */ | |
227 | int Run(Int_t iNofEvents=1, int bStop=1) | |
228 | {return Run(iNofEvents, bStop, 0, 0, 0);} | |
229 | ||
230 | /** | |
231 | * Init all tasks from the list. | |
232 | * The @ref AliHLTTask::Init method is called for each task, the components | |
233 | * will be created. | |
234 | * @return neg error code if failed | |
235 | */ | |
236 | int InitTasks(); | |
237 | ||
238 | /** | |
239 | * Init the stopwatches for all tasks. | |
240 | * @param pStopwatches object array of stopwatches, for types | |
241 | * @see AliHLTComponent::AliHLTStopwatchType | |
242 | * @return neg error code if failed | |
243 | */ | |
244 | int InitBenchmarking(TObjArray* pStopwatches); | |
245 | ||
246 | /** | |
247 | * Stop the stopwatches for all tasks. | |
248 | * @param pStopwatches object array of stopwatches, for types | |
249 | * @see AliHLTComponent::AliHLTStopwatchType | |
250 | * @return neg error code if failed | |
251 | */ | |
252 | int PauseBenchmarking(TObjArray* pStopwatches) const; | |
253 | ||
254 | /** | |
255 | * Continue the stopwatches for all tasks. | |
256 | * @param pStopwatches object array of stopwatches, for types | |
257 | * @see AliHLTComponent::AliHLTStopwatchType | |
258 | * @return neg error code if failed | |
259 | */ | |
260 | int ResumeBenchmarking(TObjArray* pStopwatches) const; | |
261 | ||
262 | /** | |
263 | * Print benchmarking summary. | |
264 | * Optionak: clean up stop watches. | |
265 | * @param pStopwatches object array of stopwatches | |
266 | * @param bClean delete stop watches if 1 | |
267 | * @return neg error code if failed | |
268 | */ | |
269 | int PrintBenchmarking(TObjArray* pStopwatches, int bClean=0) const; | |
270 | ||
271 | /** | |
272 | * Start task list. | |
273 | * The @ref AliHLTTask::StartRun method is called for each task, the | |
274 | * components will be prepared for event processing. | |
275 | * @return neg error code if failed | |
276 | */ | |
277 | int StartTasks(); | |
278 | ||
279 | /** | |
280 | * Process task list. | |
281 | * The @ref AliHLTTask::ProcessTask method is called for each task. | |
282 | * @return neg error code if failed | |
283 | */ | |
284 | int ProcessTasks(Int_t eventNo, AliHLTUInt64_t trgMask, | |
285 | AliHLTUInt32_t timestamp, AliHLTUInt32_t eventtype, | |
286 | AliHLTUInt32_t participatingDetectors = 0); | |
287 | ||
288 | /** | |
289 | * Stop task list. | |
290 | * The @ref AliHLTTask::EndRun method is called for each task, the components | |
291 | * will be cleaned after event processing. | |
292 | * @return neg error code if failed | |
293 | */ | |
294 | int StopTasks(); | |
295 | ||
296 | /** | |
297 | * Send a control event trough the chain. | |
298 | * All data sources in the chain are switched to publish a control event like | |
299 | * SOR or EOR. The event is propagated in the same way as a normal event. | |
300 | * @param dt type of the event | |
301 | */ | |
302 | int SendControlEvent(AliHLTComponentDataType dt); | |
303 | ||
304 | /** | |
305 | * De-init all tasks from the list. | |
306 | * The @ref AliHLTTask::Deinit method is called for each task, the components | |
307 | * will be deleted. | |
308 | * @return neg error code if failed | |
309 | */ | |
310 | int DeinitTasks(); | |
311 | ||
312 | /** | |
313 | * Cleanup all internal objects from HLTOUT processing. | |
314 | * Go through the list of HLTOUT handlers and release them. | |
315 | */ | |
316 | int CleanupHLTOUTHandlers(); | |
317 | ||
318 | /** | |
319 | * The memory allocation function for components. | |
320 | * This function is part of the running environment of the components, | |
321 | * see AliHLTAnalysisEnvironment | |
322 | */ | |
323 | static void* AllocMemory( void* param, unsigned long size ); | |
324 | ||
325 | /** | |
326 | * The allocation function for component EventDoneData. | |
327 | * This function is part of the running environment of the components, | |
328 | * see AliHLTAnalysisEnvironment | |
329 | */ | |
330 | static int AllocEventDoneData( void* param, AliHLTEventID_t eventID, unsigned long size, AliHLTComponentEventDoneData** edd ); | |
331 | ||
332 | /** | |
333 | * AliRoot embedded reconstruction. | |
334 | * Main entry point to execute the HLT reconstruction from AliRoot. Called | |
335 | * either by the AliHLTReconstructor plugin during AliRoot reconstruction | |
336 | * of raw data, or AliHLTSimulation during simulation of data. | |
337 | * | |
338 | * The two cases are distinguished by the availablility of the AliRunLoader | |
339 | * and raw reader. | |
340 | * - AliRoot simulation: AliRunLoader is available and is propagated to the | |
341 | * module agents (AliHLTModuleAgent) to generate the corresponding | |
342 | * configurations and chains, and to the AliHLTOfflineSource components. | |
343 | * raw reader might be available depending on whether raw data was | |
344 | * simulated or not. | |
345 | * - AliRoot reconstruction: raw reader is available and is propagated to | |
346 | * the agents and AliHLTOfflineSource components. AliRunLoader is always | |
347 | * NULL. | |
348 | * | |
349 | * The system remains started after the processing and just waits for the | |
350 | * next event. A specific call with nofEvents==0 is needed to execute the | |
351 | * stop sequence. | |
352 | * | |
353 | * The 'runLoader' and 'rawReader' parameters are propagated to all active | |
354 | * AliHLTOfflineDataSource's and the HLT chain is processed for the given | |
355 | * number of events. If the rawReader is NULL, reconstruction is done on | |
356 | * simulated data, from real data if a RawReader is specified. | |
357 | * | |
358 | * After setting up the system with the reconstruction parameters the | |
359 | * Run() method is called and carries out the processing of the chain. | |
360 | * | |
361 | * @param nofEvents number of events | |
362 | * @param runLoader the AliRoot RunLoader | |
363 | * @param rawReader the AliRoot RawReader | |
364 | * @return number of reconstructed events, neg. error code if failed | |
365 | */ | |
366 | int Reconstruct(int nofEvents, AliRunLoader* runLoader, | |
367 | AliRawReader* rawReader=NULL); | |
368 | ||
369 | /** | |
370 | * Fill ESD for one event. | |
371 | * To be called by the AliHLTReconstructor plugin during the event loop | |
372 | * and FillESD method of the AliRoot reconstruction. | |
373 | * | |
374 | * The method is most likely deprecated as the scheme has been slightly | |
375 | * changed. The ESD is filled by the HLTOUT handlers implemented by the | |
376 | * HLT modules rather than by components within the reconstruction chain. | |
377 | * Still, HLT reconstruction chains can be run during the AliRoot | |
378 | * reconstruction, data produced by such chains is automatically added | |
379 | * to the HLTOUT stream in order to be equivalent to the online HLT. | |
380 | * The HLTOUT is processed during AliReconstruction at the end of the | |
381 | * HLT event processing, literally during the FillESD method of the AliRoot | |
382 | * reconstruction interface. The HLT module must implement HLTOUT handlers | |
383 | * and provide those through the module agent. | |
384 | * | |
385 | * @param eventNo current event no (Note: this event number is just a | |
386 | * processing counter and is not related to the nature/ | |
387 | * origin of the event | |
388 | * @param runLoader the AliRoot runloader | |
389 | * @param esd an AliESDEvent instance | |
390 | * @return neg. error code if failed | |
391 | */ | |
392 | int FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd); | |
393 | ||
394 | /** | |
395 | * Init the HLTOUT instance for the current event. | |
396 | * The instance can be used by other classes to get hold on the data | |
397 | * from HLTOUT. | |
398 | * @param instance instance to be set as the active HLTOUT | |
399 | * @return -EBUSY other active instance already existing | |
400 | */ | |
401 | int InitHLTOUT(AliHLTOUT* instance); | |
402 | ||
403 | /** | |
404 | * Invalidate the HLTOUT instance. | |
405 | * @param instance target variable for the instance | |
406 | * @return -EBUSY if instance in use | |
407 | */ | |
408 | int InvalidateHLTOUT(AliHLTOUT** instance=NULL); | |
409 | ||
410 | /** | |
411 | * Get the HLTOUT instance. | |
412 | * User method for processing classes. To be released after use. | |
413 | * @return pointer to HLTOUT instance | |
414 | */ | |
415 | AliHLTOUT* RequestHLTOUT(); | |
416 | ||
417 | /** | |
418 | * Release the HLTOUT instance after use. | |
419 | * @param instance pointer to instance to be released | |
420 | * @return -ENOENT if instance does not match | |
421 | */ | |
422 | int ReleaseHLTOUT(const AliHLTOUT* instance); | |
423 | ||
424 | /** | |
425 | * Process the HLTOUT data. | |
426 | * The provided instance of AliHLTOUT provides the access to the data. | |
427 | * AliHLTSystem queries all registered module agents (AliHLTModuleAgent) | |
428 | * for the ability to treat a specific data block. As the last step the | |
429 | * ESD object is filled. Please note that the provided ESD is the hltEsd | |
430 | * in case of AliReconstructor (switched in AliReconstruction). | |
431 | */ | |
432 | int ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd); | |
433 | ||
434 | /** | |
435 | * Process all kChain-type data blocks of the HLTOUT data. | |
436 | * Handlers of type AliHLTModuleAgent::kChain are executed as the first | |
437 | * step of the processing. The function is invoked from ProcessHLTOUT(), | |
438 | * eventual output of the chain is added to the HLTOUT collection. | |
439 | */ | |
440 | int ProcessHLTOUTkChain(AliHLTOUT* pHLTOUT); | |
441 | ||
442 | /** | |
443 | * Load component libraries. | |
444 | * @param libs string of blank separated library names | |
445 | * @return neg. error code if failed | |
446 | */ | |
447 | int LoadComponentLibraries(const char* libs); | |
448 | ||
449 | /** | |
450 | * Find a symbol in a dynamically loaded library. | |
451 | * @param library library | |
452 | * @param symbol the symbol to find | |
453 | * @return void pointer to function | |
454 | */ | |
455 | AliHLTfctVoid FindDynamicSymbol(const char* library, const char* symbol); | |
456 | ||
457 | /** | |
458 | * Prepare the HLT system for running. | |
459 | * - module agents are requested to register configurations | |
460 | * - task lists are built from the reconstruction chains of the modules | |
461 | * | |
462 | * @param rawReader instance of the raw reader or NULL | |
463 | * @param runloader optional instance of the AliRunLoader | |
464 | * @return neg. error code if failed <br> | |
465 | * -EBUSY system is in kRunning state <br> | |
466 | */ | |
467 | int Configure(AliRawReader* rawReader, AliRunLoader* runloader=NULL); | |
468 | ||
469 | /** | |
470 | * Old method kept for backward compatibilty. | |
471 | * | |
472 | * @param runloader optional instance of the AliRunLoader | |
473 | * @return neg. error code if failed <br> | |
474 | * -EBUSY system is in kRunning state <br> | |
475 | */ | |
476 | int Configure(AliRunLoader* runloader=NULL); | |
477 | ||
478 | /** | |
479 | * Scan options and load component libraries. | |
480 | * The options consist of blank separated tokens. Libraries can be just | |
481 | * specified by their name, and can be excluded by adding a '!'-mark in | |
482 | * front. <br> | |
483 | * Further options | |
484 | * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting --> | |
485 | * \li loglevel=<i>level</i> <br> | |
486 | * logging level for this processing | |
487 | * \li frameworklog=<i>level</i> <br> | |
488 | * logging level for framework classes | |
489 | * \li alilog=off | |
490 | * disable redirection of log messages to AliLog class | |
491 | * \li config=<i>macro</i> | |
492 | * configuration macro | |
493 | * \li chains=<i>configuration</i> | |
494 | * comma separated list of configurations to be run during local | |
495 | * reconstruction | |
496 | * \li libmode=<i>static,dynamic(default)</i> | |
497 | * libraries are persistent if loaded in mode <i>static</i>, i.e. they | |
498 | * can't be unloaded | |
499 | */ | |
500 | int ScanOptions(const char* options); | |
501 | ||
502 | /** | |
503 | * Reset the HLT system. | |
504 | * Reset is not possible while the system is in running state. | |
505 | * @param bForce force the reset | |
506 | * @return neg. error code if failed <br> | |
507 | * -EBUSY system is in kRunning state <br> | |
508 | */ | |
509 | int Reset(int bForce=0); | |
510 | ||
511 | /** | |
512 | * Load the configurations specified by the module agents. | |
513 | * The runLoader is passed to the agent and allows configuration | |
514 | * selection. | |
515 | * - AliSimulation: runloader valid, raw reader might be valid | |
516 | * - AliReconstruction: runloader always NULL, raw reader valid | |
517 | * | |
518 | * @param rawReader instance of the raw reader or NULL | |
519 | * @param runloader optional instance of the AliRunLoader | |
520 | * @return neg. error code if failed | |
521 | */ | |
522 | int LoadConfigurations(AliRawReader* rawReader, AliRunLoader* runloader=NULL); | |
523 | ||
524 | /** | |
525 | * Get the reconstruction chains from all agents and build the task lists. | |
526 | * AliHLTModuleAgent implementations can define reconstruction chains | |
527 | * depending on the availibility of AliRunLoader and AliRawReader parameters. | |
528 | * | |
529 | * @param rawReader instance of the raw reader or NULL | |
530 | * @param runloader optional instance of the AliRunLoader | |
531 | * @return neg. error code if failed | |
532 | */ | |
533 | int BuildTaskListsFromReconstructionChains(AliRawReader* rawReader, | |
534 | AliRunLoader* runloader=NULL); | |
535 | ||
536 | enum AliHLTSystemState { | |
537 | kUninitialized = 0x0, | |
538 | kLibrariesLoaded = 0x1, | |
539 | kConfigurationLoaded = 0x2, | |
540 | kTaskListCreated = 0x4, | |
541 | kReady = 0x7, | |
542 | kStarted = 0x8, | |
543 | kRunning = 0x10, | |
544 | kError = 0x1000 | |
545 | }; | |
546 | ||
547 | /** | |
548 | * Check status of the system. | |
549 | * @param flag AliHLTSystemState value to check for | |
550 | * @return 1 if set, 0 if not | |
551 | */ | |
552 | int CheckStatus(int flag); | |
553 | ||
554 | /** | |
555 | * Get the current status. | |
556 | * @return status flags of @ref AliHLTSystemState | |
557 | */ | |
558 | int GetStatusFlags(); | |
559 | ||
560 | /** | |
561 | * Set logging level for framework classes. | |
562 | * This sets the local logging level of this instance and all subsequent | |
563 | * framework classes to \em level. | |
564 | * @param level local logging level for the framework classes | |
565 | */ | |
566 | void SetFrameworkLog(AliHLTComponentLogSeverity level); | |
567 | ||
568 | /** | |
569 | * Customized logging function. | |
570 | * The name of the system and pointer is added at the beginning of each | |
571 | * message if name was set. | |
572 | */ | |
573 | int LoggingVarargs(AliHLTComponentLogSeverity severity, | |
574 | const char* originClass, const char* originFunc, | |
575 | const char* file, int line, ... ) const; | |
576 | ||
577 | protected: | |
578 | ||
579 | private: | |
580 | /** copy constructor prohibited */ | |
581 | AliHLTSystem(const AliHLTSystem&); | |
582 | /** assignment operator prohibited */ | |
583 | AliHLTSystem& operator=(const AliHLTSystem&); | |
584 | ||
585 | /** | |
586 | * Build task list from a configuration object. | |
587 | * This method implements the configuration parsing and transformation into | |
588 | * a list of AliHLTTask objects. It has been made private in April 2007. | |
589 | * Use BuildTaskList(const char*) instead. | |
590 | * | |
591 | * @param pConf pointer to configuration to build the task list from | |
592 | */ | |
593 | int BuildTaskList(AliHLTConfiguration* pConf); | |
594 | ||
595 | /** | |
596 | * Set status flags. | |
597 | */ | |
598 | int SetStatusFlags(int flags); | |
599 | ||
600 | /** | |
601 | * clear status flags. | |
602 | */ | |
603 | int ClearStatusFlags(int flags); | |
604 | ||
605 | /// Pointer to an instance of @ref AliHLTComponentHandler. | |
606 | AliHLTComponentHandler* fpComponentHandler; //! transient | |
607 | ||
608 | /// Pointer to an instance of @ref AliHLTConfigurationHandler. | |
609 | AliHLTConfigurationHandler* fpConfigurationHandler; //! transient | |
610 | ||
611 | /** list of tasks */ | |
612 | TList fTaskList; // see above | |
613 | ||
614 | /** the number of instances of AliHLTSystem */ | |
615 | static int fgNofInstances; // see above | |
616 | ||
617 | /** state of the object */ | |
618 | int fState; // see above | |
619 | ||
620 | /** chains to be run during reconstruction */ | |
621 | TString fChains; //!transient | |
622 | ||
623 | /** array of stopwatches */ | |
624 | TObjArray* fStopwatches; //!transient | |
625 | ||
626 | /** number of events processed in total */ | |
627 | int fEventCount; //!transient | |
628 | ||
629 | /** number of events processed successfully */ | |
630 | int fGoodEvents; //!transient | |
631 | ||
632 | /** array of default libraries */ | |
633 | static const char* fgkHLTDefaultLibs[]; //!transient | |
634 | ||
635 | /** active kChain handlers (AliHLTOUT::AliHLTOUTHandlerListEntryVector*) */ | |
636 | void* fpChainHandlers; //!transient | |
637 | ||
638 | /** active kEsd handlers (AliHLTOUT::AliHLTOUTHandlerListEntryVector*) */ | |
639 | void* fpEsdHandlers; //!transient | |
640 | ||
641 | /** active kProprietary handlers (AliHLTOUT::AliHLTOUTHandlerListEntryVector*) */ | |
642 | void* fpProprietaryHandlers; //!transient | |
643 | ||
644 | /** active HLTOUT task for the reconstruction */ | |
645 | AliHLTOUTTask* fpHLTOUTTask; //!transient | |
646 | ||
647 | /** HLTOUT instance for the current event */ | |
648 | AliHLTOUT* fpHLTOUT; //!transient | |
649 | ||
650 | /** HLTOUT use counter */ | |
651 | int fHLTOUTUse; //!transient | |
652 | ||
653 | /** special task to publish the control events */ | |
654 | AliHLTControlTask* fpControlTask; //!transient | |
655 | ||
656 | /** name of this system instance */ | |
657 | TString fName; //!transient | |
658 | ||
659 | /// ECS parameter string | |
660 | TString fECSParams; //!transient | |
661 | ||
662 | /// indicate the argument 'hltout-type' | |
663 | bool fUseHLTOUTComponentTypeGlobal; //!transient | |
664 | ||
665 | ClassDef(AliHLTSystem, 0); | |
666 | }; | |
667 | ||
668 | #endif |