// @(#)root/sessionviewer:$Id$
// Author: Anna Kreshuk 18/07/2008

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TProofProgressMemoryPlot                                             //
//                                                                      //
// This class implements a dialog, used to display the memory footprint //
// on the proof workers and master. For the workers, memory is plotted  //
// as a function of number of events processed. For the master, it is   //
// plotted as a function of number of objects merged                    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TProofProgressMemoryPlot.h"
#include "TProofProgressDialog.h"
#include "TRootEmbeddedCanvas.h"
#include "TCanvas.h"
#include "TGListBox.h"
#include "TGButton.h"
#include "TGLabel.h"
#include "TGMenu.h"
#include "TProofLog.h"
#include "TUrl.h"
#include "TProof.h"
#include "TError.h"
#include "TGFrame.h"
#include "TMacro.h"
#include "TObjString.h"
#include "TMultiGraph.h"
#include "TGraph.h"
#include "TLegend.h"
#include "TAxis.h"

#define kMemValuePos 8
#define kMemValuePosMaster 8
#define kEventNumberPos 13

ClassImp(TProofProgressMemoryPlot)

//_________________________________________________________________________
TProofProgressMemoryPlot::TProofProgressMemoryPlot(TProofProgressDialog *d,
                                                   Int_t w, Int_t h)
                         : TGTransientFrame(gClient->GetRoot(),
                                            gClient->GetRoot(), w, h)
{
   // Main constructor

   fDialog = d;
   fProofLog = 0;
   fWPlot = 0;
   fMPlot = 0;
   fAPlot = 0;
   fFullLogs = kFALSE;

   // use hierarchical cleaning
   SetCleanup(kDeepCleanup);
   TGHorizontalFrame *htotal = new TGHorizontalFrame(this, w, h);
   //The frame for choosing workers
   TGVerticalFrame *vworkers = new TGVerticalFrame(htotal);
   TGLabel *label1 = new TGLabel(vworkers,"Choose workers:");

   //The list of workers
   fWorkers = BuildLogList(vworkers);
   fWorkers->Resize(102,52);
   fWorkers->SetMultipleSelections(kTRUE);

   //The SelectAll/ClearAll button
   TGPopupMenu *pm = new TGPopupMenu(gClient->GetRoot());
   pm->AddEntry("Select All", 0);
   pm->AddEntry("Clear All", 1);

   fAllWorkers = new TGSplitButton(vworkers, new TGHotString("Select ...            "), pm);
   fAllWorkers->Connect("ItemClicked(Int_t)", "TProofProgressMemoryPlot", this,
                        "Select(Int_t)");
   fAllWorkers->SetSplit(kFALSE);
   //select all for the first display
   Select(1);
   fWorkers->Select(0, kTRUE);
   fWorkers->Select(1, kTRUE);

   fPlot = new TGTextButton(vworkers, "Plot");
   fPlot->Connect("Clicked()", "TProofProgressMemoryPlot", this, "DoPlot()");
   vworkers->AddFrame(label1, new TGLayoutHints(kLHintsLeft | kLHintsTop, 7, 2, 5, 2));
   vworkers->AddFrame(fAllWorkers, new TGLayoutHints(kLHintsExpandX | kLHintsTop, 5, 2, 2, 2));
   vworkers->AddFrame(fWorkers, new TGLayoutHints(kLHintsExpandX | kLHintsTop | kLHintsExpandY, 2, 2, 5, 2));
   vworkers->AddFrame(fPlot, new TGLayoutHints(kLHintsExpandX | kLHintsBottom, 2, 2, 2, 2));
   htotal->AddFrame(vworkers, new TGLayoutHints(kLHintsCenterY | kLHintsLeft | kLHintsExpandY, 2, 2, 2, 2));

   fWorkersPlot = new TRootEmbeddedCanvas("WorkersCanvas", htotal, 300, 300);
   htotal->AddFrame(fWorkersPlot, new TGLayoutHints(kLHintsCenterY | kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 2, 2, 2, 2));
   fMasterPlot = new TRootEmbeddedCanvas("MasterCanvas", htotal, 300, 300);
   htotal->AddFrame(fMasterPlot, new TGLayoutHints(kLHintsCenterY | kLHintsLeft | kLHintsExpandX | kLHintsExpandY, 2, 2, 2 ,2));

   AddFrame(htotal, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 2, 2, 2, 2));
   TString title;
   title.Form("PROOF Memory Consumption: %s", (fDialog->fProof ?
              fDialog->fProof->GetMaster() : "<dummy>"));
   SetWindowName(title);
   SetIconName(title);

   MapSubwindows();
   Resize();
   CenterOnParent();
   MapWindow();
}

