HLT/BASE/AliHLTSystem.cxx

   1 // $Id$
   2
   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   AliHLTSystem.cxx
  20     @author Matthias Richter
  21     @date
  22     @brief  Implementation of HLT module management.
  23 */
  24
  25 #if __GNUC__>= 3
  26 using namespace std;
  27 #endif
  28
  29 #include <cassert>
  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>
  47 #include <TROOT.h>
  48 //#include <TInterpreter.h>
  49
  50 /** HLT default component libraries */
  51 const char* AliHLTSystem::fgkHLTDefaultLibs[]= {
  52   "libAliHLTUtil.so",
  53   "libAliHLTRCU.so",
  54   "libAliHLTTPC.so",
  55   //  "libAliHLTSample.so",
  56   //"libAliHLTPHOS.so",
  57   "libAliHLTMUON.so",
  58   "libAliHLTTRD.so",
  59   "libAliHLTTrigger.so",
  60   NULL
  61 };
  62
  63 /** ROOT macro for the implementation of ROOT specific class methods */
  64 ClassImp(AliHLTSystem)
  65
  66 AliHLTSystem::AliHLTSystem(AliHLTComponentLogSeverity loglevel)
  67   :
  68   fpComponentHandler(AliHLTComponentHandler::CreateHandler()),
  69   fpConfigurationHandler(AliHLTConfigurationHandler::CreateHandler()),
  70   fTaskList(),
  71   fState(0),
  72   fChains(),
  73   fStopwatches(new TObjArray),
  74   fEventCount(-1),
  75   fGoodEvents(-1),
  76   fpChainHandlers(NULL),
  77   fpEsdHandlers(NULL),
  78   fpProprietaryHandlers(NULL),
  79   fpHLTOUTTask(NULL)
  80 {
  81   // see header file for class documentation
  82   // or
  83   // refer to README to build package
  84   // or
  85   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  86
  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");
  91   }
  92
  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();
 105     }
 106   } else {
 107     HLTFatal("can not create Component Handler");
 108   }
 109   if (fpConfigurationHandler) {
 110     AliHLTConfiguration::GlobalInit(fpConfigurationHandler);
 111   } else {
 112     HLTFatal("can not create Configuration Handler");
 113   }
 114 }
 115
 116 AliHLTSystem::~AliHLTSystem()
 117 {
 118   // see header file for class documentation
 119   fgNofInstances--;
 120   CleanTaskList();
 121   AliHLTConfiguration::GlobalDeinit(fpConfigurationHandler);
 122   if (fpConfigurationHandler) {
 123     fpConfigurationHandler->Destroy();
 124   }
 125   fpConfigurationHandler=NULL;
 126
 127   if (fpComponentHandler) {
 128     fpComponentHandler->Destroy();
 129   }
 130   fpComponentHandler=NULL;
 131 }
 132
 133 int AliHLTSystem::fgNofInstances=0;
 134
 135 int AliHLTSystem::AddConfiguration(AliHLTConfiguration* pConf)
 136 {
 137   // see header file for class documentation
 138   HLTLogKeyword("configuration handling");
 139   int iResult=0;
 140   if (pConf) {
 141     HLTError("function not yet implemented");
 142     iResult=-ENOSYS;
 143   } else {
 144     iResult=-EINVAL;
 145   }
 146   return iResult;
 147 }
 148
 149 int AliHLTSystem::InsertConfiguration(AliHLTConfiguration* pConf, AliHLTConfiguration* pPrec)
 150 {
 151   // see header file for class documentation
 152   HLTLogKeyword("configuration handling");
 153   int iResult=0;
 154   if (pConf) {
 155     if (pPrec) {
 156       // find the position
 157       HLTError("function not yet implemented");
 158       iResult=-ENOSYS;
 159     }
 160   } else {
 161     iResult=-EINVAL;
 162   }
 163   return iResult;
 164 }
 165
 166 int AliHLTSystem::DeleteConfiguration(AliHLTConfiguration* pConf)
 167 {
 168   // see header file for class documentation
 169   HLTLogKeyword("configuration handling");
 170   int iResult=0;
 171   if (pConf) {
 172     HLTError("function not yet implemented");
 173     iResult=-ENOSYS;
 174   } else {
 175     iResult=-EINVAL;
 176   }
 177   return iResult;
 178 }
 179
 180 int AliHLTSystem::BuildTaskList(const char* id)
 181 {
 182   // see header file for class documentation
 183   int iResult=0;
 184   if (id) {
 185     if (fpConfigurationHandler) {
 186       AliHLTConfiguration* pConf=fpConfigurationHandler->FindConfiguration(id);
 187       if (pConf) {
 188         iResult=BuildTaskList(pConf);
 189       } else {
 190         HLTError("unknown configuration \"%s\"", id);
 191         iResult=-EEXIST;
 192       }
 193     } else {
 194       iResult=-EFAULT;
 195     }
 196   } else {
 197     iResult=-EINVAL;
 198   }
 199   return iResult;
 200 }
 201
 202 int AliHLTSystem::BuildTaskList(AliHLTConfiguration* pConf)
 203 {
 204   // see header file for class documentation
 205   int iResult=0;
 206   if (pConf) {
 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);
 211         iResult=-EEXIST;
 212       }
 213       // task for this configuration exists, terminate
 214       pTask=NULL;
 215     } else if (pConf->SourcesResolved(1)!=1) {
 216         HLTError("configuration \"%s\" has unresolved sources, aborting ...", pConf->GetName());
 217         iResult=-ENOLINK;
 218     } else {
 219       pTask=new AliHLTTask(pConf);
 220       if (pTask==NULL) {
 221         iResult=-ENOMEM;
 222       } else {
 223         pTask->SetLocalLoggingLevel(GetLocalLoggingLevel());
 224       }
 225     }
 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 ...");
 233         iResult=-ELOOP;
 234       }
 235       if (iResult>=0) {
 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);
 249             iterationLevel++;
 250             iResult=BuildTaskList(pDep);
 251             iterationLevel--;
 252           }
 253           pDep=pConf->GetNextSource();
 254         }
 255         // remove the temporarily added task
 256         fTaskList.Remove(pTask);
 257
 258         // insert the task and set the cross-links
 259         if (iResult>=0) {
 260           HLTDebug("iteration %d: inserting task %s (%p)", iterationLevel, pTask->GetName(), pTask);
 261           iResult=InsertTask(pTask);
 262         }
 263       } else {
 264         delete pTask;
 265         pTask=NULL;
 266       }
 267     }
 268   } else {
 269     iResult=-EINVAL;
 270   }
 271   return iResult;
 272 }
 273
 274 int AliHLTSystem::CleanTaskList()
 275 {
 276   // see header file for class documentation
 277   int iResult=0;
 278   TObjLink* lnk=NULL;
 279   while ((lnk=fTaskList.LastLink())!=NULL) {
 280     delete (lnk->GetObject());
 281     fTaskList.Remove(lnk);
 282   }
 283   return iResult;
 284 }
 285
 286 int AliHLTSystem::InsertTask(AliHLTTask* pTask)
 287 {
 288   // see header file for class documentation
 289   int iResult=0;
 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);
 297     if (iResult>0) {
 298       iResult=pTask->SetDependency(pCurr);
 299       pCurr->SetTarget(pTask);
 300       HLTDebug("set dependency  \"%s\" for configuration \"%s\"", pCurr->GetName(), pTask->GetName());
 301     }
 302     if (pCurr->Depends(pTask)) {
 303       // circular dependency
 304       HLTError("circular dependency: can not resolve dependencies for configuration \"%s\"", pTask->GetName());
 305       iResult=-ELOOP;
 306     } else if ((iResult=pTask->CheckDependencies())>0) {
 307       lnk = lnk->Next();
 308     }
 309   }
 310   if (iResult==0) {
 311       if (lnk) {
 312         fTaskList.AddAfter(lnk, pTask);
 313       } else {
 314         fTaskList.AddFirst(pTask);
 315       }
 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);
 319     iResult=-ENOLINK;
 320   }
 321   return iResult;
 322 }
 323
 324 AliHLTTask* AliHLTSystem::FindTask(const char* id)
 325 {
 326   // see header file for class documentation
 327   AliHLTTask* pTask=NULL;
 328   if (id) {
 329     pTask=dynamic_cast<AliHLTTask*>(fTaskList.FindObject(id));
 330   }
 331   return pTask;
 332 }
 333
 334 void AliHLTSystem::PrintTaskList()
 335 {
 336   // see header file for class documentation
 337   HLTLogKeyword("task list");
 338   TObjLink *lnk = NULL;
 339   HLTMessage("Task List");
 340   lnk=fTaskList.FirstLink();
 341   while (lnk) {
 342     TObject* obj=lnk->GetObject();
 343     if (obj) {
 344       HLTMessage("  %s - status:", obj->GetName());
 345       AliHLTTask* pTask=(AliHLTTask*)obj;
 346       pTask->PrintStatus();
 347     } else {
 348     }
 349     lnk = lnk->Next();
 350   }
 351 }
 352
 353 int AliHLTSystem::Run(Int_t iNofEvents, int bStop)
 354 {
 355   // see header file for class documentation
 356   int iResult=0;
 357   int iCount=0;
 358   SetStatusFlags(kRunning);
 359   if (fEventCount>=0 || (iResult=InitTasks())>=0) {
 360     if (fEventCount>=0 || (iResult=StartTasks())>=0) {
 361       if (fEventCount==0) {
 362         InitBenchmarking(fStopwatches);
 363       } else {
 364         ResumeBenchmarking(fStopwatches);
 365       }
 366       for (int i=fEventCount; i<fEventCount+iNofEvents && iResult>=0; i++) {
 367         if (fpHLTOUTTask) {
 368           if (iNofEvents>1 && i==fEventCount) {
 369             HLTWarning("can not add more than one event to the HLTOUT, skipping all but last block");
 370           }
 371           // reset and prepare for new data
 372           fpHLTOUTTask->Reset();
 373         }
 374         if ((iResult=ProcessTasks(i))>=0) {
 375           fGoodEvents++;
 376           iCount++;
 377         } else {
 378           // TODO: define different running modes to either ignore errors in
 379           // event processing or not
 380           // currently ignored
 381           iResult=0;
 382         }
 383       }
 384       fEventCount+=iNofEvents;
 385       if (bStop) StopTasks();
 386       else PauseBenchmarking(fStopwatches);
 387     }
 388     if (bStop) DeinitTasks();
 389   }
 390   if (iResult>=0) {
 391     iResult=iCount;
 392   } else  if (iResult==-126 /*ENOKEY*/) {
 393     iResult=0; // do not propagate the error
 394   }
 395   ClearStatusFlags(kRunning);
 396   return iResult;
 397 }
 398
 399 int AliHLTSystem::InitTasks()
 400 {
 401   // see header file for class documentation
 402   int iResult=0;
 403   TObjLink *lnk=fTaskList.FirstLink();
 404
 405   if (lnk==NULL) {
 406     HLTWarning("Task list is empty, skipping HLT");
 407     return -126 /*ENOKEY*/;
 408   }
 409   while (lnk && iResult>=0) {
 410     TObject* obj=lnk->GetObject();
 411     if (obj) {
 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);
 417     } else {
 418     }
 419     lnk = lnk->Next();
 420   }
 421   if (iResult<0) {
 422     HLTError("can not initialize task list, error %d", iResult);
 423   }
 424
 425   return iResult;
 426 }
 427
 428 int AliHLTSystem::InitBenchmarking(TObjArray* pStopwatches)
 429 {
 430   // see header file for class documentation
 431   int iResult=0;
 432   if (pStopwatches==NULL) return 0;
 433
 434   for (int i=0; i<(int)AliHLTComponent::kSWTypeCount; i++) {
 435     TStopwatch* pStopwatch= new TStopwatch;
 436     if (pStopwatch) {
 437       pStopwatch->Reset();
 438       pStopwatches->AddAt(pStopwatch, i);
 439     } else {
 440       iResult=-ENOMEM;
 441       break;
 442     }
 443   }
 444
 445   TObjLink *lnk=fTaskList.FirstLink();
 446   while (lnk && iResult>=0) {
 447     TObject* obj=lnk->GetObject();
 448     if (obj) {
 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);
 455           break;
 456         case AliHLTComponent::kSource:
 457           {
 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);
 465           }
 466           break;
 467         case AliHLTComponent::kSink:
 468           {
 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);
 476           }
 477           break;
 478         default:
 479           HLTWarning("unknown component type %d", (int)pComp->GetComponentType());
 480         }
 481       }
 482     } else {
 483     }
 484     lnk = lnk->Next();
 485   }
 486   return iResult;
 487 }
 488
 489 int AliHLTSystem::PauseBenchmarking(TObjArray* pStopwatches) const
 490 {
 491   // see header file for class documentation
 492   if (pStopwatches==NULL) return 0;
 493
 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();
 498   }
 499   return 0;
 500 }
 501
 502 int AliHLTSystem::ResumeBenchmarking(TObjArray* pStopwatches) const
 503 {
 504   // see header file for class documentation
 505   if (pStopwatches==NULL) return 0;
 506
 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();
 511   }
 512   return 0;
 513 }
 514
 515 int AliHLTSystem::PrintBenchmarking(TObjArray* pStopwatches, int bClean) const
 516 {
 517   // see header file for class documentation
 518   int iInitialized=1;
 519   if (pStopwatches==NULL) return 0;
 520
 521   for (int i=0; i<(int)AliHLTComponent::kSWTypeCount; i++) {
 522     if (!dynamic_cast<TStopwatch*>(pStopwatches->At(i))) {
 523       iInitialized=0;
 524       break;
 525     }
 526   }
 527
 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()
 542             );
 543   }
 544
 545   if (bClean) {
 546     for (int i=0; i<(int)AliHLTComponent::kSWTypeCount; i++) {
 547       TObject* pObj=pStopwatches->RemoveAt(i);
 548       if (pObj) delete pObj;
 549     }
 550   }
 551   return 0;
 552 }
 553
 554 int AliHLTSystem::StartTasks()
 555 {
 556   // see header file for class documentation
 557   int iResult=0;
 558   TObjLink *lnk=fTaskList.FirstLink();
 559   while (lnk && iResult>=0) {
 560     TObject* obj=lnk->GetObject();
 561     if (obj) {
 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);
 567     } else {
 568     }
 569     lnk = lnk->Next();
 570   }
 571   if (iResult<0) {
 572     HLTError("can not start task list, error %d", iResult);
 573   } else {
 574     SetStatusFlags(kStarted);
 575     fEventCount=0;
 576     fGoodEvents=0;
 577     if ((iResult=SendControlEvent(kAliHLTDataTypeSOR))<0) {
 578       HLTError("can not send SOR event");
 579     }
 580   }
 581   return iResult;
 582 }
 583
 584 int AliHLTSystem::ProcessTasks(Int_t eventNo)
 585 {
 586   // see header file for class documentation
 587   int iResult=0;
 588   HLTDebug("processing event no %d", eventNo);
 589   TObjLink *lnk=fTaskList.FirstLink();
 590   while (lnk && iResult>=0) {
 591     TObject* obj=lnk->GetObject();
 592     if (obj) {
 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);
 598     } else {
 599     }
 600     lnk = lnk->Next();
 601   }
 602
 603   if (iResult>=0) {
 604     HLTImportant("Event %d successfully finished (%d)", eventNo, iResult);
 605     iResult=0;
 606   } else {
 607     HLTError("Processing of event %d failed (%d)", eventNo, iResult);
 608   }
 609
 610   return iResult;
 611 }
 612
 613 int AliHLTSystem::StopTasks()
 614 {
 615   // see header file for class documentation
 616   int iResult=0;
 617   if ((iResult=SendControlEvent(kAliHLTDataTypeEOR))<0) {
 618     HLTError("can not send EOR event");
 619   }
 620   TObjLink *lnk=fTaskList.FirstLink();
 621   while (lnk) {
 622     TObject* obj=lnk->GetObject();
 623     if (obj) {
 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);
 630     } else {
 631     }
 632     lnk = lnk->Next();
 633   }
 634   PrintBenchmarking(fStopwatches, 1 /*clean*/);
 635   ClearStatusFlags(kStarted);
 636   return iResult;
 637 }
 638
 639 int AliHLTSystem::SendControlEvent(AliHLTComponentDataType dt)
 640 {
 641   // see header file for class documentation
 642
 643   // disabled for the moment
 644   return 0;
 645
 646   int iResult=0;
 647   AliHLTRunDesc runDesc;
 648   memset(&runDesc, 0, sizeof(AliHLTRunDesc));
 649   runDesc.fStructSize=sizeof(AliHLTRunDesc);
 650   HLTDebug("sending event %s, run descriptor %p", AliHLTComponent::DataType2Text(dt).c_str(), &runDesc);
 651   TObjLink *lnk=fTaskList.FirstLink();
 652   while (lnk && iResult>=0) {
 653     TObject* obj=lnk->GetObject();
 654     if (obj) {
 655       AliHLTTask* pTask=(AliHLTTask*)obj;
 656       iResult=pTask->ProcessTask(-1);
 657     } else {
 658     }
 659     lnk = lnk->Next();
 660   }
 661   HLTDebug("event %s done (%d)", AliHLTComponent::DataType2Text(dt).c_str(), iResult);
 662   return iResult;
 663 }
 664
 665 int AliHLTSystem::DeinitTasks()
 666 {
 667   // see header file for class documentation
 668   int iResult=0;
 669   TObjLink *lnk=fTaskList.FirstLink();
 670   while (lnk && iResult>=0) {
 671     TObject* obj=lnk->GetObject();
 672     if (obj) {
 673       AliHLTTask* pTask=(AliHLTTask*)obj;
 674       iResult=pTask->Deinit();
 675 //       ProcInfo_t ProcInfo;
 676 //       gSystem->GetProcInfo(&ProcInfo);
 677 //       HLTInfo("task %s cleaned (%d), current memory usage %d %d", pTask->GetName(), iResult, ProcInfo.fMemResident, ProcInfo.fMemVirtual);
 678     } else {
 679     }
 680     lnk = lnk->Next();
 681   }
 682   fEventCount=-1;
 683   fGoodEvents=-1;
 684
 685   return iResult;
 686 }
 687
 688 void* AliHLTSystem::AllocMemory( void* /*param*/, unsigned long size )
 689 {
 690   // see header file for class documentation
 691   void* p=NULL;
 692   try {
 693     p=(void*)new char[size];
 694   }
 695   catch (...) {
 696     AliHLTLogging log;
 697     log.LoggingVarargs(kHLTLogError, "AliHLTSystem" , "AllocMemory" , __FILE__ , __LINE__ , "exeption during memory allocation" );
 698   }
 699   return p;
 700 }
 701
 702 int AliHLTSystem::Reconstruct(int nofEvents, AliRunLoader* runLoader,
 703                               AliRawReader* rawReader)
 704 {
 705   // see header file for class documentation
 706   int iResult=0;
 707   if (runLoader || rawReader || nofEvents==0) {
 708     if (nofEvents>0) {HLTInfo("Run Loader %p, Raw Reader %p , %d event(s)", runLoader, rawReader, nofEvents);}
 709     if (CheckStatus(kReady)) {
 710       if (nofEvents==0) {
 711         // special case to close the reconstruction
 712         if (!CheckStatus(kError)) {
 713         StopTasks();
 714         DeinitTasks();
 715         }
 716       } else {
 717       if ((iResult=AliHLTOfflineInterface::SetParamsToComponents(runLoader, rawReader))>=0) {
 718         // the system always remains started after event processing, a specific
 719         // call with nofEvents==0 is needed to execute the stop sequence
 720         if ((iResult=Run(nofEvents, 0))<0) SetStatusFlags(kError);
 721       }
 722       }
 723     } else {
 724       HLTError("wrong state %#x, required flags %#x", GetStatusFlags(), kReady);
 725     }
 726   } else {
 727     HLTError("missing RunLoader (%p)/RawReader (%p) instance", runLoader, rawReader);
 728     iResult=-EINVAL;
 729   }
 730   return iResult;
 731 }
 732
 733 int AliHLTSystem::FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd)
 734 {
 735   // see header file for class documentation
 736   int iResult=0;
 737   if (runLoader || esd) {
 738     HLTInfo("Event %d: Run Loader %p, ESD %p", eventNo, runLoader, esd);
 739     iResult=AliHLTOfflineInterface::FillComponentESDs(eventNo, runLoader, esd);
 740   } else {
 741     HLTError("missing run loader/ESD instance(s)");
 742     iResult=-EINVAL;
 743   }
 744   return iResult;
 745 }
 746
 747 int AliHLTSystem::ProcessHLTOUT(AliHLTOUT* pHLTOUT, AliESDEvent* esd)
 748 {
 749   // see header file for class documentation
 750   int iResult=0;
 751   if (!pHLTOUT) return -EINVAL;
 752   HLTDebug("processing %d HLT data blocks", pHLTOUT->GetNofDataBlocks());
 753
 754   // add the current HLTOUT task to the collection
 755   if (fpHLTOUTTask) {
 756     AliHLTOUT* pTask=dynamic_cast<AliHLTOUT*>(fpHLTOUTTask);
 757     if (pTask && (iResult=pTask->Init())>=0) {
 758       if (pTask->GetNofDataBlocks()>0) {
 759         pHLTOUT->AddSubCollection(pTask);
 760       }
 761     } else {
 762       HLTWarning("can not initialize HLTOUT sub collection %s for reconstruction chain (%d), data blocks are lost", pTask?fpHLTOUTTask->GetName():"nil", iResult);
 763       iResult=0;
 764     }
 765   }
 766
 767
 768   //
 769   // process all kChain handlers first
 770   //
 771   if ((iResult=ProcessHLTOUTkChain(pHLTOUT))<0) {
 772     HLTWarning("Processing of kChain-type data blocks failed with error code %d", iResult);
 773     iResult=0;
 774   }
 775
 776   if (!fpEsdHandlers)
 777     fpEsdHandlers=new AliHLTOUT::AliHLTOUTHandlerListEntryVector;
 778   if (!fpProprietaryHandlers)
 779     fpProprietaryHandlers=new AliHLTOUT::AliHLTOUTHandlerListEntryVector;
 780
 781   AliHLTOUT::AliHLTOUTHandlerListEntryVector* pEsdHandlers=reinterpret_cast<AliHLTOUT::AliHLTOUTHandlerListEntryVector*>(fpEsdHandlers);
 782   AliHLTOUT::AliHLTOUTHandlerListEntryVector* pProprietaryHandlers=reinterpret_cast<AliHLTOUT::AliHLTOUTHandlerListEntryVector*>(fpProprietaryHandlers);
 783   if (!pEsdHandlers || !pProprietaryHandlers) return -ENOMEM;
 784
 785   // invalidate all blocks
 786   AliHLTOUT::InvalidateBlocks(*pEsdHandlers);
 787   AliHLTOUT::InvalidateBlocks(*pProprietaryHandlers);
 788
 789   // first come first serve: the ESD of the first handler is also filled into
 790   // the main ESD. Has to be changed later.
 791   // currently, merging to the provided ESDs crashes at the level of the
 792   // TTree::Fill in AliReconstruction, furthermore, the wrong ESD is passed
 793   // by the framework
 794   AliESDEvent* pMasterESD=NULL;
 795   pMasterESD=esd;
 796
 797   AliHLTComponentDataTypeList esdBlocks;
 798
 799   for (iResult=pHLTOUT->SelectFirstDataBlock();
 800        iResult>=0;
 801        iResult=pHLTOUT->SelectNextDataBlock()) {
 802     AliHLTComponentDataType dt=kAliHLTVoidDataType;
 803     AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
 804     pHLTOUT->GetDataBlockDescription(dt, spec);
 805     AliHLTOUTHandler* pHandler=pHLTOUT->GetHandler();
 806     AliHLTModuleAgent::AliHLTOUTHandlerType handlerType=pHLTOUT->GetDataBlockHandlerType();
 807
 808     // default handling for ESD data blocks does not require an explicite handler
 809     if (!pHandler && (dt==kAliHLTDataTypeESDObject || dt==kAliHLTDataTypeESDTree)) {
 810       handlerType=AliHLTModuleAgent::kEsd;
 811     }
 812     const char* pMsg="invalid";
 813     switch (handlerType) {
 814     case AliHLTModuleAgent::kEsd:
 815       {
 816         if (pHandler) {
 817           // schedule for later processing
 818           pHLTOUT->InsertHandler(*pEsdHandlers, pHLTOUT->GetDataBlockHandlerDesc());
 819         } else {
 820           AliHLTComponentDataTypeList::iterator element=esdBlocks.begin();
 821           for (; element!=esdBlocks.end(); element++) {
 822             if (*element==dt) {
 823               HLTWarning("multiple ESDs of identical data type %s, please add appropriate handler to merge ESDs", AliHLTComponent::DataType2Text(dt).c_str());
 824               break;
 825             }
 826           }
 827           if (element==esdBlocks.end()) esdBlocks.push_back(dt);
 828
 829           // write directly
 830           const AliHLTUInt8_t* pBuffer=NULL;
 831           AliHLTUInt32_t size=0;
 832           if (pHLTOUT->GetDataBuffer(pBuffer, size)>=0) {
 833             pHLTOUT->WriteESD(pBuffer, size, dt);
 834             if (pMasterESD) {
 835               pHLTOUT->WriteESD(pBuffer, size, dt, pMasterESD);
 836               pMasterESD=NULL;
 837             }
 838             pHLTOUT->ReleaseDataBuffer(pBuffer);
 839           }
 840           pHLTOUT->MarkDataBlockProcessed();
 841         }
 842       }
 843       break;
 844     case AliHLTModuleAgent::kRawReader:
 845       // handled in the AliRawReaderHLT
 846       break;
 847     case AliHLTModuleAgent::kRawStream:
 848       HLTWarning("HLTOUT handler type 'kRawStream' not yet implemented: agent %s, data type %s, specification %#x",
 849                  pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
 850                  AliHLTComponent::DataType2Text(dt).c_str(), spec);
 851       break;
 852     case AliHLTModuleAgent::kChain:
 853       HLTWarning("HLTOUT handler type 'kChain' has already been processed: agent %s, data type %s, specification %#x\n"
 854                  "New block of this type added by the chain? Skipping data block ...",
 855                  pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
 856                  AliHLTComponent::DataType2Text(dt).c_str(), spec);
 857       break;
 858     case AliHLTModuleAgent::kProprietary:
 859       HLTDebug("processing proprietary data: agent %s, data type %s, specification %#x",
 860                  pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
 861                  AliHLTComponent::DataType2Text(dt).c_str(), spec);
 862       if (pHandler) {
 863         AliHLTOUT::AliHLTOUTLockGuard g(pHLTOUT);
 864         int res=pHandler->ProcessData(pHLTOUT);
 865         if (res<0) {
 866           HLTWarning("processing proprietary data failed (%d): agent %s, data type %s, specification %#x",
 867                      res, pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
 868                      AliHLTComponent::DataType2Text(dt).c_str(), spec);
 869         }
 870       }
 871       break;
 872     case AliHLTModuleAgent::kUnknownOutput:
 873       pMsg="unknown";
 874       // fall trough intended
 875     default:
 876       HLTWarning("%s handler type: agent %s, data type %s, specification %#x, ... skipping data block",
 877                  pMsg, pHLTOUT->GetAgent()?pHLTOUT->GetAgent()->GetModuleId():"<invalid>",
 878                  AliHLTComponent::DataType2Text(dt).c_str(), spec);
 879     }
 880   }
 881   // TODO: the return value of SelectFirst/NextDataBlock must be
 882   // changed in order to avoid this check
 883   if (iResult==-ENOENT) iResult=0;
 884
 885   AliHLTOUT::AliHLTOUTHandlerListEntryVector::iterator handler;
 886
 887   // process and write all esd data blocks
 888   for (handler=pEsdHandlers->begin(); handler!=pEsdHandlers->end() && iResult>=0; handler++) {
 889     AliHLTOUT::AliHLTOUTSelectionGuard g(pHLTOUT, &(*handler));
 890     AliHLTOUTHandler* pHandler=*handler;
 891     const AliHLTUInt8_t* pBuffer=NULL;
 892     AliHLTUInt32_t size=0;
 893     pHandler->ProcessData(pHLTOUT);
 894     if ((size=pHandler->GetProcessedData(pBuffer))>0) {
 895       AliHLTModuleAgent::AliHLTOUTHandlerDesc desc=*handler;
 896       AliHLTComponentDataType dt=desc;
 897       pHLTOUT->WriteESD(pBuffer, size, dt);
 898       if (pMasterESD) {
 899         pHLTOUT->WriteESD(pBuffer, size, dt, pMasterESD);
 900         pMasterESD=NULL;
 901       }
 902       pHandler->ReleaseProcessedData(pBuffer, size);
 903     }
 904     pHLTOUT->MarkDataBlocksProcessed(&(*handler));
 905   }
 906
 907   // process all kProprietary data blocks
 908   for (handler=pProprietaryHandlers->begin(); handler!=pProprietaryHandlers->end() && iResult>=0; handler++) {
 909     AliHLTOUT::AliHLTOUTSelectionGuard g(pHLTOUT, &(*handler));
 910     AliHLTOUTHandler* pHandler=*handler;
 911     const AliHLTUInt8_t* pBuffer=NULL;
 912     AliHLTUInt32_t size=0;
 913     pHandler->ProcessData(pHLTOUT);
 914     if ((size=pHandler->GetProcessedData(pBuffer))>0) {
 915       HLTWarning("data produced by kProprietary handler ignored");
 916       pHandler->ReleaseProcessedData(pBuffer, size);
 917     }
 918     pHLTOUT->MarkDataBlocksProcessed(&(*handler));
 919   }
 920
 921   // remove all empty handlers form the list (handlers which did not get a block this time)
 922   AliHLTOUT::RemoveEmptyDuplicateHandlers(*pEsdHandlers);
 923   AliHLTOUT::RemoveEmptyDuplicateHandlers(*pProprietaryHandlers);
 924
 925   return iResult;
 926 }
 927
 928 int AliHLTSystem::ProcessHLTOUTkChain(AliHLTOUT* pHLTOUT)
 929 {
 930   // see header file for class documentation
 931   int iResult=0;
 932   if (!pHLTOUT) return -EINVAL;
 933
 934   if (!fpChainHandlers)
 935     fpChainHandlers=new AliHLTOUT::AliHLTOUTHandlerListEntryVector;
 936
 937   AliHLTOUT::AliHLTOUTHandlerListEntryVector* pChainHandlers=reinterpret_cast<AliHLTOUT::AliHLTOUTHandlerListEntryVector*>(fpChainHandlers);
 938   if (!pChainHandlers) return -ENOMEM;
 939
 940   // invalidate all blocks
 941   AliHLTOUT::InvalidateBlocks(*pChainHandlers);
 942
 943   // fill the list
 944   pHLTOUT->FillHandlerList(*pChainHandlers, AliHLTModuleAgent::kChain);
 945
 946   // process all defined chain handlers
 947   AliHLTOUT::AliHLTOUTHandlerListEntryVector::iterator chainHandler;
 948   for (chainHandler=pChainHandlers->begin(); chainHandler!=pChainHandlers->end() && iResult>=0; chainHandler++) {
 949     if (chainHandler->IsEmpty()) continue;
 950     AliHLTOUT::AliHLTOUTSelectionGuard g(pHLTOUT, &(*chainHandler));
 951     AliHLTOUTHandler* pHandler=*chainHandler;
 952     const AliHLTUInt8_t* pBuffer=NULL;
 953     AliHLTUInt32_t size=0;
 954     pHandler->ProcessData(pHLTOUT);
 955     if ((size=pHandler->GetProcessedData(pBuffer))>0) {
 956       AliHLTModuleAgent::AliHLTOUTHandlerDesc desc=*chainHandler;
 957       AliHLTComponentDataType dt=desc;
 958
 959       pHandler->ReleaseProcessedData(pBuffer, size);
 960     }
 961     pHLTOUT->MarkDataBlocksProcessed(&(*chainHandler));
 962   }
 963
 964   // remove all empty handlers form the list (handlers which did not get a block this time)
 965   AliHLTOUT::RemoveEmptyDuplicateHandlers(*pChainHandlers);
 966
 967   return iResult;
 968 }
 969
 970 int AliHLTSystem::LoadComponentLibraries(const char* libraries)
 971 {
 972   // see header file for class documentation
 973   int iResult=0;
 974   if (libraries) {
 975     if (fpComponentHandler) {
 976       TString libs(libraries);
 977       TObjArray* pTokens=libs.Tokenize(" ");
 978       if (pTokens) {
 979         int iEntries=pTokens->GetEntries();
 980         for (int i=0; i<iEntries && iResult>=0; i++) {
 981           iResult=fpComponentHandler->LoadLibrary((((TObjString*)pTokens->At(i))->GetString()).Data());
 982         }
 983         delete pTokens;
 984       }
 985       if (iResult>=0) {
 986         SetStatusFlags(kLibrariesLoaded);
 987       } else {
 988         // lets see if we need this, probably not
 989         //fpComponentHandler->UnloadLibraries();
 990         ClearStatusFlags(kLibrariesLoaded);
 991       }
 992     } else {
 993       iResult=-EFAULT;
 994       HLTFatal("no component handler available");
 995     }
 996   } else {
 997     iResult=-EINVAL;
 998   }
 999   return iResult;
1000 }
1001
1002 int AliHLTSystem::Configure(AliRunLoader* runloader)
1003 {
1004   // see header file for class documentation
1005   return Configure(NULL, runloader);
1006 }
1007
1008 int AliHLTSystem::Configure(AliRawReader* rawReader, AliRunLoader* runloader)
1009 {
1010   // see header file for class documentation
1011   int iResult=0;
1012   if (CheckStatus(kRunning)) {
1013     HLTError("HLT system in running state, can not configure");
1014     return -EBUSY;
1015   }
1016   ClearStatusFlags(kTaskListCreated);
1017   if (CheckFilter(kHLTLogDebug))
1018     AliHLTModuleAgent::PrintStatus();
1019   if (CheckStatus(kConfigurationLoaded)==0) {
1020     iResult=LoadConfigurations(rawReader, runloader);
1021   } else {
1022     if (fChains.Length()==0) {
1023       HLTError("custom configuration(s) specified, but no configuration to run in local reconstruction, use \'chains=<chain,...>\' option");
1024       iResult=-ENOENT;
1025     }
1026   }
1027   if (iResult>=0) {
1028     SetStatusFlags(kConfigurationLoaded);
1029     if (CheckFilter(kHLTLogDebug))
1030       fpConfigurationHandler->PrintConfigurations();
1031     iResult=BuildTaskListsFromReconstructionChains(rawReader, runloader);
1032     if (iResult>=0) {
1033       SetStatusFlags(kTaskListCreated);
1034     }
1035   }
1036   if (iResult<0) SetStatusFlags(kError);
1037
1038   return iResult;
1039 }
1040
1041 int AliHLTSystem::ScanOptions(const char* options)
1042 {
1043   // see header file for class documentation
1044   int iResult=0;
1045   if (options) {
1046     //AliHLTComponentHandler::TLibraryMode libMode=AliHLTComponentHandler::kDynamic;
1047     TString libs("");
1048     TString alloptions(options);
1049     TObjArray* pTokens=alloptions.Tokenize(" ");
1050     if (pTokens) {
1051       int iEntries=pTokens->GetEntries();
1052       for (int i=0; i<iEntries; i++) {
1053         TString token=(((TObjString*)pTokens->At(i))->GetString());
1054         if (token.Contains("loglevel=")) {
1055           TString param=token.ReplaceAll("loglevel=", "");
1056           if (param.IsDigit()) {
1057             SetGlobalLoggingLevel((AliHLTComponentLogSeverity)param.Atoi());
1058           } else if (param.BeginsWith("0x") &&
1059                      param.Replace(0,2,"",0).IsHex()) {
1060             int severity=0;
1061             sscanf(param.Data(),"%x", &severity);
1062             SetGlobalLoggingLevel((AliHLTComponentLogSeverity)severity);
1063           } else {
1064             HLTWarning("wrong parameter for option \'loglevel=\', (hex) number expected");
1065           }
1066         } else if (token.Contains("frameworklog=")) {
1067           TString param=token.ReplaceAll("frameworklog=", "");
1068           if (param.IsDigit()) {
1069             SetFrameworkLog((AliHLTComponentLogSeverity)param.Atoi());
1070           } else if (param.BeginsWith("0x") &&
1071                      param.Replace(0,2,"",0).IsHex()) {
1072             int severity=0;
1073             sscanf(param.Data(),"%x", &severity);
1074             SetFrameworkLog((AliHLTComponentLogSeverity)severity);
1075           } else {
1076             HLTWarning("wrong parameter for option \'loglevel=\', (hex) number expected");
1077           }
1078         } else if (token.Contains("alilog=off")) {
1079           SwitchAliLog(0);
1080         } else if (token.Contains("config=")) {
1081           TString param=token.ReplaceAll("config=", "");
1082           Int_t error=0;
1083           gROOT->Macro(param.Data(), &error);
1084           if (error==0) {
1085             SetStatusFlags(kConfigurationLoaded);
1086           } else {
1087             HLTError("can not execute macro \'%s\'", param.Data());
1088             iResult=-EBADF;
1089           }
1090         } else if (token.Contains("chains=")) {
1091           TString param=token.ReplaceAll("chains=", "");
1092           fChains=param.ReplaceAll(",", " ");
1093           if (fChains.IsNull()) fChains=" "; // disable all chains
1094         } else if (token.Contains("libmode=")) {
1095           TString param=token.ReplaceAll("libmode=", "");
1096           param.ReplaceAll(",", " ");
1097           if (fpComponentHandler) {
1098             if (param.CompareTo("static")==0) {
1099               fpComponentHandler->SetLibraryMode(AliHLTComponentHandler::kStatic);
1100             } else if (param.CompareTo("dynamic")==0) {
1101               fpComponentHandler->SetLibraryMode(AliHLTComponentHandler::kDynamic);
1102             } else {
1103               HLTWarning("wrong argument for option \'libmode=\', use \'static\' or \'dynamic\'");
1104             }
1105           }
1106         } else if (token.BeginsWith("lib") && token.EndsWith(".so")) {
1107           libs+=token;
1108           libs+=" ";
1109         } else {
1110           HLTWarning("unknown option \'%s\'", token.Data());
1111         }
1112       }
1113       delete pTokens;
1114     }
1115
1116     if (iResult>=0) {
1117       if (libs.IsNull()) {
1118         const char** deflib=fgkHLTDefaultLibs;
1119         while (*deflib) {
1120           libs+=*deflib++;
1121           libs+=" ";
1122         }
1123       }
1124       if ((!CheckStatus(AliHLTSystem::kLibrariesLoaded)) &&
1125           (LoadComponentLibraries(libs.Data())<0)) {
1126         HLTError("error while loading HLT libraries");
1127         iResult=-EFAULT;
1128       }
1129     }
1130   }
1131   return iResult;
1132 }
1133
1134 int AliHLTSystem::Reset(int bForce)
1135 {
1136   // see header file for class documentation
1137   int iResult=0;
1138   if (!bForce && CheckStatus(kRunning)) {
1139     HLTError("HLT system in running state, can not configure");
1140     return -EBUSY;
1141   }
1142   CleanTaskList();
1143   ClearStatusFlags(~kUninitialized);
1144   return iResult;
1145 }
1146
1147 int AliHLTSystem::LoadConfigurations(AliRawReader* rawReader, AliRunLoader* runloader)
1148 {
1149   // see header file for class documentation
1150   if (CheckStatus(kRunning)) {
1151     HLTError("HLT system in running state, can not configure");
1152     return -EBUSY;
1153   }
1154   int iResult=0;
1155   AliHLTModuleAgent* pAgent=AliHLTModuleAgent::GetFirstAgent();
1156   TString extralibs;
1157   while (pAgent && iResult>=0) {
1158     const char* deplibs=pAgent->GetRequiredComponentLibraries();
1159     if (deplibs) {
1160       HLTDebug("required libraries \'%s\' for agent %s (%p)", deplibs, pAgent->GetName(), pAgent);
1161       extralibs+=deplibs;
1162     }
1163     if (iResult>=0) {
1164       HLTDebug("load configurations for agent %s (%p)", pAgent->GetName(), pAgent);
1165       pAgent->CreateConfigurations(fpConfigurationHandler, rawReader, runloader);
1166       pAgent=AliHLTModuleAgent::GetNextAgent();
1167     }
1168   }
1169   if (iResult>=0) {
1170     iResult=LoadComponentLibraries(extralibs.Data());
1171   }
1172
1173   return iResult;
1174 }
1175
1176 int AliHLTSystem::BuildTaskListsFromReconstructionChains(AliRawReader* rawReader, AliRunLoader* runloader)
1177 {
1178   // see header file for class documentation
1179   if (CheckStatus(kRunning)) {
1180     HLTError("HLT system in running state, can not configure");
1181     return -EBUSY;
1182   }
1183   if (!CheckStatus(kConfigurationLoaded)) {
1184     HLTWarning("configurations not yet loaded");
1185     return 0;
1186   }
1187
1188   int iResult=0;
1189   int bHaveOutput=0;
1190
1191   // query chains
1192   TString chains;
1193   if (fChains.Length()>0) {
1194     chains=fChains;
1195     HLTImportant("custom reconstruction chain: %s", chains.Data());
1196   } else {
1197     AliHLTModuleAgent* pAgent=AliHLTModuleAgent::GetFirstAgent();
1198     while ((pAgent || fChains.Length()>0) && iResult>=0) {
1199       const char* agentchains=pAgent->GetReconstructionChains(rawReader, runloader);
1200       if (agentchains) {
1201         if (!chains.IsNull()) chains+=" ";
1202         chains+=agentchains;
1203         HLTInfo("reconstruction chains for agent %s (%p): %s", pAgent->GetName(), pAgent, agentchains);
1204       }
1205       pAgent=AliHLTModuleAgent::GetNextAgent();
1206     }
1207   }
1208
1209   // build task list for chains
1210   TObjArray* pTokens=chains.Tokenize(" ");
1211   if (pTokens) {
1212     int iEntries=pTokens->GetEntries();
1213     for (int i=0; i<iEntries && iResult>=0; i++) {
1214       const char* pCID=((TObjString*)pTokens->At(i))->GetString().Data();
1215       AliHLTConfiguration* pConf=fpConfigurationHandler->FindConfiguration(pCID);
1216       if (pConf) {
1217         iResult=BuildTaskList(pConf);
1218         if (true) { // condition was deprecated but kept for sake of svn diff
1219           // bHaveOutput variable has to be set for both running modes
1220           // AliHLTSimulation and AliHLTReconstruction
1221           assert(fpComponentHandler!=NULL);
1222           TString cid=pConf->GetComponentID();
1223           if (runloader!=NULL && cid.CompareTo("HLTOUT")==0) {
1224             // remove from the input of a global HLTOUT configuration
1225             chains.ReplaceAll(pCID, "");
1226           } else if (bHaveOutput==0) {
1227             // check whether this configuration produces data output
1228             if ((bHaveOutput=fpComponentHandler->HasOutputData(cid.Data()))<0) {
1229               bHaveOutput=0;
1230               chains.ReplaceAll(pCID, "");
1231             }
1232           }
1233         }
1234       } else {
1235         HLTWarning("can not find configuration %s", pCID);
1236       }
1237     }
1238     delete pTokens;
1239   }
1240
1241   // build HLTOUT for simulation
1242   if (iResult>=0 && runloader) {
1243     if (bHaveOutput) {
1244       // there are components in the chain which produce data which need to be
1245       // piped to an HLTOUT
1246       if (fpComponentHandler->FindComponentIndex("HLTOUT")>=0 ||
1247           fpComponentHandler->LoadLibrary("libHLTsim.so")>=0) {
1248         AliHLTConfiguration globalout("_globalout_", "HLTOUT", chains.Data(), NULL);
1249         iResult=BuildTaskList("_globalout_");
1250       } else {
1251         HLTError("can not load libHLTsim.so and HLTOUT component");
1252         iResult=-EFAULT;
1253       }
1254     }
1255   }
1256
1257   // build HLTOUT task for reconstruction
1258   // Matthias 08.07.2008 the rawReader is never set when running embedded into
1259   // AliReconstruction. The system is configured during AliHLTReconstructor::Init
1260   // where the RawReader is not available. It is available in the first invocation
1261   // of Reconstruct.
1262   //
1263   // That means that policy is slightly changed:
1264   // - if the run loader is available -> AliSimulation
1265   // - no run loader available -> AliReconstruction
1266   if (iResult>=0 && !runloader) {
1267     if (bHaveOutput) {
1268       // there are components in the chain which produce data which need to be
1269       // piped to an HLTOUT sub-collection
1270       if (!fpHLTOUTTask) {
1271         fpHLTOUTTask=new AliHLTOUTTask(chains.Data());
1272         if (fpHLTOUTTask) {
1273           if (fpHLTOUTTask->GetConf() && fpHLTOUTTask->GetConf()->SourcesResolved()>=0) {
1274             iResult=InsertTask(fpHLTOUTTask);
1275           } else {
1276             HLTError("HLTOUT task (%s) sources not resolved", fpHLTOUTTask->GetName());
1277             iResult=-ENOENT;
1278           }
1279         }
1280       }
1281     }
1282   }
1283
1284   if (iResult>=0) SetStatusFlags(kTaskListCreated);
1285
1286   return iResult;
1287 }
1288
1289 int AliHLTSystem::CheckStatus(int flag)
1290 {
1291   // see header file for class documentation
1292   if (flag==kUninitialized && flag==fState) return 1;
1293   if ((fState&flag)==flag) return 1;
1294   return 0;
1295 }
1296
1297 int AliHLTSystem::GetStatusFlags()
1298 {
1299   // see header file for class documentation
1300   return fState;
1301 }
1302
1303 int AliHLTSystem::SetStatusFlags(int flags)
1304 {
1305   // see header file for class documentation
1306   fState|=flags;
1307   return fState;
1308 }
1309
1310 int AliHLTSystem::ClearStatusFlags(int flags)
1311 {
1312   // see header file for class documentation
1313   fState&=~flags;
1314   return fState;
1315 }
1316
1317 void* AliHLTSystem::FindDynamicSymbol(const char* library, const char* symbol)
1318 {
1319   // see header file for class documentation
1320   if (fpComponentHandler==NULL) return NULL;
1321   return fpComponentHandler->FindSymbol(library, symbol);
1322 }
1323
1324 void AliHLTSystem::SetFrameworkLog(AliHLTComponentLogSeverity level)
1325 {
1326   // see header file for class documentation
1327   SetLocalLoggingLevel(level);
1328   if (fpComponentHandler) fpComponentHandler->SetLocalLoggingLevel(level);
1329   if (fpConfigurationHandler) fpConfigurationHandler->SetLocalLoggingLevel(level);
1330 }