improved the look of the figure to compare the different methods
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTTask.cxx
CommitLineData
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
32using 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 */
46ClassImp(AliHLTTask)
47
48AliHLTTask::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
64AliHLTTask::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
76AliHLTTask::~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
98int 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) {
97d2b87a 103 HLTWarning("overriding existing reference to configuration object %p by %p",
104 fpConfiguration, pConf);
7a436c89 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
114int 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
155int 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 {
97d2b87a 167 HLTWarning("task doesn't seem to be in initialized");
7a436c89 168 }
169 return iResult;
170}
171
172const 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
180AliHLTConfiguration* AliHLTTask::GetConf() const
181{
182 // see header file for function documentation
183 return fpConfiguration;
184}
185
186AliHLTComponent* AliHLTTask::GetComponent() const
187{
188 // see header file for function documentation
189 return fpComponent;
190}
191
192AliHLTTask* 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
202int 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
232void 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) {
97d2b87a 246 HLTMessage(" dependency level %d ", iResult);
7a436c89 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
265int 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
281int 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
291int 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
307int 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
328AliHLTTask* 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
338int 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
354int AliHLTTask::UnsetTarget(AliHLTTask* pTarget)
355{
356 // see header file for function documentation
357 fListTargets.Remove(pTarget);
358 return 0;
359}
360
361int 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
432int 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 447int 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
3ee8781a 518 AliHLTUInt32_t iLastOutputDataSize=0;
7a436c89 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;
53f79557 530 if (pComponent->GetComponentType()!=AliHLTComponent::kSink) {
7a436c89 531 pComponent->GetOutputDataSize(iConstBase, fInputMultiplier);
53f79557 532 // add a small margin to the buffer to allow optional component
533 // statistics
534 iConstBase+=100;
535 }
7a436c89 536 if (fInputMultiplier<0) {
537 HLTWarning("ignoring negative input multiplier");
538 fInputMultiplier=0;
539 }
032c5e5e 540 iOutputDataSize=int(fInputMultiplier*iInputDataVolume) + iConstBase;
7a436c89 541 //HLTDebug("task %s: reqired output size %d", GetName(), iOutputDataSize);
032c5e5e 542 }
7a436c89 543 if (iNofTrial>0) {
544 // dont process again if the buffer size is the same
3ee8781a 545 if (iLastOutputDataSize==iOutputDataSize) break;
97d2b87a 546 HLTImportant("processing event %d again with buffer size %d", eventNo, iOutputDataSize);
7a436c89 547 }
548 AliHLTUInt8_t* pTgtBuffer=NULL;
549 if (iOutputDataSize>0) pTgtBuffer=fpDataBuffer->GetTargetBuffer(iOutputDataSize);
550 //HLTDebug("provided raw buffer %p", pTgtBuffer);
551 AliHLTComponentEventData evtData;
552 AliHLTComponent::FillEventData(evtData);
48abe484 553 if (eventNo>=0)
554 evtData.fEventID=(AliHLTEventID_t)eventNo;
7a436c89 555 AliHLTComponentTriggerData trigData;
804007a6 556 trigData.fStructSize=sizeof(trigData);
557 trigData.fDataSize=0;
558 trigData.fData=NULL;
3ee8781a 559 iLastOutputDataSize=iOutputDataSize;
560 AliHLTUInt32_t size=iOutputDataSize;
7a436c89 561 AliHLTUInt32_t outputBlockCnt=0;
562 AliHLTComponentBlockData* outputBlocks=NULL;
a0aeb701 563 AliHLTComponentEventDoneData* edd=NULL;
7a436c89 564 if (pTgtBuffer!=NULL || iOutputDataSize==0) {
48abe484 565 // add event type data block
7e81df35 566 // the block is removed immediately after processing from the list
48abe484 567 AliHLTComponentBlockData eventTypeBlock;
568 AliHLTComponent::FillBlockData(eventTypeBlock);
569 // Note: no payload!
570 eventTypeBlock.fDataType=kAliHLTDataTypeEvent;
571 eventTypeBlock.fSpecification=eventType;
572 fBlockDataArray.push_back(eventTypeBlock);
573
574 // process
575 evtData.fBlockCnt=fBlockDataArray.size();
7a436c89 576 iResult=pComponent->ProcessEvent(evtData, &fBlockDataArray[0], trigData, pTgtBuffer, size, outputBlockCnt, outputBlocks, edd);
97d2b87a 577 HLTDebug("component %s ProcessEvent finnished (%d): size=%d blocks=%d", pComponent->GetComponentID(), iResult, size, outputBlockCnt);
48abe484 578
579 // remove event data block
580 fBlockDataArray.pop_back();
581
7e81df35 582 // check for forwarded blocks.
583 // loop over all output blocks and check
584 // 1. for duplicate blocks (pointing to same location in output buffer
585 // or to the same buffer)
586 // 2. for blocks forwarded from the input.
b46ca65e 587 if (iResult>=0 && outputBlocks) {
457ec821 588 if (fListTargets.First()!=NULL) {
589 AliHLTComponentBlockDataList segments;
590 for (AliHLTUInt32_t oblock=0; oblock<outputBlockCnt; oblock++) {
7e81df35 591 // consistency check for data reference
0ad4ebd1 592 if (outputBlocks[oblock].fPtr!=NULL && outputBlocks[oblock].fPtr!=pTgtBuffer &&
593 outputBlocks[oblock].fOffset!=0) {
7e81df35 594 HLTWarning("output block %s 0x%08x has inconsistent data reference ptr=%p offset=0x%08x: "
595 "for new blocks use offset only, forwarded blocks have fPtr set only",
596 AliHLTComponent::DataType2Text(outputBlocks[oblock].fDataType).c_str(),
597 outputBlocks[oblock].fSpecification,
598 outputBlocks[oblock].fPtr, outputBlocks[oblock].fOffset);
599 }
600
601 // check for duplicates in the output
602 AliHLTUInt32_t checkblock=0;
603 for (; checkblock<oblock; checkblock++) {
0ad4ebd1 604 if (outputBlocks[oblock].fPtr!=NULL && outputBlocks[oblock].fPtr!=pTgtBuffer &&
605 outputBlocks[checkblock].fPtr==outputBlocks[oblock].fPtr) {
7e81df35 606 if (outputBlocks[checkblock].fSize!=outputBlocks[oblock].fSize ||
607 outputBlocks[checkblock].fDataType!=outputBlocks[oblock].fDataType) {
608 HLTWarning("output blocks %d (%s 0x%08x) and %d (%s 0x%08x) have identical data references ptr=%p "
609 "but differ in data type and/or size: %d vs. %d",
610 oblock,
611 AliHLTComponent::DataType2Text(outputBlocks[oblock].fDataType).c_str(),
612 outputBlocks[oblock].fSpecification,
613 checkblock,
614 AliHLTComponent::DataType2Text(outputBlocks[checkblock].fDataType).c_str(),
615 outputBlocks[checkblock].fSpecification,
616 outputBlocks[oblock].fPtr,
617 outputBlocks[oblock].fSize,
618 outputBlocks[checkblock].fSize);
619 }
620 // ignore from the second copy
621 break;
622 }
623 }
624 if (checkblock<oblock) continue;
625
626 // search for the forwarded data blocks
627 // new data blocks are announced to the data buffer, forwarded data blocks
628 // to the publisher task. The publisher task of a forwarded data block is
629 // removed from the list in order to keep the buffer open. It will be releases
630 // when the subscribing task releases it
457ec821 631 AliHLTUInt32_t iblock=0;
48abe484 632 for (; iblock<fBlockDataArray.size(); iblock++) {
0ad4ebd1 633 if (outputBlocks[oblock].fDataType==kAliHLTDataTypeEvent) {
634 // the event type data block is ignored if it was forwarded
0925276e 635 break;
0ad4ebd1 636 }
457ec821 637 if (fBlockDataArray[iblock].fPtr==outputBlocks[oblock].fPtr) {
638 assert(subscribedTaskList[iblock]!=NULL);
639 if (subscribedTaskList[iblock]==NULL) continue;
640 HLTDebug("forward segment %d (source task %s %p) to data buffer %p", iblock, pSrcTask->GetName(), pSrcTask, fpDataBuffer);
641 fpDataBuffer->Forward(subscribedTaskList[iblock], &fBlockDataArray[iblock]);
642 subscribedTaskList[iblock]=NULL; // not to be released in the loop further down
643 break;
644 }
645 }
48abe484 646 if (iblock==fBlockDataArray.size()) segments.push_back(outputBlocks[oblock]);
042b7a5d 647 }
648 if (pTgtBuffer && segments.size()>0) {
649 iResult=fpDataBuffer->SetSegments(pTgtBuffer, &segments[0], segments.size());
b46ca65e 650 }
457ec821 651 } else {
652 // no forwarding, actually we dont even need to keep the data, this is a
653 // dead end (fListTargets empty)
654 //iResult=fpDataBuffer->SetSegments(pTgtBuffer, outputBlocks, outputBlockCnt);
b46ca65e 655 }
7a436c89 656 delete [] outputBlocks; outputBlocks=NULL; outputBlockCnt=0;
657 } else {
658 fpDataBuffer->Reset();
659 }
457ec821 660 if (fListTargets.First()!=NULL) {
661 if (iSOR>=0 && subscribedTaskList[iSOR]!=NULL) {
662 HLTDebug("forward SOR event segment %d (source task %s %p) to data buffer %p", iSOR, pSrcTask->GetName(), pSrcTask, fpDataBuffer);
663 fpDataBuffer->Forward(subscribedTaskList[iSOR], &fBlockDataArray[iSOR]);
664 subscribedTaskList[iSOR]=NULL; // not to be released in the loop further down
665 }
666 if (iEOR>=0 && subscribedTaskList[iEOR]!=NULL) {
667 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);
668 fpDataBuffer->Forward(subscribedTaskList[iEOR], &fBlockDataArray[iEOR]);
669 subscribedTaskList[iEOR]=NULL; // not to be released in the loop further down
670 }
671 }
7a436c89 672 } else {
97d2b87a 673 HLTError("no target buffer available");
7a436c89 674 iResult=-EFAULT;
675 }
676 } while (iResult==-ENOSPC && iNofTrial++<1);
677 }
678
679 // now release all buffers which we have subscribed to
680 iSourceDataBlock=0;
b46ca65e 681 AliHLTTaskPList::iterator element;
682 while ((element=subscribedTaskList.begin())!=subscribedTaskList.end()) {
683 pSrcTask=*element;
7a436c89 684 if (pSrcTask) {
685 int iTempRes=0;
686 if ((iTempRes=pSrcTask->Release(&fBlockDataArray[iSourceDataBlock], this))>=0) {
97d2b87a 687 HLTDebug("successfully released segment of task %s (%p)", pSrcTask->GetName(), pSrcTask);
7a436c89 688 } else {
97d2b87a 689 HLTError("realease of task %s (%p) failed with error %d", pSrcTask->GetName(), pSrcTask, iTempRes);
7a436c89 690 }
7a436c89 691 }
b46ca65e 692 subscribedTaskList.erase(element);
7a436c89 693 iSourceDataBlock++;
694 }
b46ca65e 695 if (subscribedTaskList.size()>0) {
97d2b87a 696 HLTError("could not release all data buffers");
7a436c89 697 }
698 } else {
97d2b87a 699 HLTError("internal failure (not initialized component %p, data buffer %p)", fpComponent, fpDataBuffer);
7a436c89 700 iResult=-EFAULT;
701 }
702 return iResult;
703}
704
705int AliHLTTask::GetNofMatchingDataBlocks(const AliHLTTask* pConsumerTask) const
706{
707 // see header file for function documentation
708 int iResult=0;
709 if (pConsumerTask) {
710 if (fpDataBuffer) {
711 iResult=fpDataBuffer->FindMatchingDataBlocks(pConsumerTask->GetComponent(), NULL);
712 } else {
713 HLTFatal("internal data buffer missing");
714 iResult=-EFAULT;
715 }
716 } else {
717 iResult=-EINVAL;
718 }
719 return iResult;
720}
721
722int AliHLTTask::GetNofMatchingDataTypes(const AliHLTTask* pConsumerTask) const
723{
724 // see header file for function documentation
725 int iResult=0;
726 if (pConsumerTask) {
727 AliHLTComponent* pComponent=GetComponent();
728 if (!pComponent) {
729 // init ?
730 HLTError("component not initialized");
731 iResult=-EFAULT;
732 }
733 if (pComponent) {
734 iResult=pComponent->FindMatchingDataTypes(pConsumerTask->GetComponent(), NULL);
735 } else {
736 HLTFatal("task initialization failed");
737 iResult=-EFAULT;
738 }
739 } else {
740 iResult=-EINVAL;
741 }
742 return iResult;
743}
744
457ec821 745int AliHLTTask::Subscribe(const AliHLTTask* pConsumerTask, AliHLTComponentBlockDataList& blockDescList)
7a436c89 746{
747 // see header file for function documentation
748 int iResult=0;
749 if (pConsumerTask) {
750 if (fpDataBuffer) {
457ec821 751 iResult=fpDataBuffer->Subscribe(pConsumerTask->GetComponent(), blockDescList);
7a436c89 752 } else {
753 HLTFatal("internal data buffer missing");
754 iResult=-EFAULT;
755 }
756 } else {
757 iResult=-EINVAL;
758 }
759 return iResult;
760}
761
762int AliHLTTask::Release(AliHLTComponentBlockData* pBlockDesc, const AliHLTTask* pConsumerTask)
763{
764 // see header file for function documentation
765 int iResult=0;
766 if (pConsumerTask && pBlockDesc) {
767 if (fpDataBuffer) {
b46ca65e 768 iResult=fpDataBuffer->Release(pBlockDesc, pConsumerTask->GetComponent(), this);
7a436c89 769 } else {
770 HLTFatal("internal data buffer missing");
771 iResult=-EFAULT;
772 }
773 } else {
774 iResult=-EINVAL;
775 }
776 return iResult;
777}
778
779void AliHLTTask::PrintStatus()
780{
781 // see header file for function documentation
782 HLTLogKeyword("task properties");
783 AliHLTComponent* pComponent=GetComponent();
784 if (pComponent) {
785 HLTMessage(" component: %s (%p)", pComponent->GetComponentID(), pComponent);
786 } else {
787 HLTMessage(" no component set!");
788 }
789 if (fpConfiguration) {
790 AliHLTConfiguration* pSrc=fpConfiguration->GetFirstSource();
791 while (pSrc) {
792 const char* pQualifier="unresolved";
793 if (FindDependency(pSrc->GetName()))
794 pQualifier="resolved";
795 HLTMessage(" source: %s (%s)", pSrc->GetName(), pQualifier);
796 pSrc=fpConfiguration->GetNextSource();
797 }
798 TObjLink* lnk = fListTargets.FirstLink();
799 while (lnk) {
800 TObject *obj = lnk->GetObject();
801 HLTMessage(" target: %s", obj->GetName());
802 lnk = lnk->Next();
803 }
804 } else {
97d2b87a 805 HLTMessage(" task not initialized");
7a436c89 806 }
807}
7131ea63 808
809int AliHLTTask::CustomInit(AliHLTComponentHandler* /*pCH*/)
810{
811 // default implementation nothing to do
812 return 0;
813}
814
815int AliHLTTask::CustomCleanup()
816{
817 // default implementation nothing to do
818 return 0;
819}
97d2b87a 820
821int AliHLTTask::LoggingVarargs(AliHLTComponentLogSeverity severity,
822 const char* originClass, const char* originFunc,
823 const char* file, int line, ... ) const
824{
825 // see header file for function documentation
826 int iResult=0;
827
828 va_list args;
829 va_start(args, line);
830
831 AliHLTLogging::SetLogString("%s (%p): ", GetName(), this);
832 iResult=SendMessage(severity, originClass, originFunc, file, line, AliHLTLogging::BuildLogString(NULL, args, true /*append*/));
833 va_end(args);
834
835 return iResult;
836}