//______________________________________________________________________________
TProofProgressMemoryPlot::~TProofProgressMemoryPlot()
{
   // Destructor

   if (fProofLog){
      delete fProofLog;
      fProofLog = 0;
   }
   if (fMPlot){
      delete fMPlot;
      fMPlot = 0;
   }
   if (fWPlot){
      delete fWPlot;
      fWPlot = 0;
   }

   fProofLog = 0;
   fDialog->fMemWindow = 0;

}

//______________________________________________________________________________
TGListBox* TProofProgressMemoryPlot::BuildLogList(TGFrame *parent)
{
   // Build the list of workers. For this, extract the logs and take the names
   // of TProofLogElements

   TGListBox *c = new TGListBox(parent);
   c->AddEntry("average", 0);

   SafeDelete(fProofLog);
   fProofLog = 0;

   TProofMgr *mgr = TProof::Mgr(fDialog->fSessionUrl.Data());
   if (mgr) fProofLog = mgr->GetSessionLogs(0, 0, "Svc.*Memory");
   if (fDialog->fStatus==TProofProgressDialog::kRunning) {
      fFullLogs = kFALSE;
   } else {
      fFullLogs = kTRUE;
   }

   if (fProofLog) {
      TList *elem = fProofLog->GetListOfLogs();
      TIter next(elem);
      TProofLogElem *pe = 0;

      TString buf;
      Int_t is = 1;
      while ((pe=(TProofLogElem*)next())){
         TUrl url(pe->GetTitle());
         buf = TString::Format("%s %s", pe->GetName(), url.GetHost());
         c->AddEntry(buf.Data(), is);
         is++;
      }
   }
   return c;
}

//______________________________________________________________________________
void TProofProgressMemoryPlot::Clear(Option_t *)
{
   // Clear the canvases

   if (fWorkersPlot)
      fWorkersPlot->GetCanvas()->Clear();
   if (fMasterPlot)
      fMasterPlot->GetCanvas()->Clear();
}

