Logo ROOT   6.08/07
Reference Guide
TProof.h
Go to the documentation of this file.
1 // @(#)root/proof:$Id$
2 // Author: Fons Rademakers 13/02/97
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #ifndef ROOT_TProof
13 #define ROOT_TProof
14 
15 
16 //////////////////////////////////////////////////////////////////////////
17 // //
18 // TProof //
19 // //
20 // This class controls a Parallel ROOT Facility, PROOF, cluster. //
21 // It fires the worker servers, it keeps track of how many workers are //
22 // running, it keeps track of the workers running status, it broadcasts //
23 // messages to all workers, it collects results, etc. //
24 // //
25 //////////////////////////////////////////////////////////////////////////
26 
27 #ifndef ROOT_TProofMgr
28 #include "TProofMgr.h"
29 #endif
30 #ifndef ROOT_TProofDebug
31 #include "TProofDebug.h"
32 #endif
33 #ifndef ROOT_TString
34 #include "TString.h"
35 #endif
36 #ifndef ROOT_TMacro
37 #include "TMacro.h"
38 #endif
39 #ifndef ROOT_MessageTypes
40 #include "MessageTypes.h"
41 #endif
42 #ifndef ROOT_TMD5
43 #include "TMD5.h"
44 #endif
45 #ifndef ROOT_TRegexp
46 #include "TRegexp.h"
47 #endif
48 #ifndef ROOT_TSysEvtHandler
49 #include "TSysEvtHandler.h"
50 #endif
51 #ifndef ROOT_TUrl
52 #include "TUrl.h"
53 #endif
54 #ifndef ROOT_TProofOutputList
55 #include "TProofOutputList.h"
56 #endif
57 #ifndef ROOT_TStopwatch
58 #include "TStopwatch.h"
59 #endif
60 #ifndef ROOT_TVirtualMutex
61 #include "TVirtualMutex.h"
62 #endif
63 #ifndef ROOT_TPackMgr
64 #include "TPackMgr.h"
65 #endif
66 
67 #include <map>
68 #include <mutex>
69 
70 #ifdef R__GLOBALSTL
71 namespace std { using ::map; }
72 #endif
73 
74 #define CANNOTUSE(x) Info(x,"Not manager: cannot use this method")
75 
76 class TChain;
77 class TCondor;
78 class TCondorSlave;
79 class TDrawFeedback;
80 class TDSet;
81 class TEventList;
82 class THashList;
83 class TList;
84 class TCollection;
85 class TMessage;
86 class TMonitor;
87 class TPluginHandler;
88 class TProof;
89 class TProofInputHandler;
91 class TProofLockPath;
93 class TProofPlayer;
94 class TProofPlayerRemote;
96 class TProofServ;
97 class TQueryResult;
98 class TSignalHandler;
99 class TSlave;
100 class TSocket;
101 class TTree;
102 class TFileCollection;
103 class TMap;
104 class TDataSetManager;
105 class TDataSetManagerFile;
106 class TMacro;
107 class TSelector;
108 
109 // protocol changes:
110 // 1 -> 2: new arguments for Process() command, option added
111 // 2 -> 3: package manager enabling protocol changed
112 // 3 -> 4: introduction of multi-level-master support
113 // 4 -> 5: added friends support
114 // 5 -> 6: drop TFTP, support for asynchronous queries
115 // 6 -> 7: support for multisessions, archieve, retrieve, ...
116 // 7 -> 8: return number of entries in GetNextPacket
117 // 8 -> 9: support for stateless connection via xproofd
118 // 9 -> 10: new features requested, tested at CAF
119 // 10 -> 11: new merging strategy
120 // 11 -> 12: new progress message
121 // 12 -> 13: exchange version/architecture/compiler info
122 // 13 -> 14: new proofserv environment setting
123 // 14 -> 15: add support for entry lists; new version of TFileInfo
124 // 15 -> 16: add support for generic non-data based processing
125 // 16 -> 17: new dataset handling system; support for TFileCollection processing
126 // 17 -> 18: support for reconnection on daemon restarts
127 // 18 -> 19: TProofProgressStatus used in kPROOF_PROGRESS, kPROOF_STOPPROCESS
128 // and kPROOF_GETNEXTPACKET messages in Master - worker communication
129 // 19 -> 20: Fix the asynchronous mode (required changes in some messages)
130 // 20 -> 21: Add support for session queuing
131 // 21 -> 22: Add support for switching from sync to async while running ('Ctrl-Z' functionality)
132 // 22 -> 23: New dataset features (default tree name; classification per fileserver)
133 // 23 -> 24: Merging optimization
134 // 24 -> 25: Handling of 'data' dir; group information
135 // 25 -> 26: Use new TProofProgressInfo class
136 // 26 -> 27: Use new file for updating the session status
137 // 27 -> 28: Support for multi-datasets, fix global pack dirs, fix AskStatistics,
138 // package download, dataset caching
139 // 28 -> 29: Support for config parameters in EnablePackage, idle-timeout
140 // 29 -> 30: Add information about data dir in TSlaveInfo
141 // 30 -> 31: Development cycle 5.29
142 // 31 -> 32: New log path trasmission
143 // 32 -> 33: Development cycle 5.29/04 (fixed worker activation, new startup technology, ...)
144 // 33 -> 34: Development cycle 5.33/02 (fix load issue, ...)
145 // 34 -> 35: Development cycle 5.99/01 (PLite on workers, staging requests in separate dsmgr...)
146 // 35 -> 36: SetParallel in dynamic mode (changes default in GoParallel), cancel staging requests
147 // 36 -> 37: Support for remote (web) PAR packages
148 
149 // PROOF magic constants
150 const Int_t kPROOF_Protocol = 37; // protocol version number
151 const Int_t kPROOF_Port = 1093; // IANA registered PROOF port
152 const char* const kPROOF_ConfFile = "proof.conf"; // default config file
153 const char* const kPROOF_ConfDir = "/usr/local/root"; // default config dir
154 const char* const kPROOF_WorkDir = ".proof"; // default working directory
155 const char* const kPROOF_CacheDir = "cache"; // file cache dir, under WorkDir
156 const char* const kPROOF_PackDir = "packages"; // package dir, under WorkDir
157 const char* const kPROOF_PackDownloadDir = "downloaded"; // subdir with downloaded PARs, under PackDir
158 const char* const kPROOF_QueryDir = "queries"; // query dir, under WorkDir
159 const char* const kPROOF_DataSetDir = "datasets"; // dataset dir, under WorkDir
160 const char* const kPROOF_DataDir = "data"; // dir for produced data, under WorkDir
161 const char* const kPROOF_CacheLockFile = "proof-cache-lock-"; // cache lock file
162 const char* const kPROOF_PackageLockFile = "proof-package-lock-"; // package lock file
163 const char* const kPROOF_QueryLockFile = "proof-query-lock-"; // query lock file
164 const char* const kPROOF_TerminateWorker = "+++ terminating +++"; // signal worker termination in MarkBad
165 const char* const kPROOF_WorkerIdleTO = "+++ idle-timeout +++"; // signal worker idle timeout in MarkBad
166 const char* const kPROOF_InputDataFile = "inputdata.root"; // Default input data file name
167 const char* const kPROOF_MissingFiles = "MissingFiles"; // Missingfile list name
168 const Long64_t kPROOF_DynWrkPollInt_s = 10; // minimum number of seconds between two polls for dyn wrks
169 
170 #ifndef R__WIN32
171 const char* const kCP = "/bin/cp -fp";
172 const char* const kRM = "/bin/rm -rf";
173 const char* const kLS = "/bin/ls -l";
174 const char* const kUNTAR = "%s -c %s/%s | (cd %s; tar xf -)";
175 const char* const kUNTAR2 = "%s -c %s | (cd %s; tar xf -)";
176 const char* const kUNTAR3 = "%s -c %s | (tar xf -)";
177 const char* const kGUNZIP = "gunzip";
178 #else
179 const char* const kCP = "copy";
180 const char* const kRM = "delete";
181 const char* const kLS = "dir";
182 const char* const kUNTAR = "...";
183 const char* const kUNTAR2 = "...";
184 const char* const kUNTAR3 = "...";
185 const char* const kGUNZIP = "gunzip";
186 #endif
187 
188 typedef void (*PrintProgress_t)(Long64_t tot, Long64_t proc, Float_t proctime, Long64_t bytes);
189 
190 // Structure for the progress information
191 class TProofProgressInfo : public TObject {
192 public:
193  Long64_t fTotal; // Total number of events to process
194  Long64_t fProcessed; // Number of events processed
195  Long64_t fBytesRead; // Number of bytes read
196  Float_t fInitTime; // Time for initialization
197  Float_t fProcTime; // Time for processing
198  Float_t fEvtRateI; // Instantaneous event rate
199  Float_t fMBRateI; // Instantaneous byte read rate
200  Int_t fActWorkers; // Numebr of workers still active
201  Int_t fTotSessions; // Numebr of PROOF sessions running currently on the clusters
202  Float_t fEffSessions; // Number of effective sessions running on the machines allocated to this session
203  TProofProgressInfo(Long64_t tot = 0, Long64_t proc = 0, Long64_t bytes = 0,
204  Float_t initt = -1., Float_t proct = -1.,
205  Float_t evts = -1., Float_t mbs = -1.,
206  Int_t actw = 0, Int_t tsess = 0, Float_t esess = 0.) :
207  fTotal(tot), fProcessed(proc), fBytesRead(bytes),
208  fInitTime(initt), fProcTime(proct), fEvtRateI(evts), fMBRateI(mbs),
209  fActWorkers(actw), fTotSessions(tsess), fEffSessions(esess) { }
210  virtual ~TProofProgressInfo() { }
211  ClassDef(TProofProgressInfo, 1); // Progress information
212 };
213 
214 // PROOF Interrupt signal handler
216 private:
218 
219  TProofInterruptHandler(const TProofInterruptHandler&); // Not implemented
220  TProofInterruptHandler& operator=(const TProofInterruptHandler&); // Not implemented
221 public:
223  : TSignalHandler(kSigInterrupt, kFALSE), fProof(p) { }
224  Bool_t Notify();
225 };
226 
227 // Input handler for messages from TProofServ
229 private:
232 
233  TProofInputHandler(const TProofInputHandler&); // Not implemented
234  TProofInputHandler& operator=(const TProofInputHandler&); // Not implemented
235 public:
237  Bool_t Notify();
238  Bool_t ReadNotify() { return Notify(); }
239 };
240 
241 // Slaves info class
242 class TSlaveInfo : public TObject {
243 public:
244  enum ESlaveStatus { kActive, kNotActive, kBad };
245 
246  TString fOrdinal; //slave ordinal
247  TString fHostName; //hostname this slave is running on
248  TString fMsd; //mass storage domain slave is in
249  TString fDataDir; //directory for user data
250  Int_t fPerfIndex; //relative performance of this slave
251  SysInfo_t fSysInfo; //Infomation about its hardware
252  ESlaveStatus fStatus; //slave status
253 
254  TSlaveInfo(const char *ordinal = "", const char *host = "", Int_t perfidx = 0,
255  const char *msd = "", const char *datadir = "") :
256  fOrdinal(ordinal), fHostName(host), fMsd(msd), fDataDir(datadir),
257  fPerfIndex(perfidx), fSysInfo(), fStatus(kNotActive) { }
258 
259  const char *GetDataDir() const { return fDataDir; }
260  const char *GetMsd() const { return fMsd; }
261  const char *GetName() const { return fHostName; }
262  const char *GetOrdinal() const { return fOrdinal; }
263  SysInfo_t GetSysInfo() const { return fSysInfo; }
264  void SetStatus(ESlaveStatus stat) { fStatus = stat; }
265  void SetSysInfo(SysInfo_t si);
266  void SetOrdinal(const char *ord) { fOrdinal = ord; }
267 
268  Int_t Compare(const TObject *obj) const;
269  Bool_t IsSortable() const { return kTRUE; }
270  void Print(Option_t *option="") const;
271  Bool_t IsEqual(const TObject* obj) const;
272 
273  ClassDef(TSlaveInfo,4) //basic info on workers
274 };
275 
276 // Merger info class
277 class TMergerInfo : public TObject {
278 private:
279 
280  TSlave *fMerger; // Slave that acts as merger
281  Int_t fPort; // Port number, on which it accepts outputs from other workers
282  Int_t fMergedObjects; // Total number of objects it must accept from other workers
283  // (-1 == not set yet)
284  Int_t fWorkersToMerge; // Number of workers that are merged on this merger
285  // (does not change during time)
286  Int_t fMergedWorkers; // Current number of already merged workers
287  // (does change during time as workers are being merged)
288 
289  TList *fWorkers; // List of already assigned workers
290  Bool_t fIsActive; // Merger state
291 
292  TMergerInfo(const TMergerInfo&); // Not implemented
293  TMergerInfo& operator=(const TMergerInfo&); // Not implemented
294 
295 public:
296  TMergerInfo(TSlave *t, Int_t port, Int_t forHowManyWorkers) :
297  fMerger(t), fPort(port), fMergedObjects(0), fWorkersToMerge(forHowManyWorkers),
298  fMergedWorkers(0), fWorkers(0), fIsActive(kTRUE) { }
299  virtual ~TMergerInfo();
300 
301  void AddWorker(TSlave *sl);
302  TList *GetWorkers() { return fWorkers; }
303 
304  TSlave *GetMerger() { return fMerger; }
305  Int_t GetPort() { return fPort; }
306 
307  Int_t GetWorkersToMerge() { return fWorkersToMerge; }
308  Int_t GetMergedWorkers() { return fMergedWorkers; }
309  Int_t GetMergedObjects() { return fMergedObjects; }
310 
311  void SetMergedWorker();
312  void AddMergedObjects(Int_t objects) { fMergedObjects += objects; }
313 
314  Bool_t AreAllWorkersAssigned();
315  Bool_t AreAllWorkersMerged();
316 
317  void Deactivate() { fIsActive = kFALSE; }
318  Bool_t IsActive() { return fIsActive; }
319 
320  ClassDef(TMergerInfo,0) // Basic info on merger, i.e. worker serving as merger
321 };
322 
323 // Small auxiliary class for merging progress notification
325 private:
330  static char fgCr[4];
331 public:
332  TProofMergePrg() : fExp(), fIdx(-1), fNWrks(-1), fLastNWrks(-1) { }
333 
334  const char *Export(Bool_t &changed) {
335  fExp.Form("%c (%d workers still sending) ", fgCr[fIdx], fNWrks);
336  changed = (fLastNWrks != fNWrks || fLastNWrks == -1) ? kTRUE : kFALSE;
337  fLastNWrks = fNWrks;
338  return fExp.Data(); }
339  void DecreaseNWrks() { fNWrks--; }
340  void IncreaseNWrks() { fNWrks++; }
341  void IncreaseIdx() { fIdx++; if (fIdx == 4) fIdx = 0; }
342  void Reset(Int_t n = -1) { fIdx = -1; SetNWrks(n); }
343  void SetNWrks(Int_t n) { fNWrks = n; }
344 };
345 
346 class TProof : public TNamed, public TQObject {
347 
348 friend class TPacketizer;
349 friend class TPacketizerDev;
350 friend class TPacketizerAdaptive;
351 friend class TProofLite;
352 friend class TDataSetManager;
353 friend class TProofServ;
354 friend class TProofInputHandler;
356 friend class TProofPlayer;
357 friend class TProofPlayerLite;
358 friend class TProofPlayerRemote;
359 friend class TProofProgressDialog;
360 friend class TSlave;
361 friend class TSlaveLite;
362 friend class TVirtualPacketizer;
363 friend class TXSlave;
364 friend class TXSocket; // to access kPing
365 friend class TXSocketHandler; // to access fCurrentMonitor and CollectInputFrom
366 friend class TXProofMgr; // to access EUrgent
367 friend class TXProofServ; // to access EUrgent
368 
369 public:
370  // PROOF status bits
371  enum EStatusBits {
372  kUsingSessionGui = BIT(14),
373  kNewInputData = BIT(15),
374  kIsClient = BIT(16),
375  kIsMaster = BIT(17),
376  kIsTopMaster = BIT(18),
377  kUseProgressDialog = BIT(19)
378  };
379  enum EQueryMode {
380  kSync = 0,
381  kAsync = 1
382  };
383  enum EUploadOpt {
384  kAppend = 0x1,
385  kOverwriteDataSet = 0x2,
386  kNoOverwriteDataSet = 0x4,
387  kOverwriteAllFiles = 0x8,
388  kOverwriteNoFiles = 0x10,
389  kAskUser = 0x0
390  };
392  kFailIfExists = 0,
393  kOverwriteIfExists = 1,
394  kMergeIfExists = 2
395  };
397  kUntar = 0x0, //Untar over existing dir [default]
398  kRemoveOld = 0x1 //Remove existing dir with same name
399  };
400  enum ERunStatus {
401  kRunning = 0, // Normal status
402  kStopped = 1, // After the stop button has been pressed
403  kAborted = 2 // After the abort button has been pressed
404  };
405 
406  enum ESubMerger {
407  kOutputSize = 1, //Number of objects in worker's output list
408  kSendOutput = 2, //Naster asks worker for its output list
409  kBeMerger = 3, //Master tells worker to be a merger
410  kMergerDown = 4, //Merger cannot serve
411  kStopMerging = 5, //Master tells worker to stop merging (and return output)
412  kOutputSent = 6 //Worker reports sending its output to given worker
413  };
414 
416  kPurge = 0x1,
417  kUnregistered = 0x2,
418  kDataset = 0x4,
419  kForceClear = 0x8
420  };
421 
422 private:
423  enum EUrgent {
424  kLocalInterrupt = -1,
425  kPing = 0,
426  kHardInterrupt = 1,
428  kShutdownInterrupt
429  };
431  kShowCache = 1,
432  kClearCache = 2,
433  kShowPackages = 3,
434  kClearPackages = 4,
435  kClearPackage = 5,
436  kBuildPackage = 6,
437  kLoadPackage = 7,
438  kShowEnabledPackages = 8,
439  kShowSubCache = 9,
440  kClearSubCache = 10,
441  kShowSubPackages = 11,
442  kDisableSubPackages = 12,
443  kDisableSubPackage = 13,
444  kBuildSubPackage = 14,
445  kUnloadPackage = 15,
446  kDisablePackage = 16,
447  kUnloadPackages = 17,
448  kDisablePackages = 18,
449  kListPackages = 19,
450  kListEnabledPackages = 20,
451  kLoadMacro = 21
452  };
454  kUploadDataSet = 1, //Upload a dataset
455  kCheckDataSetName = 2, //Check wheter dataset of this name exists
456  kGetDataSets = 3, //List datasets saved on the master node
457  kRegisterDataSet = 4, //Save a TList object as a dataset
458  kGetDataSet = 5, //Get a TFileCollection of TFileInfo objects
459  kVerifyDataSet = 6, //Try open all files from a dataset and report results
460  kRemoveDataSet = 7, //Remove a dataset but leave files belonging to it
461  kMergeDataSet = 8, //Add new files to an existing dataset
462  kShowDataSets = 9, //Shows datasets, returns formatted output
463  kGetQuota = 10, //Get quota info per group
464  kShowQuota = 11, //Show quotas
465  kSetDefaultTreeName = 12, //Set the default tree name
466  kCache = 13, //Show/clear cache
467  kRequestStaging = 14, //Request staging of a dataset
468  kStagingStatus = 15, //Obtain staging status for the given dataset
469  kCancelStaging = 16 //Cancels dataset staging request
470  };
472  kAscii = 0x0,
473  kBinary = 0x1,
474  kForce = 0x2,
475  kForward = 0x4,
476  kCpBin = 0x8,
477  kCp = 0x10
478  };
480  kActivateWorker = 1,
481  kDeactivateWorker = 2
482  };
484  kDontBuildOnClient = -2,
485  kBuildOnSlavesNoWait = -1,
486  kBuildAll = 0,
487  kCollectBuildResults = 1
488  };
490  kPerGroup = 0x1,
491  kPerUser = 0x2
492  };
493 
494  Bool_t fValid; //is this a valid proof object
495  Bool_t fTty; //TRUE if connected to a terminal
496  TString fMaster; //master server ("" if a master); used in the browser
497  TString fWorkDir; //current work directory on remote servers
498  TString fGroup; //PROOF group of this user
499  Int_t fLogLevel; //server debug logging level
500  Int_t fStatus; //remote return status (part of kPROOF_LOGDONE)
501  Int_t fCheckFileStatus; //remote return status after kPROOF_CHECKFILE
502  TList *fRecvMessages; //Messages received during collect not yet processed
503  TList *fSlaveInfo; //!list returned by kPROOF_GETSLAVEINFO
504  Bool_t fSendGroupView; //if true send new group view
505  Bool_t fIsPollingWorkers; //will be set to kFALSE to prevent recursive dyn workers check in dyn mode
506  Long64_t fLastPollWorkers_s; //timestamp (in seconds) of last poll for workers, -1 if never checked
507  TList *fActiveSlaves; //list of active slaves (subset of all slaves)
508  TString fActiveSlavesSaved;// comma-separated list of active slaves (before last call to
509  // SetParallel or Activate/DeactivateWorkers)
510  TList *fInactiveSlaves; //list of inactive slaves (good but not used for processing)
511  TList *fUniqueSlaves; //list of all active slaves with unique file systems
512  TList *fAllUniqueSlaves; //list of all active slaves with unique file systems, including all submasters
513  TList *fNonUniqueMasters; //list of all active masters with a nonunique file system
514  TMonitor *fActiveMonitor; //monitor activity on all active slave sockets
515  TMonitor *fUniqueMonitor; //monitor activity on all unique slave sockets
516  TMonitor *fAllUniqueMonitor; //monitor activity on all unique slave sockets, including all submasters
517  TMonitor *fCurrentMonitor; //currently active monitor
518  Long64_t fBytesRead; //bytes read by all slaves during the session
519  Float_t fRealTime; //realtime spent by all slaves during the session
520  Float_t fCpuTime; //CPU time spent by all slaves during the session
521  TSignalHandler *fIntHandler; //interrupt signal handler (ctrl-c)
522  TPluginHandler *fProgressDialog; //progress dialog plugin
523  Bool_t fProgressDialogStarted; //indicates if the progress dialog is up
524  TVirtualProofPlayer *fPlayer; //current player
525  TList *fFeedback; //list of names to be returned as feedback
526  TList *fChains; //chains with this proof set
527  struct MD5Mod_t {
528  TMD5 fMD5; //file's md5
529  Long_t fModtime; //file's modification time
530  };
531  typedef std::map<TString, MD5Mod_t> FileMap_t;
532  FileMap_t fFileMap; //map keeping track of a file's md5 and mod time
533  TDSet *fDSet; //current TDSet being validated
534 
535  Int_t fNotIdle; //Number of non-idle sub-nodes
536  Bool_t fSync; //true if type of currently processed query is sync
537  ERunStatus fRunStatus; //run status
538  Bool_t fIsWaiting; //true if queries have been enqueued
539 
540  Bool_t fRedirLog; //redirect received log info
541  TString fLogFileName; //name of the temp file for redirected logs
542  FILE *fLogFileW; //temp file to redirect logs
543  FILE *fLogFileR; //temp file to read redirected logs
544  Bool_t fLogToWindowOnly; //send log to window only
545 
546  Bool_t fSaveLogToMacro; // Whether to save received logs to TMacro fMacroLog (use with care)
547  TMacro fMacroLog; // Macro with the saved (last) log
548 
549  TProofMergePrg fMergePrg; //Merging progress
550 
551  TList *fWaitingSlaves; //stores a TPair of the slaves's TSocket and TMessage
552  TList *fQueries; //list of TProofQuery objects
553  Int_t fOtherQueries; //number of queries in list from previous sessions
554  Int_t fDrawQueries; //number of draw queries during this sessions
555  Int_t fMaxDrawQueries; //max number of draw queries kept
556  Int_t fSeqNum; //Remote sequential # of the last query submitted
557 
558  Int_t fSessionID; //remote ID of the session
559 
560  Bool_t fEndMaster; //true for a master in direct contact only with workers
561 
562  TPackMgr *fPackMgr; // Default package manager
563  TList *fEnabledPackagesOnCluster; //list of enabled packages
564 
565  TList *fInputData; //Input data objects sent over via file
566  TString fInputDataFile; //File with input data objects
567 
568  TProofOutputList fOutputList; // TList implementation filtering ls(...) and Print(...)
569 
570  PrintProgress_t fPrintProgress; //Function function to display progress info in batch mode
571 
572  std::recursive_mutex fCloseMutex; // Avoid crashes in MarkBad or alike while closing
573 
574  TList *fLoadedMacros; // List of loaded macros (just file names)
575  static TList *fgProofEnvList; // List of TNameds defining environment
576  // variables to pass to proofserv
577 
578  Bool_t fMergersSet; // Indicates, if the following variables have been initialized properly
579  Bool_t fMergersByHost; // Mergers assigned by host name
581  Int_t fWorkersToMerge; // Current total number of workers, which have not been yet assigned to any merger
586 
587  TString fPerfTree; // If non-null triggers saving of the performance info into fPerfTree
588 
589  TList *fWrksOutputReady; // List of workers ready to send output (in control output sending mode)
590 
591  static TPluginHandler *fgLogViewer; // Log dialog box plugin
592 
593 protected:
594  enum ESlaves { kAll, kActive, kUnique, kAllUnique };
595 
596  Bool_t fMasterServ; //true if we are a master server
597  TUrl fUrl; //Url of the master
598  TString fConfFile; //file containing config information
599  TString fConfDir; //directory containing cluster config information
600  TString fImage; //master's image name
601  Int_t fProtocol; //remote PROOF server protocol version number
602  TList *fSlaves; //list of all slave servers as in config file
603  TList *fTerminatedSlaveInfos; //list of unique infos of terminated slaves
604  TList *fBadSlaves; //dead slaves (subset of all slaves)
605  TMonitor *fAllMonitor; //monitor activity on all valid slave sockets
606  Bool_t fDataReady; //true if data is ready to be analyzed
607  Long64_t fBytesReady; //number of bytes staged
608  Long64_t fTotalBytes; //number of bytes to be analyzed
609  TList *fAvailablePackages; //list of available packages
610  TList *fEnabledPackages; //list of enabled packages
611  TList *fRunningDSets; // Temporary datasets used for async running
612 
613  Int_t fCollectTimeout; // Timeout for (some) collect actions
614 
615  TString fDataPoolUrl; // default data pool entry point URL
616  TProofMgr::EServType fServType; // type of server: proofd, XrdProofd
617  TProofMgr *fManager; // manager to which this session belongs (if any)
618  EQueryMode fQueryMode; // default query mode
619  Bool_t fDynamicStartup; // are the workers started dynamically?
620 
621  TSelector *fSelector; // Selector to be processed, if any
622 
623  TStopwatch fQuerySTW; // Stopwatch to measure query times
624  Float_t fPrepTime; // Preparation time
625 
626 private:
627  TProof(const TProof &); // not implemented
628  void operator=(const TProof &); // idem
629 
630  void CleanGDirectory(TList *ol);
631 
632  Int_t Exec(const char *cmd, ESlaves list, Bool_t plusMaster);
633  Int_t SendCommand(const char *cmd, ESlaves list = kActive);
634  Int_t SendCurrentState(ESlaves list = kActive);
635  Int_t SendCurrentState(TList *list);
636  Bool_t CheckFile(const char *file, TSlave *sl, Long_t modtime, Int_t cpopt = (kCp | kCpBin));
637  Int_t SendObject(const TObject *obj, ESlaves list = kActive);
638  Int_t SendGroupView();
639  Int_t SendInitialState();
640  Int_t SendPrint(Option_t *option="");
641  Int_t Ping(ESlaves list);
642  void Interrupt(EUrgent type, ESlaves list = kActive);
643  void AskStatistics();
644  void AskParallel();
645  Int_t GoParallel(Int_t nodes, Bool_t accept = kFALSE, Bool_t random = kFALSE);
646  Int_t GoMoreParallel(Int_t nWorkersToAdd);
647  Int_t SetParallelSilent(Int_t nodes, Bool_t random = kFALSE);
648  void RecvLogFile(TSocket *s, Int_t size);
649  void NotifyLogMsg(const char *msg, const char *sfx = "\n");
650 
651  Int_t BuildPackage(const char *package, EBuildPackageOpt opt = kBuildAll, Int_t chkveropt = TPackMgr::kCheckROOT, TList *workers = 0);
652  Int_t LoadPackage(const char *package, Bool_t notOnClient = kFALSE, TList *loadopts = 0, TList *workers = 0);
653  Int_t UnloadPackage(const char *package);
654  Int_t UnloadPackages();
655  Int_t DisablePackage(const char *package);
656  Int_t DisablePackages();
657 
658  void Activate(TList *slaves = 0);
659  Int_t Broadcast(const TMessage &mess, TList *slaves);
660  Int_t Broadcast(const TMessage &mess, ESlaves list = kActive);
661  Int_t Broadcast(const char *mess, Int_t kind, TList *slaves);
662  Int_t Broadcast(const char *mess, Int_t kind = kMESS_STRING, ESlaves list = kActive);
663  Int_t Broadcast(Int_t kind, TList *slaves) { return Broadcast(0, kind, slaves); }
664  Int_t Broadcast(Int_t kind, ESlaves list = kActive) { return Broadcast(0, kind, list); }
665  Int_t BroadcastFile(const char *file, Int_t opt, const char *rfile, TList *wrks);
666  Int_t BroadcastFile(const char *file, Int_t opt, const char *rfile = 0, ESlaves list = kAllUnique);
667  Int_t BroadcastGroupPriority(const char *grp, Int_t priority, ESlaves list = kAllUnique);
668  Int_t BroadcastGroupPriority(const char *grp, Int_t priority, TList *workers);
669  Int_t BroadcastObject(const TObject *obj, Int_t kind, TList *slaves);
670  Int_t BroadcastObject(const TObject *obj, Int_t kind = kMESS_OBJECT, ESlaves list = kActive);
671  Int_t BroadcastRaw(const void *buffer, Int_t length, TList *slaves);
672  Int_t BroadcastRaw(const void *buffer, Int_t length, ESlaves list = kActive);
673  Int_t Collect(const TSlave *sl, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE);
674  Int_t Collect(TMonitor *mon, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE);
675  Int_t CollectInputFrom(TSocket *s, Int_t endtype = -1, Bool_t deactonfail = kFALSE);
676  Int_t HandleInputMessage(TSlave *wrk, TMessage *m, Bool_t deactonfail = kFALSE);
677  void HandleSubmerger(TMessage *mess, TSlave *sl);
678  void SetMonitor(TMonitor *mon = 0, Bool_t on = kTRUE);
679 
680  void ReleaseMonitor(TMonitor *mon);
681 
682  virtual void FindUniqueSlaves();
683  TSlave *FindSlave(TSocket *s) const;
684  TList *GetListOfSlaves() const { return fSlaves; }
685  TList *GetListOfInactiveSlaves() const { return fInactiveSlaves; }
686  TList *GetListOfUniqueSlaves() const { return fUniqueSlaves; }
687  TList *GetListOfBadSlaves() const { return fBadSlaves; }
688  Int_t GetNumberOfSlaves() const;
689  Int_t GetNumberOfActiveSlaves() const;
690  Int_t GetNumberOfInactiveSlaves() const;
691  Int_t GetNumberOfUniqueSlaves() const;
692  Int_t GetNumberOfBadSlaves() const;
693 
694  Bool_t IsEndMaster() const { return fEndMaster; }
695  Int_t ModifyWorkerLists(const char *ord, Bool_t add, Bool_t save);
696  Int_t RestoreActiveList();
697  void SaveActiveList();
698 
699  Bool_t IsSync() const { return fSync; }
700  void InterruptCurrentMonitor();
701 
702  void SetRunStatus(ERunStatus rst) { fRunStatus = rst; }
703 
704  void MarkBad(TSlave *wrk, const char *reason = 0);
705  void MarkBad(TSocket *s, const char *reason = 0);
706  void TerminateWorker(TSlave *wrk);
707  void TerminateWorker(const char *ord);
708 
709  void ActivateAsyncInput();
710  void DeActivateAsyncInput();
711 
712  Int_t GetQueryReference(Int_t qry, TString &ref);
713  void PrintProgress(Long64_t total, Long64_t processed,
714  Float_t procTime = -1., Long64_t bytesread = -1);
715 
716  // Managing mergers
717  Bool_t CreateMerger(TSlave *sl, Int_t port);
718  void RedirectWorker(TSocket *s, TSlave * sl, Int_t output_size);
719  Int_t GetActiveMergersCount();
720  Int_t FindNextFreeMerger();
721  void ResetMergers() { fMergersSet = kFALSE; }
722  void AskForOutput(TSlave *sl);
723 
724  void FinalizationDone() { fFinalizationRunning = kFALSE; }
725 
726  void ResetMergePrg();
727  void ParseConfigField(const char *config);
728 
729  Bool_t Prompt(const char *p);
730  void ClearDataProgress(Int_t r, Int_t t);
731 
732  static TList *GetDataSetSrvMaps(const TString &srvmaps);
733 
734 protected:
735  TProof(); // For derived classes to use
736  void InitMembers();
737  Int_t Init(const char *masterurl, const char *conffile,
738  const char *confdir, Int_t loglevel,
739  const char *alias = 0);
740  virtual Bool_t StartSlaves(Bool_t attach = kFALSE);
741  Int_t AddWorkers(TList *wrks);
742  Int_t RemoveWorkers(TList *wrks);
743  void SetupWorkersEnv(TList *wrks, Bool_t increasingpool = kFALSE);
744 
745  void SetPlayer(TVirtualProofPlayer *player);
746  TVirtualProofPlayer *GetPlayer() const { return fPlayer; }
747  virtual TVirtualProofPlayer *MakePlayer(const char *player = 0, TSocket *s = 0);
748 
749  void UpdateDialog();
750 
751  void HandleLibIncPath(const char *what, Bool_t add, const char *dirs);
752 
753  TList *GetListOfActiveSlaves() const { return fActiveSlaves; }
754  TSlave *CreateSlave(const char *url, const char *ord,
755  Int_t perf, const char *image, const char *workdir);
756  TSlave *CreateSubmaster(const char *url, const char *ord,
757  const char *image, const char *msd, Int_t nwk = 1);
758 
759  virtual Int_t PollForNewWorkers();
760  virtual void SaveWorkerInfo();
761 
762  Int_t Collect(ESlaves list = kActive, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE);
763  Int_t Collect(TList *slaves, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE);
764 
765  TList *GetEnabledPackages() const { return fEnabledPackagesOnCluster; }
766 
767  void SetDSet(TDSet *dset) { fDSet = dset; }
768  virtual void ValidateDSet(TDSet *dset);
769 
770  Int_t VerifyDataSetParallel(const char *uri, const char *optStr);
771 
772  TPluginHandler *GetProgressDialog() const { return fProgressDialog; }
773 
774  Int_t AssertPath(const char *path, Bool_t writable);
775  Int_t GetSandbox(TString &sb, Bool_t assert = kFALSE, const char *rc = 0);
776 
777  void PrepareInputDataFile(TString &dataFile);
778  virtual void SendInputDataFile();
779  Int_t SendFile(const char *file, Int_t opt = (kBinary | kForward | kCp | kCpBin),
780  const char *rfile = 0, TSlave *sl = 0);
781 
782  // Fast enable/disable feedback from Process
783  void SetFeedback(TString &opt, TString &optfb, Int_t action);
784  // Output file handling during Process
785  Int_t HandleOutputOptions(TString &opt, TString &target, Int_t action);
786 
787  static void *SlaveStartupThread(void *arg);
788 
789  static Int_t AssertDataSet(TDSet *dset, TList *input,
790  TDataSetManager *mgr, TString &emsg);
791  static void AssertMacroPath(const char *macro);
792 
793  // Input data handling
794  static Int_t GetInputData(TList *input, const char *cachedir, TString &emsg);
795  static Int_t SaveInputData(TQueryResult *qr, const char *cachedir, TString &emsg);
796  static Int_t SendInputData(TQueryResult *qr, TProof *p, TString &emsg);
797 
798  // Parse CINT commands
799  static Bool_t GetFileInCmd(const char *cmd, TString &fn);
800 
801  // Pipe execution of commands
802  static void SystemCmd(const char *cmd, Int_t fdout);
803 
804 public:
805  TProof(const char *masterurl, const char *conffile = kPROOF_ConfFile,
806  const char *confdir = kPROOF_ConfDir, Int_t loglevel = 0,
807  const char *alias = 0, TProofMgr *mgr = 0);
808  virtual ~TProof();
809 
810  void cd(Int_t id = -1);
811 
812  Int_t Ping();
813  void Touch();
814  Int_t Exec(const char *cmd, Bool_t plusMaster = kFALSE);
815  Int_t Exec(const char *cmd, const char *ord, Bool_t logtomacro = kFALSE);
816 
817  TString Getenv(const char *env, const char *ord = "0");
818  Int_t GetRC(const char *RCenv, Int_t &env, const char *ord = "0");
819  Int_t GetRC(const char *RCenv, Double_t &env, const char *ord = "0");
820  Int_t GetRC(const char *RCenv, TString &env, const char *ord = "0");
821 
822  virtual Long64_t Process(TDSet *dset, const char *selector,
823  Option_t *option = "", Long64_t nentries = -1,
824  Long64_t firstentry = 0);
825  virtual Long64_t Process(TFileCollection *fc, const char *selector,
826  Option_t *option = "", Long64_t nentries = -1,
827  Long64_t firstentry = 0);
828  virtual Long64_t Process(const char *dsetname, const char *selector,
829  Option_t *option = "", Long64_t nentries = -1,
830  Long64_t firstentry = 0, TObject *enl = 0);
831  virtual Long64_t Process(const char *selector, Long64_t nentries,
832  Option_t *option = "");
833  // Process via TSelector
834  virtual Long64_t Process(TDSet *dset, TSelector *selector,
835  Option_t *option = "", Long64_t nentries = -1,
836  Long64_t firstentry = 0);
837  virtual Long64_t Process(TFileCollection *fc, TSelector *selector,
838  Option_t *option = "", Long64_t nentries = -1,
839  Long64_t firstentry = 0);
840  virtual Long64_t Process(const char *dsetname, TSelector *selector,
841  Option_t *option = "", Long64_t nentries = -1,
842  Long64_t firstentry = 0, TObject *enl = 0);
843  virtual Long64_t Process(TSelector *selector, Long64_t nentries,
844  Option_t *option = "");
845 
846  virtual Long64_t DrawSelect(TDSet *dset, const char *varexp,
847  const char *selection = "",
848  Option_t *option = "", Long64_t nentries = -1,
849  Long64_t firstentry = 0);
850  Long64_t DrawSelect(const char *dsetname, const char *varexp,
851  const char *selection = "",
852  Option_t *option = "", Long64_t nentries = -1,
853  Long64_t firstentry = 0, TObject *enl = 0);
854  Int_t Archive(Int_t query, const char *url);
855  Int_t Archive(const char *queryref, const char *url = 0);
856  Int_t CleanupSession(const char *sessiontag);
857  Long64_t Finalize(Int_t query = -1, Bool_t force = kFALSE);
858  Long64_t Finalize(const char *queryref, Bool_t force = kFALSE);
859  Int_t Remove(Int_t query, Bool_t all = kFALSE);
860  Int_t Remove(const char *queryref, Bool_t all = kFALSE);
861  Int_t Retrieve(Int_t query, const char *path = 0);
862  Int_t Retrieve(const char *queryref, const char *path = 0);
863 
864  void DisableGoAsyn();
865  void GoAsynchronous();
866  void StopProcess(Bool_t abort, Int_t timeout = -1);
867  void Browse(TBrowser *b);
868 
869  virtual Int_t Echo(const TObject *obj);
870  virtual Int_t Echo(const char *str);
871 
872  Int_t SetParallel(Int_t nodes = -1, Bool_t random = kFALSE);
873  void SetLogLevel(Int_t level, UInt_t mask = TProofDebug::kAll);
874 
875  void Close(Option_t *option="");
876  virtual void Print(Option_t *option="") const;
877 
878  //-- cache and package management
879  virtual void ShowCache(Bool_t all = kFALSE);
880  virtual void ClearCache(const char *file = 0);
881  TList *GetListOfPackages();
882  TList *GetListOfEnabledPackages();
883  void ShowPackages(Bool_t all = kFALSE, Bool_t redirlog = kFALSE);
884  void ShowEnabledPackages(Bool_t all = kFALSE);
885  Int_t ClearPackages();
886  Int_t ClearPackage(const char *package);
887  Int_t DownloadPackage(const char *par, const char *dstdir = 0);
888  Int_t EnablePackage(const char *package, Bool_t notOnClient = kFALSE, TList *workers = 0);
889  Int_t EnablePackage(const char *package, const char *loadopts,
890  Bool_t notOnClient = kFALSE, TList *workers = 0);
891  Int_t EnablePackage(const char *package, TList *loadopts,
892  Bool_t notOnClient = kFALSE, TList *workers = 0);
893  Int_t UploadPackage(const char *par, EUploadPackageOpt opt = kUntar, TList *workers = 0);
894  virtual Int_t Load(const char *macro, Bool_t notOnClient = kFALSE, Bool_t uniqueOnly = kTRUE,
895  TList *wrks = 0);
896 
897  Int_t AddDynamicPath(const char *libpath, Bool_t onClient = kFALSE, TList *wrks = 0, Bool_t doCollect = kTRUE);
898  Int_t AddIncludePath(const char *incpath, Bool_t onClient = kFALSE, TList *wrks = 0, Bool_t doCollect = kTRUE);
899  Int_t RemoveDynamicPath(const char *libpath, Bool_t onClient = kFALSE);
900  Int_t RemoveIncludePath(const char *incpath, Bool_t onClient = kFALSE);
901 
902  //-- dataset management
903  Int_t UploadDataSet(const char *, TList *, const char * = 0, Int_t = 0, TList * = 0);
904  Int_t UploadDataSet(const char *, const char *, const char * = 0, Int_t = 0, TList * = 0);
905  Int_t UploadDataSetFromFile(const char *, const char *, const char * = 0, Int_t = 0, TList * = 0);
906  virtual Bool_t RegisterDataSet(const char *name,
907  TFileCollection *dataset, const char* optStr = "");
908  virtual TMap *GetDataSets(const char *uri = "", const char* optStr = "");
909  virtual void ShowDataSets(const char *uri = "", const char* optStr = "");
910 
911  TMap *GetDataSetQuota(const char* optStr = "");
912  void ShowDataSetQuota(Option_t* opt = 0);
913 
914  virtual Bool_t ExistsDataSet(const char *dataset);
915  void ShowDataSet(const char *dataset = "", const char* opt = "filter:SsCc");
916  virtual Int_t RemoveDataSet(const char *dataset, const char* optStr = "");
917  virtual Int_t VerifyDataSet(const char *dataset, const char* optStr = "");
918  virtual TFileCollection *GetDataSet(const char *dataset, const char* optStr = "");
919  TList *FindDataSets(const char *searchString, const char* optStr = "");
920  virtual Bool_t RequestStagingDataSet(const char *dataset);
921  virtual TFileCollection *GetStagingStatusDataSet(const char *dataset);
922  virtual void ShowStagingStatusDataSet(const char *dataset, const char *optStr = "filter:SsCc");
923  virtual Bool_t CancelStagingDataSet(const char *dataset);
924 
925  virtual Int_t SetDataSetTreeName( const char *dataset, const char *treename);
926 
927  virtual void ShowDataSetCache(const char *dataset = 0);
928  virtual void ClearDataSetCache(const char *dataset = 0);
929 
930  virtual void ShowData();
931  void ClearData(UInt_t what = kUnregistered, const char *dsname = 0);
932 
933  const char *GetMaster() const { return fMaster; }
934  const char *GetConfDir() const { return fConfDir; }
935  const char *GetConfFile() const { return fConfFile; }
936  const char *GetUser() const { return fUrl.GetUser(); }
937  const char *GetGroup() const { return fGroup; }
938  const char *GetWorkDir() const { return fWorkDir; }
939  const char *GetSessionTag() const { return GetName(); }
940  const char *GetImage() const { return fImage; }
941  const char *GetUrl() { return fUrl.GetUrl(); }
942  Int_t GetPort() const { return fUrl.GetPort(); }
943  Int_t GetRemoteProtocol() const { return fProtocol; }
945  Int_t GetStatus() const { return fStatus; }
946  Int_t GetLogLevel() const { return fLogLevel; }
947  Int_t GetParallel() const;
948  Int_t GetSeqNum() const { return fSeqNum; }
949  Int_t GetSessionID() const { return fSessionID; }
950  TList *GetListOfSlaveInfos();
951  Bool_t UseDynamicStartup() const { return fDynamicStartup; }
952 
953  EQueryMode GetQueryMode(Option_t *mode = 0) const;
954  void SetQueryMode(EQueryMode mode);
955 
956  void SetRealTimeLog(Bool_t on = kTRUE);
957 
958  void GetStatistics(Bool_t verbose = kFALSE);
959  Long64_t GetBytesRead() const { return fBytesRead; }
960  Float_t GetRealTime() const { return fRealTime; }
961  Float_t GetCpuTime() const { return fCpuTime; }
962 
963  Bool_t IsLite() const { return (fServType == TProofMgr::kProofLite) ? kTRUE : kFALSE; }
964  Bool_t IsProofd() const { return (fServType == TProofMgr::kProofd) ? kTRUE : kFALSE; }
965  Bool_t IsFolder() const { return kTRUE; }
966  Bool_t IsMaster() const { return fMasterServ; }
967  Bool_t IsValid() const { return fValid; }
968  Bool_t IsTty() const { return fTty; }
969  Bool_t IsParallel() const { return GetParallel() > 0 ? kTRUE : kFALSE; }
970  Bool_t IsIdle() const { return (fNotIdle <= 0) ? kTRUE : kFALSE; }
971  Bool_t IsWaiting() const { return fIsWaiting; }
972 
973  ERunStatus GetRunStatus() const { return fRunStatus; }
974  TList *GetLoadedMacros() const { return fLoadedMacros; }
975 
976  //-- input list parameter handling
977  void SetParameter(const char *par, const char *value);
978  void SetParameter(const char *par, Int_t value);
979  void SetParameter(const char *par, Long_t value);
980  void SetParameter(const char *par, Long64_t value);
981  void SetParameter(const char *par, Double_t value);
982  TObject *GetParameter(const char *par) const;
983  void DeleteParameters(const char *wildcard);
984  void ShowParameters(const char *wildcard = "PROOF_*") const;
985 
986  void AddInput(TObject *obj);
987  void ClearInput();
988  TList *GetInputList();
989  TObject *GetOutput(const char *name);
990  TList *GetOutputList();
991  static TObject *GetOutput(const char *name, TList *out);
992 
993  void ShowMissingFiles(TQueryResult *qr = 0);
994  TFileCollection *GetMissingFiles(TQueryResult *qr = 0);
995 
996  void AddInputData(TObject *obj, Bool_t push = kFALSE);
997  void SetInputDataFile(const char *datafile);
998  void ClearInputData(TObject *obj = 0);
999  void ClearInputData(const char *name);
1000 
1001  void AddFeedback(const char *name);
1002  void RemoveFeedback(const char *name);
1003  void ClearFeedback();
1004  void ShowFeedback() const;
1005  TList *GetFeedbackList() const;
1006 
1007  virtual TList *GetListOfQueries(Option_t *opt = "");
1008  Int_t GetNumberOfQueries();
1009  Int_t GetNumberOfDrawQueries() { return fDrawQueries; }
1010  TList *GetQueryResults();
1011  TQueryResult *GetQueryResult(const char *ref = 0);
1012  void GetMaxQueries();
1013  void SetMaxDrawQueries(Int_t max);
1014  void ShowQueries(Option_t *opt = "");
1015 
1016  Bool_t IsDataReady(Long64_t &totalbytes, Long64_t &bytesready);
1017 
1018  void SetActive(Bool_t /*active*/ = kTRUE) { }
1019 
1020  void LogMessage(const char *msg, Bool_t all); //*SIGNAL*
1021  void Progress(Long64_t total, Long64_t processed); //*SIGNAL*
1022  void Progress(Long64_t total, Long64_t processed, Long64_t bytesread,
1023  Float_t initTime, Float_t procTime,
1024  Float_t evtrti, Float_t mbrti); // *SIGNAL*
1025  void Progress(Long64_t total, Long64_t processed, Long64_t bytesread,
1026  Float_t initTime, Float_t procTime,
1027  Float_t evtrti, Float_t mbrti,
1028  Int_t actw, Int_t tses, Float_t eses); // *SIGNAL*
1029  void Feedback(TList *objs); //*SIGNAL*
1030  void QueryResultReady(const char *ref); //*SIGNAL*
1031  void CloseProgressDialog(); //*SIGNAL*
1032  void ResetProgressDialog(const char *sel, Int_t sz,
1033  Long64_t fst, Long64_t ent); //*SIGNAL*
1034  void StartupMessage(const char *msg, Bool_t status, Int_t done,
1035  Int_t total); //*SIGNAL*
1036  void DataSetStatus(const char *msg, Bool_t status,
1037  Int_t done, Int_t total); //*SIGNAL*
1038 
1039  void SendDataSetStatus(const char *msg, UInt_t n, UInt_t tot, Bool_t st);
1040 
1041  void GetLog(Int_t start = -1, Int_t end = -1);
1042  TMacro *GetLastLog();
1043  void PutLog(TQueryResult *qr);
1044  void ShowLog(Int_t qry = -1);
1045  void ShowLog(const char *queryref);
1046  Bool_t SendingLogToWindow() const { return fLogToWindowOnly; }
1047  void SendLogToWindow(Bool_t mode) { fLogToWindowOnly = mode; }
1048 
1049  TMacro *GetMacroLog() { return &fMacroLog; }
1050 
1051  void ResetProgressDialogStatus() { fProgressDialogStarted = kFALSE; }
1052 
1053  virtual TTree *GetTreeHeader(TDSet *tdset);
1054  TList *GetOutputNames();
1055 
1056  void AddChain(TChain *chain);
1057  void RemoveChain(TChain *chain);
1058 
1059  TDrawFeedback *CreateDrawFeedback();
1060  void SetDrawFeedbackOption(TDrawFeedback *f, Option_t *opt);
1061  void DeleteDrawFeedback(TDrawFeedback *f);
1062 
1063  void Detach(Option_t *opt = "");
1064 
1065  virtual void SetAlias(const char *alias="");
1066 
1067  TProofMgr *GetManager() { return fManager; }
1068  void SetManager(TProofMgr *mgr);
1069 
1070  Int_t ActivateWorker(const char *ord, Bool_t save = kTRUE);
1071  Int_t DeactivateWorker(const char *ord, Bool_t save = kTRUE);
1072 
1073  const char *GetDataPoolUrl() const { return fManager ? fManager->GetMssUrl() : 0; }
1074  void SetDataPoolUrl(const char *url) { if (fManager) fManager->SetMssUrl(url); }
1075 
1076  void SetPrintProgress(PrintProgress_t pp) { fPrintProgress = pp; }
1077 
1078  void SetProgressDialog(Bool_t on = kTRUE);
1079 
1080  // Enable the performance tree
1081  Int_t SavePerfTree(const char *pf = 0, const char *qref = 0);
1082  void SetPerfTree(const char *pf = "perftree.root", Bool_t withWrks = kFALSE);
1083 
1084  // Opening and managing PROOF connections
1085  static TProof *Open(const char *url = 0, const char *conffile = 0,
1086  const char *confdir = 0, Int_t loglevel = 0);
1087  static void LogViewer(const char *url = 0, Int_t sessionidx = 0);
1088  static TProofMgr *Mgr(const char *url);
1089  static void Reset(const char *url, Bool_t hard = kFALSE);
1090 
1091  static void AddEnvVar(const char *name, const char *value);
1092  static void DelEnvVar(const char *name);
1093  static const TList *GetEnvVars();
1094  static void ResetEnvVars();
1095 
1096  // Input/output list utilities
1097  static Int_t GetParameter(TCollection *c, const char *par, TString &value);
1098  static Int_t GetParameter(TCollection *c, const char *par, Int_t &value);
1099  static Int_t GetParameter(TCollection *c, const char *par, Long_t &value);
1100  static Int_t GetParameter(TCollection *c, const char *par, Long64_t &value);
1101  static Int_t GetParameter(TCollection *c, const char *par, Double_t &value);
1102 
1103  ClassDef(TProof,0) //PROOF control class
1104 };
1105 
1106 // Global object with default PROOF session
1108 
1109 #endif
Int_t fTotSessions
Definition: TProof.h:201
std::map< TString, MD5Mod_t > FileMap_t
Definition: TProof.h:531
const Int_t kPROOF_Port
Definition: TProof.h:151
std::string GetName(const std::string &scope_name)
Definition: Cppyy.cxx:140
Long64_t fTotal
Definition: TProof.h:193
void(* PrintProgress_t)(Long64_t tot, Long64_t proc, Float_t proctime, Long64_t bytes)
Definition: TProof.h:188
double par[1]
Definition: unuranDistr.cxx:38
This class starts a PROOF session on the local machine: no daemons, client and master merged...
Definition: TProofLite.h:42
const Long64_t kPROOF_DynWrkPollInt_s
Definition: TProof.h:168
TMap * GetDataSets(const char *owner="", const char *server="", const char *opt=0)
GetDataSets wrapper.
TList * GetListOfBadSlaves() const
Definition: TProof.h:687
The PROOF package manager contains tools to manage packages.
Definition: TPackMgr.h:47
TString fPerfTree
Definition: TProof.h:587
const char *const kGUNZIP
Definition: TProof.h:177
const char * GetName() const
Returns name of object.
Definition: TProof.h:261
Long64_t GetBytesRead() const
Definition: TProof.h:959
Bool_t fIsWaiting
Definition: TProof.h:538
EProofDataSetCommands
Definition: TProof.h:453
Internal class steering processing in PROOF.
Definition: TProofPlayer.h:78
TMonitor * fAllUniqueMonitor
Definition: TProof.h:516
long long Long64_t
Definition: RtypesCore.h:69
void FinalizationDone()
Definition: TProof.h:724
TString fConfDir
Definition: TProof.h:599
EUrgent
Definition: TProof.h:423
ERunStatus
Definition: TProof.h:400
Int_t GetPort() const
Definition: TProof.h:942
const char *const kCP
Definition: TProof.h:171
const char *const kLS
Definition: TProof.h:173
Int_t fOtherQueries
Definition: TProof.h:553
float Float_t
Definition: RtypesCore.h:53
Long64_t fBytesRead
Definition: TProof.h:195
Int_t fWorkersToMerge
Definition: TProof.h:581
return c
Float_t fCpuTime
Definition: TProof.h:520
const char Option_t
Definition: RtypesCore.h:62
Bool_t fSync
Definition: TProof.h:536
Bool_t IsFolder() const
Returns kTRUE in case object contains browsable objects (like containers or lists of other objects)...
Definition: TProof.h:965
TList * fWrksOutputReady
Definition: TProof.h:589
This class represents a WWW compatible URL.
Definition: TUrl.h:41
Bool_t fMergersSet
Definition: TProof.h:578
Int_t fMergedWorkers
Definition: TProof.h:286
TList * GetWorkers()
Definition: TProof.h:302
This class implements a data set to be used for PROOF processing.
Definition: TDSet.h:153
TProofMgr * GetManager()
Definition: TProof.h:1067
#define BIT(n)
Definition: Rtypes.h:120
TSlave * GetMerger()
Definition: TProof.h:304
Int_t GetStatus() const
Definition: TProof.h:945
The PROOF manager interacts with the PROOF server coordinator to create or destroy a PROOF session...
Definition: TProofMgr.h:53
const char *const kPROOF_WorkDir
Definition: TProof.h:154
TList * fAllUniqueSlaves
Definition: TProof.h:512
TString fImage
Definition: TProof.h:600
Int_t Broadcast(Int_t kind, TList *slaves)
Definition: TProof.h:663
This is the ROOT implementation of the Qt object communication mechanism (see also http://www...
Definition: TQObject.h:53
const char * GetOrdinal() const
Definition: TProof.h:262
TString fLogFileName
Definition: TProof.h:541
Int_t fPerfIndex
Definition: TProof.h:250
TList * GetListOfInactiveSlaves() const
Definition: TProof.h:685
Class supporting a collection of lines with C++ code.
Definition: TMacro.h:33
Float_t fEvtRateI
Definition: TProof.h:198
TList * GetListOfSlaves() const
Definition: TProof.h:684
TList * fQueries
Definition: TProof.h:552
Basic string class.
Definition: TString.h:137
void SetDSet(TDSet *dset)
Definition: TProof.h:767
Int_t GetClientProtocol() const
Definition: TProof.h:944
TString fGroup
Definition: TProof.h:498
TString fDataDir
Definition: TProof.h:249
Version of TSlave for local worker servers.
Definition: TSlaveLite.h:33
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
TList * fUniqueSlaves
Definition: TProof.h:511
const Bool_t kFALSE
Definition: Rtypes.h:92
Bool_t IsMaster() const
Definition: TProof.h:966
TList * fWaitingSlaves
Definition: TProof.h:551
const char *const kRM
Definition: TProof.h:172
const char *const kPROOF_PackageLockFile
Definition: TProof.h:162
TMacro * GetMacroLog()
Definition: TProof.h:1049
TSlave * fMerger
Definition: TProof.h:280
const char * GetConfFile() const
Definition: TProof.h:935
STL namespace.
void ResetMergers()
Definition: TProof.h:721
Int_t VerifyDataSet(const char *dsname, const char *opt=0, const char *redir=0)
VerifyDataSet wrapper.
static TPluginHandler * fgLogViewer
Definition: TProof.h:591
Float_t fRealTime
Definition: TProof.h:519
TString fHostName
Definition: TProof.h:247
This is the version of TSlave for workers servers based on XProofD.
Definition: TXSlave.h:36
Bool_t UseDynamicStartup() const
Definition: TProof.h:951
Int_t fWorkersToMerge
Definition: TProof.h:284
Int_t GetWorkersToMerge()
Definition: TProof.h:307
const char * GetDataPoolUrl() const
Definition: TProof.h:1073
TDSet * fDSet
Definition: TProof.h:533
Int_t fActWorkers
Definition: TProof.h:200
TList * fInputData
Definition: TProof.h:565
const char *const kPROOF_PackDownloadDir
Definition: TProof.h:157
void Reset(Int_t n=-1)
Definition: TProof.h:342
TVirtualProofPlayer * fPlayer
Definition: TProof.h:524
Bool_t IsLite() const
Definition: TProof.h:963
TList * fWorkers
Definition: TProof.h:289
const char * GetUrl(Bool_t withDeflt=kFALSE) const
Return full URL.
Definition: TUrl.cxx:387
Int_t GetSessionID() const
Definition: TProof.h:949
EQueryMode
Definition: TProof.h:379
EUploadPackageOpt
Definition: TProof.h:396
Bool_t fMasterServ
Definition: TProof.h:596
Bool_t fFinalizationRunning
Definition: TProof.h:584
This class generates packets to be processed on PROOF worker servers.
Definition: TPacketizer.h:41
const char * GetConfDir() const
Definition: TProof.h:934
Int_t GetMergedObjects()
Definition: TProof.h:309
TSignalHandler * fIntHandler
Definition: TProof.h:521
Int_t fDrawQueries
Definition: TProof.h:554
TString fDataPoolUrl
Definition: TProof.h:615
void AddMergedObjects(Int_t objects)
Definition: TProof.h:312
TList * fChains
Definition: TProof.h:526
static struct mg_connection * fc(struct mg_context *ctx)
Definition: civetweb.c:1956
Bool_t SendingLogToWindow() const
Definition: TProof.h:1046
TPluginHandler * fProgressDialog
Definition: TProof.h:522
TList * fBadSlaves
Definition: TProof.h:604
Int_t fLastAssignedMerger
Definition: TProof.h:582
Bool_t fSendGroupView
list returned by kPROOF_GETSLAVEINFO
Definition: TProof.h:504
const char * Export(Bool_t &changed)
Definition: TProof.h:334
EProofWrkListAction
Definition: TProof.h:479
#define ClassDef(name, id)
Definition: Rtypes.h:254
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
Definition: THashList.h:36
EProofCacheCommands
Definition: TProof.h:430
This code implements the MD5 message-digest algorithm.
Definition: TMD5.h:46
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:33
Int_t GetLogLevel() const
Definition: TProof.h:946
const char *const kPROOF_QueryDir
Definition: TProof.h:158
TString fOrdinal
Definition: TProof.h:246
Int_t fRedirectNext
Definition: TProof.h:585
Bool_t IsEndMaster() const
Definition: TProof.h:694
void Init(TClassEdit::TInterpreterLookupHelper *helper)
Definition: TClassEdit.cxx:119
const char *const kPROOF_WorkerIdleTO
Definition: TProof.h:165
const char * GetGroup() const
Definition: TProof.h:937
TProofInterruptHandler(TProof *p)
Definition: TProof.h:222
const char * GetWorkDir() const
Definition: TProof.h:938
Bool_t IsSync() const
Definition: TProof.h:699
void Deactivate()
Definition: TProof.h:317
EProofShowQuotaOpt
Definition: TProof.h:489
TString fConfFile
Definition: TProof.h:598
ESlaveStatus fStatus
Definition: TProof.h:252
const char * GetSessionTag() const
Definition: TProof.h:939
TList * fSlaves
Definition: TProof.h:602
Int_t fNotIdle
Definition: TProof.h:535
TProofMergePrg()
Definition: TProof.h:332
Int_t fMergedObjects
Definition: TProof.h:282
TList * GetEnabledPackages() const
Definition: TProof.h:765
Int_t fNWrks
Definition: TProof.h:328
const char * GetDataDir() const
Definition: TProof.h:259
TList * fInactiveSlaves
Definition: TProof.h:510
Version of TProofPlayerRemote merges the functionality needed by clients and masters.
A container class for query results.
Definition: TQueryResult.h:44
PrintProgress_t fPrintProgress
Definition: TProof.h:570
TList * GetLoadedMacros() const
Definition: TProof.h:974
Int_t fCollectTimeout
Definition: TProof.h:613
Long_t fModtime
Definition: TProof.h:529
const char *const kPROOF_DataDir
Definition: TProof.h:160
TProofMergePrg fMergePrg
Definition: TProof.h:549
static TList * fgProofEnvList
Definition: TProof.h:575
virtual const char * GetMssUrl(Bool_t=kFALSE)
Definition: TProofMgr.h:97
Float_t GetRealTime() const
Definition: TProof.h:960
std::recursive_mutex fCloseMutex
Definition: TProof.h:572
This packetizer is based on TPacketizer but uses different load-balancing algorithms and data structu...
Float_t fProcTime
Definition: TProof.h:197
Bool_t fIsPollingWorkers
Definition: TProof.h:505
A doubly linked list.
Definition: TList.h:47
static const char * what
Definition: stlLoader.cc:6
Bool_t fIsActive
Definition: TProof.h:290
void SetDataPoolUrl(const char *url)
Definition: TProof.h:1074
const char * GetUser() const
Definition: TUrl.h:74
This class implements the XProofD version of TProofServ, with respect to which it differs only for th...
Definition: TXProofServ.h:34
Bool_t fRedirLog
Definition: TProof.h:540
virtual void SetMssUrl(const char *mss)
Definition: TProofMgr.h:115
TMonitor * fUniqueMonitor
Definition: TProof.h:515
Bool_t IsSortable() const
Definition: TProof.h:269
const char *const kPROOF_ConfFile
Definition: TProof.h:152
FileMap_t fFileMap
Definition: TProof.h:532
const char *const kPROOF_QueryLockFile
Definition: TProof.h:163
TMonitor * fAllMonitor
Definition: TProof.h:605
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:41
Int_t RemoveDataSet(const char *dsname)
RemoveDataSet wrapper.
TFileCollection * GetDataSet(const char *ds, const char *server="")
GetDataSet wrapper.
Definition: pq2wrappers.cxx:87
Int_t fLogLevel
Definition: TProof.h:499
TProofMgr * fManager
Definition: TProof.h:617
const char *const kPROOF_TerminateWorker
Definition: TProof.h:164
TList * fActiveSlaves
Definition: TProof.h:507
Bool_t fSaveLogToMacro
Definition: TProof.h:546
Bool_t fValid
Definition: TProof.h:494
Bool_t fDataReady
Definition: TProof.h:606
Float_t fInitTime
Definition: TProof.h:196
void DecreaseNWrks()
Definition: TProof.h:339
TRandom2 r(17)
SysInfo_t fSysInfo
Definition: TProof.h:251
Class providing the PROOF server.
Definition: TProofServ.h:80
TString fWorkDir
Definition: TProof.h:497
void SetPrintProgress(PrintProgress_t pp)
Definition: TProof.h:1076
ERunStatus fRunStatus
Definition: TProof.h:537
const char *const kPROOF_DataSetDir
Definition: TProof.h:159
TMonitor * fCurrentMonitor
Definition: TProof.h:517
Input handler for XProofD sockets.
const char *const kPROOF_ConfDir
Definition: TProof.h:153
High level handler of connections to XProofD.
Definition: TXSocket.h:73
static int push(struct mg_context *ctx, FILE *fp, SOCKET sock, SSL *ssl, const char *buf, int len, double timeout)
Definition: civetweb.c:3754
Int_t fSeqNum
Definition: TProof.h:556
Collection abstract base class.
Definition: TCollection.h:48
void SetActive(Bool_t=kTRUE)
Definition: TProof.h:1018
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2322
TList * fSlaveInfo
Definition: TProof.h:503
unsigned int UInt_t
Definition: RtypesCore.h:42
TMarker * m
Definition: textangle.C:8
const char *const kPROOF_CacheLockFile
Definition: TProof.h:161
TMacro fMacroLog
Definition: TProof.h:547
ERunStatus GetRunStatus() const
Definition: TProof.h:973
bool verbose
Int_t GetPort()
Definition: TProof.h:305
void IncreaseIdx()
Definition: TProof.h:341
A TEventList object is a list of selected events (entries) in a TTree.
Definition: TEventList.h:33
const char *const kUNTAR2
Definition: TProof.h:175
Long64_t fProcessed
Definition: TProof.h:194
EProofClearData
Definition: TProof.h:415
Bool_t fProgressDialogStarted
Definition: TProof.h:523
const Int_t kPROOF_Protocol
Definition: TProof.h:150
TStopwatch fQuerySTW
Definition: TProof.h:623
TMergerInfo(TSlave *t, Int_t port, Int_t forHowManyWorkers)
Definition: TProof.h:296
Bool_t fMergersByHost
Definition: TProof.h:579
TString fInputDataFile
Definition: TProof.h:566
void SetStatus(ESlaveStatus stat)
Definition: TProof.h:264
FILE * fLogFileR
Definition: TProof.h:543
Int_t fProtocol
Definition: TProof.h:601
void Reset(Detail::TBranchProxy *x)
const char * GetUrl()
Definition: TProof.h:941
Float_t fEffSessions
Definition: TProof.h:202
TString fExp
Definition: TProof.h:326
Bool_t fLogToWindowOnly
Definition: TProof.h:544
Implementation of the functionality provided by TProofMgr in the case of a xproofd-based session...
Definition: TXProofMgr.h:46
TList * fFeedback
Definition: TProof.h:525
Bool_t IsIdle() const
Definition: TProof.h:970
TSlaveInfo(const char *ordinal="", const char *host="", Int_t perfidx=0, const char *msd="", const char *datadir="")
Definition: TProof.h:254
TString fMsd
Definition: TProof.h:248
Float_t fPrepTime
Definition: TProof.h:624
TList * fRunningDSets
Definition: TProof.h:611
Bool_t fDynamicStartup
Definition: TProof.h:619
static unsigned int total
long Long_t
Definition: RtypesCore.h:50
The packetizer is a load balancing object created for each query.
R__EXTERN TProof * gProof
Definition: TProof.h:1107
void SendLogToWindow(Bool_t mode)
Definition: TProof.h:1047
Bool_t fEndMaster
Definition: TProof.h:560
double f(double x)
void Print(std::ostream &os, const OptionType &opt)
const char *const kPROOF_InputDataFile
Definition: TProof.h:166
Bool_t IsProofd() const
Definition: TProof.h:964
ERegisterOpt
Definition: TProof.h:391
TVirtualProofPlayer * GetPlayer() const
Definition: TProof.h:746
Long64_t fBytesRead
Definition: TProof.h:518
Int_t fMergersCount
Definition: TProof.h:580
double Double_t
Definition: RtypesCore.h:55
ESlaves
Definition: TProof.h:594
Int_t fPort
Definition: TProof.h:281
const char * GetMaster() const
Definition: TProof.h:933
TList * fEnabledPackages
Definition: TProof.h:610
EStatusBits
Definition: TObject.h:55
Int_t GetNumberOfDrawQueries()
Definition: TProof.h:1009
TList * fNonUniqueMasters
Definition: TProof.h:513
TMap implements an associative array of (key,value) pairs using a THashTable for efficient retrieval ...
Definition: TMap.h:44
int type
Definition: TGX11.cxx:120
TList * fRecvMessages
Definition: TProof.h:502
TList * fEnabledPackagesOnCluster
Definition: TProof.h:563
This class controls a Parallel ROOT Facility, PROOF, cluster.
Definition: TProof.h:346
TPluginHandler * GetProgressDialog() const
Definition: TProof.h:772
int nentries
Definition: THbookFile.cxx:89
const char *const kPROOF_MissingFiles
Definition: TProof.h:167
void SetNWrks(Int_t n)
Definition: TProof.h:343
EBuildPackageOpt
Definition: TProof.h:483
void SetRunStatus(ERunStatus rst)
Definition: TProof.h:702
void ShowDataSets(const char *ds, const char *opt="")
ShowDataSets wrapper.
Definition: pq2wrappers.cxx:70
bool IsEqual(const Transform &t1, const Transform &t2, unsigned int size)
Int_t GetPort() const
Definition: TUrl.h:87
EQueryMode fQueryMode
Definition: TProof.h:618
Bool_t IsTty() const
Definition: TProof.h:968
EUploadOpt
Definition: TProof.h:383
FILE * fLogFileW
Definition: TProof.h:542
Mother of all ROOT objects.
Definition: TObject.h:37
#define R__EXTERN
Definition: DllImport.h:27
TPackMgr * fPackMgr
Definition: TProof.h:562
typedef void((*Func_t)())
TSelector * fSelector
Definition: TProof.h:621
void ResetProgressDialogStatus()
Definition: TProof.h:1051
TString fActiveSlavesSaved
Definition: TProof.h:508
Float_t GetCpuTime() const
Definition: TProof.h:961
ESlaveStatus
Definition: TProof.h:244
Int_t fLastNWrks
Definition: TProof.h:329
Class that contains a list of TFileInfo&#39;s and accumulated meta data information about its entries...
Definition: file.py:1
Utility class to draw objects in the feedback list during queries.
Definition: TDrawFeedback.h:39
TProofOutputList fOutputList
Definition: TProof.h:568
SysInfo_t GetSysInfo() const
Definition: TProof.h:263
Int_t Compare(const void *item1, const void *item2)
Int_t fSessionID
Definition: TProof.h:558
A chain is a collection of files containg TTree objects.
Definition: TChain.h:35
ESubMerger
Definition: TProof.h:406
const char * GetImage() const
Definition: TProof.h:940
const char *const kUNTAR
Definition: TProof.h:174
TList * GetListOfUniqueSlaves() const
Definition: TProof.h:686
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
const char *const kUNTAR3
Definition: TProof.h:176
Int_t GetRemoteProtocol() const
Definition: TProof.h:943
Int_t fStatus
Definition: TProof.h:500
Bool_t IsParallel() const
Definition: TProof.h:969
const char * GetUser() const
Definition: TProof.h:936
Bool_t IsActive()
Definition: TProof.h:318
TList * fAvailablePackages
Definition: TProof.h:609
Int_t fCheckFileStatus
Definition: TProof.h:501
A TTree object has a header with a name and a title.
Definition: TTree.h:98
Long64_t fTotalBytes
Definition: TProof.h:608
Float_t fMBRateI
Definition: TProof.h:199
Bool_t IsWaiting() const
Definition: TProof.h:971
TProofMgr::EServType fServType
Definition: TProof.h:616
Bool_t IsValid() const
Definition: TProof.h:967
Int_t GetSeqNum() const
Definition: TProof.h:948
TList * fTerminatedSlaveInfos
Definition: TProof.h:603
Abstract interface for the PROOF player.
const char * GetMsd() const
Definition: TProof.h:260
TProof * fProof
Definition: TProof.h:231
TList * fLoadedMacros
Definition: TProof.h:574
Class describing a PROOF worker server.
Definition: TSlave.h:50
A TSelector object is used by the TTree::Draw, TTree::Scan, TTree::Process to navigate in a TTree and...
Definition: TSelector.h:39
const Bool_t kTRUE
Definition: Rtypes.h:91
Long64_t fBytesReady
Definition: TProof.h:607
Int_t RegisterDataSet(const char *dsname, TFileCollection *fc, const char *opt="")
RegisterDataSet wrapper.
TString fMaster
Definition: TProof.h:496
Bool_t fTty
Definition: TProof.h:495
TList * fMergers
Definition: TProof.h:583
TList * GetListOfActiveSlaves() const
Definition: TProof.h:753
TUrl fUrl
Definition: TProof.h:597
TProofProgressInfo(Long64_t tot=0, Long64_t proc=0, Long64_t bytes=0, Float_t initt=-1., Float_t proct=-1., Float_t evts=-1., Float_t mbs=-1., Int_t actw=0, Int_t tsess=0, Float_t esess=0.)
Definition: TProof.h:203
Int_t GetMergedWorkers()
Definition: TProof.h:308
const Int_t n
Definition: legend1.C:16
TMonitor * fActiveMonitor
Definition: TProof.h:514
Int_t fIdx
Definition: TProof.h:327
TSocket * fSocket
Definition: TProof.h:230
char name[80]
Definition: TGX11.cxx:109
virtual ~TProofProgressInfo()
Definition: TProof.h:210
Derivation of TList with an overload of ls() and Print() allowing to filter out some of the variables...
Bool_t ExistsDataSet(const char *dsname)
ExistsDataSet wrapper.
ESendFileOpt
Definition: TProof.h:471
Long64_t fLastPollWorkers_s
Definition: TProof.h:506
Int_t fMaxDrawQueries
Definition: TProof.h:555
Int_t Broadcast(Int_t kind, ESlaves list=kActive)
Definition: TProof.h:664
void IncreaseNWrks()
Definition: TProof.h:340
const char *const kPROOF_CacheDir
Definition: TProof.h:155
const char * Data() const
Definition: TString.h:349
void SetOrdinal(const char *ord)
Definition: TProof.h:266
const char *const kPROOF_PackDir
Definition: TProof.h:156
Stopwatch class.
Definition: TStopwatch.h:30
Bool_t ReadNotify()
Notify when something can be read from the descriptor associated with this handler.
Definition: TProof.h:238