]>
Commit | Line | Data |
---|---|---|
7a436c89 | 1 | // $Id$ |
2 | // splitted from AliHLTConfiguration.cxx,v 1.25 2007/10/12 13:24:47 | |
3 | /************************************************************************** | |
4 | * This file is property of and copyright by the ALICE HLT Project * | |
5 | * ALICE Experiment at CERN, All rights reserved. * | |
6 | * * | |
7 | * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> * | |
8 | * for The ALICE HLT Project. * | |
9 | * * | |
10 | * Permission to use, copy, modify and distribute this software and its * | |
11 | * documentation strictly for non-commercial purposes is hereby granted * | |
12 | * without fee, provided that the above copyright notice appears in all * | |
13 | * copies and that both the copyright notice and this permission notice * | |
14 | * appear in the supporting documentation. The authors make no claims * | |
15 | * about the suitability of this software for any purpose. It is * | |
16 | * provided "as is" without express or implied warranty. * | |
17 | **************************************************************************/ | |
18 | ||
19 | /** @file AliHLTTask.cxx | |
20 | @author Matthias Richter | |
21 | @date | |
22 | @brief Implementation of HLT tasks. | |
23 | */ | |
24 | ||
25 | // see header file for class documentation | |
26 | // or | |
27 | // refer to README to build package | |
28 | // or | |
29 | // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt | |
30 | ||
31 | #if __GNUC__>= 3 | |
32 | using namespace std; | |
33 | #endif | |
34 | ||
35 | #include <cerrno> | |
b46ca65e | 36 | #include <cassert> |
7a436c89 | 37 | #include <iostream> |
38 | #include <string> | |
39 | #include "AliHLTTask.h" | |
40 | #include "AliHLTConfiguration.h" | |
41 | #include "AliHLTComponent.h" | |
42 | #include "AliHLTComponentHandler.h" | |
43 | #include "TList.h" | |
44 | ||
45 | /** ROOT macro for the implementation of ROOT specific class methods */ | |
46 | ClassImp(AliHLTTask) | |
47 | ||
48 | AliHLTTask::AliHLTTask() | |
49 | : | |
50 | fpConfiguration(NULL), | |
51 | fpComponent(NULL), | |
52 | fpDataBuffer(NULL), | |
53 | fListTargets(), | |
54 | fListDependencies(), | |
55 | fBlockDataArray() | |
56 | { | |
57 | // see header file for class documentation | |
58 | // or | |
59 | // refer to README to build package | |
60 | // or | |
61 | // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt | |
62 | } | |
63 | ||
64 | AliHLTTask::AliHLTTask(AliHLTConfiguration* pConf) | |
65 | : | |
66 | fpConfiguration(pConf), | |
67 | fpComponent(NULL), | |
68 | fpDataBuffer(NULL), | |
69 | fListTargets(), | |
70 | fListDependencies(), | |
71 | fBlockDataArray() | |
72 | { | |
73 | // see header file for function documentation | |
74 | } | |
75 | ||
76 | AliHLTTask::~AliHLTTask() | |
77 | { | |
78 | // see header file for function documentation | |
79 | TObjLink* lnk=fListDependencies.FirstLink(); | |
80 | ||
81 | while (lnk!=NULL) { | |
82 | AliHLTTask* pTask=(AliHLTTask*)lnk->GetObject(); | |
83 | pTask->UnsetTarget(this); | |
84 | lnk=lnk->Next(); | |
85 | } | |
86 | lnk=fListTargets.FirstLink(); | |
87 | ||
88 | while (lnk!=NULL) { | |
89 | AliHLTTask* pTask=(AliHLTTask*)lnk->GetObject(); | |
90 | pTask->UnsetDependency(this); | |
91 | lnk=lnk->Next(); | |
92 | } | |
93 | ||
94 | if (fpComponent) delete fpComponent; | |
95 | fpComponent=NULL; | |
96 | } | |
97 | ||
98 | int AliHLTTask::Init(AliHLTConfiguration* pConf, AliHLTComponentHandler* pCH) | |
99 | { | |
100 | // see header file for function documentation | |
101 | int iResult=0; | |
102 | if (fpConfiguration!=NULL && pConf!=NULL && fpConfiguration!=pConf) { | |
103 | HLTWarning("overriding existing reference to configuration object %p (%s) by %p", | |
104 | fpConfiguration, GetName(), pConf); | |
105 | } | |
106 | if (pConf!=NULL) fpConfiguration=pConf; | |
48abe484 | 107 | iResult=CreateComponent(fpConfiguration, pCH, fpComponent); |
108 | if (iResult>=0) { | |
109 | iResult=CustomInit(pCH); | |
110 | } | |
111 | return iResult; | |
112 | } | |
113 | ||
114 | int AliHLTTask::CreateComponent(AliHLTConfiguration* pConf, AliHLTComponentHandler* pCH, AliHLTComponent*& pComponent) const | |
115 | { | |
116 | // see header file for class documentation | |
117 | int iResult=0; | |
118 | if (pConf) { | |
7a436c89 | 119 | if (pCH) { |
120 | int argc=0; | |
121 | const char** argv=NULL; | |
48abe484 | 122 | if ((iResult=pConf->GetArguments(&argv))>=0) { |
7a436c89 | 123 | argc=iResult; // just to make it clear |
124 | // TODO: we have to think about the optional environment parameter, | |
48abe484 | 125 | // currently just set to NULL. |
126 | iResult=pCH->CreateComponent(pConf->GetComponentID(), pComponent); | |
127 | if (pComponent && iResult>=0) { | |
128 | TString description; | |
129 | description.Form("chainid=%s", GetName()); | |
130 | pComponent->SetComponentDescription(description.Data()); | |
131 | const AliHLTAnalysisEnvironment* pEnv=pCH->GetEnvironment(); | |
132 | if ((iResult=pComponent->Init(pEnv, NULL, argc, argv))>=0) { | |
133 | //HLTDebug("component %s (%p) created", pComponent->GetComponentID(), pComponent); | |
134 | } else { | |
135 | HLTError("Initialization of component \"%s\" failed with error %d", pComponent->GetComponentID(), iResult); | |
136 | } | |
7a436c89 | 137 | } else { |
48abe484 | 138 | //HLTError("can not find component \"%s\" (%d)", pConf->GetComponentID(), iResult); |
7a436c89 | 139 | } |
140 | } else { | |
48abe484 | 141 | HLTError("can not get argument list for configuration %s (%s)", pConf->GetName(), pConf->GetComponentID()); |
7a436c89 | 142 | iResult=-EINVAL; |
143 | } | |
144 | } else { | |
145 | HLTError("component handler instance needed for task initialization"); | |
146 | iResult=-EINVAL; | |
147 | } | |
148 | } else { | |
149 | HLTError("configuration object instance needed for task initialization"); | |
150 | iResult=-EINVAL; | |
151 | } | |
152 | return iResult; | |
153 | } | |
154 | ||
155 | int AliHLTTask::Deinit() | |
156 | { | |
157 | // see header file for function documentation | |
158 | int iResult=0; | |
7131ea63 | 159 | CustomCleanup(); |
7a436c89 | 160 | AliHLTComponent* pComponent=GetComponent(); |
161 | fpComponent=NULL; | |
162 | if (pComponent) { | |
163 | //HLTDebug("delete component %s (%p)", pComponent->GetComponentID(), pComponent); | |
164 | pComponent->Deinit(); | |
165 | delete pComponent; | |
166 | } else { | |
167 | HLTWarning("task %s (%p) doesn't seem to be in initialized", GetName(), this); | |
168 | } | |
169 | return iResult; | |
170 | } | |
171 | ||
172 | const char *AliHLTTask::GetName() const | |
173 | { | |
174 | // see header file for function documentation | |
175 | if (fpConfiguration) | |
176 | return fpConfiguration->GetName(); | |
177 | return TObject::GetName(); | |
178 | } | |
179 | ||
180 | AliHLTConfiguration* AliHLTTask::GetConf() const | |
181 | { | |
182 | // see header file for function documentation | |
183 | return fpConfiguration; | |
184 | } | |
185 | ||
186 | AliHLTComponent* AliHLTTask::GetComponent() const | |
187 | { | |
188 | // see header file for function documentation | |
189 | return fpComponent; | |
190 | } | |
191 | ||
192 | AliHLTTask* AliHLTTask::FindDependency(const char* id) | |
193 | { | |
194 | // see header file for function documentation | |
195 | AliHLTTask* pTask=NULL; | |
196 | if (id) { | |
197 | pTask=(AliHLTTask*)fListDependencies.FindObject(id); | |
198 | } | |
199 | return pTask; | |
200 | } | |
201 | ||
202 | int AliHLTTask::FollowDependency(const char* id, TList* pTgtList) | |
203 | { | |
204 | // see header file for function documentation | |
205 | int iResult=0; | |
206 | if (id) { | |
207 | AliHLTTask* pDep=NULL; | |
208 | if ((pDep=(AliHLTTask*)fListDependencies.FindObject(id))!=NULL) { | |
209 | if (pTgtList) pTgtList->Add(pDep); | |
210 | iResult++; | |
211 | } else { | |
212 | TObjLink* lnk=fListDependencies.FirstLink(); | |
213 | while (lnk && iResult==0) { | |
214 | pDep=(AliHLTTask*)lnk->GetObject(); | |
215 | if (pDep) { | |
216 | if ((iResult=pDep->FollowDependency(id, pTgtList))>0) { | |
217 | if (pTgtList) pTgtList->AddFirst(pDep); | |
218 | iResult++; | |
219 | } | |
220 | } else { | |
221 | iResult=-EFAULT; | |
222 | } | |
223 | lnk=lnk->Next(); | |
224 | } | |
225 | } | |
226 | } else { | |
227 | iResult=-EINVAL; | |
228 | } | |
229 | return iResult; | |
230 | } | |
231 | ||
232 | void AliHLTTask::PrintDependencyTree(const char* id, int bFromConfiguration) | |
233 | { | |
234 | // see header file for function documentation | |
235 | HLTLogKeyword("task dependencies"); | |
236 | int iResult=0; | |
237 | TList tgtList; | |
238 | if (bFromConfiguration) { | |
239 | if (fpConfiguration) | |
240 | iResult=fpConfiguration->FollowDependency(id, &tgtList); | |
241 | else | |
242 | iResult=-EFAULT; | |
243 | } else | |
244 | iResult=FollowDependency(id, &tgtList); | |
245 | if (iResult>0) { | |
246 | HLTMessage(" task \"%s\": dependency level %d ", GetName(), iResult); | |
247 | TObjLink* lnk=tgtList.FirstLink(); | |
248 | int i=iResult; | |
249 | char* pSpace = new char[iResult+1]; | |
250 | if (pSpace) { | |
251 | memset(pSpace, 32, iResult); | |
252 | pSpace[i]=0; | |
253 | while (lnk) { | |
254 | TObject* obj=lnk->GetObject(); | |
255 | HLTMessage(" %s^-- %s ", &pSpace[i--], obj->GetName()); | |
256 | lnk=lnk->Next(); | |
257 | } | |
258 | delete [] pSpace; | |
259 | } else { | |
260 | iResult=-ENOMEM; | |
261 | } | |
262 | } | |
263 | } | |
264 | ||
265 | int AliHLTTask::SetDependency(AliHLTTask* pDep) | |
266 | { | |
267 | // see header file for function documentation | |
268 | int iResult=0; | |
269 | if (pDep) { | |
270 | if (FindDependency(pDep->GetName())==NULL) { | |
271 | fListDependencies.Add(pDep); | |
272 | } else { | |
273 | iResult=-EEXIST; | |
274 | } | |
275 | } else { | |
276 | iResult=-EINVAL; | |
277 | } | |
278 | return iResult; | |
279 | } | |
280 | ||
281 | int AliHLTTask::UnsetDependency(AliHLTTask* pDep) | |
282 | { | |
283 | // see header file for function documentation | |
284 | fListDependencies.Remove(pDep); | |
285 | if (fpConfiguration) { | |
286 | fpConfiguration->InvalidateSources(); | |
287 | } | |
288 | return 0; | |
289 | } | |
290 | ||
291 | int AliHLTTask::CheckDependencies() | |
292 | { | |
293 | // see header file for function documentation | |
294 | int iResult=0; | |
295 | AliHLTConfiguration* pSrc=fpConfiguration->GetFirstSource(); | |
296 | while (pSrc) { | |
297 | if (FindDependency(pSrc->GetName())==NULL) { | |
298 | //HLTDebug("dependency \"%s\" unresolved", pSrc->GetName()); | |
299 | iResult++; | |
300 | } | |
301 | pSrc=fpConfiguration->GetNextSource(); | |
302 | } | |
303 | return iResult; | |
304 | } | |
305 | ||
306 | ||
307 | int AliHLTTask::Depends(AliHLTTask* pTask) | |
308 | { | |
309 | // see header file for function documentation | |
310 | int iResult=0; | |
311 | if (pTask) { | |
312 | if (fpConfiguration) { | |
313 | iResult=fpConfiguration->GetSource(pTask->GetName())!=NULL; | |
314 | if (iResult>0) { | |
315 | //HLTDebug("task \"%s\" depends on \"%s\"", GetName(), pTask->GetName()); | |
316 | } else { | |
317 | //HLTDebug("task \"%s\" independend of \"%s\"", GetName(), pTask->GetName()); | |
318 | } | |
319 | } else { | |
320 | iResult=-EFAULT; | |
321 | } | |
322 | } else { | |
323 | iResult=-EINVAL; | |
324 | } | |
325 | return iResult; | |
326 | } | |
327 | ||
328 | AliHLTTask* AliHLTTask::FindTarget(const char* id) | |
329 | { | |
330 | // see header file for function documentation | |
331 | AliHLTTask* pTask=NULL; | |
332 | if (id) { | |
333 | pTask=(AliHLTTask*)fListTargets.FindObject(id); | |
334 | } | |
335 | return pTask; | |
336 | } | |
337 | ||
338 | int AliHLTTask::SetTarget(AliHLTTask* pTgt) | |
339 | { | |
340 | // see header file for function documentation | |
341 | int iResult=0; | |
342 | if (pTgt) { | |
343 | if (FindTarget(pTgt->GetName())==NULL) { | |
344 | fListTargets.Add(pTgt); | |
345 | } else { | |
346 | iResult=-EEXIST; | |
347 | } | |
348 | } else { | |
349 | iResult=-EINVAL; | |
350 | } | |
351 | return iResult; | |
352 | } | |
353 | ||
354 | int AliHLTTask::UnsetTarget(AliHLTTask* pTarget) | |
355 | { | |
356 | // see header file for function documentation | |
357 | fListTargets.Remove(pTarget); | |
358 | return 0; | |
359 | } | |
360 | ||
361 | int AliHLTTask::StartRun() | |
362 | { | |
363 | // see header file for function documentation | |
364 | int iResult=0; | |
365 | int iNofInputDataBlocks=0; | |
366 | AliHLTComponent* pComponent=GetComponent(); | |
367 | if (pComponent) { | |
368 | // determine the number of input data blocks provided from the source tasks | |
f7561f8d | 369 | { // set scope for lnk as a local variable |
7a436c89 | 370 | TObjLink* lnk=fListDependencies.FirstLink(); |
371 | while (lnk && iResult>=0) { | |
372 | AliHLTTask* pSrcTask=(AliHLTTask*)lnk->GetObject(); | |
373 | if (pSrcTask) { | |
374 | if ((iResult=pSrcTask->GetNofMatchingDataTypes(this))>0) { | |
375 | iNofInputDataBlocks+=iResult; | |
376 | } else if (iResult==0) { | |
377 | HLTWarning("source task %s (%p) does not provide any matching data type for task %s (%p)", pSrcTask->GetName(), pSrcTask, GetName(), this); | |
378 | } else { | |
379 | HLTError("task %s (%p): error getting matching data types for source task %s (%p)", GetName(), this, pSrcTask->GetName(), pSrcTask); | |
380 | iResult=-EFAULT; | |
381 | } | |
382 | } | |
383 | lnk=lnk->Next(); | |
384 | } | |
f7561f8d | 385 | } |
7a436c89 | 386 | if (iResult>=0) { |
387 | if (fBlockDataArray.size()>0) { | |
388 | HLTWarning("block data array for task %s (%p) was not cleaned", GetName(), this); | |
457ec821 | 389 | fBlockDataArray.clear(); |
7a436c89 | 390 | } |
391 | ||
392 | // component init | |
393 | // the initialization of the component is done by the ComponentHandler after creation | |
394 | // of the component. | |
a3c9b745 | 395 | //iResult=Init( AliHLTAnalysisEnvironment* environ, void* environ_param, int argc, const char** argv ); |
7a436c89 | 396 | |
7a436c89 | 397 | // allocate the data buffer, which controls the output buffer and subscriptions |
398 | if (iResult>=0) { | |
399 | fpDataBuffer=new AliHLTDataBuffer; | |
400 | if (fpDataBuffer!=NULL) { | |
dba03d72 | 401 | fpDataBuffer->SetLocalLoggingLevel(GetLocalLoggingLevel()); |
7a436c89 | 402 | HLTDebug("created data buffer %p for task %s (%p)", fpDataBuffer, GetName(), this); |
403 | TObjLink* lnk=fListTargets.FirstLink(); | |
404 | while (lnk && iResult>=0) { | |
405 | AliHLTTask* pTgtTask=(AliHLTTask*)lnk->GetObject(); | |
406 | if (pTgtTask) { | |
407 | if ((iResult=fpDataBuffer->SetConsumer(pTgtTask->GetComponent()))>=0) { | |
408 | } | |
409 | } else { | |
410 | break; | |
411 | iResult=-EFAULT; | |
412 | } | |
413 | lnk=lnk->Next(); | |
414 | } | |
415 | } else { | |
416 | HLTFatal("can not create data buffer object, memory allocation failed"); | |
417 | iResult=-ENOMEM; | |
418 | } | |
419 | } | |
420 | } | |
457ec821 | 421 | if (iResult>=0) { |
422 | // send the SOR event | |
423 | ||
424 | } | |
7a436c89 | 425 | } else { |
426 | HLTError("task %s (%p) does not have a component", GetName(), this); | |
427 | iResult=-EFAULT; | |
428 | } | |
429 | return iResult; | |
430 | } | |
431 | ||
432 | int AliHLTTask::EndRun() | |
433 | { | |
434 | // see header file for function documentation | |
435 | int iResult=0; | |
436 | if (fBlockDataArray.size()>0) { | |
457ec821 | 437 | fBlockDataArray.clear(); |
7a436c89 | 438 | } |
439 | if (fpDataBuffer) { | |
440 | AliHLTDataBuffer* pBuffer=fpDataBuffer; | |
441 | fpDataBuffer=NULL; | |
442 | delete pBuffer; | |
443 | } | |
444 | return iResult; | |
445 | } | |
446 | ||
48abe484 | 447 | int AliHLTTask::ProcessTask(Int_t eventNo, AliHLTUInt32_t eventType) |
7a436c89 | 448 | { |
449 | // see header file for function documentation | |
450 | int iResult=0; | |
451 | AliHLTComponent* pComponent=GetComponent(); | |
452 | if (pComponent && fpDataBuffer) { | |
453 | HLTDebug("Processing task %s (%p) fpDataBuffer %p", GetName(), this, fpDataBuffer); | |
454 | fpDataBuffer->Reset(); | |
455 | int iSourceDataBlock=0; | |
456 | int iInputDataVolume=0; | |
457 | ||
458 | AliHLTTask* pSrcTask=NULL; | |
b46ca65e | 459 | AliHLTTaskPList subscribedTaskList; |
7a436c89 | 460 | TObjLink* lnk=fListDependencies.FirstLink(); |
461 | ||
457ec821 | 462 | // instances of SOR and EOR events to be kept |
463 | int iSOR=-1; | |
464 | int iEOR=-1; | |
465 | ||
7a436c89 | 466 | // subscribe to all source tasks |
457ec821 | 467 | fBlockDataArray.clear(); |
7a436c89 | 468 | while (lnk && iResult>=0) { |
469 | pSrcTask=(AliHLTTask*)lnk->GetObject(); | |
470 | if (pSrcTask) { | |
471 | int iMatchingDB=pSrcTask->GetNofMatchingDataBlocks(this); | |
457ec821 | 472 | if (iMatchingDB<0) { |
473 | HLTError("task %s (%p): error getting no of matching data blocks from task %s (%p), error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iMatchingDB); | |
474 | iResult=iMatchingDB; | |
475 | break; | |
476 | } else if (iMatchingDB==0) { | |
477 | HLTDebug("source task %s (%p) does not provide any matching data type for task %s (%p)", pSrcTask->GetName(), pSrcTask, GetName(), this); | |
7a436c89 | 478 | } |
457ec821 | 479 | if ((iResult=pSrcTask->Subscribe(this, fBlockDataArray))>=0) { |
480 | iSOR=iEOR=-1; | |
481 | AliHLTComponentBlockDataList::iterator block=fBlockDataArray.begin(); | |
482 | for (int i=0; block!=fBlockDataArray.end(); i++) { | |
483 | bool bRemove=0; | |
484 | bRemove|=(*block).fDataType==kAliHLTDataTypeSOR && !(iSOR<0 && (iSOR=i)>=0); | |
485 | bRemove|=(*block).fDataType==kAliHLTDataTypeEOR && !(iEOR<0 && (iEOR=i)>=0); | |
486 | //HLTInfo("block %d, iSOR=%d iEOR=%d remove=%d", i, iSOR, iEOR, bRemove); | |
487 | if (i<iSourceDataBlock) { | |
488 | assert(!bRemove); | |
489 | } else if (bRemove) { | |
490 | HLTDebug("remove duplicated event %s (%d)", AliHLTComponent::DataType2Text((*block).fDataType).c_str(), i); | |
491 | pSrcTask->Release(&(*block), this); | |
492 | block=fBlockDataArray.erase(block); | |
493 | continue; | |
494 | } else { | |
495 | iInputDataVolume+=(*block).fSize; | |
7a436c89 | 496 | // put the source task as many times into the list as it provides data blocks |
497 | // makes the bookkeeping for the data release easier | |
b46ca65e | 498 | subscribedTaskList.push_back(pSrcTask); |
457ec821 | 499 | } |
500 | block++; | |
7a436c89 | 501 | } |
502 | HLTDebug("Task %s (%p) successfully subscribed to %d data block(s) of task %s (%p)", GetName(), this, iResult, pSrcTask->GetName(), pSrcTask); | |
457ec821 | 503 | iSourceDataBlock=fBlockDataArray.size(); |
7a436c89 | 504 | iResult=0; |
505 | } else { | |
506 | HLTError("Task %s (%p): subscription to task %s (%p) failed with error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iResult); | |
507 | iResult=-EFAULT; | |
508 | } | |
509 | } else { | |
510 | HLTFatal("fatal internal error in ROOT list handling"); | |
511 | iResult=-EFAULT; | |
512 | } | |
513 | lnk=lnk->Next(); | |
457ec821 | 514 | } |
7a436c89 | 515 | |
516 | // process the event | |
517 | int iNofTrial=0; // repeat processing if component returns -ENOSPC | |
518 | AliHLTUInt32_t size=0; | |
519 | if (iResult>=0) { | |
520 | do { | |
032c5e5e | 521 | long unsigned int iOutputDataSize=0; |
522 | AliHLTConfiguration* pConf=GetConf(); | |
032c5e5e | 523 | // check if there was a buffer size specified, query output size |
524 | // estimator from component otherwize | |
525 | if (pConf && pConf->GetOutputBufferSize()>=0) { | |
526 | iOutputDataSize=pConf->GetOutputBufferSize(); | |
527 | } else { | |
7a436c89 | 528 | long unsigned int iConstBase=0; |
529 | double fInputMultiplier=0; | |
530 | if (pComponent->GetComponentType()!=AliHLTComponent::kSink) | |
531 | pComponent->GetOutputDataSize(iConstBase, fInputMultiplier); | |
532 | if (fInputMultiplier<0) { | |
533 | HLTWarning("ignoring negative input multiplier"); | |
534 | fInputMultiplier=0; | |
535 | } | |
032c5e5e | 536 | iOutputDataSize=int(fInputMultiplier*iInputDataVolume) + iConstBase; |
7a436c89 | 537 | //HLTDebug("task %s: reqired output size %d", GetName(), iOutputDataSize); |
032c5e5e | 538 | } |
7a436c89 | 539 | if (iNofTrial>0) { |
540 | // dont process again if the buffer size is the same | |
541 | if (size==iOutputDataSize) break; | |
542 | HLTInfo("processing task %s again with buffer size %d", GetName(), iOutputDataSize); | |
543 | } | |
544 | AliHLTUInt8_t* pTgtBuffer=NULL; | |
545 | if (iOutputDataSize>0) pTgtBuffer=fpDataBuffer->GetTargetBuffer(iOutputDataSize); | |
546 | //HLTDebug("provided raw buffer %p", pTgtBuffer); | |
547 | AliHLTComponentEventData evtData; | |
548 | AliHLTComponent::FillEventData(evtData); | |
48abe484 | 549 | if (eventNo>=0) |
550 | evtData.fEventID=(AliHLTEventID_t)eventNo; | |
7a436c89 | 551 | AliHLTComponentTriggerData trigData; |
804007a6 | 552 | trigData.fStructSize=sizeof(trigData); |
553 | trigData.fDataSize=0; | |
554 | trigData.fData=NULL; | |
7a436c89 | 555 | size=iOutputDataSize; |
556 | AliHLTUInt32_t outputBlockCnt=0; | |
557 | AliHLTComponentBlockData* outputBlocks=NULL; | |
a0aeb701 | 558 | AliHLTComponentEventDoneData* edd=NULL; |
7a436c89 | 559 | if (pTgtBuffer!=NULL || iOutputDataSize==0) { |
48abe484 | 560 | // add event type data block |
561 | AliHLTComponentBlockData eventTypeBlock; | |
562 | AliHLTComponent::FillBlockData(eventTypeBlock); | |
563 | // Note: no payload! | |
564 | eventTypeBlock.fDataType=kAliHLTDataTypeEvent; | |
565 | eventTypeBlock.fSpecification=eventType; | |
566 | fBlockDataArray.push_back(eventTypeBlock); | |
567 | ||
568 | // process | |
569 | evtData.fBlockCnt=fBlockDataArray.size(); | |
7a436c89 | 570 | iResult=pComponent->ProcessEvent(evtData, &fBlockDataArray[0], trigData, pTgtBuffer, size, outputBlockCnt, outputBlocks, edd); |
571 | HLTDebug("task %s: component %s ProcessEvent finnished (%d): size=%d blocks=%d", GetName(), pComponent->GetComponentID(), iResult, size, outputBlockCnt); | |
48abe484 | 572 | |
573 | // remove event data block | |
574 | fBlockDataArray.pop_back(); | |
575 | ||
b46ca65e | 576 | if (iResult>=0 && outputBlocks) { |
457ec821 | 577 | if (fListTargets.First()!=NULL) { |
578 | AliHLTComponentBlockDataList segments; | |
579 | for (AliHLTUInt32_t oblock=0; oblock<outputBlockCnt; oblock++) { | |
580 | AliHLTUInt32_t iblock=0; | |
48abe484 | 581 | for (; iblock<fBlockDataArray.size(); iblock++) { |
457ec821 | 582 | if (fBlockDataArray[iblock].fPtr==outputBlocks[oblock].fPtr) { |
583 | assert(subscribedTaskList[iblock]!=NULL); | |
584 | if (subscribedTaskList[iblock]==NULL) continue; | |
585 | HLTDebug("forward segment %d (source task %s %p) to data buffer %p", iblock, pSrcTask->GetName(), pSrcTask, fpDataBuffer); | |
586 | fpDataBuffer->Forward(subscribedTaskList[iblock], &fBlockDataArray[iblock]); | |
587 | subscribedTaskList[iblock]=NULL; // not to be released in the loop further down | |
588 | break; | |
589 | } | |
590 | } | |
48abe484 | 591 | if (iblock==fBlockDataArray.size()) segments.push_back(outputBlocks[oblock]); |
042b7a5d | 592 | } |
593 | if (pTgtBuffer && segments.size()>0) { | |
594 | iResult=fpDataBuffer->SetSegments(pTgtBuffer, &segments[0], segments.size()); | |
b46ca65e | 595 | } |
457ec821 | 596 | } else { |
597 | // no forwarding, actually we dont even need to keep the data, this is a | |
598 | // dead end (fListTargets empty) | |
599 | //iResult=fpDataBuffer->SetSegments(pTgtBuffer, outputBlocks, outputBlockCnt); | |
b46ca65e | 600 | } |
7a436c89 | 601 | delete [] outputBlocks; outputBlocks=NULL; outputBlockCnt=0; |
602 | } else { | |
603 | fpDataBuffer->Reset(); | |
604 | } | |
457ec821 | 605 | if (fListTargets.First()!=NULL) { |
606 | if (iSOR>=0 && subscribedTaskList[iSOR]!=NULL) { | |
607 | HLTDebug("forward SOR event segment %d (source task %s %p) to data buffer %p", iSOR, pSrcTask->GetName(), pSrcTask, fpDataBuffer); | |
608 | fpDataBuffer->Forward(subscribedTaskList[iSOR], &fBlockDataArray[iSOR]); | |
609 | subscribedTaskList[iSOR]=NULL; // not to be released in the loop further down | |
610 | } | |
611 | if (iEOR>=0 && subscribedTaskList[iEOR]!=NULL) { | |
612 | HLTDebug("forward EOR event (%s) segment %d (source task %s %p) to data buffer %p", AliHLTComponent::DataType2Text(fBlockDataArray[iEOR].fDataType).c_str(), iEOR, pSrcTask->GetName(), pSrcTask, fpDataBuffer); | |
613 | fpDataBuffer->Forward(subscribedTaskList[iEOR], &fBlockDataArray[iEOR]); | |
614 | subscribedTaskList[iEOR]=NULL; // not to be released in the loop further down | |
615 | } | |
616 | } | |
7a436c89 | 617 | } else { |
618 | HLTError("task %s: no target buffer available", GetName()); | |
619 | iResult=-EFAULT; | |
620 | } | |
621 | } while (iResult==-ENOSPC && iNofTrial++<1); | |
622 | } | |
623 | ||
624 | // now release all buffers which we have subscribed to | |
625 | iSourceDataBlock=0; | |
b46ca65e | 626 | AliHLTTaskPList::iterator element; |
627 | while ((element=subscribedTaskList.begin())!=subscribedTaskList.end()) { | |
628 | pSrcTask=*element; | |
7a436c89 | 629 | if (pSrcTask) { |
630 | int iTempRes=0; | |
631 | if ((iTempRes=pSrcTask->Release(&fBlockDataArray[iSourceDataBlock], this))>=0) { | |
632 | HLTDebug("Task %s (%p) successfully released segment of task %s (%p)", GetName(), this, pSrcTask->GetName(), pSrcTask); | |
633 | } else { | |
634 | HLTError("Task %s (%p): realease of task %s (%p) failed with error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iTempRes); | |
635 | } | |
7a436c89 | 636 | } |
b46ca65e | 637 | subscribedTaskList.erase(element); |
7a436c89 | 638 | iSourceDataBlock++; |
639 | } | |
b46ca65e | 640 | if (subscribedTaskList.size()>0) { |
7a436c89 | 641 | HLTError("task %s (%p): could not release all data buffers", GetName(), this); |
642 | } | |
643 | } else { | |
644 | HLTError("task %s (%p): internal failure (not initialized component %p, data buffer %p)", GetName(), this, fpComponent, fpDataBuffer); | |
645 | iResult=-EFAULT; | |
646 | } | |
647 | return iResult; | |
648 | } | |
649 | ||
650 | int AliHLTTask::GetNofMatchingDataBlocks(const AliHLTTask* pConsumerTask) const | |
651 | { | |
652 | // see header file for function documentation | |
653 | int iResult=0; | |
654 | if (pConsumerTask) { | |
655 | if (fpDataBuffer) { | |
656 | iResult=fpDataBuffer->FindMatchingDataBlocks(pConsumerTask->GetComponent(), NULL); | |
657 | } else { | |
658 | HLTFatal("internal data buffer missing"); | |
659 | iResult=-EFAULT; | |
660 | } | |
661 | } else { | |
662 | iResult=-EINVAL; | |
663 | } | |
664 | return iResult; | |
665 | } | |
666 | ||
667 | int AliHLTTask::GetNofMatchingDataTypes(const AliHLTTask* pConsumerTask) const | |
668 | { | |
669 | // see header file for function documentation | |
670 | int iResult=0; | |
671 | if (pConsumerTask) { | |
672 | AliHLTComponent* pComponent=GetComponent(); | |
673 | if (!pComponent) { | |
674 | // init ? | |
675 | HLTError("component not initialized"); | |
676 | iResult=-EFAULT; | |
677 | } | |
678 | if (pComponent) { | |
679 | iResult=pComponent->FindMatchingDataTypes(pConsumerTask->GetComponent(), NULL); | |
680 | } else { | |
681 | HLTFatal("task initialization failed"); | |
682 | iResult=-EFAULT; | |
683 | } | |
684 | } else { | |
685 | iResult=-EINVAL; | |
686 | } | |
687 | return iResult; | |
688 | } | |
689 | ||
457ec821 | 690 | int AliHLTTask::Subscribe(const AliHLTTask* pConsumerTask, AliHLTComponentBlockDataList& blockDescList) |
7a436c89 | 691 | { |
692 | // see header file for function documentation | |
693 | int iResult=0; | |
694 | if (pConsumerTask) { | |
695 | if (fpDataBuffer) { | |
457ec821 | 696 | iResult=fpDataBuffer->Subscribe(pConsumerTask->GetComponent(), blockDescList); |
7a436c89 | 697 | } else { |
698 | HLTFatal("internal data buffer missing"); | |
699 | iResult=-EFAULT; | |
700 | } | |
701 | } else { | |
702 | iResult=-EINVAL; | |
703 | } | |
704 | return iResult; | |
705 | } | |
706 | ||
707 | int AliHLTTask::Release(AliHLTComponentBlockData* pBlockDesc, const AliHLTTask* pConsumerTask) | |
708 | { | |
709 | // see header file for function documentation | |
710 | int iResult=0; | |
711 | if (pConsumerTask && pBlockDesc) { | |
712 | if (fpDataBuffer) { | |
b46ca65e | 713 | iResult=fpDataBuffer->Release(pBlockDesc, pConsumerTask->GetComponent(), this); |
7a436c89 | 714 | } else { |
715 | HLTFatal("internal data buffer missing"); | |
716 | iResult=-EFAULT; | |
717 | } | |
718 | } else { | |
719 | iResult=-EINVAL; | |
720 | } | |
721 | return iResult; | |
722 | } | |
723 | ||
724 | void AliHLTTask::PrintStatus() | |
725 | { | |
726 | // see header file for function documentation | |
727 | HLTLogKeyword("task properties"); | |
728 | AliHLTComponent* pComponent=GetComponent(); | |
729 | if (pComponent) { | |
730 | HLTMessage(" component: %s (%p)", pComponent->GetComponentID(), pComponent); | |
731 | } else { | |
732 | HLTMessage(" no component set!"); | |
733 | } | |
734 | if (fpConfiguration) { | |
735 | AliHLTConfiguration* pSrc=fpConfiguration->GetFirstSource(); | |
736 | while (pSrc) { | |
737 | const char* pQualifier="unresolved"; | |
738 | if (FindDependency(pSrc->GetName())) | |
739 | pQualifier="resolved"; | |
740 | HLTMessage(" source: %s (%s)", pSrc->GetName(), pQualifier); | |
741 | pSrc=fpConfiguration->GetNextSource(); | |
742 | } | |
743 | TObjLink* lnk = fListTargets.FirstLink(); | |
744 | while (lnk) { | |
745 | TObject *obj = lnk->GetObject(); | |
746 | HLTMessage(" target: %s", obj->GetName()); | |
747 | lnk = lnk->Next(); | |
748 | } | |
749 | } else { | |
750 | HLTMessage(" task \"%s\" not initialized", GetName()); | |
751 | } | |
752 | } | |
7131ea63 | 753 | |
754 | int AliHLTTask::CustomInit(AliHLTComponentHandler* /*pCH*/) | |
755 | { | |
756 | // default implementation nothing to do | |
757 | return 0; | |
758 | } | |
759 | ||
760 | int AliHLTTask::CustomCleanup() | |
761 | { | |
762 | // default implementation nothing to do | |
763 | return 0; | |
764 | } |