// @(#)root/proof:$Id$
// Author: Sangsu Ryu 22/06/2010

/*************************************************************************
 * Copyright (C) 1995-2005, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TProofBenchRunCPU                                                    //
//                                                                      //
// CPU-intensive PROOF benchmark test generates events and fill 1, 2,   //
// or 3-D histograms. No I/O activity is involved.                       //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "RConfigure.h"

#include "TProofBenchRunCPU.h"
#include "TProofNodes.h"
#include "TProofPerfAnalysis.h"
#include "TFileCollection.h"
#include "TFileInfo.h"
#include "TProof.h"
#include "TString.h"
#include "Riostream.h"
#include "TMap.h"
#include "TEnv.h"
#include "TTree.h"
#include "TLeaf.h"
#include "TCanvas.h"
#include "TROOT.h"
#include "TH2.h"
#include "TF1.h"
#include "TProfile.h"
#include "TLegend.h"
#include "TKey.h"
#include "TRegexp.h"
#include "TPerfStats.h"
#include "TQueryResult.h"
#include "TMath.h"
#include "TStyle.h"
#include "TProofNodes.h"
#include "TGraphErrors.h"
#include "TLegend.h"

ClassImp(TProofBenchRunCPU)

//______________________________________________________________________________
TProofBenchRunCPU::TProofBenchRunCPU(TPBHistType *histtype, Int_t nhists,
                                     TDirectory* dirproofbench, TProof* proof,
                                     TProofNodes* nodes, Long64_t nevents, Int_t ntries,
                                     Int_t start, Int_t stop, Int_t step, Int_t draw,
                                     Int_t debug)
                  : TProofBenchRun(proof, kPROOF_BenchSelCPUDef),
                    fHistType(histtype), fNHists(nhists),
                    fNEvents(nevents), fNTries(ntries), fStart(start), fStop(stop),
                    fStep(step), fDraw(draw), fDebug(debug), fDirProofBench(dirproofbench),
                    fNodes(nodes), fListPerfPlots(0),
                    fCanvas(0), fProfile_perfstat_event(0), fHist_perfstat_event(0),
                    fProfile_perfstat_evtmax(0), fNorm_perfstat_evtmax(0),
                    fProfile_queryresult_event(0), fNorm_queryresult_event(0), fProfile_cpu_eff(0),
                    fProfLegend(0), fNormLegend(0), fName(0)
{
   // Default constructor

   if (TestBit(kInvalidObject)) {
      Error("TProofBenchRunCPU", "problems validating PROOF session or enabling selector PAR");
      return;
   }

   fName = "CPU";

   if (!fNodes) fNodes = new TProofNodes(fProof);

   if (stop == -1) fStop = fNodes->GetNWorkersCluster();

   fListPerfPlots = new TList;

   gEnv->SetValue("Proof.StatsTrace",1);
   gStyle->SetOptStat(0);
}

//______________________________________________________________________________
TProofBenchRunCPU::~TProofBenchRunCPU()
{
   // Destructor
   fProof=0;
   fDirProofBench=0;
   SafeDelete(fListPerfPlots);
   SafeDelete(fCanvas);
   SafeDelete(fNodes);
   SafeDelete(fProfLegend);
   SafeDelete(fNormLegend);
}

//______________________________________________________________________________
void TProofBenchRunCPU::BuildHistos(Int_t start, Int_t stop, Int_t step, Bool_t nx)
{
   // Build histograms, profiles and graphs needed for this run

   TObject *o = 0;
   Int_t quotient = (stop - start) / step;
   Int_t ndiv = quotient + 1;
   Double_t ns_min = start - step/2.;
   Double_t ns_max = quotient*step + start + step/2.;

   fProfLegend = new TLegend(0.1, 0.8, 0.3, 0.9);
   fNormLegend = new TLegend(0.7, 0.8, 0.9, 0.9);

   TString axtitle("Active Workers"), namelab(GetName()), sellab(GetSelName());
   if (nx) {
      axtitle = "Active Workers/Node";
      namelab.Form("x_%s", GetName());
   }
   if (fSelName == kPROOF_BenchSelCPUDef)
      sellab.Form("%s_%s", GetSelName(), GetNameStem().Data());

   TString name, title;

   // Book perfstat profile (max evts)
   name.Form("Prof_%s_PS_MaxEvts_%s", namelab.Data(), sellab.Data());
   title.Form("Profile %s PerfStat Event - %s", namelab.Data(), sellab.Data());
   fProfile_perfstat_evtmax = new TProfile(name, title, ndiv, ns_min, ns_max);
   fProfile_perfstat_evtmax->SetDirectory(fDirProofBench);
   fProfile_perfstat_evtmax->GetYaxis()->SetTitle("Events/sec");
   fProfile_perfstat_evtmax->GetXaxis()->SetTitle(axtitle);
   fProfile_perfstat_evtmax->SetMarkerStyle(23);
   fProfile_perfstat_evtmax->SetMarkerColor(2);
   if ((o = fListPerfPlots->FindObject(name))) {
      fListPerfPlots->Remove(o);
      delete o;
   }
   fListPerfPlots->Add(fProfile_perfstat_evtmax);
   fProfLegend->AddEntry(fProfile_perfstat_evtmax, "Maximum");

   // Book perfstat profile
   name.Form("Prof_%s_PS_Evts_%s", namelab.Data(), sellab.Data());
   title.Form("Profile %s PerfStat Event - %s", namelab.Data(), sellab.Data());
   fProfile_perfstat_event = new TProfile(name, title, ndiv, ns_min, ns_max);
   fProfile_perfstat_event->SetDirectory(fDirProofBench);
   fProfile_perfstat_event->GetYaxis()->SetTitle("Events/sec");
   fProfile_perfstat_event->GetXaxis()->SetTitle(axtitle);
   fProfile_perfstat_event->SetMarkerStyle(21);
   if ((o = fListPerfPlots->FindObject(name))) {
      fListPerfPlots->Remove(o);
      delete o;
   }
   fListPerfPlots->Add(fProfile_perfstat_event);
   fProfLegend->AddEntry(fProfile_perfstat_event, "Average");

   // Book perfstat histogram
   name.Form("Hist_%s_PS_Evts_%s", namelab.Data(), sellab.Data());
   title.Form("Histogram %s PerfStat Event - %s", namelab.Data(), sellab.Data());
   fHist_perfstat_event = new TH2D(name, title, ndiv, ns_min, ns_max, 100, 0, 0);
   fHist_perfstat_event->SetDirectory(fDirProofBench);
   fHist_perfstat_event->GetYaxis()->SetTitle("Events/sec");
   fHist_perfstat_event->GetXaxis()->SetTitle(axtitle);
   fHist_perfstat_event->SetMarkerStyle(7);
   if ((o = fListPerfPlots->FindObject(name))) {
      fListPerfPlots->Remove(o);
      delete o;
   }
   fListPerfPlots->Add(fHist_perfstat_event);

   // Book normalized perfstat profile (max evts)
   name.Form("Norm_%s_PS_MaxEvts_%s", namelab.Data(), sellab.Data());
   title.Form("Profile %s Normalized PerfStat Event - %s", namelab.Data(), sellab.Data());
   fNorm_perfstat_evtmax = new TProfile(name, title, ndiv, ns_min, ns_max);
   fNorm_perfstat_evtmax->SetDirectory(fDirProofBench);
   fNorm_perfstat_evtmax->GetYaxis()->SetTitle("Events/sec");
   fNorm_perfstat_evtmax->GetXaxis()->SetTitle(axtitle);
   fNorm_perfstat_evtmax->SetMarkerStyle(23);
   fNorm_perfstat_evtmax->SetMarkerColor(2);
   if ((o = fListPerfPlots->FindObject(name))) {
      fListPerfPlots->Remove(o);
      delete o;
   }
   fListPerfPlots->Add(fNorm_perfstat_evtmax);
   fNormLegend->AddEntry(fNorm_perfstat_evtmax, "Maximum");

   // Book queryresult profile
   name.Form("Prof_%s_QR_Evts_%s", namelab.Data(), sellab.Data());
   title.Form("Profile %s QueryResult Event - %s", namelab.Data(), sellab.Data());
   fProfile_queryresult_event = new TProfile(name, title, ndiv, ns_min, ns_max);
   fProfile_queryresult_event->SetDirectory(fDirProofBench);
   fProfile_queryresult_event->GetYaxis()->SetTitle("Events/sec");
   fProfile_queryresult_event->GetXaxis()->SetTitle(axtitle);
   fProfile_queryresult_event->SetMarkerStyle(22);
   if ((o = fListPerfPlots->FindObject(name))) {
      fListPerfPlots->Remove(o);
      delete o;
   }
   fListPerfPlots->Add(fProfile_queryresult_event);

   // Book normalized queryresult profile
   name.Form("Norm_%s_QR_Evts_%s", namelab.Data(), sellab.Data());
   title.Form("Profile %s Normalized QueryResult Event - %s", namelab.Data(), sellab.Data());
   fNorm_queryresult_event = new TProfile(name, title, ndiv, ns_min, ns_max);
   fNorm_queryresult_event->SetDirectory(fDirProofBench);
   fNorm_queryresult_event->GetYaxis()->SetTitle("Events/sec");
   fNorm_queryresult_event->GetXaxis()->SetTitle(axtitle);
   fNorm_queryresult_event->SetMarkerStyle(22);
   if ((o = fListPerfPlots->FindObject(name))) {
      fListPerfPlots->Remove(o);
      delete o;
   }
   fListPerfPlots->Add(fNorm_queryresult_event);
   fNormLegend->AddEntry(fNorm_queryresult_event, "Average");

   // Book CPU efficiency profile
   name.Form("Prof_%s_CPU_eff_%s", namelab.Data(), sellab.Data());
   title.Form("Profile %s CPU efficiency - %s", namelab.Data(), sellab.Data());
   fProfile_cpu_eff = new TProfile(name, title, ndiv, ns_min, ns_max);
   fProfile_cpu_eff->SetDirectory(fDirProofBench);
   fProfile_cpu_eff->GetYaxis()->SetTitle("Efficiency");
   fProfile_cpu_eff->GetXaxis()->SetTitle(axtitle);
   fProfile_cpu_eff->SetMarkerStyle(22);
   if ((o = fListPerfPlots->FindObject(name))) {
      fListPerfPlots->Remove(o);
      delete o;
   }
   fListPerfPlots->Add(fProfile_cpu_eff);
}

//______________________________________________________________________________
void TProofBenchRunCPU::Run(Long64_t nevents, Int_t start, Int_t stop,
                            Int_t step, Int_t ntries, Int_t debug, Int_t draw)
{
   // Run benchmark
   // Input parameters
   //   nevents:   Number of events to run per file. When it is -1, use data member fNEvents.
   //   start: Start scan with 'start' workers. When it is -1, use data member fStart.
   //          When 0, the same number of workers are activated on all nodes.
   //   stop: Stop scan at 'stop' workers. When it is -1 , use data member fStop.
   //   step: Scan every 'step' workers. When it is -1, use data member fStep.
   //   ntries: Number of repetitions.  When it is -1, use data member fNTries.
   //   debug: debug switch. When it is -1, use data member fDebug.
   //   draw: draw switch. When it is -1, use data member fDraw.
   // Returns
   //    Nothing

   if (!fProof){
      Error("Run", "Proof not set");
      return;
   }

   nevents = (nevents == -1) ? fNEvents : nevents;
   start = (start == -1) ? fStart : start;
   stop = (stop == -1) ? fStop : stop;
   step = (step == -1) ? fStep : step;
   ntries = (ntries == -1) ? fNTries : ntries;
   debug = (debug == -1) ? fDebug : debug;
   draw = (draw == -1) ? fDraw : draw;

   Bool_t nx = kFALSE;
   if (step == -2){
      nx = kTRUE;
      start = fStart;
      step = 1;
   }

   if (nx){
      Int_t minnworkersanode = fNodes->GetMinWrksPerNode();
      if (stop > minnworkersanode) stop = minnworkersanode;
   }

   // Load the selector, if needed
   if (!TClass::GetClass(fSelName)) {
      // Is it the default selector?
      if (fSelName == kPROOF_BenchSelCPUDef) {
         // Load the parfile
#ifdef R__HAVE_CONFIG
         TString par = TString::Format("%s/%s%s.par", ROOTETCDIR, kPROOF_BenchParDir, kPROOF_BenchCPUSelPar);
#else
         TString par = TString::Format("$ROOTSYS/etc/%s%s.par", kPROOF_BenchParDir, kPROOF_BenchCPUSelPar);
#endif
         Info("Run", "Uploading '%s' ...", par.Data());
         if (fProof->UploadPackage(par) != 0) {
            Error("Run", "problems uploading '%s' - cannot continue", par.Data());
            return;
         }
         Info("Run", "Enabling '%s' ...", kPROOF_BenchCPUSelPar);
         if (fProof->EnablePackage(kPROOF_BenchCPUSelPar) != 0) {
            Error("Run", "problems enabling '%s' - cannot continue", kPROOF_BenchCPUSelPar);
            return;
         }
      } else {
         if (fParList.IsNull()) {
            Error("Run", "you should load the class '%s' before running the benchmark", fSelName.Data());
            return;
         } else {
            TString par;
            Int_t from = 0;
            while (fParList.Tokenize(par, from, ",")) {
               Info("Run", "Uploading '%s' ...", par.Data());
               if (fProof->UploadPackage(par) != 0) {
                  Error("Run", "problems uploading '%s' - cannot continue", par.Data());
                  return;
               }
               Info("Run", "Enabling '%s' ...", par.Data());
               if (fProof->EnablePackage(par) != 0) {
                  Error("Run", "problems enabling '%s' - cannot continue", par.Data());
                  return;
               }
            }
         }
      }
      // Check
      if (!TClass::GetClass(fSelName)) {
         Error("Run", "failed to load '%s'", fSelName.Data());
         return;
      }
   }

   // Build histograms, profiles and graphs needed for this run
   BuildHistos(start, stop, step, nx);

   // Get pad
   if (!fCanvas) fCanvas = new TCanvas("Canvas");
   // Cleanup up the canvas
   fCanvas->Clear();

   // Divide the canvas as many as the number of profiles in the list
   fCanvas->Divide(2,1);

   TString perfstats_name = "PROOF_PerfStats";

   SetParameters();

   if (nx){
      Info("Run", "Running CPU-bound tests; %d ~ %d active worker(s)/node,"
                  " every %d worker(s)/node.", start, stop, step);
   } else {
      Info("Run", "Running CPU-bound tests; %d ~ %d active worker(s),"
                  " every %d worker(s).", start, stop, step);
   }

   Int_t npad = 1; //pad number

   Int_t nnodes = fNodes->GetNNodes(); // Number of machines
   Int_t ncores = fNodes->GetNCores(); // Number of cores

   Double_t ymi = -1., ymx = -1., emx = -1.;
   for (Int_t nactive = start; nactive <= stop; nactive += step) {

      // For CPU effectiveness (ok for lite; should do it properly for standard clusters)
      Int_t ncoren = (nactive < ncores) ? nactive : ncores;

      // Actvate the wanted workers
      Int_t nw = -1;
      if (nx) {
         TString workers;
         workers.Form("%dx", nactive);
         nw = fNodes->ActivateWorkers(workers);
      } else {
         nw = fNodes->ActivateWorkers(nactive);
      }
      if (nw < 0){
         Error("Run", "could not activate the requested number of"
                      " workers/node on the cluster; skipping the test point"
                      " (%d workers/node)", nactive);
         continue;
      }

      for (Int_t j = 0; j < ntries; j++) {

         if (nx){
            Info("Run", "Running CPU-bound tests with %d active worker(s)/node;"
                        " trial %d/%d", nactive, j + 1, ntries);
         } else {
            Info("Run", "Running CPU-bound tests with %d active worker(s);"
                        " trial %d/%d", nactive, j + 1, ntries);
         }

         Int_t nevents_all=0;
         if (nx){
            nevents_all=nevents*nactive*nnodes;
         } else {
            nevents_all=nevents*nactive;
         }

         // Process
         fProof->Process(fSelName, nevents_all, fSelOption);

         TList *l = fProof->GetOutputList();

         // Save perfstats
         TTree *t = 0;
         if (l) t = dynamic_cast<TTree*>(l->FindObject(perfstats_name.Data()));
         if (t) {

            //FillPerfStatPerfPlots(t, profile_perfstat_event, nactive);
            FillPerfStatPerfPlots(t, nactive);

            TProofPerfAnalysis pfa(t);
            Double_t pf_eventrate = pfa.GetEvtRateAvgMax();
//            if (pf_eventrate > emx) emx = pf_eventrate;
            fProfile_perfstat_evtmax->Fill(nactive, pf_eventrate);
            fCanvas->cd(npad);
            fProfile_perfstat_evtmax->SetMaximum(emx*1.6);
            fProfile_perfstat_evtmax->SetMinimum(0.);
            fProfile_perfstat_evtmax->Draw("L");
            fProfLegend->Draw();
            gPad->Update();
            // The normalised histos
            // Use the first bin to set the Y range for the histo
            Double_t nert = nx ? pf_eventrate/nactive/nnodes : pf_eventrate/nactive;
            fNorm_perfstat_evtmax->Fill(nactive, nert);
            Double_t y1 = fNorm_perfstat_evtmax->GetBinContent(1);
            Double_t e1 = fNorm_perfstat_evtmax->GetBinError(1);
            Double_t dy = 5 * e1;
            if (dy / y1 < 0.2) dy = y1 * 0.2;
            if (dy > y1) dy = y1*.999999;
            if (ymi < 0.) ymi = y1 - dy;
            if (fNorm_perfstat_evtmax->GetBinContent(nactive) < ymi)
               ymi = fNorm_perfstat_evtmax->GetBinContent(nactive) / 2.;
            if (ymx < 0.) ymx = y1 + dy;
            if (fNorm_perfstat_evtmax->GetBinContent(nactive) > ymx)
               ymx = fNorm_perfstat_evtmax->GetBinContent(nactive) * 1.5;
            fNorm_perfstat_evtmax->SetMaximum(ymx);
            fNorm_perfstat_evtmax->SetMinimum(ymi);
            fCanvas->cd(npad + 1);
            fNorm_perfstat_evtmax->Draw("L");
            fNormLegend->Draw();
            gPad->Update();

            // Build up new name
            TString newname = TString::Format("%s_%s_%dwrks%dthtry", t->GetName(), GetName(), nactive, j);
            t->SetName(newname);

            if (debug && fDirProofBench->IsWritable()){
               TDirectory *curdir = gDirectory;
               TString dirn = nx ? "RunCPUx" : "RunCPU";
               if (!fDirProofBench->GetDirectory(dirn))
                  fDirProofBench->mkdir(dirn, "RunCPU results");
               if (fDirProofBench->cd(dirn)) {
                  t->SetDirectory(fDirProofBench);
                  t->Write();
                  l->Remove(t);
               } else {
                  Warning("Run", "cannot cd to subdirectory '%s' to store the results!", dirn.Data());
               }
               curdir->cd();
            }

         } else {
            if (l)
               Warning("Run", "%s: tree not found", perfstats_name.Data());
            else
               Error("Run", "PROOF output list is empty!");
         }

         // Performance measures from TQueryResult

         const char *drawopt = t ? "LSAME" : "L";
         TQueryResult *queryresult = fProof->GetQueryResult();
         if (queryresult) {
            queryresult->Print("F");
            TDatime qr_start = queryresult->GetStartTime();
            TDatime qr_end = queryresult->GetEndTime();
            Float_t qr_proc = queryresult->GetProcTime();

            Long64_t qr_entries = queryresult->GetEntries();

            // Calculate event rate
            Double_t qr_eventrate = qr_entries / Double_t(qr_proc);
            if (qr_eventrate > emx) emx = qr_eventrate;

            // Calculate and fill CPU efficiency
            Float_t qr_cpu_eff = -1.;
            if (qr_proc > 0.) {
               qr_cpu_eff = queryresult->GetUsedCPU() / ncoren / qr_proc ;
               fProfile_cpu_eff->Fill(nactive, qr_cpu_eff);
               Printf("cpu_eff: %f", qr_cpu_eff);
            }

            // Fill and draw
            fProfile_queryresult_event->Fill(nactive, qr_eventrate);
            fCanvas->cd(npad);
            fProfile_queryresult_event->Draw(drawopt);
            fProfLegend->Draw();
            gPad->Update();
            // The normalised histo
            Double_t nert = nx ? qr_eventrate/nactive/nnodes : qr_eventrate/nactive;
            fNorm_queryresult_event->Fill(nactive, nert);
            // Use the first bin to set the Y range for the histo
            Double_t y1 = fNorm_queryresult_event->GetBinContent(1);
            Double_t e1 = fNorm_queryresult_event->GetBinError(1);
            Double_t dy = 5 * e1;
            if (dy / y1 < 0.2) dy = y1 * 0.2;
            if (dy > y1) dy = y1*.999999;
            if (ymi < 0.) ymi = y1 - dy;
            if (fNorm_queryresult_event->GetBinContent(nactive) < ymi)
               ymi = fNorm_queryresult_event->GetBinContent(nactive) / 2.;
            if (ymx < 0.) ymx = y1 + dy;
            if (fNorm_queryresult_event->GetBinContent(nactive) > ymx)
               ymx = fNorm_queryresult_event->GetBinContent(nactive) * 1.5;
            fNorm_queryresult_event->SetMaximum(ymx);
//            fNorm_queryresult_event->SetMinimum(ymi);
            fNorm_queryresult_event->SetMinimum(0.);
            fCanvas->cd(npad+1);
            fNorm_queryresult_event->Draw(drawopt);
            fNormLegend->Draw();
         } else {
            Warning("Run", "TQueryResult not found!");
         }
         gPad->Update();

      } // for iterations
   } // for number of workers

   // Make the result persistent
   fCanvas->cd(npad);
   fProfile_queryresult_event->SetMaximum(1.6*emx);
   fProfile_queryresult_event->DrawCopy("L");
   fProfile_perfstat_evtmax->DrawCopy("LSAME");
   fProfLegend->Draw();
   fCanvas->cd(npad + 1);
   fNorm_queryresult_event->DrawCopy("L");
   fNorm_perfstat_evtmax->DrawCopy("LSAME");
   fNormLegend->Draw();
   gPad->Update();

   //save performance profiles to file
   if (fDirProofBench && fDirProofBench->IsWritable()){
      TDirectory *curdir = gDirectory;
      TString dirn = nx ? "RunCPUx" : "RunCPU";
      if (!fDirProofBench->GetDirectory(dirn))
         fDirProofBench->mkdir(dirn, "RunCPU results");
      if (fDirProofBench->cd(dirn)) {
         fListPerfPlots->Write(0, kOverwrite);
         fListPerfPlots->SetOwner(kFALSE);
         fListPerfPlots->Clear();
      } else {
         Warning("Run", "cannot cd to subdirectory '%s' to store the results!", dirn.Data());
      }
      curdir->cd();
   }
}

//______________________________________________________________________________
void TProofBenchRunCPU::FillPerfStatPerfPlots(TTree* t, Int_t nactive)
{

   // Fill performance profiles using tree 't'(PROOF_PerfStats).
   // Input parameters
   //    t: Proof output tree (PROOF_PerfStat) containing performance statistics.
   //    profile: Profile to be filled up with information from tree 't'.
   //    nactive: Number of active workers processed the query.
   // Return
   //    Nothing

   // find perfstat profile
   if (!fProfile_perfstat_event){
      Error("FillPerfStatPerfPlots", "no perfstat profile found");
      return;
   }

   // find perfstat histogram
   if (!fHist_perfstat_event){
      Error("FillPerfStatPerfPlots", "no perfstat histogram found");
      return;
   }

   // extract timing information
   TPerfEvent pe;
   TPerfEvent* pep = &pe;
   t->SetBranchAddress("PerfEvents",&pep);
   Long64_t entries = t->GetEntries();

   Double_t event_rate_packet = 0;

   for (Long64_t k=0; k<entries; k++) {

      t->GetEntry(k);

      // Skip information from workers
      if (pe.fEvtNode.Contains(".")) continue;

      if (pe.fType == TVirtualPerfStats::kPacket){
         if (pe.fProcTime != 0.0) {
            event_rate_packet = pe.fEventsProcessed / pe.fProcTime;
            fHist_perfstat_event->Fill(Double_t(nactive), event_rate_packet);
         }
      }
   }

   return;
}

//______________________________________________________________________________
void TProofBenchRunCPU::Print(Option_t* option) const
{
   // Show settings

   Printf("+++ TProofBenchRunCPU +++++++++++++++++++++++++++++++++++++++++");
   Printf("Name      = %s", fName.Data());
   if (fProof) fProof->Print(option);
   Printf("fHistType = k%s", GetNameStem().Data());
   Printf("fNHists   = %d", fNHists);
   Printf("fNEvents  = %lld", fNEvents);
   Printf("fNTries   = %d", fNTries);
   Printf("fStart    = %d", fStart);
   Printf("fStop     = %d", fStop);
   Printf("fStep     = %d", fStep);
   Printf("fDraw     = %d", fDraw);
   Printf("fDebug    = %d", fDebug);
   if (fDirProofBench)
      Printf("fDirProofBench = %s", fDirProofBench->GetPath());
   if (fNodes) fNodes->Print(option);
   if (fListPerfPlots) fListPerfPlots->Print(option);
   if (fCanvas)
      Printf("Performance Canvas: Name = %s Title = %s",
              fCanvas->GetName(), fCanvas->GetTitle());
   Printf("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
}

//______________________________________________________________________________
void TProofBenchRunCPU::DrawPerfPlots()
{
   // Draw Performance plots

   // Get canvas
   if (!fCanvas) fCanvas = new TCanvas("Canvas");

   fCanvas->Clear();

   // Divide the canvas as many as the number of profiles in the list
   Int_t nprofiles = fListPerfPlots->GetSize();
   if (nprofiles <= 2){
      fCanvas->Divide(1,nprofiles);
   } else {
      Int_t nside = (Int_t)TMath::Sqrt((Float_t)nprofiles);
      nside = (nside*nside<nprofiles)?nside+1:nside;
      fCanvas->Divide(nside,nside);
   }

   Int_t npad=1;
   TIter nxt(fListPerfPlots);
   TProfile* profile=0;
   while ((profile=(TProfile*)(nxt()))){
      fCanvas->cd(npad++);
      profile->Draw();
      gPad->Update();
   }
   return;
}

//______________________________________________________________________________
void TProofBenchRunCPU::SetHistType(TPBHistType *histtype)
{
   // Set histogram type

   fHistType = histtype;
   fName.Form("%sCPU", GetNameStem().Data());
}

//______________________________________________________________________________
TString TProofBenchRunCPU::GetNameStem() const
{
   // Get name for this run

   TString namestem("+++undef+++");
   if (fHistType) {
      switch (fHistType->GetType()) {
         case TPBHistType::kHist1D:
            namestem = "Hist1D";
            break;
         case TPBHistType::kHist2D:
            namestem = "Hist2D";
            break;
         case TPBHistType::kHist3D:
            namestem = "Hist3D";
            break;
         case TPBHistType::kHistAll:
            namestem = "HistAll";
            break;
         default:
            break;
      }
   }
   return namestem;
}

//______________________________________________________________________________
Int_t TProofBenchRunCPU::SetParameters()
{
   // Set parameters

   if (!fProof) {
      Error("SetParameters", "proof not set; Doing nothing");
      return 1;
   }

   if (!fHistType) fHistType = new TPBHistType(TPBHistType::kHist1D);
   fProof->AddInput(fHistType);
   fProof->SetParameter("PROOF_BenchmarkNHists", fNHists);
   fProof->SetParameter("PROOF_BenchmarkDraw", Int_t(fDraw));
   return 0;
}

//______________________________________________________________________________
Int_t TProofBenchRunCPU::DeleteParameters()
{
   // Delete parameters set for this run
   if (!fProof){
      Error("DeleteParameters", "proof not set; Doing nothing");
      return 1;
   }
   if (fProof->GetInputList()) {
      TObject *type = fProof->GetInputList()->FindObject("PROOF_Benchmark_HistType");
      if (type) fProof->GetInputList()->Remove(type);
   }
   fProof->DeleteParameters("PROOF_BenchmarkNHists");
   fProof->DeleteParameters("PROOF_BenchmarkDraw");
   return 0;
}

 TProofBenchRunCPU.cxx:1
 TProofBenchRunCPU.cxx:2
 TProofBenchRunCPU.cxx:3
 TProofBenchRunCPU.cxx:4
 TProofBenchRunCPU.cxx:5
 TProofBenchRunCPU.cxx:6
 TProofBenchRunCPU.cxx:7
 TProofBenchRunCPU.cxx:8
 TProofBenchRunCPU.cxx:9
 TProofBenchRunCPU.cxx:10
 TProofBenchRunCPU.cxx:11
 TProofBenchRunCPU.cxx:12
 TProofBenchRunCPU.cxx:13
 TProofBenchRunCPU.cxx:14
 TProofBenchRunCPU.cxx:15
 TProofBenchRunCPU.cxx:16
 TProofBenchRunCPU.cxx:17
 TProofBenchRunCPU.cxx:18
 TProofBenchRunCPU.cxx:19
 TProofBenchRunCPU.cxx:20
 TProofBenchRunCPU.cxx:21
 TProofBenchRunCPU.cxx:22
 TProofBenchRunCPU.cxx:23
 TProofBenchRunCPU.cxx:24
 TProofBenchRunCPU.cxx:25
 TProofBenchRunCPU.cxx:26
 TProofBenchRunCPU.cxx:27
 TProofBenchRunCPU.cxx:28
 TProofBenchRunCPU.cxx:29
 TProofBenchRunCPU.cxx:30
 TProofBenchRunCPU.cxx:31
 TProofBenchRunCPU.cxx:32
 TProofBenchRunCPU.cxx:33
 TProofBenchRunCPU.cxx:34
 TProofBenchRunCPU.cxx:35
 TProofBenchRunCPU.cxx:36
 TProofBenchRunCPU.cxx:37
 TProofBenchRunCPU.cxx:38
 TProofBenchRunCPU.cxx:39
 TProofBenchRunCPU.cxx:40
 TProofBenchRunCPU.cxx:41
 TProofBenchRunCPU.cxx:42
 TProofBenchRunCPU.cxx:43
 TProofBenchRunCPU.cxx:44
 TProofBenchRunCPU.cxx:45
 TProofBenchRunCPU.cxx:46
 TProofBenchRunCPU.cxx:47
 TProofBenchRunCPU.cxx:48
 TProofBenchRunCPU.cxx:49
 TProofBenchRunCPU.cxx:50
 TProofBenchRunCPU.cxx:51
 TProofBenchRunCPU.cxx:52
 TProofBenchRunCPU.cxx:53
 TProofBenchRunCPU.cxx:54
 TProofBenchRunCPU.cxx:55
 TProofBenchRunCPU.cxx:56
 TProofBenchRunCPU.cxx:57
 TProofBenchRunCPU.cxx:58
 TProofBenchRunCPU.cxx:59
 TProofBenchRunCPU.cxx:60
 TProofBenchRunCPU.cxx:61
 TProofBenchRunCPU.cxx:62
 TProofBenchRunCPU.cxx:63
 TProofBenchRunCPU.cxx:64
 TProofBenchRunCPU.cxx:65
 TProofBenchRunCPU.cxx:66
 TProofBenchRunCPU.cxx:67
 TProofBenchRunCPU.cxx:68
 TProofBenchRunCPU.cxx:69
 TProofBenchRunCPU.cxx:70
 TProofBenchRunCPU.cxx:71
 TProofBenchRunCPU.cxx:72
 TProofBenchRunCPU.cxx:73
 TProofBenchRunCPU.cxx:74
 TProofBenchRunCPU.cxx:75
 TProofBenchRunCPU.cxx:76
 TProofBenchRunCPU.cxx:77
 TProofBenchRunCPU.cxx:78
 TProofBenchRunCPU.cxx:79
 TProofBenchRunCPU.cxx:80
 TProofBenchRunCPU.cxx:81
 TProofBenchRunCPU.cxx:82
 TProofBenchRunCPU.cxx:83
 TProofBenchRunCPU.cxx:84
 TProofBenchRunCPU.cxx:85
 TProofBenchRunCPU.cxx:86
 TProofBenchRunCPU.cxx:87
 TProofBenchRunCPU.cxx:88
 TProofBenchRunCPU.cxx:89
 TProofBenchRunCPU.cxx:90
 TProofBenchRunCPU.cxx:91
 TProofBenchRunCPU.cxx:92
 TProofBenchRunCPU.cxx:93
 TProofBenchRunCPU.cxx:94
 TProofBenchRunCPU.cxx:95
 TProofBenchRunCPU.cxx:96
 TProofBenchRunCPU.cxx:97
 TProofBenchRunCPU.cxx:98
 TProofBenchRunCPU.cxx:99
 TProofBenchRunCPU.cxx:100
 TProofBenchRunCPU.cxx:101
 TProofBenchRunCPU.cxx:102
 TProofBenchRunCPU.cxx:103
 TProofBenchRunCPU.cxx:104
 TProofBenchRunCPU.cxx:105
 TProofBenchRunCPU.cxx:106
 TProofBenchRunCPU.cxx:107
 TProofBenchRunCPU.cxx:108
 TProofBenchRunCPU.cxx:109
 TProofBenchRunCPU.cxx:110
 TProofBenchRunCPU.cxx:111
 TProofBenchRunCPU.cxx:112
 TProofBenchRunCPU.cxx:113
 TProofBenchRunCPU.cxx:114
 TProofBenchRunCPU.cxx:115
 TProofBenchRunCPU.cxx:116
 TProofBenchRunCPU.cxx:117
 TProofBenchRunCPU.cxx:118
 TProofBenchRunCPU.cxx:119
 TProofBenchRunCPU.cxx:120
 TProofBenchRunCPU.cxx:121
 TProofBenchRunCPU.cxx:122
 TProofBenchRunCPU.cxx:123
 TProofBenchRunCPU.cxx:124
 TProofBenchRunCPU.cxx:125
 TProofBenchRunCPU.cxx:126
 TProofBenchRunCPU.cxx:127
 TProofBenchRunCPU.cxx:128
 TProofBenchRunCPU.cxx:129
 TProofBenchRunCPU.cxx:130
 TProofBenchRunCPU.cxx:131
 TProofBenchRunCPU.cxx:132
 TProofBenchRunCPU.cxx:133
 TProofBenchRunCPU.cxx:134
 TProofBenchRunCPU.cxx:135
 TProofBenchRunCPU.cxx:136
 TProofBenchRunCPU.cxx:137
 TProofBenchRunCPU.cxx:138
 TProofBenchRunCPU.cxx:139
 TProofBenchRunCPU.cxx:140
 TProofBenchRunCPU.cxx:141
 TProofBenchRunCPU.cxx:142
 TProofBenchRunCPU.cxx:143
 TProofBenchRunCPU.cxx:144
 TProofBenchRunCPU.cxx:145
 TProofBenchRunCPU.cxx:146
 TProofBenchRunCPU.cxx:147
 TProofBenchRunCPU.cxx:148
 TProofBenchRunCPU.cxx:149
 TProofBenchRunCPU.cxx:150
 TProofBenchRunCPU.cxx:151
 TProofBenchRunCPU.cxx:152
 TProofBenchRunCPU.cxx:153
 TProofBenchRunCPU.cxx:154
 TProofBenchRunCPU.cxx:155
 TProofBenchRunCPU.cxx:156
 TProofBenchRunCPU.cxx:157
 TProofBenchRunCPU.cxx:158
 TProofBenchRunCPU.cxx:159
 TProofBenchRunCPU.cxx:160
 TProofBenchRunCPU.cxx:161
 TProofBenchRunCPU.cxx:162
 TProofBenchRunCPU.cxx:163
 TProofBenchRunCPU.cxx:164
 TProofBenchRunCPU.cxx:165
 TProofBenchRunCPU.cxx:166
 TProofBenchRunCPU.cxx:167
 TProofBenchRunCPU.cxx:168
 TProofBenchRunCPU.cxx:169
 TProofBenchRunCPU.cxx:170
 TProofBenchRunCPU.cxx:171
 TProofBenchRunCPU.cxx:172
 TProofBenchRunCPU.cxx:173
 TProofBenchRunCPU.cxx:174
 TProofBenchRunCPU.cxx:175
 TProofBenchRunCPU.cxx:176
 TProofBenchRunCPU.cxx:177
 TProofBenchRunCPU.cxx:178
 TProofBenchRunCPU.cxx:179
 TProofBenchRunCPU.cxx:180
 TProofBenchRunCPU.cxx:181
 TProofBenchRunCPU.cxx:182
 TProofBenchRunCPU.cxx:183
 TProofBenchRunCPU.cxx:184
 TProofBenchRunCPU.cxx:185
 TProofBenchRunCPU.cxx:186
 TProofBenchRunCPU.cxx:187
 TProofBenchRunCPU.cxx:188
 TProofBenchRunCPU.cxx:189
 TProofBenchRunCPU.cxx:190
 TProofBenchRunCPU.cxx:191
 TProofBenchRunCPU.cxx:192
 TProofBenchRunCPU.cxx:193
 TProofBenchRunCPU.cxx:194
 TProofBenchRunCPU.cxx:195
 TProofBenchRunCPU.cxx:196
 TProofBenchRunCPU.cxx:197
 TProofBenchRunCPU.cxx:198
 TProofBenchRunCPU.cxx:199
 TProofBenchRunCPU.cxx:200
 TProofBenchRunCPU.cxx:201
 TProofBenchRunCPU.cxx:202
 TProofBenchRunCPU.cxx:203
 TProofBenchRunCPU.cxx:204
 TProofBenchRunCPU.cxx:205
 TProofBenchRunCPU.cxx:206
 TProofBenchRunCPU.cxx:207
 TProofBenchRunCPU.cxx:208
 TProofBenchRunCPU.cxx:209
 TProofBenchRunCPU.cxx:210
 TProofBenchRunCPU.cxx:211
 TProofBenchRunCPU.cxx:212
 TProofBenchRunCPU.cxx:213
 TProofBenchRunCPU.cxx:214
 TProofBenchRunCPU.cxx:215
 TProofBenchRunCPU.cxx:216
 TProofBenchRunCPU.cxx:217
 TProofBenchRunCPU.cxx:218
 TProofBenchRunCPU.cxx:219
 TProofBenchRunCPU.cxx:220
 TProofBenchRunCPU.cxx:221
 TProofBenchRunCPU.cxx:222
 TProofBenchRunCPU.cxx:223
 TProofBenchRunCPU.cxx:224
 TProofBenchRunCPU.cxx:225
 TProofBenchRunCPU.cxx:226
 TProofBenchRunCPU.cxx:227
 TProofBenchRunCPU.cxx:228
 TProofBenchRunCPU.cxx:229
 TProofBenchRunCPU.cxx:230
 TProofBenchRunCPU.cxx:231
 TProofBenchRunCPU.cxx:232
 TProofBenchRunCPU.cxx:233
 TProofBenchRunCPU.cxx:234
 TProofBenchRunCPU.cxx:235
 TProofBenchRunCPU.cxx:236
 TProofBenchRunCPU.cxx:237
 TProofBenchRunCPU.cxx:238
 TProofBenchRunCPU.cxx:239
 TProofBenchRunCPU.cxx:240
 TProofBenchRunCPU.cxx:241
 TProofBenchRunCPU.cxx:242
 TProofBenchRunCPU.cxx:243
 TProofBenchRunCPU.cxx:244
 TProofBenchRunCPU.cxx:245
 TProofBenchRunCPU.cxx:246
 TProofBenchRunCPU.cxx:247
 TProofBenchRunCPU.cxx:248
 TProofBenchRunCPU.cxx:249
 TProofBenchRunCPU.cxx:250
 TProofBenchRunCPU.cxx:251
 TProofBenchRunCPU.cxx:252
 TProofBenchRunCPU.cxx:253
 TProofBenchRunCPU.cxx:254
 TProofBenchRunCPU.cxx:255
 TProofBenchRunCPU.cxx:256
 TProofBenchRunCPU.cxx:257
 TProofBenchRunCPU.cxx:258
 TProofBenchRunCPU.cxx:259
 TProofBenchRunCPU.cxx:260
 TProofBenchRunCPU.cxx:261
 TProofBenchRunCPU.cxx:262
 TProofBenchRunCPU.cxx:263
 TProofBenchRunCPU.cxx:264
 TProofBenchRunCPU.cxx:265
 TProofBenchRunCPU.cxx:266
 TProofBenchRunCPU.cxx:267
 TProofBenchRunCPU.cxx:268
 TProofBenchRunCPU.cxx:269
 TProofBenchRunCPU.cxx:270
 TProofBenchRunCPU.cxx:271
 TProofBenchRunCPU.cxx:272
 TProofBenchRunCPU.cxx:273
 TProofBenchRunCPU.cxx:274
 TProofBenchRunCPU.cxx:275
 TProofBenchRunCPU.cxx:276
 TProofBenchRunCPU.cxx:277
 TProofBenchRunCPU.cxx:278
 TProofBenchRunCPU.cxx:279
 TProofBenchRunCPU.cxx:280
 TProofBenchRunCPU.cxx:281
 TProofBenchRunCPU.cxx:282
 TProofBenchRunCPU.cxx:283
 TProofBenchRunCPU.cxx:284
 TProofBenchRunCPU.cxx:285
 TProofBenchRunCPU.cxx:286
 TProofBenchRunCPU.cxx:287
 TProofBenchRunCPU.cxx:288
 TProofBenchRunCPU.cxx:289
 TProofBenchRunCPU.cxx:290
 TProofBenchRunCPU.cxx:291
 TProofBenchRunCPU.cxx:292
 TProofBenchRunCPU.cxx:293
 TProofBenchRunCPU.cxx:294
 TProofBenchRunCPU.cxx:295
 TProofBenchRunCPU.cxx:296
 TProofBenchRunCPU.cxx:297
 TProofBenchRunCPU.cxx:298
 TProofBenchRunCPU.cxx:299
 TProofBenchRunCPU.cxx:300
 TProofBenchRunCPU.cxx:301
 TProofBenchRunCPU.cxx:302
 TProofBenchRunCPU.cxx:303
 TProofBenchRunCPU.cxx:304
 TProofBenchRunCPU.cxx:305
 TProofBenchRunCPU.cxx:306
 TProofBenchRunCPU.cxx:307
 TProofBenchRunCPU.cxx:308
 TProofBenchRunCPU.cxx:309
 TProofBenchRunCPU.cxx:310
 TProofBenchRunCPU.cxx:311
 TProofBenchRunCPU.cxx:312
 TProofBenchRunCPU.cxx:313
 TProofBenchRunCPU.cxx:314
 TProofBenchRunCPU.cxx:315
 TProofBenchRunCPU.cxx:316
 TProofBenchRunCPU.cxx:317
 TProofBenchRunCPU.cxx:318
 TProofBenchRunCPU.cxx:319
 TProofBenchRunCPU.cxx:320
 TProofBenchRunCPU.cxx:321
 TProofBenchRunCPU.cxx:322
 TProofBenchRunCPU.cxx:323
 TProofBenchRunCPU.cxx:324
 TProofBenchRunCPU.cxx:325
 TProofBenchRunCPU.cxx:326
 TProofBenchRunCPU.cxx:327
 TProofBenchRunCPU.cxx:328
 TProofBenchRunCPU.cxx:329
 TProofBenchRunCPU.cxx:330
 TProofBenchRunCPU.cxx:331
 TProofBenchRunCPU.cxx:332
 TProofBenchRunCPU.cxx:333
 TProofBenchRunCPU.cxx:334
 TProofBenchRunCPU.cxx:335
 TProofBenchRunCPU.cxx:336
 TProofBenchRunCPU.cxx:337
 TProofBenchRunCPU.cxx:338
 TProofBenchRunCPU.cxx:339
 TProofBenchRunCPU.cxx:340
 TProofBenchRunCPU.cxx:341
 TProofBenchRunCPU.cxx:342
 TProofBenchRunCPU.cxx:343
 TProofBenchRunCPU.cxx:344
 TProofBenchRunCPU.cxx:345
 TProofBenchRunCPU.cxx:346
 TProofBenchRunCPU.cxx:347
 TProofBenchRunCPU.cxx:348
 TProofBenchRunCPU.cxx:349
 TProofBenchRunCPU.cxx:350
 TProofBenchRunCPU.cxx:351
 TProofBenchRunCPU.cxx:352
 TProofBenchRunCPU.cxx:353
 TProofBenchRunCPU.cxx:354
 TProofBenchRunCPU.cxx:355
 TProofBenchRunCPU.cxx:356
 TProofBenchRunCPU.cxx:357
 TProofBenchRunCPU.cxx:358
 TProofBenchRunCPU.cxx:359
 TProofBenchRunCPU.cxx:360
 TProofBenchRunCPU.cxx:361
 TProofBenchRunCPU.cxx:362
 TProofBenchRunCPU.cxx:363
 TProofBenchRunCPU.cxx:364
 TProofBenchRunCPU.cxx:365
 TProofBenchRunCPU.cxx:366
 TProofBenchRunCPU.cxx:367
 TProofBenchRunCPU.cxx:368
 TProofBenchRunCPU.cxx:369
 TProofBenchRunCPU.cxx:370
 TProofBenchRunCPU.cxx:371
 TProofBenchRunCPU.cxx:372
 TProofBenchRunCPU.cxx:373
 TProofBenchRunCPU.cxx:374
 TProofBenchRunCPU.cxx:375
 TProofBenchRunCPU.cxx:376
 TProofBenchRunCPU.cxx:377
 TProofBenchRunCPU.cxx:378
 TProofBenchRunCPU.cxx:379
 TProofBenchRunCPU.cxx:380
 TProofBenchRunCPU.cxx:381
 TProofBenchRunCPU.cxx:382
 TProofBenchRunCPU.cxx:383
 TProofBenchRunCPU.cxx:384
 TProofBenchRunCPU.cxx:385
 TProofBenchRunCPU.cxx:386
 TProofBenchRunCPU.cxx:387
 TProofBenchRunCPU.cxx:388
 TProofBenchRunCPU.cxx:389
 TProofBenchRunCPU.cxx:390
 TProofBenchRunCPU.cxx:391
 TProofBenchRunCPU.cxx:392
 TProofBenchRunCPU.cxx:393
 TProofBenchRunCPU.cxx:394
 TProofBenchRunCPU.cxx:395
 TProofBenchRunCPU.cxx:396
 TProofBenchRunCPU.cxx:397
 TProofBenchRunCPU.cxx:398
 TProofBenchRunCPU.cxx:399
 TProofBenchRunCPU.cxx:400
 TProofBenchRunCPU.cxx:401
 TProofBenchRunCPU.cxx:402
 TProofBenchRunCPU.cxx:403
 TProofBenchRunCPU.cxx:404
 TProofBenchRunCPU.cxx:405
 TProofBenchRunCPU.cxx:406
 TProofBenchRunCPU.cxx:407
 TProofBenchRunCPU.cxx:408
 TProofBenchRunCPU.cxx:409
 TProofBenchRunCPU.cxx:410
 TProofBenchRunCPU.cxx:411
 TProofBenchRunCPU.cxx:412
 TProofBenchRunCPU.cxx:413
 TProofBenchRunCPU.cxx:414
 TProofBenchRunCPU.cxx:415
 TProofBenchRunCPU.cxx:416
 TProofBenchRunCPU.cxx:417
 TProofBenchRunCPU.cxx:418
 TProofBenchRunCPU.cxx:419
 TProofBenchRunCPU.cxx:420
 TProofBenchRunCPU.cxx:421
 TProofBenchRunCPU.cxx:422
 TProofBenchRunCPU.cxx:423
 TProofBenchRunCPU.cxx:424
 TProofBenchRunCPU.cxx:425
 TProofBenchRunCPU.cxx:426
 TProofBenchRunCPU.cxx:427
 TProofBenchRunCPU.cxx:428
 TProofBenchRunCPU.cxx:429
 TProofBenchRunCPU.cxx:430
 TProofBenchRunCPU.cxx:431
 TProofBenchRunCPU.cxx:432
 TProofBenchRunCPU.cxx:433
 TProofBenchRunCPU.cxx:434
 TProofBenchRunCPU.cxx:435
 TProofBenchRunCPU.cxx:436
 TProofBenchRunCPU.cxx:437
 TProofBenchRunCPU.cxx:438
 TProofBenchRunCPU.cxx:439
 TProofBenchRunCPU.cxx:440
 TProofBenchRunCPU.cxx:441
 TProofBenchRunCPU.cxx:442
 TProofBenchRunCPU.cxx:443
 TProofBenchRunCPU.cxx:444
 TProofBenchRunCPU.cxx:445
 TProofBenchRunCPU.cxx:446
 TProofBenchRunCPU.cxx:447
 TProofBenchRunCPU.cxx:448
 TProofBenchRunCPU.cxx:449
 TProofBenchRunCPU.cxx:450
 TProofBenchRunCPU.cxx:451
 TProofBenchRunCPU.cxx:452
 TProofBenchRunCPU.cxx:453
 TProofBenchRunCPU.cxx:454
 TProofBenchRunCPU.cxx:455
 TProofBenchRunCPU.cxx:456
 TProofBenchRunCPU.cxx:457
 TProofBenchRunCPU.cxx:458
 TProofBenchRunCPU.cxx:459
 TProofBenchRunCPU.cxx:460
 TProofBenchRunCPU.cxx:461
 TProofBenchRunCPU.cxx:462
 TProofBenchRunCPU.cxx:463
 TProofBenchRunCPU.cxx:464
 TProofBenchRunCPU.cxx:465
 TProofBenchRunCPU.cxx:466
 TProofBenchRunCPU.cxx:467
 TProofBenchRunCPU.cxx:468
 TProofBenchRunCPU.cxx:469
 TProofBenchRunCPU.cxx:470
 TProofBenchRunCPU.cxx:471
 TProofBenchRunCPU.cxx:472
 TProofBenchRunCPU.cxx:473
 TProofBenchRunCPU.cxx:474
 TProofBenchRunCPU.cxx:475
 TProofBenchRunCPU.cxx:476
 TProofBenchRunCPU.cxx:477
 TProofBenchRunCPU.cxx:478
 TProofBenchRunCPU.cxx:479
 TProofBenchRunCPU.cxx:480
 TProofBenchRunCPU.cxx:481
 TProofBenchRunCPU.cxx:482
 TProofBenchRunCPU.cxx:483
 TProofBenchRunCPU.cxx:484
 TProofBenchRunCPU.cxx:485
 TProofBenchRunCPU.cxx:486
 TProofBenchRunCPU.cxx:487
 TProofBenchRunCPU.cxx:488
 TProofBenchRunCPU.cxx:489
 TProofBenchRunCPU.cxx:490
 TProofBenchRunCPU.cxx:491
 TProofBenchRunCPU.cxx:492
 TProofBenchRunCPU.cxx:493
 TProofBenchRunCPU.cxx:494
 TProofBenchRunCPU.cxx:495
 TProofBenchRunCPU.cxx:496
 TProofBenchRunCPU.cxx:497
 TProofBenchRunCPU.cxx:498
 TProofBenchRunCPU.cxx:499
 TProofBenchRunCPU.cxx:500
 TProofBenchRunCPU.cxx:501
 TProofBenchRunCPU.cxx:502
 TProofBenchRunCPU.cxx:503
 TProofBenchRunCPU.cxx:504
 TProofBenchRunCPU.cxx:505
 TProofBenchRunCPU.cxx:506
 TProofBenchRunCPU.cxx:507
 TProofBenchRunCPU.cxx:508
 TProofBenchRunCPU.cxx:509
 TProofBenchRunCPU.cxx:510
 TProofBenchRunCPU.cxx:511
 TProofBenchRunCPU.cxx:512
 TProofBenchRunCPU.cxx:513
 TProofBenchRunCPU.cxx:514
 TProofBenchRunCPU.cxx:515
 TProofBenchRunCPU.cxx:516
 TProofBenchRunCPU.cxx:517
 TProofBenchRunCPU.cxx:518
 TProofBenchRunCPU.cxx:519
 TProofBenchRunCPU.cxx:520
 TProofBenchRunCPU.cxx:521
 TProofBenchRunCPU.cxx:522
 TProofBenchRunCPU.cxx:523
 TProofBenchRunCPU.cxx:524
 TProofBenchRunCPU.cxx:525
 TProofBenchRunCPU.cxx:526
 TProofBenchRunCPU.cxx:527
 TProofBenchRunCPU.cxx:528
 TProofBenchRunCPU.cxx:529
 TProofBenchRunCPU.cxx:530
 TProofBenchRunCPU.cxx:531
 TProofBenchRunCPU.cxx:532
 TProofBenchRunCPU.cxx:533
 TProofBenchRunCPU.cxx:534
 TProofBenchRunCPU.cxx:535
 TProofBenchRunCPU.cxx:536
 TProofBenchRunCPU.cxx:537
 TProofBenchRunCPU.cxx:538
 TProofBenchRunCPU.cxx:539
 TProofBenchRunCPU.cxx:540
 TProofBenchRunCPU.cxx:541
 TProofBenchRunCPU.cxx:542
 TProofBenchRunCPU.cxx:543
 TProofBenchRunCPU.cxx:544
 TProofBenchRunCPU.cxx:545
 TProofBenchRunCPU.cxx:546
 TProofBenchRunCPU.cxx:547
 TProofBenchRunCPU.cxx:548
 TProofBenchRunCPU.cxx:549
 TProofBenchRunCPU.cxx:550
 TProofBenchRunCPU.cxx:551
 TProofBenchRunCPU.cxx:552
 TProofBenchRunCPU.cxx:553
 TProofBenchRunCPU.cxx:554
 TProofBenchRunCPU.cxx:555
 TProofBenchRunCPU.cxx:556
 TProofBenchRunCPU.cxx:557
 TProofBenchRunCPU.cxx:558
 TProofBenchRunCPU.cxx:559
 TProofBenchRunCPU.cxx:560
 TProofBenchRunCPU.cxx:561
 TProofBenchRunCPU.cxx:562
 TProofBenchRunCPU.cxx:563
 TProofBenchRunCPU.cxx:564
 TProofBenchRunCPU.cxx:565
 TProofBenchRunCPU.cxx:566
 TProofBenchRunCPU.cxx:567
 TProofBenchRunCPU.cxx:568
 TProofBenchRunCPU.cxx:569
 TProofBenchRunCPU.cxx:570
 TProofBenchRunCPU.cxx:571
 TProofBenchRunCPU.cxx:572
 TProofBenchRunCPU.cxx:573
 TProofBenchRunCPU.cxx:574
 TProofBenchRunCPU.cxx:575
 TProofBenchRunCPU.cxx:576
 TProofBenchRunCPU.cxx:577
 TProofBenchRunCPU.cxx:578
 TProofBenchRunCPU.cxx:579
 TProofBenchRunCPU.cxx:580
 TProofBenchRunCPU.cxx:581
 TProofBenchRunCPU.cxx:582
 TProofBenchRunCPU.cxx:583
 TProofBenchRunCPU.cxx:584
 TProofBenchRunCPU.cxx:585
 TProofBenchRunCPU.cxx:586
 TProofBenchRunCPU.cxx:587
 TProofBenchRunCPU.cxx:588
 TProofBenchRunCPU.cxx:589
 TProofBenchRunCPU.cxx:590
 TProofBenchRunCPU.cxx:591
 TProofBenchRunCPU.cxx:592
 TProofBenchRunCPU.cxx:593
 TProofBenchRunCPU.cxx:594
 TProofBenchRunCPU.cxx:595
 TProofBenchRunCPU.cxx:596
 TProofBenchRunCPU.cxx:597
 TProofBenchRunCPU.cxx:598
 TProofBenchRunCPU.cxx:599
 TProofBenchRunCPU.cxx:600
 TProofBenchRunCPU.cxx:601
 TProofBenchRunCPU.cxx:602
 TProofBenchRunCPU.cxx:603
 TProofBenchRunCPU.cxx:604
 TProofBenchRunCPU.cxx:605
 TProofBenchRunCPU.cxx:606
 TProofBenchRunCPU.cxx:607
 TProofBenchRunCPU.cxx:608
 TProofBenchRunCPU.cxx:609
 TProofBenchRunCPU.cxx:610
 TProofBenchRunCPU.cxx:611
 TProofBenchRunCPU.cxx:612
 TProofBenchRunCPU.cxx:613
 TProofBenchRunCPU.cxx:614
 TProofBenchRunCPU.cxx:615
 TProofBenchRunCPU.cxx:616
 TProofBenchRunCPU.cxx:617
 TProofBenchRunCPU.cxx:618
 TProofBenchRunCPU.cxx:619
 TProofBenchRunCPU.cxx:620
 TProofBenchRunCPU.cxx:621
 TProofBenchRunCPU.cxx:622
 TProofBenchRunCPU.cxx:623
 TProofBenchRunCPU.cxx:624
 TProofBenchRunCPU.cxx:625
 TProofBenchRunCPU.cxx:626
 TProofBenchRunCPU.cxx:627
 TProofBenchRunCPU.cxx:628
 TProofBenchRunCPU.cxx:629
 TProofBenchRunCPU.cxx:630
 TProofBenchRunCPU.cxx:631
 TProofBenchRunCPU.cxx:632
 TProofBenchRunCPU.cxx:633
 TProofBenchRunCPU.cxx:634
 TProofBenchRunCPU.cxx:635
 TProofBenchRunCPU.cxx:636
 TProofBenchRunCPU.cxx:637
 TProofBenchRunCPU.cxx:638
 TProofBenchRunCPU.cxx:639
 TProofBenchRunCPU.cxx:640
 TProofBenchRunCPU.cxx:641
 TProofBenchRunCPU.cxx:642
 TProofBenchRunCPU.cxx:643
 TProofBenchRunCPU.cxx:644
 TProofBenchRunCPU.cxx:645
 TProofBenchRunCPU.cxx:646
 TProofBenchRunCPU.cxx:647
 TProofBenchRunCPU.cxx:648
 TProofBenchRunCPU.cxx:649
 TProofBenchRunCPU.cxx:650
 TProofBenchRunCPU.cxx:651
 TProofBenchRunCPU.cxx:652
 TProofBenchRunCPU.cxx:653
 TProofBenchRunCPU.cxx:654
 TProofBenchRunCPU.cxx:655
 TProofBenchRunCPU.cxx:656
 TProofBenchRunCPU.cxx:657
 TProofBenchRunCPU.cxx:658
 TProofBenchRunCPU.cxx:659
 TProofBenchRunCPU.cxx:660
 TProofBenchRunCPU.cxx:661
 TProofBenchRunCPU.cxx:662
 TProofBenchRunCPU.cxx:663
 TProofBenchRunCPU.cxx:664
 TProofBenchRunCPU.cxx:665
 TProofBenchRunCPU.cxx:666
 TProofBenchRunCPU.cxx:667
 TProofBenchRunCPU.cxx:668
 TProofBenchRunCPU.cxx:669
 TProofBenchRunCPU.cxx:670
 TProofBenchRunCPU.cxx:671
 TProofBenchRunCPU.cxx:672
 TProofBenchRunCPU.cxx:673
 TProofBenchRunCPU.cxx:674
 TProofBenchRunCPU.cxx:675
 TProofBenchRunCPU.cxx:676
 TProofBenchRunCPU.cxx:677
 TProofBenchRunCPU.cxx:678
 TProofBenchRunCPU.cxx:679
 TProofBenchRunCPU.cxx:680
 TProofBenchRunCPU.cxx:681
 TProofBenchRunCPU.cxx:682
 TProofBenchRunCPU.cxx:683
 TProofBenchRunCPU.cxx:684
 TProofBenchRunCPU.cxx:685
 TProofBenchRunCPU.cxx:686
 TProofBenchRunCPU.cxx:687
 TProofBenchRunCPU.cxx:688
 TProofBenchRunCPU.cxx:689
 TProofBenchRunCPU.cxx:690
 TProofBenchRunCPU.cxx:691
 TProofBenchRunCPU.cxx:692
 TProofBenchRunCPU.cxx:693
 TProofBenchRunCPU.cxx:694
 TProofBenchRunCPU.cxx:695
 TProofBenchRunCPU.cxx:696
 TProofBenchRunCPU.cxx:697
 TProofBenchRunCPU.cxx:698
 TProofBenchRunCPU.cxx:699
 TProofBenchRunCPU.cxx:700
 TProofBenchRunCPU.cxx:701
 TProofBenchRunCPU.cxx:702
 TProofBenchRunCPU.cxx:703
 TProofBenchRunCPU.cxx:704
 TProofBenchRunCPU.cxx:705
 TProofBenchRunCPU.cxx:706
 TProofBenchRunCPU.cxx:707
 TProofBenchRunCPU.cxx:708
 TProofBenchRunCPU.cxx:709
 TProofBenchRunCPU.cxx:710
 TProofBenchRunCPU.cxx:711
 TProofBenchRunCPU.cxx:712
 TProofBenchRunCPU.cxx:713
 TProofBenchRunCPU.cxx:714
 TProofBenchRunCPU.cxx:715
 TProofBenchRunCPU.cxx:716
 TProofBenchRunCPU.cxx:717
 TProofBenchRunCPU.cxx:718
 TProofBenchRunCPU.cxx:719
 TProofBenchRunCPU.cxx:720
 TProofBenchRunCPU.cxx:721
 TProofBenchRunCPU.cxx:722
 TProofBenchRunCPU.cxx:723