Logo ROOT   6.16/01
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
15I/O-intensive PROOF benchmark test reads in event files distributed
16on the cluster. Number of events processed per second and size of
17events processed per second are plotted against number of active
18workers. Performance rate for unit packets and performance rate
19for query are plotted.
20
21*/
22
23#include "RConfigure.h"
24
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 "TPad.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
90
91 gEnv->SetValue("Proof.StatsTrace",1);
93}
94
95////////////////////////////////////////////////////////////////////////////////
96/// Destructor
97
99{
100 fProof=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
123void 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
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
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
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
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);
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);
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);
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);
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");
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");
501 gPad->Update();
502
503 //save performance profiles to file
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#if ROOT_VERSION_CODE >= ROOT_VERSION(5,30,0)
547 TMap *mpref = fcref->GetFilesPerServer(fProof->GetMaster(), kTRUE);
548#else
549 TMap *mpref = fcref->GetFilesPerServer(fProof->GetMaster());
550#endif
551 if (!mpref) {
552 SafeDelete(fcref);
553 Error("GetDataSet", "problems classifying info on per-server base");
554 return fcsub;
555 }
556 mpref->Print();
557
558 // Get Active node information
559 TMap *mpnodes = fNodes->GetMapOfActiveNodes();
560 if (!mpnodes) {
561 SafeDelete(fcref);
562 SafeDelete(mpref);
563 Error("GetDataSet", "problems getting map of active nodes");
564 return fcsub;
565 }
566 mpnodes->Print();
567
568 // Number of files: fFilesPerWrk per active worker
570 Printf(" number of files needed (ideally): %d (%d per worker)", nf, fFilesPerWrk);
571
572 // The output dataset
573 fcsub = new TFileCollection(TString::Format("%s_%d_%d", fcref->GetName(), nact, nx),
574 fcref->GetTitle());
575
576 // Order reference sub-collections
577 TIter nxnd(mpnodes);
578 TObject *key = 0;
579 TFileInfo *fi = 0;
580 TFileCollection *xfc = 0;
581 TList *lswrks = 0;
582 while ((key = nxnd())) {
583 TIter nxsrv(mpref);
584 TObject *ksrv = 0;
585 while ((ksrv = nxsrv())) {
586 TUrl urlsrv(ksrv->GetName());
587 if (TString(urlsrv.GetHostFQDN()).IsNull())
589 if (remote ||
590 !strcmp(urlsrv.GetHostFQDN(), TUrl(key->GetName()).GetHostFQDN())) {
591 if ((xfc = dynamic_cast<TFileCollection *>(mpref->GetValue(ksrv)))) {
592 if ((lswrks = dynamic_cast<TList *>(mpnodes->GetValue(key)))) {
593 Int_t nfnd = fFilesPerWrk * lswrks->GetSize();
594 while (nfnd-- && xfc->GetList()->GetSize() > 0) {
595 if ((fi = (TFileInfo *) xfc->GetList()->First())) {
596 xfc->GetList()->Remove(fi);
597 fcsub->Add(fi);
598 }
599 }
600 } else {
601 Warning("GetDataSet", "could not attach to worker list for node '%s'",
602 key->GetName());
603 }
604 } else {
605 Warning("GetDataSet", "could not attach to file collection for server '%s'",
606 ksrv->GetName());
607 }
608 }
609 }
610 }
611
612 // Update counters
613 fcsub->Update();
614 fcsub->Print();
615
616 // Make sure that the tree name is the one of the original dataset
617 if (fcref) {
618 TString dflt(fcref->GetDefaultTreeName());
619 if (!dflt.IsNull()) fcsub->SetDefaultTreeName(dflt);
620 }
621
622 // Cleanup
623 SafeDelete(fcref);
624 SafeDelete(mpref);
625 // Done
626 return fcsub;
627}
628
629////////////////////////////////////////////////////////////////////////////////
630
632{
633 // Fill performance profiles using tree 't'(PROOF_PerfStats).
634 // Input parameters
635 // t: Proof output tree (PROOF_PerfStat) containing performance
636 // statistics.
637 // nactive: Number of active workers processed the query.
638 // Return
639 // Nothing
640
641 // extract timing information
642 TPerfEvent pe;
643 TPerfEvent* pep = &pe;
644 t->SetBranchAddress("PerfEvents",&pep);
645 Long64_t entries = t->GetEntries();
646
647 const Double_t Dmegabytes = 1024.*1024.;
648 Double_t event_rate_packet = 0;
649 Double_t IO_rate_packet = 0;
650
651 for (Long64_t k=0; k<entries; k++) {
652 t->GetEntry(k);
653
654 // Skip information from workers
655 if (pe.fEvtNode.Contains(".")) continue;
656
658 if (pe.fProcTime != 0.0) {
659 event_rate_packet = pe.fEventsProcessed / pe.fProcTime;
660 fHist_perfstat_event->Fill(Double_t(nactive), event_rate_packet);
661 IO_rate_packet = pe.fBytesRead / Dmegabytes / pe.fProcTime;
662 fHist_perfstat_IO->Fill(Double_t(nactive), IO_rate_packet);
663 }
664 }
665 }
666
667 return;
668}
669
670////////////////////////////////////////////////////////////////////////////////
671/// Print the content of this object
672
674{
675 Printf("Name = %s", fName.Data());
676 if (fProof) fProof->Print(option);
677 Printf("fReadType = %s%s", "k", GetNameStem().Data());
678 Printf("fNEvents = %lld", fNEvents);
679 Printf("fNTries = %d", fNTries);
680 Printf("fStart = %d", fStart);
681 Printf("fStop = %d", fStop);
682 Printf("fStep = %d", fStep);
683 Printf("fDebug = %d", fDebug);
684 if (fDirProofBench)
685 Printf("fDirProofBench = %s", fDirProofBench->GetPath());
686 if (fNodes) fNodes->Print(option);
687 if (fListPerfPlots) fListPerfPlots->Print(option);
688
689 if (fCPerfProfiles)
690 Printf("Performance Profiles Canvas: Name = %s Title = %s",
692}
693
694////////////////////////////////////////////////////////////////////////////////
695/// Get canvas
696
698{
699 if (!fCPerfProfiles){
700 TString canvasname = TString::Format("Performance Profiles %s", GetName());
701 fCPerfProfiles = new TCanvas(canvasname.Data(), canvasname.Data());
702 }
703
705
706 // Divide the canvas as many as the number of profiles in the list
707 Int_t nprofiles = fListPerfPlots->GetSize();
708 if (nprofiles <= 2){
709 fCPerfProfiles->Divide(nprofiles);
710 } else {
711 Int_t nside = (Int_t)TMath::Sqrt((Float_t)nprofiles);
712 nside = (nside*nside < nprofiles) ? nside + 1 : nside;
713 fCPerfProfiles->Divide(nside,nside);
714 }
715
716 Int_t npad=1;
718 TProfile* profile=0;
719 while ((profile=(TProfile*)(nxt()))){
720 fCPerfProfiles->cd(npad++);
721 profile->Draw();
722 gPad->Update();
723 }
724 return;
725}
726
727////////////////////////////////////////////////////////////////////////////////
728/// Get name for this run
729
731{
732 TString namestem("+++undef+++");
733 if (fReadType) {
734 switch (fReadType->GetType()) {
736 namestem="Full";
737 break;
739 namestem="Opt";
740 break;
742 namestem="No";
743 break;
744 default:
745 break;
746 }
747 }
748 return namestem;
749}
750
751////////////////////////////////////////////////////////////////////////////////
752/// Set parameters
753
755{
756 if (!fProof){
757 Error("SetParameters", "Proof not set; Doing nothing");
758 return 1;
759 }
762 fProof->SetParameter("PROOF_BenchmarkDebug", Int_t(fDebug));
763 // For Mac Os X only: do not OS cache the files read
764 fProof->SetParameter("PROOF_DontCacheFiles", Int_t(1));
765 return 0;
766}
767
768////////////////////////////////////////////////////////////////////////////////
769/// Delete parameters set for this run
770
772{
773 if (!fProof){
774 Error("DeleteParameters", "Proof not set; Doing nothing");
775 return 1;
776 }
777 if (fProof->GetInputList()) {
778 TObject *type = fProof->GetInputList()->FindObject("PROOF_Benchmark_ReadType");
780 }
781 fProof->DeleteParameters("PROOF_BenchmarkDebug");
782 return 0;
783}
784
785////////////////////////////////////////////////////////////////////////////////
786/// Build histograms, profiles and graphs needed for this run
787
789{
790 TObject *o = 0;
791 Int_t quotient = (stop - start) / step;
792 Int_t ndiv = quotient + 1;
793 Double_t ns_min = start - step/2.;
794 Double_t ns_max = quotient*step + start + step/2.;
795
796 fProfLegend_evt = new TLegend(0.1, 0.8, 0.3, 0.9);
797 fNormLegend_evt = new TLegend(0.7, 0.8, 0.9, 0.9);
798 fProfLegend_mb = new TLegend(0.1, 0.8, 0.3, 0.9);
799 fNormLegend_mb = new TLegend(0.7, 0.8, 0.9, 0.9);
800
801 TString axtitle("Active Workers"), namelab(GetName()), sellab(GetSelName());
802 if (nx) {
803 axtitle = "Active Workers/Node";
804 namelab.Form("x_%s", GetName());
805 }
807 sellab.Form("%s_%s", GetSelName(), GetNameStem().Data());
808
809 TString name, title;
810
811 // Book perfstat profile (max evts)
812 name.Form("Prof_%s_PS_MaxEvts_%s", namelab.Data(), sellab.Data());
813 title.Form("Profile %s PerfStat Event- %s", namelab.Data(), sellab.Data());
814 fProfile_perfstat_evtmax = new TProfile(name, title, ndiv, ns_min, ns_max);
820 if ((o = fListPerfPlots->FindObject(name))) {
822 delete o;
823 }
826
827 // Book perfstat profile (evts)
828 name.Form("Prof_%s_PS_Evts_%s", namelab.Data(), sellab.Data());
829 title.Form("Profile %s PerfStat Event - %s", namelab.Data(), sellab.Data());
830 fProfile_perfstat_event = new TProfile(name, title, ndiv, ns_min, ns_max);
832 fProfile_perfstat_event->GetYaxis()->SetTitle("Events/sec");
835 if ((o = fListPerfPlots->FindObject(name))) {
837 delete o;
838 }
840
841 // Book perfstat histogram (evts)
842 name.Form("Hist_%s_PS_Evts_%s", namelab.Data(), sellab.Data());
843 title.Form("Histogram %s PerfStat Event - %s", namelab.Data(), sellab.Data());
844 fHist_perfstat_event = new TH2D(name, title, ndiv, ns_min, ns_max, 100, 0, 0);
846 fHist_perfstat_event->GetYaxis()->SetTitle("Events/sec");
849 if ((o = fListPerfPlots->FindObject(name))) {
851 delete o;
852 }
854
855 // Book normalized perfstat profile (max evts)
856 name.Form("Norm_%s_PF_MaxEvts_%s", namelab.Data(), sellab.Data());
857 title.Form("Profile %s Normalized QueryResult Event - %s", namelab.Data(), sellab.Data());
858 fNorm_perfstat_evtmax = new TProfile(name, title, ndiv, ns_min, ns_max);
860 fNorm_perfstat_evtmax->GetYaxis()->SetTitle("Events/sec");
864 if ((o = fListPerfPlots->FindObject(name))) {
866 delete o;
867 }
870
871 // Book queryresult profile (evts)
872 name.Form("Prof_%s_QR_Evts_%s", namelab.Data(), sellab.Data());
873 title.Form("Profile %s QueryResult Event - %s", namelab.Data(), sellab.Data());
874 fProfile_queryresult_event = new TProfile(name, title, ndiv, ns_min, ns_max);
879 if ((o = fListPerfPlots->FindObject(name))) {
881 delete o;
882 }
885
886 // Book normalized queryresult profile (evts)
887 name.Form("Norm_%s_QR_Evts_%s", namelab.Data(), sellab.Data());
888 title.Form("Profile %s Normalized QueryResult Event - %s", namelab.Data(), sellab.Data());
889 fNorm_queryresult_event = new TProfile(name, title, ndiv, ns_min, ns_max);
891 fNorm_queryresult_event->GetYaxis()->SetTitle("Events/sec");
894 if ((o = fListPerfPlots->FindObject(name))) {
896 delete o;
897 }
900
901 // Book perfstat profile (mbs)
902 name.Form("Prof_%s_PS_IO_%s", namelab.Data(), sellab.Data());
903 title.Form("Profile %s PerfStat I/O %s", namelab.Data(), sellab.Data());
904 fProfile_perfstat_IO = new TProfile(name, title, ndiv, ns_min, ns_max);
909 if ((o = fListPerfPlots->FindObject(name))) {
911 delete o;
912 }
914
915 // Book perfstat histogram (mbs)
916 name.Form("Hist_%s_PS_IO_%s", namelab.Data(), sellab.Data());
917 title.Form("Histogram %s PerfStat I/O - %s", namelab.Data(), sellab.Data());
918 fHist_perfstat_IO = new TH2D(name, title, ndiv, ns_min, ns_max, 100, 0, 0);
920 fHist_perfstat_IO->GetYaxis()->SetTitle("MB/sec");
923 if ((o = fListPerfPlots->FindObject(name))) {
925 delete o;
926 }
928
929 // Book perfstat profile (max mbs)
930 name.Form("Prof_%s_PS_MaxIO_%s", namelab.Data(), sellab.Data());
931 title.Form("Profile %s PerfStat I/O - %s", namelab.Data(), sellab.Data());
932 fProfile_perfstat_IOmax = new TProfile(name, title, ndiv, ns_min, ns_max);
938 if ((o = fListPerfPlots->FindObject(name))) {
940 delete o;
941 }
944
945 // Book normalized perfstat profile (max mbs)
946 name.Form("Norm_%s_PS_MaxIO_%s", namelab.Data(), sellab.Data());
947 title.Form("Profile %s Normalized PerfStat I/O - %s", namelab.Data(), sellab.Data());
948 fNorm_perfstat_IOmax = new TProfile(name, title, ndiv, ns_min, ns_max);
954 if ((o = fListPerfPlots->FindObject(name))) {
956 delete o;
957 }
960
961 // Book queryresult profile (mbs)
962 name.Form("Prof_%s_QR_IO_%s", namelab.Data(), sellab.Data());
963 title.Form("Profile %s QueryResult I/O - %s", namelab.Data(), sellab.Data());
964 fProfile_queryresult_IO = new TProfile(name, title, ndiv, ns_min, ns_max);
969 if ((o = fListPerfPlots->FindObject(name))) {
971 delete o;
972 }
975
976 // Book normalized queryresult profile (mbs)
977 name.Form("Norm_%s_QR_IO_%s", namelab.Data(), sellab.Data());
978 title.Form("Profile %s Normalized QueryResult I/O - %s", namelab.Data(), sellab.Data());
979 fNorm_queryresult_IO = new TProfile(name, title, ndiv, ns_min, ns_max);
984 if ((o = fListPerfPlots->FindObject(name))) {
986 delete o;
987 }
990
991 // Book CPU efficiency profile
992 name.Form("Prof_%s_CPU_eff_%s", namelab.Data(), sellab.Data());
993 title.Form("Profile %s CPU efficiency - %s", namelab.Data(), sellab.Data());
994 fProfile_cpu_eff = new TProfile(name, title, ndiv, ns_min, ns_max);
996 fProfile_cpu_eff->GetYaxis()->SetTitle("Efficiency");
999 if ((o = fListPerfPlots->FindObject(name))) {
1001 delete o;
1002 }
1004}
#define SafeDelete(p)
Definition: RConfig.hxx:529
int Int_t
Definition: RtypesCore.h:41
const Bool_t kFALSE
Definition: RtypesCore.h:88
bool Bool_t
Definition: RtypesCore.h:59
double Double_t
Definition: RtypesCore.h:55
long long Long64_t
Definition: RtypesCore.h:69
float Float_t
Definition: RtypesCore.h:53
const Bool_t kTRUE
Definition: RtypesCore.h:87
const char Option_t
Definition: RtypesCore.h:62
#define ClassImp(name)
Definition: Rtypes.h:363
#define gDirectory
Definition: TDirectory.h:213
R__EXTERN TEnv * gEnv
Definition: TEnv.h:171
int type
Definition: TGX11.cxx:120
#define Printf
Definition: TGeoToOCC.h:18
const char *const kPROOF_BenchSelDataDef
const char *const kPROOF_BenchDataSelPar
const char *const kPROOF_BenchParDir
R__EXTERN TProof * gProof
Definition: TProof.h:1077
R__EXTERN TStyle * gStyle
Definition: TStyle.h:406
R__EXTERN TSystem * gSystem
Definition: TSystem.h:540
#define gPad
Definition: TVirtualPad.h:286
static struct mg_connection * fc(struct mg_context *ctx)
Definition: civetweb.c:3728
virtual void SetMarkerColor(Color_t mcolor=1)
Set the marker color.
Definition: TAttMarker.h:38
virtual void SetMarkerStyle(Style_t mstyle=1)
Set the marker style.
Definition: TAttMarker.h:40
The Canvas class.
Definition: TCanvas.h:31
void Clear(Option_t *option="")
Remove all primitives from the canvas.
Definition: TCanvas.cxx:712
TVirtualPad * cd(Int_t subpadnumber=0)
Set current canvas & pad.
Definition: TCanvas.cxx:693
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:2885
virtual void Print(Option_t *option="") const
Default print for collections, calls Print(option, 1).
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:182
virtual Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0)
Write all objects in this collection.
This class stores the date and time with a precision of one second in an unsigned 32 bit word (950130...
Definition: TDatime.h:37
Describe directory structure in memory.
Definition: TDirectory.h:34
virtual TDirectory * GetDirectory(const char *namecycle, Bool_t printError=false, const char *funcname="GetDirectory")
Find a directory using apath.
Definition: TDirectory.cxx:400
virtual const char * GetPath() const
Returns the full path of the directory.
Definition: TDirectory.cxx:987
virtual Bool_t cd(const char *path=0)
Change current directory to "this" directory.
Definition: TDirectory.cxx:497
virtual Bool_t IsWritable() const
Definition: TDirectory.h:163
virtual TDirectory * mkdir(const char *name, const char *title="")
Create a sub-directory "a" or a hierarchy of sub-directories "a/b/c/...".
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
Class that contains a list of TFileInfo's and accumulated meta data information about its entries.
Int_t Update(Long64_t avgsize=-1)
Update accumulated information about the elements of the collection (e.g.
THashList * GetList()
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...
void SetDefaultTreeName(const char *treeName)
void Print(Option_t *option="") const
Prints the contents of the TFileCollection.
const char * GetDefaultTreeName() const
Returns the tree set with SetDefaultTreeName if set Returns the name of the first tree in the meta da...
Int_t Add(TFileInfo *info)
Add TFileInfo to the collection.
Class describing a generic file including meta information.
Definition: TFileInfo.h:38
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:8259
TAxis * GetXaxis()
Get the behaviour adopted by the object about the statoverflows. See EStatOverflows for more informat...
Definition: TH1.h:316
virtual void SetMaximum(Double_t maximum=-1111)
Definition: TH1.h:394
TAxis * GetYaxis()
Definition: TH1.h:317
virtual void SetMinimum(Double_t minimum=-1111)
Definition: TH1.h:395
virtual TH1 * DrawCopy(Option_t *option="", const char *name_postfix="_copy") const
Copy this histogram and Draw in the current pad.
Definition: TH1.cxx:3021
virtual void Draw(Option_t *option="")
Draw this histogram with options.
Definition: TH1.cxx:2974
2-D histogram with a double per channel (see TH1 documentation)}
Definition: TH2.h:291
Int_t Fill(Double_t)
Invalid Fill method.
Definition: TH2.cxx:292
TObject * Remove(TObject *obj)
Remove object from the list.
Definition: THashList.cxx:378
This class displays a legend box (TPaveText) containing several legend entries.
Definition: TLegend.h:23
TLegendEntry * AddEntry(const TObject *obj, const char *label="", Option_t *option="lpf")
Add a new entry to this legend.
Definition: TLegend.cxx:330
virtual void Draw(Option_t *option="")
Draw this legend with its current attributes.
Definition: TLegend.cxx:423
A doubly linked list.
Definition: TList.h:44
virtual void Add(TObject *obj)
Definition: TList.h:87
virtual TObject * Remove(TObject *obj)
Remove object from the list.
Definition: TList.cxx:818
virtual TObject * FindObject(const char *name) const
Delete a TObjLink object.
Definition: TList.cxx:574
virtual TObject * First() const
Return the first object in the list. Returns 0 when list is empty.
Definition: TList.cxx:655
virtual void Clear(Option_t *option="")
Remove all objects from the list.
Definition: TList.cxx:399
TMap implements an associative array of (key,value) pairs using a THashTable for efficient retrieval ...
Definition: TMap.h:40
TObject * GetValue(const char *keyname) const
Returns a pointer to the value associated with keyname as name of the key.
Definition: TMap.cxx:235
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:48
virtual TObject * Clone(const char *newname="") const
Make a clone of an object using the Streamer facility.
Definition: TNamed.cxx:74
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:47
Mother of all ROOT objects.
Definition: TObject.h:37
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:357
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:172
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:866
@ kOverwrite
overwrite existing object with same name
Definition: TObject.h:88
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:880
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:854
EReadType GetType() const
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:1162
const char * GetTitle() const
Returns title of object.
Definition: TPad.h:256
const char * GetName() const
Returns name of object.
Definition: TPad.h:255
TString fEvtNode
Definition: TPerfStats.h:42
TVirtualPerfStats::EEventType fType
Definition: TPerfStats.h:44
Double_t fProcTime
Definition: TPerfStats.h:54
Long64_t fBytesRead
Definition: TPerfStats.h:51
Long64_t fEventsProcessed
Definition: TPerfStats.h:50
Profile Histogram.
Definition: TProfile.h:32
virtual Double_t GetBinError(Int_t bin) const
Return bin error of a Profile histogram.
Definition: TProfile.cxx:865
virtual Double_t GetBinContent(Int_t bin) const
Return bin content of a Profile histogram.
Definition: TProfile.cxx:801
Int_t Fill(const Double_t *v)
Definition: TProfile.h:54
Handle operations on datasets used by ProofBench.
Bool_t IsProof(TProof *p)
Int_t ReleaseCache(const char *dset)
Release memory cache for dataset 'dset' Return 0 on success, -1 on error.
I/O-intensive PROOF benchmark test reads in event files distributed on the cluster.
TProofBenchDataSet * fDS
const char * GetName() const
Returns name of object.
TFileCollection * GetDataSet(const char *dset, Int_t nact, Bool_t nx)
Get a subsample of dsname suited to run with 'nact' and option 'nx'.
void FillPerfStatProfiles(TTree *t, Int_t nactive)
Int_t SetParameters()
Set parameters.
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)
TString GetNameStem() const
Get name for this run.
Int_t DeleteParameters()
Delete parameters set for this run.
void Print(Option_t *option="") const
Print the content of this object.
virtual ~TProofBenchRunDataRead()
Destructor.
void BuildHistos(Int_t start, Int_t stop, Int_t step, Bool_t nx)
Build histograms, profiles and graphs needed for this run.
void Run(Long64_t, Int_t, Int_t, Int_t, Int_t, Int_t, Int_t)
Abstract base class for PROOF benchmark runs.
virtual const char * GetSelName()
TString fSelOption
PROOF worker node information
Definition: TProofNodes.h:28
Int_t ActivateWorkers(Int_t nwrks)
Description: Activate 'nwrks' workers; calls TProof::SetParallel and rebuild the internal lists Input...
Int_t GetNNodes() const
Definition: TProofNodes.h:49
Int_t GetMinWrksPerNode() const
Definition: TProofNodes.h:51
void Print(Option_t *option="") const
Description: Print node information.
Int_t GetNWorkersCluster() const
Definition: TProofNodes.h:48
Int_t GetNCores() const
Definition: TProofNodes.h:50
TMap * GetMapOfActiveNodes() const
Definition: TProofNodes.h:54
Int_t GetNActives() const
Definition: TProofNodes.h:52
Set of tools to analyse the performance tree.
Double_t GetMBRateAvgMax() const
Double_t GetEvtRateAvgMax() const
This class controls a Parallel ROOT Facility, PROOF, cluster.
Definition: TProof.h:316
Int_t UploadPackage(const char *par, EUploadPackageOpt opt=kUntar, TList *workers=0)
Upload a PROOF archive (PAR file).
Definition: TProof.cxx:8413
virtual void Print(Option_t *option="") const
Print status of PROOF cluster.
Definition: TProof.cxx:4775
TQueryResult * GetQueryResult(const char *ref=0)
Return pointer to the full TQueryResult instance owned by the player and referenced by 'ref'.
Definition: TProof.cxx:2126
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:10679
void DeleteParameters(const char *wildcard)
Delete the input list parameters specified by a wildcard (e.g.
Definition: TProof.cxx:9905
void SetParameter(const char *par, const char *value)
Set input list parameter.
Definition: TProof.cxx:9794
virtual Int_t RemoveDataSet(const char *dataset, const char *optStr="")
Remove the specified dataset from the PROOF cluster.
Definition: TProof.cxx:10963
TList * GetOutputList()
Get list with all object created during processing (see Process()).
Definition: TProof.cxx:9780
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:10909
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:5275
virtual Bool_t ExistsDataSet(const char *dataset)
Returns kTRUE if 'dataset' exists, kFALSE otherwise.
Definition: TProof.cxx:10840
void ShowDataSet(const char *dataset="", const char *opt="filter:SsCc")
display meta-info for given dataset usi
Definition: TProof.cxx:10949
void AddInput(TObject *obj)
Add objects that might be needed during the processing of the selector (see Process()).
Definition: TProof.cxx:9706
TList * GetInputList()
Get input list.
Definition: TProof.cxx:9725
const char * GetMaster() const
Definition: TProof.h:903
Int_t EnablePackage(const char *package, Bool_t notOnClient=kFALSE, TList *workers=0)
Enable specified package.
Definition: TProof.cxx:8147
A container class for query results.
Definition: TQueryResult.h:36
Long64_t GetEntries() const
Definition: TQueryResult.h:122
TDatime GetEndTime() const
Definition: TQueryResult.h:118
TDatime GetStartTime() const
Definition: TQueryResult.h:117
Float_t GetProcTime() const
Definition: TQueryResult.h:135
Float_t GetUsedCPU() const
Definition: TQueryResult.h:125
Long64_t GetBytes() const
Definition: TQueryResult.h:124
static const TString & GetEtcDir()
Get the sysconfig directory in the installation. Static utility function.
Definition: TROOT.cxx:3010
Basic string class.
Definition: TString.h:131
const char * Data() const
Definition: TString.h:364
TObjArray * Tokenize(const TString &delim) const
This function is used to isolate sequential tokens in a TString.
Definition: TString.cxx:2172
Bool_t IsNull() const
Definition: TString.h:402
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:2286
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2264
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:619
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:1444
virtual TTime Now()
Get current time in milliseconds since 0:00 Jan 1 1995.
Definition: TSystem.cxx:472
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
Definition: TSystem.cxx:941
Basic time type with millisecond precision.
Definition: TTime.h:27
A TTree object has a header with a name and a title.
Definition: TTree.h:71
virtual Int_t SetBranchAddress(const char *bname, void *add, TBranch **ptr=0)
Change branch address, dealing with clone trees properly.
Definition: TTree.cxx:8022
virtual void SetDirectory(TDirectory *dir)
Change the tree's directory.
Definition: TTree.cxx:8590
virtual Long64_t GetEntries() const
Definition: TTree.h:402
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:5397
virtual void SetName(const char *name)
Change the name of this tree.
Definition: TTree.cxx:8819
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:9338
This class represents a WWW compatible URL.
Definition: TUrl.h:35
const char * GetHostFQDN() const
Return fully qualified domain name of url host.
Definition: TUrl.cxx:467
void SetHost(const char *host)
Definition: TUrl.h:87
Double_t Sqrt(Double_t x)
Definition: TMath.h:679
auto * l
Definition: textangle.C:4