//______________________________________________________________________________
void TProofProgressMemoryPlot::DoPlot()
{
   // Draw the plot from the logs

   Clear();

   if (!fProofLog || !fFullLogs ||
      (fDialog && fDialog->fStatus == TProofProgressDialog::kRunning)){

      SafeDelete(fProofLog);
      if (fDialog) {
         TProofMgr *mgr = TProof::Mgr(fDialog->fSessionUrl.Data());
         if (mgr) fProofLog = mgr->GetSessionLogs(0, 0, "Svc.*Memory");
         if (fDialog->fStatus==TProofProgressDialog::kRunning) {
            fFullLogs = kFALSE;
         } else {
            fFullLogs = kTRUE;
         }
      } else {
         Error("DoPlot", "TProofProgessDialog instance undefined - protocol error?");
         return;
      }
   }

   // Make sure we have something to parse
   if (!fProofLog) {
      Error("DoPlot", "could not get a valid instance of TProofLog");
      return;
   }

   char name[512]; //should be long enough

   TList *elem = fProofLog->GetListOfLogs();
   if (!elem) {Error("DoPlot", "No log elements\n"); return;}
   TIter next(elem);
   TProofLogElem *ple=0;

   Int_t iwelem = 0;
   Int_t imelem = 0;
   TGraph *gr=0;

   TList *selected = new TList;
   fWorkers->GetSelectedEntries(selected);
   TIter nextworker(selected);
   TGTextLBEntry *selworker;
   TLegend *legw = 0;
   TLegend *legm = 0;

   //delete the current multigraphs
   if (fWPlot){
      delete fWPlot;
      fWPlot = 0;
   }
   if (fMPlot) {
      delete fMPlot;
      fMPlot = 0;
   }

   //loop over the selected workers in the list
   Int_t max = -1;
   Int_t min = -1;
   while ((selworker=(TGTextLBEntry*)nextworker())){

      snprintf(name, sizeof(name)-1, "%s", selworker->GetText()->GetString());
      char *token;
      token = strtok(name, " ");
      if (token && !strcmp(token, "average")) { //change that to id comparison later
         gr = DoAveragePlot(max, min);
         if (gr && gr->GetN()>0){
            if (!fWPlot) {
               fWPlot = new TMultiGraph();
            }
            if (!legw) {
               legw = new TLegend(0.1, 0.7, 0.4, 0.9);
               legw->SetHeader("Workers");
            }
            gr->SetMarkerColor(1);
            gr->SetMarkerStyle(2);
            gr->SetMarkerSize(1);
            gr->SetLineWidth(2);
            gr->SetLineColor(1);
            fWPlot->Add(gr, "l");
            legw->AddEntry(gr, token, "l");
         }
         TProofLogElem *pltemp = (TProofLogElem*)elem->At(min+1);
         gr = DoWorkerPlot(pltemp);
         if (gr && gr->GetN()>0){
            if (!fWPlot) {
               fWPlot = new TMultiGraph();
            }
            if (!legw) {
               legw = new TLegend(0.1, 0.7, 0.4, 0.9);
               legw->SetHeader("Workers");
            }
            gr->SetLineWidth(2);
            gr->SetLineColor(2);
            gr->SetLineStyle(3);
            fWPlot->Add(gr, "l");
            legw->AddEntry(gr, TString::Format("%s - min", pltemp->GetName()) , "l");
         }
         pltemp = (TProofLogElem*)elem->At(max+1);
         gr = DoWorkerPlot(pltemp);
         if (gr && gr->GetN()>0){
            if (!fWPlot) {
               fWPlot = new TMultiGraph();
            }
            if (!legw) {
               legw = new TLegend(0.1, 0.7, 0.4, 0.9);
               legw->SetHeader("Workers");
            }
            gr->SetLineWidth(2);
            gr->SetLineColor(2);
            gr->SetLineStyle(2);
            fWPlot->Add(gr, "l");
            legw->AddEntry(gr, TString::Format("%s - max", pltemp->GetName()), "l");
         }

         continue;
      }


      ple = (TProofLogElem*)elem->FindObject(token);
      const char *role = ple->GetRole();
      if (role[0]=='w'){
         //role should be equal to "worker", only check the 1st char

         gr = DoWorkerPlot(ple);
         if (gr && gr->GetN()>0) {
            if (!fWPlot) {
               fWPlot = new TMultiGraph();
            }
            if (!legw) {
               legw = new TLegend(0.1, 0.7, 0.4, 0.9);
               legw->SetHeader("Workers");
            }
            gr->SetLineWidth(2);
            gr->SetLineColor(iwelem+3);
            fWPlot->Add(gr, "l");
            legw->AddEntry(gr, token, "l");
            iwelem++;
         }
      } else {
         //a master or submaster log
         //display without meaningful labels for now
         gr = DoMasterPlot(ple);
         if (gr && gr->GetN()>0){
            if (!fMPlot){
               fMPlot = new TMultiGraph();
            }
            if (!legm) {
               legm = new TLegend(0.1, 0.7, 0.4, 0.9);
               legm->SetHeader("Master");
            }
            gr->SetLineWidth(2);
            gr->SetLineColor(imelem+1);
            fMPlot->Add(gr, "l");
            legm->AddEntry(gr, token, "l");
            imelem++;
         }
      }

   }

   if (fWPlot){
      fWorkersPlot->GetCanvas()->cd();
      fWPlot->Draw("a");
      if (fWPlot->GetXaxis())
         fWPlot->GetXaxis()->SetTitle("Events Processed");
      if (fWPlot->GetYaxis())
         fWPlot->GetYaxis()->SetTitle("MBytes");
      if (legw) legw->Draw();

   }
   if (fMPlot) {
      fMasterPlot->GetCanvas()->cd();
      fMPlot->Draw("a");
      if (fMPlot->GetXaxis())
         fMPlot->GetXaxis()->SetTitle("Objects Merged");
      if (fMPlot->GetYaxis())
         fMPlot->GetYaxis()->SetTitle("MBytes");
      if (legm) legm->Draw();
   }
   fWorkersPlot->GetCanvas()->Update();
   fMasterPlot->GetCanvas()->Update();

   delete selected;
}

