FileWriters: handling of control events and PRIV data blocks: ignored by default...
[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) {
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
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 {
167 HLTWarning("task %s (%p) doesn't seem to be in initialized", GetName(), this);
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) {
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
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
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
650int 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
667int 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 690int 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
707int 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
724void 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
754int AliHLTTask::CustomInit(AliHLTComponentHandler* /*pCH*/)
755{
756 // default implementation nothing to do
757 return 0;
758}
759
760int AliHLTTask::CustomCleanup()
761{
762 // default implementation nothing to do
763 return 0;
764}