Logo ROOT  
Reference Guide
TProofPlayerLite.cxx
Go to the documentation of this file.
1 // @(#)root/proofplayer:$Id$
2 // Author: G. Ganis Mar 2008
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2001, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 /** \class TProofPlayerLite
13 \ingroup proofkernel
14 
15 Version of TProofPlayerRemote merges the functionality needed by clients
16 and masters. It is used in optmized local sessions.
17 
18 */
19 
20 #include "TProofPlayerLite.h"
21 
22 #include "MessageTypes.h"
23 #include "TDSet.h"
24 #include "TDSetProxy.h"
25 #include "TEntryList.h"
26 #include "TEventList.h"
27 #include "THashList.h"
28 #include "TMap.h"
29 #include "TMessage.h"
30 #include "TObjString.h"
31 #include "TPerfStats.h"
32 #include "TProofLite.h"
33 #include "TProofDebug.h"
34 #include "TProofServ.h"
35 #include "TROOT.h"
36 #include "TSelector.h"
37 #include "TVirtualPacketizer.h"
38 
39 ////////////////////////////////////////////////////////////////////////////////
40 /// Create the selector object and save the relevant files and binary information
41 /// in the cache so that the worker can pick it up.
42 /// Returns 0 and fill fSelector in case of success. Returns -1 and sets
43 /// fSelector to 0 in case of failure.
44 
46 {
47  fSelectorClass = 0;
49  if (!selfile || strlen(selfile) <= 0) {
50  Error("MakeSelector", "input file path or name undefined");
51  return -1;
52  }
53 
54  // If we are just given a name, init the selector and return
55  if (!strchr(gSystem->BaseName(selfile), '.')) {
56  if (gDebug > 1)
57  Info("MakeSelector", "selector name '%s' does not contain a '.':"
58  " no file to check, it will be loaded from a library", selfile);
59  if (!(fSelector = TSelector::GetSelector(selfile))) {
60  Error("MakeSelector", "could not create a %s selector", selfile);
61  return -1;
62  }
63  // Done
64  return 0;
65  }
66 
67  if (((TProofLite*)fProof)->CopyMacroToCache(selfile, 1, &fSelector, TProof::kCp | TProof::kCpBin) < 0)
68  return -1;
69 
70  // Done
71  return 0;
72 }
73 
74 ////////////////////////////////////////////////////////////////////////////////
75 /// Process specified TDSet on PROOF.
76 /// This method is called on client and on the PROOF master.
77 /// The return value is -1 in case of an error and TSelector::GetStatus() in
78 /// in case of success.
79 
81  Option_t *option, Long64_t nentries,
83 {
84  if (!selector) {
85  Error("Process", "selector object undefined");
86  return -1;
87  }
88 
89  // Define fSelector in Client
90  if (selector != fSelector) {
92  fSelector = selector;
93  }
94 
96  Long64_t rc = Process(dset, selector->ClassName(), option, nentries, first);
98 
99  // Done
100  return rc;
101 }
102 
103 ////////////////////////////////////////////////////////////////////////////////
104 /// Process specified TDSet on PROOF.
105 /// This method is called on client and on the PROOF master.
106 /// The return value is -1 in case of error and TSelector::GetStatus() in
107 /// in case of success.
108 
109 Long64_t TProofPlayerLite::Process(TDSet *dset, const char *selector_file,
110  Option_t *option, Long64_t nentries,
111  Long64_t first)
112 {
113  PDB(kGlobal,1) Info("Process","Enter");
114  fDSet = dset;
116 
117  if (!fProgressStatus) {
118  Error("Process", "No progress status");
119  return -1;
120  }
122 
123  // delete fOutput;
124  if (!fOutput)
125  fOutput = new THashList;
126  else
127  fOutput->Clear();
128 
131 
132  TStopwatch elapsed;
133 
134  TMessage mesg(kPROOF_PROCESS);
135  TString fn(gSystem->BaseName(selector_file));
136 
137  // Parse option
138  Bool_t sync = (fProof->GetQueryMode(option) == TProof::kSync);
139 
140  // Make sure that the temporary output list is empty
141  if (fOutputLists) {
142  fOutputLists->Delete();
143  delete fOutputLists;
144  fOutputLists = 0;
145  }
146 
147  if (!sync) {
149  Printf(" ");
150  Info("Process","starting new query");
151  }
152 
153  if (fCreateSelObj) {
154  if (MakeSelector(selector_file) != 0) {
155  if (!sync)
157  return -1;
158  }
159  }
160 
161  fSelectorClass = fSelector->IsA();
162  // Add fSelector to inputlist if processing with object
163  TList *inputtmp = 0; // List of temporary input objects
164  if (!fCreateSelObj) {
165  // In any input list was set into the selector move it to the PROOF
166  // input list, because we do not want to stream the selector one
167  if (fSelector->GetInputList() && fSelector->GetInputList()->GetSize() > 0) {
168  TIter nxi(fSelector->GetInputList());
169  TObject *o = 0;
170  while ((o = nxi())) {
171  if (!fInput->FindObject(o)) {
172  fInput->Add(o);
173  if (!inputtmp) {
174  inputtmp = new TList;
175  inputtmp->SetOwner(kFALSE);
176  }
177  inputtmp->Add(o);
178  }
179  }
180  }
181  fInput->Add(fSelector);
182  }
183  // Set the input list for initialization
185  fSelector->SetOption(option);
187 
188  PDB(kLoop,1) Info("Process","Call Begin(0)");
189  fSelector->Begin(0);
190 
191  // Send large input data objects, if any
193 
194  // Attach to the transient histogram with the assigned packets, if required
195  if (fInput->FindObject("PROOF_StatsHist") != 0) {
196  if (!(fProcPackets = (TH1 *) fOutput->FindObject("PROOF_ProcPcktHist"))) {
197  Warning("Process", "could not attach to histogram 'PROOF_ProcPcktHist'");
198  } else {
199  PDB(kLoop,1)
200  Info("Process", "attached to histogram 'PROOF_ProcPcktHist' to record"
201  " packets being processed");
202  }
203  }
204 
205  PDB(kPacketizer,1) Info("Process","Create Proxy TDSet");
206  TDSet *set = new TDSetProxy(dset->GetType(), dset->GetObjName(),
207  dset->GetDirectory());
208  if (dset->TestBit(TDSet::kEmpty))
209  set->SetBit(TDSet::kEmpty);
210  fProof->SetParameter("PROOF_MaxSlavesPerNode", (Long_t) 0);
211  if (InitPacketizer(dset, nentries, first, "TPacketizerUnit", "TPacketizer") != 0) {
212  Error("Process", "cannot init the packetizer");
214  return -1;
215  }
216  // reset start, this is now managed by the packetizer
217  first = 0;
218 
219  // Negative memlogfreq disable checks.
220  // If 0 is passed we try to have 100 messages about memory
221  // Otherwise we use the frequency passed.
222  Int_t mrc = -1;
223  Long64_t memlogfreq = -1, mlf;
224  if ((mrc = TProof::GetParameter(fProof->GetInputList(), "PROOF_MemLogFreq", mlf)) == 0) memlogfreq = mlf;
225  if (mrc != 0 && gSystem->Getenv("PROOF_MEMLOGFREQ")) {
226  TString clf(gSystem->Getenv("PROOF_MEMLOGFREQ"));
227  if (clf.IsDigit()) { memlogfreq = clf.Atoi(); mrc = 0; }
228  }
229  if (memlogfreq == 0) {
230  memlogfreq = fPacketizer->GetTotalEntries()/(fProof->GetParallel()*100);
231  if (memlogfreq <= 0) memlogfreq = 1;
232  }
233  if (mrc == 0) fProof->SetParameter("PROOF_MemLogFreq", memlogfreq);
234 
235  // Add the unique query tag as TNamed object to the input list
236  // so that it is available in TSelectors for monitoring
237  fProof->SetParameter("PROOF_QueryTag", fProof->GetName());
238  // ... and the sequential number
239  fProof->SetParameter("PROOF_QuerySeqNum", fProof->fSeqNum);
240 
241  if (!sync)
243 
244  TCleanup clean(this);
245  SetupFeedback();
246 
247  TString opt = option;
248 
249  // Workers will get the entry ranges from the packetizer
250  Long64_t num = (fProof->IsParallel()) ? -1 : nentries;
251  Long64_t fst = (fProof->IsParallel()) ? -1 : first;
252 
253  // Entry- or Event- list ?
254  TEntryList *enl = (!fProof->IsMaster()) ? dynamic_cast<TEntryList *>(set->GetEntryList())
255  : (TEntryList *)0;
256  TEventList *evl = (!fProof->IsMaster() && !enl) ? dynamic_cast<TEventList *>(set->GetEntryList())
257  : (TEventList *)0;
258  // Reset the merging progress information
260 
261  // Broadcast main message
262  PDB(kGlobal,1) Info("Process","Calling Broadcast");
263  if (fProcessMessage) delete fProcessMessage;
265  mesg << set << fn << fInput << opt << num << fst << evl << sync << enl;
266  (*fProcessMessage) << set << fn << fInput << opt << num << fst << evl << sync << enl;
267  Int_t nb = fProof->Broadcast(mesg);
268  PDB(kGlobal,1) Info("Process", "Broadcast called: %d workers notified", nb);
269  fProof->fNotIdle += nb;
270 
271  // Redirect logs from master to special log frame
273 
274  if (!sync) {
275 
276  // Asynchronous query: just make sure that asynchronous input
277  // is enabled and return the prompt
278  PDB(kGlobal,1) Info("Process","Asynchronous processing:"
279  " activating CollectInputFrom");
280  fProof->Activate();
281 
282  // Return the query sequential number
283  return fProof->fSeqNum;
284 
285  } else {
286 
287  // Wait for processing
288  PDB(kGlobal,1) Info("Process","Synchronous processing: calling Collect");
289  fProof->Collect();
290 
291  // Restore prompt logging (Collect leaves things as they were
292  // at the time it was called)
294 
295  if (!TSelector::IsStandardDraw(fn))
296  HandleTimer(0); // force an update of final result
297  if (fPacketizer) {
299  // The progress timer will now stop itself at the next call
301  // Store process info
302  elapsed.Stop();
303  if (fQuery)
306  elapsed.RealTime());
307  }
308  StopFeedback();
309 
310  Long64_t rc = -1;
312  rc = Finalize(kFALSE, sync);
313 
314  // Remove temporary input objects, if any
315  if (inputtmp) {
316  TIter nxi(inputtmp);
317  TObject *o = 0;
318  while ((o = nxi())) fInput->Remove(o);
319  SafeDelete(inputtmp);
320  }
321 
322  // Done
323  return rc;
324  }
325 }
326 
327 ////////////////////////////////////////////////////////////////////////////////
328 /// Finalize a query.
329 /// Returns -1 in case error, 0 otherwise.
330 
332 {
333  if (fOutputLists == 0) {
334  if (force && fQuery)
335  return fProof->Finalize(Form("%s:%s", fQuery->GetTitle(),
336  fQuery->GetName()), force);
337  }
338 
339  Long64_t rv = 0;
340 
342 
343  if (!fQuery) {
344  Info("Finalize", "query is undefined!");
345  return -1;
346  }
347 
348  // Some objects (e.g. histos in autobin) may not have been merged yet
349  // do it now
350  MergeOutput();
351 
352  if (fExitStatus != kAborted) {
353 
354  if (!sync) {
355  // Reinit selector (with multi-sessioning we must do this until
356  // TSelector::GetSelector() is optimized to i) avoid reloading of an
357  // unchanged selector and ii) invalidate existing instances of
358  // reloaded selector)
359  if (ReinitSelector(fQuery) == -1) {
360  Info("Finalize", "problems reinitializing selector \"%s\"",
361  fQuery->GetSelecImp()->GetName());
362  return -1;
363  }
364  }
365 
366  // Some input parameters may be needed in Terminate
368 
370  if (output) {
371  TIter next(fOutput);
372  while(TObject* obj = next()) {
373  if (fProof->IsParallel() || DrawCanvas(obj) == 1)
374  // Either parallel or not a canvas or not able to display it:
375  // just add to the list
376  output->Add(obj);
377  }
378  } else {
379  Warning("Finalize", "undefined output list in the selector! Protocol error?");
380  }
381 
383 
384  PDB(kLoop,1) Info("Finalize","Call Terminate()");
385  fOutput->Clear("nodelete");
386  // This is the end of merging
388  // We measure the merge time
390  // Call Terminate now
391  fSelector->Terminate();
392 
393  rv = fSelector->GetStatus();
394 
395  // copy the output list back and clean the selector's list
396  TIter it(output);
397  while(TObject* o = it()) {
398  fOutput->Add(o);
399  }
400 
401  // Save the output list in the current query, if any
402  if (fQuery) {
404  // Set in finalized state (cannot be done twice)
405  fQuery->SetFinalized();
406  } else {
407  Warning("Finalize","current TQueryResult object is undefined!");
408  }
409 
410  if (!fCreateSelObj) {
413  if (output) output->Remove(fSelector);
414  fSelector = 0;
415  }
416 
417  // We have transferred copy of the output objects in TQueryResult,
418  // so now we can cleanup the selector, making sure that we do not
419  // touch the output objects
420  if (output) output->SetOwner(kFALSE);
422 
423  // Delete fOutput (not needed anymore, cannot be finalized twice),
424  // making sure that the objects saved in TQueryResult are not deleted
427  } else {
428 
429  // Cleanup
430  fOutput->SetOwner();
432  if (!fCreateSelObj) fSelector = 0;
433  }
434 
435  PDB(kGlobal,1) Info("Finalize","exit");
436  return rv;
437 }
438 
439 ////////////////////////////////////////////////////////////////////////////////
440 /// Send feedback objects to client.
441 
443 {
444  PDB(kFeedback,2)
445  Info("HandleTimer","Entry: %p", fFeedbackTimer);
446 
447  if (fFeedbackTimer == 0) return kFALSE; // timer already switched off
448 
449 
450  // process local feedback objects
451 
452  TList *fb = new TList;
453  fb->SetOwner();
454 
455  TIter next(fFeedback);
456  while( TObjString *name = (TObjString*) next() ) {
457  TObject *o = fOutput->FindObject(name->GetName());
458  if (o != 0) fb->Add(o->Clone());
459  }
460 
461  if (fb->GetSize() > 0)
462  StoreFeedback(this, fb); // adopts fb
463  else
464  delete fb;
465 
466  if (fFeedbackLists == 0) {
467  fFeedbackTimer->Start(fFeedbackPeriod, kTRUE); // maybe next time
468  return kFALSE;
469  }
470 
471  fb = MergeFeedback();
472 
473  Feedback(fb);
474  fb->SetOwner();
475  delete fb;
476 
478 
479  return kFALSE; // ignored?
480 }
481 
482 ////////////////////////////////////////////////////////////////////////////////
483 /// Setup reporting of feedback objects.
484 
486 {
487  fFeedback = (TList*) fInput->FindObject("FeedbackList");
488 
489  if (fFeedback) {
490  PDB(kFeedback,1)
491  Info("SetupFeedback","\"FeedbackList\" found: %d objects", fFeedback->GetSize());
492  } else {
493  PDB(kFeedback,1)
494  Info("SetupFeedback","\"FeedbackList\" NOT found");
495  }
496 
497  if (fFeedback == 0 || fFeedback->GetSize() == 0) return;
498 
499  // OK, feedback was requested, setup the timer
501  fFeedbackPeriod = 2000;
502  TProof::GetParameter(fInput, "PROOF_FeedbackPeriod", fFeedbackPeriod);
503  fFeedbackTimer = new TTimer;
504  fFeedbackTimer->SetObject(this);
506 }
507 
508 ////////////////////////////////////////////////////////////////////////////////
509 /// Store feedback results from the specified slave.
510 
512 {
513  PDB(kFeedback,1)
514  Info("StoreFeedback","Enter (%p,%p,%d)", fFeedbackLists, out, (out ? out->GetSize() : -1));
515 
516  if ( out == 0 ) {
517  PDB(kFeedback,1)
518  Info("StoreFeedback","Leave (empty)");
519  return;
520  }
521 
522  if (fFeedbackLists == 0) {
523  PDB(kFeedback,2) Info("StoreFeedback","Create fFeedbackLists");
524  fFeedbackLists = new TList;
526  }
527 
528  TIter next(out);
529  out->SetOwner(kFALSE); // take ownership of the contents
530 
531  TObject *obj;
532  while( (obj = next()) ) {
533  PDB(kFeedback,2)
534  Info("StoreFeedback","Find '%s'", obj->GetName() );
535 
536  TMap *map = (TMap*) fFeedbackLists->FindObject(obj->GetName());
537  if ( map == 0 ) {
538  PDB(kFeedback,2)
539  Info("StoreFeedback", "map for '%s' not found (creating)", obj->GetName());
540  // map must not be owner (ownership is with regards to the keys (only))
541  map = new TMap;
542  map->SetName(obj->GetName());
543  fFeedbackLists->Add(map);
544  } else {
545  PDB(kFeedback,2)
546  Info("StoreFeedback","removing previous value");
547  if (map->GetValue(slave))
548  delete map->GetValue(slave);
549  map->Remove(slave);
550  }
551  map->Add(slave, obj);
552  }
553 
554  delete out;
555  PDB(kFeedback,1)
556  Info("StoreFeedback","Leave");
557 }
TProofPlayerLite::StoreFeedback
void StoreFeedback(TObject *slave, TList *out)
Store feedback results from the specified slave.
Definition: TProofPlayerLite.cxx:511
TTimer::SetObject
void SetObject(TObject *object)
Set the object to be notified at time out.
Definition: TTimer.cxx:184
TDSet::GetDirectory
const char * GetDirectory() const
Definition: TDSet.h:230
first
Definition: first.py:1
TSelector::GetStatus
virtual Long64_t GetStatus() const
Definition: TSelector.h:58
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
TProofPlayerLite::HandleTimer
Bool_t HandleTimer(TTimer *timer)
Send feedback objects to client.
Definition: TProofPlayerLite.cxx:442
TObject::TestBit
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:172
TEventList
Definition: TEventList.h:31
TDSet::GetObjName
const char * GetObjName() const
Definition: TDSet.h:229
TSelector
Definition: TSelector.h:31
TProofPlayerRemote::fProof
TProof * fProof
Definition: TProofPlayer.h:282
PDB
#define PDB(mask, level)
Definition: TProofDebug.h:56
TString::Atoi
Int_t Atoi() const
Return integer value of string.
Definition: TString.cxx:1921
TProofPlayerRemote::fDSet
TDSet * fDSet
Definition: TProofPlayer.h:288
TDSet::kEmpty
@ kEmpty
Definition: TDSet.h:159
TSystem::BaseName
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
Definition: TSystem.cxx:933
TList::FindObject
virtual TObject * FindObject(const char *name) const
Find an object in this list using its name.
Definition: TList.cxx:577
TPerfStats::Setup
static void Setup(TList *input)
Setup the PROOF input list with requested statistics and tracing options.
Definition: TPerfStats.cxx:727
TList::Delete
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:469
TVirtualProofPlayer::kAborted
@ kAborted
Definition: TVirtualProofPlayer.h:48
gProof
R__EXTERN TProof * gProof
Definition: TProof.h:1077
TProofDebug.h
Form
char * Form(const char *fmt,...)
TNamed::GetTitle
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:54
TSelector::Terminate
virtual void Terminate()
Definition: TSelector.h:71
TVirtualPacketizer::GetInitTime
Float_t GetInitTime() const
Definition: TVirtualPacketizer.h:135
TObjString.h
TSelector::GetSelector
static TSelector * GetSelector(const char *filename)
The code in filename is loaded (interpreted or compiled, see below), filename must contain a valid cl...
Definition: TSelector.cxx:142
TTimer::Start
virtual void Start(Long_t milliSec=-1, Bool_t singleShot=kFALSE)
Starts the timer with a milliSec timeout.
Definition: TTimer.cxx:211
TObject::Info
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:864
Long64_t
long long Long64_t
Definition: RtypesCore.h:73
TObject::Error
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:890
TProof::Collect
Int_t Collect(const TSlave *sl, Long_t timeout=-1, Int_t endtype=-1, Bool_t deactonfail=kFALSE)
Collect responses from slave sl.
Definition: TProof.cxx:2659
TDSet::GetEntryList
TObject * GetEntryList() const
Definition: TDSet.h:251
output
static void output(int code)
Definition: gifencode.c:226
TVirtualProofPlayer::kFinished
@ kFinished
Definition: TVirtualProofPlayer.h:48
TCollection::SetOwner
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
Definition: TCollection.cxx:746
TMap::GetValue
TObject * GetValue(const char *keyname) const
Returns a pointer to the value associated with keyname as name of the key.
Definition: TMap.cxx:236
TVirtualPacketizer.h
TProof::ResetMergePrg
void ResetMergePrg()
Reset the merge progress notificator.
Definition: TProof.cxx:2455
SafeDelete
#define SafeDelete(p)
Definition: RConfig.hxx:543
MessageTypes.h
TProofPlayer::TCleanup
Definition: TProofPlayer.h:117
TProofLite
Definition: TProofLite.h:40
nentries
int nentries
Definition: THbookFile.cxx:91
TMessage.h
TProofPlayerRemote::SetMerging
void SetMerging(Bool_t on=kTRUE)
Switch on/off merge timer.
Definition: TProofPlayer.cxx:1814
TProofPlayerRemote::Feedback
void Feedback(TList *objs)
Feedback signal.
Definition: TProofPlayer.cxx:3317
TProof::SetParameter
void SetParameter(const char *par, const char *value)
Set input list parameter.
Definition: TProof.cxx:9812
TMap::Add
void Add(TObject *obj)
This function may not be used (but we need to provide it since it is a pure virtual in TCollection).
Definition: TMap.cxx:54
TProof::fRedirLog
Bool_t fRedirLog
Definition: TProof.h:510
TString
Definition: TString.h:136
TProofPlayer::fSelector
TSelector * fSelector
Definition: TProofPlayer.h:68
TProofPlayerRemote::InitPacketizer
Int_t InitPacketizer(TDSet *dset, Long64_t nentries, Long64_t first, const char *defpackunit, const char *defpackdata)
Init the packetizer Return 0 on success (fPacketizer is correctly initialized), -1 on failure.
Definition: TProofPlayer.cxx:1915
TProofPlayerRemote::SetSelectorDataMembersFromOutputList
void SetSelectorDataMembersFromOutputList()
Set the selector's data members: find the mapping of data members to otuput list entries in the outpu...
Definition: TProofPlayer.cxx:2766
TSelector::Begin
virtual void Begin(TTree *)
Definition: TSelector.h:54
kPROOF_PROCESS
@ kPROOF_PROCESS
Definition: MessageTypes.h:62
bool
TVirtualPacketizer::GetTotalEntries
Long64_t GetTotalEntries() const
Definition: TVirtualPacketizer.h:124
TProof::Broadcast
Int_t Broadcast(const TMessage &mess, TList *slaves)
Broadcast a message to all slaves in the specified list.
Definition: TProof.cxx:2465
TQueryResult::SetFinalized
virtual void SetFinalized()
Definition: TQueryResult.h:96
TROOT.h
TStopwatch::RealTime
Double_t RealTime()
Stop the stopwatch (if it is running) and return the realtime (in seconds) passed between the start a...
Definition: TStopwatch.cxx:110
TObjString
Definition: TObjString.h:28
TProofPlayerRemote::fProcessMessage
TMessage * fProcessMessage
Histogram with packets being processed (owned by TPerfStats)
Definition: TProofPlayer.h:292
TProof::fSeqNum
Int_t fSeqNum
Definition: TProof.h:526
TVirtualPacketizer::StopProcess
virtual void StopProcess(Bool_t abort, Bool_t stoptimer=kFALSE)
Stop process.
Definition: TVirtualPacketizer.cxx:243
TObject::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:359
TProofLite.h
TProof::IsMaster
Bool_t IsMaster() const
Definition: TProof.h:936
TPerfStats::Start
static void Start(TList *input, TList *output)
Initialize PROOF statistics run.
Definition: TPerfStats.cxx:744
TTimer
Definition: TTimer.h:51
Option_t
const typedef char Option_t
Definition: RtypesCore.h:66
TProof::fQuerySTW
TStopwatch fQuerySTW
Definition: TProof.h:593
TProofPlayer::fCreateSelObj
Bool_t fCreateSelObj
the latest selector
Definition: TProofPlayer.h:69
TSystem::RedirectOutput
virtual Int_t RedirectOutput(const char *name, const char *mode="a", RedirectHandle_t *h=nullptr)
Redirect standard output (stdout, stderr) to the specified file.
Definition: TSystem.cxx:1711
TProofPlayerRemote::fFeedbackLists
TList * fFeedbackLists
Definition: TProofPlayer.h:285
TPerfStats.h
THashList
Definition: THashList.h:34
TProofPlayer::fInput
TList * fInput
Definition: TProofPlayer.h:66
TObject::SetBit
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:696
TProof::GetQueryMode
EQueryMode GetQueryMode(Option_t *mode=0) const
Find out the query mode based on the current setting and 'mode'.
Definition: TProof.cxx:6109
THashList::FindObject
TObject * FindObject(const char *name) const
Find object using its name.
Definition: THashList.cxx:262
TProofPlayer::fSelectorClass
TClass * fSelectorClass
kTRUE when fSelector has been created locally
Definition: TProofPlayer.h:70
TStopwatch::Reset
void Reset()
Definition: TStopwatch.h:58
TProof::GetInputList
TList * GetInputList()
Get input list.
Definition: TProof.cxx:9743
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
gDebug
R__EXTERN Int_t gDebug
Definition: RtypesCore.h:119
Long_t
long Long_t
Definition: RtypesCore.h:54
TProof::Finalize
Long64_t Finalize(Int_t query=-1, Bool_t force=kFALSE)
Finalize the qry-th query in fQueries.
Definition: TProof.cxx:5873
TObject::Clone
virtual TObject * Clone(const char *newname="") const
Make a clone of an object using the Streamer facility.
Definition: TObject.cxx:146
TProofPlayerLite::SetupFeedback
void SetupFeedback()
Setup reporting of feedback objects.
Definition: TProofPlayerLite.cxx:485
TProofServ.h
TMap::Remove
TObject * Remove(TObject *key)
Remove the (key,value) pair with key from the map.
Definition: TMap.cxx:296
TSelector::SetInputList
virtual void SetInputList(TList *input)
Definition: TSelector.h:66
TProofPlayerLite::Process
Long64_t Process(TDSet *set, const char *selector, Option_t *option="", Long64_t nentries=-1, Long64_t firstentry=0)
Process specified TDSet on PROOF.
Definition: TProofPlayerLite.cxx:109
TProofPlayer::fProgressStatus
TProofProgressStatus * fProgressStatus
Definition: TProofPlayer.h:77
TDSet::GetType
const char * GetType() const
Definition: TDSet.h:228
TProof::fNotIdle
Int_t fNotIdle
Definition: TProof.h:505
TProofPlayer::fFeedbackPeriod
Long_t fFeedbackPeriod
timer for sending intermediate results
Definition: TProofPlayer.h:72
TProofPlayerRemote::fOutputLists
TList * fOutputLists
Definition: TProofPlayer.h:283
TProofPlayer::DrawCanvas
virtual Int_t DrawCanvas(TObject *obj)
Draw the object if it is a canvas.
Definition: TProofPlayer.cxx:1696
TDSet
Definition: TDSet.h:153
TProofPlayerLite.h
THashList::Remove
TObject * Remove(TObject *obj)
Remove object from the list.
Definition: THashList.cxx:378
TObject::Warning
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:876
TString::IsDigit
Bool_t IsDigit() const
Returns true if all characters in string are digits (0-9) or white spaces, i.e.
Definition: TString.cxx:1763
TDSetProxy
Definition: TDSetProxy.h:29
TSelector::GetOutputList
virtual TList * GetOutputList() const
Definition: TSelector.h:69
TQueryResult::GetSelecImp
TMacro * GetSelecImp() const
Definition: TQueryResult.h:133
TProof::IsParallel
Bool_t IsParallel() const
Definition: TProof.h:939
TEntryList
Definition: TEntryList.h:25
THashList.h
Printf
void Printf(const char *fmt,...)
TProofPlayerLite::Finalize
Long64_t Finalize(Bool_t force=kFALSE, Bool_t sync=kFALSE)
Finalize a query.
Definition: TProofPlayerLite.cxx:331
gSystem
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
TQueryResult::SetProcessInfo
virtual void SetProcessInfo(Long64_t ent, Float_t cpu=0., Long64_t siz=-1, Float_t inittime=0., Float_t proctime=0.)
Set processing info.
Definition: TQueryResult.cxx:272
TProofPlayerRemote::fFeedback
TList * fFeedback
Definition: TProofPlayer.h:284
TSystem::Getenv
virtual const char * Getenv(const char *env)
Get environment variable.
Definition: TSystem.cxx:1661
TVirtualPacketizer::kIsDone
@ kIsDone
Definition: TVirtualPacketizer.h:115
TProofPlayer::fOutput
THashList * fOutput
Definition: TProofPlayer.h:67
TSelector::SetOption
virtual void SetOption(const char *option)
Definition: TSelector.h:64
TProofPlayer::fFeedbackTimer
TTimer * fFeedbackTimer
class of the latest selector
Definition: TProofPlayer.h:71
TPerfStats::Stop
static void Stop()
Terminate the PROOF statistics run.
Definition: TPerfStats.cxx:764
TList::Remove
virtual TObject * Remove(TObject *obj)
Remove object from the list.
Definition: TList.cxx:821
TCollection::GetSize
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:182
TProofPlayerLite::MakeSelector
Int_t MakeSelector(const char *selfile)
Create the selector object and save the relevant files and binary information in the cache so that th...
Definition: TProofPlayerLite.cxx:45
THashList::Clear
void Clear(Option_t *option="")
Remove all objects from the list.
Definition: THashList.cxx:189
TProofPlayer::ReinitSelector
Int_t ReinitSelector(TQueryResult *qr)
Reinitialize fSelector using the selector files in the query result.
Definition: TProofPlayer.cxx:499
TCollection::SetName
void SetName(const char *name)
Definition: TCollection.h:204
TList::Add
virtual void Add(TObject *obj)
Definition: TList.h:87
TProofPlayerRemote::fProcPackets
TH1 * fProcPackets
Definition: TProofPlayer.h:291
TProofPlayer::fQuery
TQueryResult * fQuery
Definition: TProofPlayer.h:84
TStopwatch
Definition: TStopwatch.h:28
TObject
Definition: TObject.h:37
TH1
Definition: TH1.h:57
TProofPlayerRemote::StopFeedback
void StopFeedback()
Stop reporting of feedback objects.
Definition: TProofPlayer.cxx:4118
TProofProgressStatus::Reset
void Reset()
Definition: TProofProgressStatus.h:50
TEntryList.h
TMap.h
TQueryResult::SetOutputList
virtual void SetOutputList(TList *out, Bool_t adopt=kTRUE)
Set / change the output list.
Definition: TQueryResult.cxx:457
TList::Clear
virtual void Clear(Option_t *option="")
Remove all objects from the list.
Definition: TList.cxx:401
name
char name[80]
Definition: TGX11.cxx:110
TProof::kSync
@ kSync
Definition: TProof.h:350
TIter
Definition: TCollection.h:233
TProofPlayer::fExitStatus
EExitStatus fExitStatus
status of query in progress
Definition: TProofPlayer.h:75
TDSetProxy.h
TSelector::IsStandardDraw
static Bool_t IsStandardDraw(const char *selec)
Find out if this is a standard selection used for Draw actions (either TSelectorDraw,...
Definition: TSelector.cxx:237
TProofPlayer::GetExitStatus
EExitStatus GetExitStatus() const
Definition: TProofPlayer.h:205
TNamed::GetName
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:53
TMessage
Definition: TMessage.h:33
TVirtualPacketizer::GetBytesRead
Long64_t GetBytesRead() const
Definition: TVirtualPacketizer.h:132
TStopwatch::Stop
void Stop()
Stop the stopwatch.
Definition: TStopwatch.cxx:77
TDSet.h
TProof::Activate
void Activate(TList *slaves=0)
Activate slave server list.
Definition: TProof.cxx:2379
TProofPlayerRemote::MergeOutput
virtual void MergeOutput(Bool_t savememvalues=kFALSE)
Merge objects in output the lists.
Definition: TProofPlayer.cxx:3114
TObject::ClassName
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition: TObject.cxx:130
TProof::GetParameter
TObject * GetParameter(const char *par) const
Get specified parameter.
Definition: TProof.cxx:9908
TProof::GetParallel
Int_t GetParallel() const
Returns number of slaves active in parallel mode.
Definition: TProof.cxx:2294
TProof::SendInputDataFile
virtual void SendInputDataFile()
Send the input data objects to the master; the objects are taken from the dedicated list and / or the...
Definition: TProof.cxx:9602
TSelector.h
TList
Definition: TList.h:44
TProofPlayerRemote::MergeFeedback
TList * MergeFeedback()
Merge feedback lists.
Definition: TProofPlayer.cxx:3926
TSelector::GetInputList
virtual TList * GetInputList() const
Definition: TSelector.h:68
TProofPlayerRemote::fPacketizer
TVirtualPacketizer * fPacketizer
Definition: TProofPlayer.h:286
TProof::fLogFileName
TString fLogFileName
Definition: TProof.h:511
int
TProof::kCp
@ kCp
Definition: TProof.h:447
TMap
Definition: TMap.h:40
TEventList.h
TProof::kCpBin
@ kCpBin
Definition: TProof.h:446