//______________________________________________________________________________
TGraph *TProofProgressMemoryPlot::DoAveragePlot(Int_t &max_el, Int_t &min_el)
{
   // Create the average plots

   TList *elem = fProofLog->GetListOfLogs();
   if (!elem) {
      Error("DoAveragePlot", "Empty log");
      return 0;
   }
   TIter next(elem);

   TProofLogElem *ple=0;
   Double_t max_av = 0;
   Double_t min_av = 10E9;

   Long64_t maxevent = 0;
   Long64_t step = -1;
   TObjString *curline = 0;
   TObjString *prevline = 0;
   Long64_t curevent_value;
   Long64_t prevevent_value;
   Long64_t *last = new Long64_t[elem->GetEntries()];
   Long64_t vmem = -1, rmem = -1, nevt = -1;
   TString token;
   Int_t ielem=0;
   for (Int_t i=0; i<elem->GetEntries(); i++) {
      last[i] = 0;
   }
   while ((ple = (TProofLogElem *)next())){
      //find the maximal entry processed in the last query
      const char *role = ple->GetRole();
      if (role[0] != 'w') continue; //skip the master log
      TList *lines = ple->GetMacro()->GetListOfLines();
      if (!lines || lines->GetSize() <= 0) continue;
      curline = (TObjString *) lines->Last();
      if (!curline) continue;
      curevent_value = 0;
      if (ParseLine(curline->String(), vmem, rmem, curevent_value) != 0) {
         Warning("DoAveragePlot", "error parsing line: '%s'", curline->String().Data());
         continue;
      }
      if (maxevent < curevent_value) maxevent = curevent_value;
      last[ielem] = curevent_value;
      if (step < 0) {
         // Find the step
         prevline = (TObjString *)lines->Before(curline);
         if (prevline) {
            prevevent_value = 0;
            if (ParseLine(prevline->String(), vmem, rmem, prevevent_value) != 0) {
               Warning("DoAveragePlot", "error parsing line: '%s'", curline->String().Data());
            } else {
               step = curevent_value - prevevent_value;
            }
         }
      }
      ielem++;
   }
   Int_t maxlines = Int_t(maxevent/(1.*step));
   //transform the array of last event numbers to an array of numbers of lines
   for (Int_t i=0; i<ielem; i++){
      last[i] /= step;
   }

   Double_t *av_mem = new Double_t[maxlines];
   Int_t *nw = new Int_t[maxlines];
   for (Int_t i=0; i<maxlines; i++){
      av_mem[i]=0;
      nw[i]=0;
   }
   next.Reset();
   ielem=0;
   Int_t iline=0;
   Double_t cur_av;
   while ((ple = (TProofLogElem*)next())){
      const char *role = ple->GetRole();
      if (role[0]!='w') continue;
      TList *lines = ple->GetMacro()->GetListOfLines();
      if (!lines || lines->GetSize() <= 0) continue;
      TIter prev(lines, kIterBackward);
      iline=0;
      cur_av = 0;
      while ((curline = (TObjString*)prev()) && iline<last[ielem]){
         // a backward loop, so that only the last query is counted
         vmem = 0;
         if (ParseLine(curline->String(), vmem, rmem, nevt) != 0) {
            Warning("DoWorkerPlot", "error parsing line: '%s'", curline->String().Data());
            continue;
         }
         av_mem[last[ielem] -1 - iline] += vmem; //last[ielem] is the number of lines for
         nw[last[ielem] -1 - iline]++;              //this query and this element
         if (last[ielem] > 0) cur_av += (Double_t)vmem / last[ielem];
         iline++;
      }
      if (cur_av > max_av){
         max_av = cur_av;
         max_el = ielem;
      }
      if (cur_av < min_av){
         min_av = cur_av;
         min_el = ielem;
      }
      ielem++;
   }

   TGraph *gr = new TGraph(maxlines);
   //make an average
   for (Int_t i=0; i<maxlines; i++){
      gr->SetPoint(i, (i+1)*step, av_mem[i]/(nw[i]*1024.));
   }
   delete [] av_mem;
   av_mem = 0;
   delete [] nw;
   nw = 0;
   delete [] last;
   last = 0;
   return gr;

}

