#include "AliSysInfo.h"
#include "AliAnalysisStatistics.h"
+using std::ofstream;
+using std::ios;
+using std::cout;
+using std::endl;
ClassImp(AliAnalysisManager)
AliAnalysisManager *AliAnalysisManager::fgAnalysisManager = NULL;
//______________________________________________________________________________
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),
- fDebugOptions(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),
fTable(),
fRunFromPath(0),
fStatisticsMsg(),
fRequestedBranches(),
fStatistics(0),
- fGlobals(0)
+ fGlobals(0),
+ fIOTimer(0),
+ fCPUTimer(0),
+ fInitTimer(0),
+ fIOTime(0),
+ fCPUTime(0),
+ fInitTime(0)
{
// Default constructor.
fgAnalysisManager = this;
fOutputs = new TObjArray();
fParamCont = new TObjArray();
fGlobals = new TMap();
- }
+ }
+ fIOTimer = new TStopwatch();
+ fCPUTimer = new TStopwatch();
+ fInitTimer = new TStopwatch();
SetEventLoop(kTRUE);
}
fInitOK(other.fInitOK),
fMustClean(other.fMustClean),
fIsRemote(other.fIsRemote),
+ fLocked(other.fLocked),
fDebug(other.fDebug),
fSpecialOutputLocation(""),
fTasks(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),
fTable(),
fRunFromPath(0),
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);
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);
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;
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;
}
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;
}
//______________________________________________________________________________
fCurrentEntry = entry;
if (!fAutoBranchHandling)
return 123456789;
- return fTree ? fTree->GetTree()->GetEntry(entry, getall) : -1;
+ if (!fTree) return -1;
+ fIOTimer->Start(kTRUE);
+ Long64_t readbytes = fTree->GetTree()->GetEntry(entry, getall);
+ fIOTimer->Stop();
+ fIOTime += fIOTimer->RealTime();
+ return (Int_t)readbytes;
}
//______________________________________________________________________________
// 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();
}
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");
}
// 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;
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());
task->Notify();
if (fDebug > 1) printf("<-AliAnalysisManager::Notify()\n");
+ fIOTimer->Stop();
+ fIOTime += fIOTimer->RealTime();
return kTRUE;
}
// 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;
}
}
}
+ 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());
}
{
// 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;
cont->ImportData(wrap);
}
if (cdir) cdir->cd();
+ fIOTimer->Stop();
+ fIOTime += fIOTimer->RealTime();
if (fDebug > 1) printf("<-AliAnalysisManager::ImportWrappers(): %d containers imported\n", icont);
}
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.");
}
}
}
+ fIOTimer->Stop();
+ fIOTime += fIOTimer->RealTime();
if (fDebug > 1) printf("<-AliAnalysisManager::UnpackOutput()\n");
}
// 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;
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();
}
out.open("outputs_valid", ios::out);
out.close();
}
- if (cdir) 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");
}
//______________________________________________________________________________
}
}
fTable.Add(br);
- if (load && br->GetReadEntry()!=GetCurrentEntry()) br->GetEntry(GetCurrentEntry());
+ if (load && br->GetReadEntry()!=GetCurrentEntry()) {
+ br->GetEntry(GetCurrentEntry());
+ }
}
delete arr;
}
if (fDebug > 1) {
printf("StartAnalysis %s\n",GetName());
AliLog::SetGlobalLogLevel(AliLog::kInfo);
- }
+ }
fMaxEntries = nentries;
fIsRemote = kFALSE;
TString anaType = type;
}
}
cout << "===== TERMINATING GRID ANALYSIS JOB: " << GetName() << endl;
+ if (cdir) cdir->cd();
ImportWrappers(NULL);
Terminate();
if (cdir) cdir->cd();
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;
//
// 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())) {
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();
if (getsysInfo && ((fNcalls%fNSysInfo)==0))
AliSysInfo::AddStamp("Handlers_FinishEvent",fNcalls, 1001, 1);
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);
task->ExecuteTask(option);
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);
if (cdir) cdir->cd();
+ fIOTimer->Stop();
+ fIOTime += fIOTimer->RealTime();
}
//______________________________________________________________________________
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);
}
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();
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);
}
}
+//______________________________________________________________________________
+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");
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff