3 //**************************************************************************
4 //* This file is property of and copyright by the ALICE HLT Project *
5 //* ALICE Experiment at CERN, All rights reserved. *
7 //* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
8 //* for The ALICE HLT Project. *
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 //**************************************************************************
19 /** @file AliHLTSystem.cxx
20 @author Matthias Richter
22 @brief Implementation of HLT module management.
30 #include "AliHLTStdIncludes.h"
31 #include "AliHLTSystem.h"
32 #include "AliHLTComponentHandler.h"
33 #include "AliHLTComponent.h"
34 #include "AliHLTConfiguration.h"
35 #include "AliHLTConfigurationHandler.h"
36 #include "AliHLTTask.h"
37 #include "AliHLTModuleAgent.h"
38 #include "AliHLTOfflineInterface.h"
39 #include "AliHLTDataSource.h"
40 #include "AliHLTOUT.h"
41 #include "AliHLTOUTHandler.h"
42 #include "AliHLTOUTTask.h"
43 #include <TObjArray.h>
44 #include <TObjString.h>
45 #include <TStopwatch.h>
46 //#include <TSystem.h>
48 //#include <TInterpreter.h>
50 /** HLT default component libraries */
51 const char* AliHLTSystem::fgkHLTDefaultLibs[]= {
55 // "libAliHLTSample.so",
59 "libAliHLTTrigger.so",
63 /** ROOT macro for the implementation of ROOT specific class methods */
64 ClassImp(AliHLTSystem)
66 AliHLTSystem::AliHLTSystem(AliHLTComponentLogSeverity loglevel)
68 fpComponentHandler(AliHLTComponentHandler::CreateHandler()),
69 fpConfigurationHandler(AliHLTConfigurationHandler::CreateHandler()),
73 fStopwatches(new TObjArray),
76 fpChainHandlers(NULL),
78 fpProprietaryHandlers(NULL),
81 // see header file for class documentation
83 // refer to README to build package
85 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
87 if (fgNofInstances++>0) {
88 // July 2008: multiple instances are now allowed
89 // AliHLTSystem is used in multiple instances for the kChain HLTOUT handler
90 //HLTWarning("multiple instances of AliHLTSystem, you should not use more than one at a time");
93 SetGlobalLoggingLevel(loglevel);
94 SetFrameworkLog(loglevel);
95 if (fpComponentHandler) {
96 AliHLTAnalysisEnvironment env;
97 memset(&env, 0, sizeof(AliHLTAnalysisEnvironment));
98 env.fStructSize=sizeof(AliHLTAnalysisEnvironment);
99 env.fAllocMemoryFunc=AliHLTSystem::AllocMemory;
100 env.fLoggingFunc=NULL;
101 fpComponentHandler->SetEnvironment(&env);
102 InitAliLogFunc(fpComponentHandler);
103 if (fgNofInstances==1) {
104 fpComponentHandler->AnnounceVersion();
107 HLTFatal("can not create Component Handler");
109 if (fpConfigurationHandler) {
110 AliHLTConfiguration::GlobalInit(fpConfigurationHandler);
112 HLTFatal("can not create Configuration Handler");
116 AliHLTSystem::~AliHLTSystem()
118 // see header file for class documentation
121 AliHLTConfiguration::GlobalDeinit(fpConfigurationHandler);
122 if (fpConfigurationHandler) {
123 fpConfigurationHandler->Destroy();
125 fpConfigurationHandler=NULL;
127 if (fpComponentHandler) {
128 fpComponentHandler->Destroy();
130 fpComponentHandler=NULL;
133 int AliHLTSystem::fgNofInstances=0;
135 int AliHLTSystem::AddConfiguration(AliHLTConfiguration* pConf)
137 // see header file for class documentation
138 HLTLogKeyword("configuration handling");
141 HLTError("function not yet implemented");
149 int AliHLTSystem::InsertConfiguration(AliHLTConfiguration* pConf, AliHLTConfiguration* pPrec)
151 // see header file for class documentation
152 HLTLogKeyword("configuration handling");
157 HLTError("function not yet implemented");
166 int AliHLTSystem::DeleteConfiguration(AliHLTConfiguration* pConf)
168 // see header file for class documentation
169 HLTLogKeyword("configuration handling");
172 HLTError("function not yet implemented");
180 int AliHLTSystem::BuildTaskList(const char* id)
182 // see header file for class documentation
185 if (fpConfigurationHandler) {
186 AliHLTConfiguration* pConf=fpConfigurationHandler->FindConfiguration(id);
188 iResult=BuildTaskList(pConf);
190 HLTError("unknown configuration \"%s\"", id);
202 int AliHLTSystem::BuildTaskList(AliHLTConfiguration* pConf)
204 // see header file for class documentation
207 AliHLTTask* pTask=NULL;
208 if ((pTask=FindTask(pConf->GetName()))!=NULL) {
209 if (pTask->GetConf()!=pConf) {
210 HLTError("configuration mismatch, there is already a task with configuration name \"%s\", but it is different. Most likely configuration %p is not registered properly", pConf->GetName(), pConf);
213 // task for this configuration exists, terminate
215 } else if (pConf->SourcesResolved(1)!=1) {
216 HLTError("configuration \"%s\" has unresolved sources, aborting ...", pConf->GetName());
219 pTask=new AliHLTTask(pConf);
223 pTask->SetLocalLoggingLevel(GetLocalLoggingLevel());
226 static int iterationLevel=0;
227 if (pTask && iResult>=0) {
228 // check for circular dependencies
229 if ((iResult=pConf->FollowDependency(pConf->GetName()))>0) {
230 HLTError("detected circular dependency for configuration \"%s\"", pTask->GetName());
231 pTask->PrintDependencyTree(pTask->GetName(), 1/*use the configuration list*/);
232 HLTError("aborted ...");
236 // check whether all dependencies are already in the task list
237 // create the missing ones
238 // this step is an iterative process which calls this function again for the missing
239 // configurations, in order to avoid the currently processed task to be created
240 // again it is added to the list temporarily and removed afterwards
241 // This is of high importance to preserve the order of the tasks. Furthermore, the
242 // InsertTask method has to be used in order to set all the cross links right
243 fTaskList.Add(pTask);
244 AliHLTConfiguration* pDep=pConf->GetFirstSource();
245 while (pDep!=NULL && iResult>=0) {
246 HLTDebug("iteration %d: checking dependency %s (%p)", iterationLevel, pDep->GetName(), pDep);
247 if (FindTask(pDep->GetName())==NULL) {
248 HLTDebug("iteration %d: building task list for configuration %s (%p)", iterationLevel, pDep->GetName(), pDep);
250 iResult=BuildTaskList(pDep);
253 pDep=pConf->GetNextSource();
255 // remove the temporarily added task
256 fTaskList.Remove(pTask);
258 // insert the task and set the cross-links
260 HLTDebug("iteration %d: inserting task %s (%p)", iterationLevel, pTask->GetName(), pTask);
261 iResult=InsertTask(pTask);
274 int AliHLTSystem::CleanTaskList()
276 // see header file for class documentation
279 while ((lnk=fTaskList.LastLink())!=NULL) {
280 delete (lnk->GetObject());
281 fTaskList.Remove(lnk);
286 int AliHLTSystem::InsertTask(AliHLTTask* pTask)
288 // see header file for class documentation
290 TObjLink *lnk = NULL;
291 if ((iResult=pTask->CheckDependencies())>0)
292 lnk=fTaskList.FirstLink();
293 while (lnk && iResult>0) {
294 AliHLTTask* pCurr = (AliHLTTask*)lnk->GetObject();
295 //HLTDebug("checking \"%s\"", pCurr->GetName());
296 iResult=pTask->Depends(pCurr);
298 iResult=pTask->SetDependency(pCurr);
299 pCurr->SetTarget(pTask);
300 HLTDebug("set dependency \"%s\" for configuration \"%s\"", pCurr->GetName(), pTask->GetName());
302 if (pCurr->Depends(pTask)) {
303 // circular dependency
304 HLTError("circular dependency: can not resolve dependencies for configuration \"%s\"", pTask->GetName());
306 } else if ((iResult=pTask->CheckDependencies())>0) {
312 fTaskList.AddAfter(lnk, pTask);
314 fTaskList.AddFirst(pTask);
316 HLTDebug("task \"%s\" (%p) inserted (size %d)", pTask->GetName(), pTask, sizeof(AliHLTTask));
317 } else if (iResult>0) {
318 HLTError("can not resolve dependencies for configuration \"%s\" (%d unresolved)", pTask->GetName(), iResult);
324 AliHLTTask* AliHLTSystem::FindTask(const char* id)
326 // see header file for class documentation
327 AliHLTTask* pTask=NULL;
329 pTask=dynamic_cast<AliHLTTask*>(fTaskList.FindObject(id));
334 void AliHLTSystem::PrintTaskList()
336 // see header file for class documentation
337 HLTLogKeyword("task list");
338 TObjLink *lnk = NULL;
339 HLTMessage("Task List");
340 lnk=fTaskList.FirstLink();
342 TObject* obj=lnk->GetObject();
344 HLTMessage(" %s - status:", obj->GetName());
345 AliHLTTask* pTask=(AliHLTTask*)obj;
346 pTask->PrintStatus();
353 int AliHLTSystem::Run(Int_t iNofEvents, int bStop)
355 // see header file for class documentation
358 SetStatusFlags(kRunning);
359 if (fEventCount>=0 || (iResult=InitTasks())>=0) {
360 if (fEventCount>=0 || (iResult=StartTasks())>=0) {
361 if (fEventCount==0) {
362 InitBenchmarking(fStopwatches);
364 ResumeBenchmarking(fStopwatches);
366 for (int i=fEventCount; i<fEventCount+iNofEvents && iResult>=0; i++) {
368 if (iNofEvents>1 && i==fEventCount) {
369 HLTWarning("can not add more than one event to the HLTOUT, skipping all but last block");
371 // reset and prepare for new data
372 fpHLTOUTTask->Reset();
374 if ((iResult=ProcessTasks(i))>=0) {
378 // TODO: define different running modes to either ignore errors in
379 // event processing or not
384 fEventCount+=iNofEvents;
385 if (bStop) StopTasks();
386 else PauseBenchmarking(fStopwatches);
388 if (bStop) DeinitTasks();
392 } else if (iResult==-126 /*ENOKEY*/) {
393 iResult=0; // do not propagate the error
395 ClearStatusFlags(kRunning);
399 int AliHLTSystem::InitTasks()
401 // see header file for class documentation
403 TObjLink *lnk=fTaskList.FirstLink();
406 HLTWarning("Task list is empty, skipping HLT");
407 return -126 /*ENOKEY*/;
409 while (lnk && iResult>=0) {
410 TObject* obj=lnk->GetObject();
412 AliHLTTask* pTask=(AliHLTTask*)obj;
413 iResult=pTask->Init(NULL, fpComponentHandler);
414 // ProcInfo_t ProcInfo;
415 // gSystem->GetProcInfo(&ProcInfo);
416 // HLTInfo("task %s initialized (%d), current memory usage %d %d", pTask->GetName(), iResult, ProcInfo.fMemResident, ProcInfo.fMemVirtual);
422 HLTError("can not initialize task list, error %d", iResult);
428 int AliHLTSystem::InitBenchmarking(TObjArray* pStopwatches)
430 // see header file for class documentation
432 if (pStopwatches==NULL) return 0;
434 for (int i=0; i<(int)AliHLTComponent::kSWTypeCount; i++) {
435 TStopwatch* pStopwatch= new TStopwatch;
438 pStopwatches->AddAt(pStopwatch, i);
445 TObjLink *lnk=fTaskList.FirstLink();
446 while (lnk && iResult>=0) {
447 TObject* obj=lnk->GetObject();
449 AliHLTTask* pTask=(AliHLTTask*)obj;
450 AliHLTComponent* pComp=NULL;
451 if (iResult>=0 && (pComp=pTask->GetComponent())!=NULL) {
452 switch (pComp->GetComponentType()) {
453 case AliHLTComponent::kProcessor:
454 pComp->SetStopwatches(pStopwatches);
456 case AliHLTComponent::kSource:
458 // this switch determines whether the time consumption of the
459 // AliHLTComponent base methods should be counted to the input
460 // stopwatch or base stopwatch.
461 //int inputBase=(int)AliHLTComponent::kSWBase;
462 int inputBase=(int)AliHLTComponent::kSWInput;
463 pComp->SetStopwatch(pStopwatches->At(inputBase), AliHLTComponent::kSWBase);
464 pComp->SetStopwatch(pStopwatches->At((int)AliHLTComponent::kSWInput), AliHLTComponent::kSWDA);
467 case AliHLTComponent::kSink:
469 // this switch determines whether the time consumption of the
470 // AliHLTComponent base methods should be counted to the output
471 // stopwatch or base stopwatch.
472 //int outputBase=(int)AliHLTComponent::kSWBase;
473 int outputBase=(int)AliHLTComponent::kSWOutput;
474 pComp->SetStopwatch(pStopwatches->At(outputBase), AliHLTComponent::kSWBase);
475 pComp->SetStopwatch(pStopwatches->At((int)AliHLTComponent::kSWOutput), AliHLTComponent::kSWDA);
479 HLTWarning("unknown component type %d", (int)pComp->GetComponentType());
489 int AliHLTSystem::PauseBenchmarking(TObjArray* pStopwatches) const
491 // see header file for class documentation
492 if (pStopwatches==NULL) return 0;
494 for (int i=0; i<(int)AliHLTComponent::kSWTypeCount; i++) {
495 if (!pStopwatches->At(i)) continue;
496 TStopwatch* pSw=dynamic_cast<TStopwatch*>(pStopwatches->At(i));
497 if (pSw) pSw->Stop();
502 int AliHLTSystem::ResumeBenchmarking(TObjArray* pStopwatches) const
504 // see header file for class documentation
505 if (pStopwatches==NULL) return 0;
507 for (int i=0; i<(int)AliHLTComponent::kSWTypeCount; i++) {
508 if (!pStopwatches->At(i)) continue;
509 TStopwatch* pSw=dynamic_cast<TStopwatch*>(pStopwatches->At(i));
510 if (pSw) pSw->Continue();
515 int AliHLTSystem::PrintBenchmarking(TObjArray* pStopwatches, int bClean) const
517 // see header file for class documentation
519 if (pStopwatches==NULL) return 0;
521 for (int i=0; i<(int)AliHLTComponent::kSWTypeCount; i++) {
522 if (!dynamic_cast<TStopwatch*>(pStopwatches->At(i))) {
528 if (iInitialized!=0) {
529 HLTImportant("HLT statistics:\n"
530 " base: R:%.3fs C:%.3fs\n"
531 " input: R:%.3fs C:%.3fs\n"
532 " output: R:%.3fs C:%.3fs\n"
533 " event processing : R:%.3fs C:%.3fs"
534 , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWBase))->RealTime()
535 , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWBase))->CpuTime()
536 , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWInput))->RealTime()
537 , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWInput))->CpuTime()
538 , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWOutput))->RealTime()
539 , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWOutput))->CpuTime()
540 , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWDA))->RealTime()
541 , dynamic_cast<TStopwatch*>(pStopwatches->At(AliHLTComponent::kSWDA))->CpuTime()
546 for (int i=0; i<(int)AliHLTComponent::kSWTypeCount; i++) {
547 TObject* pObj=pStopwatches->RemoveAt(i);
548 if (pObj) delete pObj;
554 int AliHLTSystem::StartTasks()
556 // see header file for class documentation
558 TObjLink *lnk=fTaskList.FirstLink();
559 while (lnk && iResult>=0) {
560 TObject* obj=lnk->GetObject();
562 AliHLTTask* pTask=(AliHLTTask*)obj;
563 iResult=pTask->StartRun();
564 // ProcInfo_t ProcInfo;
565 // gSystem->GetProcInfo(&ProcInfo);
566 // HLTInfo("task %s started (%d), current memory usage %d %d", pTask->GetName(), iResult, ProcInfo.fMemResident, ProcInfo.fMemVirtual);
572 HLTError("can not start task list, error %d", iResult);
574 SetStatusFlags(kStarted);
577 if ((iResult=SendControlEvent(kAliHLTDataTypeSOR))<0) {
578 HLTError("can not send SOR event");
584 int AliHLTSystem::ProcessTasks(Int_t eventNo)
586 // see header file for class documentation
588 HLTDebug("processing event no %d", eventNo);
589 TObjLink *lnk=fTaskList.FirstLink();
590 while (lnk && iResult>=0) {
591 TObject* obj=lnk->GetObject();
593 AliHLTTask* pTask=(AliHLTTask*)obj;
594 iResult=pTask->ProcessTask(eventNo);
595 // ProcInfo_t ProcInfo;
596 // gSystem->GetProcInfo(&ProcInfo);
597 // HLTInfo("task %s processed (%d), current memory usage %d %d", pTask->GetName(), iResult, ProcInfo.fMemResident, ProcInfo.fMemVirtual);
604 HLTImportant("Event %d successfully finished (%d)", eventNo, iResult);
607 HLTError("Processing of event %d failed (%d)", eventNo, iResult);
613 int AliHLTSystem::StopTasks()
615 // see header file for class documentation
617 if ((iResult=SendControlEvent(kAliHLTDataTypeEOR))<0) {
618 HLTError("can not send EOR event");
620 TObjLink *lnk=fTaskList.FirstLink();
622 TObject* obj=lnk->GetObject();
624 AliHLTTask* pTask=(AliHLTTask*)obj;
625 int locResult=pTask->EndRun();
626 if (iResult>=0 && locResult<0) iResult=locResult;
627 // ProcInfo_t ProcInfo;
628 // gSystem->GetProcInfo(&ProcInfo);
629 // HLTInfo("task %s stopped (%d), current memory usage %d %d", pTask->GetName(), iResult, ProcInfo.fMemResident, ProcInfo.fMemVirtual);
634 PrintBenchmarking(fStopwatches, 1 /*clean*/);
635 ClearStatusFlags(kStarted);
639 int AliHLTSystem::SendControlEvent(AliHLTComponentDataType dt)
641 // see header file for class documentation
643 // disabled for the moment
647 AliHLTRunDesc runDesc;
648 memset(&runDesc, 0, sizeof(AliHLTRunDesc));
649 runDesc.fStructSize=sizeof(AliHLTRunDesc);
650 AliHLTDataSource::AliSpecialEventGuard g(&runDesc, dt, kAliHLTVoidDataSpec);
651 HLTDebug("sending event %s, run descriptor %p", AliHLTComponent::DataType2Text(dt).c_str(), &runDesc);
652 TObjLink *lnk=fTaskList.FirstLink();
653 while (lnk && iResult>=0) {
654 TObject* obj=lnk->GetObject();
656 AliHLTTask* pTask=(AliHLTTask*)obj;
657 iResult=pTask->ProcessTask(-1);
662 HLTDebug("event %s done (%d)", AliHLTComponent::DataType2Text(dt).c_str(), iResult);
666 int AliHLTSystem::DeinitTasks()
668 // see header file for class documentation
670 TObjLink *lnk=fTaskList.FirstLink();
671 while (lnk && iResult>=0) {
672 TObject* obj=lnk->GetObject();
674 AliHLTTask* pTask=(AliHLTTask*)obj;
675 iResult=pTask->Deinit();
676 // ProcInfo_t ProcInfo;
677 // gSystem->GetProcInfo(&ProcInfo);
678 // HLTInfo("task %s cleaned (%d), current memory usage %d %d", pTask->GetName(), iResult, ProcInfo.fMemResident, ProcInfo.fMemVirtual);
689 void* AliHLTSystem::AllocMemory( void* /*param*/, unsigned long size )
691 // see header file for class documentation
694 p=(void*)new char[size];
698 log.LoggingVarargs(kHLTLogError, "AliHLTSystem" , "AllocMemory" , __FILE__ , __LINE__ , "exeption during memory allocation" );
703 int AliHLTSystem::Reconstruct(int nofEvents, AliRunLoader* runLoader,
704 AliRawReader* rawReader)
706 // see header file for class documentation
708 if (runLoader || rawReader || nofEvents==0) {
709 if (nofEvents>0) {HLTInfo("Run Loader %p, Raw Reader %p , %d event(s)", runLoader, rawReader, nofEvents);}
710 if (CheckStatus(kReady)) {
712 // special case to close the reconstruction
713 if (!CheckStatus(kError)) {
718 if ((iResult=AliHLTOfflineInterface::SetParamsToComponents(runLoader, rawReader))>=0) {
719 // the system always remains started after event processing, a specific
720 // call with nofEvents==0 is needed to execute the stop sequence
721 if ((iResult=Run(nofEvents, 0))<0) SetStatusFlags(kError);
725 HLTError("wrong state %#x, required flags %#x", GetStatusFlags(), kReady);
728 HLTError("missing RunLoader (%p)/RawReader (%p) instance", runLoader, rawReader);
734 int AliHLTSystem::FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd)
736 // see header file for class documentation
738 if (runLoader || esd) {
739 HLTInfo("Event %d: Run Loader %p, ESD %p", eventNo, runLoader, esd);
740 iResult=AliHLTOfflineInterface::FillComponentESDs(eventNo, runLoader, esd);
742 HLTError("missing run loader/ESD instance(s)");
748 int AliHLTSystem::ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd)
750 // see header file for class documentation
752 if (!pHLTOUT) return -EINVAL;
753 HLTDebug("processing %d HLT data blocks", pHLTOUT->GetNofDataBlocks());
755 // add the current HLTOUT task to the collection
757 AliHLTOUT* pTask=dynamic_cast<AliHLTOUT*>(fpHLTOUTTask);
758 if (pTask && (iResult=pTask->Init())>=0) {
759 if (pTask->GetNofDataBlocks()>0) {
760 pHLTOUT->AddSubCollection(pTask);
763 HLTWarning("can not initialize HLTOUT sub collection %s for reconstruction chain (%d), data blocks are lost", pTask?fpHLTOUTTask->GetName():"nil", iResult);
770 // process all kChain handlers first
772 if ((iResult=ProcessHLTOUTkChain(pHLTOUT))<0) {
773 HLTWarning("Processing of kChain-type data blocks failed with error code %d", iResult);
778 fpEsdHandlers=new AliHLTOUT::AliHLTOUTHandlerListEntryVector;
779 if (!fpProprietaryHandlers)
780 fpProprietaryHandlers=new AliHLTOUT::AliHLTOUTHandlerListEntryVector;
782 AliHLTOUT::AliHLTOUTHandlerListEntryVector* pEsdHandlers=reinterpret_cast<AliHLTOUT::AliHLTOUTHandlerListEntryVector*>(fpEsdHandlers);
783 AliHLTOUT::AliHLTOUTHandlerListEntryVector* pProprietaryHandlers=reinterpret_cast<AliHLTOUT::AliHLTOUTHandlerListEntryVector*>(fpProprietaryHandlers);
784 if (!pEsdHandlers || !pProprietaryHandlers) return -ENOMEM;
786 // invalidate all blocks
787 AliHLTOUT::InvalidateBlocks(*pEsdHandlers);
788 AliHLTOUT::InvalidateBlocks(*pProprietaryHandlers);
790 // first come first serve: the ESD of the first handler is also filled into
791 // the main ESD. Has to be changed later.
792 // currently, merging to the provided ESDs crashes at the level of the
793 // TTree::Fill in AliReconstruction, furthermore, the wrong ESD is passed
795 AliESDEvent* pMasterESD=NULL;
798 AliHLTComponentDataTypeList esdBlocks;
800 for (iResult=pHLTOUT->SelectFirstDataBlock();
802 iResult=pHLTOUT->SelectNextDataBlock()) {
803 AliHLTComponentDataType dt=kAliHLTVoidDataType;
804 AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
805 pHLTOUT->GetDataBlockDescription(dt, spec);
806 AliHLTOUTHandler* pHandler=pHLTOUT->GetHandler();
807 AliHLTModuleAgent::AliHLTOUTHandlerType handlerType=pHLTOUT->GetDataBlockHandlerType();
809 // default handling for ESD data blocks does not require an explicite handler
810 if (!pHandler && (dt==kAliHLTDataTypeESDObject || dt==kAliHLTDataTypeESDTree)) {
811 handlerType=AliHLTModuleAgent::kEsd;
813 const char* pMsg="invalid";
814 switch (handlerType) {
815 case AliHLTModuleAgent::kEsd:
818 // schedule for later processing
819 pHLTOUT->InsertHandler(*pEsdHandlers, pHLTOUT->GetDataBlockHandlerDesc());
821 AliHLTComponentDataTypeList::iterator element=esdBlocks.begin();
822 for (; element!=esdBlocks.end(); element++) {
824 HLTWarning("multiple ESDs of identical data type %s, please add appropriate handler to merge ESDs", AliHLTComponent::DataType2Text(dt).c_str());
828 if (element==esdBlocks.end()) esdBlocks.push_back(dt);
831 const AliHLTUInt8_t* pBuffer=NULL;
832 AliHLTUInt32_t size=0;
833 if (pHLTOUT->GetDataBuffer(pBuffer, size)>=0) {
834 pHLTOUT->WriteESD(pBuffer, size, dt);
836 pHLTOUT->WriteESD(pBuffer, size, dt, pMasterESD);
839 pHLTOUT->ReleaseDataBuffer(pBuffer);
841 pHLTOUT->MarkDataBlockProcessed();
845 case AliHLTModuleAgent::kRawReader:
846 // handled in the AliRawReaderHLT
848 case AliHLTModuleAgent::kRawStream:
849 HLTWarning("HLTOUT handler type 'kRawStream' not yet implemented: agent %s, data type %s, specification %#x",
850 pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
851 AliHLTComponent::DataType2Text(dt).c_str(), spec);
853 case AliHLTModuleAgent::kChain:
854 HLTWarning("HLTOUT handler type 'kChain' has already been processed: agent %s, data type %s, specification %#x\n"
855 "New block of this type added by the chain? Skipping data block ...",
856 pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
857 AliHLTComponent::DataType2Text(dt).c_str(), spec);
859 case AliHLTModuleAgent::kProprietary:
860 HLTDebug("processing proprietary data: agent %s, data type %s, specification %#x",
861 pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
862 AliHLTComponent::DataType2Text(dt).c_str(), spec);
864 AliHLTOUT::AliHLTOUTLockGuard g(pHLTOUT);
865 int res=pHandler->ProcessData(pHLTOUT);
867 HLTWarning("processing proprietary data failed (%d): agent %s, data type %s, specification %#x",
868 res, pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
869 AliHLTComponent::DataType2Text(dt).c_str(), spec);
873 case AliHLTModuleAgent::kUnknownOutput:
875 // fall trough intended
877 HLTWarning("%s handler type: agent %s, data type %s, specification %#x, ... skipping data block",
878 pMsg, pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
879 AliHLTComponent::DataType2Text(dt).c_str(), spec);
882 // TODO: the return value of SelectFirst/NextDataBlock must be
883 // changed in order to avoid this check
884 if (iResult==-ENOENT) iResult=0;
886 AliHLTOUT::AliHLTOUTHandlerListEntryVector::iterator handler;
888 // process and write all esd data blocks
889 for (handler=pEsdHandlers->begin(); handler!=pEsdHandlers->end() && iResult>=0; handler++) {
890 AliHLTOUT::AliHLTOUTSelectionGuard g(pHLTOUT, &(*handler));
891 AliHLTOUTHandler* pHandler=*handler;
892 const AliHLTUInt8_t* pBuffer=NULL;
893 AliHLTUInt32_t size=0;
894 pHandler->ProcessData(pHLTOUT);
895 if ((size=pHandler->GetProcessedData(pBuffer))>0) {
896 AliHLTModuleAgent::AliHLTOUTHandlerDesc desc=*handler;
897 AliHLTComponentDataType dt=desc;
898 pHLTOUT->WriteESD(pBuffer, size, dt);
900 pHLTOUT->WriteESD(pBuffer, size, dt, pMasterESD);
903 pHandler->ReleaseProcessedData(pBuffer, size);
905 pHLTOUT->MarkDataBlocksProcessed(&(*handler));
908 // process all kProprietary data blocks
909 for (handler=pProprietaryHandlers->begin(); handler!=pProprietaryHandlers->end() && iResult>=0; handler++) {
910 AliHLTOUT::AliHLTOUTSelectionGuard g(pHLTOUT, &(*handler));
911 AliHLTOUTHandler* pHandler=*handler;
912 const AliHLTUInt8_t* pBuffer=NULL;
913 AliHLTUInt32_t size=0;
914 pHandler->ProcessData(pHLTOUT);
915 if ((size=pHandler->GetProcessedData(pBuffer))>0) {
916 HLTWarning("data produced by kProprietary handler ignored");
917 pHandler->ReleaseProcessedData(pBuffer, size);
919 pHLTOUT->MarkDataBlocksProcessed(&(*handler));
922 // remove all empty handlers form the list (handlers which did not get a block this time)
923 AliHLTOUT::RemoveEmptyDuplicateHandlers(*pEsdHandlers);
924 AliHLTOUT::RemoveEmptyDuplicateHandlers(*pProprietaryHandlers);
929 int AliHLTSystem::ProcessHLTOUTkChain(AliHLTOUT* pHLTOUT)
931 // see header file for class documentation
933 if (!pHLTOUT) return -EINVAL;
935 if (!fpChainHandlers)
936 fpChainHandlers=new AliHLTOUT::AliHLTOUTHandlerListEntryVector;
938 AliHLTOUT::AliHLTOUTHandlerListEntryVector* pChainHandlers=reinterpret_cast<AliHLTOUT::AliHLTOUTHandlerListEntryVector*>(fpChainHandlers);
939 if (!pChainHandlers) return -ENOMEM;
941 // invalidate all blocks
942 AliHLTOUT::InvalidateBlocks(*pChainHandlers);
945 pHLTOUT->FillHandlerList(*pChainHandlers, AliHLTModuleAgent::kChain);
947 // process all defined chain handlers
948 AliHLTOUT::AliHLTOUTHandlerListEntryVector::iterator chainHandler;
949 for (chainHandler=pChainHandlers->begin(); chainHandler!=pChainHandlers->end() && iResult>=0; chainHandler++) {
950 if (chainHandler->IsEmpty()) continue;
951 AliHLTOUT::AliHLTOUTSelectionGuard g(pHLTOUT, &(*chainHandler));
952 AliHLTOUTHandler* pHandler=*chainHandler;
953 const AliHLTUInt8_t* pBuffer=NULL;
954 AliHLTUInt32_t size=0;
955 pHandler->ProcessData(pHLTOUT);
956 if ((size=pHandler->GetProcessedData(pBuffer))>0) {
957 AliHLTModuleAgent::AliHLTOUTHandlerDesc desc=*chainHandler;
958 AliHLTComponentDataType dt=desc;
960 pHandler->ReleaseProcessedData(pBuffer, size);
962 pHLTOUT->MarkDataBlocksProcessed(&(*chainHandler));
965 // remove all empty handlers form the list (handlers which did not get a block this time)
966 AliHLTOUT::RemoveEmptyDuplicateHandlers(*pChainHandlers);
971 int AliHLTSystem::LoadComponentLibraries(const char* libraries)
973 // see header file for class documentation
976 if (fpComponentHandler) {
977 TString libs(libraries);
978 TObjArray* pTokens=libs.Tokenize(" ");
980 int iEntries=pTokens->GetEntries();
981 for (int i=0; i<iEntries && iResult>=0; i++) {
982 iResult=fpComponentHandler->LoadLibrary((((TObjString*)pTokens->At(i))->GetString()).Data());
987 SetStatusFlags(kLibrariesLoaded);
989 // lets see if we need this, probably not
990 //fpComponentHandler->UnloadLibraries();
991 ClearStatusFlags(kLibrariesLoaded);
995 HLTFatal("no component handler available");
1003 int AliHLTSystem::Configure(AliRunLoader* runloader)
1005 // see header file for class documentation
1006 return Configure(NULL, runloader);
1009 int AliHLTSystem::Configure(AliRawReader* rawReader, AliRunLoader* runloader)
1011 // see header file for class documentation
1013 if (CheckStatus(kRunning)) {
1014 HLTError("HLT system in running state, can not configure");
1017 ClearStatusFlags(kTaskListCreated);
1018 if (CheckFilter(kHLTLogDebug))
1019 AliHLTModuleAgent::PrintStatus();
1020 if (CheckStatus(kConfigurationLoaded)==0) {
1021 iResult=LoadConfigurations(rawReader, runloader);
1023 if (fChains.Length()==0) {
1024 HLTError("custom configuration(s) specified, but no configuration to run in local reconstruction, use \'chains=<chain,...>\' option");
1029 SetStatusFlags(kConfigurationLoaded);
1030 if (CheckFilter(kHLTLogDebug))
1031 fpConfigurationHandler->PrintConfigurations();
1032 iResult=BuildTaskListsFromReconstructionChains(rawReader, runloader);
1034 SetStatusFlags(kTaskListCreated);
1037 if (iResult<0) SetStatusFlags(kError);
1042 int AliHLTSystem::ScanOptions(const char* options)
1044 // see header file for class documentation
1047 //AliHLTComponentHandler::TLibraryMode libMode=AliHLTComponentHandler::kDynamic;
1049 TString alloptions(options);
1050 TObjArray* pTokens=alloptions.Tokenize(" ");
1052 int iEntries=pTokens->GetEntries();
1053 for (int i=0; i<iEntries; i++) {
1054 TString token=(((TObjString*)pTokens->At(i))->GetString());
1055 if (token.Contains("loglevel=")) {
1056 TString param=token.ReplaceAll("loglevel=", "");
1057 if (param.IsDigit()) {
1058 SetGlobalLoggingLevel((AliHLTComponentLogSeverity)param.Atoi());
1059 } else if (param.BeginsWith("0x") &&
1060 param.Replace(0,2,"",0).IsHex()) {
1062 sscanf(param.Data(),"%x", &severity);
1063 SetGlobalLoggingLevel((AliHLTComponentLogSeverity)severity);
1065 HLTWarning("wrong parameter for option \'loglevel=\', (hex) number expected");
1067 } else if (token.Contains("frameworklog=")) {
1068 TString param=token.ReplaceAll("frameworklog=", "");
1069 if (param.IsDigit()) {
1070 SetFrameworkLog((AliHLTComponentLogSeverity)param.Atoi());
1071 } else if (param.BeginsWith("0x") &&
1072 param.Replace(0,2,"",0).IsHex()) {
1074 sscanf(param.Data(),"%x", &severity);
1075 SetFrameworkLog((AliHLTComponentLogSeverity)severity);
1077 HLTWarning("wrong parameter for option \'loglevel=\', (hex) number expected");
1079 } else if (token.Contains("alilog=off")) {
1081 } else if (token.Contains("config=")) {
1082 TString param=token.ReplaceAll("config=", "");
1084 gROOT->Macro(param.Data(), &error);
1086 SetStatusFlags(kConfigurationLoaded);
1088 HLTError("can not execute macro \'%s\'", param.Data());
1091 } else if (token.Contains("chains=")) {
1092 TString param=token.ReplaceAll("chains=", "");
1093 fChains=param.ReplaceAll(",", " ");
1094 if (fChains.IsNull()) fChains=" "; // disable all chains
1095 } else if (token.Contains("libmode=")) {
1096 TString param=token.ReplaceAll("libmode=", "");
1097 param.ReplaceAll(",", " ");
1098 if (fpComponentHandler) {
1099 if (param.CompareTo("static")==0) {
1100 fpComponentHandler->SetLibraryMode(AliHLTComponentHandler::kStatic);
1101 } else if (param.CompareTo("dynamic")==0) {
1102 fpComponentHandler->SetLibraryMode(AliHLTComponentHandler::kDynamic);
1104 HLTWarning("wrong argument for option \'libmode=\', use \'static\' or \'dynamic\'");
1107 } else if (token.BeginsWith("lib") && token.EndsWith(".so")) {
1111 HLTWarning("unknown option \'%s\'", token.Data());
1118 if (libs.IsNull()) {
1119 const char** deflib=fgkHLTDefaultLibs;
1125 if ((!CheckStatus(AliHLTSystem::kLibrariesLoaded)) &&
1126 (LoadComponentLibraries(libs.Data())<0)) {
1127 HLTError("error while loading HLT libraries");
1135 int AliHLTSystem::Reset(int bForce)
1137 // see header file for class documentation
1139 if (!bForce && CheckStatus(kRunning)) {
1140 HLTError("HLT system in running state, can not configure");
1144 ClearStatusFlags(~kUninitialized);
1148 int AliHLTSystem::LoadConfigurations(AliRawReader* rawReader, AliRunLoader* runloader)
1150 // see header file for class documentation
1151 if (CheckStatus(kRunning)) {
1152 HLTError("HLT system in running state, can not configure");
1156 AliHLTModuleAgent* pAgent=AliHLTModuleAgent::GetFirstAgent();
1158 while (pAgent && iResult>=0) {
1159 const char* deplibs=pAgent->GetRequiredComponentLibraries();
1161 HLTDebug("required libraries \'%s\' for agent %s (%p)", deplibs, pAgent->GetName(), pAgent);
1165 HLTDebug("load configurations for agent %s (%p)", pAgent->GetName(), pAgent);
1166 pAgent->CreateConfigurations(fpConfigurationHandler, rawReader, runloader);
1167 pAgent=AliHLTModuleAgent::GetNextAgent();
1171 iResult=LoadComponentLibraries(extralibs.Data());
1177 int AliHLTSystem::BuildTaskListsFromReconstructionChains(AliRawReader* rawReader, AliRunLoader* runloader)
1179 // see header file for class documentation
1180 if (CheckStatus(kRunning)) {
1181 HLTError("HLT system in running state, can not configure");
1184 if (!CheckStatus(kConfigurationLoaded)) {
1185 HLTWarning("configurations not yet loaded");
1194 if (fChains.Length()>0) {
1196 HLTImportant("custom reconstruction chain: %s", chains.Data());
1198 AliHLTModuleAgent* pAgent=AliHLTModuleAgent::GetFirstAgent();
1199 while ((pAgent || fChains.Length()>0) && iResult>=0) {
1200 const char* agentchains=pAgent->GetReconstructionChains(rawReader, runloader);
1202 if (!chains.IsNull()) chains+=" ";
1203 chains+=agentchains;
1204 HLTInfo("reconstruction chains for agent %s (%p): %s", pAgent->GetName(), pAgent, agentchains);
1206 pAgent=AliHLTModuleAgent::GetNextAgent();
1210 // build task list for chains
1211 TObjArray* pTokens=chains.Tokenize(" ");
1213 int iEntries=pTokens->GetEntries();
1214 for (int i=0; i<iEntries && iResult>=0; i++) {
1215 const char* pCID=((TObjString*)pTokens->At(i))->GetString().Data();
1216 AliHLTConfiguration* pConf=fpConfigurationHandler->FindConfiguration(pCID);
1218 iResult=BuildTaskList(pConf);
1219 if (true) { // condition was deprecated but kept for sake of svn diff
1220 // bHaveOutput variable has to be set for both running modes
1221 // AliHLTSimulation and AliHLTReconstruction
1222 assert(fpComponentHandler!=NULL);
1223 TString cid=pConf->GetComponentID();
1224 if (runloader!=NULL && cid.CompareTo("HLTOUT")==0) {
1225 // remove from the input of a global HLTOUT configuration
1226 chains.ReplaceAll(pCID, "");
1227 } else if (bHaveOutput==0) {
1228 // check whether this configuration produces data output
1229 if ((bHaveOutput=fpComponentHandler->HasOutputData(cid.Data()))<0) {
1231 chains.ReplaceAll(pCID, "");
1236 HLTWarning("can not find configuration %s", pCID);
1242 // build HLTOUT for simulation
1243 if (iResult>=0 && runloader) {
1245 // there are components in the chain which produce data which need to be
1246 // piped to an HLTOUT
1247 if (fpComponentHandler->FindComponentIndex("HLTOUT")>=0 ||
1248 fpComponentHandler->LoadLibrary("libHLTsim.so")>=0) {
1249 AliHLTConfiguration globalout("_globalout_", "HLTOUT", chains.Data(), NULL);
1250 iResult=BuildTaskList("_globalout_");
1252 HLTError("can not load libHLTsim.so and HLTOUT component");
1258 // build HLTOUT task for reconstruction
1259 // Matthias 08.07.2008 the rawReader is never set when running embedded into
1260 // AliReconstruction. The system is configured during AliHLTReconstructor::Init
1261 // where the RawReader is not available. It is available in the first invocation
1264 // That means that policy is slightly changed:
1265 // - if the run loader is available -> AliSimulation
1266 // - no run loader available -> AliReconstruction
1267 if (iResult>=0 && !runloader) {
1269 // there are components in the chain which produce data which need to be
1270 // piped to an HLTOUT sub-collection
1271 if (!fpHLTOUTTask) {
1272 fpHLTOUTTask=new AliHLTOUTTask(chains.Data());
1274 if (fpHLTOUTTask->GetConf() && fpHLTOUTTask->GetConf()->SourcesResolved()>=0) {
1275 iResult=InsertTask(fpHLTOUTTask);
1277 HLTError("HLTOUT task (%s) sources not resolved", fpHLTOUTTask->GetName());
1285 if (iResult>=0) SetStatusFlags(kTaskListCreated);
1290 int AliHLTSystem::CheckStatus(int flag)
1292 // see header file for class documentation
1293 if (flag==kUninitialized && flag==fState) return 1;
1294 if ((fState&flag)==flag) return 1;
1298 int AliHLTSystem::GetStatusFlags()
1300 // see header file for class documentation
1304 int AliHLTSystem::SetStatusFlags(int flags)
1306 // see header file for class documentation
1311 int AliHLTSystem::ClearStatusFlags(int flags)
1313 // see header file for class documentation
1318 void* AliHLTSystem::FindDynamicSymbol(const char* library, const char* symbol)
1320 // see header file for class documentation
1321 if (fpComponentHandler==NULL) return NULL;
1322 return fpComponentHandler->FindSymbol(library, symbol);
1325 void AliHLTSystem::SetFrameworkLog(AliHLTComponentLogSeverity level)
1327 // see header file for class documentation
1328 SetLocalLoggingLevel(level);
1329 if (fpComponentHandler) fpComponentHandler->SetLocalLoggingLevel(level);
1330 if (fpConfigurationHandler) fpConfigurationHandler->SetLocalLoggingLevel(level);