- setup scripts for running environment added
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTConfiguration.cxx
1 // $Id$
2
3 /**************************************************************************
4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5  *                                                                        *
6  * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
7  *          for The ALICE Off-line Project.                               *
8  *                                                                        *
9  * Permission to use, copy, modify and distribute this software and its   *
10  * documentation strictly for non-commercial purposes is hereby granted   *
11  * without fee, provided that the above copyright notice appears in all   *
12  * copies and that both the copyright notice and this permission notice   *
13  * appear in the supporting documentation. The authors make no claims     *
14  * about the suitability of this software for any purpose. It is          *
15  * provided "as is" without express or implied warranty.                  *
16  **************************************************************************/
17
18 /** @file   AliHLTConfiguration.cxx
19     @author Matthias Richter
20     @date   
21     @brief  Implementation of HLT configuration handler.
22 */
23
24 #if __GNUC__>= 3
25 using namespace std;
26 #endif
27
28 #include <cerrno>
29 #include "AliHLTConfiguration.h"
30 #include "AliHLTConfigurationHandler.h"
31 #include "AliHLTTask.h"
32 #include "AliHLTComponent.h"
33 #include "AliHLTComponentHandler.h"
34 #include <iostream>
35 #include <string>
36
37 /** ROOT macro for the implementation of ROOT specific class methods */
38 ClassImp(AliHLTConfiguration)
39
40 AliHLTConfiguration::AliHLTConfiguration()
41   :
42   fID(NULL),
43   fComponent(NULL),
44   fStringSources(NULL),
45   fNofSources(-1),
46   fListSources(),
47   fListSrcElement(),
48   fArguments(NULL),
49   fArgc(-1),
50   fArgv(NULL)
51
52   fListSrcElement=fListSources.begin();
53 }
54
55 AliHLTConfiguration::AliHLTConfiguration(const char* id, const char* component, const char* sources, const char* arguments)
56   :
57   fID(id),
58   fComponent(component),
59   fStringSources(sources),
60   fNofSources(-1),
61   fListSources(),
62   fListSrcElement(),
63   fArguments(arguments),
64   fArgc(-1),
65   fArgv(NULL)
66 {
67   fListSrcElement=fListSources.begin();
68   if (id && component) {
69     if (fConfigurationHandler) {
70       fConfigurationHandler->RegisterConfiguration(this);
71     } else {
72       HLTError("no configuration handler set, abort registration");
73     }
74   }
75 }
76
77 AliHLTConfiguration::AliHLTConfiguration(const AliHLTConfiguration&)
78   :
79   TObject(),
80   AliHLTLogging(),
81   fID(NULL),
82   fComponent(NULL),
83   fStringSources(NULL),
84   fNofSources(-1),
85   fListSources(),
86   fListSrcElement(),
87   fArguments(NULL),
88   fArgc(-1),
89   fArgv(NULL)
90
91   fListSrcElement=fListSources.begin();
92   HLTFatal("copy constructor untested");
93 }
94
95 AliHLTConfiguration& AliHLTConfiguration::operator=(const AliHLTConfiguration&)
96
97   HLTFatal("assignment operator untested");
98   return *this;
99 }
100
101 AliHLTConfiguration::~AliHLTConfiguration()
102 {
103   if (fConfigurationHandler) {
104     if (fConfigurationHandler->FindConfiguration(fID)!=NULL) {
105       fConfigurationHandler->RemoveConfiguration(this);
106     }
107   }
108   if (fArgv != NULL) {
109     if (fArgc>0) {
110       for (int i=0; i<fArgc; i++) {
111         delete[] fArgv[i];
112       }
113     }
114     delete[] fArgv;
115     fArgv=NULL;
116   }
117 }
118
119 /* the global configuration handler which is used to automatically register the configuration
120  */
121 AliHLTConfigurationHandler* AliHLTConfiguration::fConfigurationHandler=NULL;
122
123 int AliHLTConfiguration::GlobalInit(AliHLTConfigurationHandler* pHandler)
124 {
125   int iResult=0;
126   if (fConfigurationHandler!=NULL) {
127     fConfigurationHandler->Logging(kHLTLogWarning, "AliHLTConfiguration::GlobalInit", HLT_DEFAULT_LOG_KEYWORD, "configuration handler already initialized, overriding object %p", fConfigurationHandler);
128   }
129   fConfigurationHandler=pHandler;
130   return iResult;
131 }
132
133 int AliHLTConfiguration::GlobalDeinit()
134 {
135   int iResult=0;
136   fConfigurationHandler=NULL;
137   return iResult;
138 }
139
140 const char* AliHLTConfiguration::GetName() const {
141   if (fID)
142     return fID;
143   return TObject::GetName();
144 }
145
146 AliHLTConfiguration* AliHLTConfiguration::GetSource(const char* id)
147 {
148   AliHLTConfiguration* pSrc=NULL;
149   if (id) {
150     // first check the current element
151     if (fListSrcElement!=fListSources.end() && strcmp(id, (*fListSrcElement)->GetName())==0) {
152       pSrc=*fListSrcElement;
153       } else {
154       // check the list
155
156       pSrc=GetFirstSource();
157       while (pSrc) {
158         if (strcmp(id, pSrc->GetName())==0)
159           break;
160         pSrc=GetNextSource();
161       }
162     }
163   }
164   return pSrc;
165 }
166
167 AliHLTConfiguration* AliHLTConfiguration::GetFirstSource()
168 {
169   AliHLTConfiguration* pSrc=NULL;
170   if (fNofSources>=0 || ExtractSources()) {
171     fListSrcElement=fListSources.begin();
172     if (fListSrcElement!=fListSources.end()) pSrc=*fListSrcElement;
173   } 
174   return pSrc;
175 }
176
177 AliHLTConfiguration* AliHLTConfiguration::GetNextSource()
178 {
179   AliHLTConfiguration* pSrc=NULL;
180   if (fNofSources>0) {
181     if (fListSrcElement!=fListSources.end() && (++fListSrcElement)!=fListSources.end()) 
182       pSrc=*fListSrcElement;
183   } 
184   return pSrc;
185 }
186
187 int AliHLTConfiguration::SourcesResolved(int bAuto) 
188 {
189   int iResult=0;
190   if (fNofSources>=0 || bAuto && (iResult=ExtractSources())>=0) {
191     //HLTDebug("fNofSources=%d", fNofSources);
192     //HLTDebug("list size = %d", fListSources.size());
193     iResult=fNofSources==(int)fListSources.size();
194   }
195   return iResult;
196 }
197
198 int AliHLTConfiguration::InvalidateSource(AliHLTConfiguration* pConf)
199 {
200   int iResult=0;
201   if (pConf) {
202     vector<AliHLTConfiguration*>::iterator element=fListSources.begin();
203     while (element!=fListSources.end()) {
204       if (*element==pConf) {
205         fListSources.erase(element);
206         fListSrcElement=fListSources.end();
207         // there is no need to re-evaluate until there was a new configuration registered
208         // -> postpone the invalidation, its done in AliHLTConfigurationHandler::RegisterConfiguration
209         //InvalidateSources();
210         break;
211       }
212       element++;
213     }
214   } else {
215     iResult=-EINVAL;
216   }
217   return iResult;
218 }
219
220 void AliHLTConfiguration::PrintStatus()
221 {
222   HLTLogKeyword("configuration status");
223   HLTMessage("status of configuration \"%s\" (%p)", GetName(), this);
224   if (fComponent) HLTMessage("  - component: \"%s\"", fComponent);
225   else HLTMessage("  - component string invalid");
226   if (fStringSources) HLTMessage("  - sources: \"%s\"", fStringSources);
227   else HLTMessage("  - no sources");
228   if (SourcesResolved(1)<=0)
229     HLTMessage("    there are unresolved sources");
230   AliHLTConfiguration* pSrc=GetFirstSource();
231   while (pSrc) {
232     HLTMessage("    source \"%s\" (%p) resolved", pSrc->GetName(), pSrc);
233     pSrc=GetNextSource();
234   }
235 }
236
237 int AliHLTConfiguration::GetArguments(const char*** pArgv)
238 {
239   int iResult=0;
240   if (pArgv) {
241     iResult=fArgc;
242     *pArgv=(const char**)fArgv;
243   } else {
244     iResult=-EINVAL;
245   }
246   return iResult;
247 }
248
249
250 int AliHLTConfiguration::ExtractSources()
251 {
252   int iResult=0;
253   fNofSources=0;
254   if (fStringSources!=NULL) {
255     vector<char*> tgtList;
256     fListSources.clear();
257     if ((iResult=InterpreteString(fStringSources, tgtList))>=0) {
258       fNofSources=tgtList.size();
259       vector<char*>::iterator element=tgtList.begin();
260       while ((element=tgtList.begin())!=tgtList.end()) {
261         if (fConfigurationHandler) {
262           AliHLTConfiguration* pConf=fConfigurationHandler->FindConfiguration(*element);
263           if (pConf) {
264             HLTDebug("source \"%s\" inserted", pConf->GetName());
265             fListSources.push_back(pConf);
266           } else {
267             HLTError("can not find source \"%s\"", (*element));
268             iResult=-ENOENT;
269           }
270         } else if (iResult>=0) {
271           iResult=-EFAULT;
272           HLTFatal("global configuration handler not initialized, can not resolve sources");
273         }
274         delete[] (*element);
275         tgtList.erase(element);
276       }
277       fListSrcElement=fListSources.begin();
278     }
279   }
280   return iResult;
281 }
282
283 int AliHLTConfiguration::ExtractArguments()
284 {
285   int iResult=0;
286   if (fArguments!=NULL) {
287     vector<char*> tgtList;
288     if ((iResult=InterpreteString(fArguments, tgtList))>=0) {
289       fArgc=tgtList.size();
290       //HLTDebug("found %d arguments", fArgc);
291       if (fArgc>0) {
292         fArgv = new char*[fArgc];
293         if (fArgv) {
294           vector<char*>::iterator element=tgtList.begin();
295           int i=0;
296           while (element!=tgtList.end()) {
297             //HLTDebug("assign arguments %d (%s)", i, *element);
298             fArgv[i++]=(*element);
299             element++;
300           }
301         } else {
302           iResult=-ENOMEM;
303         }
304       }
305     }
306   }
307   return iResult;
308 }
309
310 int AliHLTConfiguration::InterpreteString(const char* arg, vector<char*>& argList)
311 {
312   int iResult=0;
313   if (arg) {
314     //HLTDebug("interprete \"%s\"", arg);
315     int i=0;
316     int prec=-1;
317     do {
318       if (arg[i]==0 || arg[i]==' ') {
319         if (prec>=0) {
320           char* pEntry= new char[i-prec+1];
321           if (pEntry) {
322             strncpy(pEntry, &arg[prec], i-prec);
323             pEntry[i-prec]=0; // terminate string
324             //HLTDebug("create string \"%s\", insert at %d", pEntry, argList.size());
325             argList.push_back(pEntry);
326           } else 
327             iResult=-ENOMEM;
328           prec=-1;
329         }
330       } else if (prec==-1) prec=i;
331     } while (arg[i++]!=0 && iResult>=0); 
332   } else {
333     iResult=-EINVAL;
334   }
335   return iResult;
336 }
337
338 int AliHLTConfiguration::FollowDependency(const char* id, TList* pTgtList)
339 {
340   int iResult=0;
341   if (id) {
342     AliHLTConfiguration* pDep=NULL;
343     if ((pDep=GetSource(id))!=NULL) {
344       if (pTgtList) pTgtList->Add(pDep);
345       iResult++;
346     } else {
347       pDep=GetFirstSource();
348       while (pDep && iResult==0) {
349         if ((iResult=pDep->FollowDependency(id, pTgtList))>0) {
350           if (pTgtList) pTgtList->AddFirst(pDep);
351           iResult++;
352         }
353         pDep=GetNextSource();
354       }
355     }
356   } else {
357     iResult=-EINVAL;
358   }
359   return iResult;
360 }
361
362 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
363
364 /** ROOT macro for the implementation of ROOT specific class methods */
365 ClassImp(AliHLTTask)
366
367 AliHLTTask::AliHLTTask()
368   :
369   fpConfiguration(NULL),
370   fpComponent(NULL),
371   fpDataBuffer(NULL),
372   fListTargets(),
373   fListDependencies(),
374   fpBlockDataArray(NULL),
375   fBlockDataArraySize(0)
376 {
377 }
378
379 AliHLTTask::AliHLTTask(AliHLTConfiguration* pConf)
380   :
381   fpConfiguration(pConf),
382   fpComponent(NULL),
383   fpDataBuffer(NULL),
384   fListTargets(),
385   fListDependencies(),
386   fpBlockDataArray(NULL),
387   fBlockDataArraySize(0)
388 {
389 }
390
391 AliHLTTask::AliHLTTask(const AliHLTTask&)
392   :
393   TObject(),
394   AliHLTLogging(),
395   fpConfiguration(NULL),
396   fpComponent(NULL),
397   fpDataBuffer(NULL),
398   fListTargets(),
399   fListDependencies(),
400   fpBlockDataArray(NULL),
401   fBlockDataArraySize(0)
402 {
403   HLTFatal("copy constructor untested");
404 }
405
406 AliHLTTask& AliHLTTask::operator=(const AliHLTTask&)
407
408   HLTFatal("assignment operator untested");
409   return *this;
410 }
411
412 AliHLTTask::~AliHLTTask()
413 {
414   if (fpComponent) delete fpComponent;
415   fpComponent=NULL;
416   if (fpBlockDataArray) delete[] fpBlockDataArray;
417   fpBlockDataArray=NULL;
418 }
419
420 int AliHLTTask::Init(AliHLTConfiguration* pConf, AliHLTComponentHandler* pCH)
421 {
422   int iResult=0;
423   if (fpConfiguration!=NULL && fpConfiguration!=pConf) {
424     HLTWarning("overriding previous reference to configuration object %p (%s) by %p",
425                fpConfiguration, GetName(), pConf);
426   }
427   if (pConf!=NULL) fpConfiguration=pConf;
428   if (fpConfiguration) {
429     if (pCH) {
430       int argc=0;
431       const char** argv=NULL;
432       if ((iResult=fpConfiguration->GetArguments(&argv))>=0) {
433         argc=iResult; // just to make it clear
434         iResult=pCH->CreateComponent(fpConfiguration->GetComponentID(), NULL, argc, argv, fpComponent);
435         if (fpComponent) {
436         } else {
437           HLTError("can not find component \"%s\"", fpConfiguration->GetComponentID());
438         }
439       }
440     } else {
441       HLTError("component handler instance needed for task initialization");
442       iResult=-EINVAL;
443     }
444   } else {
445     HLTError("configuration object instance needed for task initialization");
446     iResult=-EINVAL;
447   }
448   return iResult;
449 }
450
451 int AliHLTTask::Deinit()
452 {
453   return 0;
454 }
455
456 const char *AliHLTTask::GetName() const
457 {
458   if (fpConfiguration)
459     return fpConfiguration->GetName();
460   return TObject::GetName();
461 }
462
463 AliHLTConfiguration* AliHLTTask::GetConf() const
464 {
465   return fpConfiguration;
466 }
467
468 AliHLTComponent* AliHLTTask::GetComponent() const
469 {
470   return fpComponent;
471 }
472
473 AliHLTTask* AliHLTTask::FindDependency(const char* id)
474 {
475   AliHLTTask* pTask=NULL;
476   if (id) {
477     pTask=(AliHLTTask*)fListDependencies.FindObject(id);
478   }
479   return pTask;
480 }
481
482 int AliHLTTask::FollowDependency(const char* id, TList* pTgtList)
483 {
484   int iResult=0;
485   if (id) {
486     AliHLTTask* pDep=NULL;
487     if ((pDep=(AliHLTTask*)fListDependencies.FindObject(id))!=NULL) {
488       if (pTgtList) pTgtList->Add(pDep);
489       iResult++;
490     } else {
491       TObjLink* lnk=fListDependencies.FirstLink();
492       while (lnk && iResult==0) {
493         pDep=(AliHLTTask*)lnk->GetObject();
494         if (pDep) {
495           if ((iResult=pDep->FollowDependency(id, pTgtList))>0) {
496             if (pTgtList) pTgtList->AddFirst(pDep);
497             iResult++;
498           }
499         } else {
500           iResult=-EFAULT;
501         }
502         lnk=lnk->Next();
503       }
504     }
505   } else {
506     iResult=-EINVAL;
507   }
508   return iResult;
509 }
510
511 void AliHLTTask::PrintDependencyTree(const char* id, int bFromConfiguration)
512 {
513   HLTLogKeyword("task dependencies");
514   int iResult=0;
515   TList tgtList;
516   if (bFromConfiguration) {
517     if (fpConfiguration)
518       iResult=fpConfiguration->FollowDependency(id, &tgtList);
519     else
520       iResult=-EFAULT;
521   } else
522     iResult=FollowDependency(id, &tgtList);
523   if (iResult>0) {
524     HLTMessage("     task \"%s\": dependency level %d ", GetName(), iResult);
525     TObjLink* lnk=tgtList.FirstLink();
526     int i=iResult;
527     char* pSpace = new char[iResult+1];
528     if (pSpace) {
529       memset(pSpace, 32, iResult);
530       pSpace[i]=0;
531       while (lnk) {
532         TObject* obj=lnk->GetObject();
533         HLTMessage("     %s^-- %s ", &pSpace[i--], obj->GetName());
534         lnk=lnk->Next();
535       }
536       delete [] pSpace;
537     } else {
538       iResult=-ENOMEM;
539     }
540   }
541 }
542
543 /* this function is most likely depricated
544 int AliHLTTask::InsertBlockData(AliHLTComponent_BlockData* pBlock, AliHLTTask* pSource)
545 {
546   int iResult=0;
547   return iResult;
548 }
549 */
550
551 int AliHLTTask::SetDependency(AliHLTTask* pDep)
552 {
553   int iResult=0;
554   if (pDep) {
555     if (FindDependency(pDep->GetName())==NULL) {
556       fListDependencies.Add(pDep);
557     } else {
558       iResult=-EEXIST;
559     }
560   } else {
561     iResult=-EINVAL;
562   }
563   return iResult;
564 }
565
566 int AliHLTTask::CheckDependencies()
567 {
568   int iResult=0;
569   AliHLTConfiguration* pSrc=fpConfiguration->GetFirstSource();
570   while (pSrc) {
571     if (FindDependency(pSrc->GetName())==NULL) {
572       //HLTDebug("dependency \"%s\" unresolved", pSrc->GetName());
573       iResult++;
574     }
575     pSrc=fpConfiguration->GetNextSource();
576   }
577   return iResult;
578 }
579
580
581 int AliHLTTask::Depends(AliHLTTask* pTask)
582 {
583   int iResult=0;
584   if (pTask) {
585     if (fpConfiguration) {
586       iResult=fpConfiguration->GetSource(pTask->GetName())!=NULL;
587       if (iResult>0) {
588         //HLTDebug("task  \"%s\" depends on \"%s\"", GetName(), pTask->GetName());
589       } else {
590         //HLTDebug("task  \"%s\" independend of \"%s\"", GetName(), pTask->GetName());
591       }
592     } else {
593       iResult=-EFAULT;
594     }
595   } else {
596     iResult=-EINVAL;
597   }
598   return iResult;
599 }
600
601 AliHLTTask* AliHLTTask::FindTarget(const char* id)
602 {
603   AliHLTTask* pTask=NULL;
604   if (id) {
605     pTask=(AliHLTTask*)fListTargets.FindObject(id);
606   }
607   return pTask;
608 }
609
610 int AliHLTTask::SetTarget(AliHLTTask* pTgt)
611 {
612   int iResult=0;
613   if (pTgt) {
614     if (FindTarget(pTgt->GetName())==NULL) {
615       fListTargets.Add(pTgt);
616     } else {
617       iResult=-EEXIST;
618     }
619   } else {
620     iResult=-EINVAL;
621   }
622   return iResult;
623 }
624
625 /* this function is most likely depricated
626 int AliHLTTask::BuildBlockDataArray(AliHLTComponent_BlockData*& pBlockData)
627 {
628   int iResult=0;
629   return iResult;
630 }
631 */
632
633 int AliHLTTask::StartRun()
634 {
635   int iResult=0;
636   int iNofInputDataBlocks=0;
637   AliHLTComponent* pComponent=GetComponent();
638   if (pComponent) {
639     // determine the number of input data blocks provided from the source tasks
640     TObjLink* lnk=fListDependencies.FirstLink();
641     while (lnk && iResult>=0) {
642       AliHLTTask* pSrcTask=(AliHLTTask*)lnk->GetObject();
643       if (pSrcTask) {
644         if ((iResult=pSrcTask->GetNofMatchingDataTypes(this))>0) {
645           iNofInputDataBlocks+=iResult;
646         } else if (iResult==0) {
647           HLTWarning("source task %s (%p) does not provide any matching data type for task %s (%p)", pSrcTask->GetName(), pSrcTask, GetName(), this);
648         } else {
649           HLTError("task %s (%p): error getting matching data types for source task %s (%p)", GetName(), this, pSrcTask->GetName(), pSrcTask);
650           iResult=-EFAULT;
651         }
652       }
653       lnk=lnk->Next();
654     }
655     if (iResult>=0) {
656       if (fpBlockDataArray) {
657         HLTWarning("block data array for task %s (%p) was not cleaned", GetName(), this);
658         delete [] fpBlockDataArray;
659         fpBlockDataArray=NULL;
660         fBlockDataArraySize=0;
661       }
662
663       // component init
664       //iResult=Init( AliHLTComponentEnvironment* environ, void* environ_param, int argc, const char** argv );
665
666       // allocate internal task varables for bookkeeping aso.
667       fpBlockDataArray=new AliHLTComponent_BlockData[iNofInputDataBlocks];
668       if (fpBlockDataArray) {
669         fBlockDataArraySize=iNofInputDataBlocks;
670       } else {
671         HLTError("memory allocation failed");
672         iResult=-ENOMEM;
673       }
674     }
675   } else {
676     HLTError("task %s (%p) does not have a component", GetName(), this);
677     iResult=-EFAULT;
678   }
679   return iResult;
680 }
681
682 int AliHLTTask::EndRun()
683 {
684   int iResult=0;
685   return iResult;
686 }
687
688 int AliHLTTask::ProcessTask()
689 {
690   int iResult=0;
691   if (fpComponent && fpBlockDataArray) {
692     int iSourceDataBlock=0;
693     int iInputDataVolume=0;
694
695     int iNofInputDataBlocks=0;
696     /* TODO: the assumption of only one output data type per component is the current constraint
697      * later it should be checked how many output blocks of the source component match the input
698      * data types of the consumer component (GetNofMatchingDataBlocks). If one assumes that a
699      * certain output block is always been produced, the initialization could be done in the
700      * StartRun. Otherwise the fpBlockDataArray has to be adapted each time.
701      */
702     iNofInputDataBlocks=fListDependencies.GetSize(); // one block per source
703     // is not been used since the allocation was done in StartRun, but check the size
704     if (iNofInputDataBlocks>fBlockDataArraySize) {
705       HLTError("block data array too small");
706     }
707
708     AliHLTTask* pSrcTask=NULL;
709     TList subscribedTaskList;
710     TObjLink* lnk=fListDependencies.FirstLink();
711
712     // subscribe to all source tasks
713     while (lnk && iResult>=0) {
714       pSrcTask=(AliHLTTask*)lnk->GetObject();
715       if (pSrcTask) {
716         if (pSrcTask->GetNofMatchingDataBlocks(this)<fBlockDataArraySize-iSourceDataBlock) {
717           if ((iResult=pSrcTask->Subscribe(this, &fpBlockDataArray[iSourceDataBlock],fBlockDataArraySize-iSourceDataBlock))>0) {
718             for (int i=0; i<iResult; i++) {
719               iInputDataVolume+=fpBlockDataArray[i+iSourceDataBlock].fSize;
720               // put the source task as many times into the list as it provides data blocks
721               // makes the bookkeeping for the data release easier
722               subscribedTaskList.Add(pSrcTask);
723             }
724             iSourceDataBlock+=iResult;
725             HLTDebug("Task %s (%p) successfully subscribed to %d data blocks of task %s (%p)", GetName(), this, iResult, pSrcTask->GetName(), pSrcTask);
726             iResult=0;
727           } else {
728             HLTError("Task %s (%p): subscription to task %s (%p) failed with error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iResult);
729             iResult=-EFAULT;
730           }
731         } else {
732           HLTFatal("Task %s (%p): too little space in data block array for subscription to task %s (%p)", GetName(), this, pSrcTask->GetName(), pSrcTask);
733           iResult=-EFAULT;
734         }
735       } else {
736         HLTFatal("fatal internal error in ROOT list handling");
737         iResult=-EFAULT;
738       }
739       lnk=lnk->Next();
740     }
741
742     // process the event
743     if (iResult>=0) {
744       long unsigned int iConstBase=0;
745       double fInputMultiplier=0;
746       fpComponent->GetOutputDataSize(iConstBase, fInputMultiplier);
747       int iOutputDataSize=int(fInputMultiplier*iInputDataVolume) + iConstBase;
748       AliHLTUInt8_t* pTgtBuffer=fpDataBuffer->GetTargetBuffer(iOutputDataSize);
749       AliHLTComponent_EventData evtData;
750       AliHLTComponent_TriggerData trigData;
751       AliHLTUInt32_t size=iOutputDataSize;
752       AliHLTUInt32_t outputBlockCnt=0;
753       AliHLTComponent_BlockData* outputBlocks=NULL;
754       AliHLTComponent_EventDoneData* edd;
755       if (pTgtBuffer!=NULL || iOutputDataSize==0) {
756         iResult=fpComponent->ProcessEvent(evtData, fpBlockDataArray, trigData, pTgtBuffer, size, outputBlockCnt, outputBlocks, edd);
757       } else {
758       }
759     }
760
761     // now release all buffers which we have subscribed to
762     iSourceDataBlock=0;
763     lnk=subscribedTaskList.FirstLink();
764     while (lnk) {
765       pSrcTask=(AliHLTTask*)lnk->GetObject();
766       if (pSrcTask) {
767         int iTempRes=0;
768         if ((iTempRes=pSrcTask->Release(&fpBlockDataArray[iSourceDataBlock], this))>=0) {
769           HLTDebug("Task %s (%p) successfully released task %s (%p)", GetName(), this, pSrcTask->GetName(), pSrcTask);
770         } else {
771           HLTError("Task %s (%p): realease of task %s (%p) failed with error %d", GetName(), this, pSrcTask->GetName(), pSrcTask, iTempRes);
772         }
773       } else {
774         HLTFatal("fatal internal error in ROOT list handling");
775         iResult=-EFAULT;
776       }
777       subscribedTaskList.Remove(lnk);
778       lnk=subscribedTaskList.FirstLink();
779       iSourceDataBlock++;
780     }
781     if (subscribedTaskList.GetSize()>0) {
782       HLTError("task %s (%p): could not release all data buffers", GetName(), this);
783     }
784   } else {
785     HLTError("internal failure: task not initialized");
786     iResult=-EFAULT;
787   }
788   return iResult;
789 }
790
791 int AliHLTTask::GetNofMatchingDataBlocks(const AliHLTTask* pConsumerTask)
792 {
793   int iResult=0;
794   if (pConsumerTask) {
795     if (fpDataBuffer) {
796       iResult=fpDataBuffer->FindMatchingDataBlocks(pConsumerTask->GetComponent(), NULL);
797     } else {
798       HLTFatal("internal data buffer missing");
799       iResult=-EFAULT;
800     }
801   } else {
802     iResult=-EINVAL;
803   }
804   return iResult;
805 }
806
807 int AliHLTTask::GetNofMatchingDataTypes(const AliHLTTask* pConsumerTask)
808 {
809   int iResult=0;
810   if (pConsumerTask) {
811     AliHLTComponent* pComponent=GetComponent();
812     if (!pComponent) {
813       // init
814     }
815     if (pComponent) {
816       iResult=pComponent->FindMatchingDataTypes(pConsumerTask->GetComponent(), NULL);
817     } else {
818       HLTFatal("task initialization failed");
819       iResult=-EFAULT;
820     }
821   } else {
822     iResult=-EINVAL;
823   }
824   return iResult;
825 }
826
827 int AliHLTTask::Subscribe(const AliHLTTask* pConsumerTask, AliHLTComponent_BlockData* pBlockDesc, int iArraySize)
828 {
829   int iResult=0;
830   if (pConsumerTask) {
831     if (fpDataBuffer) {
832       iResult=fpDataBuffer->Subscribe(pConsumerTask->GetComponent(), pBlockDesc, iArraySize);
833     } else {
834       HLTFatal("internal data buffer missing");
835       iResult=-EFAULT;
836     }
837   } else {
838     iResult=-EINVAL;
839   }
840   return iResult;
841 }
842
843 int AliHLTTask::Release(AliHLTComponent_BlockData* pBlockDesc, const AliHLTTask* pConsumerTask)
844 {
845   int iResult=0;
846   if (pConsumerTask && pBlockDesc) {
847     if (fpDataBuffer) {
848       iResult=fpDataBuffer->Release(pBlockDesc, pConsumerTask->GetComponent());
849     } else {
850       HLTFatal("internal data buffer missing");
851       iResult=-EFAULT;
852     }
853   } else {
854     iResult=-EINVAL;
855   }
856   return iResult;
857 }
858
859 /* this function is most likely depricated
860 int AliHLTTask::ClearSourceBlocks()
861 {
862   int iResult=0;
863   return iResult;
864 }
865 */
866
867 void AliHLTTask::PrintStatus()
868 {
869   HLTLogKeyword("task properties");
870   if (fpComponent) {
871     HLTMessage("     component: %s (%p)", fpComponent->GetComponentID(), fpComponent);
872   } else {
873     HLTMessage("     no component set!");
874   }
875   if (fpConfiguration) {
876     AliHLTConfiguration* pSrc=fpConfiguration->GetFirstSource();
877     while (pSrc) {
878       const char* pQualifier="unresolved";
879       if (FindDependency(pSrc->GetName()))
880         pQualifier="resolved";
881       HLTMessage("     source: %s (%s)", pSrc->GetName(), pQualifier);
882       pSrc=fpConfiguration->GetNextSource();
883     }
884     TObjLink* lnk = fListTargets.FirstLink();
885     while (lnk) {
886       TObject *obj = lnk->GetObject();
887       HLTMessage("     target: %s", obj->GetName());
888       lnk = lnk->Next();
889     }
890   } else {
891     HLTMessage("     task \"%s\" not initialized", GetName());
892   }
893 }
894
895 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
896
897 TList AliHLTConfigurationHandler::fListConfigurations;
898 TList AliHLTConfigurationHandler::fListDynamicConfigurations;
899
900 /** ROOT macro for the implementation of ROOT specific class methods */
901 ClassImp(AliHLTConfigurationHandler)
902
903 AliHLTConfigurationHandler::AliHLTConfigurationHandler()
904 {
905 }
906
907 AliHLTConfigurationHandler::~AliHLTConfigurationHandler()
908 {
909   TObjLink* lnk=fListDynamicConfigurations.FirstLink();
910   while (lnk) {
911     TObject* obj=lnk->GetObject();
912     if (fListConfigurations.FindObject(obj->GetName())==NULL) {
913       HLTDebug("delete dynamic configuration \"%s\"", obj->GetName());
914       delete obj;
915     }
916     lnk=lnk->Next();
917   }
918 }
919
920 int AliHLTConfigurationHandler::RegisterConfiguration(AliHLTConfiguration* pConf)
921 {
922   int iResult=0;
923   if (pConf) {
924     if (FindConfiguration(pConf->GetName()) == NULL) {
925       fListConfigurations.Add(pConf);
926       //HLTDebug("configuration \"%s\" registered", pConf->GetName());
927
928       // mark all configurations with unresolved dependencies for re-evaluation
929       TObjLink* lnk=fListConfigurations.FirstLink();
930       while (lnk) {
931         AliHLTConfiguration* pSrc=(AliHLTConfiguration*)lnk->GetObject();
932         if (pSrc && pSrc!=pConf && pSrc->SourcesResolved()!=1) {
933           pSrc->InvalidateSources();
934         }
935         lnk=lnk->Next();
936       }
937     } else {
938       iResult=-EEXIST;
939       HLTWarning("configuration \"%s\" already registered", pConf->GetName());
940     }
941   } else {
942     iResult=-EINVAL;
943   }
944   return iResult;
945 }
946
947 int AliHLTConfigurationHandler::CreateConfiguration(const char* id, const char* component, const char* sources, const char* arguments)
948 {
949   int iResult=0;
950   AliHLTConfiguration* pConf= new AliHLTConfiguration(id, component, sources, arguments);
951   if (pConf) {
952     // the configuration will be registered automatically, if this failes the configuration
953     // is missing -> delete it
954     if (FindConfiguration(id)==NULL) {
955       delete pConf;
956       pConf=NULL;
957       iResult=-EEXIST;
958     } else {
959       fListDynamicConfigurations.Add(pConf);
960     }
961   } else {
962     HLTError("system error: object allocation failed");
963     iResult=-ENOMEM;
964   }
965   return iResult;
966 }
967
968 void AliHLTConfigurationHandler::PrintConfigurations()
969 {
970   HLTLogKeyword("configuration listing");
971   HLTMessage("registered configurations:");
972   TObjLink *lnk = fListConfigurations.FirstLink();
973   while (lnk) {
974     TObject *obj = lnk->GetObject();
975     HLTMessage("  %s", obj->GetName());
976     lnk = lnk->Next();
977   }
978 }
979
980 int AliHLTConfigurationHandler::RemoveConfiguration(const char* id)
981 {
982   int iResult=0;
983   if (id) {
984     AliHLTConfiguration* pConf=NULL;
985     if ((pConf=FindConfiguration(id))!=NULL) {
986       iResult=RemoveConfiguration(pConf);
987     } else {
988       HLTWarning("can not find configuration \"%s\"", id);
989       iResult=-ENOENT;
990     }
991   } else {
992     iResult=-EINVAL;
993   }
994   return iResult;
995 }
996
997 int AliHLTConfigurationHandler::RemoveConfiguration(AliHLTConfiguration* pConf)
998 {
999   int iResult=0;
1000   if (pConf) {
1001     // remove the configuration from the list
1002     fListConfigurations.Remove(pConf);
1003     // remove cross links in the remaining configurations
1004     TObjLink* lnk=fListConfigurations.FirstLink();
1005     while (lnk && iResult>=0) {
1006       AliHLTConfiguration* pRem=(AliHLTConfiguration*)lnk->GetObject();
1007       if (pRem) {
1008         pRem->InvalidateSource(pConf);
1009       } else {
1010         iResult=-EFAULT;
1011       }
1012       lnk=lnk->Next();
1013     }
1014   }
1015   return iResult;
1016 }
1017
1018 AliHLTConfiguration* AliHLTConfigurationHandler::FindConfiguration(const char* id)
1019 {
1020   AliHLTConfiguration* pConf=NULL;
1021   if (id) {
1022     pConf=(AliHLTConfiguration*)fListConfigurations.FindObject(id); 
1023   }
1024   return pConf;
1025 }
1026