Logo ROOT  
Reference Guide
TProofBenchRunDataRead.cxx
Go to the documentation of this file.
1 // @(#)root/proof:$Id$
2 // Author: Sangsu Ryu 22/06/2010
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 /** \class TProofBenchRunDataRead
13 \ingroup proofbench
14 
15 I/O-intensive PROOF benchmark test reads in event files distributed
16 on the cluster. Number of events processed per second and size of
17 events processed per second are plotted against number of active
18 workers. Performance rate for unit packets and performance rate
19 for query are plotted.
20 
21 */
22 
23 #include "RConfigure.h"
24 
25 #include "TProofBenchRunDataRead.h"
26 #include "TProofBenchDataSet.h"
27 #include "TProofPerfAnalysis.h"
28 #include "TProofNodes.h"
29 #include "TFileCollection.h"
30 #include "TFileInfo.h"
31 #include "TProof.h"
32 #include "TString.h"
33 #include "Riostream.h"
34 #include "TMap.h"
35 #include "TTree.h"
36 #include "TH1.h"
37 #include "TH2D.h"
38 #include "TCanvas.h"
39 #include "TProfile.h"
40 #include "TKey.h"
41 #include "TRegexp.h"
42 #include "TPerfStats.h"
43 #include "THashList.h"
44 #include "TSortedList.h"
45 #include "TVirtualPad.h"
46 #include "TEnv.h"
47 #include "TLeaf.h"
48 #include "TQueryResult.h"
49 #include "TMath.h"
50 #include "TStyle.h"
51 #include "TLegend.h"
52 #include "TROOT.h"
53 
55 
56 ////////////////////////////////////////////////////////////////////////////////
57 
59  TDirectory* dirproofbench, TProof* proof,
60  TProofNodes* nodes, Long64_t nevents, Int_t ntries,
61  Int_t start, Int_t stop, Int_t step, Int_t debug)
62  : TProofBenchRun(proof, kPROOF_BenchSelDataDef), fProof(proof),
63  fReadType(readtype), fDS(pbds),
64  fNEvents(nevents), fNTries(ntries), fStart(start), fStop(stop), fStep(step),
65  fDebug(debug), fFilesPerWrk(2), fReleaseCache(kTRUE),
66  fDirProofBench(dirproofbench), fNodes(nodes),
67  fListPerfPlots(0), fProfile_perfstat_event(0), fHist_perfstat_event(0),
68  fProfile_perfstat_evtmax(0), fNorm_perfstat_evtmax(0),
69  fProfile_queryresult_event(0), fNorm_queryresult_event(0),
70  fProfile_perfstat_IO(0), fHist_perfstat_IO(0),
71  fProfile_perfstat_IOmax(0), fNorm_perfstat_IOmax(0),
72  fProfile_queryresult_IO(0), fNorm_queryresult_IO(0), fProfile_cpu_eff(0),
73  fProfLegend_evt(0), fNormLegend_evt(0), fProfLegend_mb(0), fNormLegend_mb(0),
74  fCPerfProfiles(0), fName(0)
75 {
76  // Default constructor
77 
78  if (!fProof) fProof = gProof;
79  if (!fDS) fDS = new TProofBenchDataSet(fProof);
80 
81  // Set name
82  fName = "DataRead";
83 
84  if (!fNodes) fNodes = new TProofNodes(fProof);
86 
87  if (stop == -1) fStop = fNodes->GetNWorkersCluster();
88 
89  fListPerfPlots = new TList;
90 
91  gEnv->SetValue("Proof.StatsTrace",1);
92  gStyle->SetOptStat(0);
93 }
94 
95 ////////////////////////////////////////////////////////////////////////////////
96 /// Destructor
97 
99 {
100  fProof=0;
101  fDirProofBench=0;
103  if (fCPerfProfiles) delete fCPerfProfiles;
108 }
109 
110 ////////////////////////////////////////////////////////////////////////////////
111 /// Run benchmark
112 /// Input parameters
113 /// dset: Dataset on which to run
114 /// start: Start scan with 'start' workers.
115 /// stop: Stop scan at 'stop workers.
116 /// step: Scan every 'step' workers.
117 /// ntries: Number of tries. When it is -1, data member fNTries is used.
118 /// debug: debug switch.
119 /// Int_t: Ignored
120 /// Returns
121 /// Nothing
122 
123 void TProofBenchRunDataRead::Run(const char *dset, Int_t start, Int_t stop,
124  Int_t step, Int_t ntries, Int_t debug, Int_t)
125 {
126  if (!fProof){
127  Error("Run", "Proof not set");
128  return;
129  }
130  if (!dset || (dset && strlen(dset) <= 0)){
131  Error("Run", "dataset name not set");
132  return;
133  }
134  // Check if the dataset exists
135  if (!fProof->ExistsDataSet(dset)) {
136  Error("Run", "no such data set found; %s", dset);
137  return;
138  }
139 
140  start = (start == -1) ? fStart : start;
141  stop = (stop == -1) ? fStop : stop;
142  step = (step == -1) ? fStep : step;
143  ntries = (ntries == -1) ? fNTries : ntries;
144  debug = (debug == -1) ? fDebug : debug;
145 
146  Int_t fDebug_sav = fDebug;
147  fDebug = debug;
148 
149  Bool_t nx = kFALSE;
150  if (step == -2){
151  nx = kTRUE;
152  step = 1;
153  }
154 
155  if (nx){
156  Int_t minnworkersanode = fNodes->GetMinWrksPerNode();
157  if (stop > minnworkersanode) stop = minnworkersanode;
158  }
159 
160  // Load the selector, if needed
162  // Is it the default selector?
164  // Load the parfile
166  Info("Run", "Uploading '%s' ...", par.Data());
167  if (fProof->UploadPackage(par) != 0) {
168  Error("Run", "problems uploading '%s' - cannot continue", par.Data());
169  return;
170  }
171  Info("Run", "Enabling '%s' ...", kPROOF_BenchDataSelPar);
173  Error("Run", "problems enabling '%s' - cannot continue", kPROOF_BenchDataSelPar);
174  return;
175  }
176  } else {
177  if (fParList.IsNull()) {
178  Error("Run", "you should load the class '%s' before running the benchmark", fSelName.Data());
179  return;
180  } else {
181  TString par;
182  Int_t from = 0;
183  while (fParList.Tokenize(par, from, ",")) {
184  Info("Run", "Uploading '%s' ...", par.Data());
185  if (fProof->UploadPackage(par) != 0) {
186  Error("Run", "problems uploading '%s' - cannot continue", par.Data());
187  return;
188  }
189  Info("Run", "Enabling '%s' ...", par.Data());
190  if (fProof->EnablePackage(par) != 0) {
191  Error("Run", "problems enabling '%s' - cannot continue", par.Data());
192  return;
193  }
194  }
195  }
196  }
197  // Check
198  if (!TClass::GetClass(fSelName)) {
199  Error("Run", "failed to load '%s'", fSelName.Data());
200  return;
201  }
202  }
203 
204  // Build histograms, profiles and graphs needed for this run
205  BuildHistos(start, stop, step, nx);
206 
207  TString dsname(dset);
208  TString dsbasename = gSystem->BaseName(dset);
209 
210  // Get pad
211  if (!fCPerfProfiles){
212  TString canvasname = TString::Format("Performance Profiles %s", GetName());
213  fCPerfProfiles = new TCanvas(canvasname.Data(), canvasname.Data());
214  }
215 
216  // Cleanup up the canvas
218 
219  fCPerfProfiles->Divide(2,2);
220 
221  Info("Run", "Running IO-bound tests on dataset '%s'; %d ~ %d active worker(s),"
222  " every %d worker(s).", dset, start, stop, step);
223 
224  Int_t npad = 1; //pad number
225 
226  Int_t nnodes = fNodes->GetNNodes(); // Number of machines
227  Int_t ncores = fNodes->GetNCores(); // Number of cores
228 
229  Bool_t drawpf = kFALSE;
230  Double_t ymi = -1., ymx = -1., emx =- 1, ymiio = -1., ymxio = -1., mbmx = -1.;
231  for (Int_t nactive = start; nactive <= stop; nactive += step) {
232 
233  // For CPU effectiveness (ok for lite; should do it properly for standard clusters)
234  Int_t ncoren = (nactive < ncores) ? nactive : ncores;
235 
236  // Actvate the wanted workers
237  Int_t nw = -1;
238  if (nx) {
239  TString workers;
240  workers.Form("%dx", nactive);
241  nw = fNodes->ActivateWorkers(workers);
242  } else {
243  nw = fNodes->ActivateWorkers(nactive);
244  }
245  if (nw < 0){
246  Error("Run", "could not activate the requested number of"
247  " workers/node on the cluster; skipping the test point"
248  " (%d workers/node)", nactive);
249  continue;
250  }
251 
252  // Prepare the dataset for this run. possibly a subsample of
253  // the total one
254  TFileCollection *fc = GetDataSet(dsname, nactive, nx);
255  if (!fc) {
256  Error("Run", "could not retrieve dataset '%s'", dsname.Data());
257  continue;
258  }
259  fc->Print("F");
260  TString dsn = TString::Format("%s_%d_%d", dsbasename.Data(), nactive, (Int_t)nx);
261  fProof->RegisterDataSet(dsn, fc, "OT");
262  fProof->ShowDataSet(dsn, "F");
263 
264  for (Int_t j=0; j<ntries; j++) {
265 
266  if (nx){
267  Info("Run", "Running IO-bound tests with %d active worker(s)/node;"
268  " trial %d/%d", nactive, j + 1, ntries);
269  } else {
270  Info("Run", "Running IO-bound tests with %d active worker(s);"
271  " trial %d/%d", nactive, j + 1, ntries);
272  }
273 
274  // Cleanup run
275  const char *dsnr = (fDS->IsProof(fProof)) ? dsn.Data() : dsname.Data();
276  if (fReleaseCache) fDS->ReleaseCache(dsnr);
277 
279  SetParameters();
280 
281  Info("Run", "Processing data set %s with"
282  " %d active worker(s).", dsn.Data(), nactive);
283 
284  TTime starttime = gSystem->Now();
286 
288 
289  TTime endtime = gSystem->Now();
290 
291  TList *l = fProof->GetOutputList();
292 
293  //save perfstats
294  TString perfstats_name = "PROOF_PerfStats";
295  TTree *t = 0;
296  if (l) t = dynamic_cast<TTree*>(l->FindObject(perfstats_name.Data()));
297  if (t) {
298  drawpf = kTRUE;
299  TTree* tnew=(TTree*)t->Clone("tnew");
300 
301  FillPerfStatProfiles(tnew, nactive);
302 
303  TProofPerfAnalysis pfa(tnew);
304  Double_t pf_eventrate = pfa.GetEvtRateAvgMax();
305  Double_t pf_IOrate = pfa.GetMBRateAvgMax();
306  fProfile_perfstat_evtmax->Fill(nactive, pf_eventrate);
307  fCPerfProfiles->cd(npad);
312  gPad->Update();
313  fProfile_perfstat_IOmax->Fill(nactive, pf_IOrate);
314  fCPerfProfiles->cd(npad + 2);
318  fProfLegend_mb->Draw();
319  gPad->Update();
320  // The normalised histos
321  // Use the first bin to set the Y range for the histo
322  Double_t nert = nx ? pf_eventrate/nactive/nnodes : pf_eventrate/nactive;
323  fNorm_perfstat_evtmax->Fill(nactive, nert);
326  Double_t dy = 5 * e1;
327  if (dy / y1 < 0.2) dy = y1 * 0.2;
328  if (dy > y1) dy = y1*.999999;
329  if (ymi < 0.) ymi = y1 - dy;
330  if (fNorm_perfstat_evtmax->GetBinContent(nactive) < ymi)
331  ymi = fNorm_perfstat_evtmax->GetBinContent(nactive) / 2.;
332  if (ymx < 0.) ymx = y1 + dy;
333  if (fNorm_perfstat_evtmax->GetBinContent(nactive) > ymx)
334  ymx = fNorm_perfstat_evtmax->GetBinContent(nactive) * 1.5;
337  fCPerfProfiles->cd(npad + 1);
339  gPad->Update();
340  //
341  Double_t niort = nx ? pf_IOrate/nactive/nnodes : pf_IOrate/nactive;
342  fNorm_perfstat_IOmax->Fill(nactive, niort);
345  dy = 5 * e1;
346  if (dy / y1 < 0.2) dy = y1 * 0.2;
347  if (dy > y1) dy = y1*.999999;
348  if (ymiio < 0.) ymiio = y1 - dy;
349  if (fNorm_perfstat_IOmax->GetBinContent(nactive) < ymiio)
350  ymiio = fNorm_perfstat_IOmax->GetBinContent(nactive) / 2.;
351  if (ymxio < 0.) ymxio = y1 + dy;
352  if (fNorm_perfstat_IOmax->GetBinContent(nactive) > ymxio)
353  ymxio = fNorm_perfstat_IOmax->GetBinContent(nactive) * 1.5;
356  fCPerfProfiles->cd(npad + 3);
358  gPad->Update();
359 
360  //change the name
361  TString newname = TString::Format("%s_%s_%dwrks%dthtry", t->GetName(), GetName(), nactive, j);
362  tnew->SetName(newname);
363 
364  if (debug && fDirProofBench->IsWritable()){
365  TDirectory *curdir = gDirectory;
366  TString dirn = nx ? "RunDataReadx" : "RunDataRead";
367  if (!fDirProofBench->GetDirectory(dirn))
368  fDirProofBench->mkdir(dirn, "RunDataRead results");
369  if (fDirProofBench->cd(dirn)) {
371  tnew->Write();
372  l->Remove(tnew);
373  } else {
374  Warning("Run", "cannot cd to subdirectory '%s' to store the results!", dirn.Data());
375  }
376  curdir->cd();
377  }
378  } else {
379  if (l)
380  Warning("Run", "%s: tree not found", perfstats_name.Data());
381  else
382  Error("Run", "PROOF output list is empty!");
383  }
384 
385  //
386  const char *drawopt = t ? "SAME" : "";
387  // Performance measures from TQueryResult
388  TQueryResult *queryresult = fProof->GetQueryResult();
389  if (queryresult) {
390  TDatime qr_start = queryresult->GetStartTime();
391  TDatime qr_end = queryresult->GetEndTime();
392  Float_t qr_proc = queryresult->GetProcTime();
393  Long64_t qr_bytes = queryresult->GetBytes();
394 
395  Long64_t qr_entries = queryresult->GetEntries();
396 
397  // Calculate and fill CPU efficiency
398  Float_t qr_cpu_eff = -1.;
399  if (qr_proc > 0.) {
400  qr_cpu_eff = queryresult->GetUsedCPU() / ncoren / qr_proc ;
401  fProfile_cpu_eff->Fill(nactive, qr_cpu_eff);
402  Printf("cpu_eff: %f", qr_cpu_eff);
403  }
404 
405  // Calculate event rate, fill and draw
406  Double_t qr_eventrate=0;
407 
408  qr_eventrate = qr_entries / Double_t(qr_proc);
409  if (qr_eventrate > emx) emx = qr_eventrate;
410 
411  fProfile_queryresult_event->Fill(nactive, qr_eventrate);
412  fCPerfProfiles->cd(npad);
416  gPad->Update();
417 
418  // Calculate IO rate, fill and draw
419  Double_t qr_IOrate = 0;
420 
421  const Double_t Dmegabytes = 1024*1024;
422 
423  qr_IOrate = qr_bytes / Dmegabytes / Double_t(qr_proc);
424  if (qr_IOrate > mbmx) mbmx = qr_IOrate;
425 
426  fProfile_queryresult_IO->Fill(nactive, qr_IOrate);
427  fCPerfProfiles->cd(npad + 2);
429  fProfile_queryresult_IO->Draw(drawopt);
430  fProfLegend_mb->Draw();
431  gPad->Update();
432 
433  // The normalised histos
434  // Use the first bin to set the Y range for the histo
435  Double_t nert = nx ? qr_eventrate/nactive/nnodes : qr_eventrate/nactive;
436  fNorm_queryresult_event->Fill(nactive, nert);
439  Double_t dy = 5 * e1;
440  if (dy / y1 < 0.2) dy = y1 * 0.2;
441  if (dy > y1) dy = y1*.999999;
442  if (ymi < 0.) ymi = y1 - dy;
443  if (fNorm_queryresult_event->GetBinContent(nactive) < ymi)
444  ymi = fNorm_queryresult_event->GetBinContent(nactive) / 2.;
445  if (ymx < 0.) ymx = y1 + dy;
446  if (fNorm_queryresult_event->GetBinContent(nactive) > ymx)
447  ymx = fNorm_queryresult_event->GetBinContent(nactive) * 1.5;
448 // fNorm_queryresult_event->SetMaximum(ymx);
450  fCPerfProfiles->cd(npad + 1);
451  fNorm_queryresult_event->Draw(drawopt);
453  gPad->Update();
454  //
455  Double_t niort = nx ? qr_IOrate/nactive/nnodes : qr_IOrate/nactive;
456  fNorm_queryresult_IO->Fill(nactive, niort);
459  dy = 5 * e1;
460  if (dy / y1 < 0.2) dy = y1 * 0.2;
461  if (dy > y1) dy = y1*.999999;
462  if (ymiio < 0.) ymiio = y1 - dy;
463  if (fNorm_queryresult_IO->GetBinContent(nactive) < ymiio)
464  ymiio = fNorm_queryresult_IO->GetBinContent(nactive) / 2.;
465  if (ymxio < 0.) ymxio = y1 + dy;
466  if (fNorm_queryresult_IO->GetBinContent(nactive) > ymxio)
467  ymxio = fNorm_queryresult_IO->GetBinContent(nactive) * 1.5;
468 // fNorm_queryresult_IO->SetMaximum(ymxio);
470  fCPerfProfiles->cd(npad + 3);
471  fNorm_queryresult_IO->Draw(drawopt);
472  fNormLegend_mb->Draw();
473  gPad->Update();
474  }
475  fCPerfProfiles->cd(0);
476  }
477  // Remove temporary dataset
478  fProof->RemoveDataSet(dsn);
479  SafeDelete(fc);
480  }
481 
482  // Make the result persistent
483  fCPerfProfiles->cd(npad);
486  if (drawpf) fProfile_perfstat_evtmax->DrawCopy("SAME");
488  fCPerfProfiles->cd(npad + 2);
491  if (drawpf) fProfile_perfstat_IOmax->DrawCopy("SAME");
492  fProfLegend_mb->Draw();
493  fCPerfProfiles->cd(npad + 1);
495  if (drawpf) fNorm_perfstat_evtmax->DrawCopy("SAME");
497  fCPerfProfiles->cd(npad + 3);
499  if (drawpf) fNorm_perfstat_IOmax->DrawCopy("SAME");
500  fProfLegend_mb->Draw();
501  gPad->Update();
502 
503  //save performance profiles to file
504  if (fDirProofBench->IsWritable()){
505  TDirectory *curdir = gDirectory;
506  TString dirn = nx ? "RunDataReadx" : "RunDataRead";
507  if (!fDirProofBench->GetDirectory(dirn))
508  fDirProofBench->mkdir(dirn, "RunDataRead results");
509  if (fDirProofBench->cd(dirn)) {
513  } else {
514  Warning("Run", "cannot cd to subdirectory '%s' to store the results!", dirn.Data());
515  }
516  curdir->cd();
517  }
518  // Restore member data
519  fDebug = fDebug_sav;
520 }
521 
522 ////////////////////////////////////////////////////////////////////////////////
523 /// Get a subsample of dsname suited to run with 'nact' and option 'nx'.
524 
526  Int_t nact, Bool_t nx)
527 {
528  TFileCollection *fcsub = 0;
529 
530  // Dataset must exists
531  if (!fProof || (fProof && !fProof->ExistsDataSet(dset))) {
532  Error("GetDataSet", "dataset '%s' does not exist", dset);
533  return fcsub;
534  }
535 
536  // Get the full collection
537  TFileCollection *fcref = fProof->GetDataSet(dset);
538  if (!fcref) {
539  Error("GetDataSet", "dataset '%s' could not be retrieved", dset);
540  return fcsub;
541  }
542  // Is it remote ?
544 
545  // Separate info per server
546  TMap *mpref = fcref->GetFilesPerServer(fProof->GetMaster(), kTRUE);
547  if (!mpref) {
548  SafeDelete(fcref);
549  Error("GetDataSet", "problems classifying info on per-server base");
550  return fcsub;
551  }
552  mpref->Print();
553 
554  // Get Active node information
555  TMap *mpnodes = fNodes->GetMapOfActiveNodes();
556  if (!mpnodes) {
557  SafeDelete(fcref);
558  SafeDelete(mpref);
559  Error("GetDataSet", "problems getting map of active nodes");
560  return fcsub;
561  }
562  mpnodes->Print();
563 
564  // Number of files: fFilesPerWrk per active worker
566  Printf(" number of files needed (ideally): %d (%d per worker)", nf, fFilesPerWrk);
567 
568  // The output dataset
569  fcsub = new TFileCollection(TString::Format("%s_%d_%d", fcref->GetName(), nact, nx),
570  fcref->GetTitle());
571 
572  // Order reference sub-collections
573  TIter nxnd(mpnodes);
574  TObject *key = 0;
575  TFileInfo *fi = 0;
576  TFileCollection *xfc = 0;
577  TList *lswrks = 0;
578  while ((key = nxnd())) {
579  TIter nxsrv(mpref);
580  TObject *ksrv = 0;
581  while ((ksrv = nxsrv())) {
582  TUrl urlsrv(ksrv->GetName());
583  if (TString(urlsrv.GetHostFQDN()).IsNull())
584  urlsrv.SetHost(TUrl(gProof->GetMaster()).GetHostFQDN());
585  if (remote ||
586  !strcmp(urlsrv.GetHostFQDN(), TUrl(key->GetName()).GetHostFQDN())) {
587  if ((xfc = dynamic_cast<TFileCollection *>(mpref->GetValue(ksrv)))) {
588  if ((lswrks = dynamic_cast<TList *>(mpnodes->GetValue(key)))) {
589  Int_t nfnd = fFilesPerWrk * lswrks->GetSize();
590  while (nfnd-- && xfc->GetList()->GetSize() > 0) {
591  if ((fi = (TFileInfo *) xfc->GetList()->First())) {
592  xfc->GetList()->Remove(fi);
593  fcsub->Add(fi);
594  }
595  }
596  } else {
597  Warning("GetDataSet", "could not attach to worker list for node '%s'",
598  key->GetName());
599  }
600  } else {
601  Warning("GetDataSet", "could not attach to file collection for server '%s'",
602  ksrv->GetName());
603  }
604  }
605  }
606  }
607 
608  // Update counters
609  fcsub->Update();
610  fcsub->Print();
611 
612  // Make sure that the tree name is the one of the original dataset
613  if (fcref) {
614  TString dflt(fcref->GetDefaultTreeName());
615  if (!dflt.IsNull()) fcsub->SetDefaultTreeName(dflt);
616  }
617 
618  // Cleanup
619  SafeDelete(fcref);
620  SafeDelete(mpref);
621  // Done
622  return fcsub;
623 }
624 
625 ////////////////////////////////////////////////////////////////////////////////
626 
628 {
629  // Fill performance profiles using tree 't'(PROOF_PerfStats).
630  // Input parameters
631  // t: Proof output tree (PROOF_PerfStat) containing performance
632  // statistics.
633  // nactive: Number of active workers processed the query.
634  // Return
635  // Nothing
636 
637  // extract timing information
638  TPerfEvent pe;
639  TPerfEvent* pep = &pe;
640  t->SetBranchAddress("PerfEvents",&pep);
641  Long64_t entries = t->GetEntries();
642 
643  const Double_t Dmegabytes = 1024.*1024.;
644  Double_t event_rate_packet = 0;
645  Double_t IO_rate_packet = 0;
646 
647  for (Long64_t k=0; k<entries; k++) {
648  t->GetEntry(k);
649 
650  // Skip information from workers
651  if (pe.fEvtNode.Contains(".")) continue;
652 
654  if (pe.fProcTime != 0.0) {
655  event_rate_packet = pe.fEventsProcessed / pe.fProcTime;
656  fHist_perfstat_event->Fill(Double_t(nactive), event_rate_packet);
657  IO_rate_packet = pe.fBytesRead / Dmegabytes / pe.fProcTime;
658  fHist_perfstat_IO->Fill(Double_t(nactive), IO_rate_packet);
659  }
660  }
661  }
662 
663  return;
664 }
665 
666 ////////////////////////////////////////////////////////////////////////////////
667 /// Print the content of this object
668 
670 {
671  Printf("Name = %s", fName.Data());
672  if (fProof) fProof->Print(option);
673  Printf("fReadType = %s%s", "k", GetNameStem().Data());
674  Printf("fNEvents = %lld", fNEvents);
675  Printf("fNTries = %d", fNTries);
676  Printf("fStart = %d", fStart);
677  Printf("fStop = %d", fStop);
678  Printf("fStep = %d", fStep);
679  Printf("fDebug = %d", fDebug);
680  if (fDirProofBench)
681  Printf("fDirProofBench = %s", fDirProofBench->GetPath());
682  if (fNodes) fNodes->Print(option);
683  if (fListPerfPlots) fListPerfPlots->Print(option);
684 
685  if (fCPerfProfiles)
686  Printf("Performance Profiles Canvas: Name = %s Title = %s",
688 }
689 
690 ////////////////////////////////////////////////////////////////////////////////
691 /// Get canvas
692 
694 {
695  if (!fCPerfProfiles){
696  TString canvasname = TString::Format("Performance Profiles %s", GetName());
697  fCPerfProfiles = new TCanvas(canvasname.Data(), canvasname.Data());
698  }
699 
701 
702  // Divide the canvas as many as the number of profiles in the list
703  Int_t nprofiles = fListPerfPlots->GetSize();
704  if (nprofiles <= 2){
705  fCPerfProfiles->Divide(nprofiles);
706  } else {
707  Int_t nside = (Int_t)TMath::Sqrt((Float_t)nprofiles);
708  nside = (nside*nside < nprofiles) ? nside + 1 : nside;
709  fCPerfProfiles->Divide(nside,nside);
710  }
711 
712  Int_t npad=1;
713  TIter nxt(fListPerfPlots);
714  TProfile* profile=0;
715  while ((profile=(TProfile*)(nxt()))){
716  fCPerfProfiles->cd(npad++);
717  profile->Draw();
718  gPad->Update();
719  }
720  return;
721 }
722 
723 ////////////////////////////////////////////////////////////////////////////////
724 /// Get name for this run
725 
727 {
728  TString namestem("+++undef+++");
729  if (fReadType) {
730  switch (fReadType->GetType()) {
732  namestem="Full";
733  break;
735  namestem="Opt";
736  break;
738  namestem="No";
739  break;
740  default:
741  break;
742  }
743  }
744  return namestem;
745 }
746 
747 ////////////////////////////////////////////////////////////////////////////////
748 /// Set parameters
749 
751 {
752  if (!fProof){
753  Error("SetParameters", "Proof not set; Doing nothing");
754  return 1;
755  }
758  fProof->SetParameter("PROOF_BenchmarkDebug", Int_t(fDebug));
759  // For Mac Os X only: do not OS cache the files read
760  fProof->SetParameter("PROOF_DontCacheFiles", Int_t(1));
761  return 0;
762 }
763 
764 ////////////////////////////////////////////////////////////////////////////////
765 /// Delete parameters set for this run
766 
768 {
769  if (!fProof){
770  Error("DeleteParameters", "Proof not set; Doing nothing");
771  return 1;
772  }
773  if (fProof->GetInputList()) {
774  TObject *type = fProof->GetInputList()->FindObject("PROOF_Benchmark_ReadType");
775  if (type) fProof->GetInputList()->Remove(type);
776  }
777  fProof->DeleteParameters("PROOF_BenchmarkDebug");
778  return 0;
779 }
780 
781 ////////////////////////////////////////////////////////////////////////////////
782 /// Build histograms, profiles and graphs needed for this run
783 
785 {
786  TObject *o = 0;
787  Int_t quotient = (stop - start) / step;
788  Int_t ndiv = quotient + 1;
789  Double_t ns_min = start - step/2.;
790  Double_t ns_max = quotient*step + start + step/2.;
791 
792  fProfLegend_evt = new TLegend(0.1, 0.8, 0.3, 0.9);
793  fNormLegend_evt = new TLegend(0.7, 0.8, 0.9, 0.9);
794  fProfLegend_mb = new TLegend(0.1, 0.8, 0.3, 0.9);
795  fNormLegend_mb = new TLegend(0.7, 0.8, 0.9, 0.9);
796 
797  TString axtitle("Active Workers"), namelab(GetName()), sellab(GetSelName());
798  if (nx) {
799  axtitle = "Active Workers/Node";
800  namelab.Form("x_%s", GetName());
801  }
803  sellab.Form("%s_%s", GetSelName(), GetNameStem().Data());
804 
805  TString name, title;
806 
807  // Book perfstat profile (max evts)
808  name.Form("Prof_%s_PS_MaxEvts_%s", namelab.Data(), sellab.Data());
809  title.Form("Profile %s PerfStat Event- %s", namelab.Data(), sellab.Data());
810  fProfile_perfstat_evtmax = new TProfile(name, title, ndiv, ns_min, ns_max);
812  fProfile_perfstat_evtmax->GetYaxis()->SetTitle("Events/sec");
814  fProfile_perfstat_evtmax->SetMarkerStyle(23);
815  fProfile_perfstat_evtmax->SetMarkerStyle(2);
816  if ((o = fListPerfPlots->FindObject(name))) {
818  delete o;
819  }
822 
823  // Book perfstat profile (evts)
824  name.Form("Prof_%s_PS_Evts_%s", namelab.Data(), sellab.Data());
825  title.Form("Profile %s PerfStat Event - %s", namelab.Data(), sellab.Data());
826  fProfile_perfstat_event = new TProfile(name, title, ndiv, ns_min, ns_max);
828  fProfile_perfstat_event->GetYaxis()->SetTitle("Events/sec");
830  fProfile_perfstat_event->SetMarkerStyle(21);
831  if ((o = fListPerfPlots->FindObject(name))) {
833  delete o;
834  }
836 
837  // Book perfstat histogram (evts)
838  name.Form("Hist_%s_PS_Evts_%s", namelab.Data(), sellab.Data());
839  title.Form("Histogram %s PerfStat Event - %s", namelab.Data(), sellab.Data());
840  fHist_perfstat_event = new TH2D(name, title, ndiv, ns_min, ns_max, 100, 0, 0);
842  fHist_perfstat_event->GetYaxis()->SetTitle("Events/sec");
844  fHist_perfstat_event->SetMarkerStyle(7);
845  if ((o = fListPerfPlots->FindObject(name))) {
847  delete o;
848  }
850 
851  // Book normalized perfstat profile (max evts)
852  name.Form("Norm_%s_PF_MaxEvts_%s", namelab.Data(), sellab.Data());
853  title.Form("Profile %s Normalized QueryResult Event - %s", namelab.Data(), sellab.Data());
854  fNorm_perfstat_evtmax = new TProfile(name, title, ndiv, ns_min, ns_max);
856  fNorm_perfstat_evtmax->GetYaxis()->SetTitle("Events/sec");
858  fNorm_perfstat_evtmax->SetMarkerStyle(23);
859  fNorm_perfstat_evtmax->SetMarkerColor(2);
860  if ((o = fListPerfPlots->FindObject(name))) {
862  delete o;
863  }
866 
867  // Book queryresult profile (evts)
868  name.Form("Prof_%s_QR_Evts_%s", namelab.Data(), sellab.Data());
869  title.Form("Profile %s QueryResult Event - %s", namelab.Data(), sellab.Data());
870  fProfile_queryresult_event = new TProfile(name, title, ndiv, ns_min, ns_max);
872  fProfile_queryresult_event->GetYaxis()->SetTitle("Events/sec");
874  fProfile_queryresult_event->SetMarkerStyle(22);
875  if ((o = fListPerfPlots->FindObject(name))) {
877  delete o;
878  }
881 
882  // Book normalized queryresult profile (evts)
883  name.Form("Norm_%s_QR_Evts_%s", namelab.Data(), sellab.Data());
884  title.Form("Profile %s Normalized QueryResult Event - %s", namelab.Data(), sellab.Data());
885  fNorm_queryresult_event = new TProfile(name, title, ndiv, ns_min, ns_max);
887  fNorm_queryresult_event->GetYaxis()->SetTitle("Events/sec");
889  fNorm_queryresult_event->SetMarkerStyle(22);
890  if ((o = fListPerfPlots->FindObject(name))) {
892  delete o;
893  }
896 
897  // Book perfstat profile (mbs)
898  name.Form("Prof_%s_PS_IO_%s", namelab.Data(), sellab.Data());
899  title.Form("Profile %s PerfStat I/O %s", namelab.Data(), sellab.Data());
900  fProfile_perfstat_IO = new TProfile(name, title, ndiv, ns_min, ns_max);
902  fProfile_perfstat_IO->GetYaxis()->SetTitle("MB/sec");
904  fProfile_perfstat_IO->SetMarkerStyle(21);
905  if ((o = fListPerfPlots->FindObject(name))) {
907  delete o;
908  }
910 
911  // Book perfstat histogram (mbs)
912  name.Form("Hist_%s_PS_IO_%s", namelab.Data(), sellab.Data());
913  title.Form("Histogram %s PerfStat I/O - %s", namelab.Data(), sellab.Data());
914  fHist_perfstat_IO = new TH2D(name, title, ndiv, ns_min, ns_max, 100, 0, 0);
916  fHist_perfstat_IO->GetYaxis()->SetTitle("MB/sec");
917  fHist_perfstat_IO->GetXaxis()->SetTitle(axtitle);
918  fHist_perfstat_IO->SetMarkerStyle(7);
919  if ((o = fListPerfPlots->FindObject(name))) {
921  delete o;
922  }
924 
925  // Book perfstat profile (max mbs)
926  name.Form("Prof_%s_PS_MaxIO_%s", namelab.Data(), sellab.Data());
927  title.Form("Profile %s PerfStat I/O - %s", namelab.Data(), sellab.Data());
928  fProfile_perfstat_IOmax = new TProfile(name, title, ndiv, ns_min, ns_max);
932  fProfile_perfstat_IOmax->SetMarkerStyle(21);
933  fProfile_perfstat_IOmax->SetMarkerColor(2);
934  if ((o = fListPerfPlots->FindObject(name))) {
936  delete o;
937  }
940 
941  // Book normalized perfstat profile (max mbs)
942  name.Form("Norm_%s_PS_MaxIO_%s", namelab.Data(), sellab.Data());
943  title.Form("Profile %s Normalized PerfStat I/O - %s", namelab.Data(), sellab.Data());
944  fNorm_perfstat_IOmax = new TProfile(name, title, ndiv, ns_min, ns_max);
946  fNorm_perfstat_IOmax->GetYaxis()->SetTitle("MB/sec");
948  fNorm_perfstat_IOmax->SetMarkerStyle(23);
949  fNorm_perfstat_IOmax->SetMarkerColor(2);
950  if ((o = fListPerfPlots->FindObject(name))) {
952  delete o;
953  }
956 
957  // Book queryresult profile (mbs)
958  name.Form("Prof_%s_QR_IO_%s", namelab.Data(), sellab.Data());
959  title.Form("Profile %s QueryResult I/O - %s", namelab.Data(), sellab.Data());
960  fProfile_queryresult_IO = new TProfile(name, title, ndiv, ns_min, ns_max);
964  fProfile_queryresult_IO->SetMarkerStyle(22);
965  if ((o = fListPerfPlots->FindObject(name))) {
967  delete o;
968  }
971 
972  // Book normalized queryresult profile (mbs)
973  name.Form("Norm_%s_QR_IO_%s", namelab.Data(), sellab.Data());
974  title.Form("Profile %s Normalized QueryResult I/O - %s", namelab.Data(), sellab.Data());
975  fNorm_queryresult_IO = new TProfile(name, title, ndiv, ns_min, ns_max);
977  fNorm_queryresult_IO->GetYaxis()->SetTitle("MB/sec");
979  fNorm_queryresult_IO->SetMarkerStyle(22);
980  if ((o = fListPerfPlots->FindObject(name))) {
982  delete o;
983  }
986 
987  // Book CPU efficiency profile
988  name.Form("Prof_%s_CPU_eff_%s", namelab.Data(), sellab.Data());
989  title.Form("Profile %s CPU efficiency - %s", namelab.Data(), sellab.Data());
990  fProfile_cpu_eff = new TProfile(name, title, ndiv, ns_min, ns_max);
992  fProfile_cpu_eff->GetYaxis()->SetTitle("Efficiency");
993  fProfile_cpu_eff->GetXaxis()->SetTitle(axtitle);
994  fProfile_cpu_eff->SetMarkerStyle(22);
995  if ((o = fListPerfPlots->FindObject(name))) {
997  delete o;
998  }
1000 }
TProofBenchDataSet::ReleaseCache
Int_t ReleaseCache(const char *dset)
Release memory cache for dataset 'dset' Return 0 on success, -1 on error.
Definition: TProofBenchDataSet.cxx:46
l
auto * l
Definition: textangle.C:4
TProofNodes::GetNNodes
Int_t GetNNodes() const
Definition: TProofNodes.h:49
TProofPerfAnalysis.h
TProofBenchRunDataRead::fNormLegend_evt
TLegend * fNormLegend_evt
Definition: TProofBenchRunDataRead.h:81
TFileInfo
Definition: TFileInfo.h:39
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
TObject::TestBit
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:172
TProof::RemoveDataSet
virtual Int_t RemoveDataSet(const char *dataset, const char *optStr="")
Remove the specified dataset from the PROOF cluster.
Definition: TProof.cxx:10981
TCollection::Print
virtual void Print(Option_t *option="") const
Default print for collections, calls Print(option, 1).
Definition: TCollection.cxx:476
TDirectory::mkdir
virtual TDirectory * mkdir(const char *name, const char *title="", Bool_t returnExistingDirectory=kFALSE)
Create a sub-directory "a" or a hierarchy of sub-directories "a/b/c/...".
Definition: TDirectory.cxx:1042
TProofNodes.h
TProofNodes
Definition: TProofNodes.h:28
TProfile::GetBinError
virtual Double_t GetBinError(Int_t bin) const
Return bin error of a Profile histogram.
Definition: TProfile.cxx:881
TPerfEvent::fProcTime
Double_t fProcTime
Definition: TPerfStats.h:54
TPerfEvent::fEventsProcessed
Long64_t fEventsProcessed
Definition: TPerfStats.h:50
TCollection::Write
virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0)
Write all objects in this collection.
Definition: TCollection.cxx:672
TProofBenchRunDataRead::fProfile_perfstat_event
TProfile * fProfile_perfstat_event
Definition: TProofBenchRunDataRead.h:66
TH1::SetMinimum
virtual void SetMinimum(Double_t minimum=-1111)
Definition: TH1.h:396
fc
static struct mg_connection * fc(struct mg_context *ctx)
Definition: civetweb.c:3728
gEnv
R__EXTERN TEnv * gEnv
Definition: TEnv.h:171
TSystem::BaseName
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
Definition: TSystem.cxx:933
TProofBenchRunDataRead::fProfile_queryresult_IO
TProfile * fProfile_queryresult_IO
Definition: TProofBenchRunDataRead.h:76
TList::FindObject
virtual TObject * FindObject(const char *name) const
Find an object in this list using its name.
Definition: TList.cxx:577
TString::Data
const char * Data() const
Definition: TString.h:369
TProof::Print
virtual void Print(Option_t *option="") const
Print status of PROOF cluster.
Definition: TProof.cxx:4793
TProofBenchRunDataRead::fProfile_perfstat_IO
TProfile * fProfile_perfstat_IO
Definition: TProofBenchRunDataRead.h:72
TFileCollection::kRemoteCollection
@ kRemoteCollection
Definition: TFileCollection.h:60
TProofBenchRunDataRead::SetParameters
Int_t SetParameters()
Set parameters.
Definition: TProofBenchRunDataRead.cxx:750
gProof
R__EXTERN TProof * gProof
Definition: TProof.h:1077
TH1::DrawCopy
virtual TH1 * DrawCopy(Option_t *option="", const char *name_postfix="_copy") const
Copy this histogram and Draw in the current pad.
Definition: TH1.cxx:3044
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
TNamed::GetTitle
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:54
TPBReadType::kReadNo
@ kReadNo
Definition: TProofBenchTypes.h:39
TProofBenchRun::GetSelName
virtual const char * GetSelName()
Definition: TProofBenchRun.h:45
TObject::Info
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:864
Long64_t
long long Long64_t
Definition: RtypesCore.h:73
TProofNodes::GetNWorkersCluster
Int_t GetNWorkersCluster() const
Definition: TProofNodes.h:48
TPerfEvent
Definition: TPerfStats.h:39
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:890
TLegend.h
TTree
Definition: TTree.h:79
TMath::Sqrt
Double_t Sqrt(Double_t x)
Definition: TMath.h:691
TCollection::SetOwner
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
Definition: TCollection.cxx:746
TTree::SetBranchAddress
virtual Int_t SetBranchAddress(const char *bname, void *add, TBranch **ptr=0)
Change branch address, dealing with clone trees properly.
Definition: TTree.cxx:8205
TProofNodes::GetNCores
Int_t GetNCores() const
Definition: TProofNodes.h:50
Float_t
float Float_t
Definition: RtypesCore.h:57
TMap::GetValue
TObject * GetValue(const char *keyname) const
Returns a pointer to the value associated with keyname as name of the key.
Definition: TMap.cxx:236
TStyle.h
TProof::ShowDataSet
void ShowDataSet(const char *dataset="", const char *opt="filter:SsCc")
display meta-info for given dataset usi
Definition: TProof.cxx:10967
TUrl::SetHost
void SetHost(const char *host)
Definition: TUrl.h:84
Int_t
int Int_t
Definition: RtypesCore.h:45
TString::Contains
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
SafeDelete
#define SafeDelete(p)
Definition: RConfig.hxx:543
TProofNodes::Print
void Print(Option_t *option="") const
Description: Print node information.
Definition: TProofNodes.cxx:271
TProofBenchRunDataRead::DeleteParameters
Int_t DeleteParameters()
Delete parameters set for this run.
Definition: TProofBenchRunDataRead.cxx:767
TQueryResult.h
kPROOF_BenchDataSelPar
const char *const kPROOF_BenchDataSelPar
Definition: TProofBenchTypes.h:25
TProofNodes::GetNActives
Int_t GetNActives() const
Definition: TProofNodes.h:52
TPad::GetName
const char * GetName() const
Returns name of object.
Definition: TPad.h:254
TProof::ExistsDataSet
virtual Bool_t ExistsDataSet(const char *dataset)
Returns kTRUE if 'dataset' exists, kFALSE otherwise.
Definition: TProof.cxx:10858
TCanvas::Clear
void Clear(Option_t *option="")
Remove all primitives from the canvas.
Definition: TCanvas.cxx:723
TDirectory::cd
virtual Bool_t cd(const char *path=nullptr)
Change current directory to "this" directory.
Definition: TDirectory.cxx:498
TQueryResult
Definition: TQueryResult.h:41
TProof::EnablePackage
Int_t EnablePackage(const char *package, Bool_t notOnClient=kFALSE, TList *workers=0)
Enable specified package.
Definition: TProof.cxx:8165
TPad::Divide
virtual void Divide(Int_t nx=1, Int_t ny=1, Float_t xmargin=0.01, Float_t ymargin=0.01, Int_t color=0)
Automatic pad generation by division.
Definition: TPad.cxx:1166
TProofBenchRunDataRead::fStop
Int_t fStop
Definition: TProofBenchRunDataRead.h:55
TProofBenchRunDataRead::fListPerfPlots
TList * fListPerfPlots
Definition: TProofBenchRunDataRead.h:65
TString::Format
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition: TString.cxx:2311
TCanvas.h
TProof::SetParameter
void SetParameter(const char *par, const char *value)
Set input list parameter.
Definition: TProof.cxx:9812
TEnv.h
TProfile.h
TTree.h
TProof::GetDataSet
virtual TFileCollection * GetDataSet(const char *dataset, const char *optStr="")
Get a list of TFileInfo objects describing the files of the specified dataset.
Definition: TProof.cxx:10927
TString
Definition: TString.h:136
TVirtualPerfStats::kPacket
@ kPacket
Definition: TVirtualPerfStats.h:38
TProof::UploadPackage
Int_t UploadPackage(const char *par, EUploadPackageOpt opt=kUntar, TList *workers=0)
Upload a PROOF archive (PAR file).
Definition: TProof.cxx:8431
TProofBenchRunDataRead::fReleaseCache
Bool_t fReleaseCache
Definition: TProofBenchRunDataRead.h:59
TString.h
TTree::GetEntry
virtual Int_t GetEntry(Long64_t entry=0, Int_t getall=0)
Read all branches of entry and return total number of bytes read.
Definition: TTree.cxx:5537
TProofBenchRunDataRead::fDirProofBench
TDirectory * fDirProofBench
Definition: TProofBenchRunDataRead.h:61
bool
TTree::Write
virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0)
Write this object to the current directory.
Definition: TTree.cxx:9563
TProofBenchRunDataRead::fDebug
Int_t fDebug
Definition: TProofBenchRunDataRead.h:57
TProof::GetOutputList
TList * GetOutputList()
Get list with all object created during processing (see Process()).
Definition: TProof.cxx:9798
TPerfEvent::fType
TVirtualPerfStats::EEventType fType
Definition: TPerfStats.h:44
TDirectory::IsWritable
virtual Bool_t IsWritable() const
Definition: TDirectory.h:181
TROOT.h
TProofBenchRunDataRead::fProfile_perfstat_evtmax
TProfile * fProfile_perfstat_evtmax
Definition: TProofBenchRunDataRead.h:68
TProofBenchRunDataRead::fProfile_perfstat_IOmax
TProfile * fProfile_perfstat_IOmax
Definition: TProofBenchRunDataRead.h:74
TSortedList.h
TObject::kOverwrite
@ kOverwrite
overwrite existing object with same name
Definition: TObject.h:88
TFileCollection::Update
Int_t Update(Long64_t avgsize=-1)
Update accumulated information about the elements of the collection (e.g.
Definition: TFileCollection.cxx:312
kPROOF_BenchParDir
const char *const kPROOF_BenchParDir
Definition: TProofBenchTypes.h:26
TProofBenchRunDataRead::Run
void Run(Long64_t, Int_t, Int_t, Int_t, Int_t, Int_t, Int_t)
Definition: TProofBenchRunDataRead.h:107
TList::First
virtual TObject * First() const
Return the first object in the list. Returns 0 when list is empty.
Definition: TList.cxx:658
TObject::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:359
TProofBenchRunDataRead::GetName
const char * GetName() const
Returns name of object.
Definition: TProofBenchRunDataRead.h:137
TProofBenchRunDataRead::fNorm_perfstat_evtmax
TProfile * fNorm_perfstat_evtmax
Definition: TProofBenchRunDataRead.h:69
TProofBenchRunDataRead::GetDataSet
TFileCollection * GetDataSet(const char *dset, Int_t nact, Bool_t nx)
Get a subsample of dsname suited to run with 'nact' and option 'nx'.
Definition: TProofBenchRunDataRead.cxx:525
TRegexp.h
TProofBenchRunDataRead::fNEvents
Long64_t fNEvents
Definition: TProofBenchRunDataRead.h:52
TString::Form
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2289
TProofBenchRunDataRead::fNormLegend_mb
TLegend * fNormLegend_mb
Definition: TProofBenchRunDataRead.h:83
TQueryResult::GetStartTime
TDatime GetStartTime() const
Definition: TQueryResult.h:122
TPerfEvent::fBytesRead
Long64_t fBytesRead
Definition: TPerfStats.h:51
TProofBenchRunDataRead::fDS
TProofBenchDataSet * fDS
Definition: TProofBenchRunDataRead.h:50
TProofBenchRunDataRead::fFilesPerWrk
Int_t fFilesPerWrk
Definition: TProofBenchRunDataRead.h:58
TString::Tokenize
TObjArray * Tokenize(const TString &delim) const
This function is used to isolate sequential tokens in a TString.
Definition: TString.cxx:2197
Option_t
const typedef char Option_t
Definition: RtypesCore.h:66
TProofBenchRunDataRead::BuildHistos
void BuildHistos(Int_t start, Int_t stop, Int_t step, Bool_t nx)
Build histograms, profiles and graphs needed for this run.
Definition: TProofBenchRunDataRead.cxx:784
TProofBenchRunDataRead::fNTries
Int_t fNTries
Definition: TProofBenchRunDataRead.h:53
TProofPerfAnalysis::GetMBRateAvgMax
Double_t GetMBRateAvgMax() const
Definition: TProofPerfAnalysis.h:105
TProofBenchDataSet
Definition: TProofBenchDataSet.h:27
TLeaf.h
TQueryResult::GetEntries
Long64_t GetEntries() const
Definition: TQueryResult.h:127
gStyle
R__EXTERN TStyle * gStyle
Definition: TStyle.h:412
TProofBenchRunDataRead::fProfile_queryresult_event
TProfile * fProfile_queryresult_event
Definition: TProofBenchRunDataRead.h:70
TProofPerfAnalysis
Definition: TProofPerfAnalysis.h:32
TProof::AddInput
void AddInput(TObject *obj)
Add objects that might be needed during the processing of the selector (see Process()).
Definition: TProof.cxx:9724
TH1::GetYaxis
TAxis * GetYaxis()
Definition: TH1.h:318
TH2D.h
TFileInfo.h
TPerfStats.h
TProof::GetMaster
const char * GetMaster() const
Definition: TProof.h:903
TCanvas::cd
TVirtualPad * cd(Int_t subpadnumber=0)
Set current canvas & pad.
Definition: TCanvas.cxx:704
TProofBenchRun::fSelName
TString fSelName
Definition: TProofBenchRun.h:35
TProof::GetInputList
TList * GetInputList()
Get input list.
Definition: TProof.cxx:9743
TProofBenchRunDataRead::fProof
TProof * fProof
Definition: TProofBenchRunDataRead.h:47
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
TProfile::Fill
Int_t Fill(const Double_t *v)
Definition: TProfile.h:54
TProof.h
TPBReadType::GetType
EReadType GetType() const
Definition: TProofBenchTypes.h:48
TNamed::Clone
virtual TObject * Clone(const char *newname="") const
Make a clone of an object using the Streamer facility.
Definition: TNamed.cxx:74
TH2D
2-D histogram with a double per channel (see TH1 documentation)}
Definition: TH2.h:292
TTime
Definition: TTime.h:27
TH1::SetMaximum
virtual void SetMaximum(Double_t maximum=-1111)
Definition: TH1.h:395
TLegend::AddEntry
TLegendEntry * AddEntry(const TObject *obj, const char *label="", Option_t *option="lpf")
Add a new entry to this legend.
Definition: TLegend.cxx:330
TProof::GetQueryResult
TQueryResult * GetQueryResult(const char *ref=0)
Return pointer to the full TQueryResult instance owned by the player and referenced by 'ref'.
Definition: TProof.cxx:2138
gDirectory
#define gDirectory
Definition: TDirectory.h:236
TProofBenchDataSet::IsProof
Bool_t IsProof(TProof *p)
Definition: TProofBenchDataSet.h:41
TFileCollection.h
TQueryResult::GetEndTime
TDatime GetEndTime() const
Definition: TQueryResult.h:123
TDirectory::GetDirectory
virtual TDirectory * GetDirectory(const char *namecycle, Bool_t printError=false, const char *funcname="GetDirectory")
Find a directory using apath.
Definition: TDirectory.cxx:401
TVirtualPad.h
TH1::SetDirectory
virtual void SetDirectory(TDirectory *dir)
By default when an histogram is created, it is added to the list of histogram objects in the current ...
Definition: TH1.cxx:8392
TProofBenchRun
Definition: TProofBenchRun.h:28
TClass::GetClass
static TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE)
Static method returning pointer to TClass of the specified class name.
Definition: TClass.cxx:2925
TSystem::Now
virtual TTime Now()
Get current time in milliseconds since 0:00 Jan 1 1995.
Definition: TSystem.cxx:464
TQueryResult::GetUsedCPU
Float_t GetUsedCPU() const
Definition: TQueryResult.h:130
TPBReadType::kReadOpt
@ kReadOpt
Definition: TProofBenchTypes.h:38
TProofNodes::GetMinWrksPerNode
Int_t GetMinWrksPerNode() const
Definition: TProofNodes.h:51
TProofBenchRunDataRead::TProofBenchRunDataRead
TProofBenchRunDataRead(TProofBenchDataSet *pbds, TPBReadType *readtype=0, TDirectory *dirproofbench=0, TProof *proof=0, TProofNodes *nodes=0, Long64_t nevents=-1, Int_t ntries=2, Int_t start=1, Int_t stop=-1, Int_t step=1, Int_t debug=0)
Definition: TProofBenchRunDataRead.cxx:58
TProofBenchRunDataRead::fHist_perfstat_event
TH2 * fHist_perfstat_event
Definition: TProofBenchRunDataRead.h:67
TNamed::SetTitle
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
THashList::Remove
TObject * Remove(TObject *obj)
Remove object from the list.
Definition: THashList.cxx:378
TTree::SetDirectory
virtual void SetDirectory(TDirectory *dir)
Change the tree's directory.
Definition: TTree.cxx:8781
TObject::Warning
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:876
TUrl
Definition: TUrl.h:33
TStyle::SetOptStat
void SetOptStat(Int_t stat=1)
The type of information printed in the histogram statistics box can be selected via the parameter mod...
Definition: TStyle.cxx:1592
TPBReadType::kReadFull
@ kReadFull
Definition: TProofBenchTypes.h:37
TFileCollection::Add
Int_t Add(TFileInfo *info)
Add TFileInfo to the collection.
Definition: TFileCollection.cxx:73
TDirectory::GetPath
virtual const char * GetPath() const
Returns the full path of the directory.
Definition: TDirectory.cxx:988
TH2::Fill
Int_t Fill(Double_t)
Invalid Fill method.
Definition: TH2.cxx:294
TProofBenchRunDataRead::fProfLegend_evt
TLegend * fProfLegend_evt
Definition: TProofBenchRunDataRead.h:80
TProofBenchRunDataRead::DrawPerfProfiles
void DrawPerfProfiles()
Get canvas.
Definition: TProofBenchRunDataRead.cxx:693
THashList.h
TROOT::GetEtcDir
static const TString & GetEtcDir()
Get the sysconfig directory in the installation. Static utility function.
Definition: TROOT.cxx:2958
Printf
void Printf(const char *fmt,...)
TProfile
Definition: TProfile.h:32
gSystem
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
TProofBenchRunDataRead::fCPerfProfiles
TCanvas * fCPerfProfiles
Definition: TProofBenchRunDataRead.h:85
TProofBenchRunDataRead::fProfLegend_mb
TLegend * fProfLegend_mb
Definition: TProofBenchRunDataRead.h:82
TProofBenchRunDataRead
Definition: TProofBenchRunDataRead.h:44
TString::IsNull
Bool_t IsNull() const
Definition: TString.h:407
Double_t
double Double_t
Definition: RtypesCore.h:59
TProofBenchRunDataRead.h
TProofNodes::GetMapOfActiveNodes
TMap * GetMapOfActiveNodes() const
Definition: TProofNodes.h:54
TProofBenchRunDataRead::fStart
Int_t fStart
Definition: TProofBenchRunDataRead.h:54
TCanvas
Definition: TCanvas.h:23
TPerfEvent::fEvtNode
TString fEvtNode
Definition: TPerfStats.h:42
TList::Remove
virtual TObject * Remove(TObject *obj)
Remove object from the list.
Definition: TList.cxx:821
TCollection::GetSize
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:182
TProofBenchRunDataRead::fNorm_perfstat_IOmax
TProfile * fNorm_perfstat_IOmax
Definition: TProofBenchRunDataRead.h:75
TProof::Process
virtual Long64_t Process(TDSet *dset, const char *selector, Option_t *option="", Long64_t nentries=-1, Long64_t firstentry=0)
Process a data set (TDSet) using the specified selector (.C) file or Tselector object Entry- or event...
Definition: TProof.cxx:5293
TProofNodes::ActivateWorkers
Int_t ActivateWorkers(Int_t nwrks)
Description: Activate 'nwrks' workers; calls TProof::SetParallel and rebuild the internal lists Input...
Definition: TProofNodes.cxx:150
TFileCollection::GetList
THashList * GetList()
Definition: TFileCollection.h:70
TProofBenchRunDataRead::Print
void Print(Option_t *option="") const
Print the content of this object.
Definition: TProofBenchRunDataRead.cxx:669
TQueryResult::GetProcTime
Float_t GetProcTime() const
Definition: TQueryResult.h:140
TList::Add
virtual void Add(TObject *obj)
Definition: TList.h:87
TProofBenchRunDataRead::fReadType
TPBReadType * fReadType
Definition: TProofBenchRunDataRead.h:49
TObject
Definition: TObject.h:37
TProofBenchRunDataRead::fNorm_queryresult_event
TProfile * fNorm_queryresult_event
Definition: TProofBenchRunDataRead.h:71
TProofBenchRunDataRead::FillPerfStatProfiles
void FillPerfStatProfiles(TTree *t, Int_t nactive)
Definition: TProofBenchRunDataRead.cxx:627
TMap.h
TList::Clear
virtual void Clear(Option_t *option="")
Remove all objects from the list.
Definition: TList.cxx:401
name
char name[80]
Definition: TGX11.cxx:110
TTree::SetName
virtual void SetName(const char *name)
Change the name of this tree.
Definition: TTree.cxx:9020
TProofBenchRunDataRead::fHist_perfstat_IO
TH2 * fHist_perfstat_IO
Definition: TProofBenchRunDataRead.h:73
TDirectory
Definition: TDirectory.h:40
TProofBenchRunDataRead::fProfile_cpu_eff
TProfile * fProfile_cpu_eff
Definition: TProofBenchRunDataRead.h:78
TProofBenchRun::fParList
TString fParList
Definition: TProofBenchRun.h:36
gPad
#define gPad
Definition: TVirtualPad.h:287
TIter
Definition: TCollection.h:233
TLegend::Draw
virtual void Draw(Option_t *option="")
Draw this legend with its current attributes.
Definition: TLegend.cxx:423
TFileCollection::Print
void Print(Option_t *option="") const
Prints the contents of the TFileCollection.
Definition: TFileCollection.cxx:404
TFileCollection::SetDefaultTreeName
void SetDefaultTreeName(const char *treeName)
Definition: TFileCollection.h:95
kPROOF_BenchSelDataDef
const char *const kPROOF_BenchSelDataDef
Definition: TProofBenchTypes.h:30
TProof
Definition: TProof.h:316
TFileCollection::GetDefaultTreeName
const char * GetDefaultTreeName() const
Returns the tree set with SetDefaultTreeName if set Returns the name of the first tree in the meta da...
Definition: TFileCollection.cxx:602
TQueryResult::GetBytes
Long64_t GetBytes() const
Definition: TQueryResult.h:129
TDatime
Definition: TDatime.h:37
TProofPerfAnalysis::GetEvtRateAvgMax
Double_t GetEvtRateAvgMax() const
Definition: TProofPerfAnalysis.h:104
TEnv::SetValue
virtual void SetValue(const char *name, const char *value, EEnvLevel level=kEnvChange, const char *type=0)
Set the value of a resource or create a new resource.
Definition: TEnv.cxx:736
TProofBenchDataSet.h
TProof::DeleteParameters
void DeleteParameters(const char *wildcard)
Delete the input list parameters specified by a wildcard (e.g.
Definition: TProof.cxx:9923
TLegend
Definition: TLegend.h:23
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:53
TProofBenchRun::fSelOption
TString fSelOption
Definition: TProofBenchRun.h:37
type
int type
Definition: TGX11.cxx:121
TProofBenchRunDataRead::fStep
Int_t fStep
Definition: TProofBenchRunDataRead.h:56
TKey.h
TPBReadType
Definition: TProofBenchTypes.h:33
TH1::GetXaxis
TAxis * GetXaxis()
Get the behaviour adopted by the object about the statoverflows. See EStatOverflows for more informat...
Definition: TH1.h:317
Riostream.h
TProofBenchRunDataRead::fNorm_queryresult_IO
TProfile * fNorm_queryresult_IO
Definition: TProofBenchRunDataRead.h:77
TH1.h
TProof::RegisterDataSet
virtual Bool_t RegisterDataSet(const char *name, TFileCollection *dataset, const char *optStr="")
Register the 'dataSet' on the cluster under the current user, group and the given 'dataSetName'.
Definition: TProof.cxx:10697
TTree::GetEntries
virtual Long64_t GetEntries() const
Definition: TTree.h:458
TPad::GetTitle
const char * GetTitle() const
Returns title of object.
Definition: TPad.h:255
TProfile::GetBinContent
virtual Double_t GetBinContent(Int_t bin) const
Return bin content of a Profile histogram.
Definition: TProfile.cxx:817
TUrl::GetHostFQDN
const char * GetHostFQDN() const
Return fully qualified domain name of url host.
Definition: TUrl.cxx:469
TProofBenchRunDataRead::fNodes
TProofNodes * fNodes
Definition: TProofBenchRunDataRead.h:63
TProofBenchRunDataRead::~TProofBenchRunDataRead
virtual ~TProofBenchRunDataRead()
Destructor.
Definition: TProofBenchRunDataRead.cxx:98
TList
Definition: TList.h:44
TMath.h
TProofBenchRunDataRead::fName
TString fName
Definition: TProofBenchRunDataRead.h:87
TProofBenchRunDataRead::GetNameStem
TString GetNameStem() const
Get name for this run.
Definition: TProofBenchRunDataRead.cxx:726
int
TFileCollection::GetFilesPerServer
TMap * GetFilesPerServer(const char *exclude=0, Bool_t curronly=kFALSE)
Return a map of TFileCollections with the files on each data server, excluding servers in the comma-s...
Definition: TFileCollection.cxx:865
TFileCollection
Definition: TFileCollection.h:39
TH1::Draw
virtual void Draw(Option_t *option="")
Draw this histogram with options.
Definition: TH1.cxx:2997
TMap
Definition: TMap.h:40