5 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
6 * See cxx source for full Copyright notice */
9 @author Matthias Richter
11 @brief base class for HLT tasks
17 #include "AliHLTDataTypes.h"
18 #include "AliHLTLogging.h"
19 #include "AliHLTDataBuffer.h"
21 struct AliHLTComponent_BlockData;
22 class AliHLTComponent;
23 class AliHLTComponentHandler;
25 /******************************************************************************/
29 * A task collects all the information which is necessary to process a certain
30 * step in the HLT data processing chain.
31 * - the instance of the component
32 * the task object creates and deletes the component object
33 * - the data buffer which receives the result of the component and provides
34 * the data to other tasks/components
35 * - a list of all dependencies
36 * - a list of consumers
37 * - the task object holds an external pointer to the configuration object;
38 * \b Note: the configuration object must exist through the existence of the
42 * @note This class is only used for the @ref alihlt_system.
44 * @ingroup alihlt_system
46 class AliHLTTask : public TObject, public AliHLTLogging {
48 /** standard constructor */
51 @param pConf pointer to configuration descriptor
53 AliHLTTask(AliHLTConfiguration* pConf);
54 /** not a valid copy constructor, defined according to effective C++ style */
55 AliHLTTask(const AliHLTTask&);
56 /** not a valid assignment op, but defined according to effective C++ style */
57 AliHLTTask& operator=(const AliHLTTask&);
59 virtual ~AliHLTTask();
62 * Initialize the task.
63 * The task is initialized with a configuration descriptor. It needs a
64 * component handler instance to create the analysis component.
65 * @param pConf pointer to configuration descriptor, can be NULL if it
66 * was already provided to the constructor
67 * @param pCH the HLT component handler
69 int Init(AliHLTConfiguration* pConf, AliHLTComponentHandler* pCH);
72 * De-Initialize the task.
73 * Final cleanup after the run. The analysis component is deleted.
78 * Get the name of the object.
79 * This is an overridden TObject function in order to return the configuration
80 * name instead of the class name. Enables use of TList standard functions.
81 * @return name of the configuration
83 const char *GetName() const;
86 * Return pointer to configuration.
87 * The tasks holds internally the configuration object.
88 * @return pointer to configuration
90 AliHLTConfiguration* GetConf() const;
93 * Return pointer to component, which the task internally holds.
94 * <b>Never delete this object!!!</b>
95 * @return instance of the component
97 AliHLTComponent* GetComponent() const;
100 * Find a dependency with a certain <i>name id</i>.
101 * Searches in the list of dependencies for a task.
102 * @param id the id of the <b>CONFIGURATION</b><br>
103 * <b>NOTE:</b> the id does NOT specify a COMPONENT
104 * @return pointer to task
106 AliHLTTask* FindDependency(const char* id);
109 * insert block data to the list
110 * the data has to come from a task the current one depends on
112 * -EEXIST : the block data from this task has already been inserted
113 * -ENOENT : no dependencies to the task the data is coming from
116 * this function is most likely depricated
117 int InsertBlockData(AliHLTComponent_BlockData* pBlock, AliHLTTask* pSource);
121 * Add a dependency for the task.
122 * The task maintains a list of other tasks it depends on.
123 * @param pDep pointer to a task descriptor
124 * @return 0 if suceeded, neg error code if failed <br>
125 * -EEXIST : the dependencie exists already
128 int SetDependency(AliHLTTask* pDep);
131 * Return number of unresolved dependencies.
132 * Iterate through all the configurations the task depends on and check
133 * whether a corresponding task is available in the list.
134 * @return number of unresolved dependencies
136 int CheckDependencies();
139 * Check whether the current task depends on the task pTask.
140 * @param pTask pointer to Task descriptor
141 * @return 1 the current task depends on pTask <br>
142 * 0 no dependency <br>
143 * neg. error code if failed
145 int Depends(AliHLTTask* pTask);
148 * Find a target with a certain id.
149 * Tasks which depend on the current task are referred to be <i>targets</i>.
150 * @param id configuration id to search for
151 * @return pointer to task instance
153 AliHLTTask* FindTarget(const char* id);
156 * Insert task into target list.
157 * The target list specifies all the tasks which depend on the current task.
158 * @param pDep pointer task object
159 * @return >=0 if succeeded, neg. error code if failed
161 int SetTarget(AliHLTTask* pDep);
163 // build a monolithic array of block data
164 // @param pBlockData reference to the block data target
165 // @return: array size, pointer to array in the target pTgt
167 /* this function is most likely depricated
168 int BuildBlockDataArray(AliHLTComponent_BlockData*& pBlockData);
172 * Prepare the task for event processing.
173 * The method initializes the Data Buffer and calls the
174 * @ref AliHLTComponent::Init method of the component.<br>
175 * The @ref ProcessTask methode can be called an arbitrary number of times
176 * as soon as the task is in <i>running</i> mode.
181 * Clean-up the task after event processing.
182 * The method cleans up internal structures and calls the
183 * @ref AliHLTComponent::Deinit method of the component.
189 * If all dependencies are resolved the tasks subscribes to the data of
190 * all source tasks, builds the block descriptor and calls the
191 * @ref AliHLTComponent::ProcessEvent method of the component, after
192 * processing, the data blocks are released. <br>
193 * The @ref StartRun method must be called before.
197 // clear the list of source data blocks
198 // the list of source data blocks has to be cleared at the beginning of
200 /* this function is most likely depricated
201 int ClearSourceBlocks();
205 * Determine the number of matching data block between the component and the
206 * data buffer of a consumer component. It checks which data types from the
207 * list of input data types of the consumer component can be provided by data
208 * blocks of the current component.
209 * @param pConsumerTask the task which subscribes to the data
210 * @return number of matching data blocks
212 int GetNofMatchingDataBlocks(const AliHLTTask* pConsumerTask);
215 * Determine the number of matching data types between the component and a
216 * consumer component. It checks which data types from the list of input data
217 * types of the consumer component can be provided by the current component.
218 * @param pConsumerTask the task which subscribes to the data
219 * @return number of matching data types
221 int GetNofMatchingDataTypes(const AliHLTTask* pConsumerTask);
224 * Subscribe to the data of a source task.
225 * The function prepares the block descriptors for subsequent use with the
226 * @ref AliHLTComponent::ProcessEvent method, the method prepares all block
227 * descriptors which match the input data type of the consumer the function
228 * returns the number of blocks which would be prepared in case the target
229 * array is big enough.
230 * @param pConsumerTask the task which subscribes to the data
231 * @param arrayBlockDesc pointer to block descriptor to be filled
232 * @param iArraySize size of the block descriptor array
233 * @return number of matching data blocks, negative error code if failed
235 int Subscribe(const AliHLTTask* pConsumerTask,
236 AliHLTComponent_BlockData* arrayBlockDesc, int iArraySize);
239 * Release a block descriptor.
240 * Notification from consumer task.
241 * @param pBlockDesc descriptor of the data segment
242 * @param pConsumerTask the task which subscribed to the data
243 * @return: >0 if success, negative error code if failed
245 int Release(AliHLTComponent_BlockData* pBlockDesc,
246 const AliHLTTask* pConsumerTask);
249 * Print the status of the task with component, dependencies and targets.
254 * Search task dependency list recursively to find a dependency.
255 * @param id id of the task to search for
256 * @param pTgtList (optional) target list to receive dependency tree
257 * @return 0 if not found, >0 found in the n-th level,
258 dependency list in the target list
260 int FollowDependency(const char* id, TList* pTgtList=NULL);
263 * Print the tree for a certain dependency either from the task or
264 * configuration list.
265 * Each task posseses two "link lists": The configurations are the origin
266 * of the task list. In case of an error during the built of the task list,
267 * the dependencies for the task list might be incomplete. In this case the
268 * configurations can give infomation on the error reason.
269 * @param id id of the dependency to search for
270 * @param bMode 0 (default) from task dependency list, <br>
271 * 1 from configuration list
273 void PrintDependencyTree(const char* id, int bMode=0);
276 * Get number of source tasks.
277 * @return number of source tasks
279 int GetNofSources() {return fListDependencies.GetSize();}
282 /** the configuration descriptor (external pointer) */
283 AliHLTConfiguration* fpConfiguration;
284 /** the component described by this task (created and deleted by the task object) */
285 AliHLTComponent* fpComponent;
286 /** the data buffer for the component processing */
287 AliHLTDataBuffer* fpDataBuffer;
288 /** the list of targets (tasks which depend upon the current one) */
290 /** the list of sources (tasks upon which the current one depends) */
291 TList fListDependencies;
294 * block data array to be passed as argument to the
295 * @ref AliHLTComponent::ProcessEvent method.
296 * Filled through subscription to source tasks (@ref Subscribe).
298 AliHLTComponent_BlockData* fpBlockDataArray;
299 /** size of the block data array */
300 int fBlockDataArraySize;
302 ClassDef(AliHLTTask, 1);