Removing shadowed variable to get rid of compilation warnings.
[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;
107 if (fpConfiguration) {
108 if (pCH) {
109 int argc=0;
110 const char** argv=NULL;
111 if ((iResult=fpConfiguration->GetArguments(&argv))>=0) {
112 argc=iResult; // just to make it clear
113 // TODO: we have to think about the optional environment parameter,
114 // currently just set to NULL.
115 iResult=pCH->CreateComponent(fpConfiguration->GetComponentID(), NULL, argc, argv, fpComponent);
116 if (fpComponent || iResult<=0) {
117 //HLTDebug("component %s (%p) created", fpComponent->GetComponentID(), fpComponent);
118 } else {
e642a402 119 //HLTError("can not find component \"%s\" (%d)", fpConfiguration->GetComponentID(), iResult);
7a436c89 120 }
121 } else {
122 HLTError("can not get argument list for configuration %s (%s)", fpConfiguration->GetName(), fpConfiguration->GetComponentID());
123 iResult=-EINVAL;
124 }
125 } else {
126 HLTError("component handler instance needed for task initialization");
127 iResult=-EINVAL;
128 }
129 } else {
130 HLTError("configuration object instance needed for task initialization");
131 iResult=-EINVAL;
132 }
133 return iResult;
134}
135
136int AliHLTTask::Deinit()
137{
138 // see header file for function documentation
139 int iResult=0;
140 AliHLTComponent* pComponent=GetComponent();
141 fpComponent=NULL;
142 if (pComponent) {
143 //HLTDebug("delete component %s (%p)", pComponent->GetComponentID(), pComponent);
144 pComponent->Deinit();
145 delete pComponent;
146 } else {
147 HLTWarning("task %s (%p) doesn't seem to be in initialized", GetName(), this);
148 }
149 return iResult;
150}
151
152const char *AliHLTTask::GetName() const
153{
154 // see header file for function documentation
155 if (fpConfiguration)
156 return fpConfiguration->GetName();
157 return TObject::GetName();
158}
159
160AliHLTConfiguration* AliHLTTask::GetConf() const
161{
162 // see header file for function documentation
163 return fpConfiguration;
164}
165
166AliHLTComponent* AliHLTTask::GetComponent() const
167{
168 // see header file for function documentation
169 return fpComponent;
170}
171
172AliHLTTask* AliHLTTask::FindDependency(const char* id)
173{
174 // see header file for function documentation
175 AliHLTTask* pTask=NULL;
176 if (id) {
177 pTask=(AliHLTTask*)fListDependencies.FindObject(id);
178 }
179 return pTask;
180}
181
182int AliHLTTask::FollowDependency(const char* id, TList* pTgtList)
183{
184 // see header file for function documentation
185 int iResult=0;
186 if (id) {
187 AliHLTTask* pDep=NULL;
188 if ((pDep=(AliHLTTask*)fListDependencies.FindObject(id))!=NULL) {
189 if (pTgtList) pTgtList->Add(pDep);
190 iResult++;
191 } else {
192 TObjLink* lnk=fListDependencies.FirstLink();
193 while (lnk && iResult==0) {
194 pDep=(AliHLTTask*)lnk->GetObject();
195 if (pDep) {
196 if ((iResult=pDep->FollowDependency(id, pTgtList))>0) {
197 if (pTgtList) pTgtList->AddFirst(pDep);
198 iResult++;
199 }
200 } else {
201 iResult=-EFAULT;
202 }
203 lnk=lnk->Next();
204 }
205 }
206 } else {
207 iResult=-EINVAL;
208 }
209 return iResult;
210}
211
212void AliHLTTask::PrintDependencyTree(const char* id, int bFromConfiguration)
213{
214 // see header file for function documentation
215 HLTLogKeyword("task dependencies");
216 int iResult=0;
217 TList tgtList;
218 if (bFromConfiguration) {
219 if (fpConfiguration)
220 iResult=fpConfiguration->FollowDependency(id, &tgtList);
221 else
222 iResult=-EFAULT;
223 } else
224 iResult=FollowDependency(id, &tgtList);
225 if (iResult>0) {
226 HLTMessage(" task \"%s\": dependency level %d ", GetName(), iResult);
227 TObjLink* lnk=tgtList.FirstLink();
228 int i=iResult;
229 char* pSpace = new char[iResult+1];
230 if (pSpace) {
231 memset(pSpace, 32, iResult);
232 pSpace[i]=0;
233 while (lnk) {
234 TObject* obj=lnk->GetObject();
235 HLTMessage(" %s^-- %s ", &pSpace[i--], obj->GetName());
236 lnk=lnk->Next();
237 }
238 delete [] pSpace;
239 } else {
240 iResult=-ENOMEM;
241 }
242 }
243}
244
245int AliHLTTask::SetDependency(AliHLTTask* pDep)
246{
247 // see header file for function documentation
248 int iResult=0;
249 if (pDep) {
250 if (FindDependency(pDep->GetName())==NULL) {
251 fListDependencies.Add(pDep);
252 } else {
253 iResult=-EEXIST;
254 }
255 } else {
256 iResult=-EINVAL;
257 }
258 return iResult;
259}
260
261int AliHLTTask::UnsetDependency(AliHLTTask* pDep)
262{
263 // see header file for function documentation
264 fListDependencies.Remove(pDep);
265 if (fpConfiguration) {
266 fpConfiguration->InvalidateSources();
267 }
268 return 0;
269}
270
271int AliHLTTask::CheckDependencies()
272{
273 // see header file for function documentation
274 int iResult=0;
275 AliHLTConfiguration* pSrc=fpConfiguration->GetFirstSource();
276 while (pSrc) {
277 if (FindDependency(pSrc->GetName())==NULL) {
278 //HLTDebug("dependency \"%s\" unresolved", pSrc->GetName());
279 iResult++;
280 }
281 pSrc=fpConfiguration->GetNextSource();
282 }
283 return iResult;
284}
285
286
287int AliHLTTask::Depends(AliHLTTask* pTask)
288{
289 // see header file for function documentation
290 int iResult=0;
291 if (pTask) {
292 if (fpConfiguration) {
293 iResult=fpConfiguration->GetSource(pTask->GetName())!=NULL;
294 if (iResult>0) {
295 //HLTDebug("task \"%s\" depends on \"%s\"", GetName(), pTask->GetName());
296 } else {
297 //HLTDebug("task \"%s\" independend of \"%s\"", GetName(), pTask->GetName());
298 }
299 } else {
300 iResult=-EFAULT;
301 }
302 } else {
303 iResult=-EINVAL;
304 }
305 return iResult;
306}
307
308AliHLTTask* AliHLTTask::FindTarget(const char* id)
309{
310 // see header file for function documentation
311 AliHLTTask* pTask=NULL;
312 if (id) {
313 pTask=(AliHLTTask*)fListTargets.FindObject(id);
314 }
315 return pTask;
316}
317
318int AliHLTTask::SetTarget(AliHLTTask* pTgt)
319{
320 // see header file for function documentation
321 int iResult=0;
322 if (pTgt) {
323 if (FindTarget(pTgt->GetName())==NULL) {
324 fListTargets.Add(pTgt);
325 } else {
326 iResult=-EEXIST;
327 }
328 } else {
329 iResult=-EINVAL;
330 }
331 return iResult;
332}
333
334int AliHLTTask::UnsetTarget(AliHLTTask* pTarget)
335{
336 // see header file for function documentation
337 fListTargets.Remove(pTarget);
338 return 0;
339}
340
341int AliHLTTask::StartRun()
342{
343 // see header file for function documentation
344 int iResult=0;
345 int iNofInputDataBlocks=0;
346 AliHLTComponent* pComponent=GetComponent();
347 if (pComponent) {
348 // determine the number of input data blocks provided from the source tasks
349 TObjLink* lnk=fListDependencies.FirstLink();
350 while (lnk && iResult>=0) {
351 AliHLTTask* pSrcTask=(AliHLTTask*)lnk->GetObject();
352 if (pSrcTask) {
353 if ((iResult=pSrcTask->GetNofMatchingDataTypes(this))>0) {
354 iNofInputDataBlocks+=iResult;
355 } else if (iResult==0) {
356 HLTWarning("source task %s (%p) does not provide any matching data type for task %s (%p)", pSrcTask->GetName(), pSrcTask, GetName(), this);
357 } else {
358 HLTError("task %s (%p): error getting matching data types for source task %s (%p)", GetName(), this, pSrcTask->GetName(), pSrcTask);
359 iResult=-EFAULT;
360 }
361 }
362 lnk=lnk->Next();
363 }
364 if (iResult>=0) {
365 if (fBlockDataArray.size()>0) {
366 HLTWarning("block data array for task %s (%p) was not cleaned", GetName(), this);
457ec821 367 fBlockDataArray.clear();
7a436c89 368 }
369
370 // component init
371 // the initialization of the component is done by the ComponentHandler after creation
372 // of the component.
373 //iResult=Init( AliHLTComponentEnvironment* environ, void* environ_param, int argc, const char** argv );
374
7a436c89 375 // allocate the data buffer, which controls the output buffer and subscriptions
376 if (iResult>=0) {
377 fpDataBuffer=new AliHLTDataBuffer;
378 if (fpDataBuffer!=NULL) {
dba03d72 379 fpDataBuffer->SetLocalLoggingLevel(GetLocalLoggingLevel());
7a436c89 380 HLTDebug("created data buffer %p for task %s (%p)", fpDataBuffer, GetName(), this);
381 TObjLink* lnk=fListTargets.FirstLink();
382 while (lnk && iResult>=0) {
383 AliHLTTask* pTgtTask=(AliHLTTask*)lnk->GetObject();
384 if (pTgtTask) {
385 if ((iResult=fpDataBuffer->SetConsumer(pTgtTask->GetComponent()))>=0) {
386 }
387 } else {
388 break;
389 iResult=-EFAULT;
390 }
391 lnk=lnk->Next();
392 }
393 } else {
394 HLTFatal("can not create data buffer object, memory allocation failed");
395 iResult=-ENOMEM;
396 }
397 }
398 }
457ec821 399 if (iResult>=0) {
400 // send the SOR event
401
402 }
7a436c89 403 } else {
404 HLTError("task %s (%p) does not have a component", GetName(), this);
405 iResult=-EFAULT;
406 }
407 return iResult;
408}
409
410int AliHLTTask::EndRun()
411{
412 // see header file for function documentation
413 int iResult=0;
414 if (fBlockDataArray.size()>0) {
457ec821 415 fBlockDataArray.clear();
7a436c89 416 }
417 if (fpDataBuffer) {
418 AliHLTDataBuffer* pBuffer=fpDataBuffer;
419 fpDataBuffer=NULL;
420 delete pBuffer;
421 }
422 return iResult;
423}
424
425int AliHLTTask::ProcessTask(Int_t eventNo)
426{
427 // see header file for function documentation
428 int iResult=0;
429 AliHLTComponent* pComponent=GetComponent();
430 if (pComponent && fpDataBuffer) {
431 HLTDebug("Processing task %s (%p) fpDataBuffer %p", GetName(), this, fpDataBuffer);
432 fpDataBuffer->Reset();
433 int iSourceDataBlock=0;
434 int iInputDataVolume=0;
435
436 AliHLTTask* pSrcTask=NULL;
b46ca65e 437 AliHLTTaskPList subscribedTaskList;
7a436c89 438 TObjLink* lnk=fListDependencies.FirstLink();
439
457ec821 440 // instances of SOR and EOR events to be kept
441 int iSOR=-1;
442 int iEOR=-1;
443
7a436c89 444 // subscribe to all source tasks
457ec821 445 fBlockDataArray.clear();
7a436c89 446 while (lnk && iResult>=0) {
447 pSrcTask=(AliHLTTask*)lnk->GetObject();
448 if (pSrcTask) {
449 int iMatchingDB=pSrcTask->GetNofMatchingDataBlocks(this);
457ec821 450 if (iMatchingDB<0) {
451 HLTError("task %s (%p): error getting no of matching data blocks from task %s (%p), error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iMatchingDB);
452 iResult=iMatchingDB;
453 break;
454 } else if (iMatchingDB==0) {
455 HLTDebug("source task %s (%p) does not provide any matching data type for task %s (%p)", pSrcTask->GetName(), pSrcTask, GetName(), this);
7a436c89 456 }
457ec821 457 if ((iResult=pSrcTask->Subscribe(this, fBlockDataArray))>=0) {
458 iSOR=iEOR=-1;
459 AliHLTComponentBlockDataList::iterator block=fBlockDataArray.begin();
460 for (int i=0; block!=fBlockDataArray.end(); i++) {
461 bool bRemove=0;
462 bRemove|=(*block).fDataType==kAliHLTDataTypeSOR && !(iSOR<0 && (iSOR=i)>=0);
463 bRemove|=(*block).fDataType==kAliHLTDataTypeEOR && !(iEOR<0 && (iEOR=i)>=0);
464 //HLTInfo("block %d, iSOR=%d iEOR=%d remove=%d", i, iSOR, iEOR, bRemove);
465 if (i<iSourceDataBlock) {
466 assert(!bRemove);
467 } else if (bRemove) {
468 HLTDebug("remove duplicated event %s (%d)", AliHLTComponent::DataType2Text((*block).fDataType).c_str(), i);
469 pSrcTask->Release(&(*block), this);
470 block=fBlockDataArray.erase(block);
471 continue;
472 } else {
473 iInputDataVolume+=(*block).fSize;
7a436c89 474 // put the source task as many times into the list as it provides data blocks
475 // makes the bookkeeping for the data release easier
b46ca65e 476 subscribedTaskList.push_back(pSrcTask);
457ec821 477 }
478 block++;
7a436c89 479 }
480 HLTDebug("Task %s (%p) successfully subscribed to %d data block(s) of task %s (%p)", GetName(), this, iResult, pSrcTask->GetName(), pSrcTask);
457ec821 481 iSourceDataBlock=fBlockDataArray.size();
7a436c89 482 iResult=0;
483 } else {
484 HLTError("Task %s (%p): subscription to task %s (%p) failed with error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iResult);
485 iResult=-EFAULT;
486 }
487 } else {
488 HLTFatal("fatal internal error in ROOT list handling");
489 iResult=-EFAULT;
490 }
491 lnk=lnk->Next();
457ec821 492 }
7a436c89 493
494 // process the event
495 int iNofTrial=0; // repeat processing if component returns -ENOSPC
496 AliHLTUInt32_t size=0;
497 if (iResult>=0) {
498 do {
032c5e5e 499 long unsigned int iOutputDataSize=0;
500 AliHLTConfiguration* pConf=GetConf();
501 assert(pConf);
502 // check if there was a buffer size specified, query output size
503 // estimator from component otherwize
504 if (pConf && pConf->GetOutputBufferSize()>=0) {
505 iOutputDataSize=pConf->GetOutputBufferSize();
506 } else {
7a436c89 507 long unsigned int iConstBase=0;
508 double fInputMultiplier=0;
509 if (pComponent->GetComponentType()!=AliHLTComponent::kSink)
510 pComponent->GetOutputDataSize(iConstBase, fInputMultiplier);
511 if (fInputMultiplier<0) {
512 HLTWarning("ignoring negative input multiplier");
513 fInputMultiplier=0;
514 }
032c5e5e 515 iOutputDataSize=int(fInputMultiplier*iInputDataVolume) + iConstBase;
7a436c89 516 //HLTDebug("task %s: reqired output size %d", GetName(), iOutputDataSize);
032c5e5e 517 }
7a436c89 518 if (iNofTrial>0) {
519 // dont process again if the buffer size is the same
520 if (size==iOutputDataSize) break;
521 HLTInfo("processing task %s again with buffer size %d", GetName(), iOutputDataSize);
522 }
523 AliHLTUInt8_t* pTgtBuffer=NULL;
524 if (iOutputDataSize>0) pTgtBuffer=fpDataBuffer->GetTargetBuffer(iOutputDataSize);
525 //HLTDebug("provided raw buffer %p", pTgtBuffer);
526 AliHLTComponentEventData evtData;
527 AliHLTComponent::FillEventData(evtData);
528 evtData.fEventID=(AliHLTEventID_t)eventNo;
529 evtData.fBlockCnt=iSourceDataBlock;
530 AliHLTComponentTriggerData trigData;
531 size=iOutputDataSize;
532 AliHLTUInt32_t outputBlockCnt=0;
533 AliHLTComponentBlockData* outputBlocks=NULL;
534 AliHLTComponentEventDoneData* edd;
535 if (pTgtBuffer!=NULL || iOutputDataSize==0) {
536 iResult=pComponent->ProcessEvent(evtData, &fBlockDataArray[0], trigData, pTgtBuffer, size, outputBlockCnt, outputBlocks, edd);
537 HLTDebug("task %s: component %s ProcessEvent finnished (%d): size=%d blocks=%d", GetName(), pComponent->GetComponentID(), iResult, size, outputBlockCnt);
b46ca65e 538 if (iResult>=0 && outputBlocks) {
457ec821 539 if (fListTargets.First()!=NULL) {
540 AliHLTComponentBlockDataList segments;
541 for (AliHLTUInt32_t oblock=0; oblock<outputBlockCnt; oblock++) {
542 AliHLTUInt32_t iblock=0;
543 for (; iblock<evtData.fBlockCnt; iblock++) {
544 if (fBlockDataArray[iblock].fPtr==outputBlocks[oblock].fPtr) {
545 assert(subscribedTaskList[iblock]!=NULL);
546 if (subscribedTaskList[iblock]==NULL) continue;
547 HLTDebug("forward segment %d (source task %s %p) to data buffer %p", iblock, pSrcTask->GetName(), pSrcTask, fpDataBuffer);
548 fpDataBuffer->Forward(subscribedTaskList[iblock], &fBlockDataArray[iblock]);
549 subscribedTaskList[iblock]=NULL; // not to be released in the loop further down
550 break;
551 }
552 }
553 if (iblock==evtData.fBlockCnt) segments.push_back(outputBlocks[oblock]);
042b7a5d 554 }
555 if (pTgtBuffer && segments.size()>0) {
556 iResult=fpDataBuffer->SetSegments(pTgtBuffer, &segments[0], segments.size());
b46ca65e 557 }
457ec821 558 } else {
559 // no forwarding, actually we dont even need to keep the data, this is a
560 // dead end (fListTargets empty)
561 //iResult=fpDataBuffer->SetSegments(pTgtBuffer, outputBlocks, outputBlockCnt);
b46ca65e 562 }
7a436c89 563 delete [] outputBlocks; outputBlocks=NULL; outputBlockCnt=0;
564 } else {
565 fpDataBuffer->Reset();
566 }
457ec821 567 if (fListTargets.First()!=NULL) {
568 if (iSOR>=0 && subscribedTaskList[iSOR]!=NULL) {
569 HLTDebug("forward SOR event segment %d (source task %s %p) to data buffer %p", iSOR, pSrcTask->GetName(), pSrcTask, fpDataBuffer);
570 fpDataBuffer->Forward(subscribedTaskList[iSOR], &fBlockDataArray[iSOR]);
571 subscribedTaskList[iSOR]=NULL; // not to be released in the loop further down
572 }
573 if (iEOR>=0 && subscribedTaskList[iEOR]!=NULL) {
574 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);
575 fpDataBuffer->Forward(subscribedTaskList[iEOR], &fBlockDataArray[iEOR]);
576 subscribedTaskList[iEOR]=NULL; // not to be released in the loop further down
577 }
578 }
7a436c89 579 } else {
580 HLTError("task %s: no target buffer available", GetName());
581 iResult=-EFAULT;
582 }
583 } while (iResult==-ENOSPC && iNofTrial++<1);
584 }
585
586 // now release all buffers which we have subscribed to
587 iSourceDataBlock=0;
b46ca65e 588 AliHLTTaskPList::iterator element;
589 while ((element=subscribedTaskList.begin())!=subscribedTaskList.end()) {
590 pSrcTask=*element;
7a436c89 591 if (pSrcTask) {
592 int iTempRes=0;
593 if ((iTempRes=pSrcTask->Release(&fBlockDataArray[iSourceDataBlock], this))>=0) {
594 HLTDebug("Task %s (%p) successfully released segment of task %s (%p)", GetName(), this, pSrcTask->GetName(), pSrcTask);
595 } else {
596 HLTError("Task %s (%p): realease of task %s (%p) failed with error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iTempRes);
597 }
7a436c89 598 }
b46ca65e 599 subscribedTaskList.erase(element);
7a436c89 600 iSourceDataBlock++;
601 }
b46ca65e 602 if (subscribedTaskList.size()>0) {
7a436c89 603 HLTError("task %s (%p): could not release all data buffers", GetName(), this);
604 }
605 } else {
606 HLTError("task %s (%p): internal failure (not initialized component %p, data buffer %p)", GetName(), this, fpComponent, fpDataBuffer);
607 iResult=-EFAULT;
608 }
609 return iResult;
610}
611
612int AliHLTTask::GetNofMatchingDataBlocks(const AliHLTTask* pConsumerTask) const
613{
614 // see header file for function documentation
615 int iResult=0;
616 if (pConsumerTask) {
617 if (fpDataBuffer) {
618 iResult=fpDataBuffer->FindMatchingDataBlocks(pConsumerTask->GetComponent(), NULL);
619 } else {
620 HLTFatal("internal data buffer missing");
621 iResult=-EFAULT;
622 }
623 } else {
624 iResult=-EINVAL;
625 }
626 return iResult;
627}
628
629int AliHLTTask::GetNofMatchingDataTypes(const AliHLTTask* pConsumerTask) const
630{
631 // see header file for function documentation
632 int iResult=0;
633 if (pConsumerTask) {
634 AliHLTComponent* pComponent=GetComponent();
635 if (!pComponent) {
636 // init ?
637 HLTError("component not initialized");
638 iResult=-EFAULT;
639 }
640 if (pComponent) {
641 iResult=pComponent->FindMatchingDataTypes(pConsumerTask->GetComponent(), NULL);
642 } else {
643 HLTFatal("task initialization failed");
644 iResult=-EFAULT;
645 }
646 } else {
647 iResult=-EINVAL;
648 }
649 return iResult;
650}
651
457ec821 652int AliHLTTask::Subscribe(const AliHLTTask* pConsumerTask, AliHLTComponentBlockDataList& blockDescList)
7a436c89 653{
654 // see header file for function documentation
655 int iResult=0;
656 if (pConsumerTask) {
657 if (fpDataBuffer) {
457ec821 658 iResult=fpDataBuffer->Subscribe(pConsumerTask->GetComponent(), blockDescList);
7a436c89 659 } else {
660 HLTFatal("internal data buffer missing");
661 iResult=-EFAULT;
662 }
663 } else {
664 iResult=-EINVAL;
665 }
666 return iResult;
667}
668
669int AliHLTTask::Release(AliHLTComponentBlockData* pBlockDesc, const AliHLTTask* pConsumerTask)
670{
671 // see header file for function documentation
672 int iResult=0;
673 if (pConsumerTask && pBlockDesc) {
674 if (fpDataBuffer) {
b46ca65e 675 iResult=fpDataBuffer->Release(pBlockDesc, pConsumerTask->GetComponent(), this);
7a436c89 676 } else {
677 HLTFatal("internal data buffer missing");
678 iResult=-EFAULT;
679 }
680 } else {
681 iResult=-EINVAL;
682 }
683 return iResult;
684}
685
686void AliHLTTask::PrintStatus()
687{
688 // see header file for function documentation
689 HLTLogKeyword("task properties");
690 AliHLTComponent* pComponent=GetComponent();
691 if (pComponent) {
692 HLTMessage(" component: %s (%p)", pComponent->GetComponentID(), pComponent);
693 } else {
694 HLTMessage(" no component set!");
695 }
696 if (fpConfiguration) {
697 AliHLTConfiguration* pSrc=fpConfiguration->GetFirstSource();
698 while (pSrc) {
699 const char* pQualifier="unresolved";
700 if (FindDependency(pSrc->GetName()))
701 pQualifier="resolved";
702 HLTMessage(" source: %s (%s)", pSrc->GetName(), pQualifier);
703 pSrc=fpConfiguration->GetNextSource();
704 }
705 TObjLink* lnk = fListTargets.FirstLink();
706 while (lnk) {
707 TObject *obj = lnk->GetObject();
708 HLTMessage(" target: %s", obj->GetName());
709 lnk = lnk->Next();
710 }
711 } else {
712 HLTMessage(" task \"%s\" not initialized", GetName());
713 }
714}