// @(#)root/proof:$Id: TProof.cxx 29171 2009-06-23 14:13:06Z brun $ // Author: Fons Rademakers 13/02/97 /************************************************************************* * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. * * All rights reserved. * * * * For the licensing terms see $ROOTSYS/LICENSE. * * For the list of contributors see $ROOTSYS/README/CREDITS. * *************************************************************************/ ////////////////////////////////////////////////////////////////////////// // // // TProof // // // // This class controls a Parallel ROOT Facility, PROOF, cluster. // // It fires the worker servers, it keeps track of how many workers are // // running, it keeps track of the workers running status, it broadcasts // // messages to all workers, it collects results, etc. // // // ////////////////////////////////////////////////////////////////////////// #include <stdlib.h> #include <fcntl.h> #include <errno.h> #ifdef WIN32 # include <io.h> # include <sys/stat.h> # include <sys/types.h> #else # include <unistd.h> #endif #include <vector> #include "RConfigure.h" #include "Riostream.h" #include "Getline.h" #include "TBrowser.h" #include "TChain.h" #include "TCondor.h" #include "TDSet.h" #include "TError.h" #include "TEnv.h" #include "TEventList.h" #include "TFile.h" #include "TFileInfo.h" #include "TFTP.h" #include "THashList.h" #include "TInterpreter.h" #include "TKey.h" #include "TMap.h" #include "TMessage.h" #include "TMonitor.h" #include "TMutex.h" #include "TObjArray.h" #include "TObjString.h" #include "TParameter.h" #include "TProof.h" #include "TProofNodeInfo.h" #include "TVirtualProofPlayer.h" #include "TVirtualPacketizer.h" #include "TProofServ.h" #include "TPluginManager.h" #include "TQueryResult.h" #include "TRandom.h" #include "TRegexp.h" #include "TROOT.h" #include "TSemaphore.h" #include "TSlave.h" #include "TSocket.h" #include "TSortedList.h" #include "TSystem.h" #include "TThread.h" #include "TTree.h" #include "TUrl.h" #include "TFileCollection.h" #include "TDataSetManager.h" TProof *gProof = 0; TVirtualMutex *gProofMutex = 0; // Rotating indicator char TProofMergePrg::fgCr[4] = {'-', '\\', '|', '/'}; TList *TProof::fgProofEnvList = 0; // List of env vars for proofserv TPluginHandler *TProof::fgLogViewer = 0; // Log viewer handler ClassImp(TProof) //----- PROOF Interrupt signal handler ----------------------------------------- //______________________________________________________________________________ Bool_t TProofInterruptHandler::Notify() { // TProof interrupt handler. if (isatty(0) == 0 || isatty(1) == 0 || fProof->GetRemoteProtocol() < 22) { // Cannot ask the user : abort any remote processing fProof->StopProcess(kTRUE); } else { // Real stop or request to switch to asynchronous? char *a = 0; if (fProof->GetRemoteProtocol() < 22) { a = Getline("\nSwith to asynchronous mode not supported remotely:" "\nEnter S/s to stop, Q/q to quit, any other key to continue: "); } else { a = Getline("\nEnter A/a to switch asynchronous, S/s to stop, Q/q to quit," " any other key to continue: "); } if (a[0] == 'Q' || a[0] == 'S' || a[0] == 'q' || a[0] == 's') { Info("Notify","Processing interrupt signal ... %c", a[0]); // Stop or abort any remote processing Bool_t abort = (a[0] == 'Q' || a[0] == 'q') ? kTRUE : kFALSE; fProof->StopProcess(abort); } else if ((a[0] == 'A' || a[0] == 'a') && fProof->GetRemoteProtocol() >= 22) { // Stop any remote processing fProof->GoAsynchronous(); } } return kTRUE; } //----- Input handler for messages from TProofServ ----------------------------- //______________________________________________________________________________ TProofInputHandler::TProofInputHandler(TProof *p, TSocket *s) : TFileHandler(s->GetDescriptor(),1), fSocket(s), fProof(p) { // Constructor } //______________________________________________________________________________ Bool_t TProofInputHandler::Notify() { // Handle input fProof->CollectInputFrom(fSocket); return kTRUE; } //------------------------------------------------------------------------------ ClassImp(TSlaveInfo) //______________________________________________________________________________ Int_t TSlaveInfo::Compare(const TObject *obj) const { // Used to sort slaveinfos by ordinal. if (!obj) return 1; const TSlaveInfo *si = dynamic_cast<const TSlaveInfo*>(obj); if (!si) return fOrdinal.CompareTo(obj->GetName()); const char *myord = GetOrdinal(); const char *otherord = si->GetOrdinal(); while (myord && otherord) { Int_t myval = atoi(myord); Int_t otherval = atoi(otherord); if (myval < otherval) return 1; if (myval > otherval) return -1; myord = strchr(myord, '.'); if (myord) myord++; otherord = strchr(otherord, '.'); if (otherord) otherord++; } if (myord) return -1; if (otherord) return 1; return 0; } //______________________________________________________________________________ void TSlaveInfo::Print(Option_t *opt) const { // Print slave info. If opt = "active" print only the active // slaves, if opt="notactive" print only the not active slaves, // if opt = "bad" print only the bad slaves, else // print all slaves. TString stat = fStatus == kActive ? "active" : fStatus == kBad ? "bad" : "not active"; TString msd = fMsd.IsNull() ? "<null>" : fMsd.Data(); if (!opt) opt = ""; if (!strcmp(opt, "active") && fStatus != kActive) return; if (!strcmp(opt, "notactive") && fStatus != kNotActive) return; if (!strcmp(opt, "bad") && fStatus != kBad) return; cout << "Slave: " << fOrdinal << " hostname: " << fHostName << " msd: " << msd << " perf index: " << fPerfIndex << " " << stat << endl; } //------------------------------------------------------------------------------ //______________________________________________________________________________ static char *CollapseSlashesInPath(const char *path) { // Get rid of spare slashes in a path. Returned path must be deleted[] // by the user. if (path) { Int_t i = 1; // current index as we go along the string Int_t j = 0; // current end of new path in newPath char *newPath = new char [strlen(path) + 1]; newPath[0] = path[0]; while (path[i]) { if (path[i] != '/' || newPath[j] != '/') { j++; newPath[j] = path[i]; } i++; } if (newPath[j] != '/') j++; newPath[j] = 0; // We have to terminate the new path. return newPath; } return 0; } ClassImp(TProof) TSemaphore *TProof::fgSemaphore = 0; //______________________________________________________________________________ TProof::TProof(const char *masterurl, const char *conffile, const char *confdir, Int_t loglevel, const char *alias, TProofMgr *mgr) : fUrl(masterurl) { // Create a PROOF environment. Starting PROOF involves either connecting // to a master server, which in turn will start a set of slave servers, or // directly starting as master server (if master = ""). Masterurl is of // the form: [proof[s]://]host[:port]. Conffile is the name of the config // file describing the remote PROOF cluster (this argument alows you to // describe different cluster configurations). // The default is proof.conf. Confdir is the directory where the config // file and other PROOF related files are (like motd and noproof files). // Loglevel is the log level (default = 1). User specified custom config // files will be first looked for in $HOME/.conffile. // Synchronize closing with actions like MarkBad fCloseMutex = 0; // This may be needed during init fManager = mgr; // Default server type fServType = TProofMgr::kXProofd; // Default query mode fQueryMode = kSync; // Parse the main URL, adjusting the missing fields and setting the relevant // bits ResetBit(TProof::kIsClient); ResetBit(TProof::kIsMaster); // Protocol and Host if (!masterurl || strlen(masterurl) <= 0) { fUrl.SetProtocol("proof"); fUrl.SetHost("__master__"); } else if (!(strstr(masterurl, "://"))) { fUrl.SetProtocol("proof"); } // Port if (fUrl.GetPort() == TUrl(" ").GetPort()) fUrl.SetPort(TUrl("proof:// ").GetPort()); // User if (strlen(fUrl.GetUser()) <= 0) { // Get user logon name UserGroup_t *pw = gSystem->GetUserInfo(); if (pw) { fUrl.SetUser(pw->fUser); delete pw; } } // Make sure to store the FQDN, so to get a solid reference for subsequent checks if (!strcmp(fUrl.GetHost(), "__master__")) fMaster = fUrl.GetHost(); else if (!strlen(fUrl.GetHost())) fMaster = gSystem->GetHostByName(gSystem->HostName()).GetHostName(); else fMaster = gSystem->GetHostByName(fUrl.GetHost()).GetHostName(); // Server type if (strlen(fUrl.GetOptions()) > 0) { TString opts(fUrl.GetOptions()); if (!(strncmp(fUrl.GetOptions(),"std",3))) { fServType = TProofMgr::kProofd; opts.Remove(0,3); fUrl.SetOptions(opts.Data()); } else if (!(strncmp(fUrl.GetOptions(),"lite",4))) { fServType = TProofMgr::kProofLite; opts.Remove(0,4); fUrl.SetOptions(opts.Data()); } } // Instance type fMasterServ = kFALSE; SetBit(TProof::kIsClient); ResetBit(TProof::kIsMaster); if (fMaster == "__master__") { fMasterServ = kTRUE; ResetBit(TProof::kIsClient); SetBit(TProof::kIsMaster); } else if (fMaster == "prooflite") { // Client and master are merged fMasterServ = kTRUE; SetBit(TProof::kIsMaster); } Init(masterurl, conffile, confdir, loglevel, alias); // If called by a manager, make sure it stays in last position // for cleaning if (mgr) { R__LOCKGUARD2(gROOTMutex); gROOT->GetListOfSockets()->Remove(mgr); gROOT->GetListOfSockets()->Add(mgr); } // Old-style server type: we add this to the list and set the global pointer if (IsProofd() || TestBit(TProof::kIsMaster)) if (!gROOT->GetListOfProofs()->FindObject(this)) gROOT->GetListOfProofs()->Add(this); // Still needed by the packetizers: needs to be changed gProof = this; } //______________________________________________________________________________ TProof::TProof() : fUrl(""), fServType(TProofMgr::kXProofd) { // Protected constructor to be used by classes deriving from TProof // (they have to call Init themselves and override StartSlaves // appropriately). // // This constructor simply closes any previous gProof and sets gProof // to this instance. fValid = kFALSE; fRecvMessages = 0; fSlaveInfo = 0; fMasterServ = kFALSE; fSendGroupView = kFALSE; fActiveSlaves = 0; fInactiveSlaves = 0; fUniqueSlaves = 0; fAllUniqueSlaves = 0; fNonUniqueMasters = 0; fActiveMonitor = 0; fUniqueMonitor = 0; fAllUniqueMonitor = 0; fCurrentMonitor = 0; fBytesRead = 0; fRealTime = 0; fCpuTime = 0; fIntHandler = 0; fProgressDialog = 0; fProgressDialogStarted = kFALSE; fPlayer = 0; fFeedback = 0; fChains = 0; fDSet = 0; fNotIdle = 0; fSync = kTRUE; fRunStatus = kRunning; fIsWaiting = kFALSE; fRedirLog = kFALSE; fLogFileW = 0; fLogFileR = 0; fLogToWindowOnly = kFALSE; fWaitingSlaves = 0; fQueries = 0; fOtherQueries = 0; fDrawQueries = 0; fMaxDrawQueries = 1; fSeqNum = 0; fSessionID = -1; fEndMaster = kFALSE; fGlobalPackageDirList = 0; fPackageLock = 0; fEnabledPackagesOnClient = 0; fInputData = 0; fPrintProgress = 0; fLoadedMacros = 0; fProtocol = -1; fSlaves = 0; fBadSlaves = 0; fAllMonitor = 0; fDataReady = kFALSE; fBytesReady = 0; fTotalBytes = 0; fAvailablePackages = 0; fEnabledPackages = 0; fRunningDSets = 0; fCollectTimeout = -1; fManager = 0; fQueryMode = kSync; fDynamicStartup = kFALSE; fCloseMutex = 0; if (!gROOT->GetListOfProofs()->FindObject(this)) gROOT->GetListOfProofs()->Add(this); gProof = this; } //______________________________________________________________________________ TProof::~TProof() { // Clean up PROOF environment. while (TChain *chain = dynamic_cast<TChain*> (fChains->First()) ) { // remove "chain" from list chain->SetProof(0); RemoveChain(chain); } // remove links to packages enabled on the client if (TestBit(TProof::kIsClient)) { // iterate over all packages TIter nextpackage(fEnabledPackagesOnClient); while (TObjString *package = dynamic_cast<TObjString*>(nextpackage())) { FileStat_t stat; gSystem->GetPathInfo(package->String(), stat); // check if symlink, if so unlink // NOTE: GetPathInfo() returns 1 in case of symlink that does not point to // existing file or to a directory, but if fIsLink is true the symlink exists if (stat.fIsLink) gSystem->Unlink(package->String()); } } Close(); SafeDelete(fIntHandler); SafeDelete(fSlaves); SafeDelete(fActiveSlaves); SafeDelete(fInactiveSlaves); SafeDelete(fUniqueSlaves); SafeDelete(fAllUniqueSlaves); SafeDelete(fNonUniqueMasters); SafeDelete(fBadSlaves); SafeDelete(fAllMonitor); SafeDelete(fActiveMonitor); SafeDelete(fUniqueMonitor); SafeDelete(fAllUniqueMonitor); SafeDelete(fSlaveInfo); SafeDelete(fChains); SafeDelete(fPlayer); SafeDelete(fFeedback); SafeDelete(fWaitingSlaves); SafeDelete(fAvailablePackages); SafeDelete(fEnabledPackages); SafeDelete(fEnabledPackagesOnClient); SafeDelete(fLoadedMacros); SafeDelete(fPackageLock); SafeDelete(fGlobalPackageDirList); SafeDelete(fRecvMessages); SafeDelete(fInputData); SafeDelete(fRunningDSets); SafeDelete(fCloseMutex); // remove file with redirected logs if (TestBit(TProof::kIsClient)) { if (fLogFileR) fclose(fLogFileR); if (fLogFileW) fclose(fLogFileW); if (fLogFileName.Length() > 0) gSystem->Unlink(fLogFileName); } // Remove for the global list gROOT->GetListOfProofs()->Remove(this); // ... and from the manager list if (fManager && fManager->IsValid()) fManager->DiscardSession(this); if (gProof && gProof == this) { // Set previous as default TIter pvp(gROOT->GetListOfProofs(), kIterBackward); while ((gProof = (TProof *)pvp())) { if (gProof->InheritsFrom("TProof")) break; } } // For those interested in our destruction ... Emit("~TProof()"); } //______________________________________________________________________________ Int_t TProof::Init(const char *, const char *conffile, const char *confdir, Int_t loglevel, const char *alias) { // Start the PROOF environment. Starting PROOF involves either connecting // to a master server, which in turn will start a set of slave servers, or // directly starting as master server (if master = ""). For a description // of the arguments see the TProof ctor. Returns the number of started // master or slave servers, returns 0 in case of error, in which case // fValid remains false. R__ASSERT(gSystem); fValid = kFALSE; // If in attach mode, options is filled with additiona info Bool_t attach = kFALSE; if (strlen(fUrl.GetOptions()) > 0) { attach = kTRUE; // A flag from the GUI TString opts = fUrl.GetOptions(); if (opts.Contains("GUI")) { SetBit(TProof::kUsingSessionGui); opts.Remove(opts.Index("GUI")); fUrl.SetOptions(opts); } } if (TestBit(TProof::kIsMaster)) { // Fill default conf file and conf dir if (!conffile || strlen(conffile) == 0) fConfFile = kPROOF_ConfFile; if (!confdir || strlen(confdir) == 0) fConfDir = kPROOF_ConfDir; } else { fConfDir = confdir; fConfFile = conffile; } // Analysise the conffile field ParseConfigField(fConfFile); fWorkDir = gSystem->WorkingDirectory(); fLogLevel = loglevel; fProtocol = kPROOF_Protocol; fSendGroupView = kTRUE; fImage = fMasterServ ? "" : "<local>"; fIntHandler = 0; fStatus = 0; fRecvMessages = new TList; fRecvMessages->SetOwner(kTRUE); fSlaveInfo = 0; fChains = new TList; fAvailablePackages = 0; fEnabledPackages = 0; fRunningDSets = 0; fEndMaster = TestBit(TProof::kIsMaster) ? kTRUE : kFALSE; fInputData = 0; ResetBit(TProof::kNewInputData); fPrintProgress = 0; // Timeout for some collect actions fCollectTimeout = gEnv->GetValue("Proof.CollectTimeout", -1); // Should the workers be started dynamically; default: no fDynamicStartup = gEnv->GetValue("Proof.DynamicStartup", kFALSE); // Default entry point for the data pool is the master if (TestBit(TProof::kIsClient)) fDataPoolUrl.Form("root://%s", fMaster.Data()); else fDataPoolUrl = ""; fProgressDialog = 0; fProgressDialogStarted = kFALSE; // Default alias is the master name TString al = (alias) ? alias : fMaster.Data(); SetAlias(al); // Client logging of messages from the master and slaves fRedirLog = kFALSE; if (TestBit(TProof::kIsClient)) { fLogFileName.Form("%s/ProofLog_%d", gSystem->TempDirectory(), gSystem->GetPid()); if ((fLogFileW = fopen(fLogFileName, "w")) == 0) Error("Init", "could not create temporary logfile"); if ((fLogFileR = fopen(fLogFileName, "r")) == 0) Error("Init", "could not open temp logfile for reading"); } fLogToWindowOnly = kFALSE; // Status of cluster fNotIdle = 0; // Query type fSync = (attach) ? kFALSE : kTRUE; // Not enqueued fIsWaiting = kFALSE; // Counters fBytesRead = 0; fRealTime = 0; fCpuTime = 0; // List of queries fQueries = 0; fOtherQueries = 0; fDrawQueries = 0; fMaxDrawQueries = 1; fSeqNum = 0; // Remote ID of the session fSessionID = -1; // Part of active query fWaitingSlaves = 0; // Make remote PROOF player fPlayer = 0; MakePlayer(); fFeedback = new TList; fFeedback->SetOwner(); fFeedback->SetName("FeedbackList"); AddInput(fFeedback); // sort slaves by descending performance index fSlaves = new TSortedList(kSortDescending); fActiveSlaves = new TList; fInactiveSlaves = new TList; fUniqueSlaves = new TList; fAllUniqueSlaves = new TList; fNonUniqueMasters = new TList; fBadSlaves = new TList; fAllMonitor = new TMonitor; fActiveMonitor = new TMonitor; fUniqueMonitor = new TMonitor; fAllUniqueMonitor = new TMonitor; fCurrentMonitor = 0; fPackageLock = 0; fEnabledPackagesOnClient = 0; fLoadedMacros = 0; fGlobalPackageDirList = 0; // Enable optimized sending of streamer infos to use embedded backward/forward // compatibility support between different ROOT versions and different versions of // users classes Bool_t enableSchemaEvolution = gEnv->GetValue("Proof.SchemaEvolution",1); if (enableSchemaEvolution) { TMessage::EnableSchemaEvolutionForAll(); } else { Info("TProof", "automatic schema evolution in TMessage explicitely disabled"); } if (IsMaster()) { // to make UploadPackage() method work on the master as well. fPackageDir = gProofServ->GetPackageDir(); } else { TString sandbox = gEnv->GetValue("Proof.Sandbox", ""); if (sandbox.IsNull()) { sandbox.Form("~/%s", kPROOF_WorkDir); } gSystem->ExpandPathName(sandbox); if (AssertPath(sandbox, kTRUE) != 0) { Error("Init", "failure asserting directory %s", sandbox.Data()); return 0; } // Package Dir fPackageDir = gEnv->GetValue("Proof.PackageDir", ""); if (fPackageDir.IsNull()) fPackageDir.Form("%s/%s", sandbox.Data(), kPROOF_PackDir); if (AssertPath(fPackageDir, kTRUE) != 0) { Error("Init", "failure asserting directory %s", fPackageDir.Data()); return 0; } } if (!IsMaster()) { // List of directories where to look for global packages TString globpack = gEnv->GetValue("Proof.GlobalPackageDirs",""); if (globpack.Length() > 0) { Int_t ng = 0; Int_t from = 0; TString ldir; while (globpack.Tokenize(ldir, from, ":")) { if (gSystem->AccessPathName(ldir, kReadPermission)) { Warning("Init", "directory for global packages %s does not" " exist or is not readable", ldir.Data()); } else { // Add to the list, key will be "G<ng>", i.e. "G0", "G1", ... TString key = Form("G%d", ng++); if (!fGlobalPackageDirList) { fGlobalPackageDirList = new THashList(); fGlobalPackageDirList->SetOwner(); } fGlobalPackageDirList->Add(new TNamed(key,ldir)); } } } TString lockpath(fPackageDir); lockpath.ReplaceAll("/", "%"); lockpath.Insert(0, Form("%s/%s", gSystem->TempDirectory(), kPROOF_PackageLockFile)); fPackageLock = new TProofLockPath(lockpath.Data()); fEnabledPackagesOnClient = new TList; fEnabledPackagesOnClient->SetOwner(); } // Master may want dynamic startup if (fDynamicStartup) { if (!IsMaster()) { // If on client - start the master if (!StartSlaves(attach)) return 0; } } else { // Master Only mode (for operations requiring only the master, e.g. dataset browsing, // result retrieving, ...) Bool_t masterOnly = gEnv->GetValue("Proof.MasterOnly", kFALSE); if (!IsMaster() || !masterOnly) { // Start slaves (the old, static, per-session way) if (!StartSlaves(attach)) return 0; } } if (fgSemaphore) SafeDelete(fgSemaphore); // we are now properly initialized fValid = kTRUE; // De-activate monitor (will be activated in Collect) fAllMonitor->DeActivateAll(); // By default go into parallel mode GoParallel(9999, attach); // Send relevant initial state to slaves if (!attach) SendInitialState(); else if (!IsIdle()) // redirect log fRedirLog = kTRUE; // Done at this point, the alias will be communicated to the coordinator, if any if (TestBit(TProof::kIsClient)) SetAlias(al); SetActive(kFALSE); if (IsValid()) { // Activate input handler ActivateAsyncInput(); R__LOCKGUARD2(gROOTMutex); gROOT->GetListOfSockets()->Add(this); } return fActiveSlaves->GetSize(); } //______________________________________________________________________________ void TProof::ParseConfigField(const char *config) { // The config file field may contain special instructions which need to be // parsed at the beginning, e.g. for debug runs with valgrind. TString sconf(config); // Analysise the field Int_t ivg = kNPOS; if ((ivg = sconf.Index("valgrind")) != kNPOS) { Int_t jvg = sconf.Index(',', ivg); Int_t lvg = (jvg != kNPOS) ? (jvg-ivg) : sconf.Length(); TString vgconf = sconf(ivg, lvg); // Any existing valgrind setting? User can give full settings, which we fully respect, // or pass additional options for valgrind by prefixing 'valgrind_opts:'. For example, // TProof::AddEnvVar("PROOF_MASTER_WRAPPERCMD", "valgrind_opts:--time-stamp --leak-check=full" // will add option "--time-stamp --leak-check=full" to our default options TString mst, wrk, all; TList *envs = fgProofEnvList; TNamed *n = 0; if (envs) { if ((n = (TNamed *) envs->FindObject("PROOF_WRAPPERCMD"))) all = n->GetTitle(); if ((n = (TNamed *) envs->FindObject("PROOF_MASTER_WRAPPERCMD"))) mst = n->GetTitle(); if ((n = (TNamed *) envs->FindObject("PROOF_SLAVE_WRAPPERCMD"))) wrk = n->GetTitle(); } if (all != "" && mst == "") mst = all; if (all != "" && wrk == "") wrk = all; if (all != "" && all.BeginsWith("valgrind_opts:")) { // The field is used to add an option Reset the setting Info("ParseConfigField","valgrind run: resetting 'PROOF_WRAPPERCMD':" " must be set again for next run , if any"); TProof::DelEnvVar("PROOF_WRAPPERCMD"); } TString var, cmd("valgrind -v --suppressions=<rootsys>/etc/valgrind-root.supp"); TString mstlab("NO"), wrklab("NO"); if (vgconf == "valgrind" || vgconf.Contains("master")) { // Check if we have to add a var if (mst == "" || mst.BeginsWith("valgrind_opts:")) { mst.ReplaceAll("valgrind_opts:",""); var.Form("%s --log-file=<logfilemst>.valgrind.log %s", cmd.Data(), mst.Data()); TProof::AddEnvVar("PROOF_MASTER_WRAPPERCMD", var); mstlab = "YES"; } else if (mst != "") { mstlab = "YES"; } } if (vgconf.Contains("=workers") || vgconf.Contains("+workers")) { // Check if we have to add a var if (wrk == "" || wrk.BeginsWith("valgrind_opts:")) { wrk.ReplaceAll("valgrind_opts:",""); var.Form("%s --log-file=<logfilewrk>.valgrind.log %s", cmd.Data(), wrk.Data()); TProof::AddEnvVar("PROOF_SLAVE_WRAPPERCMD", var); TString nwrks("2"); Int_t inw = vgconf.Index('#'); if (inw != kNPOS) { nwrks = vgconf(inw+1, vgconf.Length()); if (!nwrks.IsDigit()) nwrks = "2"; } TProof::AddEnvVar("PROOF_NWORKERS", nwrks); wrklab = nwrks; // Register the additional worker log in the session file // (for the master is done automatically) TProof::AddEnvVar("PROOF_ADDITIONALLOG", "valgrind.log*"); } else if (wrk != "") { wrklab = "ALL"; } } // Increase the relevant timeouts TProof::AddEnvVar("PROOF_INTWAIT", "5000"); gEnv->SetValue("Proof.SocketActivityTimeout", 6000); // Warn for slowness Printf(" "); Printf(" ---> Starting a debug run with valgrind (master:%s, workers:%s)", mstlab.Data(), wrklab.Data()); Printf(" ---> Please be patient: startup may be VERY slow ..."); Printf(" ---> Logs will be available as special tags in the log window (from the progress dialog or TProof::LogViewer()) "); Printf(" ---> (Reminder: this debug run makes sense only if you are running a debug version of ROOT)"); Printf(" "); } } //______________________________________________________________________________ Int_t TProof::AssertPath(const char *inpath, Bool_t writable) { // Make sure that 'path' exists; if 'writable' is kTRUE, make also sure // that the path is writable if (!inpath || strlen(inpath) <= 0) { Error("AssertPath", "undefined input path"); return -1; } TString path(inpath); gSystem->ExpandPathName(path); if (gSystem->AccessPathName(path, kFileExists)) { if (gSystem->mkdir(path, kTRUE) != 0) { Error("AssertPath", "could not create path %s", path.Data()); return -1; } } // It must be writable if (gSystem->AccessPathName(path, kWritePermission) && writable) { if (gSystem->Chmod(path, 0666) != 0) { Error("AssertPath", "could not make path %s writable", path.Data()); return -1; } } // Done return 0; } //______________________________________________________________________________ void TProof::SetManager(TProofMgr *mgr) { // Set manager and schedule its destruction after this for clean // operations. fManager = mgr; if (mgr) { R__LOCKGUARD2(gROOTMutex); gROOT->GetListOfSockets()->Remove(mgr); gROOT->GetListOfSockets()->Add(mgr); } } //______________________________________________________________________________ Int_t TProof::AddWorkers(TList *workerList) { // Works on the master node only. // It starts workers on the machines in workerList and sets the paths, // packages and macros as on the master. // It is a subbstitute for StartSlaves(...) // The code is mostly the master part of StartSlaves, // with the parallel startup removed. if (!IsMaster()) { Error("AddWorkers", "AddWorkers can only be called on the master!"); return -1; } if (!workerList || !(workerList->GetSize())) { Error("AddWorkers", "The list of workers should not be empty; NULL: %d", workerList == 0); return -2; } // Code taken from master part of StartSlaves with the parllel part removed fImage = gProofServ->GetImage(); if (fImage.IsNull()) fImage = Form("%s:%s", TUrl(gSystem->HostName()).GetHostFQDN(), gProofServ->GetWorkDir()); // Get all workers UInt_t nSlaves = workerList->GetSize(); UInt_t nSlavesDone = 0; Int_t ord = 0; // Loop over all workers and start them // a list of TSlave objects for workers that are being added TList *addedWorkers = new TList(); addedWorkers->SetOwner(kFALSE); TListIter next(workerList); TObject *to; TProofNodeInfo *worker; while ((to = next())) { // Get the next worker from the list worker = (TProofNodeInfo *)to; // Read back worker node info const Char_t *image = worker->GetImage().Data(); const Char_t *workdir = worker->GetWorkDir().Data(); Int_t perfidx = worker->GetPerfIndex(); Int_t sport = worker->GetPort(); if (sport == -1) sport = fUrl.GetPort(); // create slave server TString fullord; if (worker->GetOrdinal().Length() > 0) { fullord.Form("%s.%s", gProofServ->GetOrdinal(), worker->GetOrdinal().Data()); } else { fullord.Form("%s.%d", gProofServ->GetOrdinal(), ord); } // create slave server TUrl u(Form("%s:%d",worker->GetNodeName().Data(), sport)); // Add group info in the password firdl, if any if (strlen(gProofServ->GetGroup()) > 0) { // Set also the user, otherwise the password is not exported if (strlen(u.GetUser()) <= 0) u.SetUser(gProofServ->GetUser()); u.SetPasswd(gProofServ->GetGroup()); } TSlave *slave = CreateSlave(u.GetUrl(), fullord, perfidx, image, workdir); // Add to global list (we will add to the monitor list after // finalizing the server startup) Bool_t slaveOk = kTRUE; if (slave->IsValid()) { fSlaves->Add(slave); addedWorkers->Add(slave); } else { slaveOk = kFALSE; fBadSlaves->Add(slave); } PDB(kGlobal,3) Info("StartSlaves", "worker on host %s created" " and added to list", worker->GetNodeName().Data()); // Notify opening of connection nSlavesDone++; TMessage m(kPROOF_SERVERSTARTED); m << TString("Opening connections to workers") << nSlaves << nSlavesDone << slaveOk; gProofServ->GetSocket()->Send(m); ord++; } //end of the worker loop // Cleanup SafeDelete(workerList); nSlavesDone = 0; // Here we finalize the server startup: in this way the bulk // of remote operations are almost parallelized TIter nxsl(addedWorkers); TSlave *sl = 0; while ((sl = (TSlave *) nxsl())) { // Finalize setup of the server if (sl->IsValid()) sl->SetupServ(TSlave::kSlave, 0); // Monitor good slaves Bool_t slaveOk = kTRUE; if (sl->IsValid()) { fAllMonitor->Add(sl->GetSocket()); } else { slaveOk = kFALSE; fBadSlaves->Add(sl); } // Notify end of startup operations nSlavesDone++; TMessage m(kPROOF_SERVERSTARTED); m << TString("Setting up worker servers") << nSlaves << nSlavesDone << slaveOk; gProofServ->GetSocket()->Send(m); } // Now set new state on the added workers (on all workers for simplicity) // use fEnabledPackages, fLoadedMacros, // gSystem->GetDynamicPath() and gSystem->GetIncludePath() // no need to load packages that are only loaded and not enabled (dyn mode) SetParallel(99999, 0); TList *tmpEnabledPackages = gProofServ->GetEnabledPackages(); if (tmpEnabledPackages && tmpEnabledPackages->GetSize() > 0) { TIter nxp(tmpEnabledPackages); TObjString *os = 0; while ((os = (TObjString *) nxp())) { // Upload and Enable methods are intelligent and avoid // re-uploading or re-enabling of a package to a node that has it. UploadPackage(os->GetName()); EnablePackage(os->GetName(), kTRUE); } } if (fLoadedMacros) { TIter nxp(fLoadedMacros); TObjString *os = 0; while ((os = (TObjString *) nxp())) { Printf("Loading a macro : %s", os->GetName()); Load(os->GetName(), kTRUE, kTRUE, addedWorkers); } } TString dyn = gSystem->GetDynamicPath(); dyn.ReplaceAll(":", " "); dyn.ReplaceAll("\"", " "); AddDynamicPath(dyn, addedWorkers); TString inc = gSystem->GetIncludePath(); inc.ReplaceAll("-I", " "); inc.ReplaceAll("\"", " "); AddIncludePath(inc, addedWorkers); // Cleanup delete addedWorkers; // Inform the client that the number of workers is changed if (fDynamicStartup && gProofServ) gProofServ->SendParallel(kTRUE); return 0; } //______________________________________________________________________________ Int_t TProof::RemoveWorkers(TList *workerList) { // Used for shuting down the workres after a query is finished. // Sends each of the workers from the workerList, a kPROOF_STOP message. // If the workerList == 0, shutdown all the workers. if (!IsMaster()) { Error("RemoveWorkers", "RemoveWorkers can only be called on the master!"); return -1; } fFileMap.clear(); // This could be avoided if CopyFromCache was used in SendFile if (!workerList) { // shutdown all the workers TIter nxsl(fSlaves); TSlave *sl = 0; while ((sl = (TSlave *) nxsl())) { // Shut down the worker assumig that it is not processing TerminateWorker(sl); } } else { if (!(workerList->GetSize())) { Error("RemoveWorkers", "The list of workers should not be empty!"); return -2; } // Loop over all the workers and stop them TListIter next(workerList); TObject *to; TProofNodeInfo *worker; while ((to = next())) { TSlave *sl = 0; if (!strcmp(to->ClassName(), "TProofNodeInfo")) { // Get the next worker from the list worker = (TProofNodeInfo *)to; TIter nxsl(fSlaves); while ((sl = (TSlave *) nxsl())) { // Shut down the worker assumig that it is not processing if (sl->GetName() == worker->GetNodeName()) break; } } else if (to->InheritsFrom("TSlave")) { sl = (TSlave *) to; } else { Warning("RemoveWorkers","unknown object type: %s - it should be" " TProofNodeInfo or inheriting from TSlave", to->ClassName()); } // Shut down the worker assumig that it is not processing if (sl) { if (gDebug > 0) Info("RemoveWorkers","terminating worker %s", sl->GetOrdinal()); TerminateWorker(sl); } } } // Update also the master counter if (gProofServ && fSlaves->GetSize() <= 0) gProofServ->ReleaseWorker("master"); return 0; } //______________________________________________________________________________ Bool_t TProof::StartSlaves(Bool_t attach) { // Start up PROOF slaves. // If this is a master server, find the config file and start slave // servers as specified in the config file if (TestBit(TProof::kIsMaster)) { Int_t pc = 0; TList *workerList = new TList; // Get list of workers if (gProofServ->GetWorkers(workerList, pc) == TProofServ::kQueryStop) { TString emsg("no resource currently available for this session: please retry later"); if (gDebug > 0) Info("StartSlaves", emsg.Data()); gProofServ->SendAsynMessage(emsg.Data()); return kFALSE; } // Setup the workers if (AddWorkers(workerList) < 0) return kFALSE; } else { // create master server Printf("Starting master: opening connection ..."); TSlave *slave = CreateSubmaster(fUrl.GetUrl(), "0", "master", 0); if (slave->IsValid()) { // Notify fprintf(stderr,"Starting master:" " connection open: setting up server ... \r"); StartupMessage("Connection to master opened", kTRUE, 1, 1); if (!attach) { // Set worker interrupt handler slave->SetInterruptHandler(kTRUE); // Finalize setup of the server slave->SetupServ(TSlave::kMaster, fConfFile); if (slave->IsValid()) { // Notify Printf("Starting master: OK "); StartupMessage("Master started", kTRUE, 1, 1); // check protocol compatibility // protocol 1 is not supported anymore if (fProtocol == 1) { Error("StartSlaves", "client and remote protocols not compatible (%d and %d)", kPROOF_Protocol, fProtocol); slave->Close("S"); delete slave; return kFALSE; } fSlaves->Add(slave); fAllMonitor->Add(slave->GetSocket()); // Unset worker interrupt handler slave->SetInterruptHandler(kFALSE); // Set interrupt PROOF handler from now on fIntHandler = new TProofInterruptHandler(this); // Give-up after 5 minutes Int_t rc = Collect(slave, 300); Int_t slStatus = slave->GetStatus(); if (slStatus == -99 || slStatus == -98 || rc == 0) { fSlaves->Remove(slave); fAllMonitor->Remove(slave->GetSocket()); if (slStatus == -99) Error("StartSlaves", "no resources available or problems setting up workers (check logs)"); else if (slStatus == -98) Error("StartSlaves", "could not setup output redirection on master"); else Error("StartSlaves", "setting up master"); slave->Close("S"); delete slave; return 0; } if (!slave->IsValid()) { fSlaves->Remove(slave); fAllMonitor->Remove(slave->GetSocket()); slave->Close("S"); delete slave; Error("StartSlaves", "failed to setup connection with PROOF master server"); return kFALSE; } if (!gROOT->IsBatch()) { if ((fProgressDialog = gROOT->GetPluginManager()->FindHandler("TProofProgressDialog"))) if (fProgressDialog->LoadPlugin() == -1) fProgressDialog = 0; } } else { // Notify Printf("Starting master: failure"); } } else { // Notify Printf("Starting master: OK "); StartupMessage("Master attached", kTRUE, 1, 1); if (!gROOT->IsBatch()) { if ((fProgressDialog = gROOT->GetPluginManager()->FindHandler("TProofProgressDialog"))) if (fProgressDialog->LoadPlugin() == -1) fProgressDialog = 0; } fSlaves->Add(slave); fIntHandler = new TProofInterruptHandler(this); } } else { delete slave; // Notify only if verbosity is on: most likely the failure has already been notified if (gDebug > 0) Error("StartSlaves", "failed to create (or connect to) the PROOF master server"); return kFALSE; } } return kTRUE; } //______________________________________________________________________________ void TProof::Close(Option_t *opt) { // Close all open slave servers. // Client can decide to shutdown the remote session by passing option is 'S' // or 's'. Default for clients is detach, if supported. Masters always // shutdown the remote counterpart. { R__LOCKGUARD2(fCloseMutex); fValid = kFALSE; if (fSlaves) { if (fIntHandler) fIntHandler->Remove(); TIter nxs(fSlaves); TSlave *sl = 0; while ((sl = (TSlave *)nxs())) sl->Close(opt); fActiveSlaves->Clear("nodelete"); fUniqueSlaves->Clear("nodelete"); fAllUniqueSlaves->Clear("nodelete"); fNonUniqueMasters->Clear("nodelete"); fBadSlaves->Clear("nodelete"); fSlaves->Delete(); } } { R__LOCKGUARD2(gROOTMutex); gROOT->GetListOfSockets()->Remove(this); if (IsProofd()) { gROOT->GetListOfProofs()->Remove(this); if (gProof && gProof == this) { // Set previous proofd-related as default TIter pvp(gROOT->GetListOfProofs(), kIterBackward); while ((gProof = (TProof *)pvp())) { if (gProof->IsProofd()) break; } } } } } //______________________________________________________________________________ TSlave *TProof::CreateSlave(const char *url, const char *ord, Int_t perf, const char *image, const char *workdir) { // Create a new TSlave of type TSlave::kSlave. // Note: creation of TSlave is private with TProof as a friend. // Derived classes must use this function to create slaves. TSlave* sl = TSlave::Create(url, ord, perf, image, this, TSlave::kSlave, workdir, 0); if (sl->IsValid()) { sl->SetInputHandler(new TProofInputHandler(this, sl->GetSocket())); // must set fParallel to 1 for slaves since they do not // report their fParallel with a LOG_DONE message sl->fParallel = 1; } return sl; } //______________________________________________________________________________ TSlave *TProof::CreateSubmaster(const char *url, const char *ord, const char *image, const char *msd) { // Create a new TSlave of type TSlave::kMaster. // Note: creation of TSlave is private with TProof as a friend. // Derived classes must use this function to create slaves. TSlave *sl = TSlave::Create(url, ord, 100, image, this, TSlave::kMaster, 0, msd); if (sl->IsValid()) { sl->SetInputHandler(new TProofInputHandler(this, sl->GetSocket())); } return sl; } //______________________________________________________________________________ TSlave *TProof::FindSlave(TSocket *s) const { // Find slave that has TSocket s. Returns 0 in case slave is not found. TSlave *sl; TIter next(fSlaves); while ((sl = (TSlave *)next())) { if (sl->IsValid() && sl->GetSocket() == s) return sl; } return 0; } //______________________________________________________________________________ void TProof::FindUniqueSlaves() { // Add to the fUniqueSlave list the active slaves that have a unique // (user) file system image. This information is used to transfer files // only once to nodes that share a file system (an image). Submasters // which are not in fUniqueSlaves are put in the fNonUniqueMasters // list. That list is used to trigger the transferring of files to // the submaster's unique slaves without the need to transfer the file // to the submaster. fUniqueSlaves->Clear(); fUniqueMonitor->RemoveAll(); fAllUniqueSlaves->Clear(); fAllUniqueMonitor->RemoveAll(); fNonUniqueMasters->Clear(); TIter next(fActiveSlaves); while (TSlave *sl = dynamic_cast<TSlave*>(next())) { if (fImage == sl->fImage) { if (sl->GetSlaveType() == TSlave::kMaster) { fNonUniqueMasters->Add(sl); fAllUniqueSlaves->Add(sl); fAllUniqueMonitor->Add(sl->GetSocket()); } continue; } TIter next2(fUniqueSlaves); TSlave *replace_slave = 0; Bool_t add = kTRUE; while (TSlave *sl2 = dynamic_cast<TSlave*>(next2())) { if (sl->fImage == sl2->fImage) { add = kFALSE; if (sl->GetSlaveType() == TSlave::kMaster) { if (sl2->GetSlaveType() == TSlave::kSlave) { // give preference to master replace_slave = sl2; add = kTRUE; } else if (sl2->GetSlaveType() == TSlave::kMaster) { fNonUniqueMasters->Add(sl); fAllUniqueSlaves->Add(sl); fAllUniqueMonitor->Add(sl->GetSocket()); } else { Error("FindUniqueSlaves", "TSlave is neither Master nor Slave"); R__ASSERT(0); } } break; } } if (add) { fUniqueSlaves->Add(sl); fAllUniqueSlaves->Add(sl); fUniqueMonitor->Add(sl->GetSocket()); fAllUniqueMonitor->Add(sl->GetSocket()); if (replace_slave) { fUniqueSlaves->Remove(replace_slave); fAllUniqueSlaves->Remove(replace_slave); fUniqueMonitor->Remove(replace_slave->GetSocket()); fAllUniqueMonitor->Remove(replace_slave->GetSocket()); } } } // will be actiavted in Collect() fUniqueMonitor->DeActivateAll(); fAllUniqueMonitor->DeActivateAll(); } //______________________________________________________________________________ Int_t TProof::GetNumberOfSlaves() const { // Return number of slaves as described in the config file. return fSlaves->GetSize(); } //______________________________________________________________________________ Int_t TProof::GetNumberOfActiveSlaves() const { // Return number of active slaves, i.e. slaves that are valid and in // the current computing group. return fActiveSlaves->GetSize(); } //______________________________________________________________________________ Int_t TProof::GetNumberOfInactiveSlaves() const { // Return number of inactive slaves, i.e. slaves that are valid but not in // the current computing group. return fInactiveSlaves->GetSize(); } //______________________________________________________________________________ Int_t TProof::GetNumberOfUniqueSlaves() const { // Return number of unique slaves, i.e. active slaves that have each a // unique different user files system. return fUniqueSlaves->GetSize(); } //______________________________________________________________________________ Int_t TProof::GetNumberOfBadSlaves() const { // Return number of bad slaves. This are slaves that we in the config // file, but refused to startup or that died during the PROOF session. return fBadSlaves->GetSize(); } //______________________________________________________________________________ void TProof::AskStatistics() { // Ask the for the statistics of the slaves. if (!IsValid()) return; Broadcast(kPROOF_GETSTATS, kActive); Collect(kActive, fCollectTimeout); } //______________________________________________________________________________ void TProof::AskParallel() { // Ask the for the number of parallel slaves. if (!IsValid()) return; Broadcast(kPROOF_GETPARALLEL, kActive); Collect(kActive, fCollectTimeout); } //______________________________________________________________________________ TList *TProof::GetListOfQueries(Option_t *opt) { // Ask the master for the list of queries. if (!IsValid() || TestBit(TProof::kIsMaster)) return (TList *)0; Bool_t all = ((strchr(opt,'A') || strchr(opt,'a'))) ? kTRUE : kFALSE; TMessage m(kPROOF_QUERYLIST); m << all; Broadcast(m, kActive); Collect(kActive, fCollectTimeout); // This should have been filled by now return fQueries; } //______________________________________________________________________________ Int_t TProof::GetNumberOfQueries() { // Number of queries processed by this session if (fQueries) return fQueries->GetSize() - fOtherQueries; return 0; } //______________________________________________________________________________ void TProof::SetMaxDrawQueries(Int_t max) { // Set max number of draw queries whose results are saved if (max > 0) { if (fPlayer) fPlayer->SetMaxDrawQueries(max); fMaxDrawQueries = max; } } //______________________________________________________________________________ void TProof::GetMaxQueries() { // Get max number of queries whose full results are kept in the // remote sandbox TMessage m(kPROOF_MAXQUERIES); m << kFALSE; Broadcast(m, kActive); Collect(kActive, fCollectTimeout); } //______________________________________________________________________________ TList *TProof::GetQueryResults() { // Return pointer to the list of query results in the player return (fPlayer ? fPlayer->GetListOfResults() : (TList *)0); } //______________________________________________________________________________ TQueryResult *TProof::GetQueryResult(const char *ref) { // Return pointer to the full TQueryResult instance owned by the player // and referenced by 'ref'. If ref = 0 or "", return the last query result. return (fPlayer ? fPlayer->GetQueryResult(ref) : (TQueryResult *)0); } //______________________________________________________________________________ void TProof::ShowQueries(Option_t *opt) { // Ask the master for the list of queries. // Options: // "A" show information about all the queries known to the // server, i.e. even those processed by other sessions // "L" show only information about queries locally available // i.e. already retrieved. If "L" is specified, "A" is // ignored. // "F" show all details available about queries // "H" print help menu // Default "" Bool_t help = ((strchr(opt,'H') || strchr(opt,'h'))) ? kTRUE : kFALSE; if (help) { // Help Printf("+++"); Printf("+++ Options: \"A\" show all queries known to server"); Printf("+++ \"L\" show retrieved queries"); Printf("+++ \"F\" full listing of query info"); Printf("+++ \"H\" print this menu"); Printf("+++"); Printf("+++ (case insensitive)"); Printf("+++"); Printf("+++ Use Retrieve(<#>) to retrieve the full" " query results from the master"); Printf("+++ e.g. Retrieve(8)"); Printf("+++"); return; } if (!IsValid()) return; Bool_t local = ((strchr(opt,'L') || strchr(opt,'l'))) ? kTRUE : kFALSE; TObject *pq = 0; if (!local) { GetListOfQueries(opt); if (!fQueries) return; TIter nxq(fQueries); // Queries processed by other sessions if (fOtherQueries > 0) { Printf("+++"); Printf("+++ Queries processed during other sessions: %d", fOtherQueries); Int_t nq = 0; while (nq++ < fOtherQueries && (pq = nxq())) pq->Print(opt); } // Queries processed by this session Printf("+++"); Printf("+++ Queries processed during this session: selector: %d, draw: %d", GetNumberOfQueries(), fDrawQueries); while ((pq = nxq())) pq->Print(opt); } else { // Queries processed by this session Printf("+++"); Printf("+++ Queries processed during this session: selector: %d, draw: %d", GetNumberOfQueries(), fDrawQueries); // Queries available locally TList *listlocal = fPlayer ? fPlayer->GetListOfResults() : (TList *)0; if (listlocal) { Printf("+++"); Printf("+++ Queries available locally: %d", listlocal->GetSize()); TIter nxlq(listlocal); while ((pq = nxlq())) pq->Print(opt); } } Printf("+++"); } //______________________________________________________________________________ Bool_t TProof::IsDataReady(Long64_t &totalbytes, Long64_t &bytesready) { // See if the data is ready to be analyzed. if (!IsValid()) return kFALSE; TList submasters; TIter nextSlave(GetListOfActiveSlaves()); while (TSlave *sl = dynamic_cast<TSlave*>(nextSlave())) { if (sl->GetSlaveType() == TSlave::kMaster) { submasters.Add(sl); } } fDataReady = kTRUE; //see if any submasters set it to false fBytesReady = 0; fTotalBytes = 0; //loop over submasters and see if data is ready if (submasters.GetSize() > 0) { Broadcast(kPROOF_DATA_READY, &submasters); Collect(&submasters); } bytesready = fBytesReady; totalbytes = fTotalBytes; EmitVA("IsDataReady(Long64_t,Long64_t)", 2, totalbytes, bytesready); //PDB(kGlobal,2) Info("IsDataReady", "%lld / %lld (%s)", bytesready, totalbytes, fDataReady?"READY":"NOT READY"); return fDataReady; } //______________________________________________________________________________ void TProof::Interrupt(EUrgent type, ESlaves list) { // Send interrupt to master or slave servers. if (!IsValid()) return; TList *slaves = 0; if (list == kAll) slaves = fSlaves; if (list == kActive) slaves = fActiveSlaves; if (list == kUnique) slaves = fUniqueSlaves; if (list == kAllUnique) slaves = fAllUniqueSlaves; if (slaves->GetSize() == 0) return; TSlave *sl; TIter next(slaves); while ((sl = (TSlave *)next())) { if (sl->IsValid()) { // Ask slave to progate the interrupt request sl->Interrupt((Int_t)type); } } } //______________________________________________________________________________ Int_t TProof::GetParallel() const { // Returns number of slaves active in parallel mode. Returns 0 in case // there are no active slaves. Returns -1 in case of error. if (!IsValid()) return -1; // iterate over active slaves and return total number of slaves TIter nextSlave(GetListOfActiveSlaves()); Int_t nparallel = 0; while (TSlave* sl = dynamic_cast<TSlave*>(nextSlave())) if (sl->GetParallel() >= 0) nparallel += sl->GetParallel(); return nparallel; } //______________________________________________________________________________ TList *TProof::GetListOfSlaveInfos() { // Returns list of TSlaveInfo's. In case of error return 0. if (!IsValid()) return 0; if (fSlaveInfo == 0) { fSlaveInfo = new TSortedList(kSortDescending); fSlaveInfo->SetOwner(); } else { fSlaveInfo->Delete(); } TList masters; TIter next(GetListOfSlaves()); TSlave *slave; while ((slave = (TSlave *) next()) != 0) { if (slave->GetSlaveType() == TSlave::kSlave) { TSlaveInfo *slaveinfo = new TSlaveInfo(slave->GetOrdinal(), slave->GetName(), slave->GetPerfIdx()); fSlaveInfo->Add(slaveinfo); TIter nextactive(GetListOfActiveSlaves()); TSlave *activeslave; while ((activeslave = (TSlave *) nextactive())) { if (TString(slaveinfo->GetOrdinal()) == activeslave->GetOrdinal()) { slaveinfo->SetStatus(TSlaveInfo::kActive); break; } } TIter nextbad(GetListOfBadSlaves()); TSlave *badslave; while ((badslave = (TSlave *) nextbad())) { if (TString(slaveinfo->GetOrdinal()) == badslave->GetOrdinal()) { slaveinfo->SetStatus(TSlaveInfo::kBad); break; } } } else if (slave->GetSlaveType() == TSlave::kMaster) { if (slave->IsValid()) { if (slave->GetSocket()->Send(kPROOF_GETSLAVEINFO) == -1) MarkBad(slave, "could not send kPROOF_GETSLAVEINFO message"); else masters.Add(slave); } } else { Error("GetSlaveInfo", "TSlave is neither Master nor Slave"); R__ASSERT(0); } } if (masters.GetSize() > 0) Collect(&masters); return fSlaveInfo; } //______________________________________________________________________________ void TProof::Activate(TList *slaves) { // Activate slave server list. TMonitor *mon = fAllMonitor; mon->DeActivateAll(); slaves = !slaves ? fActiveSlaves : slaves; TIter next(slaves); TSlave *sl; while ((sl = (TSlave*) next())) { if (sl->IsValid()) mon->Activate(sl->GetSocket()); } } //______________________________________________________________________________ void TProof::SetMonitor(TMonitor *mon, Bool_t on) { // Activate (on == TRUE) or deactivate (on == FALSE) all sockets // monitored by 'mon'. TMonitor *m = (mon) ? mon : fCurrentMonitor; if (m) { if (on) m->ActivateAll(); else m->DeActivateAll(); } } //______________________________________________________________________________ Int_t TProof::BroadcastGroupPriority(const char *grp, Int_t priority, TList *workers) { // Broadcast the group priority to all workers in the specified list. Returns // the number of workers the message was successfully sent to. // Returns -1 in case of error. if (!IsValid()) return -1; if (workers->GetSize() == 0) return 0; int nsent = 0; TIter next(workers); TSlave *wrk; while ((wrk = (TSlave *)next())) { if (wrk->IsValid()) { if (wrk->SendGroupPriority(grp, priority) == -1) MarkBad(wrk, "could not send group priority"); else nsent++; } } return nsent; } //______________________________________________________________________________ Int_t TProof::BroadcastGroupPriority(const char *grp, Int_t priority, ESlaves list) { // Broadcast the group priority to all workers in the specified list. Returns // the number of workers the message was successfully sent to. // Returns -1 in case of error. TList *workers = 0; if (list == kAll) workers = fSlaves; if (list == kActive) workers = fActiveSlaves; if (list == kUnique) workers = fUniqueSlaves; if (list == kAllUnique) workers = fAllUniqueSlaves; return BroadcastGroupPriority(grp, priority, workers); } //______________________________________________________________________________ void TProof::ResetMergePrg() { // Reset the merge progress notificator fMergePrg.Reset(fActiveSlaves->GetSize()); } //______________________________________________________________________________ Int_t TProof::Broadcast(const TMessage &mess, TList *slaves) { // Broadcast a message to all slaves in the specified list. Returns // the number of slaves the message was successfully sent to. // Returns -1 in case of error. if (!IsValid()) return -1; if (!slaves || slaves->GetSize() == 0) return 0; int nsent = 0; TIter next(slaves); TSlave *sl; while ((sl = (TSlave *)next())) { if (sl->IsValid()) { if (sl->GetSocket()->Send(mess) == -1) MarkBad(sl, "could not broadcast request"); else nsent++; } } return nsent; } //______________________________________________________________________________ Int_t TProof::Broadcast(const TMessage &mess, ESlaves list) { // Broadcast a message to all slaves in the specified list (either // all slaves or only the active slaves). Returns the number of slaves // the message was successfully sent to. Returns -1 in case of error. TList *slaves = 0; if (list == kAll) slaves = fSlaves; if (list == kActive) slaves = fActiveSlaves; if (list == kUnique) slaves = fUniqueSlaves; if (list == kAllUnique) slaves = fAllUniqueSlaves; return Broadcast(mess, slaves); } //______________________________________________________________________________ Int_t TProof::Broadcast(const char *str, Int_t kind, TList *slaves) { // Broadcast a character string buffer to all slaves in the specified // list. Use kind to set the TMessage what field. Returns the number of // slaves the message was sent to. Returns -1 in case of error. TMessage mess(kind); if (str) mess.WriteString(str); return Broadcast(mess, slaves); } //______________________________________________________________________________ Int_t TProof::Broadcast(const char *str, Int_t kind, ESlaves list) { // Broadcast a character string buffer to all slaves in the specified // list (either all slaves or only the active slaves). Use kind to // set the TMessage what field. Returns the number of slaves the message // was sent to. Returns -1 in case of error. TMessage mess(kind); if (str) mess.WriteString(str); return Broadcast(mess, list); } //______________________________________________________________________________ Int_t TProof::BroadcastObject(const TObject *obj, Int_t kind, TList *slaves) { // Broadcast an object to all slaves in the specified list. Use kind to // set the TMEssage what field. Returns the number of slaves the message // was sent to. Returns -1 in case of error. TMessage mess(kind); mess.WriteObject(obj); return Broadcast(mess, slaves); } //______________________________________________________________________________ Int_t TProof::BroadcastObject(const TObject *obj, Int_t kind, ESlaves list) { // Broadcast an object to all slaves in the specified list. Use kind to // set the TMEssage what field. Returns the number of slaves the message // was sent to. Returns -1 in case of error. TMessage mess(kind); mess.WriteObject(obj); return Broadcast(mess, list); } //______________________________________________________________________________ Int_t TProof::BroadcastRaw(const void *buffer, Int_t length, TList *slaves) { // Broadcast a raw buffer of specified length to all slaves in the // specified list. Returns the number of slaves the buffer was sent to. // Returns -1 in case of error. if (!IsValid()) return -1; if (slaves->GetSize() == 0) return 0; int nsent = 0; TIter next(slaves); TSlave *sl; while ((sl = (TSlave *)next())) { if (sl->IsValid()) { if (sl->GetSocket()->SendRaw(buffer, length) == -1) MarkBad(sl, "could not send broadcast-raw request"); else nsent++; } } return nsent; } //______________________________________________________________________________ Int_t TProof::BroadcastRaw(const void *buffer, Int_t length, ESlaves list) { // Broadcast a raw buffer of specified length to all slaves in the // specified list. Returns the number of slaves the buffer was sent to. // Returns -1 in case of error. TList *slaves = 0; if (list == kAll) slaves = fSlaves; if (list == kActive) slaves = fActiveSlaves; if (list == kUnique) slaves = fUniqueSlaves; if (list == kAllUnique) slaves = fAllUniqueSlaves; return BroadcastRaw(buffer, length, slaves); } //______________________________________________________________________________ Int_t TProof::BroadcastFile(const char *file, Int_t opt, const char *rfile, TList *wrks) { // Broadcast file to all workers in the specified list. Returns the number of workers // the buffer was sent to. // Returns -1 in case of error. if (!IsValid()) return -1; if (wrks->GetSize() == 0) return 0; int nsent = 0; TIter next(wrks); TSlave *wrk; while ((wrk = (TSlave *)next())) { if (wrk->IsValid()) { if (SendFile(file, opt, rfile, wrk) < 0) Error("BroadcastFile", "problems sending file to worker %s (%s)", wrk->GetOrdinal(), wrk->GetName()); else nsent++; } } return nsent; } //______________________________________________________________________________ Int_t TProof::BroadcastFile(const char *file, Int_t opt, const char *rfile, ESlaves list) { // Broadcast file to all workers in the specified list. Returns the number of workers // the buffer was sent to. // Returns -1 in case of error. TList *wrks = 0; if (list == kAll) wrks = fSlaves; if (list == kActive) wrks = fActiveSlaves; if (list == kUnique) wrks = fUniqueSlaves; if (list == kAllUnique) wrks = fAllUniqueSlaves; return BroadcastFile(file, opt, rfile, wrks); } //______________________________________________________________________________ void TProof::ReleaseMonitor(TMonitor *mon) { // Release the used monitor to be used, making sure to delete newly created // monitors. if (mon && (mon != fAllMonitor) && (mon != fActiveMonitor) && (mon != fUniqueMonitor) && (mon != fAllUniqueMonitor)) { delete mon; } } //______________________________________________________________________________ Int_t TProof::Collect(const TSlave *sl, Long_t timeout, Int_t endtype) { // Collect responses from slave sl. Returns the number of slaves that // responded (=1). // If timeout >= 0, wait at most timeout seconds (timeout = -1 by default, // which means wait forever). // If defined (>= 0) endtype is the message that stops this collection. Int_t rc = 0; TMonitor *mon = 0; if (!sl->IsValid()) return 0; if (fCurrentMonitor == fAllMonitor) { mon = new TMonitor; } else { mon = fAllMonitor; mon->DeActivateAll(); } mon->Activate(sl->GetSocket()); rc = Collect(mon, timeout, endtype); ReleaseMonitor(mon); return rc; } //______________________________________________________________________________ Int_t TProof::Collect(TList *slaves, Long_t timeout, Int_t endtype) { // Collect responses from the slave servers. Returns the number of slaves // that responded. // If timeout >= 0, wait at most timeout seconds (timeout = -1 by default, // which means wait forever). // If defined (>= 0) endtype is the message that stops this collection. Int_t rc = 0; TMonitor *mon = 0; if (fCurrentMonitor == fAllMonitor) { mon = new TMonitor; } else { mon = fAllMonitor; mon->DeActivateAll(); } TIter next(slaves); TSlave *sl; while ((sl = (TSlave*) next())) { if (sl->IsValid()) mon->Activate(sl->GetSocket()); } rc = Collect(mon, timeout, endtype); ReleaseMonitor(mon); return rc; } //______________________________________________________________________________ Int_t TProof::Collect(ESlaves list, Long_t timeout, Int_t endtype) { // Collect responses from the slave servers. Returns the number of slaves // that responded. // If timeout >= 0, wait at most timeout seconds (timeout = -1 by default, // which means wait forever). // If defined (>= 0) endtype is the message that stops this collection. Int_t rc = 0; TMonitor *mon = 0; if (list == kAll) mon = fAllMonitor; if (list == kActive) mon = fActiveMonitor; if (list == kUnique) mon = fUniqueMonitor; if (list == kAllUnique) mon = fAllUniqueMonitor; if (fCurrentMonitor == mon) { // Get a copy mon = new TMonitor(*mon); } mon->ActivateAll(); rc = Collect(mon, timeout, endtype); ReleaseMonitor(mon); return rc; } //______________________________________________________________________________ Int_t TProof::Collect(TMonitor *mon, Long_t timeout, Int_t endtype) { // Collect responses from the slave servers. Returns the number of messages // received. Can be 0 if there are no active slaves. // If timeout >= 0, wait at most timeout seconds (timeout = -1 by default, // which means wait forever). // If defined (>= 0) endtype is the message that stops this collection. // Reset the status flag and clear the messages in the list, if any fStatus = 0; fRecvMessages->Clear(); Long_t actto = (Long_t)(gEnv->GetValue("Proof.SocketActivityTimeout", 600) * 1000); if (!mon->GetActive(actto)) return 0; DeActivateAsyncInput(); // Used by external code to know what we are monitoring TMonitor *savedMonitor = 0; if (fCurrentMonitor) { savedMonitor = fCurrentMonitor; fCurrentMonitor = mon; } else { fCurrentMonitor = mon; fBytesRead = 0; fRealTime = 0.0; fCpuTime = 0.0; } // We want messages on the main window during synchronous collection, // but we save the present status to restore it at the end Bool_t saveRedirLog = fRedirLog; if (!IsIdle() && !IsSync()) fRedirLog = kFALSE; int cnt = 0, rc = 0; // Timeout counter Long_t nto = timeout; if (gDebug > 2) Info("Collect","active: %d", mon->GetActive()); // On clients, handle Ctrl-C during collection if (fIntHandler) fIntHandler->Add(); // Sockets w/o activity during the last 'sto' millisecs are deactivated Long_t sto = -1; Int_t nsto = 60; while (mon->GetActive(sto) && (nto < 0 || nto > 0)) { // Wait for a ready socket TSocket *s = mon->Select(1000); if (s && s != (TSocket *)(-1)) { // Get and analyse the info it did receive rc = CollectInputFrom(s, endtype); if (rc == 1 || (rc == 2 && !savedMonitor)) { // Deactivate it if we are done with it mon->DeActivate(s); PDB(kGlobal, 2) Info("Collect","deactivating %p (active: %d, %p)", s, mon->GetActive(), mon->GetListOfActives()->First()); } else if (rc == 2) { // This end message was for the saved monitor // Deactivate it if we are done with it if (savedMonitor) { savedMonitor->DeActivate(s); PDB(kGlobal, 2) Info("Collect","save monitor: deactivating %p (active: %d, %p)", s, savedMonitor->GetActive(), savedMonitor->GetListOfActives()->First()); } } // Update counter (if no error occured) if (rc >= 0) cnt++; } else { // If not timed-out, exit if not stopped or not aborted // (player exits status is finished in such a case); otherwise, // we still need to collect the partial output info if (!s) if (fPlayer && (fPlayer->GetExitStatus() == TVirtualProofPlayer::kFinished)) mon->DeActivateAll(); // Decrease the timeout counter if requested if (s == (TSocket *)(-1) && nto > 0) nto--; } // Check if we need to check the socket activity (we do it every 10 cycles ~ 10 sec) sto = -1; if (--nsto <= 0) { sto = (Long_t) actto; nsto = 60; } } // If timed-out, deactivate the remaining sockets if (nto == 0) { TList *al = mon->GetListOfActives(); if (al && al->GetSize() > 0) { // Notify the name of those which did timeout Info("Collect"," %d node(s) went in timeout:", al->GetSize()); TIter nxs(al); TSocket *xs = 0; while ((xs = (TSocket *)nxs())) { TSlave *wrk = FindSlave(xs); if (wrk) Info("Collect"," %s", wrk->GetName()); else Info("Collect"," %p: %s:%d", xs, xs->GetInetAddress().GetHostName(), xs->GetInetAddress().GetPort()); } } mon->DeActivateAll(); } // Deactivate Ctrl-C special handler if (fIntHandler) fIntHandler->Remove(); // make sure group view is up to date SendGroupView(); // Restore redirection setting fRedirLog = saveRedirLog; // Restore the monitor fCurrentMonitor = savedMonitor; ActivateAsyncInput(); return cnt; } //______________________________________________________________________________ void TProof::CleanGDirectory(TList *ol) { // Remove links to objects in list 'ol' from gDirectory if (ol) { TIter nxo(ol); TObject *o = 0; while ((o = nxo())) gDirectory->RecursiveRemove(o); } } //______________________________________________________________________________ Int_t TProof::CollectInputFrom(TSocket *s, Int_t endtype) { // Collect and analyze available input from socket s. // Returns 0 on success, -1 if any failure occurs. TMessage *mess; Int_t recvrc = 0; if ((recvrc = s->Recv(mess)) < 0) { PDB(kGlobal,2) Info("CollectInputFrom","%p: got %d from Recv()", s, recvrc); Bool_t bad = kTRUE; if (recvrc == -5) { // Broken connection: try reconnection if (fCurrentMonitor) fCurrentMonitor->Remove(s); if (s->Reconnect() == 0) { if (fCurrentMonitor) fCurrentMonitor->Add(s); bad = kFALSE; } } if (bad) MarkBad(s, "problems receiving a message in TProof::CollectInputFrom(...)"); // Ignore this wake up return -1; } if (!mess) { // we get here in case the remote server died MarkBad(s, "undefined message in TProof::CollectInputFrom(...)"); return -1; } Int_t rc = 0; Int_t what = mess->What(); TSlave *sl = FindSlave(s); rc = HandleInputMessage(sl, mess); if (rc == 1 && (endtype >= 0) && (what != endtype)) // This message was for the base monitor in recursive case rc = 2; // We are done successfully return rc; } //______________________________________________________________________________ Int_t TProof::HandleInputMessage(TSlave *sl, TMessage *mess) { // Analyze the received message. // Returns 0 on success (1 if this the last message from this socket), -1 if // any failure occurs. char str[512]; TObject *obj; Int_t rc = 0; if (!mess || !sl) { Warning("HandleInputMessage", "given an empty message or undefined worker"); return -1; } Bool_t delete_mess = kTRUE; TSocket *s = sl->GetSocket(); if (!s) { Warning("HandleInputMessage", "worker socket is undefined"); return -1; } // The message type Int_t what = mess->What(); PDB(kGlobal,3) Info("HandleInputMessage", "got type %d from '%s'", what, (sl ? sl->GetOrdinal() : "undef")); switch (what) { case kMESS_OK: // Add the message to the list fRecvMessages->Add(mess); delete_mess = kFALSE; break; case kMESS_OBJECT: if (fPlayer) fPlayer->HandleRecvHisto(mess); break; case kPROOF_FATAL: MarkBad(s, "received kPROOF_FATAL"); if (fProgressDialogStarted) { // Finalize the progress dialog Emit("StopProcess(Bool_t)", kTRUE); } break; case kPROOF_STOP: // Stop collection from this worker Info("HandleInputMessage", "received kPROOF_STOP from %s: disabling any further collection this worker", (sl ? sl->GetOrdinal() : "undef")); rc = 1; break; case kPROOF_GETTREEHEADER: // Add the message to the list fRecvMessages->Add(mess); delete_mess = kFALSE; rc = 1; break; case kPROOF_TOUCH: // send a request for touching the remote admin file { sl->Touch(); } break; case kPROOF_GETOBJECT: // send slave object it asks for mess->ReadString(str, sizeof(str)); obj = gDirectory->Get(str); if (obj) s->SendObject(obj); else s->Send(kMESS_NOTOK); break; case kPROOF_GETPACKET: { TDSetElement *elem = 0; elem = fPlayer ? fPlayer->GetNextPacket(sl, mess) : 0; if (elem != (TDSetElement*) -1) { TMessage answ(kPROOF_GETPACKET); answ << elem; s->Send(answ); while (fWaitingSlaves != 0 && fWaitingSlaves->GetSize()) { TPair *p = (TPair*) fWaitingSlaves->First(); s = (TSocket*) p->Key(); TMessage *m = (TMessage*) p->Value(); elem = fPlayer->GetNextPacket(sl, m); if (elem != (TDSetElement*) -1) { TMessage a(kPROOF_GETPACKET); a << elem; s->Send(a); // remove has to happen via Links because TPair does not have // a Compare() function and therefore RemoveFirst() and // Remove(TObject*) do not work fWaitingSlaves->Remove(fWaitingSlaves->FirstLink()); delete p; delete m; } else { break; } } } else { if (fWaitingSlaves == 0) fWaitingSlaves = new TList; fWaitingSlaves->Add(new TPair(s, mess)); delete_mess = kFALSE; } } break; case kPROOF_LOGFILE: { Int_t size; (*mess) >> size; PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_LOGFILE: size: %d", size); RecvLogFile(s, size); } break; case kPROOF_LOGDONE: (*mess) >> sl->fStatus >> sl->fParallel; PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_LOGDONE:%s: status %d parallel %d", sl->GetOrdinal(), sl->fStatus, sl->fParallel); if (sl->fStatus != 0) fStatus = sl->fStatus; //return last nonzero status rc = 1; break; case kPROOF_GETSTATS: { (*mess) >> sl->fBytesRead >> sl->fRealTime >> sl->fCpuTime >> sl->fWorkDir >> sl->fProofWorkDir; TString img; if ((mess->BufferSize() > mess->Length())) (*mess) >> img; // Set image if (img.IsNull()) { if (sl->fImage.IsNull()) sl->fImage = Form("%s:%s", TUrl(sl->fName).GetHostFQDN(), sl->fProofWorkDir.Data()); } else { sl->fImage = img; } PDB(kGlobal,2) Info("HandleInputMessage", "kPROOF_GETSTATS:%s image: %s", sl->GetOrdinal(), sl->GetImage()); fBytesRead += sl->fBytesRead; fRealTime += sl->fRealTime; fCpuTime += sl->fCpuTime; rc = 1; } break; case kPROOF_GETPARALLEL: { Bool_t async = kFALSE; (*mess) >> sl->fParallel; if ((mess->BufferSize() > mess->Length())) (*mess) >> async; rc = (async) ? 0 : 1; } break; case kPROOF_CHECKFILE: { // New servers (>= 5.22) send the status if ((mess->BufferSize() > mess->Length())) { (*mess) >> fCheckFileStatus; } else { // Form old servers this meant success (failure was signaled with the // dangerous kPROOF_FATAL) fCheckFileStatus = 1; } rc = 1; } break; case kPROOF_SENDFILE: { // New server: signals ending of sendfile operation rc = 1; } break; case kPROOF_PACKAGE_LIST: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_PACKAGE_LIST: enter"); Int_t type = 0; (*mess) >> type; switch (type) { case TProof::kListEnabledPackages: SafeDelete(fEnabledPackages); fEnabledPackages = (TList *) mess->ReadObject(TList::Class()); if (fEnabledPackages) { fEnabledPackages->SetOwner(); } else { Error("HandleInputMessage", "kPROOF_PACKAGE_LIST: kListEnabledPackages: TList not found in message!"); } break; case TProof::kListPackages: SafeDelete(fAvailablePackages); fAvailablePackages = (TList *) mess->ReadObject(TList::Class()); if (fAvailablePackages) { fAvailablePackages->SetOwner(); } else { Error("HandleInputMessage", "kPROOF_PACKAGE_LIST: kListPackages: TList not found in message!"); } break; default: Error("HandleInputMessage", "kPROOF_PACKAGE_LIST: unknown type: %d", type); } } break; case kPROOF_OUTPUTOBJECT: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_OUTPUTOBJECT: enter"); Int_t type = 0; while ((mess->BufferSize() > mess->Length())) { (*mess) >> type; // If a query result header, add it to the player list if (fPlayer) { if (type == 0) { // Retrieve query result instance (output list not filled) TQueryResult *pq = (TQueryResult *) mess->ReadObject(TQueryResult::Class()); if (pq) { // Add query to the result list in TProofPlayer fPlayer->AddQueryResult(pq); fPlayer->SetCurrentQuery(pq); // And clear the output list, as we start merging a new set of results if (fPlayer->GetOutputList()) fPlayer->GetOutputList()->Clear(); // Add the unique query tag as TNamed object to the input list // so that it is available in TSelectors for monitoring fPlayer->AddInput(new TNamed("PROOF_QueryTag", Form("%s:%s",pq->GetTitle(),pq->GetName()))); } else { Warning("HandleInputMessage","kPROOF_OUTPUTOBJECT: query result missing"); } } else if (type > 0) { // Read object TObject *o = mess->ReadObject(TObject::Class()); // Increment counter on the client side if (gProofServ) { fMergePrg.IncreaseIdx(); TString msg; msg.Form("%s: merging output objects ... %s", gProofServ->GetPrefix(), fMergePrg.Export()); gProofServ->SendAsynMessage(msg.Data(), kFALSE); } // Add or merge it if ((fPlayer->AddOutputObject(o) == 1)) { // Remove the object if it has been merged SafeDelete(o); } if (type > 1) { // Update the merger progress info fMergePrg.DecreaseNWrks(); if (TestBit(TProof::kIsClient) && !IsLite()) { // In PROOFLite this has to be done once only in TProofLite::Process TQueryResult *pq = fPlayer->GetCurrentQuery(); pq->SetOutputList(fPlayer->GetOutputList(), kFALSE); pq->SetInputList(fPlayer->GetInputList(), kFALSE); // If the last object, notify the GUI that the result arrived QueryResultReady(Form("%s:%s", pq->GetTitle(), pq->GetName())); // Processing is over UpdateDialog(); } } } } else { Warning("HandleInputMessage", "kPROOF_OUTPUTOBJECT: player undefined!"); } } } break; case kPROOF_OUTPUTLIST: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_OUTPUTLIST: enter"); TList *out = 0; if (fPlayer) { if (TestBit(TProof::kIsMaster) || fProtocol < 7) { out = (TList *) mess->ReadObject(TList::Class()); } else { TQueryResult *pq = (TQueryResult *) mess->ReadObject(TQueryResult::Class()); if (pq) { // Add query to the result list in TProofPlayer fPlayer->AddQueryResult(pq); fPlayer->SetCurrentQuery(pq); // To avoid accidental cleanups from anywhere else // remove objects from gDirectory and clone the list out = pq->GetOutputList(); CleanGDirectory(out); out = (TList *) out->Clone(); // Notify the GUI that the result arrived QueryResultReady(Form("%s:%s", pq->GetTitle(), pq->GetName())); } else { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_OUTPUTLIST: query result missing"); } } if (out) { out->SetOwner(); fPlayer->AddOutput(out); // Incorporate the list SafeDelete(out); } else { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_OUTPUTLIST: ouputlist is empty"); } } else { Warning("HandleInputMessage", "kPROOF_OUTPUTLIST: player undefined!"); } // On clients at this point processing is over if (TestBit(TProof::kIsClient) && !IsLite()) UpdateDialog(); } break; case kPROOF_QUERYLIST: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_QUERYLIST: enter"); (*mess) >> fOtherQueries >> fDrawQueries; if (fQueries) { fQueries->Delete(); delete fQueries; fQueries = 0; } fQueries = (TList *) mess->ReadObject(TList::Class()); } break; case kPROOF_RETRIEVE: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_RETRIEVE: enter"); TQueryResult *pq = (TQueryResult *) mess->ReadObject(TQueryResult::Class()); if (pq && fPlayer) { fPlayer->AddQueryResult(pq); // Notify the GUI that the result arrived QueryResultReady(Form("%s:%s", pq->GetTitle(), pq->GetName())); } else { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_RETRIEVE: query result missing or player undefined"); } } break; case kPROOF_MAXQUERIES: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_MAXQUERIES: enter"); Int_t max = 0; (*mess) >> max; Printf("Number of queries fully kept remotely: %d", max); } break; case kPROOF_SERVERSTARTED: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_SERVERSTARTED: enter"); UInt_t tot = 0, done = 0; TString action; Bool_t st = kTRUE; (*mess) >> action >> tot >> done >> st; if (TestBit(TProof::kIsClient)) { if (tot) { TString type = (action.Contains("submas")) ? "submasters" : "workers"; Int_t frac = (Int_t) (done*100.)/tot; char msg[512] = {0}; if (frac >= 100) { sprintf(msg,"%s: OK (%d %s) \n", action.Data(),tot, type.Data()); } else { sprintf(msg,"%s: %d out of %d (%d %%)\r", action.Data(), done, tot, frac); } if (fSync) fprintf(stderr,"%s", msg); else NotifyLogMsg(msg, 0); } // Notify GUIs StartupMessage(action.Data(), st, (Int_t)done, (Int_t)tot); } else { // Just send the message one level up TMessage m(kPROOF_SERVERSTARTED); m << action << tot << done << st; gProofServ->GetSocket()->Send(m); } } break; case kPROOF_DATASET_STATUS: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_DATASET_STATUS: enter"); UInt_t tot = 0, done = 0; TString action; Bool_t st = kTRUE; (*mess) >> action >> tot >> done >> st; if (TestBit(TProof::kIsClient)) { if (tot) { TString type = "files"; Int_t frac = (Int_t) (done*100.)/tot; char msg[512] = {0}; if (frac >= 100) { sprintf(msg,"%s: OK (%d %s) \n", action.Data(),tot, type.Data()); } else { sprintf(msg,"%s: %d out of %d (%d %%)\r", action.Data(), done, tot, frac); } if (fSync) fprintf(stderr,"%s", msg); else NotifyLogMsg(msg, 0); } // Notify GUIs DataSetStatus(action.Data(), st, (Int_t)done, (Int_t)tot); } else { // Just send the message one level up TMessage m(kPROOF_DATASET_STATUS); m << action << tot << done << st; gProofServ->GetSocket()->Send(m); } } break; case kPROOF_STARTPROCESS: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_STARTPROCESS: enter"); // For Proof-Lite this variable is the number of workers and is set // by the player if (!IsLite()) { fNotIdle = 1; fIsWaiting = kFALSE; } // Redirect the output, if needed fRedirLog = (fSync) ? fRedirLog : kTRUE; // The signal is used on masters by XrdProofdProtocol to catch // the start of processing; on clients it allows to update the // progress dialog if (!TestBit(TProof::kIsMaster)) { TString selec; Int_t dsz = -1; Long64_t first = -1, nent = -1; (*mess) >> selec >> dsz >> first >> nent; // Start or reset the progress dialog if (!gROOT->IsBatch()) { if (fProgressDialog && !TestBit(kUsingSessionGui)) { if (!fProgressDialogStarted) { fProgressDialog->ExecPlugin(5, this, selec.Data(), dsz, first, nent); fProgressDialogStarted = kTRUE; } else { ResetProgressDialog(selec, dsz, first, nent); } } ResetBit(kUsingSessionGui); } } } break; case kPROOF_ENDINIT: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_ENDINIT: enter"); if (TestBit(TProof::kIsMaster)) { if (fPlayer) fPlayer->SetInitTime(); } } break; case kPROOF_SETIDLE: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_SETIDLE: enter"); // The session is idle if (IsLite()) { if (fNotIdle > 0) { fNotIdle--; } else { Warning("HandleInputMessage", "got kPROOF_SETIDLE but no running workers ! protocol error?"); } } else { fNotIdle = 0; // Check if the query has been enqueued if ((mess->BufferSize() > mess->Length())) (*mess) >> fIsWaiting; } } break; case kPROOF_QUERYSUBMITTED: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_QUERYSUBMITTED: enter"); // We have received the sequential number (*mess) >> fSeqNum; Bool_t sync = fSync; if ((mess->BufferSize() > mess->Length())) (*mess) >> sync; if (sync != fSync && fSync) { // The server required to switch to asynchronous mode Activate(); fSync = kFALSE; } DisableGoAsyn(); // Check if the query has been enqueued fIsWaiting = kTRUE; // For Proof-Lite this variable is the number of workers and is set by the player if (!IsLite()) fNotIdle = 1; rc = 1; } break; case kPROOF_SESSIONTAG: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_SESSIONTAG: enter"); // We have received the unique tag and save it as name of this object TString stag; (*mess) >> stag; SetName(stag); } break; case kPROOF_FEEDBACK: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_FEEDBACK: enter"); TList *out = (TList *) mess->ReadObject(TList::Class()); out->SetOwner(); if (fPlayer) fPlayer->StoreFeedback(sl, out); // Adopts the list else // Not yet ready: stop collect asap rc = 1; } break; case kPROOF_AUTOBIN: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_AUTOBIN: enter"); TString name; Double_t xmin, xmax, ymin, ymax, zmin, zmax; (*mess) >> name >> xmin >> xmax >> ymin >> ymax >> zmin >> zmax; if (fPlayer) fPlayer->UpdateAutoBin(name,xmin,xmax,ymin,ymax,zmin,zmax); TMessage answ(kPROOF_AUTOBIN); answ << name << xmin << xmax << ymin << ymax << zmin << zmax; s->Send(answ); } break; case kPROOF_PROGRESS: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_PROGRESS: enter"); if (GetRemoteProtocol() > 11) { // New format Long64_t total, processed, bytesread; Float_t initTime, procTime, evtrti, mbrti; (*mess) >> total >> processed >> bytesread >> initTime >> procTime >> evtrti >> mbrti; if (fPlayer) fPlayer->Progress(sl, total, processed, bytesread, initTime, procTime, evtrti, mbrti); } else { // Old format Long64_t total, processed; (*mess) >> total >> processed; if (fPlayer) fPlayer->Progress(sl, total, processed); } } break; case kPROOF_STOPPROCESS: { // This message is sent from a worker that finished processing. // We determine whether it was asked to finish by the // packetizer or stopped during processing a packet // (by TProof::RemoveWorkers() or by an external signal). // In the later case call packetizer->MarkBad. PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_STOPPROCESS: enter"); Long64_t events = 0; Bool_t abort = kFALSE; TProofProgressStatus *status = 0; if ((mess->BufferSize() > mess->Length()) && (fProtocol > 18)) { (*mess) >> status >> abort; } else if ((mess->BufferSize() > mess->Length()) && (fProtocol > 8)) { (*mess) >> events >> abort; } else { (*mess) >> events; } if (!abort && fPlayer) { if (fProtocol > 18) { TList *listOfMissingFiles = 0; if (!(listOfMissingFiles = (TList *)GetOutput("MissingFiles"))) { listOfMissingFiles = new TList(); listOfMissingFiles->SetName("MissingFiles"); if (fPlayer) fPlayer->AddOutputObject(listOfMissingFiles); } if (fPlayer->GetPacketizer()) { Int_t ret = fPlayer->GetPacketizer()->AddProcessed(sl, status, 0, &listOfMissingFiles); if (ret > 0) fPlayer->GetPacketizer()->MarkBad(sl, status, &listOfMissingFiles); // This object is now owned by the packetizer status = 0; } } else { fPlayer->AddEventsProcessed(events); } } SafeDelete(status); if (!TestBit(TProof::kIsMaster)) Emit("StopProcess(Bool_t)", abort); break; } case kPROOF_GETSLAVEINFO: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_GETSLAVEINFO: enter"); Bool_t active = (GetListOfActiveSlaves()->FindObject(sl) != 0); Bool_t bad = (GetListOfBadSlaves()->FindObject(sl) != 0); TList* tmpinfo = 0; (*mess) >> tmpinfo; if (tmpinfo == 0) { Error("HandleInputMessage","kPROOF_GETSLAVEINFO: no list received!"); } else { tmpinfo->SetOwner(kFALSE); Int_t nentries = tmpinfo->GetSize(); for (Int_t i=0; i<nentries; i++) { TSlaveInfo* slinfo = dynamic_cast<TSlaveInfo*>(tmpinfo->At(i)); if (slinfo) { fSlaveInfo->Add(slinfo); if (slinfo->fStatus != TSlaveInfo::kBad) { if (!active) slinfo->SetStatus(TSlaveInfo::kNotActive); if (bad) slinfo->SetStatus(TSlaveInfo::kBad); } if (sl->GetMsd() && (strlen(sl->GetMsd()) > 0)) slinfo->fMsd = sl->GetMsd(); } } delete tmpinfo; rc = 1; } } break; case kPROOF_VALIDATE_DSET: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_VALIDATE_DSET: enter"); TDSet* dset = 0; (*mess) >> dset; if (!fDSet) Error("HandleInputMessage","kPROOF_VALIDATE_DSET: fDSet not set"); else fDSet->Validate(dset); delete dset; } break; case kPROOF_DATA_READY: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_DATA_READY: enter"); Bool_t dataready = kFALSE; Long64_t totalbytes, bytesready; (*mess) >> dataready >> totalbytes >> bytesready; fTotalBytes += totalbytes; fBytesReady += bytesready; if (dataready == kFALSE) fDataReady = dataready; } break; case kPROOF_PING: // do nothing (ping is already acknowledged) break; case kPROOF_MESSAGE: { PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_MESSAGE: enter"); // We have received the unique tag and save it as name of this object TString msg; (*mess) >> msg; Bool_t lfeed = kTRUE; if ((mess->BufferSize() > mess->Length())) (*mess) >> lfeed; if (TestBit(TProof::kIsClient)) { if (fSync) { // Notify locally fprintf(stderr,"%s%c", msg.Data(), (lfeed ? '\n' : '\r')); } else { // Notify locally taking care of redirection, windows logs, ... NotifyLogMsg(msg, (lfeed ? "\n" : "\r")); } } else { // The message is logged for debugging purposes. fprintf(stderr,"%s%c", msg.Data(), (lfeed ? '\n' : '\r')); if (gProofServ) { // We hide it during normal operations gProofServ->FlushLogFile(); // And send the message one level up gProofServ->SendAsynMessage(msg, lfeed); } } } break; case kPROOF_VERSARCHCOMP: { TString vac; (*mess) >> vac; PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_VERSARCHCOMP: %s", vac.Data()); Int_t from = 0; TString vers, archcomp; if (vac.Tokenize(vers, from, "|")) vac.Tokenize(archcomp, from, "|"); sl->SetArchCompiler(archcomp); vers.ReplaceAll(":","|"); sl->SetROOTVersion(vers); } break; default: { Error("HandleInputMessage", "unknown command received from '%s' (what = %d)", (sl ? sl->GetOrdinal() : "undef"), what); } break; } // Cleanup if (delete_mess) delete mess; // We are done successfully return rc; } //______________________________________________________________________________ void TProof::UpdateDialog() { // Final update of the progress dialog if (!fPlayer) return; // Handle abort ... if (fPlayer->GetExitStatus() == TVirtualProofPlayer::kAborted) { if (fSync) Info("UpdateDialog", "processing was aborted - %lld events processed", fPlayer->GetEventsProcessed()); if (GetRemoteProtocol() > 11) { // New format Progress(-1, fPlayer->GetEventsProcessed(), -1, -1., -1., -1., -1.); } else { Progress(-1, fPlayer->GetEventsProcessed()); } Emit("StopProcess(Bool_t)", kTRUE); } // Handle stop ... if (fPlayer->GetExitStatus() == TVirtualProofPlayer::kStopped) { if (fSync) Info("UpdateDialog", "processing was stopped - %lld events processed", fPlayer->GetEventsProcessed()); if (GetRemoteProtocol() > 11) { // New format Progress(-1, fPlayer->GetEventsProcessed(), -1, -1., -1., -1., -1.); } else { Progress(-1, fPlayer->GetEventsProcessed()); } Emit("StopProcess(Bool_t)", kFALSE); } // Final update of the dialog box if (GetRemoteProtocol() > 11) { // New format EmitVA("Progress(Long64_t,Long64_t,Long64_t,Float_t,Float_t,Float_t,Float_t)", 7, (Long64_t)(-1), (Long64_t)(-1), (Long64_t)(-1), (Float_t)(-1.),(Float_t)(-1.),(Float_t)(-1.),(Float_t)(-1.)); } else { EmitVA("Progress(Long64_t,Long64_t)", 2, (Long64_t)(-1), (Long64_t)(-1)); } } //______________________________________________________________________________ void TProof::ActivateAsyncInput() { // Activate the a-sync input handler. TIter next(fSlaves); TSlave *sl; while ((sl = (TSlave*) next())) if (sl->GetInputHandler()) sl->GetInputHandler()->Add(); } //______________________________________________________________________________ void TProof::DeActivateAsyncInput() { // De-actiate a-sync input handler. TIter next(fSlaves); TSlave *sl; while ((sl = (TSlave*) next())) if (sl->GetInputHandler()) sl->GetInputHandler()->Remove(); } //______________________________________________________________________________ void TProof::MarkBad(TSlave *wrk, const char *reason) { // Add a bad slave server to the bad slave list and remove it from // the active list and from the two monitor objects. Assume that the work // done by this worker was lost and ask packerizer to reassign it. R__LOCKGUARD2(fCloseMutex); // We may have been invalidated in the meanwhile: nothing to do in such a case if (!IsValid()) return; if (!wrk) { Error("MarkBad", "worker instance undefined: protocol error? "); return; } // Local URL static TString thisurl; if (thisurl.IsNull()) { if (IsMaster()) { Int_t port = gEnv->GetValue("ProofServ.XpdPort",-1); thisurl = (port > 0) ? Form("%s:%d", TUrl(gSystem->HostName()).GetHostFQDN(), port) : TUrl(gSystem->HostName()).GetHostFQDN(); } else { thisurl = Form("%s@%s:%d", fUrl.GetUser(), fUrl.GetHost(), fUrl.GetPort()); } } if (!reason || strcmp(reason, kPROOF_TerminateWorker)) { // Message for notification const char *mastertype = (gProofServ && gProofServ->IsTopMaster()) ? "top master" : "master"; TString src = IsMaster() ? Form("%s at %s", mastertype, thisurl.Data()) : "local session"; TString msg(Form("\n +++ Message from %s : ", src.Data())); msg += Form("marking %s:%d (%s) as bad\n +++ Reason: %s", wrk->GetName(), wrk->GetPort(), wrk->GetOrdinal(), (reason && strlen(reason)) ? reason : "unknown"); Info("MarkBad", "%s", msg.Data()); // Notify one level up, if the case // Add some hint for diagnostics if (gProofServ) { msg += Form("\n\n +++ Most likely your code crashed on worker %s at %s:%d.\n", wrk->GetOrdinal(), wrk->GetName(), wrk->GetPort()); } else { msg = Form("\n\n +++ Most likely your code crashed\n"); } msg += Form(" +++ Please check the session logs for error messages either using\n"); msg += Form(" +++ the 'Show logs' button or executing\n"); msg += Form(" +++\n"); if (gProofServ) { msg += Form(" +++ root [] TProof::Mgr(\"%s\")->GetSessionLogs()->Display(\"%s\",0)\n\n", thisurl.Data(), wrk->GetOrdinal()); gProofServ->SendAsynMessage(msg, kTRUE); } else { msg += Form(" +++ root [] TProof::Mgr(\"%s\")->GetSessionLogs()->Display(\"*\")\n\n", thisurl.Data()); Printf("%s", msg.Data()); } } else if (reason) { if (gDebug > 0) { Info("MarkBad", "worker %s at %s:%d asked to terminate", wrk->GetOrdinal(), wrk->GetName(), wrk->GetPort()); } } if (IsMaster() && reason) { if (strcmp(reason, kPROOF_TerminateWorker)) { // if the reason was not a planned termination TList *listOfMissingFiles = 0; if (!(listOfMissingFiles = (TList *)GetOutput("MissingFiles"))) { listOfMissingFiles = new TList(); listOfMissingFiles->SetName("MissingFiles"); if (fPlayer) fPlayer->AddOutputObject(listOfMissingFiles); } // If a query is being processed, assume that the work done by // the worker was lost and needs to be reassigned. TVirtualPacketizer *packetizer = fPlayer ? fPlayer->GetPacketizer() : 0; if (packetizer) { // the worker was lost so do resubmit the packets packetizer->MarkBad(wrk, 0, &listOfMissingFiles); } } else { // Tell the coordinator that we are gone if (gProofServ) { TString ord(wrk->GetOrdinal()); Int_t id = ord.Last('.'); if (id != kNPOS) ord.Remove(0, id+1); gProofServ->ReleaseWorker(ord.Data()); } } } fActiveSlaves->Remove(wrk); FindUniqueSlaves(); fAllMonitor->Remove(wrk->GetSocket()); fActiveMonitor->Remove(wrk->GetSocket()); fSendGroupView = kTRUE; if (IsMaster()) { if (reason && !strcmp(reason, kPROOF_TerminateWorker)) { // if the reason was a planned termination then delete the worker and // remove it from all the lists fSlaves->Remove(wrk); fBadSlaves->Remove(wrk); fActiveSlaves->Remove(wrk); fInactiveSlaves->Remove(wrk); fUniqueSlaves->Remove(wrk); fAllUniqueSlaves->Remove(wrk); fNonUniqueMasters->Remove(wrk); delete wrk; } else { fBadSlaves->Add(wrk); wrk->Close(); } // Update session workers files SaveWorkerInfo(); } else { // On clients the proof session should be removed from the lists // and deleted, since it is not valid anymore fSlaves->Remove(wrk); if (fManager) fManager->DiscardSession(this); } } //______________________________________________________________________________ void TProof::MarkBad(TSocket *s, const char *reason) { // Add slave with socket s to the bad slave list and remove if from // the active list and from the two monitor objects. R__LOCKGUARD2(fCloseMutex); // We may have been invalidated in the meanwhile: nothing to do in such a case if (!IsValid()) return; TSlave *wrk = FindSlave(s); MarkBad(wrk, reason); } //______________________________________________________________________________ void TProof::TerminateWorker(TSlave *wrk) { // Ask an active worker 'wrk' to terminate, i.e. to shutdown if (!wrk) { Warning("TerminateWorker", "worker instance undefined: protocol error? "); return; } // Send stop message if (wrk->GetSocket() && wrk->GetSocket()->IsValid()) { TMessage mess(kPROOF_STOP); wrk->GetSocket()->Send(mess); } else { if (gDebug > 0) Info("TerminateWorker", "connection to worker is already down: cannot" " send termination message"); } // This is a bad worker from now on MarkBad(wrk, kPROOF_TerminateWorker); } //______________________________________________________________________________ void TProof::TerminateWorker(const char *ord) { // Ask an active worker 'ord' to terminate, i.e. to shutdown if (ord && strlen(ord) > 0) { Bool_t all = (ord[0] == '*') ? kTRUE : kFALSE; if (IsMaster()) { TIter nxw(fSlaves); TSlave *wrk = 0; while ((wrk = (TSlave *)nxw())) { if (all || !strcmp(wrk->GetOrdinal(), ord)) { TerminateWorker(wrk); if (!all) break; } } } else { TMessage mess(kPROOF_STOP); mess << TString(ord); Broadcast(mess); } } } //______________________________________________________________________________ Int_t TProof::Ping() { // Ping PROOF. Returns 1 if master server responded. return Ping(kActive); } //______________________________________________________________________________ Int_t TProof::Ping(ESlaves list) { // Ping PROOF slaves. Returns the number of slaves that responded. TList *slaves = 0; if (list == kAll) slaves = fSlaves; if (list == kActive) slaves = fActiveSlaves; if (list == kUnique) slaves = fUniqueSlaves; if (list == kAllUnique) slaves = fAllUniqueSlaves; if (slaves->GetSize() == 0) return 0; int nsent = 0; TIter next(slaves); TSlave *sl; while ((sl = (TSlave *)next())) { if (sl->IsValid()) { if (sl->Ping() == -1) { MarkBad(sl, "ping unsuccessful"); } else { nsent++; } } } return nsent; } //______________________________________________________________________________ void TProof::Touch() { // Ping PROOF slaves. Returns the number of slaves that responded. TList *slaves = fSlaves; if (slaves->GetSize() == 0) return; TIter next(slaves); TSlave *sl; while ((sl = (TSlave *)next())) { if (sl->IsValid()) { sl->Touch(); } } return; } //______________________________________________________________________________ void TProof::Print(Option_t *option) const { // Print status of PROOF cluster. TString secCont; if (TestBit(TProof::kIsClient)) { Printf("Connected to: %s (%s)", GetMaster(), IsValid() ? "valid" : "invalid"); Printf("Port number: %d", GetPort()); Printf("User: %s", GetUser()); if (gROOT->GetSvnRevision() > 0) Printf("ROOT version|rev: %s|r%d", gROOT->GetVersion(), gROOT->GetSvnRevision()); else Printf("ROOT version: %s", gROOT->GetVersion()); Printf("Architecture-Compiler: %s-%s", gSystem->GetBuildArch(), gSystem->GetBuildCompilerVersion()); TSlave *sl = (TSlave *)fActiveSlaves->First(); if (sl) { TString sc; if (sl->GetSocket()->GetSecContext()) Printf("Security context: %s", sl->GetSocket()->GetSecContext()->AsString(sc)); Printf("Proofd protocol version: %d", sl->GetSocket()->GetRemoteProtocol()); } else { Printf("Security context: Error - No connection"); Printf("Proofd protocol version: Error - No connection"); } Printf("Client protocol version: %d", GetClientProtocol()); Printf("Remote protocol version: %d", GetRemoteProtocol()); Printf("Log level: %d", GetLogLevel()); Printf("Session unique tag: %s", IsValid() ? GetSessionTag() : ""); Printf("Default data pool: %s", IsValid() ? GetDataPoolUrl() : ""); if (IsValid()) const_cast<TProof*>(this)->SendPrint(option); } else { const_cast<TProof*>(this)->AskStatistics(); if (IsParallel()) Printf("*** Master server %s (parallel mode, %d workers):", gProofServ->GetOrdinal(), GetParallel()); else Printf("*** Master server %s (sequential mode):", gProofServ->GetOrdinal()); Printf("Master host name: %s", gSystem->HostName()); Printf("Port number: %d", GetPort()); if (strlen(gProofServ->GetGroup()) > 0) { Printf("User/Group: %s/%s", GetUser(), gProofServ->GetGroup()); } else { Printf("User: %s", GetUser()); } TString ver(gROOT->GetVersion()); if (gROOT->GetSvnRevision() > 0) ver += Form("|r%d", gROOT->GetSvnRevision()); if (gSystem->Getenv("ROOTVERSIONTAG")) ver += Form("|%s", gSystem->Getenv("ROOTVERSIONTAG")); Printf("ROOT version|rev|tag: %s", ver.Data()); Printf("Architecture-Compiler: %s-%s", gSystem->GetBuildArch(), gSystem->GetBuildCompilerVersion()); Printf("Protocol version: %d", GetClientProtocol()); Printf("Image name: %s", GetImage()); Printf("Working directory: %s", gSystem->WorkingDirectory()); Printf("Config directory: %s", GetConfDir()); Printf("Config file: %s", GetConfFile()); Printf("Log level: %d", GetLogLevel()); Printf("Number of workers: %d", GetNumberOfSlaves()); Printf("Number of active workers: %d", GetNumberOfActiveSlaves()); Printf("Number of unique workers: %d", GetNumberOfUniqueSlaves()); Printf("Number of inactive workers: %d", GetNumberOfInactiveSlaves()); Printf("Number of bad workers: %d", GetNumberOfBadSlaves()); Printf("Total MB's processed: %.2f", float(GetBytesRead())/(1024*1024)); Printf("Total real time used (s): %.3f", GetRealTime()); Printf("Total CPU time used (s): %.3f", GetCpuTime()); if (TString(option).Contains("a", TString::kIgnoreCase) && GetNumberOfSlaves()) { Printf("List of workers:"); TList masters; TIter nextslave(fSlaves); while (TSlave* sl = dynamic_cast<TSlave*>(nextslave())) { if (!sl->IsValid()) continue; if (sl->GetSlaveType() == TSlave::kSlave) { sl->Print(option); } else if (sl->GetSlaveType() == TSlave::kMaster) { TMessage mess(kPROOF_PRINT); mess.WriteString(option); if (sl->GetSocket()->Send(mess) == -1) const_cast<TProof*>(this)->MarkBad(sl, "could not send kPROOF_PRINT request"); else masters.Add(sl); } else { Error("Print", "TSlave is neither Master nor Worker"); R__ASSERT(0); } } const_cast<TProof*>(this)->Collect(&masters, fCollectTimeout); } } } //______________________________________________________________________________ Long64_t TProof::Process(TDSet *dset, const char *selector, Option_t *option, Long64_t nentries, Long64_t first) { // Process a data set (TDSet) using the specified selector (.C) file. // Entry- or event-lists should be set in the data set object using // TDSet::SetEntryList. // The return value is -1 in case of error and TSelector::GetStatus() in // in case of success. if (!IsValid() || !fPlayer) return -1; // Set PROOF to running state SetRunStatus(TProof::kRunning); // Resolve query mode fSync = (GetQueryMode(option) == kSync); TString opt(option); if (fSync && (!IsIdle() || IsWaiting())) { // Already queued or processing queries: switch to asynchronous mode Info("Process", "session is in waiting or processing status: switch to asynchronous mode"); fSync = kFALSE; opt.ReplaceAll("SYNC",""); opt += "ASYN"; } // Cleanup old temporary datasets if ((IsIdle() && !IsWaiting()) && fRunningDSets && fRunningDSets->GetSize() > 0) { fRunningDSets->SetOwner(kTRUE); fRunningDSets->Delete(); } // deactivate the default application interrupt handler // ctrl-c's will be forwarded to PROOF to stop the processing TSignalHandler *sh = 0; if (fSync) { if (gApplication) sh = gSystem->RemoveSignalHandler(gApplication->GetSignalHandler()); } Long64_t rv = fPlayer->Process(dset, selector, opt.Data(), nentries, first); if (fSync) { // reactivate the default application interrupt handler if (sh) gSystem->AddSignalHandler(sh); } return rv; } //______________________________________________________________________________ Long64_t TProof::Process(TFileCollection *fc, const char *selector, Option_t *option, Long64_t nentries, Long64_t first) { // Process a data set (TFileCollection) using the specified selector (.C) file. // The default tree is analyzed (i.e. the first one found). To specify another // tree, the default tree can be changed using TFileCollection::SetDefaultMetaData . // The return value is -1 in case of error and TSelector::GetStatus() in // in case of success. if (!IsValid() || !fPlayer) return -1; if (fProtocol < 17) { Info("Process", "server version < 5.18/00:" " processing of TFileCollection not supported"); return -1; } // We include the TFileCollection to the input list and we create a // fake TDSet with infor about it TDSet *dset = new TDSet(Form("TFileCollection:%s", fc->GetName()), 0, 0, ""); fPlayer->AddInput(fc); Long64_t retval = Process(dset, selector, option, nentries, first); fPlayer->GetInputList()->Remove(fc); // To avoid problems in future // Cleanup if (IsLite() && !fSync) { if (!fRunningDSets) fRunningDSets = new TList; fRunningDSets->Add(dset); } else { delete dset; } return retval; } //______________________________________________________________________________ Long64_t TProof::Process(const char *dsetname, const char *selector, Option_t *option, Long64_t nentries, Long64_t first, TObject *enl) { // Process a dataset which is stored on the master with name 'dsetname'. // The syntax for dsetname is name[#[dir/]objname], e.g. // "mydset" analysis of the first tree in the top dir of the dataset // named "mydset" // "mydset#T" analysis tree "T" in the top dir of the dataset // named "mydset" // "mydset#adir/T" analysis tree "T" in the dir "adir" of the dataset // named "mydset" // "mydset#adir/" analysis of the first tree in the dir "adir" of the // dataset named "mydset" // The last argument 'enl' specifies an entry- or event-list to be used as // event selection. // The return value is -1 in case of error and TSelector::GetStatus() in // in case of success. if (fProtocol < 13) { Info("Process", "processing 'by name' not supported by the server"); return -1; } TString name(dsetname); TString obj; TString dir = "/"; Int_t idxc = name.Index("#"); if (idxc != kNPOS) { Int_t idxs = name.Index("/", 1, idxc, TString::kExact); if (idxs != kNPOS) { obj = name(idxs+1, name.Length()); dir = name(idxc+1, name.Length()); dir.Remove(dir.Index("/") + 1); name.Remove(idxc); } else { obj = name(idxc+1, name.Length()); name.Remove(idxc); } } else if (name.Index(":") != kNPOS && name.Index("://") == kNPOS) { // protection against using ':' instead of '#' Error("Process", "bad name syntax (%s): please use" " a '#' after the dataset name", dsetname); return -1; } TDSet *dset = new TDSet(name, obj, dir); // Set entry list dset->SetEntryList(enl); Long64_t retval = Process(dset, selector, option, nentries, first); // Cleanup if (IsLite() && !fSync) { if (!fRunningDSets) fRunningDSets = new TList; fRunningDSets->Add(dset); } else { delete dset; } return retval; } //______________________________________________________________________________ Long64_t TProof::Process(const char *selector, Long64_t n, Option_t *option) { // Generic (non-data based) selector processing: the Process() method of the // specified selector (.C) is called 'n' times. // The return value is -1 in case of error and TSelector::GetStatus() in // in case of success. if (!IsValid()) return -1; if (fProtocol < 16) { Info("Process", "server version < 5.17/04: generic processing not supported"); return -1; } // Fake data set TDSet *dset = new TDSet; dset->SetBit(TDSet::kEmpty); Long64_t retval = Process(dset, selector, option, n); // Cleanup if (IsLite() && !fSync) { if (!fRunningDSets) fRunningDSets = new TList; fRunningDSets->Add(dset); } else { delete dset; } return retval; } //______________________________________________________________________________ Int_t TProof::GetQueryReference(Int_t qry, TString &ref) { // Get reference for the qry-th query in fQueries (as // displayed by ShowQueries). ref = ""; if (qry > 0) { if (!fQueries) GetListOfQueries(); if (fQueries) { TIter nxq(fQueries); TQueryResult *qr = 0; while ((qr = (TQueryResult *) nxq())) if (qr->GetSeqNum() == qry) { ref = Form("%s:%s", qr->GetTitle(), qr->GetName()); return 0; } } } return -1; } //______________________________________________________________________________ Long64_t TProof::Finalize(Int_t qry, Bool_t force) { // Finalize the qry-th query in fQueries. // If force, force retrieval if the query is found in the local list // but has already been finalized (default kFALSE). // If query < 0, finalize current query. // Return 0 on success, -1 on error if (fPlayer) { if (qry > 0) { TString ref; if (GetQueryReference(qry, ref) == 0) { return Finalize(ref, force); } else { Info("Finalize", "query #%d not found", qry); } } else { // The last query return Finalize("", force); } } return -1; } //______________________________________________________________________________ Long64_t TProof::Finalize(const char *ref, Bool_t force) { // Finalize query with reference ref. // If force, force retrieval if the query is found in the local list // but has already been finalized (default kFALSE). // If ref = 0, finalize current query. // Return 0 on success, -1 on error if (fPlayer) { // Get the pointer to the query TQueryResult *qr = (ref && strlen(ref) > 0) ? fPlayer->GetQueryResult(ref) : GetQueryResult(); Bool_t retrieve = kFALSE; TString xref(ref); if (!qr) { if (!xref.IsNull()) { retrieve = kTRUE; } } else { if (qr->IsFinalized()) { if (force) { retrieve = kTRUE; } else { Info("Finalize","query already finalized:" " use Finalize(<qry>,kTRUE) to force new retrieval"); qr = 0; } } else { retrieve = kTRUE; xref.Form("%s:%s", qr->GetTitle(), qr->GetName()); } } if (retrieve) { Retrieve(xref.Data()); qr = fPlayer->GetQueryResult(xref.Data()); } if (qr) return fPlayer->Finalize(qr); } return -1; } //______________________________________________________________________________ Int_t TProof::Retrieve(Int_t qry, const char *path) { // Send retrieve request for the qry-th query in fQueries. // If path is defined save it to path. if (qry > 0) { TString ref; if (GetQueryReference(qry, ref) == 0) return Retrieve(ref, path); else Info("Retrieve", "query #%d not found", qry); } else { Info("Retrieve","positive argument required - do nothing"); } return -1; } //______________________________________________________________________________ Int_t TProof::Retrieve(const char *ref, const char *path) { // Send retrieve request for the query specified by ref. // If path is defined save it to path. // Generic method working for all queries known by the server. if (ref) { TMessage m(kPROOF_RETRIEVE); m << TString(ref); Broadcast(m, kActive); Collect(kActive, fCollectTimeout); // Archive it locally, if required if (path) { // Get pointer to query TQueryResult *qr = fPlayer ? fPlayer->GetQueryResult(ref) : 0; if (qr) { TFile *farc = TFile::Open(path,"UPDATE"); if (!(farc->IsOpen())) { Info("Retrieve", "archive file cannot be open (%s)", path); return 0; } farc->cd(); // Update query status qr->SetArchived(path); // Write to file qr->Write(); farc->Close(); SafeDelete(farc); } else { Info("Retrieve", "query not found after retrieve"); return -1; } } return 0; } return -1; } //______________________________________________________________________________ Int_t TProof::Remove(Int_t qry, Bool_t all) { // Send remove request for the qry-th query in fQueries. if (qry > 0) { TString ref; if (GetQueryReference(qry, ref) == 0) return Remove(ref, all); else Info("Remove", "query #%d not found", qry); } else { Info("Remove","positive argument required - do nothing"); } return -1; } //______________________________________________________________________________ Int_t TProof::Remove(const char *ref, Bool_t all) { // Send remove request for the query specified by ref. // If all = TRUE remove also local copies of the query, if any. // Generic method working for all queries known by the server. // This method can be also used to reset the list of queries // waiting to be processed: for that purpose use ref == "cleanupqueue". if (all) { // Remove also local copies, if any if (fPlayer) fPlayer->RemoveQueryResult(ref); } if (IsLite()) return 0; if (ref) { TMessage m(kPROOF_REMOVE); m << TString(ref); Broadcast(m, kActive); Collect(kActive, fCollectTimeout); return 0; } return -1; } //______________________________________________________________________________ Int_t TProof::Archive(Int_t qry, const char *path) { // Send archive request for the qry-th query in fQueries. if (qry > 0) { TString ref; if (GetQueryReference(qry, ref) == 0) return Archive(ref, path); else Info("Archive", "query #%d not found", qry); } else { Info("Archive","positive argument required - do nothing"); } return -1; } //______________________________________________________________________________ Int_t TProof::Archive(const char *ref, const char *path) { // Send archive request for the query specified by ref. // Generic method working for all queries known by the server. // If ref == "Default", path is understood as a default path for // archiving. if (ref) { TMessage m(kPROOF_ARCHIVE); m << TString(ref) << TString(path); Broadcast(m, kActive); Collect(kActive, fCollectTimeout); return 0; } return -1; } //______________________________________________________________________________ Int_t TProof::CleanupSession(const char *sessiontag) { // Send cleanup request for the session specified by tag. if (sessiontag) { TMessage m(kPROOF_CLEANUPSESSION); m << TString(sessiontag); Broadcast(m, kActive); Collect(kActive, fCollectTimeout); return 0; } return -1; } //_____________________________________________________________________________ void TProof::SetQueryMode(EQueryMode mode) { // Change query running mode to the one specified by 'mode'. fQueryMode = mode; if (gDebug > 0) Info("SetQueryMode","query mode is set to: %s", fQueryMode == kSync ? "Sync" : "Async"); } //______________________________________________________________________________ TProof::EQueryMode TProof::GetQueryMode(Option_t *mode) const { // Find out the query mode based on the current setting and 'mode'. EQueryMode qmode = fQueryMode; if (mode && (strlen(mode) > 0)) { TString m(mode); m.ToUpper(); if (m.Contains("ASYN")) { qmode = kAsync; } else if (m.Contains("SYNC")) { qmode = kSync; } } if (gDebug > 0) Info("GetQueryMode","query mode is set to: %s", qmode == kSync ? "Sync" : "Async"); return qmode; } //______________________________________________________________________________ Long64_t TProof::DrawSelect(TDSet *dset, const char *varexp, const char *selection, Option_t *option, Long64_t nentries, Long64_t first) { // Execute the specified drawing action on a data set (TDSet). // Event- or Entry-lists should be set in the data set object using // TDSet::SetEntryList. // Returns -1 in case of error or number of selected events otherwise. if (!IsValid() || !fPlayer) return -1; // Make sure that asynchronous processing is not active if (!IsIdle()) { Info("DrawSelect","not idle, asynchronous Draw not supported"); return -1; } TString opt(option); Int_t idx = opt.Index("ASYN", 0, TString::kIgnoreCase); if (idx != kNPOS) opt.Replace(idx,4,""); return fPlayer->DrawSelect(dset, varexp, selection, opt, nentries, first); } //______________________________________________________________________________ Long64_t TProof::DrawSelect(const char *dsetname, const char *varexp, const char *selection, Option_t *option, Long64_t nentries, Long64_t first, TObject *enl) { // Execute the specified drawing action on a data set which is stored on the // master with name 'dsetname'. // The syntax for dsetname is name[#[dir/]objname], e.g. // "mydset" analysis of the first tree in the top dir of the dataset // named "mydset" // "mydset#T" analysis tree "T" in the top dir of the dataset // named "mydset" // "mydset#adir/T" analysis tree "T" in the dir "adir" of the dataset // named "mydset" // "mydset#adir/" analysis of the first tree in the dir "adir" of the // dataset named "mydset" // The last argument 'enl' specifies an entry- or event-list to be used as // event selection. // The return value is -1 in case of error and TSelector::GetStatus() in // in case of success. if (fProtocol < 13) { Info("Process", "processing 'by name' not supported by the server"); return -1; } TString name(dsetname); TString obj; TString dir = "/"; Int_t idxc = name.Index("#"); if (idxc != kNPOS) { Int_t idxs = name.Index("/", 1, idxc, TString::kExact); if (idxs != kNPOS && idxc != kNPOS) { obj = name(idxs+1, name.Length()); dir = name(idxc+1, name.Length()); dir.Remove(dir.Index("/") + 1); name.Remove(idxc); } else if (idxc != kNPOS && idxs == kNPOS) { obj = name(idxc+1, name.Length()); name.Remove(idxc); } else if (idxs != kNPOS && idxc == kNPOS) { Error("DrawSelect", "bad name syntax (%s): specification of additional" " attributes needs a '#' after the dataset name", dsetname); return -1; } } else if (name.Index(":") != kNPOS && name.Index("://") == kNPOS) { // protection against using ':' instead of '#' Error("DrawSelect", "bad name syntax (%s): please use" " a '#' after the dataset name", dsetname); return -1; } TDSet *dset = new TDSet(name, obj, dir); // Set entry-list, if required dset->SetEntryList(enl); Long64_t retval = DrawSelect(dset, varexp, selection, option, nentries, first); delete dset; return retval; } //______________________________________________________________________________ void TProof::StopProcess(Bool_t abort, Int_t timeout) { // Send STOPPROCESS message to master and workers. PDB(kGlobal,2) Info("StopProcess","enter %d", abort); if (!IsValid()) return; // Flag that we have been stopped ERunStatus rst = abort ? TProof::kAborted : TProof::kStopped; SetRunStatus(rst); if (fPlayer) fPlayer->StopProcess(abort, timeout); // Stop any blocking 'Collect' request; on masters we do this only if // aborting; when stopping, we still need to receive the results if (TestBit(TProof::kIsClient) || abort) InterruptCurrentMonitor(); if (fSlaves->GetSize() == 0) return; // Notify the remote counterpart TSlave *sl; TIter next(fSlaves); while ((sl = (TSlave *)next())) if (sl->IsValid()) // Ask slave to progate the stop/abort request sl->StopProcess(abort, timeout); } //______________________________________________________________________________ void TProof::DisableGoAsyn() { // Signal to disable related switches Emit("DisableGoAsyn()"); } //______________________________________________________________________________ void TProof::GoAsynchronous() { // Send GOASYNC message to the master. if (!IsValid()) return; if (GetRemoteProtocol() < 22) { Info("GoAsynchronous", "functionality not supported by the server - ignoring"); return; } if (fSync && !IsIdle()) { TMessage m(kPROOF_GOASYNC); Broadcast(m); } else { Info("GoAsynchronous", "either idle or already in asynchronous mode - ignoring"); } } //______________________________________________________________________________ void TProof::RecvLogFile(TSocket *s, Int_t size) { // Receive the log file of the slave with socket s. const Int_t kMAXBUF = 16384; //32768 //16384 //65536; char buf[kMAXBUF]; // Append messages to active logging unit Int_t fdout = -1; if (!fLogToWindowOnly) { fdout = (fRedirLog) ? fileno(fLogFileW) : fileno(stdout); if (fdout < 0) { Warning("RecvLogFile", "file descriptor for outputs undefined (%d):" " will not log msgs", fdout); return; } lseek(fdout, (off_t) 0, SEEK_END); } Int_t left, rec, r; Long_t filesize = 0; while (filesize < size) { left = Int_t(size - filesize); if (left > kMAXBUF) left = kMAXBUF; rec = s->RecvRaw(&buf, left); filesize = (rec > 0) ? (filesize + rec) : filesize; if (!fLogToWindowOnly) { if (rec > 0) { char *p = buf; r = rec; while (r) { Int_t w; w = write(fdout, p, r); if (w < 0) { SysError("RecvLogFile", "error writing to unit: %d", fdout); break; } r -= w; p += w; } } else if (rec < 0) { Error("RecvLogFile", "error during receiving log file"); break; } } if (rec > 0) { buf[rec] = 0; EmitVA("LogMessage(const char*,Bool_t)", 2, buf, kFALSE); } } // If idle restore logs to main session window if (fRedirLog && IsIdle() && !TestBit(TProof::kIsMaster)) fRedirLog = kFALSE; } //______________________________________________________________________________ void TProof::NotifyLogMsg(const char *msg, const char *sfx) { // Notify locally 'msg' to the appropriate units (file, stdout, window) // If defined, 'sfx' is added after 'msg' (typically a line-feed); // Must have somenthing to notify Int_t len = 0; if (!msg || (len = strlen(msg)) <= 0) return; // Get suffix length if any Int_t lsfx = (sfx) ? strlen(sfx) : 0; // Append messages to active logging unit Int_t fdout = -1; if (!fLogToWindowOnly) { fdout = (fRedirLog) ? fileno(fLogFileW) : fileno(stdout); if (fdout < 0) { Warning("NotifyLogMsg", "file descriptor for outputs undefined (%d):" " will not notify msgs", fdout); return; } lseek(fdout, (off_t) 0, SEEK_END); } if (!fLogToWindowOnly) { // Write to output unit (stdout or a log file) if (len > 0) { char *p = (char *)msg; Int_t r = len; while (r) { Int_t w = write(fdout, p, r); if (w < 0) { SysError("NotifyLogMsg", "error writing to unit: %d", fdout); break; } r -= w; p += w; } // Add a suffix, if requested if (lsfx > 0) if (write(fdout, sfx, lsfx) != lsfx) SysError("NotifyLogMsg", "error writing to unit: %d", fdout); } } if (len > 0) { // Publish the message to the separate window (if the latter is missing // the message will just get lost) EmitVA("LogMessage(const char*,Bool_t)", 2, msg, kFALSE); } // If idle restore logs to main session window if (fRedirLog && IsIdle()) fRedirLog = kFALSE; } //______________________________________________________________________________ void TProof::LogMessage(const char *msg, Bool_t all) { // Log a message into the appropriate window by emitting a signal. PDB(kGlobal,1) Info("LogMessage","Enter ... %s, 'all: %s", msg ? msg : "", all ? "true" : "false"); if (gROOT->IsBatch()) { PDB(kGlobal,1) Info("LogMessage","GUI not started - use TProof::ShowLog()"); return; } if (msg) EmitVA("LogMessage(const char*,Bool_t)", 2, msg, all); // Re-position at the beginning of the file, if requested. // This is used by the dialog when it re-opens the log window to // provide all the session messages if (all) lseek(fileno(fLogFileR), (off_t) 0, SEEK_SET); const Int_t kMAXBUF = 32768; char buf[kMAXBUF]; Int_t len; do { while ((len = read(fileno(fLogFileR), buf, kMAXBUF-1)) < 0 && TSystem::GetErrno() == EINTR) TSystem::ResetErrno(); if (len < 0) { Error("LogMessage", "error reading log file"); break; } if (len > 0) { buf[len] = 0; EmitVA("LogMessage(const char*,Bool_t)", 2, buf, kFALSE); } } while (len > 0); } //______________________________________________________________________________ Int_t TProof::SendGroupView() { // Send to all active slaves servers the current slave group size // and their unique id. Returns number of active slaves. // Returns -1 in case of error. if (!IsValid()) return -1; if (TestBit(TProof::kIsClient)) return 0; if (!fSendGroupView) return 0; fSendGroupView = kFALSE; TIter next(fActiveSlaves); TSlave *sl; int bad = 0, cnt = 0, size = GetNumberOfActiveSlaves(); char str[32]; while ((sl = (TSlave *)next())) { sprintf(str, "%d %d", cnt, size); if (sl->GetSocket()->Send(str, kPROOF_GROUPVIEW) == -1) { MarkBad(sl, "could not send kPROOF_GROUPVIEW message"); bad++; } else cnt++; } // Send the group view again in case there was a change in the // group size due to a bad slave if (bad) SendGroupView(); return GetNumberOfActiveSlaves(); } //______________________________________________________________________________ Bool_t TProof::GetFileInCmd(const char *cmd, TString &fn) { // Static method to extract the filename (if any) form a CINT command. // Returns kTRUE and the filename in 'fn'; returns kFALSE if not found or not // appliable. TString s = cmd; s = s.Strip(TString::kBoth); if (s.Length() > 0 && (s.BeginsWith(".L") || s.BeginsWith(".x") || s.BeginsWith(".X"))) { TString file = s(2, s.Length()); TString acm, arg, io; fn = gSystem->SplitAclicMode(file, acm, arg, io); if (!fn.IsNull()) return kTRUE; } // Not found return kFALSE; } //______________________________________________________________________________ Int_t TProof::Exec(const char *cmd, Bool_t plusMaster) { // Send command to be executed on the PROOF master and/or slaves. // If plusMaster is kTRUE then exeucte on slaves and master too. // Command can be any legal command line command. Commands like // ".x file.C" or ".L file.C" will cause the file file.C to be send // to the PROOF cluster. Returns -1 in case of error, >=0 in case of // succes. return Exec(cmd, kActive, plusMaster); } //______________________________________________________________________________ Int_t TProof::Exec(const char *cmd, ESlaves list, Bool_t plusMaster) { // Send command to be executed on the PROOF master and/or slaves. // Command can be any legal command line command. Commands like // ".x file.C" or ".L file.C" will cause the file file.C to be send // to the PROOF cluster. Returns -1 in case of error, >=0 in case of // succes. if (!IsValid()) return -1; TString s = cmd; s = s.Strip(TString::kBoth); if (!s.Length()) return 0; // check for macro file and make sure the file is available on all slaves TString filename; if (TProof::GetFileInCmd(s.Data(), filename)) { char *fn = gSystem->Which(TROOT::GetMacroPath(), filename, kReadPermission); if (fn) { if (GetNumberOfUniqueSlaves() > 0) { if (SendFile(fn, kAscii | kForward | kCpBin) < 0) { Error("Exec", "file %s could not be transfered", fn); delete [] fn; return -1; } } else { TString scmd = s(0,3) + fn; Int_t n = SendCommand(scmd, list); delete [] fn; return n; } } else { Error("Exec", "macro %s not found", filename.Data()); return -1; } delete [] fn; } if (plusMaster) { if (IsLite()) { gROOT->ProcessLine(cmd); } else { Int_t n = GetParallel(); SetParallelSilent(0); Int_t res = SendCommand(cmd, list); SetParallelSilent(n); if (res < 0) return res; } } return SendCommand(cmd, list); } //______________________________________________________________________________ Int_t TProof::SendCommand(const char *cmd, ESlaves list) { // Send command to be executed on the PROOF master and/or slaves. // Command can be any legal command line command, however commands // like ".x file.C" or ".L file.C" will not cause the file.C to be // transfered to the PROOF cluster. In that case use TProof::Exec(). // Returns the status send by the remote server as part of the // kPROOF_LOGDONE message. Typically this is the return code of the // command on the remote side. Returns -1 in case of error. if (!IsValid()) return -1; Broadcast(cmd, kMESS_CINT, list); Collect(list); return fStatus; } //______________________________________________________________________________ Int_t TProof::SendCurrentState(ESlaves list) { // Transfer the current state of the master to the active slave servers. // The current state includes: the current working directory, etc. // Returns the number of active slaves. Returns -1 in case of error. if (!IsValid()) return -1; // Go to the new directory, reset the interpreter environment and // tell slave to delete all objects from its new current directory. Broadcast(gDirectory->GetPath(), kPROOF_RESET, list); return GetParallel(); } //______________________________________________________________________________ Int_t TProof::SendInitialState() { // Transfer the initial (i.e. current) state of the master to all // slave servers. Currently the initial state includes: log level. // Returns the number of active slaves. Returns -1 in case of error. if (!IsValid()) return -1; SetLogLevel(fLogLevel, gProofDebugMask); return GetNumberOfActiveSlaves(); } //______________________________________________________________________________ Bool_t TProof::CheckFile(const char *file, TSlave *slave, Long_t modtime, Int_t cpopt) { // Check if a file needs to be send to the slave. Use the following // algorithm: // - check if file appears in file map // - if yes, get file's modtime and check against time in map, // if modtime not same get md5 and compare against md5 in map, // if not same return kTRUE. // - if no, get file's md5 and modtime and store in file map, ask // slave if file exists with specific md5, if yes return kFALSE, // if no return kTRUE. // The options 'cpopt' define if to copy things from cache to sandbox and what. // To retrieve from the cache the binaries associated with the file TProof::kCpBin // must be set in cpopt; the default is copy everything. // Returns kTRUE in case file needs to be send, returns kFALSE in case // file is already on remote node. Bool_t sendto = kFALSE; // create slave based filename TString sn = slave->GetName(); sn += ":"; sn += slave->GetOrdinal(); sn += ":"; sn += gSystem->BaseName(file); // check if file is in map FileMap_t::const_iterator it; if ((it = fFileMap.find(sn)) != fFileMap.end()) { // file in map MD5Mod_t md = (*it).second; if (md.fModtime != modtime) { TMD5 *md5 = TMD5::FileChecksum(file); if (md5) { if ((*md5) != md.fMD5) { sendto = kTRUE; md.fMD5 = *md5; md.fModtime = modtime; fFileMap[sn] = md; // When on the master, the master and/or slaves may share // their file systems and cache. Therefore always make a // check for the file. If the file already exists with the // expected md5 the kPROOF_CHECKFILE command will cause the // file to be copied from cache to slave sandbox. if (TestBit(TProof::kIsMaster)) { sendto = kFALSE; TMessage mess(kPROOF_CHECKFILE); mess << TString(gSystem->BaseName(file)) << md.fMD5 << cpopt; slave->GetSocket()->Send(mess); fCheckFileStatus = 0; Collect(slave, fCollectTimeout, kPROOF_CHECKFILE); sendto = (fCheckFileStatus == 0) ? kTRUE : kFALSE; } } delete md5; } else { Error("CheckFile", "could not calculate local MD5 check sum - dont send"); return kFALSE; } } } else { // file not in map TMD5 *md5 = TMD5::FileChecksum(file); MD5Mod_t md; if (md5) { md.fMD5 = *md5; md.fModtime = modtime; fFileMap[sn] = md; delete md5; } else { Error("CheckFile", "could not calculate local MD5 check sum - dont send"); return kFALSE; } TMessage mess(kPROOF_CHECKFILE); mess << TString(gSystem->BaseName(file)) << md.fMD5 << cpopt; slave->GetSocket()->Send(mess); fCheckFileStatus = 0; Collect(slave, fCollectTimeout, kPROOF_CHECKFILE); sendto = (fCheckFileStatus == 0) ? kTRUE : kFALSE; } return sendto; } //______________________________________________________________________________ Int_t TProof::SendFile(const char *file, Int_t opt, const char *rfile, TSlave *wrk) { // Send a file to master or slave servers. Returns number of slaves // the file was sent to, maybe 0 in case master and slaves have the same // file system image, -1 in case of error. // If defined, send to worker 'wrk' only. // If defined, the full path of the remote path will be rfile. // If rfile = "cache" the file is copied to the remote cache instead of the sandbox // (to copy to the cache on a different name use rfile = "cache:newname"). // The mask 'opt' is an or of ESendFileOpt: // // kAscii (0x0) if set true ascii file transfer is used // kBinary (0x1) if set true binary file transfer is used // kForce (0x2) if not set an attempt is done to find out // whether the file really needs to be downloaded // (a valid copy may already exist in the cache // from a previous run); the bit is set by // UploadPackage, since the check is done elsewhere. // kForward (0x4) if set, ask server to forward the file to slave // or submaster (meaningless for slave servers). // kCpBin (0x8) Retrieve from the cache the binaries associated // with the file // kCp (0x10) Retrieve the files from the cache // if (!IsValid()) return -1; // Use the active slaves list ... TList *slaves = (rfile && !strcmp(rfile, "cache")) ? fUniqueSlaves : fActiveSlaves; // ... or the specified slave, if any if (wrk) { slaves = new TList(); slaves->Add(wrk); } if (slaves->GetSize() == 0) return 0; #ifndef R__WIN32 Int_t fd = open(file, O_RDONLY); #else Int_t fd = open(file, O_RDONLY | O_BINARY); #endif if (fd < 0) { SysError("SendFile", "cannot open file %s", file); return -1; } // Get info about the file Long64_t size; Long_t id, flags, modtime; if (gSystem->GetPathInfo(file, &id, &size, &flags, &modtime) == 1) { Error("SendFile", "cannot stat file %s", file); return -1; } if (size == 0) { Error("SendFile", "empty file %s", file); return -1; } // Decode options Bool_t bin = (opt & kBinary) ? kTRUE : kFALSE; Bool_t force = (opt & kForce) ? kTRUE : kFALSE; Bool_t fw = (opt & kForward) ? kTRUE : kFALSE; // Copy options Int_t cpopt = 0; if ((opt & kCp)) cpopt |= kCp; if ((opt & kCpBin)) cpopt |= (kCp | kCpBin); const Int_t kMAXBUF = 32768; //16384 //65536; char buf[kMAXBUF]; Int_t nsl = 0; TIter next(slaves); TSlave *sl; TString fnam(rfile); if (fnam == "cache") { fnam += Form(":%s", gSystem->BaseName(file)); } else if (fnam.IsNull()) { fnam = gSystem->BaseName(file); } // List on which we will collect the results TList wsent; while ((sl = (TSlave *)next())) { if (!sl->IsValid()) continue; Bool_t sendto = force ? kTRUE : CheckFile(file, sl, modtime, cpopt); // Don't send the kPROOF_SENDFILE command to real slaves when sendto // is false. Masters might still need to send the file to newly added // slaves. PDB(kPackage,2) { const char *snd = (sl->fSlaveType == TSlave::kSlave && sendto) ? "" : "not"; Info("SendFile", "%s sending file %s to: %s:%s (%d)", snd, file, sl->GetName(), sl->GetOrdinal(), sendto); } if (sl->fSlaveType == TSlave::kSlave && !sendto) continue; // The value of 'size' is used as flag remotely, so we need to // reset it to 0 if we are not going to send the file Long64_t siz = sendto ? size : 0; sprintf(buf, "%s %d %lld %d", fnam.Data(), bin, siz, fw); if (sl->GetSocket()->Send(buf, kPROOF_SENDFILE) == -1) { MarkBad(sl, "could not send kPROOF_SENDFILE request"); continue; } // Record wsent.Add(sl); if (sendto) { lseek(fd, 0, SEEK_SET); Int_t len; do { while ((len = read(fd, buf, kMAXBUF)) < 0 && TSystem::GetErrno() == EINTR) TSystem::ResetErrno(); if (len < 0) { SysError("SendFile", "error reading from file %s", file); Interrupt(kSoftInterrupt, kActive); close(fd); return -1; } if (len > 0 && sl->GetSocket()->SendRaw(buf, len) == -1) { SysError("SendFile", "error writing to slave %s:%s (now offline)", sl->GetName(), sl->GetOrdinal()); MarkBad(sl, "sendraw failure"); break; } } while (len > 0); nsl++; } // Wait for the operation to be done Collect(sl, fCollectTimeout, kPROOF_SENDFILE); } close(fd); // Cleanup temporary list, if any if (slaves != fActiveSlaves && slaves != fUniqueSlaves) SafeDelete(slaves); return nsl; } //______________________________________________________________________________ Int_t TProof::SendObject(const TObject *obj, ESlaves list) { // Send object to master or slave servers. Returns number of slaves object // was sent to, -1 in case of error. if (!IsValid() || !obj) return -1; TMessage mess(kMESS_OBJECT); mess.WriteObject(obj); return Broadcast(mess, list); } //______________________________________________________________________________ Int_t TProof::SendPrint(Option_t *option) { // Send print command to master server. Returns number of slaves message // was sent to. Returns -1 in case of error. if (!IsValid()) return -1; Broadcast(option, kPROOF_PRINT, kActive); return Collect(kActive, fCollectTimeout); } //______________________________________________________________________________ void TProof::SetLogLevel(Int_t level, UInt_t mask) { // Set server logging level. char str[32]; fLogLevel = level; gProofDebugLevel = level; gProofDebugMask = (TProofDebug::EProofDebugMask) mask; sprintf(str, "%d %u", level, mask); Broadcast(str, kPROOF_LOGLEVEL, kAll); } //______________________________________________________________________________ void TProof::SetRealTimeLog(Bool_t on) { // Switch ON/OFF the real-time logging facility. When this option is // ON, log messages from processing are sent back as they come, instead of // being sent back at the end in one go. This may help debugging or monitoring // in some cases, but, depending on the amount of log, it may have significant // consequencies on the load over the network, so it must be used with care. if (IsValid()) { TMessage mess(kPROOF_REALTIMELOG); mess << on; Broadcast(mess); } else { Warning("SetRealTimeLog","session is invalid - do nothing"); } } //______________________________________________________________________________ Int_t TProof::SetParallelSilent(Int_t nodes, Bool_t random) { // Tell PROOF how many slaves to use in parallel. If random is TRUE a random // selection is done (if nodes is less than the available nodes). // Returns the number of parallel slaves. Returns -1 in case of error. if (!IsValid()) return -1; if (TestBit(TProof::kIsMaster)) { GoParallel(nodes, kFALSE, random); return SendCurrentState(); } else { PDB(kGlobal,1) Info("SetParallelSilent", "request %d node%s", nodes, nodes == 1 ? "" : "s"); TMessage mess(kPROOF_PARALLEL); mess << nodes << random; Broadcast(mess); Collect(kActive, fCollectTimeout); Int_t n = GetParallel(); PDB(kGlobal,1) Info("SetParallelSilent", "got %d node%s", n, n == 1 ? "" : "s"); return n; } } //______________________________________________________________________________ Int_t TProof::SetParallel(Int_t nodes, Bool_t random) { // Tell PROOF how many slaves to use in parallel. Returns the number of // parallel slaves. Returns -1 in case of error. Int_t n = SetParallelSilent(nodes, random); if (TestBit(TProof::kIsClient)) { if (n < 1) { Printf("PROOF set to sequential mode"); } else { TString subfix = (n == 1) ? "" : "s"; if (random) subfix += ", randomly selected"; Printf("PROOF set to parallel mode (%d worker%s)", n, subfix.Data()); } } return n; } //______________________________________________________________________________ Int_t TProof::GoParallel(Int_t nodes, Bool_t attach, Bool_t random) { // Go in parallel mode with at most "nodes" slaves. Since the fSlaves // list is sorted by slave performace the active list will contain first // the most performant nodes. Returns the number of active slaves. // If random is TRUE, and nodes is less than the number of available workers, // a random selection is done. // Returns -1 in case of error. if (!IsValid()) return -1; if (nodes < 0) nodes = 0; fActiveSlaves->Clear(); fActiveMonitor->RemoveAll(); // Prepare the list of candidates first. // Algorithm depends on random option. TSlave *sl = 0; TList *wlst = new TList; TIter nxt(fSlaves); fInactiveSlaves->Clear(); while ((sl = (TSlave *)nxt())) { if (sl->IsValid() && !fBadSlaves->FindObject(sl)) { if (strcmp("IGNORE", sl->GetImage()) == 0) continue; if ((sl->GetSlaveType() != TSlave::kSlave) && (sl->GetSlaveType() != TSlave::kMaster)) { Error("GoParallel", "TSlave is neither Master nor Slave"); R__ASSERT(0); } // Good candidate wlst->Add(sl); // Set it inactive fInactiveSlaves->Add(sl); sl->SetStatus(TSlave::kInactive); } } Int_t nwrks = (nodes > wlst->GetSize()) ? wlst->GetSize() : nodes; int cnt = 0; fEndMaster = TestBit(TProof::kIsMaster) ? kTRUE : kFALSE; while (cnt < nwrks) { // Random choice, if requested if (random) { Int_t iwrk = (Int_t) (gRandom->Rndm() * wlst->GetSize()); sl = (TSlave *) wlst->At(iwrk); } else { // The first available sl = (TSlave *) wlst->First(); } if (!sl) { Error("GoParallel", "attaching to candidate!"); break; } Int_t slavenodes = 0; if (sl->GetSlaveType() == TSlave::kSlave) { sl->SetStatus(TSlave::kActive); fActiveSlaves->Add(sl); fInactiveSlaves->Remove(sl); fActiveMonitor->Add(sl->GetSocket()); slavenodes = 1; } else if (sl->GetSlaveType() == TSlave::kMaster) { fEndMaster = kFALSE; TMessage mess(kPROOF_PARALLEL); if (!attach) { mess << nodes-cnt; } else { // To get the number of slaves mess.SetWhat(kPROOF_LOGFILE); mess << -1 << -1; } if (sl->GetSocket()->Send(mess) == -1) { MarkBad(sl, "could not send kPROOF_PARALLEL or kPROOF_LOGFILE request"); slavenodes = 0; } else { Collect(sl, fCollectTimeout); if (sl->IsValid()) { sl->SetStatus(TSlave::kActive); fActiveSlaves->Add(sl); fInactiveSlaves->Remove(sl); fActiveMonitor->Add(sl->GetSocket()); if (sl->GetParallel() > 0) { slavenodes = sl->GetParallel(); } else { slavenodes = 0; } } else { MarkBad(sl, "collect failed after kPROOF_PARALLEL or kPROOF_LOGFILE request"); slavenodes = 0; } } } // Remove from the list wlst->Remove(sl); // cnt += slavenodes; cnt += 1; } // Cleanup list wlst->SetOwner(0); SafeDelete(wlst); // Get slave status (will set the slaves fWorkDir correctly) AskStatistics(); // Find active slaves with unique image FindUniqueSlaves(); // Send new group-view to slaves if (!attach) SendGroupView(); Int_t n = GetParallel(); if (TestBit(TProof::kIsClient)) { if (n < 1) printf("PROOF set to sequential mode\n"); else printf("PROOF set to parallel mode (%d worker%s)\n", n, n == 1 ? "" : "s"); } PDB(kGlobal,1) Info("GoParallel", "got %d node%s", n, n == 1 ? "" : "s"); return n; } //______________________________________________________________________________ void TProof::ShowCache(Bool_t all) { // List contents of file cache. If all is true show all caches also on // slaves. If everything is ok all caches are to be the same. if (!IsValid()) return; TMessage mess(kPROOF_CACHE); mess << Int_t(kShowCache) << all; Broadcast(mess, kUnique); if (all) { TMessage mess2(kPROOF_CACHE); mess2 << Int_t(kShowSubCache) << all; Broadcast(mess2, fNonUniqueMasters); Collect(kAllUnique, fCollectTimeout); } else { Collect(kUnique, fCollectTimeout); } } //______________________________________________________________________________ void TProof::ClearCache(const char *file) { // Remove file from all file caches. If file is 0 or "" or "*", remove all // the files if (!IsValid()) return; TMessage mess(kPROOF_CACHE); mess << Int_t(kClearCache) << TString(file); Broadcast(mess, kUnique); TMessage mess2(kPROOF_CACHE); mess2 << Int_t(kClearSubCache) << TString(file); Broadcast(mess2, fNonUniqueMasters); Collect(kAllUnique); // clear file map so files get send again to remote nodes fFileMap.clear(); } //______________________________________________________________________________ void TProof::ShowPackages(Bool_t all) { // List contents of package directory. If all is true show all package // directries also on slaves. If everything is ok all package directories // should be the same. if (!IsValid()) return; if (TestBit(TProof::kIsClient)) { if (fGlobalPackageDirList && fGlobalPackageDirList->GetSize() > 0) { // Scan the list of global packages dirs TIter nxd(fGlobalPackageDirList); TNamed *nm = 0; while ((nm = (TNamed *)nxd())) { printf("*** Global Package cache %s client:%s ***\n", nm->GetName(), nm->GetTitle()); fflush(stdout); gSystem->Exec(Form("%s %s", kLS, nm->GetTitle())); printf("\n"); fflush(stdout); } } printf("*** Package cache client:%s ***\n", fPackageDir.Data()); fflush(stdout); gSystem->Exec(Form("%s %s", kLS, fPackageDir.Data())); } // Nothing more to do if we are a Lite-session if (IsLite()) return; TMessage mess(kPROOF_CACHE); mess << Int_t(kShowPackages) << all; Broadcast(mess, kUnique); if (all) { TMessage mess2(kPROOF_CACHE); mess2 << Int_t(kShowSubPackages) << all; Broadcast(mess2, fNonUniqueMasters); Collect(kAllUnique, fCollectTimeout); } else { Collect(kUnique, fCollectTimeout); } } //______________________________________________________________________________ void TProof::ShowEnabledPackages(Bool_t all) { // List which packages are enabled. If all is true show enabled packages // for all active slaves. If everything is ok all active slaves should // have the same packages enabled. if (!IsValid()) return; if (TestBit(TProof::kIsClient)) { printf("*** Enabled packages on client on %s\n", gSystem->HostName()); TIter next(fEnabledPackagesOnClient); while (TObjString *str = (TObjString*) next()) printf("%s\n", str->GetName()); } // Nothing more to do if we are a Lite-session if (IsLite()) return; TMessage mess(kPROOF_CACHE); mess << Int_t(kShowEnabledPackages) << all; Broadcast(mess); Collect(kActive, fCollectTimeout); } //______________________________________________________________________________ Int_t TProof::ClearPackages() { // Remove all packages. // Returns 0 in case of success and -1 in case of error. if (!IsValid()) return -1; if (UnloadPackages() == -1) return -1; if (DisablePackages() == -1) return -1; return fStatus; } //______________________________________________________________________________ Int_t TProof::ClearPackage(const char *package) { // Remove a specific package. // Returns 0 in case of success and -1 in case of error. if (!IsValid()) return -1; if (!package || !strlen(package)) { Error("ClearPackage", "need to specify a package name"); return -1; } // if name, erroneously, is a par pathname strip off .par and path TString pac = package; if (pac.EndsWith(".par")) pac.Remove(pac.Length()-4); pac = gSystem->BaseName(pac); if (UnloadPackage(pac) == -1) return -1; if (DisablePackage(pac) == -1) return -1; return fStatus; } //______________________________________________________________________________ Int_t TProof::DisablePackage(const char *package) { // Remove a specific package. // Returns 0 in case of success and -1 in case of error. if (!IsValid()) return -1; if (!package || !strlen(package)) { Error("DisablePackage", "need to specify a package name"); return -1; } // if name, erroneously, is a par pathname strip off .par and path TString pac = package; if (pac.EndsWith(".par")) pac.Remove(pac.Length()-4); pac = gSystem->BaseName(pac); if (DisablePackageOnClient(pac) == -1) return -1; // Nothing more to do if we are a Lite-session if (IsLite()) return 0; TMessage mess(kPROOF_CACHE); mess << Int_t(kDisablePackage) << pac; Broadcast(mess, kUnique); TMessage mess2(kPROOF_CACHE); mess2 << Int_t(kDisableSubPackage) << pac; Broadcast(mess2, fNonUniqueMasters); Collect(kAllUnique); return fStatus; } //______________________________________________________________________________ Int_t TProof::DisablePackageOnClient(const char *package) { // Remove a specific package from the client. // Returns 0 in case of success and -1 in case of error. if (TestBit(TProof::kIsClient)) { // remove the package directory and the par file fPackageLock->Lock(); gSystem->Exec(Form("%s %s/%s", kRM, fPackageDir.Data(), package)); gSystem->Exec(Form("%s %s/%s.par", kRM, fPackageDir.Data(), package)); fPackageLock->Unlock(); if (!gSystem->AccessPathName(Form("%s/%s.par", fPackageDir.Data(), package))) Warning("DisablePackageOnClient", "unable to remove package PAR file for %s", package); if (!gSystem->AccessPathName(Form("%s/%s", fPackageDir.Data(), package))) Warning("DisablePackageOnClient", "unable to remove package directory for %s", package); } return 0; } //______________________________________________________________________________ Int_t TProof::DisablePackages() { // Remove all packages. // Returns 0 in case of success and -1 in case of error. if (!IsValid()) return -1; // remove all packages on client if (TestBit(TProof::kIsClient)) { fPackageLock->Lock(); gSystem->Exec(Form("%s %s/*", kRM, fPackageDir.Data())); fPackageLock->Unlock(); } // Nothing more to do if we are a Lite-session if (IsLite()) return 0; TMessage mess(kPROOF_CACHE); mess << Int_t(kDisablePackages); Broadcast(mess, kUnique); TMessage mess2(kPROOF_CACHE); mess2 << Int_t(kDisableSubPackages); Broadcast(mess2, fNonUniqueMasters); Collect(kAllUnique); return fStatus; } //______________________________________________________________________________ Int_t TProof::BuildPackage(const char *package, EBuildPackageOpt opt) { // Build specified package. Executes the PROOF-INF/BUILD.sh // script if it exists on all unique nodes. If opt is kBuildOnSlavesNoWait // then submit build command to slaves, but don't wait // for results. If opt is kCollectBuildResults then collect result // from slaves. To be used on the master. // If opt = kBuildAll (default) then submit and wait for results // (to be used on the client). // Returns 0 in case of success and -1 in case of error. if (!IsValid()) return -1; if (!package || !strlen(package)) { Error("BuildPackage", "need to specify a package name"); return -1; } // if name, erroneously, is a par pathname strip off .par and path TString pac = package; if (pac.EndsWith(".par")) pac.Remove(pac.Length()-4); pac = gSystem->BaseName(pac); Bool_t buildOnClient = kTRUE; if (opt == kDontBuildOnClient) { buildOnClient = kFALSE; opt = kBuildAll; } if (opt <= kBuildAll && !IsLite()) { TMessage mess(kPROOF_CACHE); mess << Int_t(kBuildPackage) << pac; Broadcast(mess, kUnique); TMessage mess2(kPROOF_CACHE); mess2 << Int_t(kBuildSubPackage) << pac; Broadcast(mess2, fNonUniqueMasters); } if (opt >= kBuildAll) { // by first forwarding the build commands to the master and slaves // and only then building locally we build in parallel Int_t st = 0; if (buildOnClient) st = BuildPackageOnClient(pac); fStatus = 0; if (!IsLite()) Collect(kAllUnique); if (fStatus < 0 || st < 0) return -1; } return 0; } //______________________________________________________________________________ Int_t TProof::BuildPackageOnClient(const TString &package) { // Build specified package on the client. Executes the PROOF-INF/BUILD.sh // script if it exists on the client. // Returns 0 in case of success and -1 in case of error. // The code is equivalent to the one in TProofServ.cxx (TProof::kBuildPackage // case). Keep in sync in case of changes. if (TestBit(TProof::kIsClient)) { Int_t status = 0; TString pdir, ocwd; // Package path pdir = fPackageDir + "/" + package; if (gSystem->AccessPathName(pdir, kReadPermission) || gSystem->AccessPathName(pdir + "/PROOF-INF", kReadPermission)) { // Is there a global package with this name? if (fGlobalPackageDirList && fGlobalPackageDirList->GetSize() > 0) { // Scan the list of global packages dirs TIter nxd(fGlobalPackageDirList); TNamed *nm = 0; while ((nm = (TNamed *)nxd())) { pdir = Form("%s/%s", nm->GetTitle(), package.Data()); if (!gSystem->AccessPathName(pdir, kReadPermission) && !gSystem->AccessPathName(pdir + "/PROOF-INF", kReadPermission)) { // Package found, stop searching break; } pdir = ""; } if (pdir.Length() <= 0) { // Package not found Error("BuildPackageOnClient", "failure locating %s ...", package.Data()); return -1; } else { // Package is in the global dirs if (gDebug > 0) Info("BuildPackageOnClient", "found global package: %s", pdir.Data()); return 0; } } } PDB(kPackage, 1) Info("BuildPackageOnCLient", "package %s exists and has PROOF-INF directory", package.Data()); fPackageLock->Lock(); ocwd = gSystem->WorkingDirectory(); gSystem->ChangeDirectory(pdir); // check for BUILD.sh and execute if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) { // read version from file proofvers.txt, and if current version is // not the same do a "BUILD.sh clean" Bool_t savever = kFALSE; Int_t rev = -1; TString v; FILE *f = fopen("PROOF-INF/proofvers.txt", "r"); if (f) { TString r; v.Gets(f); r.Gets(f); rev = (!r.IsNull() && r.IsDigit()) ? r.Atoi() : -1; fclose(f); } if (!f || v != gROOT->GetVersion() || (gROOT->GetSvnRevision() > 0 && rev != gROOT->GetSvnRevision())) { savever = kTRUE; Info("BuildPackageOnCLient", "%s: version change (current: %s:%d, build: %s:%d): cleaning ... ", package.Data(), gROOT->GetVersion(), gROOT->GetSvnRevision(), v.Data(), rev); // Hard cleanup: go up the dir tree gSystem->ChangeDirectory(fPackageDir); // remove package directory gSystem->Exec(Form("%s %s", kRM, pdir.Data())); // find gunzip... char *gunzip = gSystem->Which(gSystem->Getenv("PATH"), kGUNZIP, kExecutePermission); if (gunzip) { TString par = Form("%s.par", pdir.Data()); // untar package TString cmd(Form(kUNTAR3, gunzip, par.Data())); status = gSystem->Exec(cmd); if ((status = gSystem->Exec(cmd))) { Error("BuildPackageOnCLient", "failure executing: %s", cmd.Data()); } else { // Go down to the package directory gSystem->ChangeDirectory(pdir); } delete [] gunzip; } else { Error("BuildPackageOnCLient", "%s not found", kGUNZIP); status = -1; } } if (gSystem->Exec("PROOF-INF/BUILD.sh")) { Error("BuildPackageOnClient", "building package %s on the client failed", package.Data()); status = -1; } if (savever && !status) { f = fopen("PROOF-INF/proofvers.txt", "w"); if (f) { fputs(gROOT->GetVersion(), f); fputs(Form("\n%d",gROOT->GetSvnRevision()), f); fclose(f); } } } else { PDB(kPackage, 1) Info("BuildPackageOnCLient", "package %s exists but has no PROOF-INF/BUILD.sh script", package.Data()); } gSystem->ChangeDirectory(ocwd); fPackageLock->Unlock(); return status; } return 0; } //______________________________________________________________________________ Int_t TProof::LoadPackage(const char *package, Bool_t notOnClient) { // Load specified package. Executes the PROOF-INF/SETUP.C script // on all active nodes. If notOnClient = true, don't load package // on the client. The default is to load the package also on the client. // Returns 0 in case of success and -1 in case of error. if (!IsValid()) return -1; if (!package || !strlen(package)) { Error("LoadPackage", "need to specify a package name"); return -1; } // if name, erroneously, is a par pathname strip off .par and path TString pac = package; if (pac.EndsWith(".par")) pac.Remove(pac.Length()-4); pac = gSystem->BaseName(pac); if (!notOnClient) if (LoadPackageOnClient(pac) == -1) return -1; TMessage mess(kPROOF_CACHE); mess << Int_t(kLoadPackage) << pac; Broadcast(mess); Collect(); return fStatus; } //______________________________________________________________________________ Int_t TProof::LoadPackageOnClient(const TString &package) { // Load specified package in the client. Executes the PROOF-INF/SETUP.C // script on the client. Returns 0 in case of success and -1 in case of error. // The code is equivalent to the one in TProofServ.cxx (TProof::kLoadPackage // case). Keep in sync in case of changes. if (TestBit(TProof::kIsClient)) { Int_t status = 0; TString pdir, ocwd; // If already loaded don't do it again if (fEnabledPackagesOnClient->FindObject(package)) { Info("LoadPackageOnClient", "package %s already loaded", package.Data()); return 0; } // always follows BuildPackage so no need to check for PROOF-INF pdir = fPackageDir + "/" + package; if (gSystem->AccessPathName(pdir, kReadPermission)) { // Is there a global package with this name? if (fGlobalPackageDirList && fGlobalPackageDirList->GetSize() > 0) { // Scan the list of global packages dirs TIter nxd(fGlobalPackageDirList); TNamed *nm = 0; while ((nm = (TNamed *)nxd())) { pdir = Form("%s/%s", nm->GetTitle(), package.Data()); if (!gSystem->AccessPathName(pdir, kReadPermission)) { // Package found, stop searching break; } pdir = ""; } if (pdir.Length() <= 0) { // Package not found Error("LoadPackageOnClient", "failure locating %s ...", package.Data()); return -1; } } } ocwd = gSystem->WorkingDirectory(); gSystem->ChangeDirectory(pdir); // check for SETUP.C and execute if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) { Int_t err = 0; Int_t errm = gROOT->Macro("PROOF-INF/SETUP.C", &err); if (errm < 0) status = -1; if (err > TInterpreter::kNoError && err <= TInterpreter::kFatal) status = -1; } else { PDB(kPackage, 1) Info("LoadPackageOnCLient", "package %s exists but has no PROOF-INF/SETUP.C script", package.Data()); } gSystem->ChangeDirectory(ocwd); if (!status) { // create link to package in working directory fPackageLock->Lock(); FileStat_t stat; Int_t st = gSystem->GetPathInfo(package, stat); // check if symlink, if so unlink, if not give error // NOTE: GetPathnfo() returns 1 in case of symlink that does not point to // existing file or to a directory, but if fIsLink is true the symlink exists if (stat.fIsLink) gSystem->Unlink(package); else if (st == 0) { Error("LoadPackageOnClient", "cannot create symlink %s in %s on client, " "another item with same name already exists", package.Data(), ocwd.Data()); fPackageLock->Unlock(); return -1; } gSystem->Symlink(pdir, package); fPackageLock->Unlock(); // add package to list of include directories to be searched by ACliC gSystem->AddIncludePath(TString("-I") + package); // add package to list of include directories to be searched by CINT gROOT->ProcessLine(TString(".include ") + package); fEnabledPackagesOnClient->Add(new TObjString(package)); PDB(kPackage, 1) Info("LoadPackageOnClient", "package %s successfully loaded", package.Data()); } else Error("LoadPackageOnClient", "loading package %s on client failed", package.Data()); return status; } return 0; } //______________________________________________________________________________ Int_t TProof::UnloadPackage(const char *package) { // Unload specified package. // Returns 0 in case of success and -1 in case of error. if (!IsValid()) return -1; if (!package || !strlen(package)) { Error("UnloadPackage", "need to specify a package name"); return -1; } // if name, erroneously, is a par pathname strip off .par and path TString pac = package; if (pac.EndsWith(".par")) pac.Remove(pac.Length()-4); pac = gSystem->BaseName(pac); if (UnloadPackageOnClient(pac) == -1) return -1; // Nothing more to do if we are a Lite-session if (IsLite()) return 0; TMessage mess(kPROOF_CACHE); mess << Int_t(kUnloadPackage) << pac; Broadcast(mess); Collect(); return fStatus; } //______________________________________________________________________________ Int_t TProof::UnloadPackageOnClient(const char *package) { // Unload a specific package on the client. // Returns 0 in case of success and -1 in case of error. // The code is equivalent to the one in TProofServ.cxx (TProof::UnloadPackage // case). Keep in sync in case of changes. if (TestBit(TProof::kIsClient)) { TObjString *pack = (TObjString *) fEnabledPackagesOnClient->FindObject(package); if (pack) { // Remove entry from include path TString aclicincpath = gSystem->GetIncludePath(); TString cintincpath = gInterpreter->GetIncludePath(); // remove interpreter part of gSystem->GetIncludePath() aclicincpath.Remove(aclicincpath.Length() - cintincpath.Length() - 1); // remove package's include path aclicincpath.ReplaceAll(TString(" -I") + package, ""); gSystem->SetIncludePath(aclicincpath); //TODO reset interpreter include path // remove entry from enabled packages list fEnabledPackagesOnClient->Remove(pack); } // cleanup the link if (!gSystem->AccessPathName(package)) if (gSystem->Unlink(package) != 0) Warning("UnloadPackageOnClient", "unable to remove symlink to %s", package); // delete entry delete pack; } return 0; } //______________________________________________________________________________ Int_t TProof::UnloadPackages() { // Unload all packages. // Returns 0 in case of success and -1 in case of error. if (!IsValid()) return -1; if (TestBit(TProof::kIsClient)) { // Iterate over packages on the client and remove each package TIter nextpackage(fEnabledPackagesOnClient); while (TObjString *objstr = dynamic_cast<TObjString*>(nextpackage())) if (UnloadPackageOnClient(objstr->String()) == -1 ) return -1; } // Nothing more to do if we are a Lite-session if (IsLite()) return 0; TMessage mess(kPROOF_CACHE); mess << Int_t(kUnloadPackages); Broadcast(mess); Collect(); return fStatus; } //______________________________________________________________________________ Int_t TProof::EnablePackage(const char *package, Bool_t notOnClient) { // Enable specified package. Executes the PROOF-INF/BUILD.sh // script if it exists followed by the PROOF-INF/SETUP.C script. // In case notOnClient = true, don't enable the package on the client. // The default is to enable packages also on the client. // Returns 0 in case of success and -1 in case of error. if (!IsValid()) return -1; if (!package || !strlen(package)) { Error("EnablePackage", "need to specify a package name"); return -1; } // if name, erroneously, is a par pathname strip off .par and path TString pac = package; if (pac.EndsWith(".par")) pac.Remove(pac.Length()-4); pac = gSystem->BaseName(pac); EBuildPackageOpt opt = kBuildAll; if (notOnClient) opt = kDontBuildOnClient; if (BuildPackage(pac, opt) == -1) return -1; if (LoadPackage(pac, notOnClient) == -1) return -1; return 0; } //______________________________________________________________________________ Int_t TProof::UploadPackage(const char *pack, EUploadPackageOpt opt) { // Upload a PROOF archive (PAR file). A PAR file is a compressed // tar file with one special additional directory, PROOF-INF // (blatantly copied from Java's jar format). It must have the extension // .par. A PAR file can be directly a binary or a source with a build // procedure. In the PROOF-INF directory there can be a build script: // BUILD.sh to be called to build the package, in case of a binary PAR // file don't specify a build script or make it a no-op. Then there is // SETUP.C which sets the right environment variables to use the package, // like LD_LIBRARY_PATH, etc. // The 'opt' allows to specify whether the .PAR should be just unpacked // in the existing dir (opt = kUntar, default) or a remove of the existing // directory should be executed (opt = kRemoveOld), so triggering a full // re-build. The option if effective only for PROOF protocol > 8 . // Returns 0 in case of success and -1 in case of error. if (!IsValid()) return -1; TString par = pack; if (!par.EndsWith(".par")) // The client specified only the name: add the extension par += ".par"; // Default location is the local working dir; then the package dir gSystem->ExpandPathName(par); if (gSystem->AccessPathName(par, kReadPermission)) { TString tried = par; // Try the package dir par = Form("%s/%s", fPackageDir.Data(), gSystem->BaseName(par)); if (gSystem->AccessPathName(par, kReadPermission)) { // Is the package a global one if (fGlobalPackageDirList && fGlobalPackageDirList->GetSize() > 0) { // Scan the list of global packages dirs TIter nxd(fGlobalPackageDirList); TNamed *nm = 0; TString pdir; while ((nm = (TNamed *)nxd())) { pdir = Form("%s/%s", nm->GetTitle(), pack); if (!gSystem->AccessPathName(pdir, kReadPermission)) { // Package found, stop searching break; } pdir = ""; } if (pdir.Length() > 0) { // Package is in the global dirs if (gDebug > 0) Info("UploadPackage", "global package found (%s): no upload needed", pdir.Data()); return 0; } } Error("UploadPackage", "PAR file '%s' not found; paths tried: %s, %s", gSystem->BaseName(par), tried.Data(), par.Data()); return -1; } } // Strategy: // On the client: // get md5 of package and check if it is different // from the one stored in the local package directory. If it is lock // the package directory and copy the package, unlock the directory. // On the masters: // get md5 of package and check if it is different from the // one stored on the remote node. If it is different lock the remote // package directory and use TFTP or SendFile to ftp the package to the // remote node, unlock the directory. TMD5 *md5 = TMD5::FileChecksum(par); if (UploadPackageOnClient(par, opt, md5) == -1) { delete md5; return -1; } // Nothing more to do if we are a Lite-session if (IsLite()) { delete md5; return 0; } TString smsg; smsg.Form("+%s", gSystem->BaseName(par)); TMessage mess(kPROOF_CHECKFILE); mess << smsg << (*md5); TMessage mess2(kPROOF_CHECKFILE); smsg.Replace(0, 1, "-"); mess2 << smsg << (*md5); TMessage mess3(kPROOF_CHECKFILE); smsg.Replace(0, 1, "="); mess3 << smsg << (*md5); delete md5; if (fProtocol > 8) { // Send also the option mess << (UInt_t) opt; mess2 << (UInt_t) opt; mess3 << (UInt_t) opt; } // loop over all selected nodes TIter next(fUniqueSlaves); TSlave *sl = 0; while ((sl = (TSlave *) next())) { if (!sl->IsValid()) continue; sl->GetSocket()->Send(mess); fCheckFileStatus = 0; Collect(sl, fCollectTimeout, kPROOF_CHECKFILE); if (fCheckFileStatus == 0) { if (fProtocol > 5) { // remote directory is locked, upload file over the open channel smsg.Form("%s/%s/%s", sl->GetProofWorkDir(), kPROOF_PackDir, gSystem->BaseName(par)); if (SendFile(par, (kBinary | kForce | kCpBin | kForward), smsg.Data(), sl) < 0) { Error("UploadPackage", "%s: problems uploading file %s", sl->GetOrdinal(), par.Data()); return -1; } } else { // old servers receive it via TFTP TFTP ftp(TString("root://")+sl->GetName(), 1); if (!ftp.IsZombie()) { smsg.Form("%s/%s", sl->GetProofWorkDir(), kPROOF_PackDir); ftp.cd(smsg.Data()); ftp.put(par, gSystem->BaseName(par)); } } // install package and unlock dir sl->GetSocket()->Send(mess2); fCheckFileStatus = 0; Collect(sl, fCollectTimeout, kPROOF_CHECKFILE); if (fCheckFileStatus == 0) { Error("UploadPackage", "%s: unpacking of package %s failed", sl->GetOrdinal(), gSystem->BaseName(par)); return -1; } } } // loop over all other master nodes TIter nextmaster(fNonUniqueMasters); TSlave *ma; while ((ma = (TSlave *) nextmaster())) { if (!ma->IsValid()) continue; ma->GetSocket()->Send(mess3); fCheckFileStatus = 0; Collect(sl, fCollectTimeout, kPROOF_CHECKFILE); if (fCheckFileStatus == 0) { // error -> package should have been found Error("UploadPackage", "package %s did not exist on submaster %s", par.Data(), ma->GetOrdinal()); return -1; } } return 0; } //______________________________________________________________________________ Int_t TProof::UploadPackageOnClient(const TString &par, EUploadPackageOpt opt, TMD5 *md5) { // Upload a package on the client in ~/proof/packages. // The 'opt' allows to specify whether the .PAR should be just unpacked // in the existing dir (opt = kUntar, default) or a remove of the existing // directory should be executed (opt = kRemoveOld), thereby triggering a full // re-build. The option if effective only for PROOF protocol > 8 . // Returns 0 in case of success and -1 in case of error. // Strategy: // get md5 of package and check if it is different // from the one stored in the local package directory. If it is lock // the package directory and copy the package, unlock the directory. Int_t status = 0; if (TestBit(TProof::kIsClient)) { // the fPackageDir directory exists (has been created in Init()) // create symlink to the par file in the fPackageDir (needed by // master in case we run on the localhost) fPackageLock->Lock(); TString lpar = fPackageDir + "/" + gSystem->BaseName(par); FileStat_t stat; Int_t st = gSystem->GetPathInfo(lpar, stat); // check if symlink, if so unlink, if not give error // NOTE: GetPathInfo() returns 1 in case of symlink that does not point to // existing file, but if fIsLink is true the symlink exists if (stat.fIsLink) gSystem->Unlink(lpar); else if (st == 0) { Error("UploadPackageOnClient", "cannot create symlink %s on client, " "another item with same name already exists", lpar.Data()); fPackageLock->Unlock(); return -1; } if (!gSystem->IsAbsoluteFileName(par)) { TString fpar = par; gSystem->Symlink(gSystem->PrependPathName(gSystem->WorkingDirectory(), fpar), lpar); } else gSystem->Symlink(par, lpar); // TODO: On Windows need to copy instead of symlink // compare md5 TString packnam = par(0, par.Length() - 4); // strip off ".par" packnam = gSystem->BaseName(packnam); // strip off path TString md5f = fPackageDir + "/" + packnam + "/PROOF-INF/md5.txt"; TMD5 *md5local = TMD5::ReadChecksum(md5f); if (!md5local || (*md5) != (*md5local)) { // if not, unzip and untar package in package directory if ((opt & TProof::kRemoveOld)) { // remove any previous package directory with same name if (gSystem->Exec(Form("%s %s/%s", kRM, fPackageDir.Data(), packnam.Data()))) Error("UploadPackageOnClient", "failure executing: %s %s/%s", kRM, fPackageDir.Data(), packnam.Data()); } // find gunzip char *gunzip = gSystem->Which(gSystem->Getenv("PATH"), kGUNZIP, kExecutePermission); if (gunzip) { // untar package if (gSystem->Exec(Form(kUNTAR2, gunzip, par.Data(), fPackageDir.Data()))) Error("Uploadpackage", "failure executing: %s", Form(kUNTAR2, gunzip, par.Data(), fPackageDir.Data())); delete [] gunzip; } else Error("UploadPackageOnClient", "%s not found", kGUNZIP); // check that fPackageDir/packnam now exists if (gSystem->AccessPathName(fPackageDir + "/" + packnam, kWritePermission)) { // par file did not unpack itself in the expected directory, failure Error("UploadPackageOnClient", "package %s did not unpack into %s/%s", par.Data(), fPackageDir.Data(), packnam.Data()); status = -1; } else { // store md5 in package/PROOF-INF/md5.txt TMD5::WriteChecksum(md5f, md5); } } fPackageLock->Unlock(); delete md5local; } return status; } //______________________________________________________________________________ Int_t TProof::Load(const char *macro, Bool_t notOnClient, Bool_t uniqueWorkers, TList *wrks) { // Load the specified macro on master, workers and, if notOnClient is // kFALSE, on the client. The macro file is uploaded if new or updated. // If existing, the corresponding header basename(macro).h or .hh, is also // uploaded. The default is to load the macro also on the client. // On masters, if uniqueWorkers is kTRUE, the macro is loaded on unique workers // only, and collection is not done; if uniqueWorkers is kFALSE, collection // from the previous request is done, and broadcasting + collection from the // other workers is done. // The wrks arg can be used on the master to limit the set of workers. // Returns 0 in case of success and -1 in case of error. if (!IsValid()) return -1; if (IsLite()) { Warning("Load", "functionality not yet implemented; please use Exec(...)" " or a dedicated PAR package"); return -1; } if (!macro || !strlen(macro)) { Error("Load", "need to specify a macro name"); return -1; } if (TestBit(TProof::kIsClient)) { if (wrks) { Error("Load", "the 'wrks' arg can be used only on the master"); return -1; } // Extract the file implementation name first TString implname = macro; TString acmode, args, io; implname = gSystem->SplitAclicMode(implname, acmode, args, io); // Macro names must have a standard format Int_t dot = implname.Last('.'); if (dot == kNPOS) { Info("Load", "macro '%s' does not contain a '.': do nothing", macro); return -1; } // Is there any associated header file Bool_t hasHeader = kTRUE; TString headname = implname; headname.Remove(dot); headname += ".h"; if (gSystem->AccessPathName(headname, kReadPermission)) { TString h = headname; headname.Remove(dot); headname += ".hh"; if (gSystem->AccessPathName(headname, kReadPermission)) { hasHeader = kFALSE; if (gDebug > 0) Info("Load", "no associated header file found: tried: %s %s", h.Data(), headname.Data()); } } // Send files now; the md5 check is run here; see SendFile for more // details. if (SendFile(implname, kAscii | kForward , "cache") == -1) { Info("Load", "problems sending implementation file %s", implname.Data()); return -1; } if (hasHeader) if (SendFile(headname, kAscii | kForward , "cache") == -1) { Info("Load", "problems sending header file %s", headname.Data()); return -1; } // The files are now on the workers: now we send the loading request TString basemacro = gSystem->BaseName(macro); TMessage mess(kPROOF_CACHE); mess << Int_t(kLoadMacro) << basemacro; Broadcast(mess, kActive); // Load locally, if required if (!notOnClient) { // by first forwarding the load command to the master and workers // and only then loading locally we load/build in parallel gROOT->ProcessLine(Form(".L %s", macro)); // Update the macro path TString mp(TROOT::GetMacroPath()); TString np(gSystem->DirName(macro)); if (!np.IsNull()) { np += ":"; Int_t ip = (mp.BeginsWith(".:")) ? 2 : 0; mp.Insert(ip, np); } TROOT::SetMacroPath(mp); if (gDebug > 0) Info("Load", "macro path set to '%s'", TROOT::GetMacroPath()); } // Wait for master and workers to be done Collect(kActive); } else { // On master // The files are now on the workers: now we send the loading request first // to the unique workers, so that the eventual compilation occurs only once. TString basemacro = gSystem->BaseName(macro); TMessage mess(kPROOF_CACHE); if (uniqueWorkers) { mess << Int_t(kLoadMacro) << basemacro; if (wrks) Broadcast(mess, wrks); else Broadcast(mess, kUnique); } else { // Wait for the result of the previous sending Collect(kUnique); // We then send a tuned loading request to the other workers TList others; TSlave *wrk = 0; TIter nxw(fActiveSlaves); while ((wrk = (TSlave *)nxw())) { if (!fUniqueSlaves->FindObject(wrk)) { others.Add(wrk); } } // Do not force compilation, if it was requested Int_t ld = basemacro.Last('.'); if (ld != kNPOS) { Int_t lpp = basemacro.Index("++", ld); if (lpp != kNPOS) basemacro.Replace(lpp, 2, "+"); } mess << Int_t(kLoadMacro) << basemacro; Broadcast(mess, &others); Collect(&others); } PDB(kGlobal, 1) Info("Load", "adding loaded macro: %s", macro); if (!fLoadedMacros) { fLoadedMacros = new TList(); fLoadedMacros->SetOwner(); } // if wrks is specified the macro should already be loaded on the master. if (!wrks) fLoadedMacros->Add(new TObjString(macro)); } // Done return 0; } //______________________________________________________________________________ Int_t TProof::AddDynamicPath(const char *libpath, Bool_t onClient, TList *wrks) { // Add 'libpath' to the lib path search. // Multiple paths can be specified at once separating them with a comma or // a blank. // Return 0 on success, -1 otherwise if ((!libpath || !strlen(libpath))) { if (gDebug > 0) Info("AddDynamicPath", "list is empty - nothing to do"); return 0; } // Do it also on clients, if required if (onClient) HandleLibIncPath("lib", kTRUE, libpath); TMessage m(kPROOF_LIB_INC_PATH); m << TString("lib") << (Bool_t)kTRUE; // Add paths if (libpath && strlen(libpath)) m << TString(libpath); else m << TString("-"); // Forward the request if (wrks) Broadcast(m, wrks); else Broadcast(m); Collect(kActive, fCollectTimeout); return 0; } //______________________________________________________________________________ Int_t TProof::AddIncludePath(const char *incpath, Bool_t onClient, TList *wrks) { // Add 'incpath' to the inc path search. // Multiple paths can be specified at once separating them with a comma or // a blank. // Return 0 on success, -1 otherwise if ((!incpath || !strlen(incpath))) { if (gDebug > 0) Info("AddIncludePath", "list is empty - nothing to do"); return 0; } // Do it also on clients, if required if (onClient) HandleLibIncPath("inc", kTRUE, incpath); TMessage m(kPROOF_LIB_INC_PATH); m << TString("inc") << (Bool_t)kTRUE; // Add paths if (incpath && strlen(incpath)) m << TString(incpath); else m << TString("-"); // Forward the request if (wrks) Broadcast(m, wrks); else Broadcast(m); Collect(kActive, fCollectTimeout); return 0; } //______________________________________________________________________________ Int_t TProof::RemoveDynamicPath(const char *libpath, Bool_t onClient) { // Remove 'libpath' from the lib path search. // Multiple paths can be specified at once separating them with a comma or // a blank. // Return 0 on success, -1 otherwise if ((!libpath || !strlen(libpath))) { if (gDebug > 0) Info("RemoveDynamicPath", "list is empty - nothing to do"); return 0; } // Do it also on clients, if required if (onClient) HandleLibIncPath("lib", kFALSE, libpath); TMessage m(kPROOF_LIB_INC_PATH); m << TString("lib") <<(Bool_t)kFALSE; // Add paths if (libpath && strlen(libpath)) m << TString(libpath); else m << TString("-"); // Forward the request Broadcast(m); Collect(kActive, fCollectTimeout); return 0; } //______________________________________________________________________________ Int_t TProof::RemoveIncludePath(const char *incpath, Bool_t onClient) { // Remove 'incpath' from the inc path search. // Multiple paths can be specified at once separating them with a comma or // a blank. // Return 0 on success, -1 otherwise if ((!incpath || !strlen(incpath))) { if (gDebug > 0) Info("RemoveIncludePath", "list is empty - nothing to do"); return 0; } // Do it also on clients, if required if (onClient) HandleLibIncPath("in", kFALSE, incpath); TMessage m(kPROOF_LIB_INC_PATH); m << TString("inc") << (Bool_t)kFALSE; // Add paths if (incpath && strlen(incpath)) m << TString(incpath); else m << TString("-"); // Forward the request Broadcast(m); Collect(kActive, fCollectTimeout); return 0; } //______________________________________________________________________________ void TProof::HandleLibIncPath(const char *what, Bool_t add, const char *dirs) { // Handle lib, inc search paths modification request TString type(what); TString path(dirs); // Check type of action if ((type != "lib") && (type != "inc")) { Error("HandleLibIncPath","unknown action type: %s", type.Data()); return; } // Separators can be either commas or blanks path.ReplaceAll(","," "); // Decompose lists TObjArray *op = 0; if (path.Length() > 0 && path != "-") { if (!(op = path.Tokenize(" "))) { Error("HandleLibIncPath","decomposing path %s", path.Data()); return; } } if (add) { if (type == "lib") { // Add libs TIter nxl(op, kIterBackward); TObjString *lib = 0; while ((lib = (TObjString *) nxl())) { // Expand path TString xlib = lib->GetName(); gSystem->ExpandPathName(xlib); // Add to the dynamic lib search path if it exists and can be read if (!gSystem->AccessPathName(xlib, kReadPermission)) { TString newlibpath = gSystem->GetDynamicPath(); // In the first position after the working dir Int_t pos = 0; if (newlibpath.BeginsWith(".:")) pos = 2; if (newlibpath.Index(xlib) == kNPOS) { newlibpath.Insert(pos,Form("%s:", xlib.Data())); gSystem->SetDynamicPath(newlibpath); } } else { Info("HandleLibIncPath", "libpath %s does not exist or cannot be read - not added", xlib.Data()); } } } else { // Add incs TIter nxi(op); TObjString *inc = 0; while ((inc = (TObjString *) nxi())) { // Expand path TString xinc = inc->GetName(); gSystem->ExpandPathName(xinc); // Add to the dynamic lib search path if it exists and can be read if (!gSystem->AccessPathName(xinc, kReadPermission)) { TString curincpath = gSystem->GetIncludePath(); if (curincpath.Index(xinc) == kNPOS) gSystem->AddIncludePath(Form("-I%s", xinc.Data())); } else Info("HandleLibIncPath", "incpath %s does not exist or cannot be read - not added", xinc.Data()); } } } else { if (type == "lib") { // Remove libs TIter nxl(op); TObjString *lib = 0; while ((lib = (TObjString *) nxl())) { // Expand path TString xlib = lib->GetName(); gSystem->ExpandPathName(xlib); // Remove from the dynamic lib search path TString newlibpath = gSystem->GetDynamicPath(); newlibpath.ReplaceAll(Form("%s:", xlib.Data()),""); gSystem->SetDynamicPath(newlibpath); } } else { // Remove incs TIter nxi(op); TObjString *inc = 0; while ((inc = (TObjString *) nxi())) { TString newincpath = gSystem->GetIncludePath(); newincpath.ReplaceAll(Form("-I%s", inc->GetName()),""); // Remove the interpreter path (added anyhow internally) newincpath.ReplaceAll(gInterpreter->GetIncludePath(),""); gSystem->SetIncludePath(newincpath); } } } } //______________________________________________________________________________ TList *TProof::GetListOfPackages() { // Get from the master the list of names of the packages available. if (!IsValid()) return (TList *)0; TMessage mess(kPROOF_CACHE); mess << Int_t(kListPackages); Broadcast(mess); Collect(kActive, fCollectTimeout); return fAvailablePackages; } //______________________________________________________________________________ TList *TProof::GetListOfEnabledPackages() { // Get from the master the list of names of the packages enabled. if (!IsValid()) return (TList *)0; TMessage mess(kPROOF_CACHE); mess << Int_t(kListEnabledPackages); Broadcast(mess); Collect(kActive, fCollectTimeout); return fEnabledPackages; } //______________________________________________________________________________ void TProof::PrintProgress(Long64_t total, Long64_t processed, Float_t procTime) { // Print a progress bar on stderr. Used in batch mode. if (fPrintProgress) { Bool_t redirlog = fRedirLog; fRedirLog = kFALSE; // Call the external function (*fPrintProgress)(total, processed, procTime); fRedirLog = redirlog; return; } fprintf(stderr, "[TProof::Progress] Total %lld events\t|", total); for (int l = 0; l < 20; l++) { if (total > 0) { if (l < 20*processed/total) fprintf(stderr, "="); else if (l == 20*processed/total) fprintf(stderr, ">"); else if (l > 20*processed/total) fprintf(stderr, "."); } else fprintf(stderr, "="); } Float_t evtrti = (procTime > 0. && processed > 0) ? processed / procTime : -1.; if (evtrti > 0.) fprintf(stderr, "| %.02f %% [%.1f evts/s]\r", (total ? ((100.0*processed)/total) : 100.0), evtrti); else fprintf(stderr, "| %.02f %%\r", (total ? ((100.0*processed)/total) : 100.0)); if (processed >= total) fprintf(stderr, "\n"); } //______________________________________________________________________________ void TProof::Progress(Long64_t total, Long64_t processed) { // Get query progress information. Connect a slot to this signal // to track progress. if (fPrintProgress) { // Call the external function return (*fPrintProgress)(total, processed, -1.); } PDB(kGlobal,1) Info("Progress","%2f (%lld/%lld)", 100.*processed/total, processed, total); if (gROOT->IsBatch()) { // Simple progress bar if (total > 0) PrintProgress(total, processed); } else { EmitVA("Progress(Long64_t,Long64_t)", 2, total, processed); } } //______________________________________________________________________________ void TProof::Progress(Long64_t total, Long64_t processed, Long64_t bytesread, Float_t initTime, Float_t procTime, Float_t evtrti, Float_t mbrti) { // Get query progress information. Connect a slot to this signal // to track progress. PDB(kGlobal,1) Info("Progress","%lld %lld %lld %f %f %f %f", total, processed, bytesread, initTime, procTime, evtrti, mbrti); if (gROOT->IsBatch()) { // Simple progress bar if (total > 0) PrintProgress(total, processed, procTime); } else { EmitVA("Progress(Long64_t,Long64_t,Long64_t,Float_t,Float_t,Float_t,Float_t)", 7, total, processed, bytesread, initTime, procTime, evtrti, mbrti); } } //______________________________________________________________________________ void TProof::Feedback(TList *objs) { // Get list of feedback objects. Connect a slot to this signal // to monitor the feedback object. PDB(kGlobal,1) Info("Feedback","%d objects", objs->GetSize()); PDB(kFeedback,1) { Info("Feedback","%d objects", objs->GetSize()); objs->ls(); } Emit("Feedback(TList *objs)", (Long_t) objs); } //______________________________________________________________________________ void TProof::CloseProgressDialog() { // Close progress dialog. PDB(kGlobal,1) Info("CloseProgressDialog", "called: have progress dialog: %d", fProgressDialogStarted); // Nothing to do if not there if (!fProgressDialogStarted) return; Emit("CloseProgressDialog()"); } //______________________________________________________________________________ void TProof::ResetProgressDialog(const char *sel, Int_t sz, Long64_t fst, Long64_t ent) { // Reset progress dialog. PDB(kGlobal,1) Info("ResetProgressDialog","(%s,%d,%lld,%lld)", sel, sz, fst, ent); EmitVA("ResetProgressDialog(const char*,Int_t,Long64_t,Long64_t)", 4, sel, sz, fst, ent); } //______________________________________________________________________________ void TProof::StartupMessage(const char *msg, Bool_t st, Int_t done, Int_t total) { // Send startup message. PDB(kGlobal,1) Info("StartupMessage","(%s,%d,%d,%d)", msg, st, done, total); EmitVA("StartupMessage(const char*,Bool_t,Int_t,Int_t)", 4, msg, st, done, total); } //______________________________________________________________________________ void TProof::DataSetStatus(const char *msg, Bool_t st, Int_t done, Int_t total) { // Send dataset preparation status. PDB(kGlobal,1) Info("DataSetStatus","(%s,%d,%d,%d)", msg, st, done, total); EmitVA("DataSetStatus(const char*,Bool_t,Int_t,Int_t)", 4, msg, st, done, total); } //______________________________________________________________________________ void TProof::SendDataSetStatus(const char *action, UInt_t done, UInt_t tot, Bool_t st) { // Send or notify data set status if (IsLite()) { if (tot) { TString type = "files"; Int_t frac = (Int_t) (done*100.)/tot; char msg[512] = {0}; if (frac >= 100) { sprintf(msg,"%s: OK (%d %s) \n", action,tot, type.Data()); } else { sprintf(msg,"%s: %d out of %d (%d %%)\r", action, done, tot, frac); } if (fSync) fprintf(stderr,"%s", msg); else NotifyLogMsg(msg, 0); } return; } if (TestBit(TProof::kIsMaster)) { TMessage mess(kPROOF_DATASET_STATUS); mess << TString(action) << tot << done << st; gProofServ->GetSocket()->Send(mess); } } //______________________________________________________________________________ void TProof::QueryResultReady(const char *ref) { // Notify availability of a query result. PDB(kGlobal,1) Info("QueryResultReady","ref: %s", ref); Emit("QueryResultReady(const char*)",ref); } //______________________________________________________________________________ void TProof::ValidateDSet(TDSet *dset) { // Validate a TDSet. if (dset->ElementsValid()) return; TList nodes; nodes.SetOwner(); TList slholder; slholder.SetOwner(); TList elemholder; elemholder.SetOwner(); // build nodelist with slaves and elements TIter nextSlave(GetListOfActiveSlaves()); while (TSlave *sl = dynamic_cast<TSlave*>(nextSlave())) { TList *sllist = 0; TPair *p = dynamic_cast<TPair*>(nodes.FindObject(sl->GetName())); if (!p) { sllist = new TList; sllist->SetName(sl->GetName()); slholder.Add(sllist); TList *elemlist = new TList; elemlist->SetName(TString(sl->GetName())+"_elem"); elemholder.Add(elemlist); nodes.Add(new TPair(sllist, elemlist)); } else { sllist = dynamic_cast<TList*>(p->Key()); } sllist->Add(sl); } // add local elements to nodes TList nonLocal; // list of nonlocal elements // make two iterations - first add local elements - then distribute nonlocals for (Int_t i = 0; i < 2; i++) { Bool_t local = i>0?kFALSE:kTRUE; TIter nextElem(local ? dset->GetListOfElements() : &nonLocal); while (TDSetElement *elem = dynamic_cast<TDSetElement*>(nextElem())) { if (elem->GetValid()) continue; TPair *p = dynamic_cast<TPair*>(local?nodes.FindObject(TUrl(elem->GetFileName()).GetHost()):nodes.At(0)); if (p) { TList *eli = dynamic_cast<TList*>(p->Value()); TList *sli = dynamic_cast<TList*>(p->Key()); eli->Add(elem); // order list by elements/slave TPair *p2 = p; Bool_t stop = kFALSE; while (!stop) { TPair *p3 = dynamic_cast<TPair*>(nodes.After(p2->Key())); if (p3) { Int_t nelem = dynamic_cast<TList*>(p3->Value())->GetSize(); Int_t nsl = dynamic_cast<TList*>(p3->Key())->GetSize(); if (nelem*sli->GetSize() < eli->GetSize()*nsl) p2 = p3; else stop = kTRUE; } else { stop = kTRUE; } } if (p2!=p) { nodes.Remove(p->Key()); nodes.AddAfter(p2->Key(), p); } } else { if (local) { nonLocal.Add(elem); } else { Error("ValidateDSet", "No Node to allocate TDSetElement to"); R__ASSERT(0); } } } } // send to slaves TList usedslaves; TIter nextNode(&nodes); SetDSet(dset); // set dset to be validated in Collect() while (TPair *node = dynamic_cast<TPair*>(nextNode())) { TList *slaves = dynamic_cast<TList*>(node->Key()); TList *setelements = dynamic_cast<TList*>(node->Value()); // distribute elements over the slaves Int_t nslaves = slaves->GetSize(); Int_t nelements = setelements->GetSize(); for (Int_t i=0; i<nslaves; i++) { TDSet copyset(dset->GetType(), dset->GetObjName(), dset->GetDirectory()); for (Int_t j = (i*nelements)/nslaves; j < ((i+1)*nelements)/nslaves; j++) { TDSetElement *elem = dynamic_cast<TDSetElement*>(setelements->At(j)); copyset.Add(elem->GetFileName(), elem->GetObjName(), elem->GetDirectory(), elem->GetFirst(), elem->GetNum(), elem->GetMsd()); } if (copyset.GetListOfElements()->GetSize()>0) { TMessage mesg(kPROOF_VALIDATE_DSET); mesg << ©set; TSlave *sl = dynamic_cast<TSlave*>(slaves->At(i)); PDB(kGlobal,1) Info("ValidateDSet", "Sending TDSet with %d elements to slave %s" " to be validated", copyset.GetListOfElements()->GetSize(), sl->GetOrdinal()); sl->GetSocket()->Send(mesg); usedslaves.Add(sl); } } } PDB(kGlobal,1) Info("ValidateDSet","Calling Collect"); Collect(&usedslaves); SetDSet(0); } //______________________________________________________________________________ void TProof::AddInputData(TObject *obj, Bool_t push) { // Add data objects that might be needed during the processing of // the selector (see Process()). This object can be very large, so they // are distributed in an optimized way using a dedicated file. // If push is TRUE the input data are sent over even if no apparent change // occured to the list. if (obj) { if (!fInputData) fInputData = new TList; if (!fInputData->FindObject(obj)) { fInputData->Add(obj); SetBit(TProof::kNewInputData); } } if (push) SetBit(TProof::kNewInputData); } //______________________________________________________________________________ void TProof::ClearInputData(TObject *obj) { // Remove obj form the input data list; if obj is null (default), clear the // input data info. if (!obj) { if (fInputData) { fInputData->SetOwner(kTRUE); SafeDelete(fInputData); } ResetBit(TProof::kNewInputData); // Also remove any info about input data in the input list TObject *o = 0; TList *in = GetInputList(); while ((o = GetInputList()->FindObject("PROOF_InputDataFile"))) in->Remove(o); while ((o = GetInputList()->FindObject("PROOF_InputData"))) in->Remove(o); // ... and reset the file fInputDataFile = ""; gSystem->Unlink(kPROOF_InputDataFile); } else if (fInputData) { Int_t sz = fInputData->GetSize(); while (fInputData->FindObject(obj)) fInputData->Remove(obj); // Flag for update, if anything changed if (sz != fInputData->GetSize()) SetBit(TProof::kNewInputData); } } //______________________________________________________________________________ void TProof::ClearInputData(const char *name) { // Remove obj 'name' form the input data list; TObject *obj = (fInputData && name) ? fInputData->FindObject(name) : 0; if (obj) ClearInputData(obj); } //______________________________________________________________________________ void TProof::SetInputDataFile(const char *datafile) { // Set the file to be used to optimally distribute the input data objects. // If the file exists the object in the file are added to those in the // fInputData list. If the file path is null, a default file will be created // at the moment of sending the processing request with the content of // the fInputData list. See also SendInputDataFile. if (datafile && strlen(datafile) > 0) { if (fInputDataFile != datafile && strcmp(datafile, kPROOF_InputDataFile)) SetBit(TProof::kNewInputData); fInputDataFile = datafile; } else { if (!fInputDataFile.IsNull()) SetBit(TProof::kNewInputData); fInputDataFile = ""; } // Make sure that the chosen file is readable if (fInputDataFile != kPROOF_InputDataFile && !fInputDataFile.IsNull() && gSystem->AccessPathName(fInputDataFile, kReadPermission)) { fInputDataFile = ""; } } //______________________________________________________________________________ void TProof::SendInputDataFile() { // Send the input data objects to the master; the objects are taken from the // dedicated list and / or the specified file. // If the fInputData is empty the specified file is sent over. // If there is no specified file, a file named "inputdata.root" is created locally // with the content of fInputData and sent over to the master. // If both fInputData and the specified file are not empty, a copy of the file // is made locally and augmented with the content of fInputData. // Prepare the file TString dataFile; PrepareInputDataFile(dataFile); // Send it, if not empty if (dataFile.Length() > 0) { Info("SendInputDataFile", "broadcasting %s", dataFile.Data()); BroadcastFile(dataFile.Data(), kBinary, "cache", kActive); // Set the name in the input list AddInput(new TNamed("PROOF_InputDataFile", Form("cache:%s", gSystem->BaseName(dataFile)))); } } //______________________________________________________________________________ void TProof::PrepareInputDataFile(TString &dataFile) { // Prepare the file with the input data objects to be sent the master; the // objects are taken from the dedicated list and / or the specified file. // If the fInputData is empty the specified file is sent over. // If there is no specified file, a file named "inputdata.root" is created locally // with the content of fInputData and sent over to the master. // If both fInputData and the specified file are not empty, a copy of the file // is made locally and augmented with the content of fInputData. // Save info about new data for usage in this call; Bool_t newdata = TestBit(TProof::kNewInputData) ? kTRUE : kFALSE; // Next time we need some change ResetBit(TProof::kNewInputData); // Check the list Bool_t list_ok = (fInputData && fInputData->GetSize() > 0) ? kTRUE : kFALSE; // Check the file Bool_t file_ok = kFALSE; if (fInputDataFile != kPROOF_InputDataFile && !fInputDataFile.IsNull() && !gSystem->AccessPathName(fInputDataFile, kReadPermission)) { // It must contain something TFile *f = TFile::Open(fInputDataFile); if (f && f->GetListOfKeys() && f->GetListOfKeys()->GetSize() > 0) file_ok = kTRUE; } // Remove any info about input data in the input list TObject *o = 0; TList *in = GetInputList(); while ((o = GetInputList()->FindObject("PROOF_InputDataFile"))) in->Remove(o); while ((o = GetInputList()->FindObject("PROOF_InputData"))) in->Remove(o); // We must have something to send dataFile = ""; if (!list_ok && !file_ok) return; // Three cases: if (file_ok && !list_ok) { // Just send the file dataFile = fInputDataFile; } else if (!file_ok && list_ok) { fInputDataFile = kPROOF_InputDataFile; // Nothing to do, if no new data if (!newdata && !gSystem->AccessPathName(fInputDataFile)) return; // Create the file first TFile *f = TFile::Open(fInputDataFile, "RECREATE"); if (f) { f->cd(); TIter next(fInputData); TObject *obj; while ((obj = next())) { obj->Write(0, TObject::kSingleKey, 0); } f->Close(); SafeDelete(f); } else { Error("PrepareInputDataFile", "could not (re-)create %s", fInputDataFile.Data()); return; } dataFile = fInputDataFile; } else if (file_ok && list_ok) { dataFile = kPROOF_InputDataFile; // Create the file if not existing or there are new data if (newdata || gSystem->AccessPathName(dataFile)) { // Cleanup previous file if obsolete if (!gSystem->AccessPathName(dataFile)) gSystem->Unlink(dataFile); if (dataFile != fInputDataFile) { // Make a local copy first if (gSystem->CopyFile(fInputDataFile, dataFile, kTRUE) != 0) { Error("PrepareInputDataFile", "could not make local copy of %s", fInputDataFile.Data()); return; } } // Add the input data list TFile *f = TFile::Open(dataFile, "UPDATE"); if (f) { f->cd(); TIter next(fInputData); TObject *obj = 0; while ((obj = next())) { obj->Write(0, TObject::kSingleKey, 0); } f->Close(); SafeDelete(f); } else { Error("PrepareInputDataFile", "could not open %s for updating", dataFile.Data()); return; } } } // Done return; } //______________________________________________________________________________ void TProof::AddInput(TObject *obj) { // Add objects that might be needed during the processing of // the selector (see Process()). if (fPlayer) fPlayer->AddInput(obj); } //______________________________________________________________________________ void TProof::ClearInput() { // Clear input object list. if (fPlayer) fPlayer->ClearInput(); // the system feedback list is always in the input list AddInput(fFeedback); } //______________________________________________________________________________ TList *TProof::GetInputList() { // Get input list. return (fPlayer ? fPlayer->GetInputList() : (TList *)0); } //______________________________________________________________________________ TObject *TProof::GetOutput(const char *name) { // Get specified object that has been produced during the processing // (see Process()). // Can be called by MarkBad on the master before the player is initialized return (fPlayer) ? fPlayer->GetOutput(name) : (TObject *)0; } //______________________________________________________________________________ TList *TProof::GetOutputList() { // Get list with all object created during processing (see Process()). return (fPlayer ? fPlayer->GetOutputList() : (TList *)0); } //______________________________________________________________________________ void TProof::SetParameter(const char *par, const char *value) { // Set input list parameter. If the parameter is already // set it will be set to the new value. if (!fPlayer) { Warning("SetParameter", "player undefined! Ignoring"); return; } TList *il = fPlayer->GetInputList(); TObject *item = il->FindObject(par); if (item) { il->Remove(item); delete item; } il->Add(new TNamed(par, value)); } //______________________________________________________________________________ void TProof::SetParameter(const char *par, Int_t value) { // Set an input list parameter. if (!fPlayer) { Warning("SetParameter", "player undefined! Ignoring"); return; } TList *il = fPlayer->GetInputList(); TObject *item = il->FindObject(par); if (item) { il->Remove(item); delete item; } il->Add(new TParameter<Int_t>(par, value)); } //______________________________________________________________________________ void TProof::SetParameter(const char *par, Long_t value) { // Set an input list parameter. if (!fPlayer) { Warning("SetParameter", "player undefined! Ignoring"); return; } TList *il = fPlayer->GetInputList(); TObject *item = il->FindObject(par); if (item) { il->Remove(item); delete item; } il->Add(new TParameter<Long_t>(par, value)); } //______________________________________________________________________________ void TProof::SetParameter(const char *par, Long64_t value) { // Set an input list parameter. if (!fPlayer) { Warning("SetParameter", "player undefined! Ignoring"); return; } TList *il = fPlayer->GetInputList(); TObject *item = il->FindObject(par); if (item) { il->Remove(item); delete item; } il->Add(new TParameter<Long64_t>(par, value)); } //______________________________________________________________________________ void TProof::SetParameter(const char *par, Double_t value) { // Set an input list parameter. if (!fPlayer) { Warning("SetParameter", "player undefined! Ignoring"); return; } TList *il = fPlayer->GetInputList(); TObject *item = il->FindObject(par); if (item) { il->Remove(item); delete item; } il->Add(new TParameter<Double_t>(par, value)); } //______________________________________________________________________________ TObject *TProof::GetParameter(const char *par) const { // Get specified parameter. A parameter set via SetParameter() is either // a TParameter or a TNamed or 0 in case par is not defined. if (!fPlayer) { Warning("GetParameter", "player undefined! Ignoring"); return (TObject *)0; } TList *il = fPlayer->GetInputList(); return il->FindObject(par); } //______________________________________________________________________________ void TProof::DeleteParameters(const char *wildcard) { // Delete the input list parameters specified by a wildcard (e.g. PROOF_*) // or exact name (e.g. PROOF_MaxSlavesPerNode). if (!fPlayer) return; if (!wildcard) wildcard = ""; TRegexp re(wildcard, kTRUE); Int_t nch = strlen(wildcard); TList *il = fPlayer->GetInputList(); TObject *p; TIter next(il); while ((p = next())) { TString s = p->GetName(); if (nch && s != wildcard && s.Index(re) == kNPOS) continue; il->Remove(p); delete p; } } //______________________________________________________________________________ void TProof::ShowParameters(const char *wildcard) const { // Show the input list parameters specified by the wildcard. // Default is the special PROOF control parameters (PROOF_*). if (!fPlayer) return; if (!wildcard) wildcard = ""; TRegexp re(wildcard, kTRUE); Int_t nch = strlen(wildcard); TList *il = fPlayer->GetInputList(); TObject *p; TIter next(il); while ((p = next())) { TString s = p->GetName(); if (nch && s != wildcard && s.Index(re) == kNPOS) continue; if (p->IsA() == TNamed::Class()) { Printf("%s\t\t\t%s", s.Data(), p->GetTitle()); } else if (p->IsA() == TParameter<Long_t>::Class()) { Printf("%s\t\t\t%ld", s.Data(), dynamic_cast<TParameter<Long_t>*>(p)->GetVal()); } else if (p->IsA() == TParameter<Long64_t>::Class()) { Printf("%s\t\t\t%lld", s.Data(), dynamic_cast<TParameter<Long64_t>*>(p)->GetVal()); } else if (p->IsA() == TParameter<Double_t>::Class()) { Printf("%s\t\t\t%f", s.Data(), dynamic_cast<TParameter<Double_t>*>(p)->GetVal()); } else { Printf("%s\t\t\t%s", s.Data(), p->GetTitle()); } } } //______________________________________________________________________________ void TProof::AddFeedback(const char *name) { // Add object to feedback list. PDB(kFeedback, 3) Info("AddFeedback", "Adding object \"%s\" to feedback", name); if (fFeedback->FindObject(name) == 0) fFeedback->Add(new TObjString(name)); } //______________________________________________________________________________ void TProof::RemoveFeedback(const char *name) { // Remove object from feedback list. TObject *obj = fFeedback->FindObject(name); if (obj != 0) { fFeedback->Remove(obj); delete obj; } } //______________________________________________________________________________ void TProof::ClearFeedback() { // Clear feedback list. fFeedback->Delete(); } //______________________________________________________________________________ void TProof::ShowFeedback() const { // Show items in feedback list. if (fFeedback->GetSize() == 0) { Info("","no feedback requested"); return; } fFeedback->Print(); } //______________________________________________________________________________ TList *TProof::GetFeedbackList() const { // Return feedback list. return fFeedback; } //______________________________________________________________________________ TTree *TProof::GetTreeHeader(TDSet *dset) { // Creates a tree header (a tree with nonexisting files) object for // the DataSet. TList *l = GetListOfActiveSlaves(); TSlave *sl = (TSlave*) l->First(); if (sl == 0) { Error("GetTreeHeader", "No connection"); return 0; } TSocket *soc = sl->GetSocket(); TMessage msg(kPROOF_GETTREEHEADER); msg << dset; soc->Send(msg); TMessage *reply; Int_t d = -1; if (fProtocol >= 20) { Collect(sl, fCollectTimeout, kPROOF_GETTREEHEADER); reply = (TMessage *) fRecvMessages->First(); } else { d = soc->Recv(reply); } if (!reply) { Error("GetTreeHeader", "Error getting a replay from the master.Result %d", (int) d); return 0; } TString s1; TTree *t = 0; (*reply) >> s1; if (s1 == "Success") (*reply) >> t; PDB(kGlobal, 1) { if (t) { Info("GetTreeHeader", "%s, message size: %d, entries: %d", s1.Data(), reply->BufferSize(), (int) t->GetMaxEntryLoop()); } else { Info("GetTreeHeader", "tree header retrieval failed"); } } delete reply; return t; } //______________________________________________________________________________ TDrawFeedback *TProof::CreateDrawFeedback() { // Draw feedback creation proxy. When accessed via TProof avoids // link dependency on libProofPlayer. return (fPlayer ? fPlayer->CreateDrawFeedback(this) : (TDrawFeedback *)0); } //______________________________________________________________________________ void TProof::SetDrawFeedbackOption(TDrawFeedback *f, Option_t *opt) { // Set draw feedback option. if (fPlayer) fPlayer->SetDrawFeedbackOption(f, opt); } //______________________________________________________________________________ void TProof::DeleteDrawFeedback(TDrawFeedback *f) { // Delete draw feedback object. if (fPlayer) fPlayer->DeleteDrawFeedback(f); } //______________________________________________________________________________ TList *TProof::GetOutputNames() { // FIXME: to be written return 0; /* TMessage msg(kPROOF_GETOUTPUTLIST); TList* slaves = fActiveSlaves; Broadcast(msg, slaves); TMonitor mon; TList* outputList = new TList(); TIter si(slaves); TSlave *slave; while ((slave = (TSlave*)si.Next()) != 0) { PDB(kGlobal,4) Info("GetOutputNames","Socket added to monitor: %p (%s)", slave->GetSocket(), slave->GetName()); mon.Add(slave->GetSocket()); } mon.ActivateAll(); ((TProof*)gProof)->DeActivateAsyncInput(); ((TProof*)gProof)->fCurrentMonitor = &mon; while (mon.GetActive() != 0) { TSocket *sock = mon.Select(); if (!sock) { Error("GetOutputList","TMonitor::.Select failed!"); break; } mon.DeActivate(sock); TMessage *reply; if (sock->Recv(reply) <= 0) { MarkBad(slave, "receive failed after kPROOF_GETOUTPUTLIST request"); // Error("GetOutputList","Recv failed! for slave-%d (%s)", // slave->GetOrdinal(), slave->GetName()); continue; } if (reply->What() != kPROOF_GETOUTPUTNAMES ) { // Error("GetOutputList","unexpected message %d from slawe-%d (%s)", reply->What(), // slave->GetOrdinal(), slave->GetName()); MarkBad(slave, "wrong reply to kPROOF_GETOUTPUTLIST request"); continue; } TList* l; (*reply) >> l; TIter next(l); TNamed *n; while ( (n = dynamic_cast<TNamed*> (next())) ) { if (!outputList->FindObject(n->GetName())) outputList->Add(n); } delete reply; } ((TProof*)gProof)->fCurrentMonitor = 0; return outputList; */ } //______________________________________________________________________________ void TProof::Browse(TBrowser *b) { // Build the PROOF's structure in the browser. b->Add(fActiveSlaves, fActiveSlaves->Class(), "fActiveSlaves"); b->Add(&fMaster, fMaster.Class(), "fMaster"); b->Add(fFeedback, fFeedback->Class(), "fFeedback"); b->Add(fChains, fChains->Class(), "fChains"); if (fPlayer) { b->Add(fPlayer->GetInputList(), fPlayer->GetInputList()->Class(), "InputList"); if (fPlayer->GetOutputList()) b->Add(fPlayer->GetOutputList(), fPlayer->GetOutputList()->Class(), "OutputList"); if (fPlayer->GetListOfResults()) b->Add(fPlayer->GetListOfResults(), fPlayer->GetListOfResults()->Class(), "ListOfResults"); } } //______________________________________________________________________________ void TProof::SetPlayer(TVirtualProofPlayer *player) { // Set a new PROOF player. if (fPlayer) delete fPlayer; fPlayer = player; }; //______________________________________________________________________________ TVirtualProofPlayer *TProof::MakePlayer(const char *player, TSocket *s) { // Construct a TProofPlayer object. The player string specifies which // player should be created: remote, slave, sm (supermaster) or base. // Default is remote. Socket is needed in case a slave player is created. if (!player) player = "remote"; SetPlayer(TVirtualProofPlayer::Create(player, this, s)); return GetPlayer(); } //______________________________________________________________________________ void TProof::AddChain(TChain *chain) { // Add chain to data set fChains->Add(chain); } //______________________________________________________________________________ void TProof::RemoveChain(TChain *chain) { // Remove chain from data set fChains->Remove(chain); } //______________________________________________________________________________ void TProof::GetLog(Int_t start, Int_t end) { // Ask for remote logs in the range [start, end]. If start == -1 all the // messages not yet received are sent back. if (!IsValid() || TestBit(TProof::kIsMaster)) return; TMessage msg(kPROOF_LOGFILE); msg << start << end; Broadcast(msg, kActive); Collect(kActive, fCollectTimeout); } //______________________________________________________________________________ void TProof::PutLog(TQueryResult *pq) { // Display log of query pq into the log window frame if (!pq) return; TList *lines = pq->GetLogFile()->GetListOfLines(); if (lines) { TIter nxl(lines); TObjString *l = 0; while ((l = (TObjString *)nxl())) EmitVA("LogMessage(const char*,Bool_t)", 2, l->GetName(), kFALSE); } } //______________________________________________________________________________ void TProof::ShowLog(const char *queryref) { // Display on screen the content of the temporary log file for query // in reference // Make sure we have all info (GetListOfQueries retrieves the // head info only) Retrieve(queryref); if (fPlayer) { if (queryref) { if (fPlayer->GetListOfResults()) { TIter nxq(fPlayer->GetListOfResults()); TQueryResult *qr = 0; while ((qr = (TQueryResult *) nxq())) if (strstr(queryref, qr->GetTitle()) && strstr(queryref, qr->GetName())) break; if (qr) { PutLog(qr); return; } } } } } //______________________________________________________________________________ void TProof::ShowLog(Int_t qry) { // Display on screen the content of the temporary log file. // If qry == -2 show messages from the last (current) query. // If qry == -1 all the messages not yet displayed are shown (default). // If qry == 0, all the messages in the file are shown. // If qry > 0, only the messages related to query 'qry' are shown. // For qry != -1 the original file offset is restored at the end // Save present offset Int_t nowlog = lseek(fileno(fLogFileR), (off_t) 0, SEEK_CUR); // Get extremes Int_t startlog = nowlog; Int_t endlog = lseek(fileno(fLogFileR), (off_t) 0, SEEK_END); lseek(fileno(fLogFileR), (off_t) nowlog, SEEK_SET); if (qry == 0) { startlog = 0; lseek(fileno(fLogFileR), (off_t) 0, SEEK_SET); } else if (qry != -1) { TQueryResult *pq = 0; if (qry == -2) { // Pickup the last one pq = (GetQueryResults()) ? ((TQueryResult *)(GetQueryResults()->Last())) : 0; if (!pq) { GetListOfQueries(); if (fQueries) pq = (TQueryResult *)(fQueries->Last()); } } else if (qry > 0) { TList *queries = GetQueryResults(); if (queries) { TIter nxq(queries); while ((pq = (TQueryResult *)nxq())) if (qry == pq->GetSeqNum()) break; } if (!pq) { queries = GetListOfQueries(); TIter nxq(queries); while ((pq = (TQueryResult *)nxq())) if (qry == pq->GetSeqNum()) break; } } if (pq) { PutLog(pq); return; } else { if (gDebug > 0) Info("ShowLog","query %d not found in list", qry); qry = -1; } } // Number of bytes to log UInt_t tolog = (UInt_t)(endlog - startlog); // Perhaps nothing if (tolog <= 0) // Set starting point lseek(fileno(fLogFileR), (off_t) startlog, SEEK_SET); // Now we go Int_t np = 0; char line[2048]; Int_t wanted = (tolog > sizeof(line)) ? sizeof(line) : tolog; while (fgets(line, wanted, fLogFileR)) { Int_t r = strlen(line); if (!SendingLogToWindow()) { if (line[r-1] != '\n') line[r-1] = '\n'; if (r > 0) { char *p = line; while (r) { Int_t w = write(fileno(stdout), p, r); if (w < 0) { SysError("ShowLogFile", "error writing to stdout"); break; } r -= w; p += w; } } tolog -= strlen(line); np++; // Ask if more is wanted if (!(np%10)) { char *opt = Getline("More (y/n)? [y]"); if (opt[0] == 'n') break; } // We may be over if (tolog <= 0) break; // Update wanted bytes wanted = (tolog > sizeof(line)) ? sizeof(line) : tolog; } else { // Log to window if (line[r-1] == '\n') line[r-1] = 0; LogMessage(line, kFALSE); } } if (!SendingLogToWindow()) { // Avoid screwing up the prompt if (write(fileno(stdout), "\n", 1) != 1) SysError("ShowLogFile", "error writing to stdout"); } // Restore original pointer if (qry > -1) lseek(fileno(fLogFileR), (off_t) nowlog, SEEK_SET); } //______________________________________________________________________________ void TProof::cd(Int_t id) { // Set session with 'id' the default one. If 'id' is not found in the list, // the current session is set as default if (GetManager()) { TProofDesc *d = GetManager()->GetProofDesc(id); if (d) { if (d->GetProof()) { gProof = d->GetProof(); return; } } // Id not found or undefined: set as default this session gProof = this; } return; } //______________________________________________________________________________ void TProof::Detach(Option_t *opt) { // Detach this instance to its proofserv. // If opt is 'S' or 's' the remote server is shutdown // Nothing to do if not in contact with proofserv if (!IsValid()) return; // Get worker and socket instances TSlave *sl = (TSlave *) fActiveSlaves->First(); TSocket *s = 0; if (!sl || !(sl->IsValid()) || !(s = sl->GetSocket())) { Error("Detach","corrupted worker instance: wrk:%p, sock:%p", sl, s); return; } Bool_t shutdown = (strchr(opt,'s') || strchr(opt,'S')) ? kTRUE : kFALSE; // If processing, try to stop processing first if (shutdown && !IsIdle()) { // Remove pending requests Remove("cleanupqueue"); // Do not wait for ever, but al least 20 seconds Long_t timeout = gEnv->GetValue("Proof.ShutdownTimeout", 60); timeout = (timeout > 20) ? timeout : 20; // Send stop signal StopProcess(kFALSE, (Long_t) (timeout / 2)); // Receive results Collect(kActive, timeout); } // Avoid spurious messages: deactivate new inputs ... DeActivateAsyncInput(); // ... and discard existing ones sl->FlushSocket(); // Close session (we always close the connection) Close(opt); // Close the progress dialog, if any if (fProgressDialogStarted) CloseProgressDialog(); // Update info in the table of our manager, if any if (GetManager() && GetManager()->QuerySessions("L")) { TIter nxd(GetManager()->QuerySessions("L")); TProofDesc *d = 0; while ((d = (TProofDesc *)nxd())) { if (d->GetProof() == this) { d->SetProof(0); GetManager()->QuerySessions("L")->Remove(d); break; } } } // Delete this instance if ((!fProgressDialogStarted) && !TestBit(kUsingSessionGui)) delete this; else // ~TProgressDialog will delete this fValid = kFALSE; return; } //______________________________________________________________________________ void TProof::SetAlias(const char *alias) { // Set an alias for this session. If reconnection is supported, the alias // will be communicated to the remote coordinator so that it can be recovered // when reconnecting // Set it locally TNamed::SetTitle(alias); if (TestBit(TProof::kIsMaster)) // Set the name at the same value TNamed::SetName(alias); // Nothing to do if not in contact with coordinator if (!IsValid()) return; if (!IsProofd() && TestBit(TProof::kIsClient)) { TSlave *sl = (TSlave *) fActiveSlaves->First(); if (sl) sl->SetAlias(alias); } return; } //______________________________________________________________________________ Int_t TProof::UploadDataSet(const char *dataSetName, TList *files, const char *desiredDest, Int_t opt, TList *skippedFiles) { // Upload a set of files and save the list of files by name dataSetName. // The 'files' argument is a list of TFileInfo objects describing the files // as first url. // The mask 'opt' is a combination of EUploadOpt: // kAppend (0x1) if set true files will be appended to // the dataset existing by given name // kOverwriteDataSet (0x2) if dataset with given name exited it // would be overwritten // kNoOverwriteDataSet (0x4) do not overwirte if the dataset exists // kOverwriteAllFiles (0x8) overwrite all files that may exist // kOverwriteNoFiles (0x10) overwrite none // kAskUser (0x0) ask user before overwriteng dataset/files // The default value is kAskUser. // The user will be asked to confirm overwriting dataset or files unless // specified opt provides the answer! // If kOverwriteNoFiles is set, then a pointer to TList must be passed as // skippedFiles argument. The function will add to this list TFileInfo // objects describing all files that existed on the cluster and were // not uploaded. // // Communication Summary // Client Master // |------------>DataSetName----------->| // |<-------kMESS_OK/kMESS_NOTOK<-------| (Name OK/file exist) // (*)|-------> call RegisterDataSet ------->| // (*) - optional if (fProtocol < 15) { Info("UploadDataSet", "functionality not available: the server has an" " incompatible version of TFileInfo"); return -1; } if (IsLite()) { Info("UploadDataSet", "Lite-session: functionality not needed - do nothing"); return -1; } // check if dataSetName is not excluded if (strchr(dataSetName, '/')) { if (strstr(dataSetName, "public") != dataSetName) { Error("UploadDataSet", "Name of public dataset should start with public/"); return kError; } } if ((opt & kOverwriteAllFiles && opt & kOverwriteNoFiles) || (opt & kNoOverwriteDataSet && opt & kAppend) || (opt & kOverwriteDataSet && opt & kAppend) || (opt & kNoOverwriteDataSet && opt & kOverwriteDataSet) || (opt & kAskUser && opt & (kOverwriteDataSet | kNoOverwriteDataSet | kAppend | kOverwriteAllFiles | kOverwriteNoFiles))) { Error("UploadDataSet", "you specified contradicting options."); return kError; } // Decode options Int_t overwriteAll = (opt & kOverwriteAllFiles) ? kTRUE : kFALSE; Int_t overwriteNone = (opt & kOverwriteNoFiles) ? kTRUE : kFALSE; Int_t goodName = (opt & (kOverwriteDataSet | kAppend)) ? 1 : -1; Int_t appendToDataSet = (opt & kAppend) ? kTRUE : kFALSE; Int_t overwriteNoDataSet = (opt & kNoOverwriteDataSet) ? kTRUE : kFALSE; //If skippedFiles is not provided we can not return list of skipped files. if (!skippedFiles && overwriteNone) { Error("UploadDataSet", "Provide pointer to TList object as skippedFiles argument when using kOverwriteNoFiles option."); return kError; } //If skippedFiles is provided but did not point to a TList the have to STOP if (skippedFiles) { if (skippedFiles->Class() != TList::Class()) { Error("UploadDataSet", "Provided skippedFiles argument does not point to a TList object."); return kError; } } TSocket *master; if (fActiveSlaves->GetSize()) master = ((TSlave*)(fActiveSlaves->First()))->GetSocket(); else { Error("UploadDataSet", "No connection to the master!"); return kError; } Int_t fileCount = 0; // return value if (goodName == -1) { // -1 for undefined // First check whether this dataset already exists unless // kAppend or kOverWriteDataSet TMessage nameMess(kPROOF_DATASETS); nameMess << Int_t(kCheckDataSetName); nameMess << TString(dataSetName); Broadcast(nameMess); Collect(kActive, fCollectTimeout); //after each call to HandleDataSets if (fStatus == -1) { //We ask user to agree on overwriting the dataset name while (goodName == -1 && !overwriteNoDataSet) { Info("UploadDataSet", "dataset %s already exist. ", dataSetName); Info("UploadDataSet", "do you want to overwrite it[Yes/No/Append]?"); TString answer; answer.ReadToken(cin); if (!strncasecmp(answer.Data(), "y", 1)) { goodName = 1; } else if (!strncasecmp(answer.Data(), "n", 1)) { goodName = 0; } else if (!strncasecmp(answer.Data(), "a", 1)) { goodName = 1; appendToDataSet = kTRUE; } } } else { goodName = 1; } } // if (goodName == -1) if (goodName == 1) { //must be == 1 as -1 was used for a bad name! //Code for enforcing writing in user "home dir" only char *relativeDestDir = Form("%s/%s/", gSystem->GetUserInfo()->fUser.Data(), desiredDest?desiredDest:""); //Consider adding dataSetName to the path relativeDestDir = CollapseSlashesInPath(relativeDestDir); TString dest = Form("%s/%s", GetDataPoolUrl(), relativeDestDir); delete[] relativeDestDir; // Now we will actually copy files and create the TList object TFileCollection *fileList = new TFileCollection(); TIter next(files); while (TFileInfo *fileInfo = ((TFileInfo*)next())) { TUrl *fileUrl = fileInfo->GetFirstUrl(); if (gSystem->AccessPathName(fileUrl->GetUrl()) == kFALSE) { //matching dir entry //getting the file name from the path represented by fileUrl const char *ent = gSystem->BaseName(fileUrl->GetFile()); Int_t goodFileName = 1; if (!overwriteAll && gSystem->AccessPathName(Form("%s/%s", dest.Data(), ent), kFileExists) == kFALSE) { //Destination file exists goodFileName = -1; while (goodFileName == -1 && !overwriteAll && !overwriteNone) { Info("UploadDataSet", "file %s already exists. ", Form("%s/%s", dest.Data(), ent)); Info("UploadDataSet", "do you want to overwrite it [Yes/No/all/none]?"); TString answer; answer.ReadToken(cin); if (!strncasecmp(answer.Data(), "y", 1)) goodFileName = 1; else if (!strncasecmp(answer.Data(), "all", 3)) overwriteAll = kTRUE; else if (!strncasecmp(answer.Data(), "none", 4)) overwriteNone = kTRUE; else if (!strncasecmp(answer.Data(), "n", 1)) goodFileName = 0; } } //if file exists // Copy the file to the redirector indicated if (goodFileName == 1 || overwriteAll) { //must be == 1 as -1 was meant for bad name! Info("UploadDataSet", "Uploading %s to %s/%s", fileUrl->GetUrl(), dest.Data(), ent); if (TFile::Cp(fileUrl->GetUrl(), Form("%s/%s", dest.Data(), ent))) { fileList->GetList()->Add(new TFileInfo(Form("%s/%s", dest.Data(), ent))); } else Error("UploadDataSet", "file %s was not copied", fileUrl->GetUrl()); } else { // don't overwrite, but file exist and must be included fileList->GetList()->Add(new TFileInfo(Form("%s/%s", dest.Data(), ent))); if (skippedFiles) { // user specified the TList *skippedFiles argument so we create // the list of skipped files skippedFiles->Add(new TFileInfo(fileUrl->GetUrl())); } } } //if matching dir entry } //while if ((fileCount = fileList->GetList()->GetSize()) == 0) { Info("UploadDataSet", "no files were copied. The dataset will not be saved"); } else { TString o = (appendToDataSet) ? "" : "O"; if (!RegisterDataSet(dataSetName, fileList, o)) { Error("UploadDataSet", "Error while saving dataset: %s", dataSetName); fileCount = kError; } } delete fileList; } else if (overwriteNoDataSet) { Info("UploadDataSet", "dataset %s already exists", dataSetName); return kDataSetExists; } //if(goodName == 1) return fileCount; } //______________________________________________________________________________ Int_t TProof::UploadDataSet(const char *dataSetName, const char *files, const char *desiredDest, Int_t opt, TList *skippedFiles) { // Upload a set of files and save the list of files by name dataSetName. // The mask 'opt' is a combination of EUploadOpt: // kAppend (0x1) if set true files will be appended to // the dataset existing by given name // kOverwriteDataSet (0x2) if dataset with given name exited it // would be overwritten // kNoOverwriteDataSet (0x4) do not overwirte if the dataset exists // kOverwriteAllFiles (0x8) overwrite all files that may exist // kOverwriteNoFiles (0x10) overwrite none // kAskUser (0x0) ask user before overwriteng dataset/files // The default value is kAskUser. // The user will be asked to confirm overwriting dataset or files unless // specified opt provides the answer! // If kOverwriteNoFiles is set, then a pointer to TList must be passed as // skippedFiles argument. The function will add to this list TFileInfo // objects describing all files that existed on the cluster and were // not uploaded. // if (fProtocol < 15) { Info("UploadDataSet", "functionality not available: the server has an" " incompatible version of TFileInfo"); return -1; } TList fileList; fileList.SetOwner(); void *dataSetDir = gSystem->OpenDirectory(gSystem->DirName(files)); const char* ent; TString filesExp(gSystem->BaseName(files)); filesExp.ReplaceAll("*",".*"); TRegexp rg(filesExp); while ((ent = gSystem->GetDirEntry(dataSetDir))) { TString entryString(ent); if (entryString.Index(rg) != kNPOS) { // Matching dir entry: add to the list TString u(Form("file://%s/%s", gSystem->DirName(files), ent)); if (gSystem->AccessPathName(u, kReadPermission) == kFALSE) fileList.Add(new TFileInfo(u)); } //if matching dir entry } //while Int_t fileCount; if ((fileCount = fileList.GetSize()) == 0) Printf("No files match your selection. The dataset will not be saved"); else fileCount = UploadDataSet(dataSetName, &fileList, desiredDest, opt, skippedFiles); return fileCount; } //______________________________________________________________________________ Int_t TProof::UploadDataSetFromFile(const char *dataset, const char *file, const char *dest, Int_t opt, TList *skippedFiles) { // Upload files listed in "file" to PROOF cluster. // Where file = name of file containing list of files and // dataset = dataset name and opt is a combination of EUploadOpt bits. // Each file description (line) can include wildcards. // Check TFileInfo compatibility if (fProtocol < 15) { Info("UploadDataSetFromFile", "functionality not available: the server has an" " incompatible version of TFileInfo"); return -1; } Int_t fileCount = -1; // Create the list to feed UploadDataSet(char *dataset, TList *l, ...) TList fileList; fileList.SetOwner(); ifstream f; f.open(gSystem->ExpandPathName(file), ifstream::out); if (f.is_open()) { while (f.good()) { TString line; line.ReadToDelim(f); line.Strip(TString::kTrailing, '\n'); if (gSystem->AccessPathName(line, kReadPermission) == kFALSE) fileList.Add(new TFileInfo(line)); } f.close(); if ((fileCount = fileList.GetSize()) == 0) Info("UploadDataSetFromFile", "no files match your selection. The dataset will not be saved"); else fileCount = UploadDataSet(dataset, &fileList, dest, opt, skippedFiles); } else { Error("UploadDataSetFromFile", "unable to open the specified file"); } // Done return fileCount; } //______________________________________________________________________________ Bool_t TProof::RegisterDataSet(const char *dataSetName, TFileCollection *dataSet, const char* optStr) { // Register the 'dataSet' on the cluster under the current // user, group and the given 'dataSetName'. // Fails if a dataset named 'dataSetName' already exists, unless 'optStr' // contains 'O', in which case the old dataset is overwritten. // If 'optStr' contains 'V' the dataset files are verified (default no // verification). // Returns kTRUE on success. // Check TFileInfo compatibility if (fProtocol < 17) { Info("RegisterDataSet", "functionality not available: the server does not have dataset support"); return kFALSE; } if (!dataSetName || strlen(dataSetName) <= 0) { Info("RegisterDataSet", "specifying a dataset name is mandatory"); return kFALSE; } TSocket *master; if (fActiveSlaves->GetSize()) master = ((TSlave*)(fActiveSlaves->First()))->GetSocket(); else { Error("RegisterDataSet", "No connection to the master!"); return kFALSE; } TMessage mess(kPROOF_DATASETS); mess << Int_t(kRegisterDataSet); mess << TString(dataSetName); mess << TString(optStr); mess.WriteObject(dataSet); Broadcast(mess); Bool_t result = kTRUE; Collect(); if (fStatus != 0) { Error("RegisterDataSet", "dataset was not saved"); result = kFALSE; } return result; } //______________________________________________________________________________ Int_t TProof::SetDataSetTreeName(const char *dataset, const char *treename) { // Set/Change the name of the default tree. The tree name may contain // subdir specification in the form "subdir/name". // Returns 0 on success, -1 otherwise. // Check TFileInfo compatibility if (fProtocol < 23) { Info("SetDataSetTreeName", "functionality not supported by the server"); return -1; } if (!dataset || strlen(dataset) <= 0) { Info("SetDataSetTreeName", "specifying a dataset name is mandatory"); return -1; } if (!treename || strlen(treename) <= 0) { Info("SetDataSetTreeName", "specifying a tree name is mandatory"); return -1; } TUri uri(dataset); TString fragment(treename); if (!fragment.BeginsWith("/")) fragment.Insert(0, "/"); uri.SetFragment(fragment); TMessage mess(kPROOF_DATASETS); mess << Int_t(kSetDefaultTreeName); mess << uri.GetUri(); Broadcast(mess); Collect(); if (fStatus != 0) { Error("SetDataSetTreeName", "some error occured: default tree name not changed"); return -1; } return 0; } //______________________________________________________________________________ TMap *TProof::GetDataSets(const char *uri, const char* optStr) { // Lists all datasets that match given uri. if (fProtocol < 15) { Info("GetDataSets", "functionality not available: the server does not have dataset support"); return 0; } TSocket *master = 0; if (fActiveSlaves->GetSize()) master = ((TSlave*)(fActiveSlaves->First()))->GetSocket(); else { Error("GetDataSets", "no connection to the master!"); return 0; } TMessage mess(kPROOF_DATASETS); mess << Int_t(kGetDataSets); mess << TString(uri?uri:""); mess << TString(optStr?optStr:""); Broadcast(mess); Collect(kActive, fCollectTimeout); TMap *dataSetMap = 0; if (fStatus != 0) { Error("GetDataSets", "error receiving datasets information"); } else { // Look in the list TMessage *retMess = (TMessage *) fRecvMessages->First(); if (retMess && retMess->What() == kMESS_OK) { if (!(dataSetMap = (TMap *)(retMess->ReadObject(TMap::Class())))) Error("GetDataSets", "error receiving datasets"); } else Error("GetDataSets", "message not found or wrong type (%p)", retMess); } return dataSetMap; } //______________________________________________________________________________ void TProof::ShowDataSets(const char *uri, const char* optStr) { // Shows datasets in locations that match the uri. // By default shows the user's datasets and global ones if (fProtocol < 15) { Info("ShowDataSets", "functionality not available: the server does not have dataset support"); return; } TSocket *master = 0; if (fActiveSlaves->GetSize()) master = ((TSlave*)(fActiveSlaves->First()))->GetSocket(); else { Error("ShowDataSets", "no connection to the master!"); return; } TMessage mess(kPROOF_DATASETS); mess << Int_t(kShowDataSets); mess << TString(uri ? uri : ""); mess << TString(optStr ? optStr : ""); Broadcast(mess); Collect(kActive, fCollectTimeout); if (fStatus != 0) Error("ShowDataSets", "error receiving datasets information"); } //______________________________________________________________________________ Bool_t TProof::ExistsDataSet(const char *dataset) { // Returns kTRUE if 'dataset' exists, kFALSE otherwise if (fProtocol < 15) { Info("ExistsDataSet", "functionality not available: the server has an" " incompatible version of TFileInfo"); return kFALSE; } if (!dataset || strlen(dataset) <= 0) { Error("ExistsDataSet", "dataset name missing"); return kFALSE; } TMessage msg(kPROOF_DATASETS); msg << Int_t(kCheckDataSetName) << TString(dataset); Broadcast(msg); Collect(kActive, fCollectTimeout); if (fStatus == -1) { // The dataset exists return kTRUE; } // The dataset does not exists return kFALSE; } //______________________________________________________________________________ TFileCollection *TProof::GetDataSet(const char *uri, const char* optStr) { // Get a list of TFileInfo objects describing the files of the specified // dataset. if (fProtocol < 15) { Info("GetDataSet", "functionality not available: the server has an" " incompatible version of TFileInfo"); return 0; } if (!uri || strlen(uri) <= 0) { Info("GetDataSet", "specifying a dataset name is mandatory"); return 0; } TSocket *master = 0; if (fActiveSlaves->GetSize()) master = ((TSlave*)(fActiveSlaves->First()))->GetSocket(); else { Error("GetDataSet", "no connection to the master!"); return 0; } TMessage nameMess(kPROOF_DATASETS); nameMess << Int_t(kGetDataSet); nameMess << TString(uri?uri:""); nameMess << TString(optStr?optStr:""); if (Broadcast(nameMess) < 0) Error("GetDataSet", "sending request failed"); Collect(kActive, fCollectTimeout); TFileCollection *fileList = 0; if (fStatus != 0) { Error("GetDataSet", "error receiving datasets information"); } else { // Look in the list TMessage *retMess = (TMessage *) fRecvMessages->First(); if (retMess && retMess->What() == kMESS_OK) { if (!(fileList = (TFileCollection*)(retMess->ReadObject(TFileCollection::Class())))) Error("GetDataSet", "error reading list of files"); } else Error("GetDataSet", "message not found or wrong type (%p)", retMess); } return fileList; } //______________________________________________________________________________ void TProof::ShowDataSet(const char *uri, const char* opt) { // display meta-info for given dataset usi TFileCollection *fileList = 0; if ((fileList = GetDataSet(uri))) { fileList->Print(opt); delete fileList; } else Warning("ShowDataSet","no such dataset: %s", uri); } //______________________________________________________________________________ Int_t TProof::RemoveDataSet(const char *uri, const char* optStr) { // Remove the specified dataset from the PROOF cluster. // Files are not deleted. TSocket *master; if (fActiveSlaves->GetSize()) master = ((TSlave*)(fActiveSlaves->First()))->GetSocket(); else { Error("RemoveDataSet", "no connection to the master!"); return kError; } TMessage nameMess(kPROOF_DATASETS); nameMess << Int_t(kRemoveDataSet); nameMess << TString(uri?uri:""); nameMess << TString(optStr?optStr:""); if (Broadcast(nameMess) < 0) Error("RemoveDataSet", "sending request failed"); Collect(kActive, fCollectTimeout); if (fStatus != 0) return -1; else return 0; } //______________________________________________________________________________ TList* TProof::FindDataSets(const char* /*searchString*/, const char* /*optStr*/) { // Find datasets, returns in a TList all found datasets. Error ("FindDataSets", "not yet implemented"); return (TList *) 0; } //______________________________________________________________________________ Int_t TProof::VerifyDataSet(const char *uri, const char* optStr) { // Verify if all files in the specified dataset are available. // Print a list and return the number of missing files. if (fProtocol < 15) { Info("VerifyDataSet", "functionality not available: the server has an" " incompatible version of TFileInfo"); return kError; } Int_t nMissingFiles = 0; TSocket *master; if (fActiveSlaves->GetSize()) master = ((TSlave*)(fActiveSlaves->First()))->GetSocket(); else { Error("VerifyDataSet", "no connection to the master!"); return kError; } TMessage nameMess(kPROOF_DATASETS); nameMess << Int_t(kVerifyDataSet); nameMess << TString(uri ? uri : ""); nameMess << TString(optStr ? optStr : ""); Broadcast(nameMess); Collect(kActive, fCollectTimeout); if (fStatus < 0) { Info("VerifyDataSet", "no such dataset %s", uri); return -1; } else nMissingFiles = fStatus; return nMissingFiles; } //______________________________________________________________________________ TMap *TProof::GetDataSetQuota(const char* optStr) { // returns a map of the quotas of all groups if (IsLite()) { Info("UploadDataSet", "Lite-session: functionality not implemented"); return (TMap *)0; } TSocket *master = 0; if (fActiveSlaves->GetSize()) master = ((TSlave*)(fActiveSlaves->First()))->GetSocket(); else { Error("GetDataSetQuota", "no connection to the master!"); return 0; } TMessage mess(kPROOF_DATASETS); mess << Int_t(kGetQuota); mess << TString(optStr?optStr:""); Broadcast(mess); Collect(kActive, fCollectTimeout); TMap *groupQuotaMap = 0; if (fStatus < 0) { Info("GetDataSetQuota", "could not receive quota"); } else { // Look in the list TMessage *retMess = (TMessage *) fRecvMessages->First(); if (retMess && retMess->What() == kMESS_OK) { if (!(groupQuotaMap = (TMap*)(retMess->ReadObject(TMap::Class())))) Error("GetDataSetQuota", "error getting quotas"); } else Error("GetDataSetQuota", "message not found or wrong type (%p)", retMess); } return groupQuotaMap; } //_____________________________________________________________________________ void TProof::ShowDataSetQuota(Option_t* opt) { // shows the quota and usage of all groups // if opt contains "U" shows also distribution of usage on user-level if (fProtocol < 15) { Info("ShowDataSetQuota", "functionality not available: the server does not have dataset support"); return; } if (IsLite()) { Info("UploadDataSet", "Lite-session: functionality not implemented"); return; } TSocket *master = 0; if (fActiveSlaves->GetSize()) master = ((TSlave*)(fActiveSlaves->First()))->GetSocket(); else { Error("ShowDataSetQuota", "no connection to the master!"); return; } TMessage mess(kPROOF_DATASETS); mess << Int_t(kShowQuota); mess << TString(opt?opt:""); Broadcast(mess); Collect(); if (fStatus != 0) Error("ShowDataSetQuota", "error receiving quota information"); } //_____________________________________________________________________________ void TProof::InterruptCurrentMonitor() { // If in active in a monitor set ready state if (fCurrentMonitor) fCurrentMonitor->Interrupt(); } //_____________________________________________________________________________ void TProof::ActivateWorker(const char *ord) { // Make sure that the worker identified by the ordinal number 'ord' is // in the active list. The request will be forwarded to the master // in direct contact with the worker. If needed, this master will move // the worker from the inactive to the active list and rebuild the list // of unique workers. // Use ord = "*" to activate all inactive workers. ModifyWorkerLists(ord, kTRUE); } //_____________________________________________________________________________ void TProof::DeactivateWorker(const char *ord) { // Remove the worker identified by the ordinal number 'ord' from the // the active list. The request will be forwarded to the master // in direct contact with the worker. If needed, this master will move // the worker from the active to the inactive list and rebuild the list // of unique workers. // Use ord = "*" to deactivate all active workers. ModifyWorkerLists(ord, kFALSE); } //_____________________________________________________________________________ void TProof::ModifyWorkerLists(const char *ord, Bool_t add) { // Modify the worker active/inactive list by making the worker identified by // the ordinal number 'ord' active (add == TRUE) or inactive (add == FALSE). // If needed, the request will be forwarded to the master in direct contact // with the worker. The end-master will move the worker from one list to the // other active and rebuild the list of unique active workers. // Use ord = "*" to deactivate all active workers. // Make sure the input make sense if (!ord || strlen(ord) <= 0) { Info("ModifyWorkerLists", "An ordinal number - e.g. \"0.4\" or \"*\" for all - is required as input"); return; } Bool_t fw = kTRUE; // Whether to forward one step down Bool_t rs = kFALSE; // Whether to rescan for unique workers // Appropriate list pointing TList *in = (add) ? fInactiveSlaves : fActiveSlaves; TList *out = (add) ? fActiveSlaves : fInactiveSlaves; if (TestBit(TProof::kIsMaster)) { fw = IsEndMaster() ? kFALSE : kTRUE; // Look for the worker in the inactive list if (in->GetSize() > 0) { TIter nxw(in); TSlave *wrk = 0; while ((wrk = (TSlave *) nxw())) { if (ord[0] == '*' || !strncmp(wrk->GetOrdinal(), ord, strlen(ord))) { // Add it to the inactive list if (!out->FindObject(wrk)) { out->Add(wrk); if (add) fActiveMonitor->Add(wrk->GetSocket()); } // Remove it from the active list in->Remove(wrk); if (!add) { fActiveMonitor->Remove(wrk->GetSocket()); wrk->SetStatus(TSlave::kInactive); } else wrk->SetStatus(TSlave::kActive); // Nothing to forward (ord is unique) fw = kFALSE; // Rescan for unique workers (active list modified) rs = kTRUE; // We are done, if not option 'all' if (ord[0] != '*') break; } } } } // Rescan for unique workers if (rs) FindUniqueSlaves(); // Forward the request one step down, if needed Int_t action = (add) ? (Int_t) kActivateWorker : (Int_t) kDeactivateWorker; if (fw) { TMessage mess(kPROOF_WORKERLISTS); mess << action << TString(ord); Broadcast(mess); Collect(kActive, fCollectTimeout); } } //_____________________________________________________________________________ TProof *TProof::Open(const char *cluster, const char *conffile, const char *confdir, Int_t loglevel) { // Start a PROOF session on a specific cluster. If cluster is 0 (the // default) then the PROOF Session Viewer GUI pops up and 0 is returned. // If cluster is "" (empty string) then we connect to a PROOF session // on the localhost ("proof://localhost"). Via conffile a specific // PROOF config file in the confir directory can be specified. // Use loglevel to set the default loging level for debugging. // The appropriate instance of TProofMgr is created, if not // yet existing. The instantiated TProof object is returned. // Use TProof::cd() to switch between PROOF sessions. // For more info on PROOF see the TProof ctor. const char *pn = "TProof::Open"; // Make sure libProof and dependents are loaded and TProof can be created, // dependents are loaded via the information in the [system].rootmap file if (!cluster) { TPluginManager *pm = gROOT->GetPluginManager(); if (!pm) { ::Error(pn, "plugin manager not found"); return 0; } if (gROOT->IsBatch()) { ::Error(pn, "we are in batch mode, cannot show PROOF Session Viewer"); return 0; } // start PROOF Session Viewer TPluginHandler *sv = pm->FindHandler("TSessionViewer", ""); if (!sv) { ::Error(pn, "no plugin found for TSessionViewer"); return 0; } if (sv->LoadPlugin() == -1) { ::Error(pn, "plugin for TSessionViewer could not be loaded"); return 0; } sv->ExecPlugin(0); return 0; } else { TString clst(cluster); if (clst.BeginsWith("workers=") || clst.BeginsWith("tunnel=")) clst.Insert(0, "/?"); // Parse input URL TUrl u(clst); // Parse any tunning info ("<cluster>/?tunnel=[<tunnel_host>:]tunnel_port) TString opts(u.GetOptions()); if (!opts.IsNull()) { Int_t it = opts.Index("tunnel="); if (it != kNPOS) { TString sport = opts(it + strlen("tunnel="), opts.Length()); TString host("127.0.0.1"); Int_t port = -1; Int_t ic = sport.Index(":"); if (ic != kNPOS) { // Isolate the host host = sport(0, ic); sport.Remove(0, ic + 1); } if (!sport.IsDigit()) { // Remove the non digit part TRegexp re("[^0-9]"); Int_t ind = sport.Index(re); if (ind != kNPOS) sport.Remove(ind); } // Set the port if (sport.IsDigit()) port = sport.Atoi(); if (port > 0) { // Set the relevant variables ::Info("TProof::Open","using tunnel at %s:%d", host.Data(), port); gEnv->SetValue("XNet.SOCKS4Host", host); gEnv->SetValue("XNet.SOCKS4Port", port); } else { // Warn parsing problems ::Warning("TProof::Open", "problems parsing tunnelling info from options: %s", opts.Data()); } } } // Find out if we are required to attach to a specific session Int_t locid = -1; Bool_t create = kFALSE; if (opts.Length() > 0) { if (opts.BeginsWith("N",TString::kIgnoreCase)) { create = kTRUE; } else if (opts.IsDigit()) { locid = opts.Atoi(); } } // Attach-to or create the appropriate manager TProofMgr *mgr = TProofMgr::Create(u.GetUrl()); TProof *proof = 0; if (mgr && mgr->IsValid()) { // If XProofd we always attempt an attach first (unless // explicitely not requested). Bool_t attach = (create || mgr->IsProofd() || mgr->IsLite()) ? kFALSE : kTRUE; if (attach) { TProofDesc *d = 0; if (locid < 0) // Get the list of sessions d = (TProofDesc *) mgr->QuerySessions("")->First(); else d = (TProofDesc *) mgr->GetProofDesc(locid); if (d) { proof = (TProof*) mgr->AttachSession(d); if (!proof || !proof->IsValid()) { if (locid) ::Error(pn, "new session could not be attached"); SafeDelete(proof); } } } // start the PROOF session if (!proof) { proof = (TProof*) mgr->CreateSession(conffile, confdir, loglevel); if (!proof || !proof->IsValid()) { ::Error(pn, "new session could not be created"); SafeDelete(proof); } } } return proof; } } //_____________________________________________________________________________ TProofMgr *TProof::Mgr(const char *url) { // Get instance of the effective manager for 'url' // Return 0 on failure. if (!url) return (TProofMgr *)0; // Attach or create the relevant instance return TProofMgr::Create(url); } //_____________________________________________________________________________ void TProof::Reset(const char *url, Bool_t hard) { // Wrapper around TProofMgr::Reset(...). if (url) { TProofMgr *mgr = TProof::Mgr(url); if (mgr && mgr->IsValid()) mgr->Reset(hard); else ::Error("TProof::Reset", "unable to initialize a valid manager instance"); } } //_____________________________________________________________________________ const TList *TProof::GetEnvVars() { // Get environemnt variables. return fgProofEnvList; } //_____________________________________________________________________________ void TProof::AddEnvVar(const char *name, const char *value) { // Add an variable to the list of environment variables passed to proofserv // on the master and slaves if (gDebug > 0) ::Info("TProof::AddEnvVar","%s=%s", name, value); if (fgProofEnvList == 0) { // initialize the list if needed fgProofEnvList = new TList; fgProofEnvList->SetOwner(); } else { // replace old entries with the same name TObject *o = fgProofEnvList->FindObject(name); if (o != 0) { fgProofEnvList->Remove(o); } } fgProofEnvList->Add(new TNamed(name, value)); } //_____________________________________________________________________________ void TProof::DelEnvVar(const char *name) { // Remove an variable from the list of environment variables passed to proofserv // on the master and slaves if (fgProofEnvList == 0) return; TObject *o = fgProofEnvList->FindObject(name); if (o != 0) { fgProofEnvList->Remove(o); } } //_____________________________________________________________________________ void TProof::ResetEnvVars() { // Clear the list of environment variables passed to proofserv // on the master and slaves if (fgProofEnvList == 0) return; SafeDelete(fgProofEnvList); } //______________________________________________________________________________ void TProof::SaveWorkerInfo() { // Save informations about the worker set in the file .workers in the working // dir. Called each time there is a change in the worker setup, e.g. by // TProof::MarkBad(). // We must be masters if (TestBit(TProof::kIsClient)) return; // We must have a server defined if (!gProofServ) { Error("SaveWorkerInfo","gProofServ undefined"); return; } // The relevant lists must be defined if (!fSlaves && !fBadSlaves) { Warning("SaveWorkerInfo","all relevant worker lists is undefined"); return; } // Create or truncate the file first TString fnwrk = Form("%s/.workers", gSystem->DirName(gProofServ->GetSessionDir())); FILE *fwrk = fopen(fnwrk.Data(),"w"); if (!fwrk) { Error("SaveWorkerInfo", "cannot open %s for writing (errno: %d)", fnwrk.Data(), errno); return; } // Do we need to register an additional line for another log? TString addlogext; if (gSystem->Getenv("PROOF_ADDITIONALLOG")) { addlogext = gSystem->Getenv("PROOF_ADDITIONALLOG"); if (gDebug > 0) Info("SaveWorkerInfo", "request for additional line with ext: '%s'", addlogext.Data()); } // Loop over the list of workers (active is any worker not flagged as bad) TIter nxa(fSlaves); TSlave *wrk = 0; while ((wrk = (TSlave *) nxa())) { Int_t status = (fBadSlaves && fBadSlaves->FindObject(wrk)) ? 0 : 1; // Write out record for this worker fprintf(fwrk,"%s@%s:%d %d %s %s.log\n", wrk->GetUser(), wrk->GetName(), wrk->GetPort(), status, wrk->GetOrdinal(), wrk->GetWorkDir()); // Additional line, if required if (addlogext.Length() > 0) { fprintf(fwrk,"%s@%s:%d %d %s %s.%s\n", wrk->GetUser(), wrk->GetName(), wrk->GetPort(), status, wrk->GetOrdinal(), wrk->GetWorkDir(), addlogext.Data()); } } // Close file fclose(fwrk); // We are done return; } //______________________________________________________________________________ Int_t TProof::GetParameter(TCollection *c, const char *par, TString &value) { // Get the value from the specified parameter from the specified collection. // Returns -1 in case of error (i.e. list is 0, parameter does not exist // or value type does not match), 0 otherwise. TObject *obj = c->FindObject(par); if (obj) { TNamed *p = dynamic_cast<TNamed*>(obj); if (p) { value = p->GetTitle(); return 0; } } return -1; } //______________________________________________________________________________ Int_t TProof::GetParameter(TCollection *c, const char *par, Int_t &value) { // Get the value from the specified parameter from the specified collection. // Returns -1 in case of error (i.e. list is 0, parameter does not exist // or value type does not match), 0 otherwise. TObject *obj = c->FindObject(par); if (obj) { TParameter<Int_t> *p = dynamic_cast<TParameter<Int_t>*>(obj); if (p) { value = p->GetVal(); return 0; } } return -1; } //______________________________________________________________________________ Int_t TProof::GetParameter(TCollection *c, const char *par, Long_t &value) { // Get the value from the specified parameter from the specified collection. // Returns -1 in case of error (i.e. list is 0, parameter does not exist // or value type does not match), 0 otherwise. TObject *obj = c->FindObject(par); if (obj) { TParameter<Long_t> *p = dynamic_cast<TParameter<Long_t>*>(obj); if (p) { value = p->GetVal(); return 0; } } return -1; } //______________________________________________________________________________ Int_t TProof::GetParameter(TCollection *c, const char *par, Long64_t &value) { // Get the value from the specified parameter from the specified collection. // Returns -1 in case of error (i.e. list is 0, parameter does not exist // or value type does not match), 0 otherwise. TObject *obj = c->FindObject(par); if (obj) { TParameter<Long64_t> *p = dynamic_cast<TParameter<Long64_t>*>(obj); if (p) { value = p->GetVal(); return 0; } } return -1; } //______________________________________________________________________________ Int_t TProof::GetParameter(TCollection *c, const char *par, Double_t &value) { // Get the value from the specified parameter from the specified collection. // Returns -1 in case of error (i.e. list is 0, parameter does not exist // or value type does not match), 0 otherwise. TObject *obj = c->FindObject(par); if (obj) { TParameter<Double_t> *p = dynamic_cast<TParameter<Double_t>*>(obj); if (p) { value = p->GetVal(); return 0; } } return -1; } //______________________________________________________________________________ Int_t TProof::AssertDataSet(TDSet *dset, TList *input, TDataSetManager *mgr, TString &emsg) { // Make sure that dataset is in the form to be processed. This may mean // retrieving the relevant info from the dataset manager or from the // attached input list. // Returns 0 on success, -1 on error emsg = ""; // We must have something to process if (!dset || !input || !mgr) { emsg.Form("invalid inputs (%p, %p, %p)", dset, input, mgr); return -1; } TFileCollection* dataset = 0; TString lookupopt; TString dsname(dset->GetName()); // The dataset maybe in the form of a TFileCollection in the input list if (dsname.BeginsWith("TFileCollection:")) { // Isolate the real name dsname.ReplaceAll("TFileCollection:", ""); // Get the object dataset = (TFileCollection *) input->FindObject(dsname); if (!dataset) { emsg.Form("TFileCollection %s not found in input list", dset->GetName()); return -1; } // Remove from everywhere input->RecursiveRemove(dataset); // Make sure we lookup everything (unless the client or the administartor // required something else) if (TProof::GetParameter(input, "PROOF_LookupOpt", lookupopt) != 0) { lookupopt = gEnv->GetValue("Proof.LookupOpt", "all"); input->Add(new TNamed("PROOF_LookupOpt", lookupopt.Data())); } } // The received message included an empty dataset, with only the name // defined: assume that a dataset, stored on the PROOF master by that // name, should be processed. if (!dataset) { dataset = mgr->GetDataSet(dsname.Data()); if (!dataset) { emsg.Form("no such dataset on the master: %s", dsname.Data()); return -1; } // Apply the lookup option requested by the client or the administartor // (by default we trust the information in the dataset) if (TProof::GetParameter(input, "PROOF_LookupOpt", lookupopt) != 0) { lookupopt = gEnv->GetValue("Proof.LookupOpt", "stagedOnly"); input->Add(new TNamed("PROOF_LookupOpt", lookupopt.Data())); } } // Logic for the subdir/obj names: try first to see if the dataset name contains // some info; if not check the settings in the TDSet object itself; if still empty // check the default tree name / path in the TFileCollection object; if still empty // use the default as the flow will determine TString dsTree; // Get the [subdir/]tree, if any mgr->ParseUri(dsname.Data(), 0, 0, 0, &dsTree); if (dsTree.IsNull()) { // Use what we have in the original dataset; we need this to locate the // meta data information dsTree += dset->GetDirectory(); dsTree += dset->GetObjName(); } if (!dsTree.IsNull() && dsTree != "/") { TString tree(dsTree); Int_t idx = tree.Index("/"); if (idx != kNPOS) { TString dir = tree(0, idx+1); tree.Remove(0, idx); dset->SetDirectory(dir); } dset->SetObjName(tree); } else { // Use the default obj name from the TFileCollection dsTree = dataset->GetDefaultTreeName(); } // Transfer the list now if (dataset) { TList *missingFiles = new TList; TSeqCollection* files = dataset->GetList(); if (gDebug > 0) files->Print(); Bool_t availableOnly = (lookupopt != "all") ? kTRUE : kFALSE; if (!dset->Add(files, dsTree, availableOnly, missingFiles)) { emsg.Form("error retrieving dataset %s", dset->GetName()); delete dataset; return -1; } if (missingFiles) { // The missing files objects have to be removed from the dataset // before delete. TIter next(missingFiles); TObject *file; while ((file = next())) dataset->GetList()->Remove(file); } delete dataset; // Make sure it will be sent back merged with other similar lists created // during processing; this list will be transferred by the player to the // output list, once the latter has been created (see TProofPlayerRemote::Process) if (missingFiles && missingFiles->GetSize() > 0) { missingFiles->SetName("MissingFiles"); input->Add(missingFiles); } } // Done return 0; } //______________________________________________________________________________ Int_t TProof::SaveInputData(TQueryResult *qr, const char *cachedir, TString &emsg) { // Save input data file from 'cachedir' into the sandbox or create a the file // with input data objects TList *input = 0; // We must have got something to process if (!qr || !(input = qr->GetInputList()) || !cachedir || strlen(cachedir) <= 0) return 0; // There must be some input data or input data file TNamed *data = (TNamed *) input->FindObject("PROOF_InputDataFile"); TList *inputdata = (TList *) input->FindObject("PROOF_InputData"); if (!data && !inputdata) return 0; // Default dstination filename if (!data) input->Add((data = new TNamed("PROOF_InputDataFile", kPROOF_InputDataFile))); TString dstname(data->GetTitle()), srcname; Bool_t fromcache = kFALSE; if (dstname.BeginsWith("cache:")) { fromcache = kTRUE; dstname.ReplaceAll("cache:", ""); srcname.Form("%s/%s", cachedir, dstname.Data()); if (gSystem->AccessPathName(srcname)) { emsg.Form("input data file not found in cache (%s)", srcname.Data()); return -1; } } // If from cache, just move the cache file if (fromcache) { if (gSystem->CopyFile(srcname, dstname, kTRUE) != 0) { emsg.Form("problems copying %s to %s", srcname.Data(), dstname.Data()); return -1; } } else { // Create the file if (inputdata && inputdata->GetSize() > 0) { TFile *f = TFile::Open(dstname.Data(), "RECREATE"); if (f) { f->cd(); inputdata->Write(); f->Close(); delete f; } else { emsg.Form("could not create %s", dstname.Data()); return -1; } } else { emsg.Form("no input data!"); return -1; } } ::Info("TProof::SaveInputData", "input data saved to %s", dstname.Data()); // Save the file name and clean up the data list data->SetTitle(dstname); if (inputdata) { input->Remove(inputdata); inputdata->SetOwner(); delete inputdata; } // Done return 0; } //______________________________________________________________________________ Int_t TProof::SendInputData(TQueryResult *qr, TProof *p, TString &emsg) { // Send the input data file to the workers TList *input = 0; // We must have got something to process if (!qr || !(input = qr->GetInputList())) return 0; // There must be some input data or input data file TNamed *inputdata = (TNamed *) input->FindObject("PROOF_InputDataFile"); if (!inputdata) return 0; TString fname(inputdata->GetTitle()); if (gSystem->AccessPathName(fname)) { emsg.Form("input data file not found in sandbox (%s)", fname.Data()); return -1; } // PROOF session must available if (!p || !p->IsValid()) { emsg.Form("TProof object undefined or invalid: protocol error!"); return -1; } // Send to unique workers and submasters p->BroadcastFile(fname, TProof::kBinary, "cache"); // Done return 0; } //______________________________________________________________________________ Int_t TProof::GetInputData(TList *input, const char *cachedir, TString &emsg) { // Get the input data from the file defined in the input list // We must have got something to process if (!input || !cachedir || strlen(cachedir) <= 0) return 0; // There must be some input data or input data file TNamed *inputdata = (TNamed *) input->FindObject("PROOF_InputDataFile"); if (!inputdata) return 0; TString fname; fname.Form("%s/%s", cachedir, inputdata->GetTitle()); if (gSystem->AccessPathName(fname)) { emsg.Form("input data file not found in cache (%s)", fname.Data()); return -1; } // Read the input data into the input list TFile *f = TFile::Open(fname.Data()); if (f) { TList *keys = (TList *) f->GetListOfKeys(); if (!keys) { emsg.Form("could not get list of object keys from file"); return -1; } TIter nxk(keys); TKey *k = 0; while ((k = (TKey *)nxk())) { TObject *o = f->Get(k->GetName()); if (o) input->Add(o); } f->Close(); delete f; } else { emsg.Form("could not open %s", fname.Data()); return -1; } // Done return 0; } //______________________________________________________________________________ void TProof::LogViewer(const char *url, Int_t idx) { // Start the log viewer window usign the plugin manager if (!gROOT->IsBatch()) { // Get the handler, if not yet done if (!fgLogViewer) { if ((fgLogViewer = gROOT->GetPluginManager()->FindHandler("TProofProgressLog"))) { if (fgLogViewer->LoadPlugin() == -1) { fgLogViewer = 0; ::Error("TProof::LogViewer", "cannot load the relevant plug-in"); return; } } } if (fgLogViewer) { // Execute the plug-in fgLogViewer->ExecPlugin(2, url, idx); } } else { if (url && strlen(url) > 0) { ::Info("TProof::LogViewer", "batch mode: use TProofLog *pl = TProof::Mgr(\"%s\")->GetSessionLogs(%d)", url, idx); } else { ::Info("TProof::LogViewer", "batch mode: use TProofLog *pl = TProof::Mgr(\"<master>\")->GetSessionLogs(%d)", idx); } } // Done return; }
TProof.cxx:1
TProof.cxx:2
TProof.cxx:3
TProof.cxx:4
TProof.cxx:5
TProof.cxx:6
TProof.cxx:7
TProof.cxx:8
TProof.cxx:9
TProof.cxx:10
TProof.cxx:11
TProof.cxx:12
TProof.cxx:13
TProof.cxx:14
TProof.cxx:15
TProof.cxx:16
TProof.cxx:17
TProof.cxx:18
TProof.cxx:19
TProof.cxx:20
TProof.cxx:21
TProof.cxx:22
TProof.cxx:23
TProof.cxx:24
TProof.cxx:25
TProof.cxx:26
TProof.cxx:27
TProof.cxx:28
TProof.cxx:29
TProof.cxx:30
TProof.cxx:31
TProof.cxx:32
TProof.cxx:33
TProof.cxx:34
TProof.cxx:35
TProof.cxx:36
TProof.cxx:37
TProof.cxx:38
TProof.cxx:39
TProof.cxx:40
TProof.cxx:41
TProof.cxx:42
TProof.cxx:43
TProof.cxx:44
TProof.cxx:45
TProof.cxx:46
TProof.cxx:47
TProof.cxx:48
TProof.cxx:49
TProof.cxx:50
TProof.cxx:51
TProof.cxx:52
TProof.cxx:53
TProof.cxx:54
TProof.cxx:55
TProof.cxx:56
TProof.cxx:57
TProof.cxx:58
TProof.cxx:59
TProof.cxx:60
TProof.cxx:61
TProof.cxx:62
TProof.cxx:63
TProof.cxx:64
TProof.cxx:65
TProof.cxx:66
TProof.cxx:67
TProof.cxx:68
TProof.cxx:69
TProof.cxx:70
TProof.cxx:71
TProof.cxx:72
TProof.cxx:73
TProof.cxx:74
TProof.cxx:75
TProof.cxx:76
TProof.cxx:77
TProof.cxx:78
TProof.cxx:79
TProof.cxx:80
TProof.cxx:81
TProof.cxx:82
TProof.cxx:83
TProof.cxx:84
TProof.cxx:85
TProof.cxx:86
TProof.cxx:87
TProof.cxx:88
TProof.cxx:89
TProof.cxx:90
TProof.cxx:91
TProof.cxx:92
TProof.cxx:93
TProof.cxx:94
TProof.cxx:95
TProof.cxx:96
TProof.cxx:97
TProof.cxx:98
TProof.cxx:99
TProof.cxx:100
TProof.cxx:101
TProof.cxx:102
TProof.cxx:103
TProof.cxx:104
TProof.cxx:105
TProof.cxx:106
TProof.cxx:107
TProof.cxx:108
TProof.cxx:109
TProof.cxx:110
TProof.cxx:111
TProof.cxx:112
TProof.cxx:113
TProof.cxx:114
TProof.cxx:115
TProof.cxx:116
TProof.cxx:117
TProof.cxx:118
TProof.cxx:119
TProof.cxx:120
TProof.cxx:121
TProof.cxx:122
TProof.cxx:123
TProof.cxx:124
TProof.cxx:125
TProof.cxx:126
TProof.cxx:127
TProof.cxx:128
TProof.cxx:129
TProof.cxx:130
TProof.cxx:131
TProof.cxx:132
TProof.cxx:133
TProof.cxx:134
TProof.cxx:135
TProof.cxx:136
TProof.cxx:137
TProof.cxx:138
TProof.cxx:139
TProof.cxx:140
TProof.cxx:141
TProof.cxx:142
TProof.cxx:143
TProof.cxx:144
TProof.cxx:145
TProof.cxx:146
TProof.cxx:147
TProof.cxx:148
TProof.cxx:149
TProof.cxx:150
TProof.cxx:151
TProof.cxx:152
TProof.cxx:153
TProof.cxx:154
TProof.cxx:155
TProof.cxx:156
TProof.cxx:157
TProof.cxx:158
TProof.cxx:159
TProof.cxx:160
TProof.cxx:161
TProof.cxx:162
TProof.cxx:163
TProof.cxx:164
TProof.cxx:165
TProof.cxx:166
TProof.cxx:167
TProof.cxx:168
TProof.cxx:169
TProof.cxx:170
TProof.cxx:171
TProof.cxx:172
TProof.cxx:173
TProof.cxx:174
TProof.cxx:175
TProof.cxx:176
TProof.cxx:177
TProof.cxx:178
TProof.cxx:179
TProof.cxx:180
TProof.cxx:181
TProof.cxx:182
TProof.cxx:183
TProof.cxx:184
TProof.cxx:185
TProof.cxx:186
TProof.cxx:187
TProof.cxx:188
TProof.cxx:189
TProof.cxx:190
TProof.cxx:191
TProof.cxx:192
TProof.cxx:193
TProof.cxx:194
TProof.cxx:195
TProof.cxx:196
TProof.cxx:197
TProof.cxx:198
TProof.cxx:199
TProof.cxx:200
TProof.cxx:201
TProof.cxx:202
TProof.cxx:203
TProof.cxx:204
TProof.cxx:205
TProof.cxx:206
TProof.cxx:207
TProof.cxx:208
TProof.cxx:209
TProof.cxx:210
TProof.cxx:211
TProof.cxx:212
TProof.cxx:213
TProof.cxx:214
TProof.cxx:215
TProof.cxx:216
TProof.cxx:217
TProof.cxx:218
TProof.cxx:219
TProof.cxx:220
TProof.cxx:221
TProof.cxx:222
TProof.cxx:223
TProof.cxx:224
TProof.cxx:225
TProof.cxx:226
TProof.cxx:227
TProof.cxx:228
TProof.cxx:229
TProof.cxx:230
TProof.cxx:231
TProof.cxx:232
TProof.cxx:233
TProof.cxx:234
TProof.cxx:235
TProof.cxx:236
TProof.cxx:237
TProof.cxx:238
TProof.cxx:239
TProof.cxx:240
TProof.cxx:241
TProof.cxx:242
TProof.cxx:243
TProof.cxx:244
TProof.cxx:245
TProof.cxx:246
TProof.cxx:247
TProof.cxx:248
TProof.cxx:249
TProof.cxx:250
TProof.cxx:251
TProof.cxx:252
TProof.cxx:253
TProof.cxx:254
TProof.cxx:255
TProof.cxx:256
TProof.cxx:257
TProof.cxx:258
TProof.cxx:259
TProof.cxx:260
TProof.cxx:261
TProof.cxx:262
TProof.cxx:263
TProof.cxx:264
TProof.cxx:265
TProof.cxx:266
TProof.cxx:267
TProof.cxx:268
TProof.cxx:269
TProof.cxx:270
TProof.cxx:271
TProof.cxx:272
TProof.cxx:273
TProof.cxx:274
TProof.cxx:275
TProof.cxx:276
TProof.cxx:277
TProof.cxx:278
TProof.cxx:279
TProof.cxx:280
TProof.cxx:281
TProof.cxx:282
TProof.cxx:283
TProof.cxx:284
TProof.cxx:285
TProof.cxx:286
TProof.cxx:287
TProof.cxx:288
TProof.cxx:289
TProof.cxx:290
TProof.cxx:291
TProof.cxx:292
TProof.cxx:293
TProof.cxx:294
TProof.cxx:295
TProof.cxx:296
TProof.cxx:297
TProof.cxx:298
TProof.cxx:299
TProof.cxx:300
TProof.cxx:301
TProof.cxx:302
TProof.cxx:303
TProof.cxx:304
TProof.cxx:305
TProof.cxx:306
TProof.cxx:307
TProof.cxx:308
TProof.cxx:309
TProof.cxx:310
TProof.cxx:311
TProof.cxx:312
TProof.cxx:313
TProof.cxx:314
TProof.cxx:315
TProof.cxx:316
TProof.cxx:317
TProof.cxx:318
TProof.cxx:319
TProof.cxx:320
TProof.cxx:321
TProof.cxx:322
TProof.cxx:323
TProof.cxx:324
TProof.cxx:325
TProof.cxx:326
TProof.cxx:327
TProof.cxx:328
TProof.cxx:329
TProof.cxx:330
TProof.cxx:331
TProof.cxx:332
TProof.cxx:333
TProof.cxx:334
TProof.cxx:335
TProof.cxx:336
TProof.cxx:337
TProof.cxx:338
TProof.cxx:339
TProof.cxx:340
TProof.cxx:341
TProof.cxx:342
TProof.cxx:343
TProof.cxx:344
TProof.cxx:345
TProof.cxx:346
TProof.cxx:347
TProof.cxx:348
TProof.cxx:349
TProof.cxx:350
TProof.cxx:351
TProof.cxx:352
TProof.cxx:353
TProof.cxx:354
TProof.cxx:355
TProof.cxx:356
TProof.cxx:357
TProof.cxx:358
TProof.cxx:359
TProof.cxx:360
TProof.cxx:361
TProof.cxx:362
TProof.cxx:363
TProof.cxx:364
TProof.cxx:365
TProof.cxx:366
TProof.cxx:367
TProof.cxx:368
TProof.cxx:369
TProof.cxx:370
TProof.cxx:371
TProof.cxx:372
TProof.cxx:373
TProof.cxx:374
TProof.cxx:375
TProof.cxx:376
TProof.cxx:377
TProof.cxx:378
TProof.cxx:379
TProof.cxx:380
TProof.cxx:381
TProof.cxx:382
TProof.cxx:383
TProof.cxx:384
TProof.cxx:385
TProof.cxx:386
TProof.cxx:387
TProof.cxx:388
TProof.cxx:389
TProof.cxx:390
TProof.cxx:391
TProof.cxx:392
TProof.cxx:393
TProof.cxx:394
TProof.cxx:395
TProof.cxx:396
TProof.cxx:397
TProof.cxx:398
TProof.cxx:399
TProof.cxx:400
TProof.cxx:401
TProof.cxx:402
TProof.cxx:403
TProof.cxx:404
TProof.cxx:405
TProof.cxx:406
TProof.cxx:407
TProof.cxx:408
TProof.cxx:409
TProof.cxx:410
TProof.cxx:411
TProof.cxx:412
TProof.cxx:413
TProof.cxx:414
TProof.cxx:415
TProof.cxx:416
TProof.cxx:417
TProof.cxx:418
TProof.cxx:419
TProof.cxx:420
TProof.cxx:421
TProof.cxx:422
TProof.cxx:423
TProof.cxx:424
TProof.cxx:425
TProof.cxx:426
TProof.cxx:427
TProof.cxx:428
TProof.cxx:429
TProof.cxx:430
TProof.cxx:431
TProof.cxx:432
TProof.cxx:433
TProof.cxx:434
TProof.cxx:435
TProof.cxx:436
TProof.cxx:437
TProof.cxx:438
TProof.cxx:439
TProof.cxx:440
TProof.cxx:441
TProof.cxx:442
TProof.cxx:443
TProof.cxx:444
TProof.cxx:445
TProof.cxx:446
TProof.cxx:447
TProof.cxx:448
TProof.cxx:449
TProof.cxx:450
TProof.cxx:451
TProof.cxx:452
TProof.cxx:453
TProof.cxx:454
TProof.cxx:455
TProof.cxx:456
TProof.cxx:457
TProof.cxx:458
TProof.cxx:459
TProof.cxx:460
TProof.cxx:461
TProof.cxx:462
TProof.cxx:463
TProof.cxx:464
TProof.cxx:465
TProof.cxx:466
TProof.cxx:467
TProof.cxx:468
TProof.cxx:469
TProof.cxx:470
TProof.cxx:471
TProof.cxx:472
TProof.cxx:473
TProof.cxx:474
TProof.cxx:475
TProof.cxx:476
TProof.cxx:477
TProof.cxx:478
TProof.cxx:479
TProof.cxx:480
TProof.cxx:481
TProof.cxx:482
TProof.cxx:483
TProof.cxx:484
TProof.cxx:485
TProof.cxx:486
TProof.cxx:487
TProof.cxx:488
TProof.cxx:489
TProof.cxx:490
TProof.cxx:491
TProof.cxx:492
TProof.cxx:493
TProof.cxx:494
TProof.cxx:495
TProof.cxx:496
TProof.cxx:497
TProof.cxx:498
TProof.cxx:499
TProof.cxx:500
TProof.cxx:501
TProof.cxx:502
TProof.cxx:503
TProof.cxx:504
TProof.cxx:505
TProof.cxx:506
TProof.cxx:507
TProof.cxx:508
TProof.cxx:509
TProof.cxx:510
TProof.cxx:511
TProof.cxx:512
TProof.cxx:513
TProof.cxx:514
TProof.cxx:515
TProof.cxx:516
TProof.cxx:517
TProof.cxx:518
TProof.cxx:519
TProof.cxx:520
TProof.cxx:521
TProof.cxx:522
TProof.cxx:523
TProof.cxx:524
TProof.cxx:525
TProof.cxx:526
TProof.cxx:527
TProof.cxx:528
TProof.cxx:529
TProof.cxx:530
TProof.cxx:531
TProof.cxx:532
TProof.cxx:533
TProof.cxx:534
TProof.cxx:535
TProof.cxx:536
TProof.cxx:537
TProof.cxx:538
TProof.cxx:539
TProof.cxx:540
TProof.cxx:541
TProof.cxx:542
TProof.cxx:543
TProof.cxx:544
TProof.cxx:545
TProof.cxx:546
TProof.cxx:547
TProof.cxx:548
TProof.cxx:549
TProof.cxx:550
TProof.cxx:551
TProof.cxx:552
TProof.cxx:553
TProof.cxx:554
TProof.cxx:555
TProof.cxx:556
TProof.cxx:557
TProof.cxx:558
TProof.cxx:559
TProof.cxx:560
TProof.cxx:561
TProof.cxx:562
TProof.cxx:563
TProof.cxx:564
TProof.cxx:565
TProof.cxx:566
TProof.cxx:567
TProof.cxx:568
TProof.cxx:569
TProof.cxx:570
TProof.cxx:571
TProof.cxx:572
TProof.cxx:573
TProof.cxx:574
TProof.cxx:575
TProof.cxx:576
TProof.cxx:577
TProof.cxx:578
TProof.cxx:579
TProof.cxx:580
TProof.cxx:581
TProof.cxx:582
TProof.cxx:583
TProof.cxx:584
TProof.cxx:585
TProof.cxx:586
TProof.cxx:587
TProof.cxx:588
TProof.cxx:589
TProof.cxx:590
TProof.cxx:591
TProof.cxx:592
TProof.cxx:593
TProof.cxx:594
TProof.cxx:595
TProof.cxx:596
TProof.cxx:597
TProof.cxx:598
TProof.cxx:599
TProof.cxx:600
TProof.cxx:601
TProof.cxx:602
TProof.cxx:603
TProof.cxx:604
TProof.cxx:605
TProof.cxx:606
TProof.cxx:607
TProof.cxx:608
TProof.cxx:609
TProof.cxx:610
TProof.cxx:611
TProof.cxx:612
TProof.cxx:613
TProof.cxx:614
TProof.cxx:615
TProof.cxx:616
TProof.cxx:617
TProof.cxx:618
TProof.cxx:619
TProof.cxx:620
TProof.cxx:621
TProof.cxx:622
TProof.cxx:623
TProof.cxx:624
TProof.cxx:625
TProof.cxx:626
TProof.cxx:627
TProof.cxx:628
TProof.cxx:629
TProof.cxx:630
TProof.cxx:631
TProof.cxx:632
TProof.cxx:633
TProof.cxx:634
TProof.cxx:635
TProof.cxx:636
TProof.cxx:637
TProof.cxx:638
TProof.cxx:639
TProof.cxx:640
TProof.cxx:641
TProof.cxx:642
TProof.cxx:643
TProof.cxx:644
TProof.cxx:645
TProof.cxx:646
TProof.cxx:647
TProof.cxx:648
TProof.cxx:649
TProof.cxx:650
TProof.cxx:651
TProof.cxx:652
TProof.cxx:653
TProof.cxx:654
TProof.cxx:655
TProof.cxx:656
TProof.cxx:657
TProof.cxx:658
TProof.cxx:659
TProof.cxx:660
TProof.cxx:661
TProof.cxx:662
TProof.cxx:663
TProof.cxx:664
TProof.cxx:665
TProof.cxx:666
TProof.cxx:667
TProof.cxx:668
TProof.cxx:669
TProof.cxx:670
TProof.cxx:671
TProof.cxx:672
TProof.cxx:673
TProof.cxx:674
TProof.cxx:675
TProof.cxx:676
TProof.cxx:677
TProof.cxx:678
TProof.cxx:679
TProof.cxx:680
TProof.cxx:681
TProof.cxx:682
TProof.cxx:683
TProof.cxx:684
TProof.cxx:685
TProof.cxx:686
TProof.cxx:687
TProof.cxx:688
TProof.cxx:689
TProof.cxx:690
TProof.cxx:691
TProof.cxx:692
TProof.cxx:693
TProof.cxx:694
TProof.cxx:695
TProof.cxx:696
TProof.cxx:697
TProof.cxx:698
TProof.cxx:699
TProof.cxx:700
TProof.cxx:701
TProof.cxx:702
TProof.cxx:703
TProof.cxx:704
TProof.cxx:705
TProof.cxx:706
TProof.cxx:707
TProof.cxx:708
TProof.cxx:709
TProof.cxx:710
TProof.cxx:711
TProof.cxx:712
TProof.cxx:713
TProof.cxx:714
TProof.cxx:715
TProof.cxx:716
TProof.cxx:717
TProof.cxx:718
TProof.cxx:719
TProof.cxx:720
TProof.cxx:721
TProof.cxx:722
TProof.cxx:723
TProof.cxx:724
TProof.cxx:725
TProof.cxx:726
TProof.cxx:727
TProof.cxx:728
TProof.cxx:729
TProof.cxx:730
TProof.cxx:731
TProof.cxx:732
TProof.cxx:733
TProof.cxx:734
TProof.cxx:735
TProof.cxx:736
TProof.cxx:737
TProof.cxx:738
TProof.cxx:739
TProof.cxx:740
TProof.cxx:741
TProof.cxx:742
TProof.cxx:743
TProof.cxx:744
TProof.cxx:745
TProof.cxx:746
TProof.cxx:747
TProof.cxx:748
TProof.cxx:749
TProof.cxx:750
TProof.cxx:751
TProof.cxx:752
TProof.cxx:753
TProof.cxx:754
TProof.cxx:755
TProof.cxx:756
TProof.cxx:757
TProof.cxx:758
TProof.cxx:759
TProof.cxx:760
TProof.cxx:761
TProof.cxx:762
TProof.cxx:763
TProof.cxx:764
TProof.cxx:765
TProof.cxx:766
TProof.cxx:767
TProof.cxx:768
TProof.cxx:769
TProof.cxx:770
TProof.cxx:771
TProof.cxx:772
TProof.cxx:773
TProof.cxx:774
TProof.cxx:775
TProof.cxx:776
TProof.cxx:777
TProof.cxx:778
TProof.cxx:779
TProof.cxx:780
TProof.cxx:781
TProof.cxx:782
TProof.cxx:783
TProof.cxx:784
TProof.cxx:785
TProof.cxx:786
TProof.cxx:787
TProof.cxx:788
TProof.cxx:789
TProof.cxx:790
TProof.cxx:791
TProof.cxx:792
TProof.cxx:793
TProof.cxx:794
TProof.cxx:795
TProof.cxx:796
TProof.cxx:797
TProof.cxx:798
TProof.cxx:799
TProof.cxx:800
TProof.cxx:801
TProof.cxx:802
TProof.cxx:803
TProof.cxx:804
TProof.cxx:805
TProof.cxx:806
TProof.cxx:807
TProof.cxx:808
TProof.cxx:809
TProof.cxx:810
TProof.cxx:811
TProof.cxx:812
TProof.cxx:813
TProof.cxx:814
TProof.cxx:815
TProof.cxx:816
TProof.cxx:817
TProof.cxx:818
TProof.cxx:819
TProof.cxx:820
TProof.cxx:821
TProof.cxx:822
TProof.cxx:823
TProof.cxx:824
TProof.cxx:825
TProof.cxx:826
TProof.cxx:827
TProof.cxx:828
TProof.cxx:829
TProof.cxx:830
TProof.cxx:831
TProof.cxx:832
TProof.cxx:833
TProof.cxx:834
TProof.cxx:835
TProof.cxx:836
TProof.cxx:837
TProof.cxx:838
TProof.cxx:839
TProof.cxx:840
TProof.cxx:841
TProof.cxx:842
TProof.cxx:843
TProof.cxx:844
TProof.cxx:845
TProof.cxx:846
TProof.cxx:847
TProof.cxx:848
TProof.cxx:849
TProof.cxx:850
TProof.cxx:851
TProof.cxx:852
TProof.cxx:853
TProof.cxx:854
TProof.cxx:855
TProof.cxx:856
TProof.cxx:857
TProof.cxx:858
TProof.cxx:859
TProof.cxx:860
TProof.cxx:861
TProof.cxx:862
TProof.cxx:863
TProof.cxx:864
TProof.cxx:865
TProof.cxx:866
TProof.cxx:867
TProof.cxx:868
TProof.cxx:869
TProof.cxx:870
TProof.cxx:871
TProof.cxx:872
TProof.cxx:873
TProof.cxx:874
TProof.cxx:875
TProof.cxx:876
TProof.cxx:877
TProof.cxx:878
TProof.cxx:879
TProof.cxx:880
TProof.cxx:881
TProof.cxx:882
TProof.cxx:883
TProof.cxx:884
TProof.cxx:885
TProof.cxx:886
TProof.cxx:887
TProof.cxx:888
TProof.cxx:889
TProof.cxx:890
TProof.cxx:891
TProof.cxx:892
TProof.cxx:893
TProof.cxx:894
TProof.cxx:895
TProof.cxx:896
TProof.cxx:897
TProof.cxx:898
TProof.cxx:899
TProof.cxx:900
TProof.cxx:901
TProof.cxx:902
TProof.cxx:903
TProof.cxx:904
TProof.cxx:905
TProof.cxx:906
TProof.cxx:907
TProof.cxx:908
TProof.cxx:909
TProof.cxx:910
TProof.cxx:911
TProof.cxx:912
TProof.cxx:913
TProof.cxx:914
TProof.cxx:915
TProof.cxx:916
TProof.cxx:917
TProof.cxx:918
TProof.cxx:919
TProof.cxx:920
TProof.cxx:921
TProof.cxx:922
TProof.cxx:923
TProof.cxx:924
TProof.cxx:925
TProof.cxx:926
TProof.cxx:927
TProof.cxx:928
TProof.cxx:929
TProof.cxx:930
TProof.cxx:931
TProof.cxx:932
TProof.cxx:933
TProof.cxx:934
TProof.cxx:935
TProof.cxx:936
TProof.cxx:937
TProof.cxx:938
TProof.cxx:939
TProof.cxx:940
TProof.cxx:941
TProof.cxx:942
TProof.cxx:943
TProof.cxx:944
TProof.cxx:945
TProof.cxx:946
TProof.cxx:947
TProof.cxx:948
TProof.cxx:949
TProof.cxx:950
TProof.cxx:951
TProof.cxx:952
TProof.cxx:953
TProof.cxx:954
TProof.cxx:955
TProof.cxx:956
TProof.cxx:957
TProof.cxx:958
TProof.cxx:959
TProof.cxx:960
TProof.cxx:961
TProof.cxx:962
TProof.cxx:963
TProof.cxx:964
TProof.cxx:965
TProof.cxx:966
TProof.cxx:967
TProof.cxx:968
TProof.cxx:969
TProof.cxx:970
TProof.cxx:971
TProof.cxx:972
TProof.cxx:973
TProof.cxx:974
TProof.cxx:975
TProof.cxx:976
TProof.cxx:977
TProof.cxx:978
TProof.cxx:979
TProof.cxx:980
TProof.cxx:981
TProof.cxx:982
TProof.cxx:983
TProof.cxx:984
TProof.cxx:985
TProof.cxx:986
TProof.cxx:987
TProof.cxx:988
TProof.cxx:989
TProof.cxx:990
TProof.cxx:991
TProof.cxx:992
TProof.cxx:993
TProof.cxx:994
TProof.cxx:995
TProof.cxx:996
TProof.cxx:997
TProof.cxx:998
TProof.cxx:999
TProof.cxx:1000
TProof.cxx:1001
TProof.cxx:1002
TProof.cxx:1003
TProof.cxx:1004
TProof.cxx:1005
TProof.cxx:1006
TProof.cxx:1007
TProof.cxx:1008
TProof.cxx:1009
TProof.cxx:1010
TProof.cxx:1011
TProof.cxx:1012
TProof.cxx:1013
TProof.cxx:1014
TProof.cxx:1015
TProof.cxx:1016
TProof.cxx:1017
TProof.cxx:1018
TProof.cxx:1019
TProof.cxx:1020
TProof.cxx:1021
TProof.cxx:1022
TProof.cxx:1023
TProof.cxx:1024
TProof.cxx:1025
TProof.cxx:1026
TProof.cxx:1027
TProof.cxx:1028
TProof.cxx:1029
TProof.cxx:1030
TProof.cxx:1031
TProof.cxx:1032
TProof.cxx:1033
TProof.cxx:1034
TProof.cxx:1035
TProof.cxx:1036
TProof.cxx:1037
TProof.cxx:1038
TProof.cxx:1039
TProof.cxx:1040
TProof.cxx:1041
TProof.cxx:1042
TProof.cxx:1043
TProof.cxx:1044
TProof.cxx:1045
TProof.cxx:1046
TProof.cxx:1047
TProof.cxx:1048
TProof.cxx:1049
TProof.cxx:1050
TProof.cxx:1051
TProof.cxx:1052
TProof.cxx:1053
TProof.cxx:1054
TProof.cxx:1055
TProof.cxx:1056
TProof.cxx:1057
TProof.cxx:1058
TProof.cxx:1059
TProof.cxx:1060
TProof.cxx:1061
TProof.cxx:1062
TProof.cxx:1063
TProof.cxx:1064
TProof.cxx:1065
TProof.cxx:1066
TProof.cxx:1067
TProof.cxx:1068
TProof.cxx:1069
TProof.cxx:1070
TProof.cxx:1071
TProof.cxx:1072
TProof.cxx:1073
TProof.cxx:1074
TProof.cxx:1075
TProof.cxx:1076
TProof.cxx:1077
TProof.cxx:1078
TProof.cxx:1079
TProof.cxx:1080
TProof.cxx:1081
TProof.cxx:1082
TProof.cxx:1083
TProof.cxx:1084
TProof.cxx:1085
TProof.cxx:1086
TProof.cxx:1087
TProof.cxx:1088
TProof.cxx:1089
TProof.cxx:1090
TProof.cxx:1091
TProof.cxx:1092
TProof.cxx:1093
TProof.cxx:1094
TProof.cxx:1095
TProof.cxx:1096
TProof.cxx:1097
TProof.cxx:1098
TProof.cxx:1099
TProof.cxx:1100
TProof.cxx:1101
TProof.cxx:1102
TProof.cxx:1103
TProof.cxx:1104
TProof.cxx:1105
TProof.cxx:1106
TProof.cxx:1107
TProof.cxx:1108
TProof.cxx:1109
TProof.cxx:1110
TProof.cxx:1111
TProof.cxx:1112
TProof.cxx:1113
TProof.cxx:1114
TProof.cxx:1115
TProof.cxx:1116
TProof.cxx:1117
TProof.cxx:1118
TProof.cxx:1119
TProof.cxx:1120
TProof.cxx:1121
TProof.cxx:1122
TProof.cxx:1123
TProof.cxx:1124
TProof.cxx:1125
TProof.cxx:1126
TProof.cxx:1127
TProof.cxx:1128
TProof.cxx:1129
TProof.cxx:1130
TProof.cxx:1131
TProof.cxx:1132
TProof.cxx:1133
TProof.cxx:1134
TProof.cxx:1135
TProof.cxx:1136
TProof.cxx:1137
TProof.cxx:1138
TProof.cxx:1139
TProof.cxx:1140
TProof.cxx:1141
TProof.cxx:1142
TProof.cxx:1143
TProof.cxx:1144
TProof.cxx:1145
TProof.cxx:1146
TProof.cxx:1147
TProof.cxx:1148
TProof.cxx:1149
TProof.cxx:1150
TProof.cxx:1151
TProof.cxx:1152
TProof.cxx:1153
TProof.cxx:1154
TProof.cxx:1155
TProof.cxx:1156
TProof.cxx:1157
TProof.cxx:1158
TProof.cxx:1159
TProof.cxx:1160
TProof.cxx:1161
TProof.cxx:1162
TProof.cxx:1163
TProof.cxx:1164
TProof.cxx:1165
TProof.cxx:1166
TProof.cxx:1167
TProof.cxx:1168
TProof.cxx:1169
TProof.cxx:1170
TProof.cxx:1171
TProof.cxx:1172
TProof.cxx:1173
TProof.cxx:1174
TProof.cxx:1175
TProof.cxx:1176
TProof.cxx:1177
TProof.cxx:1178
TProof.cxx:1179
TProof.cxx:1180
TProof.cxx:1181
TProof.cxx:1182
TProof.cxx:1183
TProof.cxx:1184
TProof.cxx:1185
TProof.cxx:1186
TProof.cxx:1187
TProof.cxx:1188
TProof.cxx:1189
TProof.cxx:1190
TProof.cxx:1191
TProof.cxx:1192
TProof.cxx:1193
TProof.cxx:1194
TProof.cxx:1195
TProof.cxx:1196
TProof.cxx:1197
TProof.cxx:1198
TProof.cxx:1199
TProof.cxx:1200
TProof.cxx:1201
TProof.cxx:1202
TProof.cxx:1203
TProof.cxx:1204
TProof.cxx:1205
TProof.cxx:1206
TProof.cxx:1207
TProof.cxx:1208
TProof.cxx:1209
TProof.cxx:1210
TProof.cxx:1211
TProof.cxx:1212
TProof.cxx:1213
TProof.cxx:1214
TProof.cxx:1215
TProof.cxx:1216
TProof.cxx:1217
TProof.cxx:1218
TProof.cxx:1219
TProof.cxx:1220
TProof.cxx:1221
TProof.cxx:1222
TProof.cxx:1223
TProof.cxx:1224
TProof.cxx:1225
TProof.cxx:1226
TProof.cxx:1227
TProof.cxx:1228
TProof.cxx:1229
TProof.cxx:1230
TProof.cxx:1231
TProof.cxx:1232
TProof.cxx:1233
TProof.cxx:1234
TProof.cxx:1235
TProof.cxx:1236
TProof.cxx:1237
TProof.cxx:1238
TProof.cxx:1239
TProof.cxx:1240
TProof.cxx:1241
TProof.cxx:1242
TProof.cxx:1243
TProof.cxx:1244
TProof.cxx:1245
TProof.cxx:1246
TProof.cxx:1247
TProof.cxx:1248
TProof.cxx:1249
TProof.cxx:1250
TProof.cxx:1251
TProof.cxx:1252
TProof.cxx:1253
TProof.cxx:1254
TProof.cxx:1255
TProof.cxx:1256
TProof.cxx:1257
TProof.cxx:1258
TProof.cxx:1259
TProof.cxx:1260
TProof.cxx:1261
TProof.cxx:1262
TProof.cxx:1263
TProof.cxx:1264
TProof.cxx:1265
TProof.cxx:1266
TProof.cxx:1267
TProof.cxx:1268
TProof.cxx:1269
TProof.cxx:1270
TProof.cxx:1271
TProof.cxx:1272
TProof.cxx:1273
TProof.cxx:1274
TProof.cxx:1275
TProof.cxx:1276
TProof.cxx:1277
TProof.cxx:1278
TProof.cxx:1279
TProof.cxx:1280
TProof.cxx:1281
TProof.cxx:1282
TProof.cxx:1283
TProof.cxx:1284
TProof.cxx:1285
TProof.cxx:1286
TProof.cxx:1287
TProof.cxx:1288
TProof.cxx:1289
TProof.cxx:1290
TProof.cxx:1291
TProof.cxx:1292
TProof.cxx:1293
TProof.cxx:1294
TProof.cxx:1295
TProof.cxx:1296
TProof.cxx:1297
TProof.cxx:1298
TProof.cxx:1299
TProof.cxx:1300
TProof.cxx:1301
TProof.cxx:1302
TProof.cxx:1303
TProof.cxx:1304
TProof.cxx:1305
TProof.cxx:1306
TProof.cxx:1307
TProof.cxx:1308
TProof.cxx:1309
TProof.cxx:1310
TProof.cxx:1311
TProof.cxx:1312
TProof.cxx:1313
TProof.cxx:1314
TProof.cxx:1315
TProof.cxx:1316
TProof.cxx:1317
TProof.cxx:1318
TProof.cxx:1319
TProof.cxx:1320
TProof.cxx:1321
TProof.cxx:1322
TProof.cxx:1323
TProof.cxx:1324
TProof.cxx:1325
TProof.cxx:1326
TProof.cxx:1327
TProof.cxx:1328
TProof.cxx:1329
TProof.cxx:1330
TProof.cxx:1331
TProof.cxx:1332
TProof.cxx:1333
TProof.cxx:1334
TProof.cxx:1335
TProof.cxx:1336
TProof.cxx:1337
TProof.cxx:1338
TProof.cxx:1339
TProof.cxx:1340
TProof.cxx:1341
TProof.cxx:1342
TProof.cxx:1343
TProof.cxx:1344
TProof.cxx:1345
TProof.cxx:1346
TProof.cxx:1347
TProof.cxx:1348
TProof.cxx:1349
TProof.cxx:1350
TProof.cxx:1351
TProof.cxx:1352
TProof.cxx:1353
TProof.cxx:1354
TProof.cxx:1355
TProof.cxx:1356
TProof.cxx:1357
TProof.cxx:1358
TProof.cxx:1359
TProof.cxx:1360
TProof.cxx:1361
TProof.cxx:1362
TProof.cxx:1363
TProof.cxx:1364
TProof.cxx:1365
TProof.cxx:1366
TProof.cxx:1367
TProof.cxx:1368
TProof.cxx:1369
TProof.cxx:1370
TProof.cxx:1371
TProof.cxx:1372
TProof.cxx:1373
TProof.cxx:1374
TProof.cxx:1375
TProof.cxx:1376
TProof.cxx:1377
TProof.cxx:1378
TProof.cxx:1379
TProof.cxx:1380
TProof.cxx:1381
TProof.cxx:1382
TProof.cxx:1383
TProof.cxx:1384
TProof.cxx:1385
TProof.cxx:1386
TProof.cxx:1387
TProof.cxx:1388
TProof.cxx:1389
TProof.cxx:1390
TProof.cxx:1391
TProof.cxx:1392
TProof.cxx:1393
TProof.cxx:1394
TProof.cxx:1395
TProof.cxx:1396
TProof.cxx:1397
TProof.cxx:1398
TProof.cxx:1399
TProof.cxx:1400
TProof.cxx:1401
TProof.cxx:1402
TProof.cxx:1403
TProof.cxx:1404
TProof.cxx:1405
TProof.cxx:1406
TProof.cxx:1407
TProof.cxx:1408
TProof.cxx:1409
TProof.cxx:1410
TProof.cxx:1411
TProof.cxx:1412
TProof.cxx:1413
TProof.cxx:1414
TProof.cxx:1415
TProof.cxx:1416
TProof.cxx:1417
TProof.cxx:1418
TProof.cxx:1419
TProof.cxx:1420
TProof.cxx:1421
TProof.cxx:1422
TProof.cxx:1423
TProof.cxx:1424
TProof.cxx:1425
TProof.cxx:1426
TProof.cxx:1427
TProof.cxx:1428
TProof.cxx:1429
TProof.cxx:1430
TProof.cxx:1431
TProof.cxx:1432
TProof.cxx:1433
TProof.cxx:1434
TProof.cxx:1435
TProof.cxx:1436
TProof.cxx:1437
TProof.cxx:1438
TProof.cxx:1439
TProof.cxx:1440
TProof.cxx:1441
TProof.cxx:1442
TProof.cxx:1443
TProof.cxx:1444
TProof.cxx:1445
TProof.cxx:1446
TProof.cxx:1447
TProof.cxx:1448
TProof.cxx:1449
TProof.cxx:1450
TProof.cxx:1451
TProof.cxx:1452
TProof.cxx:1453
TProof.cxx:1454
TProof.cxx:1455
TProof.cxx:1456
TProof.cxx:1457
TProof.cxx:1458
TProof.cxx:1459
TProof.cxx:1460
TProof.cxx:1461
TProof.cxx:1462
TProof.cxx:1463
TProof.cxx:1464
TProof.cxx:1465
TProof.cxx:1466
TProof.cxx:1467
TProof.cxx:1468
TProof.cxx:1469
TProof.cxx:1470
TProof.cxx:1471
TProof.cxx:1472
TProof.cxx:1473
TProof.cxx:1474
TProof.cxx:1475
TProof.cxx:1476
TProof.cxx:1477
TProof.cxx:1478
TProof.cxx:1479
TProof.cxx:1480
TProof.cxx:1481
TProof.cxx:1482
TProof.cxx:1483
TProof.cxx:1484
TProof.cxx:1485
TProof.cxx:1486
TProof.cxx:1487
TProof.cxx:1488
TProof.cxx:1489
TProof.cxx:1490
TProof.cxx:1491
TProof.cxx:1492
TProof.cxx:1493
TProof.cxx:1494
TProof.cxx:1495
TProof.cxx:1496
TProof.cxx:1497
TProof.cxx:1498
TProof.cxx:1499
TProof.cxx:1500
TProof.cxx:1501
TProof.cxx:1502
TProof.cxx:1503
TProof.cxx:1504
TProof.cxx:1505
TProof.cxx:1506
TProof.cxx:1507
TProof.cxx:1508
TProof.cxx:1509
TProof.cxx:1510
TProof.cxx:1511
TProof.cxx:1512
TProof.cxx:1513
TProof.cxx:1514
TProof.cxx:1515
TProof.cxx:1516
TProof.cxx:1517
TProof.cxx:1518
TProof.cxx:1519
TProof.cxx:1520
TProof.cxx:1521
TProof.cxx:1522
TProof.cxx:1523
TProof.cxx:1524
TProof.cxx:1525
TProof.cxx:1526
TProof.cxx:1527
TProof.cxx:1528
TProof.cxx:1529
TProof.cxx:1530
TProof.cxx:1531
TProof.cxx:1532
TProof.cxx:1533
TProof.cxx:1534
TProof.cxx:1535
TProof.cxx:1536
TProof.cxx:1537
TProof.cxx:1538
TProof.cxx:1539
TProof.cxx:1540
TProof.cxx:1541
TProof.cxx:1542
TProof.cxx:1543
TProof.cxx:1544
TProof.cxx:1545
TProof.cxx:1546
TProof.cxx:1547
TProof.cxx:1548
TProof.cxx:1549
TProof.cxx:1550
TProof.cxx:1551
TProof.cxx:1552
TProof.cxx:1553
TProof.cxx:1554
TProof.cxx:1555
TProof.cxx:1556
TProof.cxx:1557
TProof.cxx:1558
TProof.cxx:1559
TProof.cxx:1560
TProof.cxx:1561
TProof.cxx:1562
TProof.cxx:1563
TProof.cxx:1564
TProof.cxx:1565
TProof.cxx:1566
TProof.cxx:1567
TProof.cxx:1568
TProof.cxx:1569
TProof.cxx:1570
TProof.cxx:1571
TProof.cxx:1572
TProof.cxx:1573
TProof.cxx:1574
TProof.cxx:1575
TProof.cxx:1576
TProof.cxx:1577
TProof.cxx:1578
TProof.cxx:1579
TProof.cxx:1580
TProof.cxx:1581
TProof.cxx:1582
TProof.cxx:1583
TProof.cxx:1584
TProof.cxx:1585
TProof.cxx:1586
TProof.cxx:1587
TProof.cxx:1588
TProof.cxx:1589
TProof.cxx:1590
TProof.cxx:1591
TProof.cxx:1592
TProof.cxx:1593
TProof.cxx:1594
TProof.cxx:1595
TProof.cxx:1596
TProof.cxx:1597
TProof.cxx:1598
TProof.cxx:1599
TProof.cxx:1600
TProof.cxx:1601
TProof.cxx:1602
TProof.cxx:1603
TProof.cxx:1604
TProof.cxx:1605
TProof.cxx:1606
TProof.cxx:1607
TProof.cxx:1608
TProof.cxx:1609
TProof.cxx:1610
TProof.cxx:1611
TProof.cxx:1612
TProof.cxx:1613
TProof.cxx:1614
TProof.cxx:1615
TProof.cxx:1616
TProof.cxx:1617
TProof.cxx:1618
TProof.cxx:1619
TProof.cxx:1620
TProof.cxx:1621
TProof.cxx:1622
TProof.cxx:1623
TProof.cxx:1624
TProof.cxx:1625
TProof.cxx:1626
TProof.cxx:1627
TProof.cxx:1628
TProof.cxx:1629
TProof.cxx:1630
TProof.cxx:1631
TProof.cxx:1632
TProof.cxx:1633
TProof.cxx:1634
TProof.cxx:1635
TProof.cxx:1636
TProof.cxx:1637
TProof.cxx:1638
TProof.cxx:1639
TProof.cxx:1640
TProof.cxx:1641
TProof.cxx:1642
TProof.cxx:1643
TProof.cxx:1644
TProof.cxx:1645
TProof.cxx:1646
TProof.cxx:1647
TProof.cxx:1648
TProof.cxx:1649
TProof.cxx:1650
TProof.cxx:1651
TProof.cxx:1652
TProof.cxx:1653
TProof.cxx:1654
TProof.cxx:1655
TProof.cxx:1656
TProof.cxx:1657
TProof.cxx:1658
TProof.cxx:1659
TProof.cxx:1660
TProof.cxx:1661
TProof.cxx:1662
TProof.cxx:1663
TProof.cxx:1664
TProof.cxx:1665
TProof.cxx:1666
TProof.cxx:1667
TProof.cxx:1668
TProof.cxx:1669
TProof.cxx:1670
TProof.cxx:1671
TProof.cxx:1672
TProof.cxx:1673
TProof.cxx:1674
TProof.cxx:1675
TProof.cxx:1676
TProof.cxx:1677
TProof.cxx:1678
TProof.cxx:1679
TProof.cxx:1680
TProof.cxx:1681
TProof.cxx:1682
TProof.cxx:1683
TProof.cxx:1684
TProof.cxx:1685
TProof.cxx:1686
TProof.cxx:1687
TProof.cxx:1688
TProof.cxx:1689
TProof.cxx:1690
TProof.cxx:1691
TProof.cxx:1692
TProof.cxx:1693
TProof.cxx:1694
TProof.cxx:1695
TProof.cxx:1696
TProof.cxx:1697
TProof.cxx:1698
TProof.cxx:1699
TProof.cxx:1700
TProof.cxx:1701
TProof.cxx:1702
TProof.cxx:1703
TProof.cxx:1704
TProof.cxx:1705
TProof.cxx:1706
TProof.cxx:1707
TProof.cxx:1708
TProof.cxx:1709
TProof.cxx:1710
TProof.cxx:1711
TProof.cxx:1712
TProof.cxx:1713
TProof.cxx:1714
TProof.cxx:1715
TProof.cxx:1716
TProof.cxx:1717
TProof.cxx:1718
TProof.cxx:1719
TProof.cxx:1720
TProof.cxx:1721
TProof.cxx:1722
TProof.cxx:1723
TProof.cxx:1724
TProof.cxx:1725
TProof.cxx:1726
TProof.cxx:1727
TProof.cxx:1728
TProof.cxx:1729
TProof.cxx:1730
TProof.cxx:1731
TProof.cxx:1732
TProof.cxx:1733
TProof.cxx:1734
TProof.cxx:1735
TProof.cxx:1736
TProof.cxx:1737
TProof.cxx:1738
TProof.cxx:1739
TProof.cxx:1740
TProof.cxx:1741
TProof.cxx:1742
TProof.cxx:1743
TProof.cxx:1744
TProof.cxx:1745
TProof.cxx:1746
TProof.cxx:1747
TProof.cxx:1748
TProof.cxx:1749
TProof.cxx:1750
TProof.cxx:1751
TProof.cxx:1752
TProof.cxx:1753
TProof.cxx:1754
TProof.cxx:1755
TProof.cxx:1756
TProof.cxx:1757
TProof.cxx:1758
TProof.cxx:1759
TProof.cxx:1760
TProof.cxx:1761
TProof.cxx:1762
TProof.cxx:1763
TProof.cxx:1764
TProof.cxx:1765
TProof.cxx:1766
TProof.cxx:1767
TProof.cxx:1768
TProof.cxx:1769
TProof.cxx:1770
TProof.cxx:1771
TProof.cxx:1772
TProof.cxx:1773
TProof.cxx:1774
TProof.cxx:1775
TProof.cxx:1776
TProof.cxx:1777
TProof.cxx:1778
TProof.cxx:1779
TProof.cxx:1780
TProof.cxx:1781
TProof.cxx:1782
TProof.cxx:1783
TProof.cxx:1784
TProof.cxx:1785
TProof.cxx:1786
TProof.cxx:1787
TProof.cxx:1788
TProof.cxx:1789
TProof.cxx:1790
TProof.cxx:1791
TProof.cxx:1792
TProof.cxx:1793
TProof.cxx:1794
TProof.cxx:1795
TProof.cxx:1796
TProof.cxx:1797
TProof.cxx:1798
TProof.cxx:1799
TProof.cxx:1800
TProof.cxx:1801
TProof.cxx:1802
TProof.cxx:1803
TProof.cxx:1804
TProof.cxx:1805
TProof.cxx:1806
TProof.cxx:1807
TProof.cxx:1808
TProof.cxx:1809
TProof.cxx:1810
TProof.cxx:1811
TProof.cxx:1812
TProof.cxx:1813
TProof.cxx:1814
TProof.cxx:1815
TProof.cxx:1816
TProof.cxx:1817
TProof.cxx:1818
TProof.cxx:1819
TProof.cxx:1820
TProof.cxx:1821
TProof.cxx:1822
TProof.cxx:1823
TProof.cxx:1824
TProof.cxx:1825
TProof.cxx:1826
TProof.cxx:1827
TProof.cxx:1828
TProof.cxx:1829
TProof.cxx:1830
TProof.cxx:1831
TProof.cxx:1832
TProof.cxx:1833
TProof.cxx:1834
TProof.cxx:1835
TProof.cxx:1836
TProof.cxx:1837
TProof.cxx:1838
TProof.cxx:1839
TProof.cxx:1840
TProof.cxx:1841
TProof.cxx:1842
TProof.cxx:1843
TProof.cxx:1844
TProof.cxx:1845
TProof.cxx:1846
TProof.cxx:1847
TProof.cxx:1848
TProof.cxx:1849
TProof.cxx:1850
TProof.cxx:1851
TProof.cxx:1852
TProof.cxx:1853
TProof.cxx:1854
TProof.cxx:1855
TProof.cxx:1856
TProof.cxx:1857
TProof.cxx:1858
TProof.cxx:1859
TProof.cxx:1860
TProof.cxx:1861
TProof.cxx:1862
TProof.cxx:1863
TProof.cxx:1864
TProof.cxx:1865
TProof.cxx:1866
TProof.cxx:1867
TProof.cxx:1868
TProof.cxx:1869
TProof.cxx:1870
TProof.cxx:1871
TProof.cxx:1872
TProof.cxx:1873
TProof.cxx:1874
TProof.cxx:1875
TProof.cxx:1876
TProof.cxx:1877
TProof.cxx:1878
TProof.cxx:1879
TProof.cxx:1880
TProof.cxx:1881
TProof.cxx:1882
TProof.cxx:1883
TProof.cxx:1884
TProof.cxx:1885
TProof.cxx:1886
TProof.cxx:1887
TProof.cxx:1888
TProof.cxx:1889
TProof.cxx:1890
TProof.cxx:1891
TProof.cxx:1892
TProof.cxx:1893
TProof.cxx:1894
TProof.cxx:1895
TProof.cxx:1896
TProof.cxx:1897
TProof.cxx:1898
TProof.cxx:1899
TProof.cxx:1900
TProof.cxx:1901
TProof.cxx:1902
TProof.cxx:1903
TProof.cxx:1904
TProof.cxx:1905
TProof.cxx:1906
TProof.cxx:1907
TProof.cxx:1908
TProof.cxx:1909
TProof.cxx:1910
TProof.cxx:1911
TProof.cxx:1912
TProof.cxx:1913
TProof.cxx:1914
TProof.cxx:1915
TProof.cxx:1916
TProof.cxx:1917
TProof.cxx:1918
TProof.cxx:1919
TProof.cxx:1920
TProof.cxx:1921
TProof.cxx:1922
TProof.cxx:1923
TProof.cxx:1924
TProof.cxx:1925
TProof.cxx:1926
TProof.cxx:1927
TProof.cxx:1928
TProof.cxx:1929
TProof.cxx:1930
TProof.cxx:1931
TProof.cxx:1932
TProof.cxx:1933
TProof.cxx:1934
TProof.cxx:1935
TProof.cxx:1936
TProof.cxx:1937
TProof.cxx:1938
TProof.cxx:1939
TProof.cxx:1940
TProof.cxx:1941
TProof.cxx:1942
TProof.cxx:1943
TProof.cxx:1944
TProof.cxx:1945
TProof.cxx:1946
TProof.cxx:1947
TProof.cxx:1948
TProof.cxx:1949
TProof.cxx:1950
TProof.cxx:1951
TProof.cxx:1952
TProof.cxx:1953
TProof.cxx:1954
TProof.cxx:1955
TProof.cxx:1956
TProof.cxx:1957
TProof.cxx:1958
TProof.cxx:1959
TProof.cxx:1960
TProof.cxx:1961
TProof.cxx:1962
TProof.cxx:1963
TProof.cxx:1964
TProof.cxx:1965
TProof.cxx:1966
TProof.cxx:1967
TProof.cxx:1968
TProof.cxx:1969
TProof.cxx:1970
TProof.cxx:1971
TProof.cxx:1972
TProof.cxx:1973
TProof.cxx:1974
TProof.cxx:1975
TProof.cxx:1976
TProof.cxx:1977
TProof.cxx:1978
TProof.cxx:1979
TProof.cxx:1980
TProof.cxx:1981
TProof.cxx:1982
TProof.cxx:1983
TProof.cxx:1984
TProof.cxx:1985
TProof.cxx:1986
TProof.cxx:1987
TProof.cxx:1988
TProof.cxx:1989
TProof.cxx:1990
TProof.cxx:1991
TProof.cxx:1992
TProof.cxx:1993
TProof.cxx:1994
TProof.cxx:1995
TProof.cxx:1996
TProof.cxx:1997
TProof.cxx:1998
TProof.cxx:1999
TProof.cxx:2000
TProof.cxx:2001
TProof.cxx:2002
TProof.cxx:2003
TProof.cxx:2004
TProof.cxx:2005
TProof.cxx:2006
TProof.cxx:2007
TProof.cxx:2008
TProof.cxx:2009
TProof.cxx:2010
TProof.cxx:2011
TProof.cxx:2012
TProof.cxx:2013
TProof.cxx:2014
TProof.cxx:2015
TProof.cxx:2016
TProof.cxx:2017
TProof.cxx:2018
TProof.cxx:2019
TProof.cxx:2020
TProof.cxx:2021
TProof.cxx:2022
TProof.cxx:2023
TProof.cxx:2024
TProof.cxx:2025
TProof.cxx:2026
TProof.cxx:2027
TProof.cxx:2028
TProof.cxx:2029
TProof.cxx:2030
TProof.cxx:2031
TProof.cxx:2032
TProof.cxx:2033
TProof.cxx:2034
TProof.cxx:2035
TProof.cxx:2036
TProof.cxx:2037
TProof.cxx:2038
TProof.cxx:2039
TProof.cxx:2040
TProof.cxx:2041
TProof.cxx:2042
TProof.cxx:2043
TProof.cxx:2044
TProof.cxx:2045
TProof.cxx:2046
TProof.cxx:2047
TProof.cxx:2048
TProof.cxx:2049
TProof.cxx:2050
TProof.cxx:2051
TProof.cxx:2052
TProof.cxx:2053
TProof.cxx:2054
TProof.cxx:2055
TProof.cxx:2056
TProof.cxx:2057
TProof.cxx:2058
TProof.cxx:2059
TProof.cxx:2060
TProof.cxx:2061
TProof.cxx:2062
TProof.cxx:2063
TProof.cxx:2064
TProof.cxx:2065
TProof.cxx:2066
TProof.cxx:2067
TProof.cxx:2068
TProof.cxx:2069
TProof.cxx:2070
TProof.cxx:2071
TProof.cxx:2072
TProof.cxx:2073
TProof.cxx:2074
TProof.cxx:2075
TProof.cxx:2076
TProof.cxx:2077
TProof.cxx:2078
TProof.cxx:2079
TProof.cxx:2080
TProof.cxx:2081
TProof.cxx:2082
TProof.cxx:2083
TProof.cxx:2084
TProof.cxx:2085
TProof.cxx:2086
TProof.cxx:2087
TProof.cxx:2088
TProof.cxx:2089
TProof.cxx:2090
TProof.cxx:2091
TProof.cxx:2092
TProof.cxx:2093
TProof.cxx:2094
TProof.cxx:2095
TProof.cxx:2096
TProof.cxx:2097
TProof.cxx:2098
TProof.cxx:2099
TProof.cxx:2100
TProof.cxx:2101
TProof.cxx:2102
TProof.cxx:2103
TProof.cxx:2104
TProof.cxx:2105
TProof.cxx:2106
TProof.cxx:2107
TProof.cxx:2108
TProof.cxx:2109
TProof.cxx:2110
TProof.cxx:2111
TProof.cxx:2112
TProof.cxx:2113
TProof.cxx:2114
TProof.cxx:2115
TProof.cxx:2116
TProof.cxx:2117
TProof.cxx:2118
TProof.cxx:2119
TProof.cxx:2120
TProof.cxx:2121
TProof.cxx:2122
TProof.cxx:2123
TProof.cxx:2124
TProof.cxx:2125
TProof.cxx:2126
TProof.cxx:2127
TProof.cxx:2128
TProof.cxx:2129
TProof.cxx:2130
TProof.cxx:2131
TProof.cxx:2132
TProof.cxx:2133
TProof.cxx:2134
TProof.cxx:2135
TProof.cxx:2136
TProof.cxx:2137
TProof.cxx:2138
TProof.cxx:2139
TProof.cxx:2140
TProof.cxx:2141
TProof.cxx:2142
TProof.cxx:2143
TProof.cxx:2144
TProof.cxx:2145
TProof.cxx:2146
TProof.cxx:2147
TProof.cxx:2148
TProof.cxx:2149
TProof.cxx:2150
TProof.cxx:2151
TProof.cxx:2152
TProof.cxx:2153
TProof.cxx:2154
TProof.cxx:2155
TProof.cxx:2156
TProof.cxx:2157
TProof.cxx:2158
TProof.cxx:2159
TProof.cxx:2160
TProof.cxx:2161
TProof.cxx:2162
TProof.cxx:2163
TProof.cxx:2164
TProof.cxx:2165
TProof.cxx:2166
TProof.cxx:2167
TProof.cxx:2168
TProof.cxx:2169
TProof.cxx:2170
TProof.cxx:2171
TProof.cxx:2172
TProof.cxx:2173
TProof.cxx:2174
TProof.cxx:2175
TProof.cxx:2176
TProof.cxx:2177
TProof.cxx:2178
TProof.cxx:2179
TProof.cxx:2180
TProof.cxx:2181
TProof.cxx:2182
TProof.cxx:2183
TProof.cxx:2184
TProof.cxx:2185
TProof.cxx:2186
TProof.cxx:2187
TProof.cxx:2188
TProof.cxx:2189
TProof.cxx:2190
TProof.cxx:2191
TProof.cxx:2192
TProof.cxx:2193
TProof.cxx:2194
TProof.cxx:2195
TProof.cxx:2196
TProof.cxx:2197
TProof.cxx:2198
TProof.cxx:2199
TProof.cxx:2200
TProof.cxx:2201
TProof.cxx:2202
TProof.cxx:2203
TProof.cxx:2204
TProof.cxx:2205
TProof.cxx:2206
TProof.cxx:2207
TProof.cxx:2208
TProof.cxx:2209
TProof.cxx:2210
TProof.cxx:2211
TProof.cxx:2212
TProof.cxx:2213
TProof.cxx:2214
TProof.cxx:2215
TProof.cxx:2216
TProof.cxx:2217
TProof.cxx:2218
TProof.cxx:2219
TProof.cxx:2220
TProof.cxx:2221
TProof.cxx:2222
TProof.cxx:2223
TProof.cxx:2224
TProof.cxx:2225
TProof.cxx:2226
TProof.cxx:2227
TProof.cxx:2228
TProof.cxx:2229
TProof.cxx:2230
TProof.cxx:2231
TProof.cxx:2232
TProof.cxx:2233
TProof.cxx:2234
TProof.cxx:2235
TProof.cxx:2236
TProof.cxx:2237
TProof.cxx:2238
TProof.cxx:2239
TProof.cxx:2240
TProof.cxx:2241
TProof.cxx:2242
TProof.cxx:2243
TProof.cxx:2244
TProof.cxx:2245
TProof.cxx:2246
TProof.cxx:2247
TProof.cxx:2248
TProof.cxx:2249
TProof.cxx:2250
TProof.cxx:2251
TProof.cxx:2252
TProof.cxx:2253
TProof.cxx:2254
TProof.cxx:2255
TProof.cxx:2256
TProof.cxx:2257
TProof.cxx:2258
TProof.cxx:2259
TProof.cxx:2260
TProof.cxx:2261
TProof.cxx:2262
TProof.cxx:2263
TProof.cxx:2264
TProof.cxx:2265
TProof.cxx:2266
TProof.cxx:2267
TProof.cxx:2268
TProof.cxx:2269
TProof.cxx:2270
TProof.cxx:2271
TProof.cxx:2272
TProof.cxx:2273
TProof.cxx:2274
TProof.cxx:2275
TProof.cxx:2276
TProof.cxx:2277
TProof.cxx:2278
TProof.cxx:2279
TProof.cxx:2280
TProof.cxx:2281
TProof.cxx:2282
TProof.cxx:2283
TProof.cxx:2284
TProof.cxx:2285
TProof.cxx:2286
TProof.cxx:2287
TProof.cxx:2288
TProof.cxx:2289
TProof.cxx:2290
TProof.cxx:2291
TProof.cxx:2292
TProof.cxx:2293
TProof.cxx:2294
TProof.cxx:2295
TProof.cxx:2296
TProof.cxx:2297
TProof.cxx:2298
TProof.cxx:2299
TProof.cxx:2300
TProof.cxx:2301
TProof.cxx:2302
TProof.cxx:2303
TProof.cxx:2304
TProof.cxx:2305
TProof.cxx:2306
TProof.cxx:2307
TProof.cxx:2308
TProof.cxx:2309
TProof.cxx:2310
TProof.cxx:2311
TProof.cxx:2312
TProof.cxx:2313
TProof.cxx:2314
TProof.cxx:2315
TProof.cxx:2316
TProof.cxx:2317
TProof.cxx:2318
TProof.cxx:2319
TProof.cxx:2320
TProof.cxx:2321
TProof.cxx:2322
TProof.cxx:2323
TProof.cxx:2324
TProof.cxx:2325
TProof.cxx:2326
TProof.cxx:2327
TProof.cxx:2328
TProof.cxx:2329
TProof.cxx:2330
TProof.cxx:2331
TProof.cxx:2332
TProof.cxx:2333
TProof.cxx:2334
TProof.cxx:2335
TProof.cxx:2336
TProof.cxx:2337
TProof.cxx:2338
TProof.cxx:2339
TProof.cxx:2340
TProof.cxx:2341
TProof.cxx:2342
TProof.cxx:2343
TProof.cxx:2344
TProof.cxx:2345
TProof.cxx:2346
TProof.cxx:2347
TProof.cxx:2348
TProof.cxx:2349
TProof.cxx:2350
TProof.cxx:2351
TProof.cxx:2352
TProof.cxx:2353
TProof.cxx:2354
TProof.cxx:2355
TProof.cxx:2356
TProof.cxx:2357
TProof.cxx:2358
TProof.cxx:2359
TProof.cxx:2360
TProof.cxx:2361
TProof.cxx:2362
TProof.cxx:2363
TProof.cxx:2364
TProof.cxx:2365
TProof.cxx:2366
TProof.cxx:2367
TProof.cxx:2368
TProof.cxx:2369
TProof.cxx:2370
TProof.cxx:2371
TProof.cxx:2372
TProof.cxx:2373
TProof.cxx:2374
TProof.cxx:2375
TProof.cxx:2376
TProof.cxx:2377
TProof.cxx:2378
TProof.cxx:2379
TProof.cxx:2380
TProof.cxx:2381
TProof.cxx:2382
TProof.cxx:2383
TProof.cxx:2384
TProof.cxx:2385
TProof.cxx:2386
TProof.cxx:2387
TProof.cxx:2388
TProof.cxx:2389
TProof.cxx:2390
TProof.cxx:2391
TProof.cxx:2392
TProof.cxx:2393
TProof.cxx:2394
TProof.cxx:2395
TProof.cxx:2396
TProof.cxx:2397
TProof.cxx:2398
TProof.cxx:2399
TProof.cxx:2400
TProof.cxx:2401
TProof.cxx:2402
TProof.cxx:2403
TProof.cxx:2404
TProof.cxx:2405
TProof.cxx:2406
TProof.cxx:2407
TProof.cxx:2408
TProof.cxx:2409
TProof.cxx:2410
TProof.cxx:2411
TProof.cxx:2412
TProof.cxx:2413
TProof.cxx:2414
TProof.cxx:2415
TProof.cxx:2416
TProof.cxx:2417
TProof.cxx:2418
TProof.cxx:2419
TProof.cxx:2420
TProof.cxx:2421
TProof.cxx:2422
TProof.cxx:2423
TProof.cxx:2424
TProof.cxx:2425
TProof.cxx:2426
TProof.cxx:2427
TProof.cxx:2428
TProof.cxx:2429
TProof.cxx:2430
TProof.cxx:2431
TProof.cxx:2432
TProof.cxx:2433
TProof.cxx:2434
TProof.cxx:2435
TProof.cxx:2436
TProof.cxx:2437
TProof.cxx:2438
TProof.cxx:2439
TProof.cxx:2440
TProof.cxx:2441
TProof.cxx:2442
TProof.cxx:2443
TProof.cxx:2444
TProof.cxx:2445
TProof.cxx:2446
TProof.cxx:2447
TProof.cxx:2448
TProof.cxx:2449
TProof.cxx:2450
TProof.cxx:2451
TProof.cxx:2452
TProof.cxx:2453
TProof.cxx:2454
TProof.cxx:2455
TProof.cxx:2456
TProof.cxx:2457
TProof.cxx:2458
TProof.cxx:2459
TProof.cxx:2460
TProof.cxx:2461
TProof.cxx:2462
TProof.cxx:2463
TProof.cxx:2464
TProof.cxx:2465
TProof.cxx:2466
TProof.cxx:2467
TProof.cxx:2468
TProof.cxx:2469
TProof.cxx:2470
TProof.cxx:2471
TProof.cxx:2472
TProof.cxx:2473
TProof.cxx:2474
TProof.cxx:2475
TProof.cxx:2476
TProof.cxx:2477
TProof.cxx:2478
TProof.cxx:2479
TProof.cxx:2480
TProof.cxx:2481
TProof.cxx:2482
TProof.cxx:2483
TProof.cxx:2484
TProof.cxx:2485
TProof.cxx:2486
TProof.cxx:2487
TProof.cxx:2488
TProof.cxx:2489
TProof.cxx:2490
TProof.cxx:2491
TProof.cxx:2492
TProof.cxx:2493
TProof.cxx:2494
TProof.cxx:2495
TProof.cxx:2496
TProof.cxx:2497
TProof.cxx:2498
TProof.cxx:2499
TProof.cxx:2500
TProof.cxx:2501
TProof.cxx:2502
TProof.cxx:2503
TProof.cxx:2504
TProof.cxx:2505
TProof.cxx:2506
TProof.cxx:2507
TProof.cxx:2508
TProof.cxx:2509
TProof.cxx:2510
TProof.cxx:2511
TProof.cxx:2512
TProof.cxx:2513
TProof.cxx:2514
TProof.cxx:2515
TProof.cxx:2516
TProof.cxx:2517
TProof.cxx:2518
TProof.cxx:2519
TProof.cxx:2520
TProof.cxx:2521
TProof.cxx:2522
TProof.cxx:2523
TProof.cxx:2524
TProof.cxx:2525
TProof.cxx:2526
TProof.cxx:2527
TProof.cxx:2528
TProof.cxx:2529
TProof.cxx:2530
TProof.cxx:2531
TProof.cxx:2532
TProof.cxx:2533
TProof.cxx:2534
TProof.cxx:2535
TProof.cxx:2536
TProof.cxx:2537
TProof.cxx:2538
TProof.cxx:2539
TProof.cxx:2540
TProof.cxx:2541
TProof.cxx:2542
TProof.cxx:2543
TProof.cxx:2544
TProof.cxx:2545
TProof.cxx:2546
TProof.cxx:2547
TProof.cxx:2548
TProof.cxx:2549
TProof.cxx:2550
TProof.cxx:2551
TProof.cxx:2552
TProof.cxx:2553
TProof.cxx:2554
TProof.cxx:2555
TProof.cxx:2556
TProof.cxx:2557
TProof.cxx:2558
TProof.cxx:2559
TProof.cxx:2560
TProof.cxx:2561
TProof.cxx:2562
TProof.cxx:2563
TProof.cxx:2564
TProof.cxx:2565
TProof.cxx:2566
TProof.cxx:2567
TProof.cxx:2568
TProof.cxx:2569
TProof.cxx:2570
TProof.cxx:2571
TProof.cxx:2572
TProof.cxx:2573
TProof.cxx:2574
TProof.cxx:2575
TProof.cxx:2576
TProof.cxx:2577
TProof.cxx:2578
TProof.cxx:2579
TProof.cxx:2580
TProof.cxx:2581
TProof.cxx:2582
TProof.cxx:2583
TProof.cxx:2584
TProof.cxx:2585
TProof.cxx:2586
TProof.cxx:2587
TProof.cxx:2588
TProof.cxx:2589
TProof.cxx:2590
TProof.cxx:2591
TProof.cxx:2592
TProof.cxx:2593
TProof.cxx:2594
TProof.cxx:2595
TProof.cxx:2596
TProof.cxx:2597
TProof.cxx:2598
TProof.cxx:2599
TProof.cxx:2600
TProof.cxx:2601
TProof.cxx:2602
TProof.cxx:2603
TProof.cxx:2604
TProof.cxx:2605
TProof.cxx:2606
TProof.cxx:2607
TProof.cxx:2608
TProof.cxx:2609
TProof.cxx:2610
TProof.cxx:2611
TProof.cxx:2612
TProof.cxx:2613
TProof.cxx:2614
TProof.cxx:2615
TProof.cxx:2616
TProof.cxx:2617
TProof.cxx:2618
TProof.cxx:2619
TProof.cxx:2620
TProof.cxx:2621
TProof.cxx:2622
TProof.cxx:2623
TProof.cxx:2624
TProof.cxx:2625
TProof.cxx:2626
TProof.cxx:2627
TProof.cxx:2628
TProof.cxx:2629
TProof.cxx:2630
TProof.cxx:2631
TProof.cxx:2632
TProof.cxx:2633
TProof.cxx:2634
TProof.cxx:2635
TProof.cxx:2636
TProof.cxx:2637
TProof.cxx:2638
TProof.cxx:2639
TProof.cxx:2640
TProof.cxx:2641
TProof.cxx:2642
TProof.cxx:2643
TProof.cxx:2644
TProof.cxx:2645
TProof.cxx:2646
TProof.cxx:2647
TProof.cxx:2648
TProof.cxx:2649
TProof.cxx:2650
TProof.cxx:2651
TProof.cxx:2652
TProof.cxx:2653
TProof.cxx:2654
TProof.cxx:2655
TProof.cxx:2656
TProof.cxx:2657
TProof.cxx:2658
TProof.cxx:2659
TProof.cxx:2660
TProof.cxx:2661
TProof.cxx:2662
TProof.cxx:2663
TProof.cxx:2664
TProof.cxx:2665
TProof.cxx:2666
TProof.cxx:2667
TProof.cxx:2668
TProof.cxx:2669
TProof.cxx:2670
TProof.cxx:2671
TProof.cxx:2672
TProof.cxx:2673
TProof.cxx:2674
TProof.cxx:2675
TProof.cxx:2676
TProof.cxx:2677
TProof.cxx:2678
TProof.cxx:2679
TProof.cxx:2680
TProof.cxx:2681
TProof.cxx:2682
TProof.cxx:2683
TProof.cxx:2684
TProof.cxx:2685
TProof.cxx:2686
TProof.cxx:2687
TProof.cxx:2688
TProof.cxx:2689
TProof.cxx:2690
TProof.cxx:2691
TProof.cxx:2692
TProof.cxx:2693
TProof.cxx:2694
TProof.cxx:2695
TProof.cxx:2696
TProof.cxx:2697
TProof.cxx:2698
TProof.cxx:2699
TProof.cxx:2700
TProof.cxx:2701
TProof.cxx:2702
TProof.cxx:2703
TProof.cxx:2704
TProof.cxx:2705
TProof.cxx:2706
TProof.cxx:2707
TProof.cxx:2708
TProof.cxx:2709
TProof.cxx:2710
TProof.cxx:2711
TProof.cxx:2712
TProof.cxx:2713
TProof.cxx:2714
TProof.cxx:2715
TProof.cxx:2716
TProof.cxx:2717
TProof.cxx:2718
TProof.cxx:2719
TProof.cxx:2720
TProof.cxx:2721
TProof.cxx:2722
TProof.cxx:2723
TProof.cxx:2724
TProof.cxx:2725
TProof.cxx:2726
TProof.cxx:2727
TProof.cxx:2728
TProof.cxx:2729
TProof.cxx:2730
TProof.cxx:2731
TProof.cxx:2732
TProof.cxx:2733
TProof.cxx:2734
TProof.cxx:2735
TProof.cxx:2736
TProof.cxx:2737
TProof.cxx:2738
TProof.cxx:2739
TProof.cxx:2740
TProof.cxx:2741
TProof.cxx:2742
TProof.cxx:2743
TProof.cxx:2744
TProof.cxx:2745
TProof.cxx:2746
TProof.cxx:2747
TProof.cxx:2748
TProof.cxx:2749
TProof.cxx:2750
TProof.cxx:2751
TProof.cxx:2752
TProof.cxx:2753
TProof.cxx:2754
TProof.cxx:2755
TProof.cxx:2756
TProof.cxx:2757
TProof.cxx:2758
TProof.cxx:2759
TProof.cxx:2760
TProof.cxx:2761
TProof.cxx:2762
TProof.cxx:2763
TProof.cxx:2764
TProof.cxx:2765
TProof.cxx:2766
TProof.cxx:2767
TProof.cxx:2768
TProof.cxx:2769
TProof.cxx:2770
TProof.cxx:2771
TProof.cxx:2772
TProof.cxx:2773
TProof.cxx:2774
TProof.cxx:2775
TProof.cxx:2776
TProof.cxx:2777
TProof.cxx:2778
TProof.cxx:2779
TProof.cxx:2780
TProof.cxx:2781
TProof.cxx:2782
TProof.cxx:2783
TProof.cxx:2784
TProof.cxx:2785
TProof.cxx:2786
TProof.cxx:2787
TProof.cxx:2788
TProof.cxx:2789
TProof.cxx:2790
TProof.cxx:2791
TProof.cxx:2792
TProof.cxx:2793
TProof.cxx:2794
TProof.cxx:2795
TProof.cxx:2796
TProof.cxx:2797
TProof.cxx:2798
TProof.cxx:2799
TProof.cxx:2800
TProof.cxx:2801
TProof.cxx:2802
TProof.cxx:2803
TProof.cxx:2804
TProof.cxx:2805
TProof.cxx:2806
TProof.cxx:2807
TProof.cxx:2808
TProof.cxx:2809
TProof.cxx:2810
TProof.cxx:2811
TProof.cxx:2812
TProof.cxx:2813
TProof.cxx:2814
TProof.cxx:2815
TProof.cxx:2816
TProof.cxx:2817
TProof.cxx:2818
TProof.cxx:2819
TProof.cxx:2820
TProof.cxx:2821
TProof.cxx:2822
TProof.cxx:2823
TProof.cxx:2824
TProof.cxx:2825
TProof.cxx:2826
TProof.cxx:2827
TProof.cxx:2828
TProof.cxx:2829
TProof.cxx:2830
TProof.cxx:2831
TProof.cxx:2832
TProof.cxx:2833
TProof.cxx:2834
TProof.cxx:2835
TProof.cxx:2836
TProof.cxx:2837
TProof.cxx:2838
TProof.cxx:2839
TProof.cxx:2840
TProof.cxx:2841
TProof.cxx:2842
TProof.cxx:2843
TProof.cxx:2844
TProof.cxx:2845
TProof.cxx:2846
TProof.cxx:2847
TProof.cxx:2848
TProof.cxx:2849
TProof.cxx:2850
TProof.cxx:2851
TProof.cxx:2852
TProof.cxx:2853
TProof.cxx:2854
TProof.cxx:2855
TProof.cxx:2856
TProof.cxx:2857
TProof.cxx:2858
TProof.cxx:2859
TProof.cxx:2860
TProof.cxx:2861
TProof.cxx:2862
TProof.cxx:2863
TProof.cxx:2864
TProof.cxx:2865
TProof.cxx:2866
TProof.cxx:2867
TProof.cxx:2868
TProof.cxx:2869
TProof.cxx:2870
TProof.cxx:2871
TProof.cxx:2872
TProof.cxx:2873
TProof.cxx:2874
TProof.cxx:2875
TProof.cxx:2876
TProof.cxx:2877
TProof.cxx:2878
TProof.cxx:2879
TProof.cxx:2880
TProof.cxx:2881
TProof.cxx:2882
TProof.cxx:2883
TProof.cxx:2884
TProof.cxx:2885
TProof.cxx:2886
TProof.cxx:2887
TProof.cxx:2888
TProof.cxx:2889
TProof.cxx:2890
TProof.cxx:2891
TProof.cxx:2892
TProof.cxx:2893
TProof.cxx:2894
TProof.cxx:2895
TProof.cxx:2896
TProof.cxx:2897
TProof.cxx:2898
TProof.cxx:2899
TProof.cxx:2900
TProof.cxx:2901
TProof.cxx:2902
TProof.cxx:2903
TProof.cxx:2904
TProof.cxx:2905
TProof.cxx:2906
TProof.cxx:2907
TProof.cxx:2908
TProof.cxx:2909
TProof.cxx:2910
TProof.cxx:2911
TProof.cxx:2912
TProof.cxx:2913
TProof.cxx:2914
TProof.cxx:2915
TProof.cxx:2916
TProof.cxx:2917
TProof.cxx:2918
TProof.cxx:2919
TProof.cxx:2920
TProof.cxx:2921
TProof.cxx:2922
TProof.cxx:2923
TProof.cxx:2924
TProof.cxx:2925
TProof.cxx:2926
TProof.cxx:2927
TProof.cxx:2928
TProof.cxx:2929
TProof.cxx:2930
TProof.cxx:2931
TProof.cxx:2932
TProof.cxx:2933
TProof.cxx:2934
TProof.cxx:2935
TProof.cxx:2936
TProof.cxx:2937
TProof.cxx:2938
TProof.cxx:2939
TProof.cxx:2940
TProof.cxx:2941
TProof.cxx:2942
TProof.cxx:2943
TProof.cxx:2944
TProof.cxx:2945
TProof.cxx:2946
TProof.cxx:2947
TProof.cxx:2948
TProof.cxx:2949
TProof.cxx:2950
TProof.cxx:2951
TProof.cxx:2952
TProof.cxx:2953
TProof.cxx:2954
TProof.cxx:2955
TProof.cxx:2956
TProof.cxx:2957
TProof.cxx:2958
TProof.cxx:2959
TProof.cxx:2960
TProof.cxx:2961
TProof.cxx:2962
TProof.cxx:2963
TProof.cxx:2964
TProof.cxx:2965
TProof.cxx:2966
TProof.cxx:2967
TProof.cxx:2968
TProof.cxx:2969
TProof.cxx:2970
TProof.cxx:2971
TProof.cxx:2972
TProof.cxx:2973
TProof.cxx:2974
TProof.cxx:2975
TProof.cxx:2976
TProof.cxx:2977
TProof.cxx:2978
TProof.cxx:2979
TProof.cxx:2980
TProof.cxx:2981
TProof.cxx:2982
TProof.cxx:2983
TProof.cxx:2984
TProof.cxx:2985
TProof.cxx:2986
TProof.cxx:2987
TProof.cxx:2988
TProof.cxx:2989
TProof.cxx:2990
TProof.cxx:2991
TProof.cxx:2992
TProof.cxx:2993
TProof.cxx:2994
TProof.cxx:2995
TProof.cxx:2996
TProof.cxx:2997
TProof.cxx:2998
TProof.cxx:2999
TProof.cxx:3000
TProof.cxx:3001
TProof.cxx:3002
TProof.cxx:3003
TProof.cxx:3004
TProof.cxx:3005
TProof.cxx:3006
TProof.cxx:3007
TProof.cxx:3008
TProof.cxx:3009
TProof.cxx:3010
TProof.cxx:3011
TProof.cxx:3012
TProof.cxx:3013
TProof.cxx:3014
TProof.cxx:3015
TProof.cxx:3016
TProof.cxx:3017
TProof.cxx:3018
TProof.cxx:3019
TProof.cxx:3020
TProof.cxx:3021
TProof.cxx:3022
TProof.cxx:3023
TProof.cxx:3024
TProof.cxx:3025
TProof.cxx:3026
TProof.cxx:3027
TProof.cxx:3028
TProof.cxx:3029
TProof.cxx:3030
TProof.cxx:3031
TProof.cxx:3032
TProof.cxx:3033
TProof.cxx:3034
TProof.cxx:3035
TProof.cxx:3036
TProof.cxx:3037
TProof.cxx:3038
TProof.cxx:3039
TProof.cxx:3040
TProof.cxx:3041
TProof.cxx:3042
TProof.cxx:3043
TProof.cxx:3044
TProof.cxx:3045
TProof.cxx:3046
TProof.cxx:3047
TProof.cxx:3048
TProof.cxx:3049
TProof.cxx:3050
TProof.cxx:3051
TProof.cxx:3052
TProof.cxx:3053
TProof.cxx:3054
TProof.cxx:3055
TProof.cxx:3056
TProof.cxx:3057
TProof.cxx:3058
TProof.cxx:3059
TProof.cxx:3060
TProof.cxx:3061
TProof.cxx:3062
TProof.cxx:3063
TProof.cxx:3064
TProof.cxx:3065
TProof.cxx:3066
TProof.cxx:3067
TProof.cxx:3068
TProof.cxx:3069
TProof.cxx:3070
TProof.cxx:3071
TProof.cxx:3072
TProof.cxx:3073
TProof.cxx:3074
TProof.cxx:3075
TProof.cxx:3076
TProof.cxx:3077
TProof.cxx:3078
TProof.cxx:3079
TProof.cxx:3080
TProof.cxx:3081
TProof.cxx:3082
TProof.cxx:3083
TProof.cxx:3084
TProof.cxx:3085
TProof.cxx:3086
TProof.cxx:3087
TProof.cxx:3088
TProof.cxx:3089
TProof.cxx:3090
TProof.cxx:3091
TProof.cxx:3092
TProof.cxx:3093
TProof.cxx:3094
TProof.cxx:3095
TProof.cxx:3096
TProof.cxx:3097
TProof.cxx:3098
TProof.cxx:3099
TProof.cxx:3100
TProof.cxx:3101
TProof.cxx:3102
TProof.cxx:3103
TProof.cxx:3104
TProof.cxx:3105
TProof.cxx:3106
TProof.cxx:3107
TProof.cxx:3108
TProof.cxx:3109
TProof.cxx:3110
TProof.cxx:3111
TProof.cxx:3112
TProof.cxx:3113
TProof.cxx:3114
TProof.cxx:3115
TProof.cxx:3116
TProof.cxx:3117
TProof.cxx:3118
TProof.cxx:3119
TProof.cxx:3120
TProof.cxx:3121
TProof.cxx:3122
TProof.cxx:3123
TProof.cxx:3124
TProof.cxx:3125
TProof.cxx:3126
TProof.cxx:3127
TProof.cxx:3128
TProof.cxx:3129
TProof.cxx:3130
TProof.cxx:3131
TProof.cxx:3132
TProof.cxx:3133
TProof.cxx:3134
TProof.cxx:3135
TProof.cxx:3136
TProof.cxx:3137
TProof.cxx:3138
TProof.cxx:3139
TProof.cxx:3140
TProof.cxx:3141
TProof.cxx:3142
TProof.cxx:3143
TProof.cxx:3144
TProof.cxx:3145
TProof.cxx:3146
TProof.cxx:3147
TProof.cxx:3148
TProof.cxx:3149
TProof.cxx:3150
TProof.cxx:3151
TProof.cxx:3152
TProof.cxx:3153
TProof.cxx:3154
TProof.cxx:3155
TProof.cxx:3156
TProof.cxx:3157
TProof.cxx:3158
TProof.cxx:3159
TProof.cxx:3160
TProof.cxx:3161
TProof.cxx:3162
TProof.cxx:3163
TProof.cxx:3164
TProof.cxx:3165
TProof.cxx:3166
TProof.cxx:3167
TProof.cxx:3168
TProof.cxx:3169
TProof.cxx:3170
TProof.cxx:3171
TProof.cxx:3172
TProof.cxx:3173
TProof.cxx:3174
TProof.cxx:3175
TProof.cxx:3176
TProof.cxx:3177
TProof.cxx:3178
TProof.cxx:3179
TProof.cxx:3180
TProof.cxx:3181
TProof.cxx:3182
TProof.cxx:3183
TProof.cxx:3184
TProof.cxx:3185
TProof.cxx:3186
TProof.cxx:3187
TProof.cxx:3188
TProof.cxx:3189
TProof.cxx:3190
TProof.cxx:3191
TProof.cxx:3192
TProof.cxx:3193
TProof.cxx:3194
TProof.cxx:3195
TProof.cxx:3196
TProof.cxx:3197
TProof.cxx:3198
TProof.cxx:3199
TProof.cxx:3200
TProof.cxx:3201
TProof.cxx:3202
TProof.cxx:3203
TProof.cxx:3204
TProof.cxx:3205
TProof.cxx:3206
TProof.cxx:3207
TProof.cxx:3208
TProof.cxx:3209
TProof.cxx:3210
TProof.cxx:3211
TProof.cxx:3212
TProof.cxx:3213
TProof.cxx:3214
TProof.cxx:3215
TProof.cxx:3216
TProof.cxx:3217
TProof.cxx:3218
TProof.cxx:3219
TProof.cxx:3220
TProof.cxx:3221
TProof.cxx:3222
TProof.cxx:3223
TProof.cxx:3224
TProof.cxx:3225
TProof.cxx:3226
TProof.cxx:3227
TProof.cxx:3228
TProof.cxx:3229
TProof.cxx:3230
TProof.cxx:3231
TProof.cxx:3232
TProof.cxx:3233
TProof.cxx:3234
TProof.cxx:3235
TProof.cxx:3236
TProof.cxx:3237
TProof.cxx:3238
TProof.cxx:3239
TProof.cxx:3240
TProof.cxx:3241
TProof.cxx:3242
TProof.cxx:3243
TProof.cxx:3244
TProof.cxx:3245
TProof.cxx:3246
TProof.cxx:3247
TProof.cxx:3248
TProof.cxx:3249
TProof.cxx:3250
TProof.cxx:3251
TProof.cxx:3252
TProof.cxx:3253
TProof.cxx:3254
TProof.cxx:3255
TProof.cxx:3256
TProof.cxx:3257
TProof.cxx:3258
TProof.cxx:3259
TProof.cxx:3260
TProof.cxx:3261
TProof.cxx:3262
TProof.cxx:3263
TProof.cxx:3264
TProof.cxx:3265
TProof.cxx:3266
TProof.cxx:3267
TProof.cxx:3268
TProof.cxx:3269
TProof.cxx:3270
TProof.cxx:3271
TProof.cxx:3272
TProof.cxx:3273
TProof.cxx:3274
TProof.cxx:3275
TProof.cxx:3276
TProof.cxx:3277
TProof.cxx:3278
TProof.cxx:3279
TProof.cxx:3280
TProof.cxx:3281
TProof.cxx:3282
TProof.cxx:3283
TProof.cxx:3284
TProof.cxx:3285
TProof.cxx:3286
TProof.cxx:3287
TProof.cxx:3288
TProof.cxx:3289
TProof.cxx:3290
TProof.cxx:3291
TProof.cxx:3292
TProof.cxx:3293
TProof.cxx:3294
TProof.cxx:3295
TProof.cxx:3296
TProof.cxx:3297
TProof.cxx:3298
TProof.cxx:3299
TProof.cxx:3300
TProof.cxx:3301
TProof.cxx:3302
TProof.cxx:3303
TProof.cxx:3304
TProof.cxx:3305
TProof.cxx:3306
TProof.cxx:3307
TProof.cxx:3308
TProof.cxx:3309
TProof.cxx:3310
TProof.cxx:3311
TProof.cxx:3312
TProof.cxx:3313
TProof.cxx:3314
TProof.cxx:3315
TProof.cxx:3316
TProof.cxx:3317
TProof.cxx:3318
TProof.cxx:3319
TProof.cxx:3320
TProof.cxx:3321
TProof.cxx:3322
TProof.cxx:3323
TProof.cxx:3324
TProof.cxx:3325
TProof.cxx:3326
TProof.cxx:3327
TProof.cxx:3328
TProof.cxx:3329
TProof.cxx:3330
TProof.cxx:3331
TProof.cxx:3332
TProof.cxx:3333
TProof.cxx:3334
TProof.cxx:3335
TProof.cxx:3336
TProof.cxx:3337
TProof.cxx:3338
TProof.cxx:3339
TProof.cxx:3340
TProof.cxx:3341
TProof.cxx:3342
TProof.cxx:3343
TProof.cxx:3344
TProof.cxx:3345
TProof.cxx:3346
TProof.cxx:3347
TProof.cxx:3348
TProof.cxx:3349
TProof.cxx:3350
TProof.cxx:3351
TProof.cxx:3352
TProof.cxx:3353
TProof.cxx:3354
TProof.cxx:3355
TProof.cxx:3356
TProof.cxx:3357
TProof.cxx:3358
TProof.cxx:3359
TProof.cxx:3360
TProof.cxx:3361
TProof.cxx:3362
TProof.cxx:3363
TProof.cxx:3364
TProof.cxx:3365
TProof.cxx:3366
TProof.cxx:3367
TProof.cxx:3368
TProof.cxx:3369
TProof.cxx:3370
TProof.cxx:3371
TProof.cxx:3372
TProof.cxx:3373
TProof.cxx:3374
TProof.cxx:3375
TProof.cxx:3376
TProof.cxx:3377
TProof.cxx:3378
TProof.cxx:3379
TProof.cxx:3380
TProof.cxx:3381
TProof.cxx:3382
TProof.cxx:3383
TProof.cxx:3384
TProof.cxx:3385
TProof.cxx:3386
TProof.cxx:3387
TProof.cxx:3388
TProof.cxx:3389
TProof.cxx:3390
TProof.cxx:3391
TProof.cxx:3392
TProof.cxx:3393
TProof.cxx:3394
TProof.cxx:3395
TProof.cxx:3396
TProof.cxx:3397
TProof.cxx:3398
TProof.cxx:3399
TProof.cxx:3400
TProof.cxx:3401
TProof.cxx:3402
TProof.cxx:3403
TProof.cxx:3404
TProof.cxx:3405
TProof.cxx:3406
TProof.cxx:3407
TProof.cxx:3408
TProof.cxx:3409
TProof.cxx:3410
TProof.cxx:3411
TProof.cxx:3412
TProof.cxx:3413
TProof.cxx:3414
TProof.cxx:3415
TProof.cxx:3416
TProof.cxx:3417
TProof.cxx:3418
TProof.cxx:3419
TProof.cxx:3420
TProof.cxx:3421
TProof.cxx:3422
TProof.cxx:3423
TProof.cxx:3424
TProof.cxx:3425
TProof.cxx:3426
TProof.cxx:3427
TProof.cxx:3428
TProof.cxx:3429
TProof.cxx:3430
TProof.cxx:3431
TProof.cxx:3432
TProof.cxx:3433
TProof.cxx:3434
TProof.cxx:3435
TProof.cxx:3436
TProof.cxx:3437
TProof.cxx:3438
TProof.cxx:3439
TProof.cxx:3440
TProof.cxx:3441
TProof.cxx:3442
TProof.cxx:3443
TProof.cxx:3444
TProof.cxx:3445
TProof.cxx:3446
TProof.cxx:3447
TProof.cxx:3448
TProof.cxx:3449
TProof.cxx:3450
TProof.cxx:3451
TProof.cxx:3452
TProof.cxx:3453
TProof.cxx:3454
TProof.cxx:3455
TProof.cxx:3456
TProof.cxx:3457
TProof.cxx:3458
TProof.cxx:3459
TProof.cxx:3460
TProof.cxx:3461
TProof.cxx:3462
TProof.cxx:3463
TProof.cxx:3464
TProof.cxx:3465
TProof.cxx:3466
TProof.cxx:3467
TProof.cxx:3468
TProof.cxx:3469
TProof.cxx:3470
TProof.cxx:3471
TProof.cxx:3472
TProof.cxx:3473
TProof.cxx:3474
TProof.cxx:3475
TProof.cxx:3476
TProof.cxx:3477
TProof.cxx:3478
TProof.cxx:3479
TProof.cxx:3480
TProof.cxx:3481
TProof.cxx:3482
TProof.cxx:3483
TProof.cxx:3484
TProof.cxx:3485
TProof.cxx:3486
TProof.cxx:3487
TProof.cxx:3488
TProof.cxx:3489
TProof.cxx:3490
TProof.cxx:3491
TProof.cxx:3492
TProof.cxx:3493
TProof.cxx:3494
TProof.cxx:3495
TProof.cxx:3496
TProof.cxx:3497
TProof.cxx:3498
TProof.cxx:3499
TProof.cxx:3500
TProof.cxx:3501
TProof.cxx:3502
TProof.cxx:3503
TProof.cxx:3504
TProof.cxx:3505
TProof.cxx:3506
TProof.cxx:3507
TProof.cxx:3508
TProof.cxx:3509
TProof.cxx:3510
TProof.cxx:3511
TProof.cxx:3512
TProof.cxx:3513
TProof.cxx:3514
TProof.cxx:3515
TProof.cxx:3516
TProof.cxx:3517
TProof.cxx:3518
TProof.cxx:3519
TProof.cxx:3520
TProof.cxx:3521
TProof.cxx:3522
TProof.cxx:3523
TProof.cxx:3524
TProof.cxx:3525
TProof.cxx:3526
TProof.cxx:3527
TProof.cxx:3528
TProof.cxx:3529
TProof.cxx:3530
TProof.cxx:3531
TProof.cxx:3532
TProof.cxx:3533
TProof.cxx:3534
TProof.cxx:3535
TProof.cxx:3536
TProof.cxx:3537
TProof.cxx:3538
TProof.cxx:3539
TProof.cxx:3540
TProof.cxx:3541
TProof.cxx:3542
TProof.cxx:3543
TProof.cxx:3544
TProof.cxx:3545
TProof.cxx:3546
TProof.cxx:3547
TProof.cxx:3548
TProof.cxx:3549
TProof.cxx:3550
TProof.cxx:3551
TProof.cxx:3552
TProof.cxx:3553
TProof.cxx:3554
TProof.cxx:3555
TProof.cxx:3556
TProof.cxx:3557
TProof.cxx:3558
TProof.cxx:3559
TProof.cxx:3560
TProof.cxx:3561
TProof.cxx:3562
TProof.cxx:3563
TProof.cxx:3564
TProof.cxx:3565
TProof.cxx:3566
TProof.cxx:3567
TProof.cxx:3568
TProof.cxx:3569
TProof.cxx:3570
TProof.cxx:3571
TProof.cxx:3572
TProof.cxx:3573
TProof.cxx:3574
TProof.cxx:3575
TProof.cxx:3576
TProof.cxx:3577
TProof.cxx:3578
TProof.cxx:3579
TProof.cxx:3580
TProof.cxx:3581
TProof.cxx:3582
TProof.cxx:3583
TProof.cxx:3584
TProof.cxx:3585
TProof.cxx:3586
TProof.cxx:3587
TProof.cxx:3588
TProof.cxx:3589
TProof.cxx:3590
TProof.cxx:3591
TProof.cxx:3592
TProof.cxx:3593
TProof.cxx:3594
TProof.cxx:3595
TProof.cxx:3596
TProof.cxx:3597
TProof.cxx:3598
TProof.cxx:3599
TProof.cxx:3600
TProof.cxx:3601
TProof.cxx:3602
TProof.cxx:3603
TProof.cxx:3604
TProof.cxx:3605
TProof.cxx:3606
TProof.cxx:3607
TProof.cxx:3608
TProof.cxx:3609
TProof.cxx:3610
TProof.cxx:3611
TProof.cxx:3612
TProof.cxx:3613
TProof.cxx:3614
TProof.cxx:3615
TProof.cxx:3616
TProof.cxx:3617
TProof.cxx:3618
TProof.cxx:3619
TProof.cxx:3620
TProof.cxx:3621
TProof.cxx:3622
TProof.cxx:3623
TProof.cxx:3624
TProof.cxx:3625
TProof.cxx:3626
TProof.cxx:3627
TProof.cxx:3628
TProof.cxx:3629
TProof.cxx:3630
TProof.cxx:3631
TProof.cxx:3632
TProof.cxx:3633
TProof.cxx:3634
TProof.cxx:3635
TProof.cxx:3636
TProof.cxx:3637
TProof.cxx:3638
TProof.cxx:3639
TProof.cxx:3640
TProof.cxx:3641
TProof.cxx:3642
TProof.cxx:3643
TProof.cxx:3644
TProof.cxx:3645
TProof.cxx:3646
TProof.cxx:3647
TProof.cxx:3648
TProof.cxx:3649
TProof.cxx:3650
TProof.cxx:3651
TProof.cxx:3652
TProof.cxx:3653
TProof.cxx:3654
TProof.cxx:3655
TProof.cxx:3656
TProof.cxx:3657
TProof.cxx:3658
TProof.cxx:3659
TProof.cxx:3660
TProof.cxx:3661
TProof.cxx:3662
TProof.cxx:3663
TProof.cxx:3664
TProof.cxx:3665
TProof.cxx:3666
TProof.cxx:3667
TProof.cxx:3668
TProof.cxx:3669
TProof.cxx:3670
TProof.cxx:3671
TProof.cxx:3672
TProof.cxx:3673
TProof.cxx:3674
TProof.cxx:3675
TProof.cxx:3676
TProof.cxx:3677
TProof.cxx:3678
TProof.cxx:3679
TProof.cxx:3680
TProof.cxx:3681
TProof.cxx:3682
TProof.cxx:3683
TProof.cxx:3684
TProof.cxx:3685
TProof.cxx:3686
TProof.cxx:3687
TProof.cxx:3688
TProof.cxx:3689
TProof.cxx:3690
TProof.cxx:3691
TProof.cxx:3692
TProof.cxx:3693
TProof.cxx:3694
TProof.cxx:3695
TProof.cxx:3696
TProof.cxx:3697
TProof.cxx:3698
TProof.cxx:3699
TProof.cxx:3700
TProof.cxx:3701
TProof.cxx:3702
TProof.cxx:3703
TProof.cxx:3704
TProof.cxx:3705
TProof.cxx:3706
TProof.cxx:3707
TProof.cxx:3708
TProof.cxx:3709
TProof.cxx:3710
TProof.cxx:3711
TProof.cxx:3712
TProof.cxx:3713
TProof.cxx:3714
TProof.cxx:3715
TProof.cxx:3716
TProof.cxx:3717
TProof.cxx:3718
TProof.cxx:3719
TProof.cxx:3720
TProof.cxx:3721
TProof.cxx:3722
TProof.cxx:3723
TProof.cxx:3724
TProof.cxx:3725
TProof.cxx:3726
TProof.cxx:3727
TProof.cxx:3728
TProof.cxx:3729
TProof.cxx:3730
TProof.cxx:3731
TProof.cxx:3732
TProof.cxx:3733
TProof.cxx:3734
TProof.cxx:3735
TProof.cxx:3736
TProof.cxx:3737
TProof.cxx:3738
TProof.cxx:3739
TProof.cxx:3740
TProof.cxx:3741
TProof.cxx:3742
TProof.cxx:3743
TProof.cxx:3744
TProof.cxx:3745
TProof.cxx:3746
TProof.cxx:3747
TProof.cxx:3748
TProof.cxx:3749
TProof.cxx:3750
TProof.cxx:3751
TProof.cxx:3752
TProof.cxx:3753
TProof.cxx:3754
TProof.cxx:3755
TProof.cxx:3756
TProof.cxx:3757
TProof.cxx:3758
TProof.cxx:3759
TProof.cxx:3760
TProof.cxx:3761
TProof.cxx:3762
TProof.cxx:3763
TProof.cxx:3764
TProof.cxx:3765
TProof.cxx:3766
TProof.cxx:3767
TProof.cxx:3768
TProof.cxx:3769
TProof.cxx:3770
TProof.cxx:3771
TProof.cxx:3772
TProof.cxx:3773
TProof.cxx:3774
TProof.cxx:3775
TProof.cxx:3776
TProof.cxx:3777
TProof.cxx:3778
TProof.cxx:3779
TProof.cxx:3780
TProof.cxx:3781
TProof.cxx:3782
TProof.cxx:3783
TProof.cxx:3784
TProof.cxx:3785
TProof.cxx:3786
TProof.cxx:3787
TProof.cxx:3788
TProof.cxx:3789
TProof.cxx:3790
TProof.cxx:3791
TProof.cxx:3792
TProof.cxx:3793
TProof.cxx:3794
TProof.cxx:3795
TProof.cxx:3796
TProof.cxx:3797
TProof.cxx:3798
TProof.cxx:3799
TProof.cxx:3800
TProof.cxx:3801
TProof.cxx:3802
TProof.cxx:3803
TProof.cxx:3804
TProof.cxx:3805
TProof.cxx:3806
TProof.cxx:3807
TProof.cxx:3808
TProof.cxx:3809
TProof.cxx:3810
TProof.cxx:3811
TProof.cxx:3812
TProof.cxx:3813
TProof.cxx:3814
TProof.cxx:3815
TProof.cxx:3816
TProof.cxx:3817
TProof.cxx:3818
TProof.cxx:3819
TProof.cxx:3820
TProof.cxx:3821
TProof.cxx:3822
TProof.cxx:3823
TProof.cxx:3824
TProof.cxx:3825
TProof.cxx:3826
TProof.cxx:3827
TProof.cxx:3828
TProof.cxx:3829
TProof.cxx:3830
TProof.cxx:3831
TProof.cxx:3832
TProof.cxx:3833
TProof.cxx:3834
TProof.cxx:3835
TProof.cxx:3836
TProof.cxx:3837
TProof.cxx:3838
TProof.cxx:3839
TProof.cxx:3840
TProof.cxx:3841
TProof.cxx:3842
TProof.cxx:3843
TProof.cxx:3844
TProof.cxx:3845
TProof.cxx:3846
TProof.cxx:3847
TProof.cxx:3848
TProof.cxx:3849
TProof.cxx:3850
TProof.cxx:3851
TProof.cxx:3852
TProof.cxx:3853
TProof.cxx:3854
TProof.cxx:3855
TProof.cxx:3856
TProof.cxx:3857
TProof.cxx:3858
TProof.cxx:3859
TProof.cxx:3860
TProof.cxx:3861
TProof.cxx:3862
TProof.cxx:3863
TProof.cxx:3864
TProof.cxx:3865
TProof.cxx:3866
TProof.cxx:3867
TProof.cxx:3868
TProof.cxx:3869
TProof.cxx:3870
TProof.cxx:3871
TProof.cxx:3872
TProof.cxx:3873
TProof.cxx:3874
TProof.cxx:3875
TProof.cxx:3876
TProof.cxx:3877
TProof.cxx:3878
TProof.cxx:3879
TProof.cxx:3880
TProof.cxx:3881
TProof.cxx:3882
TProof.cxx:3883
TProof.cxx:3884
TProof.cxx:3885
TProof.cxx:3886
TProof.cxx:3887
TProof.cxx:3888
TProof.cxx:3889
TProof.cxx:3890
TProof.cxx:3891
TProof.cxx:3892
TProof.cxx:3893
TProof.cxx:3894
TProof.cxx:3895
TProof.cxx:3896
TProof.cxx:3897
TProof.cxx:3898
TProof.cxx:3899
TProof.cxx:3900
TProof.cxx:3901
TProof.cxx:3902
TProof.cxx:3903
TProof.cxx:3904
TProof.cxx:3905
TProof.cxx:3906
TProof.cxx:3907
TProof.cxx:3908
TProof.cxx:3909
TProof.cxx:3910
TProof.cxx:3911
TProof.cxx:3912
TProof.cxx:3913
TProof.cxx:3914
TProof.cxx:3915
TProof.cxx:3916
TProof.cxx:3917
TProof.cxx:3918
TProof.cxx:3919
TProof.cxx:3920
TProof.cxx:3921
TProof.cxx:3922
TProof.cxx:3923
TProof.cxx:3924
TProof.cxx:3925
TProof.cxx:3926
TProof.cxx:3927
TProof.cxx:3928
TProof.cxx:3929
TProof.cxx:3930
TProof.cxx:3931
TProof.cxx:3932
TProof.cxx:3933
TProof.cxx:3934
TProof.cxx:3935
TProof.cxx:3936
TProof.cxx:3937
TProof.cxx:3938
TProof.cxx:3939
TProof.cxx:3940
TProof.cxx:3941
TProof.cxx:3942
TProof.cxx:3943
TProof.cxx:3944
TProof.cxx:3945
TProof.cxx:3946
TProof.cxx:3947
TProof.cxx:3948
TProof.cxx:3949
TProof.cxx:3950
TProof.cxx:3951
TProof.cxx:3952
TProof.cxx:3953
TProof.cxx:3954
TProof.cxx:3955
TProof.cxx:3956
TProof.cxx:3957
TProof.cxx:3958
TProof.cxx:3959
TProof.cxx:3960
TProof.cxx:3961
TProof.cxx:3962
TProof.cxx:3963
TProof.cxx:3964
TProof.cxx:3965
TProof.cxx:3966
TProof.cxx:3967
TProof.cxx:3968
TProof.cxx:3969
TProof.cxx:3970
TProof.cxx:3971
TProof.cxx:3972
TProof.cxx:3973
TProof.cxx:3974
TProof.cxx:3975
TProof.cxx:3976
TProof.cxx:3977
TProof.cxx:3978
TProof.cxx:3979
TProof.cxx:3980
TProof.cxx:3981
TProof.cxx:3982
TProof.cxx:3983
TProof.cxx:3984
TProof.cxx:3985
TProof.cxx:3986
TProof.cxx:3987
TProof.cxx:3988
TProof.cxx:3989
TProof.cxx:3990
TProof.cxx:3991
TProof.cxx:3992
TProof.cxx:3993
TProof.cxx:3994
TProof.cxx:3995
TProof.cxx:3996
TProof.cxx:3997
TProof.cxx:3998
TProof.cxx:3999
TProof.cxx:4000
TProof.cxx:4001
TProof.cxx:4002
TProof.cxx:4003
TProof.cxx:4004
TProof.cxx:4005
TProof.cxx:4006
TProof.cxx:4007
TProof.cxx:4008
TProof.cxx:4009
TProof.cxx:4010
TProof.cxx:4011
TProof.cxx:4012
TProof.cxx:4013
TProof.cxx:4014
TProof.cxx:4015
TProof.cxx:4016
TProof.cxx:4017
TProof.cxx:4018
TProof.cxx:4019
TProof.cxx:4020
TProof.cxx:4021
TProof.cxx:4022
TProof.cxx:4023
TProof.cxx:4024
TProof.cxx:4025
TProof.cxx:4026
TProof.cxx:4027
TProof.cxx:4028
TProof.cxx:4029
TProof.cxx:4030
TProof.cxx:4031
TProof.cxx:4032
TProof.cxx:4033
TProof.cxx:4034
TProof.cxx:4035
TProof.cxx:4036
TProof.cxx:4037
TProof.cxx:4038
TProof.cxx:4039
TProof.cxx:4040
TProof.cxx:4041
TProof.cxx:4042
TProof.cxx:4043
TProof.cxx:4044
TProof.cxx:4045
TProof.cxx:4046
TProof.cxx:4047
TProof.cxx:4048
TProof.cxx:4049
TProof.cxx:4050
TProof.cxx:4051
TProof.cxx:4052
TProof.cxx:4053
TProof.cxx:4054
TProof.cxx:4055
TProof.cxx:4056
TProof.cxx:4057
TProof.cxx:4058
TProof.cxx:4059
TProof.cxx:4060
TProof.cxx:4061
TProof.cxx:4062
TProof.cxx:4063
TProof.cxx:4064
TProof.cxx:4065
TProof.cxx:4066
TProof.cxx:4067
TProof.cxx:4068
TProof.cxx:4069
TProof.cxx:4070
TProof.cxx:4071
TProof.cxx:4072
TProof.cxx:4073
TProof.cxx:4074
TProof.cxx:4075
TProof.cxx:4076
TProof.cxx:4077
TProof.cxx:4078
TProof.cxx:4079
TProof.cxx:4080
TProof.cxx:4081
TProof.cxx:4082
TProof.cxx:4083
TProof.cxx:4084
TProof.cxx:4085
TProof.cxx:4086
TProof.cxx:4087
TProof.cxx:4088
TProof.cxx:4089
TProof.cxx:4090
TProof.cxx:4091
TProof.cxx:4092
TProof.cxx:4093
TProof.cxx:4094
TProof.cxx:4095
TProof.cxx:4096
TProof.cxx:4097
TProof.cxx:4098
TProof.cxx:4099
TProof.cxx:4100
TProof.cxx:4101
TProof.cxx:4102
TProof.cxx:4103
TProof.cxx:4104
TProof.cxx:4105
TProof.cxx:4106
TProof.cxx:4107
TProof.cxx:4108
TProof.cxx:4109
TProof.cxx:4110
TProof.cxx:4111
TProof.cxx:4112
TProof.cxx:4113
TProof.cxx:4114
TProof.cxx:4115
TProof.cxx:4116
TProof.cxx:4117
TProof.cxx:4118
TProof.cxx:4119
TProof.cxx:4120
TProof.cxx:4121
TProof.cxx:4122
TProof.cxx:4123
TProof.cxx:4124
TProof.cxx:4125
TProof.cxx:4126
TProof.cxx:4127
TProof.cxx:4128
TProof.cxx:4129
TProof.cxx:4130
TProof.cxx:4131
TProof.cxx:4132
TProof.cxx:4133
TProof.cxx:4134
TProof.cxx:4135
TProof.cxx:4136
TProof.cxx:4137
TProof.cxx:4138
TProof.cxx:4139
TProof.cxx:4140
TProof.cxx:4141
TProof.cxx:4142
TProof.cxx:4143
TProof.cxx:4144
TProof.cxx:4145
TProof.cxx:4146
TProof.cxx:4147
TProof.cxx:4148
TProof.cxx:4149
TProof.cxx:4150
TProof.cxx:4151
TProof.cxx:4152
TProof.cxx:4153
TProof.cxx:4154
TProof.cxx:4155
TProof.cxx:4156
TProof.cxx:4157
TProof.cxx:4158
TProof.cxx:4159
TProof.cxx:4160
TProof.cxx:4161
TProof.cxx:4162
TProof.cxx:4163
TProof.cxx:4164
TProof.cxx:4165
TProof.cxx:4166
TProof.cxx:4167
TProof.cxx:4168
TProof.cxx:4169
TProof.cxx:4170
TProof.cxx:4171
TProof.cxx:4172
TProof.cxx:4173
TProof.cxx:4174
TProof.cxx:4175
TProof.cxx:4176
TProof.cxx:4177
TProof.cxx:4178
TProof.cxx:4179
TProof.cxx:4180
TProof.cxx:4181
TProof.cxx:4182
TProof.cxx:4183
TProof.cxx:4184
TProof.cxx:4185
TProof.cxx:4186
TProof.cxx:4187
TProof.cxx:4188
TProof.cxx:4189
TProof.cxx:4190
TProof.cxx:4191
TProof.cxx:4192
TProof.cxx:4193
TProof.cxx:4194
TProof.cxx:4195
TProof.cxx:4196
TProof.cxx:4197
TProof.cxx:4198
TProof.cxx:4199
TProof.cxx:4200
TProof.cxx:4201
TProof.cxx:4202
TProof.cxx:4203
TProof.cxx:4204
TProof.cxx:4205
TProof.cxx:4206
TProof.cxx:4207
TProof.cxx:4208
TProof.cxx:4209
TProof.cxx:4210
TProof.cxx:4211
TProof.cxx:4212
TProof.cxx:4213
TProof.cxx:4214
TProof.cxx:4215
TProof.cxx:4216
TProof.cxx:4217
TProof.cxx:4218
TProof.cxx:4219
TProof.cxx:4220
TProof.cxx:4221
TProof.cxx:4222
TProof.cxx:4223
TProof.cxx:4224
TProof.cxx:4225
TProof.cxx:4226
TProof.cxx:4227
TProof.cxx:4228
TProof.cxx:4229
TProof.cxx:4230
TProof.cxx:4231
TProof.cxx:4232
TProof.cxx:4233
TProof.cxx:4234
TProof.cxx:4235
TProof.cxx:4236
TProof.cxx:4237
TProof.cxx:4238
TProof.cxx:4239
TProof.cxx:4240
TProof.cxx:4241
TProof.cxx:4242
TProof.cxx:4243
TProof.cxx:4244
TProof.cxx:4245
TProof.cxx:4246
TProof.cxx:4247
TProof.cxx:4248
TProof.cxx:4249
TProof.cxx:4250
TProof.cxx:4251
TProof.cxx:4252
TProof.cxx:4253
TProof.cxx:4254
TProof.cxx:4255
TProof.cxx:4256
TProof.cxx:4257
TProof.cxx:4258
TProof.cxx:4259
TProof.cxx:4260
TProof.cxx:4261
TProof.cxx:4262
TProof.cxx:4263
TProof.cxx:4264
TProof.cxx:4265
TProof.cxx:4266
TProof.cxx:4267
TProof.cxx:4268
TProof.cxx:4269
TProof.cxx:4270
TProof.cxx:4271
TProof.cxx:4272
TProof.cxx:4273
TProof.cxx:4274
TProof.cxx:4275
TProof.cxx:4276
TProof.cxx:4277
TProof.cxx:4278
TProof.cxx:4279
TProof.cxx:4280
TProof.cxx:4281
TProof.cxx:4282
TProof.cxx:4283
TProof.cxx:4284
TProof.cxx:4285
TProof.cxx:4286
TProof.cxx:4287
TProof.cxx:4288
TProof.cxx:4289
TProof.cxx:4290
TProof.cxx:4291
TProof.cxx:4292
TProof.cxx:4293
TProof.cxx:4294
TProof.cxx:4295
TProof.cxx:4296
TProof.cxx:4297
TProof.cxx:4298
TProof.cxx:4299
TProof.cxx:4300
TProof.cxx:4301
TProof.cxx:4302
TProof.cxx:4303
TProof.cxx:4304
TProof.cxx:4305
TProof.cxx:4306
TProof.cxx:4307
TProof.cxx:4308
TProof.cxx:4309
TProof.cxx:4310
TProof.cxx:4311
TProof.cxx:4312
TProof.cxx:4313
TProof.cxx:4314
TProof.cxx:4315
TProof.cxx:4316
TProof.cxx:4317
TProof.cxx:4318
TProof.cxx:4319
TProof.cxx:4320
TProof.cxx:4321
TProof.cxx:4322
TProof.cxx:4323
TProof.cxx:4324
TProof.cxx:4325
TProof.cxx:4326
TProof.cxx:4327
TProof.cxx:4328
TProof.cxx:4329
TProof.cxx:4330
TProof.cxx:4331
TProof.cxx:4332
TProof.cxx:4333
TProof.cxx:4334
TProof.cxx:4335
TProof.cxx:4336
TProof.cxx:4337
TProof.cxx:4338
TProof.cxx:4339
TProof.cxx:4340
TProof.cxx:4341
TProof.cxx:4342
TProof.cxx:4343
TProof.cxx:4344
TProof.cxx:4345
TProof.cxx:4346
TProof.cxx:4347
TProof.cxx:4348
TProof.cxx:4349
TProof.cxx:4350
TProof.cxx:4351
TProof.cxx:4352
TProof.cxx:4353
TProof.cxx:4354
TProof.cxx:4355
TProof.cxx:4356
TProof.cxx:4357
TProof.cxx:4358
TProof.cxx:4359
TProof.cxx:4360
TProof.cxx:4361
TProof.cxx:4362
TProof.cxx:4363
TProof.cxx:4364
TProof.cxx:4365
TProof.cxx:4366
TProof.cxx:4367
TProof.cxx:4368
TProof.cxx:4369
TProof.cxx:4370
TProof.cxx:4371
TProof.cxx:4372
TProof.cxx:4373
TProof.cxx:4374
TProof.cxx:4375
TProof.cxx:4376
TProof.cxx:4377
TProof.cxx:4378
TProof.cxx:4379
TProof.cxx:4380
TProof.cxx:4381
TProof.cxx:4382
TProof.cxx:4383
TProof.cxx:4384
TProof.cxx:4385
TProof.cxx:4386
TProof.cxx:4387
TProof.cxx:4388
TProof.cxx:4389
TProof.cxx:4390
TProof.cxx:4391
TProof.cxx:4392
TProof.cxx:4393
TProof.cxx:4394
TProof.cxx:4395
TProof.cxx:4396
TProof.cxx:4397
TProof.cxx:4398
TProof.cxx:4399
TProof.cxx:4400
TProof.cxx:4401
TProof.cxx:4402
TProof.cxx:4403
TProof.cxx:4404
TProof.cxx:4405
TProof.cxx:4406
TProof.cxx:4407
TProof.cxx:4408
TProof.cxx:4409
TProof.cxx:4410
TProof.cxx:4411
TProof.cxx:4412
TProof.cxx:4413
TProof.cxx:4414
TProof.cxx:4415
TProof.cxx:4416
TProof.cxx:4417
TProof.cxx:4418
TProof.cxx:4419
TProof.cxx:4420
TProof.cxx:4421
TProof.cxx:4422
TProof.cxx:4423
TProof.cxx:4424
TProof.cxx:4425
TProof.cxx:4426
TProof.cxx:4427
TProof.cxx:4428
TProof.cxx:4429
TProof.cxx:4430
TProof.cxx:4431
TProof.cxx:4432
TProof.cxx:4433
TProof.cxx:4434
TProof.cxx:4435
TProof.cxx:4436
TProof.cxx:4437
TProof.cxx:4438
TProof.cxx:4439
TProof.cxx:4440
TProof.cxx:4441
TProof.cxx:4442
TProof.cxx:4443
TProof.cxx:4444
TProof.cxx:4445
TProof.cxx:4446
TProof.cxx:4447
TProof.cxx:4448
TProof.cxx:4449
TProof.cxx:4450
TProof.cxx:4451
TProof.cxx:4452
TProof.cxx:4453
TProof.cxx:4454
TProof.cxx:4455
TProof.cxx:4456
TProof.cxx:4457
TProof.cxx:4458
TProof.cxx:4459
TProof.cxx:4460
TProof.cxx:4461
TProof.cxx:4462
TProof.cxx:4463
TProof.cxx:4464
TProof.cxx:4465
TProof.cxx:4466
TProof.cxx:4467
TProof.cxx:4468
TProof.cxx:4469
TProof.cxx:4470
TProof.cxx:4471
TProof.cxx:4472
TProof.cxx:4473
TProof.cxx:4474
TProof.cxx:4475
TProof.cxx:4476
TProof.cxx:4477
TProof.cxx:4478
TProof.cxx:4479
TProof.cxx:4480
TProof.cxx:4481
TProof.cxx:4482
TProof.cxx:4483
TProof.cxx:4484
TProof.cxx:4485
TProof.cxx:4486
TProof.cxx:4487
TProof.cxx:4488
TProof.cxx:4489
TProof.cxx:4490
TProof.cxx:4491
TProof.cxx:4492
TProof.cxx:4493
TProof.cxx:4494
TProof.cxx:4495
TProof.cxx:4496
TProof.cxx:4497
TProof.cxx:4498
TProof.cxx:4499
TProof.cxx:4500
TProof.cxx:4501
TProof.cxx:4502
TProof.cxx:4503
TProof.cxx:4504
TProof.cxx:4505
TProof.cxx:4506
TProof.cxx:4507
TProof.cxx:4508
TProof.cxx:4509
TProof.cxx:4510
TProof.cxx:4511
TProof.cxx:4512
TProof.cxx:4513
TProof.cxx:4514
TProof.cxx:4515
TProof.cxx:4516
TProof.cxx:4517
TProof.cxx:4518
TProof.cxx:4519
TProof.cxx:4520
TProof.cxx:4521
TProof.cxx:4522
TProof.cxx:4523
TProof.cxx:4524
TProof.cxx:4525
TProof.cxx:4526
TProof.cxx:4527
TProof.cxx:4528
TProof.cxx:4529
TProof.cxx:4530
TProof.cxx:4531
TProof.cxx:4532
TProof.cxx:4533
TProof.cxx:4534
TProof.cxx:4535
TProof.cxx:4536
TProof.cxx:4537
TProof.cxx:4538
TProof.cxx:4539
TProof.cxx:4540
TProof.cxx:4541
TProof.cxx:4542
TProof.cxx:4543
TProof.cxx:4544
TProof.cxx:4545
TProof.cxx:4546
TProof.cxx:4547
TProof.cxx:4548
TProof.cxx:4549
TProof.cxx:4550
TProof.cxx:4551
TProof.cxx:4552
TProof.cxx:4553
TProof.cxx:4554
TProof.cxx:4555
TProof.cxx:4556
TProof.cxx:4557
TProof.cxx:4558
TProof.cxx:4559
TProof.cxx:4560
TProof.cxx:4561
TProof.cxx:4562
TProof.cxx:4563
TProof.cxx:4564
TProof.cxx:4565
TProof.cxx:4566
TProof.cxx:4567
TProof.cxx:4568
TProof.cxx:4569
TProof.cxx:4570
TProof.cxx:4571
TProof.cxx:4572
TProof.cxx:4573
TProof.cxx:4574
TProof.cxx:4575
TProof.cxx:4576
TProof.cxx:4577
TProof.cxx:4578
TProof.cxx:4579
TProof.cxx:4580
TProof.cxx:4581
TProof.cxx:4582
TProof.cxx:4583
TProof.cxx:4584
TProof.cxx:4585
TProof.cxx:4586
TProof.cxx:4587
TProof.cxx:4588
TProof.cxx:4589
TProof.cxx:4590
TProof.cxx:4591
TProof.cxx:4592
TProof.cxx:4593
TProof.cxx:4594
TProof.cxx:4595
TProof.cxx:4596
TProof.cxx:4597
TProof.cxx:4598
TProof.cxx:4599
TProof.cxx:4600
TProof.cxx:4601
TProof.cxx:4602
TProof.cxx:4603
TProof.cxx:4604
TProof.cxx:4605
TProof.cxx:4606
TProof.cxx:4607
TProof.cxx:4608
TProof.cxx:4609
TProof.cxx:4610
TProof.cxx:4611
TProof.cxx:4612
TProof.cxx:4613
TProof.cxx:4614
TProof.cxx:4615
TProof.cxx:4616
TProof.cxx:4617
TProof.cxx:4618
TProof.cxx:4619
TProof.cxx:4620
TProof.cxx:4621
TProof.cxx:4622
TProof.cxx:4623
TProof.cxx:4624
TProof.cxx:4625
TProof.cxx:4626
TProof.cxx:4627
TProof.cxx:4628
TProof.cxx:4629
TProof.cxx:4630
TProof.cxx:4631
TProof.cxx:4632
TProof.cxx:4633
TProof.cxx:4634
TProof.cxx:4635
TProof.cxx:4636
TProof.cxx:4637
TProof.cxx:4638
TProof.cxx:4639
TProof.cxx:4640
TProof.cxx:4641
TProof.cxx:4642
TProof.cxx:4643
TProof.cxx:4644
TProof.cxx:4645
TProof.cxx:4646
TProof.cxx:4647
TProof.cxx:4648
TProof.cxx:4649
TProof.cxx:4650
TProof.cxx:4651
TProof.cxx:4652
TProof.cxx:4653
TProof.cxx:4654
TProof.cxx:4655
TProof.cxx:4656
TProof.cxx:4657
TProof.cxx:4658
TProof.cxx:4659
TProof.cxx:4660
TProof.cxx:4661
TProof.cxx:4662
TProof.cxx:4663
TProof.cxx:4664
TProof.cxx:4665
TProof.cxx:4666
TProof.cxx:4667
TProof.cxx:4668
TProof.cxx:4669
TProof.cxx:4670
TProof.cxx:4671
TProof.cxx:4672
TProof.cxx:4673
TProof.cxx:4674
TProof.cxx:4675
TProof.cxx:4676
TProof.cxx:4677
TProof.cxx:4678
TProof.cxx:4679
TProof.cxx:4680
TProof.cxx:4681
TProof.cxx:4682
TProof.cxx:4683
TProof.cxx:4684
TProof.cxx:4685
TProof.cxx:4686
TProof.cxx:4687
TProof.cxx:4688
TProof.cxx:4689
TProof.cxx:4690
TProof.cxx:4691
TProof.cxx:4692
TProof.cxx:4693
TProof.cxx:4694
TProof.cxx:4695
TProof.cxx:4696
TProof.cxx:4697
TProof.cxx:4698
TProof.cxx:4699
TProof.cxx:4700
TProof.cxx:4701
TProof.cxx:4702
TProof.cxx:4703
TProof.cxx:4704
TProof.cxx:4705
TProof.cxx:4706
TProof.cxx:4707
TProof.cxx:4708
TProof.cxx:4709
TProof.cxx:4710
TProof.cxx:4711
TProof.cxx:4712
TProof.cxx:4713
TProof.cxx:4714
TProof.cxx:4715
TProof.cxx:4716
TProof.cxx:4717
TProof.cxx:4718
TProof.cxx:4719
TProof.cxx:4720
TProof.cxx:4721
TProof.cxx:4722
TProof.cxx:4723
TProof.cxx:4724
TProof.cxx:4725
TProof.cxx:4726
TProof.cxx:4727
TProof.cxx:4728
TProof.cxx:4729
TProof.cxx:4730
TProof.cxx:4731
TProof.cxx:4732
TProof.cxx:4733
TProof.cxx:4734
TProof.cxx:4735
TProof.cxx:4736
TProof.cxx:4737
TProof.cxx:4738
TProof.cxx:4739
TProof.cxx:4740
TProof.cxx:4741
TProof.cxx:4742
TProof.cxx:4743
TProof.cxx:4744
TProof.cxx:4745
TProof.cxx:4746
TProof.cxx:4747
TProof.cxx:4748
TProof.cxx:4749
TProof.cxx:4750
TProof.cxx:4751
TProof.cxx:4752
TProof.cxx:4753
TProof.cxx:4754
TProof.cxx:4755
TProof.cxx:4756
TProof.cxx:4757
TProof.cxx:4758
TProof.cxx:4759
TProof.cxx:4760
TProof.cxx:4761
TProof.cxx:4762
TProof.cxx:4763
TProof.cxx:4764
TProof.cxx:4765
TProof.cxx:4766
TProof.cxx:4767
TProof.cxx:4768
TProof.cxx:4769
TProof.cxx:4770
TProof.cxx:4771
TProof.cxx:4772
TProof.cxx:4773
TProof.cxx:4774
TProof.cxx:4775
TProof.cxx:4776
TProof.cxx:4777
TProof.cxx:4778
TProof.cxx:4779
TProof.cxx:4780
TProof.cxx:4781
TProof.cxx:4782
TProof.cxx:4783
TProof.cxx:4784
TProof.cxx:4785
TProof.cxx:4786
TProof.cxx:4787
TProof.cxx:4788
TProof.cxx:4789
TProof.cxx:4790
TProof.cxx:4791
TProof.cxx:4792
TProof.cxx:4793
TProof.cxx:4794
TProof.cxx:4795
TProof.cxx:4796
TProof.cxx:4797
TProof.cxx:4798
TProof.cxx:4799
TProof.cxx:4800
TProof.cxx:4801
TProof.cxx:4802
TProof.cxx:4803
TProof.cxx:4804
TProof.cxx:4805
TProof.cxx:4806
TProof.cxx:4807
TProof.cxx:4808
TProof.cxx:4809
TProof.cxx:4810
TProof.cxx:4811
TProof.cxx:4812
TProof.cxx:4813
TProof.cxx:4814
TProof.cxx:4815
TProof.cxx:4816
TProof.cxx:4817
TProof.cxx:4818
TProof.cxx:4819
TProof.cxx:4820
TProof.cxx:4821
TProof.cxx:4822
TProof.cxx:4823
TProof.cxx:4824
TProof.cxx:4825
TProof.cxx:4826
TProof.cxx:4827
TProof.cxx:4828
TProof.cxx:4829
TProof.cxx:4830
TProof.cxx:4831
TProof.cxx:4832
TProof.cxx:4833
TProof.cxx:4834
TProof.cxx:4835
TProof.cxx:4836
TProof.cxx:4837
TProof.cxx:4838
TProof.cxx:4839
TProof.cxx:4840
TProof.cxx:4841
TProof.cxx:4842
TProof.cxx:4843
TProof.cxx:4844
TProof.cxx:4845
TProof.cxx:4846
TProof.cxx:4847
TProof.cxx:4848
TProof.cxx:4849
TProof.cxx:4850
TProof.cxx:4851
TProof.cxx:4852
TProof.cxx:4853
TProof.cxx:4854
TProof.cxx:4855
TProof.cxx:4856
TProof.cxx:4857
TProof.cxx:4858
TProof.cxx:4859
TProof.cxx:4860
TProof.cxx:4861
TProof.cxx:4862
TProof.cxx:4863
TProof.cxx:4864
TProof.cxx:4865
TProof.cxx:4866
TProof.cxx:4867
TProof.cxx:4868
TProof.cxx:4869
TProof.cxx:4870
TProof.cxx:4871
TProof.cxx:4872
TProof.cxx:4873
TProof.cxx:4874
TProof.cxx:4875
TProof.cxx:4876
TProof.cxx:4877
TProof.cxx:4878
TProof.cxx:4879
TProof.cxx:4880
TProof.cxx:4881
TProof.cxx:4882
TProof.cxx:4883
TProof.cxx:4884
TProof.cxx:4885
TProof.cxx:4886
TProof.cxx:4887
TProof.cxx:4888
TProof.cxx:4889
TProof.cxx:4890
TProof.cxx:4891
TProof.cxx:4892
TProof.cxx:4893
TProof.cxx:4894
TProof.cxx:4895
TProof.cxx:4896
TProof.cxx:4897
TProof.cxx:4898
TProof.cxx:4899
TProof.cxx:4900
TProof.cxx:4901
TProof.cxx:4902
TProof.cxx:4903
TProof.cxx:4904
TProof.cxx:4905
TProof.cxx:4906
TProof.cxx:4907
TProof.cxx:4908
TProof.cxx:4909
TProof.cxx:4910
TProof.cxx:4911
TProof.cxx:4912
TProof.cxx:4913
TProof.cxx:4914
TProof.cxx:4915
TProof.cxx:4916
TProof.cxx:4917
TProof.cxx:4918
TProof.cxx:4919
TProof.cxx:4920
TProof.cxx:4921
TProof.cxx:4922
TProof.cxx:4923
TProof.cxx:4924
TProof.cxx:4925
TProof.cxx:4926
TProof.cxx:4927
TProof.cxx:4928
TProof.cxx:4929
TProof.cxx:4930
TProof.cxx:4931
TProof.cxx:4932
TProof.cxx:4933
TProof.cxx:4934
TProof.cxx:4935
TProof.cxx:4936
TProof.cxx:4937
TProof.cxx:4938
TProof.cxx:4939
TProof.cxx:4940
TProof.cxx:4941
TProof.cxx:4942
TProof.cxx:4943
TProof.cxx:4944
TProof.cxx:4945
TProof.cxx:4946
TProof.cxx:4947
TProof.cxx:4948
TProof.cxx:4949
TProof.cxx:4950
TProof.cxx:4951
TProof.cxx:4952
TProof.cxx:4953
TProof.cxx:4954
TProof.cxx:4955
TProof.cxx:4956
TProof.cxx:4957
TProof.cxx:4958
TProof.cxx:4959
TProof.cxx:4960
TProof.cxx:4961
TProof.cxx:4962
TProof.cxx:4963
TProof.cxx:4964
TProof.cxx:4965
TProof.cxx:4966
TProof.cxx:4967
TProof.cxx:4968
TProof.cxx:4969
TProof.cxx:4970
TProof.cxx:4971
TProof.cxx:4972
TProof.cxx:4973
TProof.cxx:4974
TProof.cxx:4975
TProof.cxx:4976
TProof.cxx:4977
TProof.cxx:4978
TProof.cxx:4979
TProof.cxx:4980
TProof.cxx:4981
TProof.cxx:4982
TProof.cxx:4983
TProof.cxx:4984
TProof.cxx:4985
TProof.cxx:4986
TProof.cxx:4987
TProof.cxx:4988
TProof.cxx:4989
TProof.cxx:4990
TProof.cxx:4991
TProof.cxx:4992
TProof.cxx:4993
TProof.cxx:4994
TProof.cxx:4995
TProof.cxx:4996
TProof.cxx:4997
TProof.cxx:4998
TProof.cxx:4999
TProof.cxx:5000
TProof.cxx:5001
TProof.cxx:5002
TProof.cxx:5003
TProof.cxx:5004
TProof.cxx:5005
TProof.cxx:5006
TProof.cxx:5007
TProof.cxx:5008
TProof.cxx:5009
TProof.cxx:5010
TProof.cxx:5011
TProof.cxx:5012
TProof.cxx:5013
TProof.cxx:5014
TProof.cxx:5015
TProof.cxx:5016
TProof.cxx:5017
TProof.cxx:5018
TProof.cxx:5019
TProof.cxx:5020
TProof.cxx:5021
TProof.cxx:5022
TProof.cxx:5023
TProof.cxx:5024
TProof.cxx:5025
TProof.cxx:5026
TProof.cxx:5027
TProof.cxx:5028
TProof.cxx:5029
TProof.cxx:5030
TProof.cxx:5031
TProof.cxx:5032
TProof.cxx:5033
TProof.cxx:5034
TProof.cxx:5035
TProof.cxx:5036
TProof.cxx:5037
TProof.cxx:5038
TProof.cxx:5039
TProof.cxx:5040
TProof.cxx:5041
TProof.cxx:5042
TProof.cxx:5043
TProof.cxx:5044
TProof.cxx:5045
TProof.cxx:5046
TProof.cxx:5047
TProof.cxx:5048
TProof.cxx:5049
TProof.cxx:5050
TProof.cxx:5051
TProof.cxx:5052
TProof.cxx:5053
TProof.cxx:5054
TProof.cxx:5055
TProof.cxx:5056
TProof.cxx:5057
TProof.cxx:5058
TProof.cxx:5059
TProof.cxx:5060
TProof.cxx:5061
TProof.cxx:5062
TProof.cxx:5063
TProof.cxx:5064
TProof.cxx:5065
TProof.cxx:5066
TProof.cxx:5067
TProof.cxx:5068
TProof.cxx:5069
TProof.cxx:5070
TProof.cxx:5071
TProof.cxx:5072
TProof.cxx:5073
TProof.cxx:5074
TProof.cxx:5075
TProof.cxx:5076
TProof.cxx:5077
TProof.cxx:5078
TProof.cxx:5079
TProof.cxx:5080
TProof.cxx:5081
TProof.cxx:5082
TProof.cxx:5083
TProof.cxx:5084
TProof.cxx:5085
TProof.cxx:5086
TProof.cxx:5087
TProof.cxx:5088
TProof.cxx:5089
TProof.cxx:5090
TProof.cxx:5091
TProof.cxx:5092
TProof.cxx:5093
TProof.cxx:5094
TProof.cxx:5095
TProof.cxx:5096
TProof.cxx:5097
TProof.cxx:5098
TProof.cxx:5099
TProof.cxx:5100
TProof.cxx:5101
TProof.cxx:5102
TProof.cxx:5103
TProof.cxx:5104
TProof.cxx:5105
TProof.cxx:5106
TProof.cxx:5107
TProof.cxx:5108
TProof.cxx:5109
TProof.cxx:5110
TProof.cxx:5111
TProof.cxx:5112
TProof.cxx:5113
TProof.cxx:5114
TProof.cxx:5115
TProof.cxx:5116
TProof.cxx:5117
TProof.cxx:5118
TProof.cxx:5119
TProof.cxx:5120
TProof.cxx:5121
TProof.cxx:5122
TProof.cxx:5123
TProof.cxx:5124
TProof.cxx:5125
TProof.cxx:5126
TProof.cxx:5127
TProof.cxx:5128
TProof.cxx:5129
TProof.cxx:5130
TProof.cxx:5131
TProof.cxx:5132
TProof.cxx:5133
TProof.cxx:5134
TProof.cxx:5135
TProof.cxx:5136
TProof.cxx:5137
TProof.cxx:5138
TProof.cxx:5139
TProof.cxx:5140
TProof.cxx:5141
TProof.cxx:5142
TProof.cxx:5143
TProof.cxx:5144
TProof.cxx:5145
TProof.cxx:5146
TProof.cxx:5147
TProof.cxx:5148
TProof.cxx:5149
TProof.cxx:5150
TProof.cxx:5151
TProof.cxx:5152
TProof.cxx:5153
TProof.cxx:5154
TProof.cxx:5155
TProof.cxx:5156
TProof.cxx:5157
TProof.cxx:5158
TProof.cxx:5159
TProof.cxx:5160
TProof.cxx:5161
TProof.cxx:5162
TProof.cxx:5163
TProof.cxx:5164
TProof.cxx:5165
TProof.cxx:5166
TProof.cxx:5167
TProof.cxx:5168
TProof.cxx:5169
TProof.cxx:5170
TProof.cxx:5171
TProof.cxx:5172
TProof.cxx:5173
TProof.cxx:5174
TProof.cxx:5175
TProof.cxx:5176
TProof.cxx:5177
TProof.cxx:5178
TProof.cxx:5179
TProof.cxx:5180
TProof.cxx:5181
TProof.cxx:5182
TProof.cxx:5183
TProof.cxx:5184
TProof.cxx:5185
TProof.cxx:5186
TProof.cxx:5187
TProof.cxx:5188
TProof.cxx:5189
TProof.cxx:5190
TProof.cxx:5191
TProof.cxx:5192
TProof.cxx:5193
TProof.cxx:5194
TProof.cxx:5195
TProof.cxx:5196
TProof.cxx:5197
TProof.cxx:5198
TProof.cxx:5199
TProof.cxx:5200
TProof.cxx:5201
TProof.cxx:5202
TProof.cxx:5203
TProof.cxx:5204
TProof.cxx:5205
TProof.cxx:5206
TProof.cxx:5207
TProof.cxx:5208
TProof.cxx:5209
TProof.cxx:5210
TProof.cxx:5211
TProof.cxx:5212
TProof.cxx:5213
TProof.cxx:5214
TProof.cxx:5215
TProof.cxx:5216
TProof.cxx:5217
TProof.cxx:5218
TProof.cxx:5219
TProof.cxx:5220
TProof.cxx:5221
TProof.cxx:5222
TProof.cxx:5223
TProof.cxx:5224
TProof.cxx:5225
TProof.cxx:5226
TProof.cxx:5227
TProof.cxx:5228
TProof.cxx:5229
TProof.cxx:5230
TProof.cxx:5231
TProof.cxx:5232
TProof.cxx:5233
TProof.cxx:5234
TProof.cxx:5235
TProof.cxx:5236
TProof.cxx:5237
TProof.cxx:5238
TProof.cxx:5239
TProof.cxx:5240
TProof.cxx:5241
TProof.cxx:5242
TProof.cxx:5243
TProof.cxx:5244
TProof.cxx:5245
TProof.cxx:5246
TProof.cxx:5247
TProof.cxx:5248
TProof.cxx:5249
TProof.cxx:5250
TProof.cxx:5251
TProof.cxx:5252
TProof.cxx:5253
TProof.cxx:5254
TProof.cxx:5255
TProof.cxx:5256
TProof.cxx:5257
TProof.cxx:5258
TProof.cxx:5259
TProof.cxx:5260
TProof.cxx:5261
TProof.cxx:5262
TProof.cxx:5263
TProof.cxx:5264
TProof.cxx:5265
TProof.cxx:5266
TProof.cxx:5267
TProof.cxx:5268
TProof.cxx:5269
TProof.cxx:5270
TProof.cxx:5271
TProof.cxx:5272
TProof.cxx:5273
TProof.cxx:5274
TProof.cxx:5275
TProof.cxx:5276
TProof.cxx:5277
TProof.cxx:5278
TProof.cxx:5279
TProof.cxx:5280
TProof.cxx:5281
TProof.cxx:5282
TProof.cxx:5283
TProof.cxx:5284
TProof.cxx:5285
TProof.cxx:5286
TProof.cxx:5287
TProof.cxx:5288
TProof.cxx:5289
TProof.cxx:5290
TProof.cxx:5291
TProof.cxx:5292
TProof.cxx:5293
TProof.cxx:5294
TProof.cxx:5295
TProof.cxx:5296
TProof.cxx:5297
TProof.cxx:5298
TProof.cxx:5299
TProof.cxx:5300
TProof.cxx:5301
TProof.cxx:5302
TProof.cxx:5303
TProof.cxx:5304
TProof.cxx:5305
TProof.cxx:5306
TProof.cxx:5307
TProof.cxx:5308
TProof.cxx:5309
TProof.cxx:5310
TProof.cxx:5311
TProof.cxx:5312
TProof.cxx:5313
TProof.cxx:5314
TProof.cxx:5315
TProof.cxx:5316
TProof.cxx:5317
TProof.cxx:5318
TProof.cxx:5319
TProof.cxx:5320
TProof.cxx:5321
TProof.cxx:5322
TProof.cxx:5323
TProof.cxx:5324
TProof.cxx:5325
TProof.cxx:5326
TProof.cxx:5327
TProof.cxx:5328
TProof.cxx:5329
TProof.cxx:5330
TProof.cxx:5331
TProof.cxx:5332
TProof.cxx:5333
TProof.cxx:5334
TProof.cxx:5335
TProof.cxx:5336
TProof.cxx:5337
TProof.cxx:5338
TProof.cxx:5339
TProof.cxx:5340
TProof.cxx:5341
TProof.cxx:5342
TProof.cxx:5343
TProof.cxx:5344
TProof.cxx:5345
TProof.cxx:5346
TProof.cxx:5347
TProof.cxx:5348
TProof.cxx:5349
TProof.cxx:5350
TProof.cxx:5351
TProof.cxx:5352
TProof.cxx:5353
TProof.cxx:5354
TProof.cxx:5355
TProof.cxx:5356
TProof.cxx:5357
TProof.cxx:5358
TProof.cxx:5359
TProof.cxx:5360
TProof.cxx:5361
TProof.cxx:5362
TProof.cxx:5363
TProof.cxx:5364
TProof.cxx:5365
TProof.cxx:5366
TProof.cxx:5367
TProof.cxx:5368
TProof.cxx:5369
TProof.cxx:5370
TProof.cxx:5371
TProof.cxx:5372
TProof.cxx:5373
TProof.cxx:5374
TProof.cxx:5375
TProof.cxx:5376
TProof.cxx:5377
TProof.cxx:5378
TProof.cxx:5379
TProof.cxx:5380
TProof.cxx:5381
TProof.cxx:5382
TProof.cxx:5383
TProof.cxx:5384
TProof.cxx:5385
TProof.cxx:5386
TProof.cxx:5387
TProof.cxx:5388
TProof.cxx:5389
TProof.cxx:5390
TProof.cxx:5391
TProof.cxx:5392
TProof.cxx:5393
TProof.cxx:5394
TProof.cxx:5395
TProof.cxx:5396
TProof.cxx:5397
TProof.cxx:5398
TProof.cxx:5399
TProof.cxx:5400
TProof.cxx:5401
TProof.cxx:5402
TProof.cxx:5403
TProof.cxx:5404
TProof.cxx:5405
TProof.cxx:5406
TProof.cxx:5407
TProof.cxx:5408
TProof.cxx:5409
TProof.cxx:5410
TProof.cxx:5411
TProof.cxx:5412
TProof.cxx:5413
TProof.cxx:5414
TProof.cxx:5415
TProof.cxx:5416
TProof.cxx:5417
TProof.cxx:5418
TProof.cxx:5419
TProof.cxx:5420
TProof.cxx:5421
TProof.cxx:5422
TProof.cxx:5423
TProof.cxx:5424
TProof.cxx:5425
TProof.cxx:5426
TProof.cxx:5427
TProof.cxx:5428
TProof.cxx:5429
TProof.cxx:5430
TProof.cxx:5431
TProof.cxx:5432
TProof.cxx:5433
TProof.cxx:5434
TProof.cxx:5435
TProof.cxx:5436
TProof.cxx:5437
TProof.cxx:5438
TProof.cxx:5439
TProof.cxx:5440
TProof.cxx:5441
TProof.cxx:5442
TProof.cxx:5443
TProof.cxx:5444
TProof.cxx:5445
TProof.cxx:5446
TProof.cxx:5447
TProof.cxx:5448
TProof.cxx:5449
TProof.cxx:5450
TProof.cxx:5451
TProof.cxx:5452
TProof.cxx:5453
TProof.cxx:5454
TProof.cxx:5455
TProof.cxx:5456
TProof.cxx:5457
TProof.cxx:5458
TProof.cxx:5459
TProof.cxx:5460
TProof.cxx:5461
TProof.cxx:5462
TProof.cxx:5463
TProof.cxx:5464
TProof.cxx:5465
TProof.cxx:5466
TProof.cxx:5467
TProof.cxx:5468
TProof.cxx:5469
TProof.cxx:5470
TProof.cxx:5471
TProof.cxx:5472
TProof.cxx:5473
TProof.cxx:5474
TProof.cxx:5475
TProof.cxx:5476
TProof.cxx:5477
TProof.cxx:5478
TProof.cxx:5479
TProof.cxx:5480
TProof.cxx:5481
TProof.cxx:5482
TProof.cxx:5483
TProof.cxx:5484
TProof.cxx:5485
TProof.cxx:5486
TProof.cxx:5487
TProof.cxx:5488
TProof.cxx:5489
TProof.cxx:5490
TProof.cxx:5491
TProof.cxx:5492
TProof.cxx:5493
TProof.cxx:5494
TProof.cxx:5495
TProof.cxx:5496
TProof.cxx:5497
TProof.cxx:5498
TProof.cxx:5499
TProof.cxx:5500
TProof.cxx:5501
TProof.cxx:5502
TProof.cxx:5503
TProof.cxx:5504
TProof.cxx:5505
TProof.cxx:5506
TProof.cxx:5507
TProof.cxx:5508
TProof.cxx:5509
TProof.cxx:5510
TProof.cxx:5511
TProof.cxx:5512
TProof.cxx:5513
TProof.cxx:5514
TProof.cxx:5515
TProof.cxx:5516
TProof.cxx:5517
TProof.cxx:5518
TProof.cxx:5519
TProof.cxx:5520
TProof.cxx:5521
TProof.cxx:5522
TProof.cxx:5523
TProof.cxx:5524
TProof.cxx:5525
TProof.cxx:5526
TProof.cxx:5527
TProof.cxx:5528
TProof.cxx:5529
TProof.cxx:5530
TProof.cxx:5531
TProof.cxx:5532
TProof.cxx:5533
TProof.cxx:5534
TProof.cxx:5535
TProof.cxx:5536
TProof.cxx:5537
TProof.cxx:5538
TProof.cxx:5539
TProof.cxx:5540
TProof.cxx:5541
TProof.cxx:5542
TProof.cxx:5543
TProof.cxx:5544
TProof.cxx:5545
TProof.cxx:5546
TProof.cxx:5547
TProof.cxx:5548
TProof.cxx:5549
TProof.cxx:5550
TProof.cxx:5551
TProof.cxx:5552
TProof.cxx:5553
TProof.cxx:5554
TProof.cxx:5555
TProof.cxx:5556
TProof.cxx:5557
TProof.cxx:5558
TProof.cxx:5559
TProof.cxx:5560
TProof.cxx:5561
TProof.cxx:5562
TProof.cxx:5563
TProof.cxx:5564
TProof.cxx:5565
TProof.cxx:5566
TProof.cxx:5567
TProof.cxx:5568
TProof.cxx:5569
TProof.cxx:5570
TProof.cxx:5571
TProof.cxx:5572
TProof.cxx:5573
TProof.cxx:5574
TProof.cxx:5575
TProof.cxx:5576
TProof.cxx:5577
TProof.cxx:5578
TProof.cxx:5579
TProof.cxx:5580
TProof.cxx:5581
TProof.cxx:5582
TProof.cxx:5583
TProof.cxx:5584
TProof.cxx:5585
TProof.cxx:5586
TProof.cxx:5587
TProof.cxx:5588
TProof.cxx:5589
TProof.cxx:5590
TProof.cxx:5591
TProof.cxx:5592
TProof.cxx:5593
TProof.cxx:5594
TProof.cxx:5595
TProof.cxx:5596
TProof.cxx:5597
TProof.cxx:5598
TProof.cxx:5599
TProof.cxx:5600
TProof.cxx:5601
TProof.cxx:5602
TProof.cxx:5603
TProof.cxx:5604
TProof.cxx:5605
TProof.cxx:5606
TProof.cxx:5607
TProof.cxx:5608
TProof.cxx:5609
TProof.cxx:5610
TProof.cxx:5611
TProof.cxx:5612
TProof.cxx:5613
TProof.cxx:5614
TProof.cxx:5615
TProof.cxx:5616
TProof.cxx:5617
TProof.cxx:5618
TProof.cxx:5619
TProof.cxx:5620
TProof.cxx:5621
TProof.cxx:5622
TProof.cxx:5623
TProof.cxx:5624
TProof.cxx:5625
TProof.cxx:5626
TProof.cxx:5627
TProof.cxx:5628
TProof.cxx:5629
TProof.cxx:5630
TProof.cxx:5631
TProof.cxx:5632
TProof.cxx:5633
TProof.cxx:5634
TProof.cxx:5635
TProof.cxx:5636
TProof.cxx:5637
TProof.cxx:5638
TProof.cxx:5639
TProof.cxx:5640
TProof.cxx:5641
TProof.cxx:5642
TProof.cxx:5643
TProof.cxx:5644
TProof.cxx:5645
TProof.cxx:5646
TProof.cxx:5647
TProof.cxx:5648
TProof.cxx:5649
TProof.cxx:5650
TProof.cxx:5651
TProof.cxx:5652
TProof.cxx:5653
TProof.cxx:5654
TProof.cxx:5655
TProof.cxx:5656
TProof.cxx:5657
TProof.cxx:5658
TProof.cxx:5659
TProof.cxx:5660
TProof.cxx:5661
TProof.cxx:5662
TProof.cxx:5663
TProof.cxx:5664
TProof.cxx:5665
TProof.cxx:5666
TProof.cxx:5667
TProof.cxx:5668
TProof.cxx:5669
TProof.cxx:5670
TProof.cxx:5671
TProof.cxx:5672
TProof.cxx:5673
TProof.cxx:5674
TProof.cxx:5675
TProof.cxx:5676
TProof.cxx:5677
TProof.cxx:5678
TProof.cxx:5679
TProof.cxx:5680
TProof.cxx:5681
TProof.cxx:5682
TProof.cxx:5683
TProof.cxx:5684
TProof.cxx:5685
TProof.cxx:5686
TProof.cxx:5687
TProof.cxx:5688
TProof.cxx:5689
TProof.cxx:5690
TProof.cxx:5691
TProof.cxx:5692
TProof.cxx:5693
TProof.cxx:5694
TProof.cxx:5695
TProof.cxx:5696
TProof.cxx:5697
TProof.cxx:5698
TProof.cxx:5699
TProof.cxx:5700
TProof.cxx:5701
TProof.cxx:5702
TProof.cxx:5703
TProof.cxx:5704
TProof.cxx:5705
TProof.cxx:5706
TProof.cxx:5707
TProof.cxx:5708
TProof.cxx:5709
TProof.cxx:5710
TProof.cxx:5711
TProof.cxx:5712
TProof.cxx:5713
TProof.cxx:5714
TProof.cxx:5715
TProof.cxx:5716
TProof.cxx:5717
TProof.cxx:5718
TProof.cxx:5719
TProof.cxx:5720
TProof.cxx:5721
TProof.cxx:5722
TProof.cxx:5723
TProof.cxx:5724
TProof.cxx:5725
TProof.cxx:5726
TProof.cxx:5727
TProof.cxx:5728
TProof.cxx:5729
TProof.cxx:5730
TProof.cxx:5731
TProof.cxx:5732
TProof.cxx:5733
TProof.cxx:5734
TProof.cxx:5735
TProof.cxx:5736
TProof.cxx:5737
TProof.cxx:5738
TProof.cxx:5739
TProof.cxx:5740
TProof.cxx:5741
TProof.cxx:5742
TProof.cxx:5743
TProof.cxx:5744
TProof.cxx:5745
TProof.cxx:5746
TProof.cxx:5747
TProof.cxx:5748
TProof.cxx:5749
TProof.cxx:5750
TProof.cxx:5751
TProof.cxx:5752
TProof.cxx:5753
TProof.cxx:5754
TProof.cxx:5755
TProof.cxx:5756
TProof.cxx:5757
TProof.cxx:5758
TProof.cxx:5759
TProof.cxx:5760
TProof.cxx:5761
TProof.cxx:5762
TProof.cxx:5763
TProof.cxx:5764
TProof.cxx:5765
TProof.cxx:5766
TProof.cxx:5767
TProof.cxx:5768
TProof.cxx:5769
TProof.cxx:5770
TProof.cxx:5771
TProof.cxx:5772
TProof.cxx:5773
TProof.cxx:5774
TProof.cxx:5775
TProof.cxx:5776
TProof.cxx:5777
TProof.cxx:5778
TProof.cxx:5779
TProof.cxx:5780
TProof.cxx:5781
TProof.cxx:5782
TProof.cxx:5783
TProof.cxx:5784
TProof.cxx:5785
TProof.cxx:5786
TProof.cxx:5787
TProof.cxx:5788
TProof.cxx:5789
TProof.cxx:5790
TProof.cxx:5791
TProof.cxx:5792
TProof.cxx:5793
TProof.cxx:5794
TProof.cxx:5795
TProof.cxx:5796
TProof.cxx:5797
TProof.cxx:5798
TProof.cxx:5799
TProof.cxx:5800
TProof.cxx:5801
TProof.cxx:5802
TProof.cxx:5803
TProof.cxx:5804
TProof.cxx:5805
TProof.cxx:5806
TProof.cxx:5807
TProof.cxx:5808
TProof.cxx:5809
TProof.cxx:5810
TProof.cxx:5811
TProof.cxx:5812
TProof.cxx:5813
TProof.cxx:5814
TProof.cxx:5815
TProof.cxx:5816
TProof.cxx:5817
TProof.cxx:5818
TProof.cxx:5819
TProof.cxx:5820
TProof.cxx:5821
TProof.cxx:5822
TProof.cxx:5823
TProof.cxx:5824
TProof.cxx:5825
TProof.cxx:5826
TProof.cxx:5827
TProof.cxx:5828
TProof.cxx:5829
TProof.cxx:5830
TProof.cxx:5831
TProof.cxx:5832
TProof.cxx:5833
TProof.cxx:5834
TProof.cxx:5835
TProof.cxx:5836
TProof.cxx:5837
TProof.cxx:5838
TProof.cxx:5839
TProof.cxx:5840
TProof.cxx:5841
TProof.cxx:5842
TProof.cxx:5843
TProof.cxx:5844
TProof.cxx:5845
TProof.cxx:5846
TProof.cxx:5847
TProof.cxx:5848
TProof.cxx:5849
TProof.cxx:5850
TProof.cxx:5851
TProof.cxx:5852
TProof.cxx:5853
TProof.cxx:5854
TProof.cxx:5855
TProof.cxx:5856
TProof.cxx:5857
TProof.cxx:5858
TProof.cxx:5859
TProof.cxx:5860
TProof.cxx:5861
TProof.cxx:5862
TProof.cxx:5863
TProof.cxx:5864
TProof.cxx:5865
TProof.cxx:5866
TProof.cxx:5867
TProof.cxx:5868
TProof.cxx:5869
TProof.cxx:5870
TProof.cxx:5871
TProof.cxx:5872
TProof.cxx:5873
TProof.cxx:5874
TProof.cxx:5875
TProof.cxx:5876
TProof.cxx:5877
TProof.cxx:5878
TProof.cxx:5879
TProof.cxx:5880
TProof.cxx:5881
TProof.cxx:5882
TProof.cxx:5883
TProof.cxx:5884
TProof.cxx:5885
TProof.cxx:5886
TProof.cxx:5887
TProof.cxx:5888
TProof.cxx:5889
TProof.cxx:5890
TProof.cxx:5891
TProof.cxx:5892
TProof.cxx:5893
TProof.cxx:5894
TProof.cxx:5895
TProof.cxx:5896
TProof.cxx:5897
TProof.cxx:5898
TProof.cxx:5899
TProof.cxx:5900
TProof.cxx:5901
TProof.cxx:5902
TProof.cxx:5903
TProof.cxx:5904
TProof.cxx:5905
TProof.cxx:5906
TProof.cxx:5907
TProof.cxx:5908
TProof.cxx:5909
TProof.cxx:5910
TProof.cxx:5911
TProof.cxx:5912
TProof.cxx:5913
TProof.cxx:5914
TProof.cxx:5915
TProof.cxx:5916
TProof.cxx:5917
TProof.cxx:5918
TProof.cxx:5919
TProof.cxx:5920
TProof.cxx:5921
TProof.cxx:5922
TProof.cxx:5923
TProof.cxx:5924
TProof.cxx:5925
TProof.cxx:5926
TProof.cxx:5927
TProof.cxx:5928
TProof.cxx:5929
TProof.cxx:5930
TProof.cxx:5931
TProof.cxx:5932
TProof.cxx:5933
TProof.cxx:5934
TProof.cxx:5935
TProof.cxx:5936
TProof.cxx:5937
TProof.cxx:5938
TProof.cxx:5939
TProof.cxx:5940
TProof.cxx:5941
TProof.cxx:5942
TProof.cxx:5943
TProof.cxx:5944
TProof.cxx:5945
TProof.cxx:5946
TProof.cxx:5947
TProof.cxx:5948
TProof.cxx:5949
TProof.cxx:5950
TProof.cxx:5951
TProof.cxx:5952
TProof.cxx:5953
TProof.cxx:5954
TProof.cxx:5955
TProof.cxx:5956
TProof.cxx:5957
TProof.cxx:5958
TProof.cxx:5959
TProof.cxx:5960
TProof.cxx:5961
TProof.cxx:5962
TProof.cxx:5963
TProof.cxx:5964
TProof.cxx:5965
TProof.cxx:5966
TProof.cxx:5967
TProof.cxx:5968
TProof.cxx:5969
TProof.cxx:5970
TProof.cxx:5971
TProof.cxx:5972
TProof.cxx:5973
TProof.cxx:5974
TProof.cxx:5975
TProof.cxx:5976
TProof.cxx:5977
TProof.cxx:5978
TProof.cxx:5979
TProof.cxx:5980
TProof.cxx:5981
TProof.cxx:5982
TProof.cxx:5983
TProof.cxx:5984
TProof.cxx:5985
TProof.cxx:5986
TProof.cxx:5987
TProof.cxx:5988
TProof.cxx:5989
TProof.cxx:5990
TProof.cxx:5991
TProof.cxx:5992
TProof.cxx:5993
TProof.cxx:5994
TProof.cxx:5995
TProof.cxx:5996
TProof.cxx:5997
TProof.cxx:5998
TProof.cxx:5999
TProof.cxx:6000
TProof.cxx:6001
TProof.cxx:6002
TProof.cxx:6003
TProof.cxx:6004
TProof.cxx:6005
TProof.cxx:6006
TProof.cxx:6007
TProof.cxx:6008
TProof.cxx:6009
TProof.cxx:6010
TProof.cxx:6011
TProof.cxx:6012
TProof.cxx:6013
TProof.cxx:6014
TProof.cxx:6015
TProof.cxx:6016
TProof.cxx:6017
TProof.cxx:6018
TProof.cxx:6019
TProof.cxx:6020
TProof.cxx:6021
TProof.cxx:6022
TProof.cxx:6023
TProof.cxx:6024
TProof.cxx:6025
TProof.cxx:6026
TProof.cxx:6027
TProof.cxx:6028
TProof.cxx:6029
TProof.cxx:6030
TProof.cxx:6031
TProof.cxx:6032
TProof.cxx:6033
TProof.cxx:6034
TProof.cxx:6035
TProof.cxx:6036
TProof.cxx:6037
TProof.cxx:6038
TProof.cxx:6039
TProof.cxx:6040
TProof.cxx:6041
TProof.cxx:6042
TProof.cxx:6043
TProof.cxx:6044
TProof.cxx:6045
TProof.cxx:6046
TProof.cxx:6047
TProof.cxx:6048
TProof.cxx:6049
TProof.cxx:6050
TProof.cxx:6051
TProof.cxx:6052
TProof.cxx:6053
TProof.cxx:6054
TProof.cxx:6055
TProof.cxx:6056
TProof.cxx:6057
TProof.cxx:6058
TProof.cxx:6059
TProof.cxx:6060
TProof.cxx:6061
TProof.cxx:6062
TProof.cxx:6063
TProof.cxx:6064
TProof.cxx:6065
TProof.cxx:6066
TProof.cxx:6067
TProof.cxx:6068
TProof.cxx:6069
TProof.cxx:6070
TProof.cxx:6071
TProof.cxx:6072
TProof.cxx:6073
TProof.cxx:6074
TProof.cxx:6075
TProof.cxx:6076
TProof.cxx:6077
TProof.cxx:6078
TProof.cxx:6079
TProof.cxx:6080
TProof.cxx:6081
TProof.cxx:6082
TProof.cxx:6083
TProof.cxx:6084
TProof.cxx:6085
TProof.cxx:6086
TProof.cxx:6087
TProof.cxx:6088
TProof.cxx:6089
TProof.cxx:6090
TProof.cxx:6091
TProof.cxx:6092
TProof.cxx:6093
TProof.cxx:6094
TProof.cxx:6095
TProof.cxx:6096
TProof.cxx:6097
TProof.cxx:6098
TProof.cxx:6099
TProof.cxx:6100
TProof.cxx:6101
TProof.cxx:6102
TProof.cxx:6103
TProof.cxx:6104
TProof.cxx:6105
TProof.cxx:6106
TProof.cxx:6107
TProof.cxx:6108
TProof.cxx:6109
TProof.cxx:6110
TProof.cxx:6111
TProof.cxx:6112
TProof.cxx:6113
TProof.cxx:6114
TProof.cxx:6115
TProof.cxx:6116
TProof.cxx:6117
TProof.cxx:6118
TProof.cxx:6119
TProof.cxx:6120
TProof.cxx:6121
TProof.cxx:6122
TProof.cxx:6123
TProof.cxx:6124
TProof.cxx:6125
TProof.cxx:6126
TProof.cxx:6127
TProof.cxx:6128
TProof.cxx:6129
TProof.cxx:6130
TProof.cxx:6131
TProof.cxx:6132
TProof.cxx:6133
TProof.cxx:6134
TProof.cxx:6135
TProof.cxx:6136
TProof.cxx:6137
TProof.cxx:6138
TProof.cxx:6139
TProof.cxx:6140
TProof.cxx:6141
TProof.cxx:6142
TProof.cxx:6143
TProof.cxx:6144
TProof.cxx:6145
TProof.cxx:6146
TProof.cxx:6147
TProof.cxx:6148
TProof.cxx:6149
TProof.cxx:6150
TProof.cxx:6151
TProof.cxx:6152
TProof.cxx:6153
TProof.cxx:6154
TProof.cxx:6155
TProof.cxx:6156
TProof.cxx:6157
TProof.cxx:6158
TProof.cxx:6159
TProof.cxx:6160
TProof.cxx:6161
TProof.cxx:6162
TProof.cxx:6163
TProof.cxx:6164
TProof.cxx:6165
TProof.cxx:6166
TProof.cxx:6167
TProof.cxx:6168
TProof.cxx:6169
TProof.cxx:6170
TProof.cxx:6171
TProof.cxx:6172
TProof.cxx:6173
TProof.cxx:6174
TProof.cxx:6175
TProof.cxx:6176
TProof.cxx:6177
TProof.cxx:6178
TProof.cxx:6179
TProof.cxx:6180
TProof.cxx:6181
TProof.cxx:6182
TProof.cxx:6183
TProof.cxx:6184
TProof.cxx:6185
TProof.cxx:6186
TProof.cxx:6187
TProof.cxx:6188
TProof.cxx:6189
TProof.cxx:6190
TProof.cxx:6191
TProof.cxx:6192
TProof.cxx:6193
TProof.cxx:6194
TProof.cxx:6195
TProof.cxx:6196
TProof.cxx:6197
TProof.cxx:6198
TProof.cxx:6199
TProof.cxx:6200
TProof.cxx:6201
TProof.cxx:6202
TProof.cxx:6203
TProof.cxx:6204
TProof.cxx:6205
TProof.cxx:6206
TProof.cxx:6207
TProof.cxx:6208
TProof.cxx:6209
TProof.cxx:6210
TProof.cxx:6211
TProof.cxx:6212
TProof.cxx:6213
TProof.cxx:6214
TProof.cxx:6215
TProof.cxx:6216
TProof.cxx:6217
TProof.cxx:6218
TProof.cxx:6219
TProof.cxx:6220
TProof.cxx:6221
TProof.cxx:6222
TProof.cxx:6223
TProof.cxx:6224
TProof.cxx:6225
TProof.cxx:6226
TProof.cxx:6227
TProof.cxx:6228
TProof.cxx:6229
TProof.cxx:6230
TProof.cxx:6231
TProof.cxx:6232
TProof.cxx:6233
TProof.cxx:6234
TProof.cxx:6235
TProof.cxx:6236
TProof.cxx:6237
TProof.cxx:6238
TProof.cxx:6239
TProof.cxx:6240
TProof.cxx:6241
TProof.cxx:6242
TProof.cxx:6243
TProof.cxx:6244
TProof.cxx:6245
TProof.cxx:6246
TProof.cxx:6247
TProof.cxx:6248
TProof.cxx:6249
TProof.cxx:6250
TProof.cxx:6251
TProof.cxx:6252
TProof.cxx:6253
TProof.cxx:6254
TProof.cxx:6255
TProof.cxx:6256
TProof.cxx:6257
TProof.cxx:6258
TProof.cxx:6259
TProof.cxx:6260
TProof.cxx:6261
TProof.cxx:6262
TProof.cxx:6263
TProof.cxx:6264
TProof.cxx:6265
TProof.cxx:6266
TProof.cxx:6267
TProof.cxx:6268
TProof.cxx:6269
TProof.cxx:6270
TProof.cxx:6271
TProof.cxx:6272
TProof.cxx:6273
TProof.cxx:6274
TProof.cxx:6275
TProof.cxx:6276
TProof.cxx:6277
TProof.cxx:6278
TProof.cxx:6279
TProof.cxx:6280
TProof.cxx:6281
TProof.cxx:6282
TProof.cxx:6283
TProof.cxx:6284
TProof.cxx:6285
TProof.cxx:6286
TProof.cxx:6287
TProof.cxx:6288
TProof.cxx:6289
TProof.cxx:6290
TProof.cxx:6291
TProof.cxx:6292
TProof.cxx:6293
TProof.cxx:6294
TProof.cxx:6295
TProof.cxx:6296
TProof.cxx:6297
TProof.cxx:6298
TProof.cxx:6299
TProof.cxx:6300
TProof.cxx:6301
TProof.cxx:6302
TProof.cxx:6303
TProof.cxx:6304
TProof.cxx:6305
TProof.cxx:6306
TProof.cxx:6307
TProof.cxx:6308
TProof.cxx:6309
TProof.cxx:6310
TProof.cxx:6311
TProof.cxx:6312
TProof.cxx:6313
TProof.cxx:6314
TProof.cxx:6315
TProof.cxx:6316
TProof.cxx:6317
TProof.cxx:6318
TProof.cxx:6319
TProof.cxx:6320
TProof.cxx:6321
TProof.cxx:6322
TProof.cxx:6323
TProof.cxx:6324
TProof.cxx:6325
TProof.cxx:6326
TProof.cxx:6327
TProof.cxx:6328
TProof.cxx:6329
TProof.cxx:6330
TProof.cxx:6331
TProof.cxx:6332
TProof.cxx:6333
TProof.cxx:6334
TProof.cxx:6335
TProof.cxx:6336
TProof.cxx:6337
TProof.cxx:6338
TProof.cxx:6339
TProof.cxx:6340
TProof.cxx:6341
TProof.cxx:6342
TProof.cxx:6343
TProof.cxx:6344
TProof.cxx:6345
TProof.cxx:6346
TProof.cxx:6347
TProof.cxx:6348
TProof.cxx:6349
TProof.cxx:6350
TProof.cxx:6351
TProof.cxx:6352
TProof.cxx:6353
TProof.cxx:6354
TProof.cxx:6355
TProof.cxx:6356
TProof.cxx:6357
TProof.cxx:6358
TProof.cxx:6359
TProof.cxx:6360
TProof.cxx:6361
TProof.cxx:6362
TProof.cxx:6363
TProof.cxx:6364
TProof.cxx:6365
TProof.cxx:6366
TProof.cxx:6367
TProof.cxx:6368
TProof.cxx:6369
TProof.cxx:6370
TProof.cxx:6371
TProof.cxx:6372
TProof.cxx:6373
TProof.cxx:6374
TProof.cxx:6375
TProof.cxx:6376
TProof.cxx:6377
TProof.cxx:6378
TProof.cxx:6379
TProof.cxx:6380
TProof.cxx:6381
TProof.cxx:6382
TProof.cxx:6383
TProof.cxx:6384
TProof.cxx:6385
TProof.cxx:6386
TProof.cxx:6387
TProof.cxx:6388
TProof.cxx:6389
TProof.cxx:6390
TProof.cxx:6391
TProof.cxx:6392
TProof.cxx:6393
TProof.cxx:6394
TProof.cxx:6395
TProof.cxx:6396
TProof.cxx:6397
TProof.cxx:6398
TProof.cxx:6399
TProof.cxx:6400
TProof.cxx:6401
TProof.cxx:6402
TProof.cxx:6403
TProof.cxx:6404
TProof.cxx:6405
TProof.cxx:6406
TProof.cxx:6407
TProof.cxx:6408
TProof.cxx:6409
TProof.cxx:6410
TProof.cxx:6411
TProof.cxx:6412
TProof.cxx:6413
TProof.cxx:6414
TProof.cxx:6415
TProof.cxx:6416
TProof.cxx:6417
TProof.cxx:6418
TProof.cxx:6419
TProof.cxx:6420
TProof.cxx:6421
TProof.cxx:6422
TProof.cxx:6423
TProof.cxx:6424
TProof.cxx:6425
TProof.cxx:6426
TProof.cxx:6427
TProof.cxx:6428
TProof.cxx:6429
TProof.cxx:6430
TProof.cxx:6431
TProof.cxx:6432
TProof.cxx:6433
TProof.cxx:6434
TProof.cxx:6435
TProof.cxx:6436
TProof.cxx:6437
TProof.cxx:6438
TProof.cxx:6439
TProof.cxx:6440
TProof.cxx:6441
TProof.cxx:6442
TProof.cxx:6443
TProof.cxx:6444
TProof.cxx:6445
TProof.cxx:6446
TProof.cxx:6447
TProof.cxx:6448
TProof.cxx:6449
TProof.cxx:6450
TProof.cxx:6451
TProof.cxx:6452
TProof.cxx:6453
TProof.cxx:6454
TProof.cxx:6455
TProof.cxx:6456
TProof.cxx:6457
TProof.cxx:6458
TProof.cxx:6459
TProof.cxx:6460
TProof.cxx:6461
TProof.cxx:6462
TProof.cxx:6463
TProof.cxx:6464
TProof.cxx:6465
TProof.cxx:6466
TProof.cxx:6467
TProof.cxx:6468
TProof.cxx:6469
TProof.cxx:6470
TProof.cxx:6471
TProof.cxx:6472
TProof.cxx:6473
TProof.cxx:6474
TProof.cxx:6475
TProof.cxx:6476
TProof.cxx:6477
TProof.cxx:6478
TProof.cxx:6479
TProof.cxx:6480
TProof.cxx:6481
TProof.cxx:6482
TProof.cxx:6483
TProof.cxx:6484
TProof.cxx:6485
TProof.cxx:6486
TProof.cxx:6487
TProof.cxx:6488
TProof.cxx:6489
TProof.cxx:6490
TProof.cxx:6491
TProof.cxx:6492
TProof.cxx:6493
TProof.cxx:6494
TProof.cxx:6495
TProof.cxx:6496
TProof.cxx:6497
TProof.cxx:6498
TProof.cxx:6499
TProof.cxx:6500
TProof.cxx:6501
TProof.cxx:6502
TProof.cxx:6503
TProof.cxx:6504
TProof.cxx:6505
TProof.cxx:6506
TProof.cxx:6507
TProof.cxx:6508
TProof.cxx:6509
TProof.cxx:6510
TProof.cxx:6511
TProof.cxx:6512
TProof.cxx:6513
TProof.cxx:6514
TProof.cxx:6515
TProof.cxx:6516
TProof.cxx:6517
TProof.cxx:6518
TProof.cxx:6519
TProof.cxx:6520
TProof.cxx:6521
TProof.cxx:6522
TProof.cxx:6523
TProof.cxx:6524
TProof.cxx:6525
TProof.cxx:6526
TProof.cxx:6527
TProof.cxx:6528
TProof.cxx:6529
TProof.cxx:6530
TProof.cxx:6531
TProof.cxx:6532
TProof.cxx:6533
TProof.cxx:6534
TProof.cxx:6535
TProof.cxx:6536
TProof.cxx:6537
TProof.cxx:6538
TProof.cxx:6539
TProof.cxx:6540
TProof.cxx:6541
TProof.cxx:6542
TProof.cxx:6543
TProof.cxx:6544
TProof.cxx:6545
TProof.cxx:6546
TProof.cxx:6547
TProof.cxx:6548
TProof.cxx:6549
TProof.cxx:6550
TProof.cxx:6551
TProof.cxx:6552
TProof.cxx:6553
TProof.cxx:6554
TProof.cxx:6555
TProof.cxx:6556
TProof.cxx:6557
TProof.cxx:6558
TProof.cxx:6559
TProof.cxx:6560
TProof.cxx:6561
TProof.cxx:6562
TProof.cxx:6563
TProof.cxx:6564
TProof.cxx:6565
TProof.cxx:6566
TProof.cxx:6567
TProof.cxx:6568
TProof.cxx:6569
TProof.cxx:6570
TProof.cxx:6571
TProof.cxx:6572
TProof.cxx:6573
TProof.cxx:6574
TProof.cxx:6575
TProof.cxx:6576
TProof.cxx:6577
TProof.cxx:6578
TProof.cxx:6579
TProof.cxx:6580
TProof.cxx:6581
TProof.cxx:6582
TProof.cxx:6583
TProof.cxx:6584
TProof.cxx:6585
TProof.cxx:6586
TProof.cxx:6587
TProof.cxx:6588
TProof.cxx:6589
TProof.cxx:6590
TProof.cxx:6591
TProof.cxx:6592
TProof.cxx:6593
TProof.cxx:6594
TProof.cxx:6595
TProof.cxx:6596
TProof.cxx:6597
TProof.cxx:6598
TProof.cxx:6599
TProof.cxx:6600
TProof.cxx:6601
TProof.cxx:6602
TProof.cxx:6603
TProof.cxx:6604
TProof.cxx:6605
TProof.cxx:6606
TProof.cxx:6607
TProof.cxx:6608
TProof.cxx:6609
TProof.cxx:6610
TProof.cxx:6611
TProof.cxx:6612
TProof.cxx:6613
TProof.cxx:6614
TProof.cxx:6615
TProof.cxx:6616
TProof.cxx:6617
TProof.cxx:6618
TProof.cxx:6619
TProof.cxx:6620
TProof.cxx:6621
TProof.cxx:6622
TProof.cxx:6623
TProof.cxx:6624
TProof.cxx:6625
TProof.cxx:6626
TProof.cxx:6627
TProof.cxx:6628
TProof.cxx:6629
TProof.cxx:6630
TProof.cxx:6631
TProof.cxx:6632
TProof.cxx:6633
TProof.cxx:6634
TProof.cxx:6635
TProof.cxx:6636
TProof.cxx:6637
TProof.cxx:6638
TProof.cxx:6639
TProof.cxx:6640
TProof.cxx:6641
TProof.cxx:6642
TProof.cxx:6643
TProof.cxx:6644
TProof.cxx:6645
TProof.cxx:6646
TProof.cxx:6647
TProof.cxx:6648
TProof.cxx:6649
TProof.cxx:6650
TProof.cxx:6651
TProof.cxx:6652
TProof.cxx:6653
TProof.cxx:6654
TProof.cxx:6655
TProof.cxx:6656
TProof.cxx:6657
TProof.cxx:6658
TProof.cxx:6659
TProof.cxx:6660
TProof.cxx:6661
TProof.cxx:6662
TProof.cxx:6663
TProof.cxx:6664
TProof.cxx:6665
TProof.cxx:6666
TProof.cxx:6667
TProof.cxx:6668
TProof.cxx:6669
TProof.cxx:6670
TProof.cxx:6671
TProof.cxx:6672
TProof.cxx:6673
TProof.cxx:6674
TProof.cxx:6675
TProof.cxx:6676
TProof.cxx:6677
TProof.cxx:6678
TProof.cxx:6679
TProof.cxx:6680
TProof.cxx:6681
TProof.cxx:6682
TProof.cxx:6683
TProof.cxx:6684
TProof.cxx:6685
TProof.cxx:6686
TProof.cxx:6687
TProof.cxx:6688
TProof.cxx:6689
TProof.cxx:6690
TProof.cxx:6691
TProof.cxx:6692
TProof.cxx:6693
TProof.cxx:6694
TProof.cxx:6695
TProof.cxx:6696
TProof.cxx:6697
TProof.cxx:6698
TProof.cxx:6699
TProof.cxx:6700
TProof.cxx:6701
TProof.cxx:6702
TProof.cxx:6703
TProof.cxx:6704
TProof.cxx:6705
TProof.cxx:6706
TProof.cxx:6707
TProof.cxx:6708
TProof.cxx:6709
TProof.cxx:6710
TProof.cxx:6711
TProof.cxx:6712
TProof.cxx:6713
TProof.cxx:6714
TProof.cxx:6715
TProof.cxx:6716
TProof.cxx:6717
TProof.cxx:6718
TProof.cxx:6719
TProof.cxx:6720
TProof.cxx:6721
TProof.cxx:6722
TProof.cxx:6723
TProof.cxx:6724
TProof.cxx:6725
TProof.cxx:6726
TProof.cxx:6727
TProof.cxx:6728
TProof.cxx:6729
TProof.cxx:6730
TProof.cxx:6731
TProof.cxx:6732
TProof.cxx:6733
TProof.cxx:6734
TProof.cxx:6735
TProof.cxx:6736
TProof.cxx:6737
TProof.cxx:6738
TProof.cxx:6739
TProof.cxx:6740
TProof.cxx:6741
TProof.cxx:6742
TProof.cxx:6743
TProof.cxx:6744
TProof.cxx:6745
TProof.cxx:6746
TProof.cxx:6747
TProof.cxx:6748
TProof.cxx:6749
TProof.cxx:6750
TProof.cxx:6751
TProof.cxx:6752
TProof.cxx:6753
TProof.cxx:6754
TProof.cxx:6755
TProof.cxx:6756
TProof.cxx:6757
TProof.cxx:6758
TProof.cxx:6759
TProof.cxx:6760
TProof.cxx:6761
TProof.cxx:6762
TProof.cxx:6763
TProof.cxx:6764
TProof.cxx:6765
TProof.cxx:6766
TProof.cxx:6767
TProof.cxx:6768
TProof.cxx:6769
TProof.cxx:6770
TProof.cxx:6771
TProof.cxx:6772
TProof.cxx:6773
TProof.cxx:6774
TProof.cxx:6775
TProof.cxx:6776
TProof.cxx:6777
TProof.cxx:6778
TProof.cxx:6779
TProof.cxx:6780
TProof.cxx:6781
TProof.cxx:6782
TProof.cxx:6783
TProof.cxx:6784
TProof.cxx:6785
TProof.cxx:6786
TProof.cxx:6787
TProof.cxx:6788
TProof.cxx:6789
TProof.cxx:6790
TProof.cxx:6791
TProof.cxx:6792
TProof.cxx:6793
TProof.cxx:6794
TProof.cxx:6795
TProof.cxx:6796
TProof.cxx:6797
TProof.cxx:6798
TProof.cxx:6799
TProof.cxx:6800
TProof.cxx:6801
TProof.cxx:6802
TProof.cxx:6803
TProof.cxx:6804
TProof.cxx:6805
TProof.cxx:6806
TProof.cxx:6807
TProof.cxx:6808
TProof.cxx:6809
TProof.cxx:6810
TProof.cxx:6811
TProof.cxx:6812
TProof.cxx:6813
TProof.cxx:6814
TProof.cxx:6815
TProof.cxx:6816
TProof.cxx:6817
TProof.cxx:6818
TProof.cxx:6819
TProof.cxx:6820
TProof.cxx:6821
TProof.cxx:6822
TProof.cxx:6823
TProof.cxx:6824
TProof.cxx:6825
TProof.cxx:6826
TProof.cxx:6827
TProof.cxx:6828
TProof.cxx:6829
TProof.cxx:6830
TProof.cxx:6831
TProof.cxx:6832
TProof.cxx:6833
TProof.cxx:6834
TProof.cxx:6835
TProof.cxx:6836
TProof.cxx:6837
TProof.cxx:6838
TProof.cxx:6839
TProof.cxx:6840
TProof.cxx:6841
TProof.cxx:6842
TProof.cxx:6843
TProof.cxx:6844
TProof.cxx:6845
TProof.cxx:6846
TProof.cxx:6847
TProof.cxx:6848
TProof.cxx:6849
TProof.cxx:6850
TProof.cxx:6851
TProof.cxx:6852
TProof.cxx:6853
TProof.cxx:6854
TProof.cxx:6855
TProof.cxx:6856
TProof.cxx:6857
TProof.cxx:6858
TProof.cxx:6859
TProof.cxx:6860
TProof.cxx:6861
TProof.cxx:6862
TProof.cxx:6863
TProof.cxx:6864
TProof.cxx:6865
TProof.cxx:6866
TProof.cxx:6867
TProof.cxx:6868
TProof.cxx:6869
TProof.cxx:6870
TProof.cxx:6871
TProof.cxx:6872
TProof.cxx:6873
TProof.cxx:6874
TProof.cxx:6875
TProof.cxx:6876
TProof.cxx:6877
TProof.cxx:6878
TProof.cxx:6879
TProof.cxx:6880
TProof.cxx:6881
TProof.cxx:6882
TProof.cxx:6883
TProof.cxx:6884
TProof.cxx:6885
TProof.cxx:6886
TProof.cxx:6887
TProof.cxx:6888
TProof.cxx:6889
TProof.cxx:6890
TProof.cxx:6891
TProof.cxx:6892
TProof.cxx:6893
TProof.cxx:6894
TProof.cxx:6895
TProof.cxx:6896
TProof.cxx:6897
TProof.cxx:6898
TProof.cxx:6899
TProof.cxx:6900
TProof.cxx:6901
TProof.cxx:6902
TProof.cxx:6903
TProof.cxx:6904
TProof.cxx:6905
TProof.cxx:6906
TProof.cxx:6907
TProof.cxx:6908
TProof.cxx:6909
TProof.cxx:6910
TProof.cxx:6911
TProof.cxx:6912
TProof.cxx:6913
TProof.cxx:6914
TProof.cxx:6915
TProof.cxx:6916
TProof.cxx:6917
TProof.cxx:6918
TProof.cxx:6919
TProof.cxx:6920
TProof.cxx:6921
TProof.cxx:6922
TProof.cxx:6923
TProof.cxx:6924
TProof.cxx:6925
TProof.cxx:6926
TProof.cxx:6927
TProof.cxx:6928
TProof.cxx:6929
TProof.cxx:6930
TProof.cxx:6931
TProof.cxx:6932
TProof.cxx:6933
TProof.cxx:6934
TProof.cxx:6935
TProof.cxx:6936
TProof.cxx:6937
TProof.cxx:6938
TProof.cxx:6939
TProof.cxx:6940
TProof.cxx:6941
TProof.cxx:6942
TProof.cxx:6943
TProof.cxx:6944
TProof.cxx:6945
TProof.cxx:6946
TProof.cxx:6947
TProof.cxx:6948
TProof.cxx:6949
TProof.cxx:6950
TProof.cxx:6951
TProof.cxx:6952
TProof.cxx:6953
TProof.cxx:6954
TProof.cxx:6955
TProof.cxx:6956
TProof.cxx:6957
TProof.cxx:6958
TProof.cxx:6959
TProof.cxx:6960
TProof.cxx:6961
TProof.cxx:6962
TProof.cxx:6963
TProof.cxx:6964
TProof.cxx:6965
TProof.cxx:6966
TProof.cxx:6967
TProof.cxx:6968
TProof.cxx:6969
TProof.cxx:6970
TProof.cxx:6971
TProof.cxx:6972
TProof.cxx:6973
TProof.cxx:6974
TProof.cxx:6975
TProof.cxx:6976
TProof.cxx:6977
TProof.cxx:6978
TProof.cxx:6979
TProof.cxx:6980
TProof.cxx:6981
TProof.cxx:6982
TProof.cxx:6983
TProof.cxx:6984
TProof.cxx:6985
TProof.cxx:6986
TProof.cxx:6987
TProof.cxx:6988
TProof.cxx:6989
TProof.cxx:6990
TProof.cxx:6991
TProof.cxx:6992
TProof.cxx:6993
TProof.cxx:6994
TProof.cxx:6995
TProof.cxx:6996
TProof.cxx:6997
TProof.cxx:6998
TProof.cxx:6999
TProof.cxx:7000
TProof.cxx:7001
TProof.cxx:7002
TProof.cxx:7003
TProof.cxx:7004
TProof.cxx:7005
TProof.cxx:7006
TProof.cxx:7007
TProof.cxx:7008
TProof.cxx:7009
TProof.cxx:7010
TProof.cxx:7011
TProof.cxx:7012
TProof.cxx:7013
TProof.cxx:7014
TProof.cxx:7015
TProof.cxx:7016
TProof.cxx:7017
TProof.cxx:7018
TProof.cxx:7019
TProof.cxx:7020
TProof.cxx:7021
TProof.cxx:7022
TProof.cxx:7023
TProof.cxx:7024
TProof.cxx:7025
TProof.cxx:7026
TProof.cxx:7027
TProof.cxx:7028
TProof.cxx:7029
TProof.cxx:7030
TProof.cxx:7031
TProof.cxx:7032
TProof.cxx:7033
TProof.cxx:7034
TProof.cxx:7035
TProof.cxx:7036
TProof.cxx:7037
TProof.cxx:7038
TProof.cxx:7039
TProof.cxx:7040
TProof.cxx:7041
TProof.cxx:7042
TProof.cxx:7043
TProof.cxx:7044
TProof.cxx:7045
TProof.cxx:7046
TProof.cxx:7047
TProof.cxx:7048
TProof.cxx:7049
TProof.cxx:7050
TProof.cxx:7051
TProof.cxx:7052
TProof.cxx:7053
TProof.cxx:7054
TProof.cxx:7055
TProof.cxx:7056
TProof.cxx:7057
TProof.cxx:7058
TProof.cxx:7059
TProof.cxx:7060
TProof.cxx:7061
TProof.cxx:7062
TProof.cxx:7063
TProof.cxx:7064
TProof.cxx:7065
TProof.cxx:7066
TProof.cxx:7067
TProof.cxx:7068
TProof.cxx:7069
TProof.cxx:7070
TProof.cxx:7071
TProof.cxx:7072
TProof.cxx:7073
TProof.cxx:7074
TProof.cxx:7075
TProof.cxx:7076
TProof.cxx:7077
TProof.cxx:7078
TProof.cxx:7079
TProof.cxx:7080
TProof.cxx:7081
TProof.cxx:7082
TProof.cxx:7083
TProof.cxx:7084
TProof.cxx:7085
TProof.cxx:7086
TProof.cxx:7087
TProof.cxx:7088
TProof.cxx:7089
TProof.cxx:7090
TProof.cxx:7091
TProof.cxx:7092
TProof.cxx:7093
TProof.cxx:7094
TProof.cxx:7095
TProof.cxx:7096
TProof.cxx:7097
TProof.cxx:7098
TProof.cxx:7099
TProof.cxx:7100
TProof.cxx:7101
TProof.cxx:7102
TProof.cxx:7103
TProof.cxx:7104
TProof.cxx:7105
TProof.cxx:7106
TProof.cxx:7107
TProof.cxx:7108
TProof.cxx:7109
TProof.cxx:7110
TProof.cxx:7111
TProof.cxx:7112
TProof.cxx:7113
TProof.cxx:7114
TProof.cxx:7115
TProof.cxx:7116
TProof.cxx:7117
TProof.cxx:7118
TProof.cxx:7119
TProof.cxx:7120
TProof.cxx:7121
TProof.cxx:7122
TProof.cxx:7123
TProof.cxx:7124
TProof.cxx:7125
TProof.cxx:7126
TProof.cxx:7127
TProof.cxx:7128
TProof.cxx:7129
TProof.cxx:7130
TProof.cxx:7131
TProof.cxx:7132
TProof.cxx:7133
TProof.cxx:7134
TProof.cxx:7135
TProof.cxx:7136
TProof.cxx:7137
TProof.cxx:7138
TProof.cxx:7139
TProof.cxx:7140
TProof.cxx:7141
TProof.cxx:7142
TProof.cxx:7143
TProof.cxx:7144
TProof.cxx:7145
TProof.cxx:7146
TProof.cxx:7147
TProof.cxx:7148
TProof.cxx:7149
TProof.cxx:7150
TProof.cxx:7151
TProof.cxx:7152
TProof.cxx:7153
TProof.cxx:7154
TProof.cxx:7155
TProof.cxx:7156
TProof.cxx:7157
TProof.cxx:7158
TProof.cxx:7159
TProof.cxx:7160
TProof.cxx:7161
TProof.cxx:7162
TProof.cxx:7163
TProof.cxx:7164
TProof.cxx:7165
TProof.cxx:7166
TProof.cxx:7167
TProof.cxx:7168
TProof.cxx:7169
TProof.cxx:7170
TProof.cxx:7171
TProof.cxx:7172
TProof.cxx:7173
TProof.cxx:7174
TProof.cxx:7175
TProof.cxx:7176
TProof.cxx:7177
TProof.cxx:7178
TProof.cxx:7179
TProof.cxx:7180
TProof.cxx:7181
TProof.cxx:7182
TProof.cxx:7183
TProof.cxx:7184
TProof.cxx:7185
TProof.cxx:7186
TProof.cxx:7187
TProof.cxx:7188
TProof.cxx:7189
TProof.cxx:7190
TProof.cxx:7191
TProof.cxx:7192
TProof.cxx:7193
TProof.cxx:7194
TProof.cxx:7195
TProof.cxx:7196
TProof.cxx:7197
TProof.cxx:7198
TProof.cxx:7199
TProof.cxx:7200
TProof.cxx:7201
TProof.cxx:7202
TProof.cxx:7203
TProof.cxx:7204
TProof.cxx:7205
TProof.cxx:7206
TProof.cxx:7207
TProof.cxx:7208
TProof.cxx:7209
TProof.cxx:7210
TProof.cxx:7211
TProof.cxx:7212
TProof.cxx:7213
TProof.cxx:7214
TProof.cxx:7215
TProof.cxx:7216
TProof.cxx:7217
TProof.cxx:7218
TProof.cxx:7219
TProof.cxx:7220
TProof.cxx:7221
TProof.cxx:7222
TProof.cxx:7223
TProof.cxx:7224
TProof.cxx:7225
TProof.cxx:7226
TProof.cxx:7227
TProof.cxx:7228
TProof.cxx:7229
TProof.cxx:7230
TProof.cxx:7231
TProof.cxx:7232
TProof.cxx:7233
TProof.cxx:7234
TProof.cxx:7235
TProof.cxx:7236
TProof.cxx:7237
TProof.cxx:7238
TProof.cxx:7239
TProof.cxx:7240
TProof.cxx:7241
TProof.cxx:7242
TProof.cxx:7243
TProof.cxx:7244
TProof.cxx:7245
TProof.cxx:7246
TProof.cxx:7247
TProof.cxx:7248
TProof.cxx:7249
TProof.cxx:7250
TProof.cxx:7251
TProof.cxx:7252
TProof.cxx:7253
TProof.cxx:7254
TProof.cxx:7255
TProof.cxx:7256
TProof.cxx:7257
TProof.cxx:7258
TProof.cxx:7259
TProof.cxx:7260
TProof.cxx:7261
TProof.cxx:7262
TProof.cxx:7263
TProof.cxx:7264
TProof.cxx:7265
TProof.cxx:7266
TProof.cxx:7267
TProof.cxx:7268
TProof.cxx:7269
TProof.cxx:7270
TProof.cxx:7271
TProof.cxx:7272
TProof.cxx:7273
TProof.cxx:7274
TProof.cxx:7275
TProof.cxx:7276
TProof.cxx:7277
TProof.cxx:7278
TProof.cxx:7279
TProof.cxx:7280
TProof.cxx:7281
TProof.cxx:7282
TProof.cxx:7283
TProof.cxx:7284
TProof.cxx:7285
TProof.cxx:7286
TProof.cxx:7287
TProof.cxx:7288
TProof.cxx:7289
TProof.cxx:7290
TProof.cxx:7291
TProof.cxx:7292
TProof.cxx:7293
TProof.cxx:7294
TProof.cxx:7295
TProof.cxx:7296
TProof.cxx:7297
TProof.cxx:7298
TProof.cxx:7299
TProof.cxx:7300
TProof.cxx:7301
TProof.cxx:7302
TProof.cxx:7303
TProof.cxx:7304
TProof.cxx:7305
TProof.cxx:7306
TProof.cxx:7307
TProof.cxx:7308
TProof.cxx:7309
TProof.cxx:7310
TProof.cxx:7311
TProof.cxx:7312
TProof.cxx:7313
TProof.cxx:7314
TProof.cxx:7315
TProof.cxx:7316
TProof.cxx:7317
TProof.cxx:7318
TProof.cxx:7319
TProof.cxx:7320
TProof.cxx:7321
TProof.cxx:7322
TProof.cxx:7323
TProof.cxx:7324
TProof.cxx:7325
TProof.cxx:7326
TProof.cxx:7327
TProof.cxx:7328
TProof.cxx:7329
TProof.cxx:7330
TProof.cxx:7331
TProof.cxx:7332
TProof.cxx:7333
TProof.cxx:7334
TProof.cxx:7335
TProof.cxx:7336
TProof.cxx:7337
TProof.cxx:7338
TProof.cxx:7339
TProof.cxx:7340
TProof.cxx:7341
TProof.cxx:7342
TProof.cxx:7343
TProof.cxx:7344
TProof.cxx:7345
TProof.cxx:7346
TProof.cxx:7347
TProof.cxx:7348
TProof.cxx:7349
TProof.cxx:7350
TProof.cxx:7351
TProof.cxx:7352
TProof.cxx:7353
TProof.cxx:7354
TProof.cxx:7355
TProof.cxx:7356
TProof.cxx:7357
TProof.cxx:7358
TProof.cxx:7359
TProof.cxx:7360
TProof.cxx:7361
TProof.cxx:7362
TProof.cxx:7363
TProof.cxx:7364
TProof.cxx:7365
TProof.cxx:7366
TProof.cxx:7367
TProof.cxx:7368
TProof.cxx:7369
TProof.cxx:7370
TProof.cxx:7371
TProof.cxx:7372
TProof.cxx:7373
TProof.cxx:7374
TProof.cxx:7375
TProof.cxx:7376
TProof.cxx:7377
TProof.cxx:7378
TProof.cxx:7379
TProof.cxx:7380
TProof.cxx:7381
TProof.cxx:7382
TProof.cxx:7383
TProof.cxx:7384
TProof.cxx:7385
TProof.cxx:7386
TProof.cxx:7387
TProof.cxx:7388
TProof.cxx:7389
TProof.cxx:7390
TProof.cxx:7391
TProof.cxx:7392
TProof.cxx:7393
TProof.cxx:7394
TProof.cxx:7395
TProof.cxx:7396
TProof.cxx:7397
TProof.cxx:7398
TProof.cxx:7399
TProof.cxx:7400
TProof.cxx:7401
TProof.cxx:7402
TProof.cxx:7403
TProof.cxx:7404
TProof.cxx:7405
TProof.cxx:7406
TProof.cxx:7407
TProof.cxx:7408
TProof.cxx:7409
TProof.cxx:7410
TProof.cxx:7411
TProof.cxx:7412
TProof.cxx:7413
TProof.cxx:7414
TProof.cxx:7415
TProof.cxx:7416
TProof.cxx:7417
TProof.cxx:7418
TProof.cxx:7419
TProof.cxx:7420
TProof.cxx:7421
TProof.cxx:7422
TProof.cxx:7423
TProof.cxx:7424
TProof.cxx:7425
TProof.cxx:7426
TProof.cxx:7427
TProof.cxx:7428
TProof.cxx:7429
TProof.cxx:7430
TProof.cxx:7431
TProof.cxx:7432
TProof.cxx:7433
TProof.cxx:7434
TProof.cxx:7435
TProof.cxx:7436
TProof.cxx:7437
TProof.cxx:7438
TProof.cxx:7439
TProof.cxx:7440
TProof.cxx:7441
TProof.cxx:7442
TProof.cxx:7443
TProof.cxx:7444
TProof.cxx:7445
TProof.cxx:7446
TProof.cxx:7447
TProof.cxx:7448
TProof.cxx:7449
TProof.cxx:7450
TProof.cxx:7451
TProof.cxx:7452
TProof.cxx:7453
TProof.cxx:7454
TProof.cxx:7455
TProof.cxx:7456
TProof.cxx:7457
TProof.cxx:7458
TProof.cxx:7459
TProof.cxx:7460
TProof.cxx:7461
TProof.cxx:7462
TProof.cxx:7463
TProof.cxx:7464
TProof.cxx:7465
TProof.cxx:7466
TProof.cxx:7467
TProof.cxx:7468
TProof.cxx:7469
TProof.cxx:7470
TProof.cxx:7471
TProof.cxx:7472
TProof.cxx:7473
TProof.cxx:7474
TProof.cxx:7475
TProof.cxx:7476
TProof.cxx:7477
TProof.cxx:7478
TProof.cxx:7479
TProof.cxx:7480
TProof.cxx:7481
TProof.cxx:7482
TProof.cxx:7483
TProof.cxx:7484
TProof.cxx:7485
TProof.cxx:7486
TProof.cxx:7487
TProof.cxx:7488
TProof.cxx:7489
TProof.cxx:7490
TProof.cxx:7491
TProof.cxx:7492
TProof.cxx:7493
TProof.cxx:7494
TProof.cxx:7495
TProof.cxx:7496
TProof.cxx:7497
TProof.cxx:7498
TProof.cxx:7499
TProof.cxx:7500
TProof.cxx:7501
TProof.cxx:7502
TProof.cxx:7503
TProof.cxx:7504
TProof.cxx:7505
TProof.cxx:7506
TProof.cxx:7507
TProof.cxx:7508
TProof.cxx:7509
TProof.cxx:7510
TProof.cxx:7511
TProof.cxx:7512
TProof.cxx:7513
TProof.cxx:7514
TProof.cxx:7515
TProof.cxx:7516
TProof.cxx:7517
TProof.cxx:7518
TProof.cxx:7519
TProof.cxx:7520
TProof.cxx:7521
TProof.cxx:7522
TProof.cxx:7523
TProof.cxx:7524
TProof.cxx:7525
TProof.cxx:7526
TProof.cxx:7527
TProof.cxx:7528
TProof.cxx:7529
TProof.cxx:7530
TProof.cxx:7531
TProof.cxx:7532
TProof.cxx:7533
TProof.cxx:7534
TProof.cxx:7535
TProof.cxx:7536
TProof.cxx:7537
TProof.cxx:7538
TProof.cxx:7539
TProof.cxx:7540
TProof.cxx:7541
TProof.cxx:7542
TProof.cxx:7543
TProof.cxx:7544
TProof.cxx:7545
TProof.cxx:7546
TProof.cxx:7547
TProof.cxx:7548
TProof.cxx:7549
TProof.cxx:7550
TProof.cxx:7551
TProof.cxx:7552
TProof.cxx:7553
TProof.cxx:7554
TProof.cxx:7555
TProof.cxx:7556
TProof.cxx:7557
TProof.cxx:7558
TProof.cxx:7559
TProof.cxx:7560
TProof.cxx:7561
TProof.cxx:7562
TProof.cxx:7563
TProof.cxx:7564
TProof.cxx:7565
TProof.cxx:7566
TProof.cxx:7567
TProof.cxx:7568
TProof.cxx:7569
TProof.cxx:7570
TProof.cxx:7571
TProof.cxx:7572
TProof.cxx:7573
TProof.cxx:7574
TProof.cxx:7575
TProof.cxx:7576
TProof.cxx:7577
TProof.cxx:7578
TProof.cxx:7579
TProof.cxx:7580
TProof.cxx:7581
TProof.cxx:7582
TProof.cxx:7583
TProof.cxx:7584
TProof.cxx:7585
TProof.cxx:7586
TProof.cxx:7587
TProof.cxx:7588
TProof.cxx:7589
TProof.cxx:7590
TProof.cxx:7591
TProof.cxx:7592
TProof.cxx:7593
TProof.cxx:7594
TProof.cxx:7595
TProof.cxx:7596
TProof.cxx:7597
TProof.cxx:7598
TProof.cxx:7599
TProof.cxx:7600
TProof.cxx:7601
TProof.cxx:7602
TProof.cxx:7603
TProof.cxx:7604
TProof.cxx:7605
TProof.cxx:7606
TProof.cxx:7607
TProof.cxx:7608
TProof.cxx:7609
TProof.cxx:7610
TProof.cxx:7611
TProof.cxx:7612
TProof.cxx:7613
TProof.cxx:7614
TProof.cxx:7615
TProof.cxx:7616
TProof.cxx:7617
TProof.cxx:7618
TProof.cxx:7619
TProof.cxx:7620
TProof.cxx:7621
TProof.cxx:7622
TProof.cxx:7623
TProof.cxx:7624
TProof.cxx:7625
TProof.cxx:7626
TProof.cxx:7627
TProof.cxx:7628
TProof.cxx:7629
TProof.cxx:7630
TProof.cxx:7631
TProof.cxx:7632
TProof.cxx:7633
TProof.cxx:7634
TProof.cxx:7635
TProof.cxx:7636
TProof.cxx:7637
TProof.cxx:7638
TProof.cxx:7639
TProof.cxx:7640
TProof.cxx:7641
TProof.cxx:7642
TProof.cxx:7643
TProof.cxx:7644
TProof.cxx:7645
TProof.cxx:7646
TProof.cxx:7647
TProof.cxx:7648
TProof.cxx:7649
TProof.cxx:7650
TProof.cxx:7651
TProof.cxx:7652
TProof.cxx:7653
TProof.cxx:7654
TProof.cxx:7655
TProof.cxx:7656
TProof.cxx:7657
TProof.cxx:7658
TProof.cxx:7659
TProof.cxx:7660
TProof.cxx:7661
TProof.cxx:7662
TProof.cxx:7663
TProof.cxx:7664
TProof.cxx:7665
TProof.cxx:7666
TProof.cxx:7667
TProof.cxx:7668
TProof.cxx:7669
TProof.cxx:7670
TProof.cxx:7671
TProof.cxx:7672
TProof.cxx:7673
TProof.cxx:7674
TProof.cxx:7675
TProof.cxx:7676
TProof.cxx:7677
TProof.cxx:7678
TProof.cxx:7679
TProof.cxx:7680
TProof.cxx:7681
TProof.cxx:7682
TProof.cxx:7683
TProof.cxx:7684
TProof.cxx:7685
TProof.cxx:7686
TProof.cxx:7687
TProof.cxx:7688
TProof.cxx:7689
TProof.cxx:7690
TProof.cxx:7691
TProof.cxx:7692
TProof.cxx:7693
TProof.cxx:7694
TProof.cxx:7695
TProof.cxx:7696
TProof.cxx:7697
TProof.cxx:7698
TProof.cxx:7699
TProof.cxx:7700
TProof.cxx:7701
TProof.cxx:7702
TProof.cxx:7703
TProof.cxx:7704
TProof.cxx:7705
TProof.cxx:7706
TProof.cxx:7707
TProof.cxx:7708
TProof.cxx:7709
TProof.cxx:7710
TProof.cxx:7711
TProof.cxx:7712
TProof.cxx:7713
TProof.cxx:7714
TProof.cxx:7715
TProof.cxx:7716
TProof.cxx:7717
TProof.cxx:7718
TProof.cxx:7719
TProof.cxx:7720
TProof.cxx:7721
TProof.cxx:7722
TProof.cxx:7723
TProof.cxx:7724
TProof.cxx:7725
TProof.cxx:7726
TProof.cxx:7727
TProof.cxx:7728
TProof.cxx:7729
TProof.cxx:7730
TProof.cxx:7731
TProof.cxx:7732
TProof.cxx:7733
TProof.cxx:7734
TProof.cxx:7735
TProof.cxx:7736
TProof.cxx:7737
TProof.cxx:7738
TProof.cxx:7739
TProof.cxx:7740
TProof.cxx:7741
TProof.cxx:7742
TProof.cxx:7743
TProof.cxx:7744
TProof.cxx:7745
TProof.cxx:7746
TProof.cxx:7747
TProof.cxx:7748
TProof.cxx:7749
TProof.cxx:7750
TProof.cxx:7751
TProof.cxx:7752
TProof.cxx:7753
TProof.cxx:7754
TProof.cxx:7755
TProof.cxx:7756
TProof.cxx:7757
TProof.cxx:7758
TProof.cxx:7759
TProof.cxx:7760
TProof.cxx:7761
TProof.cxx:7762
TProof.cxx:7763
TProof.cxx:7764
TProof.cxx:7765
TProof.cxx:7766
TProof.cxx:7767
TProof.cxx:7768
TProof.cxx:7769
TProof.cxx:7770
TProof.cxx:7771
TProof.cxx:7772
TProof.cxx:7773
TProof.cxx:7774
TProof.cxx:7775
TProof.cxx:7776
TProof.cxx:7777
TProof.cxx:7778
TProof.cxx:7779
TProof.cxx:7780
TProof.cxx:7781
TProof.cxx:7782
TProof.cxx:7783
TProof.cxx:7784
TProof.cxx:7785
TProof.cxx:7786
TProof.cxx:7787
TProof.cxx:7788
TProof.cxx:7789
TProof.cxx:7790
TProof.cxx:7791
TProof.cxx:7792
TProof.cxx:7793
TProof.cxx:7794
TProof.cxx:7795
TProof.cxx:7796
TProof.cxx:7797
TProof.cxx:7798
TProof.cxx:7799
TProof.cxx:7800
TProof.cxx:7801
TProof.cxx:7802
TProof.cxx:7803
TProof.cxx:7804
TProof.cxx:7805
TProof.cxx:7806
TProof.cxx:7807
TProof.cxx:7808
TProof.cxx:7809
TProof.cxx:7810
TProof.cxx:7811
TProof.cxx:7812
TProof.cxx:7813
TProof.cxx:7814
TProof.cxx:7815
TProof.cxx:7816
TProof.cxx:7817
TProof.cxx:7818
TProof.cxx:7819
TProof.cxx:7820
TProof.cxx:7821
TProof.cxx:7822
TProof.cxx:7823
TProof.cxx:7824
TProof.cxx:7825
TProof.cxx:7826
TProof.cxx:7827
TProof.cxx:7828
TProof.cxx:7829
TProof.cxx:7830
TProof.cxx:7831
TProof.cxx:7832
TProof.cxx:7833
TProof.cxx:7834
TProof.cxx:7835
TProof.cxx:7836
TProof.cxx:7837
TProof.cxx:7838
TProof.cxx:7839
TProof.cxx:7840
TProof.cxx:7841
TProof.cxx:7842
TProof.cxx:7843
TProof.cxx:7844
TProof.cxx:7845
TProof.cxx:7846
TProof.cxx:7847
TProof.cxx:7848
TProof.cxx:7849
TProof.cxx:7850
TProof.cxx:7851
TProof.cxx:7852
TProof.cxx:7853
TProof.cxx:7854
TProof.cxx:7855
TProof.cxx:7856
TProof.cxx:7857
TProof.cxx:7858
TProof.cxx:7859
TProof.cxx:7860
TProof.cxx:7861
TProof.cxx:7862
TProof.cxx:7863
TProof.cxx:7864
TProof.cxx:7865
TProof.cxx:7866
TProof.cxx:7867
TProof.cxx:7868
TProof.cxx:7869
TProof.cxx:7870
TProof.cxx:7871
TProof.cxx:7872
TProof.cxx:7873
TProof.cxx:7874
TProof.cxx:7875
TProof.cxx:7876
TProof.cxx:7877
TProof.cxx:7878
TProof.cxx:7879
TProof.cxx:7880
TProof.cxx:7881
TProof.cxx:7882
TProof.cxx:7883
TProof.cxx:7884
TProof.cxx:7885
TProof.cxx:7886
TProof.cxx:7887
TProof.cxx:7888
TProof.cxx:7889
TProof.cxx:7890
TProof.cxx:7891
TProof.cxx:7892
TProof.cxx:7893
TProof.cxx:7894
TProof.cxx:7895
TProof.cxx:7896
TProof.cxx:7897
TProof.cxx:7898
TProof.cxx:7899
TProof.cxx:7900
TProof.cxx:7901
TProof.cxx:7902
TProof.cxx:7903
TProof.cxx:7904
TProof.cxx:7905
TProof.cxx:7906
TProof.cxx:7907
TProof.cxx:7908
TProof.cxx:7909
TProof.cxx:7910
TProof.cxx:7911
TProof.cxx:7912
TProof.cxx:7913
TProof.cxx:7914
TProof.cxx:7915
TProof.cxx:7916
TProof.cxx:7917
TProof.cxx:7918
TProof.cxx:7919
TProof.cxx:7920
TProof.cxx:7921
TProof.cxx:7922
TProof.cxx:7923
TProof.cxx:7924
TProof.cxx:7925
TProof.cxx:7926
TProof.cxx:7927
TProof.cxx:7928
TProof.cxx:7929
TProof.cxx:7930
TProof.cxx:7931
TProof.cxx:7932
TProof.cxx:7933
TProof.cxx:7934
TProof.cxx:7935
TProof.cxx:7936
TProof.cxx:7937
TProof.cxx:7938
TProof.cxx:7939
TProof.cxx:7940
TProof.cxx:7941
TProof.cxx:7942
TProof.cxx:7943
TProof.cxx:7944
TProof.cxx:7945
TProof.cxx:7946
TProof.cxx:7947
TProof.cxx:7948
TProof.cxx:7949
TProof.cxx:7950
TProof.cxx:7951
TProof.cxx:7952
TProof.cxx:7953
TProof.cxx:7954
TProof.cxx:7955
TProof.cxx:7956
TProof.cxx:7957
TProof.cxx:7958
TProof.cxx:7959
TProof.cxx:7960
TProof.cxx:7961
TProof.cxx:7962
TProof.cxx:7963
TProof.cxx:7964
TProof.cxx:7965
TProof.cxx:7966
TProof.cxx:7967
TProof.cxx:7968
TProof.cxx:7969
TProof.cxx:7970
TProof.cxx:7971
TProof.cxx:7972
TProof.cxx:7973
TProof.cxx:7974
TProof.cxx:7975
TProof.cxx:7976
TProof.cxx:7977
TProof.cxx:7978
TProof.cxx:7979
TProof.cxx:7980
TProof.cxx:7981
TProof.cxx:7982
TProof.cxx:7983
TProof.cxx:7984
TProof.cxx:7985
TProof.cxx:7986
TProof.cxx:7987
TProof.cxx:7988
TProof.cxx:7989
TProof.cxx:7990
TProof.cxx:7991
TProof.cxx:7992
TProof.cxx:7993
TProof.cxx:7994
TProof.cxx:7995
TProof.cxx:7996
TProof.cxx:7997
TProof.cxx:7998
TProof.cxx:7999
TProof.cxx:8000
TProof.cxx:8001
TProof.cxx:8002
TProof.cxx:8003
TProof.cxx:8004
TProof.cxx:8005
TProof.cxx:8006
TProof.cxx:8007
TProof.cxx:8008
TProof.cxx:8009
TProof.cxx:8010
TProof.cxx:8011
TProof.cxx:8012
TProof.cxx:8013
TProof.cxx:8014
TProof.cxx:8015
TProof.cxx:8016
TProof.cxx:8017
TProof.cxx:8018
TProof.cxx:8019
TProof.cxx:8020
TProof.cxx:8021
TProof.cxx:8022
TProof.cxx:8023
TProof.cxx:8024
TProof.cxx:8025
TProof.cxx:8026
TProof.cxx:8027
TProof.cxx:8028
TProof.cxx:8029
TProof.cxx:8030
TProof.cxx:8031
TProof.cxx:8032
TProof.cxx:8033
TProof.cxx:8034
TProof.cxx:8035
TProof.cxx:8036
TProof.cxx:8037
TProof.cxx:8038
TProof.cxx:8039
TProof.cxx:8040
TProof.cxx:8041
TProof.cxx:8042
TProof.cxx:8043
TProof.cxx:8044
TProof.cxx:8045
TProof.cxx:8046
TProof.cxx:8047
TProof.cxx:8048
TProof.cxx:8049
TProof.cxx:8050
TProof.cxx:8051
TProof.cxx:8052
TProof.cxx:8053
TProof.cxx:8054
TProof.cxx:8055
TProof.cxx:8056
TProof.cxx:8057
TProof.cxx:8058
TProof.cxx:8059
TProof.cxx:8060
TProof.cxx:8061
TProof.cxx:8062
TProof.cxx:8063
TProof.cxx:8064
TProof.cxx:8065
TProof.cxx:8066
TProof.cxx:8067
TProof.cxx:8068
TProof.cxx:8069
TProof.cxx:8070
TProof.cxx:8071
TProof.cxx:8072
TProof.cxx:8073
TProof.cxx:8074
TProof.cxx:8075
TProof.cxx:8076
TProof.cxx:8077
TProof.cxx:8078
TProof.cxx:8079
TProof.cxx:8080
TProof.cxx:8081
TProof.cxx:8082
TProof.cxx:8083
TProof.cxx:8084
TProof.cxx:8085
TProof.cxx:8086
TProof.cxx:8087
TProof.cxx:8088
TProof.cxx:8089
TProof.cxx:8090
TProof.cxx:8091
TProof.cxx:8092
TProof.cxx:8093
TProof.cxx:8094
TProof.cxx:8095
TProof.cxx:8096
TProof.cxx:8097
TProof.cxx:8098
TProof.cxx:8099
TProof.cxx:8100
TProof.cxx:8101
TProof.cxx:8102
TProof.cxx:8103
TProof.cxx:8104
TProof.cxx:8105
TProof.cxx:8106
TProof.cxx:8107
TProof.cxx:8108
TProof.cxx:8109
TProof.cxx:8110
TProof.cxx:8111
TProof.cxx:8112
TProof.cxx:8113
TProof.cxx:8114
TProof.cxx:8115
TProof.cxx:8116
TProof.cxx:8117
TProof.cxx:8118
TProof.cxx:8119
TProof.cxx:8120
TProof.cxx:8121
TProof.cxx:8122
TProof.cxx:8123
TProof.cxx:8124
TProof.cxx:8125
TProof.cxx:8126
TProof.cxx:8127
TProof.cxx:8128
TProof.cxx:8129
TProof.cxx:8130
TProof.cxx:8131
TProof.cxx:8132
TProof.cxx:8133
TProof.cxx:8134
TProof.cxx:8135
TProof.cxx:8136
TProof.cxx:8137
TProof.cxx:8138
TProof.cxx:8139
TProof.cxx:8140
TProof.cxx:8141
TProof.cxx:8142
TProof.cxx:8143
TProof.cxx:8144
TProof.cxx:8145
TProof.cxx:8146
TProof.cxx:8147
TProof.cxx:8148
TProof.cxx:8149
TProof.cxx:8150
TProof.cxx:8151
TProof.cxx:8152
TProof.cxx:8153
TProof.cxx:8154
TProof.cxx:8155
TProof.cxx:8156
TProof.cxx:8157
TProof.cxx:8158
TProof.cxx:8159
TProof.cxx:8160
TProof.cxx:8161
TProof.cxx:8162
TProof.cxx:8163
TProof.cxx:8164
TProof.cxx:8165
TProof.cxx:8166
TProof.cxx:8167
TProof.cxx:8168
TProof.cxx:8169
TProof.cxx:8170
TProof.cxx:8171
TProof.cxx:8172
TProof.cxx:8173
TProof.cxx:8174
TProof.cxx:8175
TProof.cxx:8176
TProof.cxx:8177
TProof.cxx:8178
TProof.cxx:8179
TProof.cxx:8180
TProof.cxx:8181
TProof.cxx:8182
TProof.cxx:8183
TProof.cxx:8184
TProof.cxx:8185
TProof.cxx:8186
TProof.cxx:8187
TProof.cxx:8188
TProof.cxx:8189
TProof.cxx:8190
TProof.cxx:8191
TProof.cxx:8192
TProof.cxx:8193
TProof.cxx:8194
TProof.cxx:8195
TProof.cxx:8196
TProof.cxx:8197
TProof.cxx:8198
TProof.cxx:8199
TProof.cxx:8200
TProof.cxx:8201
TProof.cxx:8202
TProof.cxx:8203
TProof.cxx:8204
TProof.cxx:8205
TProof.cxx:8206
TProof.cxx:8207
TProof.cxx:8208
TProof.cxx:8209
TProof.cxx:8210
TProof.cxx:8211
TProof.cxx:8212
TProof.cxx:8213
TProof.cxx:8214
TProof.cxx:8215
TProof.cxx:8216
TProof.cxx:8217
TProof.cxx:8218
TProof.cxx:8219
TProof.cxx:8220
TProof.cxx:8221
TProof.cxx:8222
TProof.cxx:8223
TProof.cxx:8224
TProof.cxx:8225
TProof.cxx:8226
TProof.cxx:8227
TProof.cxx:8228
TProof.cxx:8229
TProof.cxx:8230
TProof.cxx:8231
TProof.cxx:8232
TProof.cxx:8233
TProof.cxx:8234
TProof.cxx:8235
TProof.cxx:8236
TProof.cxx:8237
TProof.cxx:8238
TProof.cxx:8239
TProof.cxx:8240
TProof.cxx:8241
TProof.cxx:8242
TProof.cxx:8243
TProof.cxx:8244
TProof.cxx:8245
TProof.cxx:8246
TProof.cxx:8247
TProof.cxx:8248
TProof.cxx:8249
TProof.cxx:8250
TProof.cxx:8251
TProof.cxx:8252
TProof.cxx:8253
TProof.cxx:8254
TProof.cxx:8255
TProof.cxx:8256
TProof.cxx:8257
TProof.cxx:8258
TProof.cxx:8259
TProof.cxx:8260
TProof.cxx:8261
TProof.cxx:8262
TProof.cxx:8263
TProof.cxx:8264
TProof.cxx:8265
TProof.cxx:8266
TProof.cxx:8267
TProof.cxx:8268
TProof.cxx:8269
TProof.cxx:8270
TProof.cxx:8271
TProof.cxx:8272
TProof.cxx:8273
TProof.cxx:8274
TProof.cxx:8275
TProof.cxx:8276
TProof.cxx:8277
TProof.cxx:8278
TProof.cxx:8279
TProof.cxx:8280
TProof.cxx:8281
TProof.cxx:8282
TProof.cxx:8283
TProof.cxx:8284
TProof.cxx:8285
TProof.cxx:8286
TProof.cxx:8287
TProof.cxx:8288
TProof.cxx:8289
TProof.cxx:8290
TProof.cxx:8291
TProof.cxx:8292
TProof.cxx:8293
TProof.cxx:8294
TProof.cxx:8295
TProof.cxx:8296
TProof.cxx:8297
TProof.cxx:8298
TProof.cxx:8299
TProof.cxx:8300
TProof.cxx:8301
TProof.cxx:8302
TProof.cxx:8303
TProof.cxx:8304
TProof.cxx:8305
TProof.cxx:8306
TProof.cxx:8307
TProof.cxx:8308
TProof.cxx:8309
TProof.cxx:8310
TProof.cxx:8311
TProof.cxx:8312
TProof.cxx:8313
TProof.cxx:8314
TProof.cxx:8315
TProof.cxx:8316
TProof.cxx:8317
TProof.cxx:8318
TProof.cxx:8319
TProof.cxx:8320
TProof.cxx:8321
TProof.cxx:8322
TProof.cxx:8323
TProof.cxx:8324
TProof.cxx:8325
TProof.cxx:8326
TProof.cxx:8327
TProof.cxx:8328
TProof.cxx:8329
TProof.cxx:8330
TProof.cxx:8331
TProof.cxx:8332
TProof.cxx:8333
TProof.cxx:8334
TProof.cxx:8335
TProof.cxx:8336
TProof.cxx:8337
TProof.cxx:8338
TProof.cxx:8339
TProof.cxx:8340
TProof.cxx:8341
TProof.cxx:8342
TProof.cxx:8343
TProof.cxx:8344
TProof.cxx:8345
TProof.cxx:8346
TProof.cxx:8347
TProof.cxx:8348
TProof.cxx:8349
TProof.cxx:8350
TProof.cxx:8351
TProof.cxx:8352
TProof.cxx:8353
TProof.cxx:8354
TProof.cxx:8355
TProof.cxx:8356
TProof.cxx:8357
TProof.cxx:8358
TProof.cxx:8359
TProof.cxx:8360
TProof.cxx:8361
TProof.cxx:8362
TProof.cxx:8363
TProof.cxx:8364
TProof.cxx:8365
TProof.cxx:8366
TProof.cxx:8367
TProof.cxx:8368
TProof.cxx:8369
TProof.cxx:8370
TProof.cxx:8371
TProof.cxx:8372
TProof.cxx:8373
TProof.cxx:8374
TProof.cxx:8375
TProof.cxx:8376
TProof.cxx:8377
TProof.cxx:8378
TProof.cxx:8379
TProof.cxx:8380
TProof.cxx:8381
TProof.cxx:8382
TProof.cxx:8383
TProof.cxx:8384
TProof.cxx:8385
TProof.cxx:8386
TProof.cxx:8387
TProof.cxx:8388
TProof.cxx:8389
TProof.cxx:8390
TProof.cxx:8391
TProof.cxx:8392
TProof.cxx:8393
TProof.cxx:8394
TProof.cxx:8395
TProof.cxx:8396
TProof.cxx:8397
TProof.cxx:8398
TProof.cxx:8399
TProof.cxx:8400
TProof.cxx:8401
TProof.cxx:8402
TProof.cxx:8403
TProof.cxx:8404
TProof.cxx:8405
TProof.cxx:8406
TProof.cxx:8407
TProof.cxx:8408
TProof.cxx:8409
TProof.cxx:8410
TProof.cxx:8411
TProof.cxx:8412
TProof.cxx:8413
TProof.cxx:8414
TProof.cxx:8415
TProof.cxx:8416
TProof.cxx:8417
TProof.cxx:8418
TProof.cxx:8419
TProof.cxx:8420
TProof.cxx:8421
TProof.cxx:8422
TProof.cxx:8423
TProof.cxx:8424
TProof.cxx:8425
TProof.cxx:8426
TProof.cxx:8427
TProof.cxx:8428
TProof.cxx:8429
TProof.cxx:8430
TProof.cxx:8431
TProof.cxx:8432
TProof.cxx:8433
TProof.cxx:8434
TProof.cxx:8435
TProof.cxx:8436
TProof.cxx:8437
TProof.cxx:8438
TProof.cxx:8439
TProof.cxx:8440
TProof.cxx:8441
TProof.cxx:8442
TProof.cxx:8443
TProof.cxx:8444
TProof.cxx:8445
TProof.cxx:8446
TProof.cxx:8447
TProof.cxx:8448
TProof.cxx:8449
TProof.cxx:8450
TProof.cxx:8451
TProof.cxx:8452
TProof.cxx:8453
TProof.cxx:8454
TProof.cxx:8455
TProof.cxx:8456
TProof.cxx:8457
TProof.cxx:8458
TProof.cxx:8459
TProof.cxx:8460
TProof.cxx:8461
TProof.cxx:8462
TProof.cxx:8463
TProof.cxx:8464
TProof.cxx:8465
TProof.cxx:8466
TProof.cxx:8467
TProof.cxx:8468
TProof.cxx:8469
TProof.cxx:8470
TProof.cxx:8471
TProof.cxx:8472
TProof.cxx:8473
TProof.cxx:8474
TProof.cxx:8475
TProof.cxx:8476
TProof.cxx:8477
TProof.cxx:8478
TProof.cxx:8479
TProof.cxx:8480
TProof.cxx:8481
TProof.cxx:8482
TProof.cxx:8483
TProof.cxx:8484
TProof.cxx:8485
TProof.cxx:8486
TProof.cxx:8487
TProof.cxx:8488
TProof.cxx:8489
TProof.cxx:8490
TProof.cxx:8491
TProof.cxx:8492
TProof.cxx:8493
TProof.cxx:8494
TProof.cxx:8495
TProof.cxx:8496
TProof.cxx:8497
TProof.cxx:8498
TProof.cxx:8499
TProof.cxx:8500
TProof.cxx:8501
TProof.cxx:8502
TProof.cxx:8503
TProof.cxx:8504
TProof.cxx:8505
TProof.cxx:8506
TProof.cxx:8507
TProof.cxx:8508
TProof.cxx:8509
TProof.cxx:8510
TProof.cxx:8511
TProof.cxx:8512
TProof.cxx:8513
TProof.cxx:8514
TProof.cxx:8515
TProof.cxx:8516
TProof.cxx:8517
TProof.cxx:8518
TProof.cxx:8519
TProof.cxx:8520
TProof.cxx:8521
TProof.cxx:8522
TProof.cxx:8523
TProof.cxx:8524
TProof.cxx:8525
TProof.cxx:8526
TProof.cxx:8527
TProof.cxx:8528
TProof.cxx:8529
TProof.cxx:8530
TProof.cxx:8531
TProof.cxx:8532
TProof.cxx:8533
TProof.cxx:8534
TProof.cxx:8535
TProof.cxx:8536
TProof.cxx:8537
TProof.cxx:8538
TProof.cxx:8539
TProof.cxx:8540
TProof.cxx:8541
TProof.cxx:8542
TProof.cxx:8543
TProof.cxx:8544
TProof.cxx:8545
TProof.cxx:8546
TProof.cxx:8547
TProof.cxx:8548
TProof.cxx:8549
TProof.cxx:8550
TProof.cxx:8551
TProof.cxx:8552
TProof.cxx:8553
TProof.cxx:8554
TProof.cxx:8555
TProof.cxx:8556
TProof.cxx:8557
TProof.cxx:8558
TProof.cxx:8559
TProof.cxx:8560
TProof.cxx:8561
TProof.cxx:8562
TProof.cxx:8563
TProof.cxx:8564
TProof.cxx:8565
TProof.cxx:8566
TProof.cxx:8567
TProof.cxx:8568
TProof.cxx:8569
TProof.cxx:8570
TProof.cxx:8571
TProof.cxx:8572
TProof.cxx:8573
TProof.cxx:8574
TProof.cxx:8575
TProof.cxx:8576
TProof.cxx:8577
TProof.cxx:8578
TProof.cxx:8579
TProof.cxx:8580
TProof.cxx:8581
TProof.cxx:8582
TProof.cxx:8583
TProof.cxx:8584
TProof.cxx:8585
TProof.cxx:8586
TProof.cxx:8587
TProof.cxx:8588
TProof.cxx:8589
TProof.cxx:8590
TProof.cxx:8591
TProof.cxx:8592
TProof.cxx:8593
TProof.cxx:8594
TProof.cxx:8595
TProof.cxx:8596
TProof.cxx:8597
TProof.cxx:8598
TProof.cxx:8599
TProof.cxx:8600
TProof.cxx:8601
TProof.cxx:8602
TProof.cxx:8603
TProof.cxx:8604
TProof.cxx:8605
TProof.cxx:8606
TProof.cxx:8607
TProof.cxx:8608
TProof.cxx:8609
TProof.cxx:8610
TProof.cxx:8611
TProof.cxx:8612
TProof.cxx:8613
TProof.cxx:8614
TProof.cxx:8615
TProof.cxx:8616
TProof.cxx:8617
TProof.cxx:8618
TProof.cxx:8619
TProof.cxx:8620
TProof.cxx:8621
TProof.cxx:8622
TProof.cxx:8623
TProof.cxx:8624
TProof.cxx:8625
TProof.cxx:8626
TProof.cxx:8627
TProof.cxx:8628
TProof.cxx:8629
TProof.cxx:8630
TProof.cxx:8631
TProof.cxx:8632
TProof.cxx:8633
TProof.cxx:8634
TProof.cxx:8635
TProof.cxx:8636
TProof.cxx:8637
TProof.cxx:8638
TProof.cxx:8639
TProof.cxx:8640
TProof.cxx:8641
TProof.cxx:8642
TProof.cxx:8643
TProof.cxx:8644
TProof.cxx:8645
TProof.cxx:8646
TProof.cxx:8647
TProof.cxx:8648
TProof.cxx:8649
TProof.cxx:8650
TProof.cxx:8651
TProof.cxx:8652
TProof.cxx:8653
TProof.cxx:8654
TProof.cxx:8655
TProof.cxx:8656
TProof.cxx:8657
TProof.cxx:8658
TProof.cxx:8659
TProof.cxx:8660
TProof.cxx:8661
TProof.cxx:8662
TProof.cxx:8663
TProof.cxx:8664
TProof.cxx:8665
TProof.cxx:8666
TProof.cxx:8667
TProof.cxx:8668
TProof.cxx:8669
TProof.cxx:8670
TProof.cxx:8671
TProof.cxx:8672
TProof.cxx:8673
TProof.cxx:8674
TProof.cxx:8675
TProof.cxx:8676
TProof.cxx:8677
TProof.cxx:8678
TProof.cxx:8679
TProof.cxx:8680
TProof.cxx:8681
TProof.cxx:8682
TProof.cxx:8683
TProof.cxx:8684
TProof.cxx:8685
TProof.cxx:8686
TProof.cxx:8687
TProof.cxx:8688
TProof.cxx:8689
TProof.cxx:8690
TProof.cxx:8691
TProof.cxx:8692
TProof.cxx:8693
TProof.cxx:8694
TProof.cxx:8695
TProof.cxx:8696
TProof.cxx:8697
TProof.cxx:8698
TProof.cxx:8699
TProof.cxx:8700
TProof.cxx:8701
TProof.cxx:8702
TProof.cxx:8703
TProof.cxx:8704
TProof.cxx:8705
TProof.cxx:8706
TProof.cxx:8707
TProof.cxx:8708
TProof.cxx:8709
TProof.cxx:8710
TProof.cxx:8711
TProof.cxx:8712
TProof.cxx:8713
TProof.cxx:8714
TProof.cxx:8715
TProof.cxx:8716
TProof.cxx:8717
TProof.cxx:8718
TProof.cxx:8719
TProof.cxx:8720
TProof.cxx:8721
TProof.cxx:8722
TProof.cxx:8723
TProof.cxx:8724
TProof.cxx:8725
TProof.cxx:8726
TProof.cxx:8727
TProof.cxx:8728
TProof.cxx:8729
TProof.cxx:8730
TProof.cxx:8731
TProof.cxx:8732
TProof.cxx:8733
TProof.cxx:8734
TProof.cxx:8735
TProof.cxx:8736
TProof.cxx:8737
TProof.cxx:8738
TProof.cxx:8739
TProof.cxx:8740
TProof.cxx:8741
TProof.cxx:8742
TProof.cxx:8743
TProof.cxx:8744
TProof.cxx:8745
TProof.cxx:8746
TProof.cxx:8747
TProof.cxx:8748
TProof.cxx:8749
TProof.cxx:8750
TProof.cxx:8751
TProof.cxx:8752
TProof.cxx:8753
TProof.cxx:8754
TProof.cxx:8755
TProof.cxx:8756
TProof.cxx:8757
TProof.cxx:8758
TProof.cxx:8759
TProof.cxx:8760
TProof.cxx:8761
TProof.cxx:8762
TProof.cxx:8763
TProof.cxx:8764
TProof.cxx:8765
TProof.cxx:8766
TProof.cxx:8767
TProof.cxx:8768
TProof.cxx:8769
TProof.cxx:8770
TProof.cxx:8771
TProof.cxx:8772
TProof.cxx:8773
TProof.cxx:8774
TProof.cxx:8775
TProof.cxx:8776
TProof.cxx:8777
TProof.cxx:8778
TProof.cxx:8779
TProof.cxx:8780
TProof.cxx:8781
TProof.cxx:8782
TProof.cxx:8783
TProof.cxx:8784
TProof.cxx:8785
TProof.cxx:8786
TProof.cxx:8787
TProof.cxx:8788
TProof.cxx:8789
TProof.cxx:8790
TProof.cxx:8791
TProof.cxx:8792
TProof.cxx:8793
TProof.cxx:8794
TProof.cxx:8795
TProof.cxx:8796
TProof.cxx:8797
TProof.cxx:8798
TProof.cxx:8799
TProof.cxx:8800
TProof.cxx:8801
TProof.cxx:8802
TProof.cxx:8803
TProof.cxx:8804
TProof.cxx:8805
TProof.cxx:8806
TProof.cxx:8807
TProof.cxx:8808
TProof.cxx:8809
TProof.cxx:8810
TProof.cxx:8811
TProof.cxx:8812
TProof.cxx:8813
TProof.cxx:8814
TProof.cxx:8815
TProof.cxx:8816
TProof.cxx:8817
TProof.cxx:8818
TProof.cxx:8819
TProof.cxx:8820
TProof.cxx:8821
TProof.cxx:8822
TProof.cxx:8823
TProof.cxx:8824
TProof.cxx:8825
TProof.cxx:8826
TProof.cxx:8827
TProof.cxx:8828
TProof.cxx:8829
TProof.cxx:8830
TProof.cxx:8831
TProof.cxx:8832
TProof.cxx:8833
TProof.cxx:8834
TProof.cxx:8835
TProof.cxx:8836
TProof.cxx:8837
TProof.cxx:8838
TProof.cxx:8839
TProof.cxx:8840
TProof.cxx:8841
TProof.cxx:8842
TProof.cxx:8843
TProof.cxx:8844
TProof.cxx:8845
TProof.cxx:8846
TProof.cxx:8847
TProof.cxx:8848
TProof.cxx:8849
TProof.cxx:8850
TProof.cxx:8851
TProof.cxx:8852
TProof.cxx:8853
TProof.cxx:8854
TProof.cxx:8855
TProof.cxx:8856
TProof.cxx:8857
TProof.cxx:8858
TProof.cxx:8859
TProof.cxx:8860
TProof.cxx:8861
TProof.cxx:8862
TProof.cxx:8863
TProof.cxx:8864
TProof.cxx:8865
TProof.cxx:8866
TProof.cxx:8867
TProof.cxx:8868
TProof.cxx:8869
TProof.cxx:8870
TProof.cxx:8871
TProof.cxx:8872
TProof.cxx:8873
TProof.cxx:8874
TProof.cxx:8875
TProof.cxx:8876
TProof.cxx:8877
TProof.cxx:8878
TProof.cxx:8879
TProof.cxx:8880
TProof.cxx:8881
TProof.cxx:8882
TProof.cxx:8883
TProof.cxx:8884
TProof.cxx:8885
TProof.cxx:8886
TProof.cxx:8887
TProof.cxx:8888
TProof.cxx:8889
TProof.cxx:8890
TProof.cxx:8891
TProof.cxx:8892
TProof.cxx:8893
TProof.cxx:8894
TProof.cxx:8895
TProof.cxx:8896
TProof.cxx:8897
TProof.cxx:8898
TProof.cxx:8899
TProof.cxx:8900
TProof.cxx:8901
TProof.cxx:8902
TProof.cxx:8903
TProof.cxx:8904
TProof.cxx:8905
TProof.cxx:8906
TProof.cxx:8907
TProof.cxx:8908
TProof.cxx:8909
TProof.cxx:8910
TProof.cxx:8911
TProof.cxx:8912
TProof.cxx:8913
TProof.cxx:8914
TProof.cxx:8915
TProof.cxx:8916
TProof.cxx:8917
TProof.cxx:8918
TProof.cxx:8919
TProof.cxx:8920
TProof.cxx:8921
TProof.cxx:8922
TProof.cxx:8923
TProof.cxx:8924
TProof.cxx:8925
TProof.cxx:8926
TProof.cxx:8927
TProof.cxx:8928
TProof.cxx:8929
TProof.cxx:8930
TProof.cxx:8931
TProof.cxx:8932
TProof.cxx:8933
TProof.cxx:8934
TProof.cxx:8935
TProof.cxx:8936
TProof.cxx:8937
TProof.cxx:8938
TProof.cxx:8939
TProof.cxx:8940
TProof.cxx:8941
TProof.cxx:8942
TProof.cxx:8943
TProof.cxx:8944
TProof.cxx:8945
TProof.cxx:8946
TProof.cxx:8947
TProof.cxx:8948
TProof.cxx:8949
TProof.cxx:8950
TProof.cxx:8951
TProof.cxx:8952
TProof.cxx:8953
TProof.cxx:8954
TProof.cxx:8955
TProof.cxx:8956
TProof.cxx:8957
TProof.cxx:8958
TProof.cxx:8959
TProof.cxx:8960
TProof.cxx:8961
TProof.cxx:8962
TProof.cxx:8963
TProof.cxx:8964
TProof.cxx:8965
TProof.cxx:8966
TProof.cxx:8967
TProof.cxx:8968
TProof.cxx:8969
TProof.cxx:8970
TProof.cxx:8971
TProof.cxx:8972
TProof.cxx:8973
TProof.cxx:8974
TProof.cxx:8975
TProof.cxx:8976
TProof.cxx:8977
TProof.cxx:8978
TProof.cxx:8979
TProof.cxx:8980
TProof.cxx:8981
TProof.cxx:8982
TProof.cxx:8983
TProof.cxx:8984
TProof.cxx:8985
TProof.cxx:8986
TProof.cxx:8987
TProof.cxx:8988
TProof.cxx:8989
TProof.cxx:8990
TProof.cxx:8991
TProof.cxx:8992
TProof.cxx:8993
TProof.cxx:8994
TProof.cxx:8995
TProof.cxx:8996
TProof.cxx:8997
TProof.cxx:8998
TProof.cxx:8999
TProof.cxx:9000
TProof.cxx:9001
TProof.cxx:9002
TProof.cxx:9003
TProof.cxx:9004
TProof.cxx:9005
TProof.cxx:9006
TProof.cxx:9007
TProof.cxx:9008
TProof.cxx:9009
TProof.cxx:9010
TProof.cxx:9011
TProof.cxx:9012
TProof.cxx:9013
TProof.cxx:9014
TProof.cxx:9015
TProof.cxx:9016
TProof.cxx:9017
TProof.cxx:9018
TProof.cxx:9019
TProof.cxx:9020
TProof.cxx:9021
TProof.cxx:9022
TProof.cxx:9023
TProof.cxx:9024
TProof.cxx:9025
TProof.cxx:9026
TProof.cxx:9027
TProof.cxx:9028
TProof.cxx:9029
TProof.cxx:9030
TProof.cxx:9031
TProof.cxx:9032
TProof.cxx:9033
TProof.cxx:9034
TProof.cxx:9035
TProof.cxx:9036
TProof.cxx:9037
TProof.cxx:9038
TProof.cxx:9039
TProof.cxx:9040
TProof.cxx:9041
TProof.cxx:9042
TProof.cxx:9043
TProof.cxx:9044
TProof.cxx:9045
TProof.cxx:9046
TProof.cxx:9047
TProof.cxx:9048
TProof.cxx:9049
TProof.cxx:9050
TProof.cxx:9051
TProof.cxx:9052
TProof.cxx:9053
TProof.cxx:9054
TProof.cxx:9055
TProof.cxx:9056
TProof.cxx:9057
TProof.cxx:9058
TProof.cxx:9059
TProof.cxx:9060
TProof.cxx:9061
TProof.cxx:9062
TProof.cxx:9063
TProof.cxx:9064
TProof.cxx:9065
TProof.cxx:9066
TProof.cxx:9067
TProof.cxx:9068
TProof.cxx:9069
TProof.cxx:9070
TProof.cxx:9071
TProof.cxx:9072
TProof.cxx:9073
TProof.cxx:9074
TProof.cxx:9075
TProof.cxx:9076
TProof.cxx:9077
TProof.cxx:9078
TProof.cxx:9079
TProof.cxx:9080
TProof.cxx:9081
TProof.cxx:9082
TProof.cxx:9083
TProof.cxx:9084
TProof.cxx:9085
TProof.cxx:9086
TProof.cxx:9087
TProof.cxx:9088
TProof.cxx:9089
TProof.cxx:9090
TProof.cxx:9091
TProof.cxx:9092
TProof.cxx:9093
TProof.cxx:9094
TProof.cxx:9095
TProof.cxx:9096
TProof.cxx:9097
TProof.cxx:9098
TProof.cxx:9099
TProof.cxx:9100
TProof.cxx:9101
TProof.cxx:9102
TProof.cxx:9103
TProof.cxx:9104
TProof.cxx:9105
TProof.cxx:9106
TProof.cxx:9107
TProof.cxx:9108
TProof.cxx:9109
TProof.cxx:9110
TProof.cxx:9111
TProof.cxx:9112
TProof.cxx:9113
TProof.cxx:9114
TProof.cxx:9115
TProof.cxx:9116
TProof.cxx:9117
TProof.cxx:9118
TProof.cxx:9119
TProof.cxx:9120
TProof.cxx:9121
TProof.cxx:9122
TProof.cxx:9123
TProof.cxx:9124
TProof.cxx:9125
TProof.cxx:9126
TProof.cxx:9127
TProof.cxx:9128
TProof.cxx:9129
TProof.cxx:9130
TProof.cxx:9131
TProof.cxx:9132
TProof.cxx:9133
TProof.cxx:9134
TProof.cxx:9135
TProof.cxx:9136
TProof.cxx:9137
TProof.cxx:9138
TProof.cxx:9139
TProof.cxx:9140
TProof.cxx:9141
TProof.cxx:9142
TProof.cxx:9143
TProof.cxx:9144
TProof.cxx:9145
TProof.cxx:9146
TProof.cxx:9147
TProof.cxx:9148
TProof.cxx:9149
TProof.cxx:9150
TProof.cxx:9151
TProof.cxx:9152
TProof.cxx:9153
TProof.cxx:9154
TProof.cxx:9155
TProof.cxx:9156
TProof.cxx:9157
TProof.cxx:9158
TProof.cxx:9159
TProof.cxx:9160
TProof.cxx:9161
TProof.cxx:9162
TProof.cxx:9163
TProof.cxx:9164
TProof.cxx:9165
TProof.cxx:9166
TProof.cxx:9167
TProof.cxx:9168
TProof.cxx:9169
TProof.cxx:9170
TProof.cxx:9171
TProof.cxx:9172
TProof.cxx:9173
TProof.cxx:9174
TProof.cxx:9175
TProof.cxx:9176
TProof.cxx:9177
TProof.cxx:9178
TProof.cxx:9179
TProof.cxx:9180
TProof.cxx:9181
TProof.cxx:9182
TProof.cxx:9183
TProof.cxx:9184
TProof.cxx:9185
TProof.cxx:9186
TProof.cxx:9187
TProof.cxx:9188
TProof.cxx:9189
TProof.cxx:9190
TProof.cxx:9191
TProof.cxx:9192
TProof.cxx:9193
TProof.cxx:9194
TProof.cxx:9195
TProof.cxx:9196
TProof.cxx:9197
TProof.cxx:9198
TProof.cxx:9199
TProof.cxx:9200
TProof.cxx:9201
TProof.cxx:9202
TProof.cxx:9203
TProof.cxx:9204
TProof.cxx:9205
TProof.cxx:9206
TProof.cxx:9207
TProof.cxx:9208
TProof.cxx:9209
TProof.cxx:9210
TProof.cxx:9211
TProof.cxx:9212