X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ANALYSIS%2FAliAnalysisManager.cxx;h=09666beb84dc3c909283d1e6d3c6399ee06ace9b;hb=fd245273e3e399717bfce498e96d6a4d122671f4;hp=7fbad0c67d13330f26535982386d57e153ef3832;hpb=d512d8e2b76198cd245f3012cd667b441243f756;p=u%2Fmrichter%2FAliRoot.git diff --git a/ANALYSIS/AliAnalysisManager.cxx b/ANALYSIS/AliAnalysisManager.cxx index 7fbad0c67d1..09666beb84d 100644 --- a/ANALYSIS/AliAnalysisManager.cxx +++ b/ANALYSIS/AliAnalysisManager.cxx @@ -33,6 +33,8 @@ #include #include #include +#include +#include #include #include #include @@ -53,48 +55,67 @@ #include "AliSysInfo.h" #include "AliAnalysisStatistics.h" +using std::ofstream; +using std::ios; +using std::cout; +using std::endl; ClassImp(AliAnalysisManager) AliAnalysisManager *AliAnalysisManager::fgAnalysisManager = NULL; TString AliAnalysisManager::fgCommonFileName = ""; +TString AliAnalysisManager::fgMacroNames = ""; Int_t AliAnalysisManager::fPBUpdateFreq = 1; //______________________________________________________________________________ AliAnalysisManager::AliAnalysisManager(const char *name, const char *title) :TNamed(name,title), - fTree(NULL), - fInputEventHandler(NULL), - fOutputEventHandler(NULL), - fMCtruthEventHandler(NULL), - fEventPool(NULL), + fTree(0), + fInputEventHandler(0), + fOutputEventHandler(0), + fMCtruthEventHandler(0), + fEventPool(0), fCurrentEntry(-1), fNSysInfo(0), fMode(kLocalAnalysis), fInitOK(kFALSE), + fMustClean(kFALSE), fIsRemote(kFALSE), + fLocked(kFALSE), fDebug(0), fSpecialOutputLocation(""), - fTasks(NULL), - fTopTasks(NULL), - fZombies(NULL), - fContainers(NULL), - fInputs(NULL), - fOutputs(NULL), - fParamCont(NULL), - fCommonInput(NULL), - fCommonOutput(NULL), - fSelector(NULL), - fGridHandler(NULL), - fExtraFiles(""), + fTasks(0), + fTopTasks(0), + fZombies(0), + fContainers(0), + fInputs(0), + fOutputs(0), + fParamCont(0), + fDebugOptions(0), + fFileDescriptors(new TObjArray()), + fCurrentDescriptor(0), + fCommonInput(0), + fCommonOutput(0), + fSelector(0), + fGridHandler(0), + fExtraFiles(), + fFileInfoLog(), fAutoBranchHandling(kTRUE), + fAsyncReading(kFALSE), // default prefetching on fTable(), fRunFromPath(0), fNcalls(0), fMaxEntries(0), + fCacheSize(100000000), // default 100 MB fStatisticsMsg(), fRequestedBranches(), fStatistics(0), - fGlobals(0) + fGlobals(0), + fIOTimer(0), + fCPUTimer(0), + fInitTimer(0), + fIOTime(0), + fCPUTime(0), + fInitTime(0) { // Default constructor. fgAnalysisManager = this; @@ -108,7 +129,10 @@ AliAnalysisManager::AliAnalysisManager(const char *name, const char *title) fOutputs = new TObjArray(); fParamCont = new TObjArray(); fGlobals = new TMap(); - } + } + fIOTimer = new TStopwatch(); + fCPUTimer = new TStopwatch(); + fInitTimer = new TStopwatch(); SetEventLoop(kTRUE); } @@ -124,7 +148,9 @@ AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other) fNSysInfo(0), fMode(other.fMode), fInitOK(other.fInitOK), + fMustClean(other.fMustClean), fIsRemote(other.fIsRemote), + fLocked(other.fLocked), fDebug(other.fDebug), fSpecialOutputLocation(""), fTasks(NULL), @@ -134,20 +160,32 @@ AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other) fInputs(NULL), fOutputs(NULL), fParamCont(NULL), + fDebugOptions(NULL), + fFileDescriptors(new TObjArray()), + fCurrentDescriptor(0), fCommonInput(NULL), fCommonOutput(NULL), fSelector(NULL), fGridHandler(NULL), - fExtraFiles(), + fExtraFiles(other.fExtraFiles), + fFileInfoLog(other.fFileInfoLog), fAutoBranchHandling(other.fAutoBranchHandling), + fAsyncReading(other.fAsyncReading), fTable(), fRunFromPath(0), fNcalls(other.fNcalls), fMaxEntries(other.fMaxEntries), + fCacheSize(other.fCacheSize), fStatisticsMsg(other.fStatisticsMsg), fRequestedBranches(other.fRequestedBranches), fStatistics(other.fStatistics), - fGlobals(other.fGlobals) + fGlobals(other.fGlobals), + fIOTimer(new TStopwatch()), + fCPUTimer(new TStopwatch()), + fInitTimer(new TStopwatch()), + fIOTime(0), + fCPUTime(0), + fInitTime(0) { // Copy constructor. fTasks = new TObjArray(*other.fTasks); @@ -177,6 +215,7 @@ AliAnalysisManager& AliAnalysisManager::operator=(const AliAnalysisManager& othe fMode = other.fMode; fInitOK = other.fInitOK; fIsRemote = other.fIsRemote; + fLocked = other.fLocked; fDebug = other.fDebug; fTasks = new TObjArray(*other.fTasks); fTopTasks = new TObjArray(*other.fTopTasks); @@ -185,22 +224,34 @@ AliAnalysisManager& AliAnalysisManager::operator=(const AliAnalysisManager& othe fInputs = new TObjArray(*other.fInputs); fOutputs = new TObjArray(*other.fOutputs); fParamCont = new TObjArray(*other.fParamCont); + fDebugOptions = NULL; + fFileDescriptors = new TObjArray(); + fCurrentDescriptor = 0; fCommonInput = NULL; fCommonOutput = NULL; fSelector = NULL; fGridHandler = NULL; fExtraFiles = other.fExtraFiles; + fFileInfoLog = other.fFileInfoLog; fgCommonFileName = "AnalysisResults.root"; fgAnalysisManager = this; fAutoBranchHandling = other.fAutoBranchHandling; + fAsyncReading = other.fAsyncReading; fTable.Clear("nodelete"); fRunFromPath = other.fRunFromPath; fNcalls = other. fNcalls; fMaxEntries = other.fMaxEntries; + fCacheSize = other.fCacheSize; fStatisticsMsg = other.fStatisticsMsg; fRequestedBranches = other.fRequestedBranches; fStatistics = other.fStatistics; fGlobals = new TMap(); + fIOTimer = new TStopwatch(); + fCPUTimer = new TStopwatch(); + fInitTimer = new TStopwatch(); + fIOTime = 0.; + fCPUTime = 0.; + fInitTime = 0.; } return *this; } @@ -216,6 +267,7 @@ AliAnalysisManager::~AliAnalysisManager() if (fInputs) delete fInputs; if (fOutputs) delete fOutputs; if (fParamCont) delete fParamCont; + if (fDebugOptions) delete fDebugOptions; if (fGridHandler) delete fGridHandler; if (fInputEventHandler) delete fInputEventHandler; if (fOutputEventHandler) delete fOutputEventHandler; @@ -223,8 +275,36 @@ AliAnalysisManager::~AliAnalysisManager() if (fEventPool) delete fEventPool; if (fgAnalysisManager==this) fgAnalysisManager = NULL; if (fGlobals) {fGlobals->DeleteAll(); delete fGlobals;} + if (fFileDescriptors) {fFileDescriptors->Delete(); delete fFileDescriptors;} + delete fIOTimer; + delete fCPUTimer; + delete fInitTimer; } +//______________________________________________________________________________ +void AliAnalysisManager::CreateReadCache() +{ +// Create cache for reading according fCacheSize and fAsyncReading. + if (!fTree || !fTree->GetCurrentFile()) { + Error("CreateReadCache","Current tree or tree file not yet defined"); + return; + } + if (!fCacheSize) { + if (fDebug) Info("CreateReadCache","=== Read caching disabled ==="); + return; + } + gEnv->SetValue("TFile.AsyncPrefetching",(Int_t)fAsyncReading); + if (fAsyncReading) gEnv->SetValue("Cache.Directory",Form("file://%s/cache", gSystem->WorkingDirectory())); + if (fAsyncReading) gEnv->SetValue("TFile.AsyncReading",1); + fTree->SetCacheSize(fCacheSize); + TTreeCache::SetLearnEntries(1); //<<< we can take the decision after 1 entry + fTree->AddBranchToCache("*",kTRUE); //<<< add all branches to the cache + if (fDebug) { + Info("CreateReadCache","Read cache enabled %lld bytes with async reading=%d",fCacheSize, (Int_t)fAsyncReading); + } + return; +} + //______________________________________________________________________________ Int_t AliAnalysisManager::GetEntry(Long64_t entry, Int_t getall) { @@ -232,7 +312,12 @@ Int_t AliAnalysisManager::GetEntry(Long64_t entry, Int_t getall) fCurrentEntry = entry; if (!fAutoBranchHandling) return 123456789; - return fTree ? fTree->GetTree()->GetEntry(entry, getall) : -1; + if (!fTree || !fTree->GetTree()) return -1; + fIOTimer->Start(kTRUE); + Long64_t readbytes = fTree->GetTree()->GetEntry(entry, getall); + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); + return (Int_t)readbytes; } //______________________________________________________________________________ @@ -331,6 +416,7 @@ Bool_t AliAnalysisManager::Init(TTree *tree) if (!fInitOK) InitAnalysis(); if (!fInitOK) return kFALSE; fTree = tree; + if (fMode != kProofAnalysis) CreateReadCache(); fTable.Rehash(100); AliAnalysisDataContainer *top = fCommonInput; if (!top) top = (AliAnalysisDataContainer*)fInputs->At(0); @@ -353,6 +439,12 @@ void AliAnalysisManager::SlaveBegin(TTree *tree) // When running with PROOF SlaveBegin() is called on each slave server. // The tree argument is deprecated (on PROOF 0 is passed). if (fDebug > 1) printf("->AliAnalysisManager::SlaveBegin()\n"); + // Init timer should be already started + // Apply debug options + ApplyDebugOptions(); + if (fCacheSize && + fMCtruthEventHandler && + (fMode != kProofAnalysis)) fMCtruthEventHandler->SetCacheSize(fCacheSize); if (!CheckTasks()) Fatal("SlaveBegin", "Not all needed libraries were loaded"); static Bool_t isCalled = kFALSE; Bool_t init = kFALSE; @@ -428,6 +520,10 @@ void AliAnalysisManager::SlaveBegin(TTree *tree) } TH1::AddDirectory(dirStatus); if (curdir) curdir->cd(); + fInitTimer->Stop(); + fInitTime += fInitTimer->RealTime(); + fInitTimer->Continue(); + printf("Initialization time: %g [sec]\n", fInitTime); if (fDebug > 1) printf("<-AliAnalysisManager::SlaveBegin()\n"); } @@ -439,6 +535,7 @@ Bool_t AliAnalysisManager::Notify() // is started when using PROOF. It is normaly not necessary to make changes // to the generated code, but the routine can be extended by the // user if needed. The return value is currently not used. + fIOTimer->Start(kTRUE); if (!fTree) return kFALSE; if (!TObject::TestBit(AliAnalysisManager::kTrueNotify)) return kFALSE; @@ -449,6 +546,11 @@ Bool_t AliAnalysisManager::Notify() if (!curfile) { Error("Notify","No current file"); return kFALSE; + } + if (IsCollectThroughput()) { + if (fCurrentDescriptor) fCurrentDescriptor->Done(); + fCurrentDescriptor = new AliAnalysisFileDescriptor(curfile); + fFileDescriptors->Add(fCurrentDescriptor); } if (fDebug > 1) printf("->AliAnalysisManager::Notify() file: %s\n", curfile->GetName()); @@ -478,6 +580,8 @@ Bool_t AliAnalysisManager::Notify() task->Notify(); if (fDebug > 1) printf("<-AliAnalysisManager::Notify()\n"); + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); return kTRUE; } @@ -512,6 +616,20 @@ void AliAnalysisManager::PackOutput(TList *target) // Pack all output data containers in the output list. Called at SlaveTerminate // stage in PROOF case for each slave. if (fDebug > 1) printf("->AliAnalysisManager::PackOutput()\n"); + fIOTimer->Start(kTRUE); + std::ofstream out; + if (IsCollectThroughput()) { + if (fCurrentDescriptor) fCurrentDescriptor->Done(); + fFileDescriptors->Print(); + if (fFileInfoLog.IsNull()) fFileInfoLog = "fileinfo.log"; + out.open(fFileInfoLog, std::ios::app); + if (out.bad()) Error("SavePrimitive", "Bad file name: %s", fFileInfoLog.Data()); + else { + TIter nextflog(fFileDescriptors); + TObject *log; + while ((log=nextflog())) log->SavePrimitive(out,""); + } + } if (!target) { Error("PackOutput", "No target. Exiting."); return; @@ -718,7 +836,37 @@ void AliAnalysisManager::PackOutput(TList *target) } } } - cdir->cd(); + fIOTime += fIOTimer->RealTime(); + if ((fDebug || IsCollectThroughput())) { + fInitTimer->Stop(); + fInitTime = fInitTimer->RealTime()-fIOTime-fCPUTime; + printf("=Analysis %s= init time: %g[sec]\ + \n I/O & data mng.: %g [sec]\ + \n task execution: %g [sec]\ + \n total time: CPU=%g [sec] REAL=%g[sec]\n", + GetName(), fInitTime, fIOTime, fCPUTime, fInitTimer->CpuTime(), fInitTimer->RealTime()); + if (IsCollectThroughput()) { + out << "#summary#########################################################" << endl; + out << "train_name " << GetName() << endl; + out << "root_time " << fInitTimer->RealTime() << endl; + out << "root_cpu " << fInitTimer->CpuTime() << endl; + out << "init_time " << fInitTime << endl; + out << "io_mng_time " << fIOTime << endl; + out << "exec_time " << fCPUTime << endl; + TString aliensite = gSystem->Getenv("ALIEN_SITE"); + out << "alien_site " << aliensite << endl; + out << "host_name "; + TString hostname = gSystem->Getenv("ALIEN_HOSTNAME"); + if (hostname.IsNull()) { + out.close(); + gSystem->Exec(Form("hostname -f >> %s", fFileInfoLog.Data())); + } else { + out << hostname << endl; + } + } + } + + if (cdir) cdir->cd(); if (fDebug > 1) printf("<-AliAnalysisManager::PackOutput: output list contains %d containers\n", target->GetSize()); } @@ -727,6 +875,7 @@ void AliAnalysisManager::ImportWrappers(TList *source) { // Import data in output containers from wrappers coming in source. if (fDebug > 1) printf("->AliAnalysisManager::ImportWrappers()\n"); + fIOTimer->Start(kTRUE); TIter next(fOutputs); AliAnalysisDataContainer *cont; AliAnalysisDataWrapper *wrap; @@ -796,6 +945,8 @@ void AliAnalysisManager::ImportWrappers(TList *source) cont->ImportData(wrap); } if (cdir) cdir->cd(); + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); if (fDebug > 1) printf("<-AliAnalysisManager::ImportWrappers(): %d containers imported\n", icont); } @@ -803,6 +954,7 @@ void AliAnalysisManager::ImportWrappers(TList *source) void AliAnalysisManager::UnpackOutput(TList *source) { // Called by AliAnalysisSelector::Terminate only on the client. + fIOTimer->Start(kTRUE); if (fDebug > 1) printf("->AliAnalysisManager::UnpackOutput()\n"); if (!source) { Error("UnpackOutput", "No target. Exiting."); @@ -828,11 +980,15 @@ void AliAnalysisManager::UnpackOutput(TList *source) // If task is active, execute it if (task->IsPostEventLoop() && task->IsActive()) { if (fDebug > 1) printf("== Executing post event loop task %s\n", task->GetName()); + if (fStatistics) fStatistics->StartTimer(GetTaskIndex(task), task->GetName(), task->ClassName()); task->ExecuteTask(); } } + if (fStatistics) fStatistics->StopTimer(); } } + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); if (fDebug > 1) printf("<-AliAnalysisManager::UnpackOutput()\n"); } @@ -843,6 +999,7 @@ void AliAnalysisManager::Terminate() // a query. It always runs on the client, it can be used to present // the results graphically. if (fDebug > 1) printf("->AliAnalysisManager::Terminate()\n"); + fInitTimer->Start(kTRUE); TDirectory *cdir = gDirectory; gROOT->cd(); AliAnalysisTask *task; @@ -863,8 +1020,8 @@ void AliAnalysisManager::Terminate() if (TObject::TestBit(kSaveCanvases)) { if (!gROOT->IsBatch()) { if (fDebug>1) printf("Waiting 5 sec for %s::Terminate() to finish drawing ...\n", task->ClassName()); - timer.Start(); - while (timer.CpuTime()<5) { + timer.Start(kTRUE); + while (timer.RealTime()<5) { timer.Continue(); gSystem->ProcessEvents(); } @@ -1090,7 +1247,11 @@ void AliAnalysisManager::Terminate() out.open("outputs_valid", ios::out); out.close(); } - cdir->cd(); + if (cdir) cdir->cd(); + fInitTimer->Stop(); + if (fDebug || IsCollectThroughput()) { + printf("=Analysis %s= Terminate time: %g[sec]\n", GetName(), fInitTimer->RealTime()); + } if (fDebug > 1) printf("<-AliAnalysisManager::Terminate()\n"); } //______________________________________________________________________________ @@ -1195,6 +1356,14 @@ AliAnalysisTask *AliAnalysisManager::GetTask(const char *name) const return (AliAnalysisTask*)fTasks->FindObject(name); } +//______________________________________________________________________________ +Int_t AliAnalysisManager::GetTaskIndex(const AliAnalysisTask *task) const +{ +// Returns task inded in the manager's list, -1 if not registered. + if (!fTasks) return -1; + return fTasks->IndexOf(task); +} + //______________________________________________________________________________ AliAnalysisDataContainer *AliAnalysisManager::CreateContainer(const char *name, TClass *datatype, EAliAnalysisContType type, const char *filename) @@ -1443,7 +1612,9 @@ void AliAnalysisManager::CheckBranches(Bool_t load) } } fTable.Add(br); - if (load && br->GetReadEntry()!=GetCurrentEntry()) br->GetEntry(GetCurrentEntry()); + if (load && br->GetReadEntry()!=GetCurrentEntry()) { + br->GetEntry(GetCurrentEntry()); + } } delete arr; } @@ -1524,10 +1695,29 @@ void AliAnalysisManager::RunLocalInit() gROOT->cd(); task->LocalInit(); } - cdir->cd(); + if (cdir) cdir->cd(); TObject::SetBit(kTasksInitialized, kTRUE); } +//______________________________________________________________________________ +void AliAnalysisManager::InputFileFromTree(TTree * const tree, TString &fname) +{ +// Retrieves name of the file from tree + fname = ""; + if (!tree) return; + TFile *file = tree->GetCurrentFile(); + TString basename; + if (!file) { + TChain *chain = dynamic_cast(tree); + if (!chain || !chain->GetNtrees()) return; + basename = gSystem->BaseName(chain->GetListOfFiles()->First()->GetTitle()); + } else { + basename = gSystem->BaseName(file->GetName()); + } + Int_t index = basename.Index("#"); + fname = basename(index+1, basename.Length()); +} + //______________________________________________________________________________ Long64_t AliAnalysisManager::StartAnalysis(const char *type, Long64_t nentries, Long64_t firstentry) { @@ -1552,14 +1742,14 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, gROOT->cd(); if (!fInitOK) { Error("StartAnalysis","Analysis manager was not initialized !"); - cdir->cd(); + if (cdir) cdir->cd(); return -1; } if (!CheckTasks()) Fatal("StartAnalysis", "Not all needed libraries were loaded"); if (fDebug > 1) { printf("StartAnalysis %s\n",GetName()); AliLog::SetGlobalLogLevel(AliLog::kInfo); - } + } fMaxEntries = nentries; fIsRemote = kFALSE; TString anaType = type; @@ -1569,6 +1759,11 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, if (anaType.Contains("proof")) fMode = kProofAnalysis; else if (anaType.Contains("grid")) fMode = kGridAnalysis; else if (anaType.Contains("mix")) fMode = kMixingAnalysis; + if (fInputEventHandler) { + TString fname; + InputFileFromTree(tree, fname); + if (fname.Length()) fInputEventHandler->SetInputFileName(fname); + } if (fMode == kGridAnalysis) { fIsRemote = kTRUE; @@ -1576,7 +1771,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, if (!fGridHandler) { Error("StartAnalysis", "Cannot start grid analysis without a grid handler."); Info("===", "Add an AliAnalysisAlien object as plugin for this manager and configure it."); - cdir->cd(); + if (cdir) cdir->cd(); return -1; } // Write analysis manager in the analysis file @@ -1585,25 +1780,26 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, RunLocalInit(); if (!fGridHandler->StartAnalysis(nentries, firstentry)) { Info("StartAnalysis", "Grid analysis was stopped and cannot be terminated"); - cdir->cd(); + if (cdir) cdir->cd(); return -1; } // Terminate grid analysis - if (fSelector && fSelector->GetStatus() == -1) {cdir->cd(); return -1;} - if (fGridHandler->GetRunMode() == AliAnalysisGrid::kOffline) {cdir->cd(); return 0;} + if (fSelector && fSelector->GetStatus() == -1) {if (cdir) cdir->cd(); return -1;} + if (fGridHandler->GetRunMode() == AliAnalysisGrid::kOffline) {if (cdir) cdir->cd(); return 0;} cout << "===== MERGING OUTPUTS REGISTERED BY YOUR ANALYSIS JOB: " << GetName() << endl; if (!fGridHandler->MergeOutputs()) { // Return if outputs could not be merged or if it alien handler // was configured for offline mode or local testing. - cdir->cd(); + if (cdir) cdir->cd(); return 0; } } cout << "===== TERMINATING GRID ANALYSIS JOB: " << GetName() << endl; + if (cdir) cdir->cd(); ImportWrappers(NULL); Terminate(); - cdir->cd(); + if (cdir) cdir->cd(); return 0; } TString line; @@ -1617,7 +1813,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, chain = (TChain*)tree; if (!chain || !chain->GetListOfFiles()->First()) { Error("StartAnalysis", "Cannot process null or empty chain..."); - cdir->cd(); + if (cdir) cdir->cd(); return -1; } ttype = "TChain"; @@ -1690,7 +1886,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, } if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) { Error("StartAnalysis", "No PROOF!!! Exiting."); - cdir->cd(); + if (cdir) cdir->cd(); return -1; } line = Form("gProof->AddInput((TObject*)%p);", this); @@ -1701,7 +1897,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, retv = chain->Process("AliAnalysisSelector", "", nentries, firstentry); } else { Error("StartAnalysis", "No chain!!! Exiting."); - cdir->cd(); + if (cdir) cdir->cd(); return -1; } break; @@ -1711,7 +1907,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, if (!fGridHandler) { Error("StartAnalysis", "Cannot start grid analysis without a grid handler."); Info("===", "Add an AliAnalysisAlien object as plugin for this manager and configure it."); - cdir->cd(); + if (cdir) cdir->cd(); return -1; } // Write analysis manager in the analysis file @@ -1719,31 +1915,31 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, // Start the analysis via the handler if (!fGridHandler->StartAnalysis(nentries, firstentry)) { Info("StartAnalysis", "Grid analysis was stopped and cannot be terminated"); - cdir->cd(); + if (cdir) cdir->cd(); return -1; } // Terminate grid analysis - if (fSelector && fSelector->GetStatus() == -1) {cdir->cd(); return -1;} - if (fGridHandler->GetRunMode() == AliAnalysisGrid::kOffline) {cdir->cd(); return 0;} + if (fSelector && fSelector->GetStatus() == -1) {if (cdir) cdir->cd(); return -1;} + if (fGridHandler->GetRunMode() == AliAnalysisGrid::kOffline) {if (cdir) cdir->cd(); return 0;} cout << "===== MERGING OUTPUTS REGISTERED BY YOUR ANALYSIS JOB: " << GetName() << endl; if (!fGridHandler->MergeOutputs()) { // Return if outputs could not be merged or if it alien handler // was configured for offline mode or local testing. - cdir->cd(); + if (cdir) cdir->cd(); return 0; } } cout << "===== TERMINATING GRID ANALYSIS JOB: " << GetName() << endl; ImportWrappers(NULL); Terminate(); - cdir->cd(); + if (cdir) cdir->cd(); return 0; case kMixingAnalysis: // Run event mixing analysis if (!fEventPool) { Error("StartAnalysis", "Cannot run event mixing without event pool"); - cdir->cd(); + if (cdir) cdir->cd(); return -1; } cout << "===== RUNNING EVENT MIXING ANALYSIS " << GetName() << endl; @@ -1756,14 +1952,14 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, retv = chain->Process(fSelector); if (retv < 0) { Error("StartAnalysis", "Mixing analysis failed"); - cdir->cd(); + if (cdir) cdir->cd(); return retv; } } PackOutput(fSelector->GetOutputList()); Terminate(); } - cdir->cd(); + if (cdir) cdir->cd(); return retv; } @@ -1786,6 +1982,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset } fMode = kProofAnalysis; TString line; + TString proofProcessOpt; SetEventLoop(kTRUE); // Set the dataset flag TObject::SetBit(kUseDataSet); @@ -1802,6 +1999,8 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset } else { dataset = fGridHandler->GetProofDataSet(); } + + proofProcessOpt = fGridHandler->GetProofProcessOpt(); } if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) { @@ -1815,8 +2014,8 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset line = Form("gProof->AddInput((TObject*)%p);", this); gROOT->ProcessLine(line); Long_t retv; - line = Form("gProof->Process(\"%s\", \"AliAnalysisSelector\", \"\", %lld, %lld);", - dataset, nentries, firstentry); + line = Form("gProof->Process(\"%s\", \"AliAnalysisSelector\", \"%s\", %lld, %lld);", + dataset,proofProcessOpt.Data(), nentries, firstentry); cout << "===== RUNNING PROOF ANALYSIS " << GetName() << " ON DATASET " << dataset << endl; retv = (Long_t)gROOT->ProcessLine(line); return retv; @@ -1997,13 +2196,14 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) if (!fNcalls) timer->Start(); if (!fIsRemote && TObject::TestBit(kUseProgressBar)) ProgressBar("Processing event", fNcalls, TMath::Min(fMaxEntries,nentries), timer, kFALSE); } + fIOTimer->Start(kTRUE); gROOT->cd(); TDirectory *cdir = gDirectory; Bool_t getsysInfo = ((fNSysInfo>0) && (fMode==kLocalAnalysis))?kTRUE:kFALSE; if (getsysInfo && ((fNcalls%fNSysInfo)==0)) AliSysInfo::AddStamp("Exec_start", (Int_t)fNcalls); if (!fInitOK) { Error("ExecAnalysis", "Analysis manager was not initialized !"); - cdir->cd(); + if (cdir) cdir->cd(); return; } fNcalls++; @@ -2019,7 +2219,7 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) if (!cont) cont = (AliAnalysisDataContainer*)fInputs->At(0); if (!cont) { Error("ExecAnalysis","Cannot execute analysis in TSelector mode without at least one top container"); - cdir->cd(); + if (cdir) cdir->cd(); return; } cont->SetData(fTree); // This will notify all consumers @@ -2035,18 +2235,26 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) // // Execute the tasks // TIter next1(cont->GetConsumers()); + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); + fCPUTimer->Start(kTRUE); TIter next1(fTopTasks); Int_t itask = 0; while ((task=(AliAnalysisTask*)next1())) { if (fDebug >1) { cout << " Executing task " << task->GetName() << endl; - } + } + if (fStatistics) fStatistics->StartTimer(GetTaskIndex(task), task->GetName(), task->ClassName()); task->ExecuteTask(option); + if (fStatistics) fStatistics->StopTimer(); gROOT->cd(); if (getsysInfo && ((fNcalls%fNSysInfo)==0)) AliSysInfo::AddStamp(task->ClassName(), fNcalls, itask, 1); itask++; } + fCPUTimer->Stop(); + fCPUTime += fCPUTimer->RealTime(); + fIOTimer->Start(kTRUE); // // Call FinishEvent() for optional output and MC services if (fInputEventHandler) fInputEventHandler ->FinishEvent(); @@ -2055,35 +2263,48 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) // Gather system information if requested if (getsysInfo && ((fNcalls%fNSysInfo)==0)) AliSysInfo::AddStamp("Handlers_FinishEvent",fNcalls, 1001, 1); - cdir->cd(); + if (cdir) cdir->cd(); + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); return; } // The event loop is not controlled by TSelector // // Call BeginEvent() for optional input/output and MC services + fIOTimer->Start(kTRUE); if (fInputEventHandler) fInputEventHandler ->BeginEvent(-1); if (fOutputEventHandler) fOutputEventHandler ->BeginEvent(-1); if (fMCtruthEventHandler) fMCtruthEventHandler->BeginEvent(-1); + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); gROOT->cd(); if (getsysInfo && ((fNcalls%fNSysInfo)==0)) AliSysInfo::AddStamp("Handlers_BeginEvent",fNcalls, 1000, 0); + fCPUTimer->Start(kTRUE); TIter next2(fTopTasks); while ((task=(AliAnalysisTask*)next2())) { task->SetActive(kTRUE); if (fDebug > 1) { cout << " Executing task " << task->GetName() << endl; } + if (fStatistics) fStatistics->StartTimer(GetTaskIndex(task), task->GetName(), task->ClassName()); task->ExecuteTask(option); + if (fStatistics) fStatistics->StopTimer(); gROOT->cd(); } + fCPUTimer->Stop(); + fCPUTime += fCPUTimer->RealTime(); // // Call FinishEvent() for optional output and MC services + fIOTimer->Start(kTRUE); if (fInputEventHandler) fInputEventHandler ->FinishEvent(); if (fOutputEventHandler) fOutputEventHandler ->FinishEvent(); if (fMCtruthEventHandler) fMCtruthEventHandler->FinishEvent(); if (getsysInfo && ((fNcalls%fNSysInfo)==0)) AliSysInfo::AddStamp("Handlers_FinishEvent",fNcalls, 1000, 1); - cdir->cd(); + if (cdir) cdir->cd(); + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); } //______________________________________________________________________________ @@ -2103,6 +2324,7 @@ Bool_t AliAnalysisManager::IsPipe(std::ostream &out) void AliAnalysisManager::SetInputEventHandler(AliVEventHandler* const handler) { // Set the input event handler and create a container for it. + Changed(); fInputEventHandler = handler; if (!fCommonInput) fCommonInput = CreateContainer("cAUTO_INPUT", TChain::Class(), AliAnalysisManager::kInputContainer); } @@ -2111,6 +2333,7 @@ void AliAnalysisManager::SetInputEventHandler(AliVEventHandler* const handler) void AliAnalysisManager::SetOutputEventHandler(AliVEventHandler* const handler) { // Set the input event handler and create a container for it. + Changed(); fOutputEventHandler = handler; if (!fCommonOutput) fCommonOutput = CreateContainer("cAUTO_OUTPUT", TTree::Class(), AliAnalysisManager::kOutputContainer, "default"); fCommonOutput->SetSpecialOutput(); @@ -2237,14 +2460,14 @@ Bool_t AliAnalysisManager::ValidateOutputFiles() const file = TFile::Open(filename); if (!file || file->IsZombie() || file->TestBit(TFile::kRecovered)) { Error("ValidateOutputs", "Output file <%s> was not created or invalid", filename.Data()); - cdir->cd(); + if (cdir) cdir->cd(); return kFALSE; } file->Close(); openedFiles += filename; openedFiles += " "; } - cdir->cd(); + if (cdir) cdir->cd(); return kTRUE; } @@ -2365,8 +2588,8 @@ void AliAnalysisManager::DoLoadBranch(const char *name) fTable.Add(br); } if (br->GetReadEntry()==fCurrentEntry) return; - Int_t ret = br->GetEntry(GetCurrentEntry()); - if (ret<0) { + Long64_t readbytes = br->GetEntry(GetCurrentEntry()); + if (readbytes<0) { Error("DoLoadBranch", "Could not load entry %lld from branch %s",GetCurrentEntry(), name); if (crtEntry != fCurrentEntry) { CountEvent(1,0,1,0); @@ -2549,3 +2772,110 @@ Double_t AliAnalysisManager::GetGlobalDbl(const char *key, Bool_t &valid) TString s = value->GetName(); return s.Atof(); } + +//______________________________________________________________________________ +void AliAnalysisManager::AddClassDebug(const char *className, Int_t debugLevel) +{ +// Sets Class debug level + + if (!fDebugOptions) { + fDebugOptions = new TObjArray(); + fDebugOptions->SetOwner(kTRUE); + } + + TNamed *debugOpt = (TNamed*)fDebugOptions->FindObject(className); + if (!debugOpt) { + AliInfo(TString::Format("Adding debug level %d for class %s",debugLevel,className).Data()); + fDebugOptions->Add(new TNamed(className,TString::Format("%d",debugLevel).Data())); + } else { + TString oldDebugStr = debugOpt->GetTitle(); + Int_t oldDebug = oldDebugStr.Atoi(); + if (debugLevel > oldDebug) { + AliWarning(TString::Format("Overwriting debug level to %d class %s, because it is higher then previously set (%d).",debugLevel,className,oldDebug).Data()); + debugOpt->SetTitle(TString::Format("%d",debugLevel).Data()); + } else { + AliWarning(TString::Format("Ignoring debug level to %d class %s, because it is smaller then previously set (%d).",debugLevel,className,oldDebug).Data()); + } + } +} + +//______________________________________________________________________________ +void AliAnalysisManager::ApplyDebugOptions() +{ +// Apply debug options + + if (!fDebugOptions) return; + + TIter next(fDebugOptions); + TNamed *debug; + TString debugLevel; + while ((debug=dynamic_cast(next()))) { + debugLevel = debug->GetTitle(); + AliInfo(TString::Format("Class=%s debulLevel=%d",debug->GetName(),debugLevel.Atoi()).Data()); + AliLog::SetClassDebugLevel(debug->GetName(), debugLevel.Atoi()); + } +} + +//______________________________________________________________________________ +Bool_t AliAnalysisManager::IsMacroLoaded(const char filename) +{ +// Check if a macro was loaded. + return fgMacroNames.Contains(filename); +} + +//______________________________________________________________________________ +Int_t AliAnalysisManager::LoadMacro(const char *filename, Int_t *error, Bool_t check) +{ +// Redirection of gROOT->LoadMacro which makes sure the same macro is not loaded +// twice + TString macroName = gSystem->BaseName(filename); + // Strip appended +, ++, +g, +O + Int_t index = macroName.Index("+"); + if (index>0) macroName.Remove(index); + if (fgMacroNames.Contains(macroName)) { + // Macro with the same name loaded already in this root session, do + // nothing + error = 0; + return 0; + } + Int_t ret = gROOT->LoadMacro(filename,error,check); + // In case of error return the error code + if (ret) return ret; + // Append the macro name to the loaded macros list + fgMacroNames += macroName; + fgMacroNames += " "; + return ret; +} + +//______________________________________________________________________________ +void AliAnalysisManager::Lock() +{ +// Security lock. This is to detect NORMAL user errors and not really to +// protect against intentional hacks. + if (fLocked) return; + fLocked = kTRUE; + if (fInputEventHandler) fInputEventHandler->Lock(); + if (fOutputEventHandler) fOutputEventHandler->Lock(); + if (fMCtruthEventHandler) fMCtruthEventHandler->Lock(); + Info("Lock","====== ANALYSIS MANAGER LOCKED ======"); +} + +//______________________________________________________________________________ +void AliAnalysisManager::UnLock() +{ +// Verbose unlocking. Hackers will be punished ;-) ... + if (!fLocked) return; + fLocked = kFALSE; + if (fInputEventHandler) fInputEventHandler->UnLock(); + if (fOutputEventHandler) fOutputEventHandler->UnLock(); + if (fMCtruthEventHandler) fMCtruthEventHandler->UnLock(); + Info("UnLock", "====== ANALYSIS MANAGER UNLOCKED ======"); +} + +//______________________________________________________________________________ +void AliAnalysisManager::Changed() +{ +// All critical setters pass through the Changed method that throws an exception +// in case the lock was set. + if (fLocked) Fatal("Changed","Critical setter called in locked mode"); +}