//______________________________________________________________________________
Int_t TProofProgressMemoryPlot::ParseLine(TString l,
                                          Long64_t &v, Long64_t &r, Long64_t &e)
{
   // Extract from line 'l' the virtual memory 'v', the resident memory 'r' and the
   // number of events 'e'.
   // The line is assumed to be in the form
   // "... Memory 130868 virtual 31540 ... event 5550"
   // The fields are only filled if >= 0 .
   // Return 0 on success, -1 if any of the values coudl not be filled (the output
   // fields are not touched in such a case).

   // Something to parse is mandatory
   if (l.IsNull()) return -1;

   // At least one field needs to be filled
   if (v < 0 && r < 0 && e < 0) return 0;

   // Position at the start of the relevant info
   Int_t from = kNPOS;
   if ((from = l.Index("Memory")) == kNPOS) return -1;

   // Prepare extraction
   from += 7;
   TString tok;

   // The virtual memory
   if (v >= 0) {
      if (!l.Tokenize(tok, from, " ")) return -1;
      v = tok.Atoll();
   }

   // The resident memory
   if (r >= 0) {
      if ((from = l.Index("virtual", from)) == kNPOS) return -1;
      from += 8;
      if (!l.Tokenize(tok, from, " ")) return -1;
      r = tok.Atoll();
   }

   // The number of events
   if (e >= 0) {
      if ((from = l.Index("event", from)) == kNPOS) return -1;
      from += 6;
      if (!l.Tokenize(tok, from, " ")) return -1;
      e = tok.Atoll();
   }

   // Done
   return 0;
}

//______________________________________________________________________________
TGraph *TProofProgressMemoryPlot::DoWorkerPlot(TProofLogElem *ple)
{
   // Make a memory consumption graph for a worker

   TObjString *curline;
   TList *lines = ple->GetMacro()->GetListOfLines();
   if (!lines) {
      //the log is empty so far
      return 0;
   }

   Long64_t vmem = -1, rmem = -1, nevt = -1;

   //find the last event value
   curline = (TObjString*)lines->Last();
   Long64_t lastevent_value = 0;
   if (ParseLine(curline->String(), vmem, rmem, lastevent_value) != 0) {
      Error("DoWorkerPlot", "error parsing line: '%s'", curline->String().Data());
      return 0;
   }

   //find the step
   TObjString *prevline = (TObjString*)lines->Before(curline);
   Long64_t prevevent_value = 0;
   if (prevline && ParseLine(prevline->String(), vmem, rmem, prevevent_value) != 0) {
      Error("DoWorkerPlot", "error parsing line: '%s'", prevline->String().Data());
      return 0;
   }
   Long64_t step = lastevent_value - prevevent_value;
   if (step <= 0) {
      Error("DoWorkerPlot", "null or negative step (%lld) - cannot continue", step);
      return 0;
   }

   Int_t nlines = lastevent_value/step;
   TGraph *gr = new TGraph(nlines);

   TIter prevl(lines, kIterBackward);
   Int_t iline = 0;
   TString token;
   while ((curline = (TObjString*)prevl()) && iline<nlines){
      //iterate backwards so that only lines for the last query are taken
      vmem = 0;
      if (ParseLine(curline->String(), vmem, rmem, nevt) != 0) {
         Warning("DoWorkerPlot", "error parsing line: '%s'", curline->String().Data());
         continue;
      }
      gr->SetPoint(nlines-1-iline, lastevent_value-iline*step, vmem/1024.);
      iline++;
   }

   return gr;
}

//______________________________________________________________________________
TGraph *TProofProgressMemoryPlot::DoMasterPlot(TProofLogElem *ple)
{
   // a master or submaster log
   // display without meaningful labels for now

   TList *lines = ple->GetMacro()->GetListOfLines();
   TIter prevline(lines, kIterBackward);
   Int_t iline=0;
   TObjString *curline;
   //count the number of lines that belong to the last query
   while ((curline = (TObjString*)prevline())) {
      if (curline->String().Contains("Start")) break;
      iline++;
   }

   Long64_t vmem = -1, rmem = -1, nevt = -1;

   Int_t nlines = iline;
   TString token;
   TGraph *gr = new TGraph(nlines);
   prevline.Reset();
   iline = 0;
   while ((curline = (TObjString*)prevline()) && iline<nlines) {
      //iterate backwards so that only lines for the last query are taken
      vmem = 0;
      if (ParseLine(curline->String(), vmem, rmem, nevt) != 0) {
         Warning("DoWorkerPlot", "error parsing line: '%s'", curline->String().Data());
         continue;
      }
      gr->SetPoint(nlines-iline, nlines-iline, vmem/1024.);
      iline++;
   }
   return gr;
}

//______________________________________________________________________________
void TProofProgressMemoryPlot::Select(Int_t id)
{
   //actions of select all/clear all button

   Int_t nen = fWorkers->GetNumberOfEntries();
   Bool_t sel = id ? 0 : 1;

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