Logo ROOT   6.08/07
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 }
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
Definition: TSystem.cxx:929
virtual const char * GetName() const
Returns name of object.
Definition: TNamed.h:51
This class starts a PROOF session on the local machine: no daemons, client and master merged...
Definition: TProofLite.h:42
void SetMerging(Bool_t on=kTRUE)
Switch on/off merge timer.
TProofProgressStatus * fProgressStatus
Definition: TProofPlayer.h:95
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:405
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:899
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
EExitStatus fExitStatus
status of query in progress
Definition: TProofPlayer.h:93
long long Long64_t
Definition: RtypesCore.h:69
void Activate(TList *slaves=0)
Activate slave server list.
Definition: TProof.cxx:2367
Long_t fFeedbackPeriod
timer for sending intermediate results
Definition: TProofPlayer.h:90
Collectable string class.
Definition: TObjString.h:32
const char Option_t
Definition: RtypesCore.h:62
void SetupFeedback()
Setup reporting of feedback objects.
TObject * GetParameter(const char *par) const
Get specified parameter.
Definition: TProof.cxx:9890
Bool_t TestBit(UInt_t f) const
Definition: TObject.h:157
This class implements a data set to be used for PROOF processing.
Definition: TDSet.h:153
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
Long64_t GetBytesRead() const
void SetParameter(const char *par, const char *value)
Set input list parameter.
Definition: TProof.cxx:9794
virtual void MergeOutput(Bool_t savememvalues=kFALSE)
Merge objects in output the lists.
TString fLogFileName
Definition: TProof.h:541
Basic string class.
Definition: TString.h:137
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
const Bool_t kFALSE
Definition: Rtypes.h:92
Bool_t IsMaster() const
Definition: TProof.h:966
Int_t Broadcast(const TMessage &mess, TList *slaves)
Broadcast a message to all slaves in the specified list.
Definition: TProof.cxx:2453
Long64_t Process(TDSet *set, const char *selector, Option_t *option="", Long64_t nentries=-1, Long64_t firstentry=0)
Process specified TDSet on PROOF.
Long64_t Finalize(Bool_t force=kFALSE, Bool_t sync=kFALSE)
Finalize a query.
TObject * FindObject(const char *name) const
Find object using its name.
Definition: THashList.cxx:213
TQueryResult * fQuery
Definition: TProofPlayer.h:102
virtual void SetInputList(TList *input)
Definition: TSelector.h:73
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:739
virtual TObject * FindObject(const char *name) const
Find an object in this list using its name.
Definition: TList.cxx:497
TList * fInput
Definition: TProofPlayer.h:84
TMessage * fProcessMessage
Histogram with packets being processed (owned by TPerfStats)
Definition: TProofPlayer.h:310
virtual void StopProcess(Bool_t abort, Bool_t stoptimer=kFALSE)
Stop process.
#define SafeDelete(p)
Definition: RConfig.h:507
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition: TObject.cxx:188
void Stop()
Stop the stopwatch.
Definition: TStopwatch.cxx:77
#define PDB(mask, level)
Definition: TProofDebug.h:58
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
Definition: THashList.h:36
virtual Long64_t GetStatus() const
Definition: TSelector.h:66
void StopFeedback()
Stop reporting of feedback objects.
virtual void Start(Long_t milliSec=-1, Bool_t singleShot=kFALSE)
Starts the timer with a milliSec timeout.
Definition: TTimer.cxx:211
virtual const char * Getenv(const char *env)
Get environment variable.
Definition: TSystem.cxx:1628
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:2647
void ResetMergePrg()
Reset the merge progress notificator.
Definition: TProof.cxx:2443
TList * MergeFeedback()
Merge feedback lists.
virtual void Begin(TTree *)
Definition: TSelector.h:62
TClass * fSelectorClass
kTRUE when fSelector has been created locally
Definition: TProofPlayer.h:88
Int_t fNotIdle
Definition: TProof.h:535
Int_t MakeSelector(const char *selfile)
Create the selector object and save the relevant files and binary information in the cache so that th...
virtual void SetOutputList(TList *out, Bool_t adopt=kTRUE)
Set / change the output list.
THashList * fOutput
Definition: TProofPlayer.h:85
static void Start(TList *input, TList *output)
Initialize PROOF statistics run.
Definition: TPerfStats.cxx:744
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.
TTimer * fFeedbackTimer
class of the latest selector
Definition: TProofPlayer.h:89
void Feedback(TList *objs)
Feedback signal.
Long64_t GetTotalEntries() const
A doubly linked list.
Definition: TList.h:47
Bool_t fRedirLog
Definition: TProof.h:540
static void Setup(TList *input)
Setup the PROOF input list with requested statistics and tracing options.
Definition: TPerfStats.cxx:727
Bool_t HandleTimer(TTimer *timer)
Send feedback objects to client.
void Clear(Option_t *option="")
Remove all objects from the list.
Definition: THashList.cxx:168
R__EXTERN TSystem * gSystem
Definition: TSystem.h:549
static Bool_t IsStandardDraw(const char *selec)
Find out if this is a standard selection used for Draw actions (either TSelectorDraw, TProofDraw or deriving from them).
Definition: TSelector.cxx:237
virtual TObject * Remove(TObject *obj)
Remove object from the list.
Definition: TList.cxx:675
Int_t fSeqNum
Definition: TProof.h:556
TObject * Remove(TObject *obj)
Remove object from the list.
Definition: THashList.cxx:285
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:925
char * Form(const char *fmt,...)
A TEventList object is a list of selected events (entries) in a TTree.
Definition: TEventList.h:33
Handles synchronous and a-synchronous timer events.
Definition: TTimer.h:57
virtual void SetFinalized()
Definition: TQueryResult.h:99
TStopwatch fQuerySTW
Definition: TProof.h:623
Int_t ReinitSelector(TQueryResult *qr)
Reinitialize fSelector using the selector files in the query result.
void SetName(const char *name)
Definition: TCollection.h:116
virtual void Terminate()
Definition: TSelector.h:78
void StoreFeedback(TObject *slave, TList *out)
Store feedback results from the specified slave.
#define Printf
Definition: TGeoToOCC.h:18
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
virtual Int_t RedirectOutput(const char *name, const char *mode="a", RedirectHandle_t *h=0)
Redirect standard output (stdout, stderr) to the specified file.
Definition: TSystem.cxx:1678
long Long_t
Definition: RtypesCore.h:50
TMacro * GetSelecImp() const
Definition: TQueryResult.h:136
TList * GetInputList()
Get input list.
Definition: TProof.cxx:9725
R__EXTERN TProof * gProof
Definition: TProof.h:1107
TSelector * fSelector
Definition: TProofPlayer.h:86
EQueryMode GetQueryMode(Option_t *mode=0) const
Find out the query mode based on the current setting and &#39;mode&#39;.
Definition: TProof.cxx:6091
Int_t GetParallel() const
Returns number of slaves active in parallel mode.
Definition: TProof.cxx:2282
TMap implements an associative array of (key,value) pairs using a THashTable for efficient retrieval ...
Definition: TMap.h:44
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:9584
int nentries
Definition: THbookFile.cxx:89
The TH1 histogram class.
Definition: TH1.h:80
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...
virtual void Clear(Option_t *option="")
Remove all objects from the list.
Definition: TList.cxx:349
const char * GetType() const
Definition: TDSet.h:228
void SetSelectorDataMembersFromOutputList()
Set the selector&#39;s data members: find the mapping of data members to otuput list entries in the outpu...
Long64_t Finalize(Int_t query=-1, Bool_t force=kFALSE)
Finalize the qry-th query in fQueries.
Definition: TProof.cxx:5855
virtual void SetOption(const char *option)
Definition: TSelector.h:71
virtual Int_t DrawCanvas(TObject *obj)
Draw the object if it is a canvas.
Mother of all ROOT objects.
Definition: TObject.h:37
virtual TObject * Clone(const char *newname="") const
Make a clone of an object using the Streamer facility.
Definition: TObject.cxx:204
virtual void Add(TObject *obj)
Definition: TList.h:81
void SetObject(TObject *object)
Set the object to be notified at time out.
Definition: TTimer.cxx:184
virtual TList * GetInputList() const
Definition: TSelector.h:75
R__EXTERN Int_t gDebug
Definition: Rtypes.h:128
Int_t Atoi() const
Return integer value of string.
Definition: TString.cxx:1965
TVirtualPacketizer * fPacketizer
Definition: TProofPlayer.h:304
void Reset()
Definition: TStopwatch.h:54
static void Stop()
Terminate the PROOF statistics run.
Definition: TPerfStats.cxx:764
Bool_t IsParallel() const
Definition: TProof.h:969
Bool_t fCreateSelObj
the latest selector
Definition: TProofPlayer.h:87
Definition: first.py:1
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:416
virtual Int_t GetSize() const
Definition: TCollection.h:95
A TSelector object is used by the TTree::Draw, TTree::Scan, TTree::Process to navigate in a TTree and...
Definition: TSelector.h:39
const char * GetObjName() const
Definition: TDSet.h:229
const Bool_t kTRUE
Definition: Rtypes.h:91
A List of entry numbers in a TTree or TChain.
Definition: TEntryList.h:27
Float_t GetInitTime() const
char name[80]
Definition: TGX11.cxx:109
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:911
virtual TList * GetOutputList() const
Definition: TSelector.h:76
virtual const char * GetTitle() const
Returns title of object.
Definition: TNamed.h:52
EExitStatus GetExitStatus() const
Definition: TProofPlayer.h:223
const char * GetDirectory() const
Definition: TDSet.h:230
Stopwatch class.
Definition: TStopwatch.h:30