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 * Timm Steinbeck <timm@kip.uni-heidelberg.de> *
9 * for The ALICE HLT Project. *
11 * Permission to use, copy, modify and distribute this software and its *
12 * documentation strictly for non-commercial purposes is hereby granted *
13 * without fee, provided that the above copyright notice appears in all *
14 * copies and that both the copyright notice and this permission notice *
15 * appear in the supporting documentation. The authors make no claims *
16 * about the suitability of this software for any purpose. It is *
17 * provided "as is" without express or implied warranty. *
18 **************************************************************************/
20 /** @file AliHLTComponentHandler.cxx
21 @author Matthias Richter, Timm Steinbeck
23 @brief Implementation of HLT component handler. */
25 // see header file for class documentation
27 // refer to README to build package
29 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
38 //#include <Riostream.h>
41 //#include "AliHLTStdIncludes.h"
42 #include "AliHLTComponentHandler.h"
43 #include "AliHLTComponent.h"
44 #include "AliHLTDataTypes.h"
45 #include "AliHLTModuleAgent.h"
48 /** ROOT macro for the implementation of ROOT specific class methods */
49 ClassImp(AliHLTComponentHandler)
51 AliHLTComponentHandler::AliHLTComponentHandler()
58 fLibraryMode(kDynamic)
60 // see header file for class documentation
62 // refer to README to build package
64 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
65 memset(&fEnvironment, 0, sizeof(AliHLTComponentEnvironment));
66 AddStandardComponents();
69 AliHLTComponentHandler::AliHLTComponentHandler(AliHLTComponentEnvironment* pEnv)
77 fLibraryMode(kDynamic)
79 // see header file for class documentation
81 memcpy(&fEnvironment, pEnv, sizeof(AliHLTComponentEnvironment));
82 if (pEnv->fLoggingFunc) {
83 // the AliHLTLogging::Init method also sets the stream output
84 // and notification handler to AliLog. This should only be done
85 // if the logging environment contains a logging function
87 AliHLTLogging::Init(pEnv->fLoggingFunc);
90 memset(&fEnvironment, 0, sizeof(AliHLTComponentEnvironment));
93 //SetLocalLoggingLevel(kHLTLogError);
95 //SetLocalLoggingLevel(kHLTLogInfo);
98 AddStandardComponents();
101 AliHLTComponentHandler::~AliHLTComponentHandler()
103 // see header file for class documentation
104 DeleteOwnedComponents();
108 int AliHLTComponentHandler::AnnounceVersion()
110 // see header file for class documentation
112 #ifdef PACKAGE_STRING
113 void HLTbaseCompileInfo( char*& date, char*& time);
116 HLTbaseCompileInfo(date, time);
117 if (!date) date="unknown";
118 if (!time) time="unknown";
119 HLTImportant("%s build on %s (%s)", PACKAGE_STRING, date, time);
121 HLTImportant("ALICE High Level Trigger build on %s (%s) (embedded AliRoot build)", __DATE__, __TIME__);
126 Int_t AliHLTComponentHandler::AddComponent(AliHLTComponent* pSample)
128 // see header file for class documentation
130 if (pSample==NULL) return -EINVAL;
131 if ((iResult=RegisterComponent(pSample))>=0) {
132 //HLTDebug("sample %s (%p) managed by handler", pSample->GetComponentID(), pSample);
133 fOwnedComponents.push_back(pSample);
138 Int_t AliHLTComponentHandler::RegisterComponent(AliHLTComponent* pSample)
140 // see header file for class documentation
143 if (FindComponent(pSample->GetComponentID())==NULL) {
144 iResult=InsertComponent(pSample);
146 HLTInfo("component %s registered", pSample->GetComponentID());
149 // component already registered
150 HLTDebug("component %s already registered, skipped", pSample->GetComponentID());
159 int AliHLTComponentHandler::DeregisterComponent( const char* componentID )
161 // see header file for class documentation
165 HLTWarning("not yet implemented, please notify the developers if you need this function");
172 Int_t AliHLTComponentHandler::ScheduleRegister(AliHLTComponent* pSample)
174 // see header file for class documentation
177 fScheduleList.push_back(pSample);
184 int AliHLTComponentHandler::CreateComponent(const char* componentID, void* pEnvParam, int argc, const char** argv, AliHLTComponent*& component, const char* cdbPath )
186 // see header file for class documentation
189 AliHLTComponent* pSample=FindComponent(componentID);
191 component=pSample->Spawn();
193 HLTDebug("component \"%s\" created (%p)", componentID, component);
195 component->InitCDB(cdbPath, this);
197 if ((iResult=component->Init(&fEnvironment, pEnvParam, argc, argv))!=0) {
198 HLTError("Initialization of component \"%s\" failed with error %d", componentID, iResult);
203 HLTError("can not spawn component \"%s\"", componentID);
207 HLTWarning("can not find component \"%s\"", componentID);
216 Int_t AliHLTComponentHandler::FindComponentIndex(const char* componentID)
218 // see header file for class documentation
221 AliHLTComponentPList::iterator element=fComponentList.begin();
222 while (element!=fComponentList.end() && iResult>=0) {
223 if (strcmp(componentID, (*element)->GetComponentID())==0) {
229 if (element==fComponentList.end()) iResult=-ENOENT;
236 AliHLTComponent* AliHLTComponentHandler::FindComponent(const char* componentID)
238 // see header file for class documentation
239 AliHLTComponent* pSample=NULL;
240 Int_t index=FindComponentIndex(componentID);
242 pSample=(AliHLTComponent*)fComponentList.at(index);
247 Int_t AliHLTComponentHandler::InsertComponent(AliHLTComponent* pSample)
249 // see header file for class documentation
252 fComponentList.push_back(pSample);
259 void AliHLTComponentHandler::List()
261 // see header file for class documentation
262 AliHLTComponentPList::iterator element=fComponentList.begin();
264 while (element!=fComponentList.end()) {
265 HLTInfo("%d. %s", index++, (*element++)->GetComponentID());
269 int AliHLTComponentHandler::HasOutputData( const char* componentID)
271 // see header file for class documentation
273 AliHLTComponent* pSample=FindComponent(componentID);
275 AliHLTComponent::TComponentType ct=AliHLTComponent::kUnknown;
276 ct=pSample->GetComponentType();
277 iResult=(ct==AliHLTComponent::kSource || ct==AliHLTComponent::kProcessor);
284 void AliHLTComponentHandler::SetEnvironment(AliHLTComponentEnvironment* pEnv)
286 // see header file for class documentation
288 memcpy(&fEnvironment, pEnv, sizeof(AliHLTComponentEnvironment));
289 if (fEnvironment.fLoggingFunc) {
290 // the AliHLTLogging::Init method also sets the stream output
291 // and notification handler to AliLog. This should only be done
292 // if the logging environment contains a logging function
294 AliHLTLogging::Init(fEnvironment.fLoggingFunc);
299 AliHLTComponentHandler::TLibraryMode AliHLTComponentHandler::SetLibraryMode(TLibraryMode mode)
301 // see header file for class documentation
302 TLibraryMode old=fLibraryMode;
307 int AliHLTComponentHandler::LoadLibrary( const char* libraryPath, int bActivateAgents)
309 // see header file for class documentation
312 // first activate all agents which are already loaded
313 if (bActivateAgents) ActivateAgents();
315 // set the global component handler for static component registration
316 AliHLTComponent::SetGlobalComponentHandler(this);
318 AliHLTLibHandle hLib;
319 const char* loadtype="";
321 // use interface to the dynamic linking loader
323 // exeption does not help in Root context, the Root exeption
324 // handler always catches the exeption before. Have to find out
325 // how exeptions can be used in Root
327 hLib.fHandle=dlopen(libraryPath, RTLD_NOW);
332 // error message printed further down
333 loadtype="dlopen exeption";
337 // use ROOT dynamic loader
338 // check if the library was already loaded, as Load returns
339 // 'failure' if the library was already loaded
341 AliHLTLibHandle* pLib=FindLibrary(libraryPath);
343 int* pRootHandle=reinterpret_cast<int*>(pLib->fHandle);
345 HLTDebug("instance %d of library %s loaded", (*pRootHandle), libraryPath);
346 hLib.fHandle=pRootHandle;
349 if (hLib.fHandle==NULL && gSystem->Load(libraryPath)>=0) {
350 int* pRootHandle=new int;
351 if (pRootHandle) *pRootHandle=1;
352 hLib.fHandle=pRootHandle;
353 //HLTDebug("library %s loaded via gSystem", libraryPath);
359 // error message printed further down
360 loadtype="gSystem exeption";
363 #endif //HAVE_DLFCN_H
364 if (hLib.fHandle!=NULL) {
365 // create TString object to store library path and use pointer as handle
366 hLib.fName=new TString(libraryPath);
367 hLib.fMode=fLibraryMode;
368 HLTImportant("library %s loaded (%s%s)", libraryPath, hLib.fMode==kStatic?"persistent, ":"", loadtype);
369 fLibraryList.insert(fLibraryList.begin(), hLib);
370 typedef void (*CompileInfo)( char*& date, char*& time);
371 CompileInfo fctInfo=(CompileInfo)FindSymbol(libraryPath, "CompileInfo");
375 (*fctInfo)(date, time);
376 if (!date) date="unknown";
377 if (!time) time="unknown";
378 HLTImportant("build on %s (%s)", date, time);
380 HLTImportant("no build info available (possible AliRoot embedded build)");
383 // static registration of components when library is loaded
384 iResult=RegisterScheduledComponents();
387 HLTError("can not load library %s (%s)", libraryPath, loadtype);
389 HLTError("dlopen error: %s", dlerror());
390 #endif //HAVE_DLFCN_H
397 AliHLTComponent::UnsetGlobalComponentHandler();
400 // alternative dynamic registration by library agents
401 // !!! has to be done after UnsetGlobalComponentHandler
402 if (bActivateAgents) ActivateAgents();
411 int AliHLTComponentHandler::UnloadLibrary( const char* libraryPath )
413 // see header file for class documentation
416 vector<AliHLTLibHandle>::iterator element=fLibraryList.begin();
417 while (element!=fLibraryList.end()) {
418 TString* pName=reinterpret_cast<TString*>((*element).fName);
419 if (pName->CompareTo(libraryPath)==0) {
420 UnloadLibrary(*element);
421 fLibraryList.erase(element);
432 int AliHLTComponentHandler::UnloadLibrary(AliHLTComponentHandler::AliHLTLibHandle &handle)
434 // see header file for class documentation
436 fgAliLoggingFunc=NULL;
437 TString* pName=reinterpret_cast<TString*>(handle.fName);
438 if (handle.fMode!=kStatic) {
440 // exeption does not help in Root context, the Root exeption
441 // handler always catches the exeption before. Have to find out
442 // how exeptions can be used in Root
445 dlclose(handle.fHandle);
449 HLTError("exeption caught during dlclose of library %s", pName!=NULL?pName->Data():"");
453 int* pCount=reinterpret_cast<int*>(handle.fHandle);
454 if (--(*pCount)==0) {
456 /** Matthias 26.04.2007
457 * I spent about a week to investigate a bug which seems to be in ROOT.
458 * Under certain circumstances, TSystem::Unload crashes. The crash occured
459 * for the first time, when libAliHLTUtil was loaded from AliHLTSystem right
460 * after the ComponentHandler was created. It does not occur when dlopen is
462 * It has most likely to do with the garbage collection and automatic
463 * cleanup in ROOT. The crash occurs when ROOT is terminated and before
464 * an instance of AliHLTSystem was created.
465 * root [0] AliHLTSystem gHLT
466 * It does not occur when the instance was created dynamically (but not even
468 * root [0] AliHLTSystem* gHLT=new AliHLTSystem
470 * For that reason, the libraries are not unloaded here, even though there
471 * will be memory leaks.
472 gSystem->Unload(pName->Data());
476 HLTError("missing library name, can not unload");
480 #endif //HAVE_DLFCN_H
482 HLTDebug("unload library %s", pName->Data());
484 HLTWarning("missing name for unloaded library");
496 int AliHLTComponentHandler::UnloadLibraries()
498 // see header file for class documentation
500 vector<AliHLTLibHandle>::iterator element=fLibraryList.begin();
501 while (element!=fLibraryList.end()) {
502 UnloadLibrary(*element);
503 fLibraryList.erase(element);
504 element=fLibraryList.begin();
509 void* AliHLTComponentHandler::FindSymbol(const char* library, const char* symbol)
511 // see header file for class documentation
512 AliHLTLibHandle* hLib=FindLibrary(library);
513 if (hLib==NULL) return NULL;
516 pFunc=dlsym(hLib->fHandle, symbol);
518 TString* name=reinterpret_cast<TString*>(hLib->fName);
519 pFunc=gSystem->DynFindSymbol(name->Data(), symbol);
524 AliHLTComponentHandler::AliHLTLibHandle* AliHLTComponentHandler::FindLibrary(const char* library)
526 // see header file for class documentation
527 AliHLTLibHandle* hLib=NULL;
528 vector<AliHLTLibHandle>::iterator element=fLibraryList.begin();
529 while (element!=fLibraryList.end()) {
530 TString* name=reinterpret_cast<TString*>((*element).fName);
531 if (name->CompareTo(library)==0) {
540 int AliHLTComponentHandler::AddStandardComponents()
542 // see header file for class documentation
544 AliHLTComponent::SetGlobalComponentHandler(this);
545 AliHLTComponent::UnsetGlobalComponentHandler();
546 iResult=RegisterScheduledComponents();
550 int AliHLTComponentHandler::RegisterScheduledComponents()
552 // see header file for class documentation
554 AliHLTComponentPList::iterator element=fScheduleList.begin();
556 while (element!=fScheduleList.end()) {
557 iLocalResult=RegisterComponent(*element);
558 if (iResult==0) iResult=iLocalResult;
559 fScheduleList.erase(element);
560 element=fScheduleList.begin();
565 int AliHLTComponentHandler::ActivateAgents(const AliHLTModuleAgent** blackList, int size)
567 // see header file for class documentation
569 AliHLTModuleAgent* pAgent=AliHLTModuleAgent::GetFirstAgent();
570 while (pAgent && iResult>=0) {
573 for (; i<size; i++) {
574 if (blackList[i]==pAgent) break;
577 // this agent was in the list
578 pAgent=AliHLTModuleAgent::GetNextAgent();
583 pAgent->ActivateComponentHandler(this);
584 pAgent=AliHLTModuleAgent::GetNextAgent();
589 int AliHLTComponentHandler::DeleteOwnedComponents()
591 // see header file for class documentation
593 AliHLTComponentPList::iterator element=fOwnedComponents.begin();
594 while (element!=fOwnedComponents.end()) {
595 //DeregisterComponent((*element)->GetComponentID());
596 // exeption does not help in Root context, the Root exeption
597 // handler always catches the exeption before. Have to find out
598 // how exeptions can be used in Root
604 HLTError("delete managed sample %p", *element);
607 fOwnedComponents.erase(element);
608 element=fOwnedComponents.begin();