ROOT » PROOF » PROOF » TProofLite

class TProofLite: public TProof


TProofLite

This class starts a PROOF session on the local machine: no daemons,
client and master merged, communications via UNIX-like sockets.
By default the number of workers started is NumberOfCores+1; a
different number can be forced on construction.


Function Members (Methods)

public:
virtual~TProofLite()
voidTObject::AbstractMethod(const char* method) const
Int_tTProof::ActivateWorker(const char* ord, Bool_t save = kTRUE)
voidTProof::AddChain(TChain* chain)
Int_tTProof::AddDynamicPath(const char* libpath, Bool_t onClient = kFALSE, TList* wrks = 0, Bool_t doCollect = kTRUE)
static voidTProof::AddEnvVar(const char* name, const char* value)
voidTProof::AddFeedback(const char* name)
Int_tTProof::AddIncludePath(const char* incpath, Bool_t onClient = kFALSE, TList* wrks = 0, Bool_t doCollect = kTRUE)
voidTProof::AddInput(TObject* obj)
voidTProof::AddInputData(TObject* obj, Bool_t push = kFALSE)
virtual voidTObject::AppendPad(Option_t* option = "")
Int_tTProof::Archive(Int_t query, const char* url)
Int_tTProof::Archive(const char* queryref, const char* url = 0)
static Bool_tTQObject::AreAllSignalsBlocked()
Bool_tTQObject::AreSignalsBlocked() const
static Bool_tTQObject::BlockAllSignals(Bool_t b)
Bool_tTQObject::BlockSignals(Bool_t b)
virtual voidTProof::Browse(TBrowser* b)
virtual Bool_tCancelStagingDataSet(const char* dataset)
voidTProof::cd(Int_t id = -1)
virtual voidTQObject::ChangedBy(const char* method)SIGNAL
static TClass*Class()
virtual const char*TObject::ClassName() const
Int_tTProof::CleanupSession(const char* sessiontag)
virtual voidTNamed::Clear(Option_t* option = "")
virtual voidClearCache(const char* file = 0)
voidTProof::ClearData(UInt_t what = kUnregistered, const char* dsname = 0)
virtual voidClearDataSetCache(const char* dataset = 0)
voidTProof::ClearFeedback()
voidTProof::ClearInput()
voidTProof::ClearInputData(TObject* obj = 0)
voidTProof::ClearInputData(const char* name)
Int_tTProof::ClearPackage(const char* package)
Int_tTProof::ClearPackages()
virtual TObject*TNamed::Clone(const char* newname = "") const
voidTProof::Close(Option_t* option = "")
voidTProof::CloseProgressDialog()SIGNAL
voidTQObject::CollectClassSignalLists(TList& list, TClass* cls)
virtual Int_tTNamed::Compare(const TObject* obj) const
Bool_tTQObject::Connect(const char* signal, const char* receiver_class, void* receiver, const char* slot)
static Bool_tTQObject::Connect(TQObject* sender, const char* signal, const char* receiver_class, void* receiver, const char* slot)
static Bool_tTQObject::Connect(const char* sender_class, const char* signal, const char* receiver_class, void* receiver, const char* slot)
virtual voidTQObject::Connected(const char*)
virtual voidTNamed::Copy(TObject& named) const
TDrawFeedback*TProof::CreateDrawFeedback()
voidTProof::DataSetStatus(const char* msg, Bool_t status, Int_t done, Int_t total)SIGNAL
Int_tTProof::DeactivateWorker(const char* ord, Bool_t save = kTRUE)
static voidTProof::DelEnvVar(const char* name)
virtual voidTObject::Delete(Option_t* option = "")MENU
voidTProof::DeleteDrawFeedback(TDrawFeedback* f)
voidTProof::DeleteParameters(const char* wildcard)
virtual voidTQObject::Destroyed()SIGNAL
voidTProof::Detach(Option_t* opt = "")
voidTProof::DisableGoAsyn()
Bool_tTQObject::Disconnect(const char* signal = 0, void* receiver = 0, const char* slot = 0)
static Bool_tTQObject::Disconnect(TQObject* sender, const char* signal = 0, void* receiver = 0, const char* slot = 0)
static Bool_tTQObject::Disconnect(const char* class_name, const char* signal, void* receiver = 0, const char* slot = 0)
virtual voidTQObject::Disconnected(const char*)
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
Int_tTProof::DownloadPackage(const char* par, const char* dstdir = 0)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual Long64_tDrawSelect(TDSet* dset, const char* varexp, const char* selection = "", Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0)
virtual voidTObject::Dump() constMENU
virtual Int_tTProof::Echo(const TObject* obj)
virtual Int_tTProof::Echo(const char* str)
voidTQObject::Emit(const char* signal)
voidTQObject::Emit(const char* signal, Long_t* paramArr)
voidTQObject::Emit(const char* signal, const char* params)
voidTQObject::Emit(const char* signal, Double_t param)
voidTQObject::Emit(const char* signal, Long_t param)
voidTQObject::Emit(const char* signal, Long64_t param)
voidTQObject::Emit(const char* signal, Bool_t param)
voidTQObject::Emit(const char* signal, Char_t param)
voidTQObject::Emit(const char* signal, UChar_t param)
voidTQObject::Emit(const char* signal, Short_t param)
voidTQObject::Emit(const char* signal, UShort_t param)
voidTQObject::Emit(const char* signal, Int_t param)
voidTQObject::Emit(const char* signal, UInt_t param)
voidTQObject::Emit(const char* signal, ULong_t param)
voidTQObject::Emit(const char* signal, ULong64_t param)
voidTQObject::Emit(const char* signal, Float_t param)
voidTQObject::EmitVA(const char* signal, Int_t nargs)
voidTQObject::EmitVA(const char* signal, Int_t nargs, va_list va)
Int_tTProof::EnablePackage(const char* package, Bool_t notOnClient = kFALSE, TList* workers = 0)
Int_tTProof::EnablePackage(const char* package, const char* loadopts, Bool_t notOnClient = kFALSE, TList* workers = 0)
Int_tTProof::EnablePackage(const char* package, TList* loadopts, Bool_t notOnClient = kFALSE, TList* workers = 0)
virtual voidTObject::Error(const char* method, const char* msgfmt) const
Int_tTProof::Exec(const char* cmd, Bool_t plusMaster = kFALSE)
Int_tTProof::Exec(const char* cmd, const char* ord, Bool_t logtomacro = kFALSE)
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual Bool_tExistsDataSet(const char* uri)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
voidTProof::Feedback(TList* objs)SIGNAL
virtual voidTNamed::FillBuffer(char*& buffer)
Long64_tTProof::Finalize(Int_t query = -1, Bool_t force = kFALSE)
Long64_tTProof::Finalize(const char* queryref, Bool_t force = kFALSE)
TList*TProof::FindDataSets(const char* searchString, const char* optStr = "")
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
Long64_tTProof::GetBytesRead() const
Int_tTProof::GetClientProtocol() const
const char*TProof::GetConfDir() const
const char*TProof::GetConfFile() const
Float_tTProof::GetCpuTime() const
const char*TProof::GetDataPoolUrl() const
virtual TFileCollection*GetDataSet(const char* uri, const char* = 0)
TMap*TProof::GetDataSetQuota(const char* optStr = "")
virtual TMap*GetDataSets(const char* uri = "", const char* = 0)
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
TStringTProof::Getenv(const char* env, const char* ord = "0")
static const TList*TProof::GetEnvVars()
TList*TProof::GetFeedbackList() const
const char*TProof::GetGroup() const
virtual const char*TObject::GetIconName() const
const char*TProof::GetImage() const
TList*TProof::GetInputList()
TMacro*TProof::GetLastLog()
TList*TQObject::GetListOfClassSignals() const
TList*TQObject::GetListOfConnections() const
TList*TProof::GetListOfEnabledPackages()
TList*TProof::GetListOfPackages()
virtual TList*GetListOfQueries(Option_t* opt = "")
TList*TQObject::GetListOfSignals() const
TList*TProof::GetListOfSlaveInfos()
TList*TProof::GetLoadedMacros() const
voidTProof::GetLog(Int_t start = -1, Int_t end = -1)
Int_tTProof::GetLogLevel() const
TMacro*TProof::GetMacroLog()
TProofMgr*TProof::GetManager()
const char*TProof::GetMaster() const
voidTProof::GetMaxQueries()
TFileCollection*TProof::GetMissingFiles(TQueryResult* qr = 0)
virtual const char*TNamed::GetName() const
Int_tTProof::GetNumberOfDrawQueries()
Int_tTProof::GetNumberOfQueries()
static Int_tGetNumberOfWorkers(const char* url = 0)
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
TObject*TProof::GetOutput(const char* name)
static TObject*TProof::GetOutput(const char* name, TList* out)
TList*TProof::GetOutputList()
TList*TProof::GetOutputNames()
Int_tTProof::GetParallel() const
TObject*TProof::GetParameter(const char* par) const
static Int_tTProof::GetParameter(TCollection* c, const char* par, TString& value)
static Int_tTProof::GetParameter(TCollection* c, const char* par, Int_t& value)
static Int_tTProof::GetParameter(TCollection* c, const char* par, Long_t& value)
static Int_tTProof::GetParameter(TCollection* c, const char* par, Long64_t& value)
static Int_tTProof::GetParameter(TCollection* c, const char* par, Double_t& value)
Int_tTProof::GetPort() const
TProof::EQueryModeTProof::GetQueryMode(Option_t* mode = 0) const
TQueryResult*TProof::GetQueryResult(const char* ref = 0)
TList*TProof::GetQueryResults()
Int_tTProof::GetRC(const char* RCenv, Int_t& env, const char* ord = "0")
Int_tTProof::GetRC(const char* RCenv, Double_t& env, const char* ord = "0")
Int_tTProof::GetRC(const char* RCenv, TString& env, const char* ord = "0")
Float_tTProof::GetRealTime() const
Int_tTProof::GetRemoteProtocol() const
TProof::ERunStatusTProof::GetRunStatus() const
Int_tTProof::GetSeqNum() const
Int_tTProof::GetSessionID() const
const char*TProof::GetSessionTag() const
virtual TFileCollection*GetStagingStatusDataSet(const char* dataset)
voidTProof::GetStatistics(Bool_t verbose = kFALSE)
Int_tTProof::GetStatus() const
virtual const char*TNamed::GetTitle() const
virtual TTree*GetTreeHeader(TDSet* tdset)
virtual UInt_tTObject::GetUniqueID() const
const char*TProof::GetUrl()
const char*TProof::GetUser() const
const char*TProof::GetWorkDir() const
voidTProof::GoAsynchronous()
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual Bool_tTQObject::HasConnection(const char* signal_name) const
virtual ULong_tTNamed::Hash() const
virtual voidTQObject::HighPriority(const char* signal_name, const char* slot_name = 0)
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
Bool_tTProof::IsDataReady(Long64_t& totalbytes, Long64_t& bytesready)
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTProof::IsFolder() const
Bool_tTProof::IsIdle() const
Bool_tTProof::IsLite() const
Bool_tTProof::IsMaster() const
Bool_tTObject::IsOnHeap() const
Bool_tTProof::IsParallel() const
Bool_tTProof::IsProofd() const
virtual Bool_tTNamed::IsSortable() const
Bool_tTProof::IsTty() const
Bool_tTProof::IsValid() const
Bool_tTProof::IsWaiting() const
Bool_tTObject::IsZombie() const
virtual Int_tLoad(const char* macro, Bool_t notOnClient = kFALSE, Bool_t uniqueOnly = kTRUE, TList* wrks = 0)
voidTProof::LogMessage(const char* msg, Bool_t all)SIGNAL
static voidTProof::LogViewer(const char* url = 0, Int_t sessionidx = 0)
virtual voidTQObject::LowPriority(const char* signal_name, const char* slot_name = 0)
virtual voidTNamed::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
virtual voidTQObject::Message(const char* msg)SIGNAL
static TProofMgr*TProof::Mgr(const char* url)
virtual Bool_tTObject::Notify()
virtual Int_tTQObject::NumberOfConnections() const
virtual Int_tTQObject::NumberOfSignals() const
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static TProof*TProof::Open(const char* url = 0, const char* conffile = 0, const char* confdir = 0, Int_t loglevel = 0)
voidTObject::operator delete(void* ptr)
voidTObject::operator delete(void* ptr, void* vp)
voidTObject::operator delete[](void* ptr)
voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
virtual voidTObject::Paint(Option_t* option = "")
Int_tTProof::Ping()
virtual voidTObject::Pop()
virtual voidPrint(Option_t* option = "") const
virtual Long64_tProcess(const char* sel, Long64_t nent, Option_t* o = "")
virtual Long64_tProcess(TSelector* sel, Long64_t nent, Option_t* o = "")
virtual Long64_tProcess(TDSet* dset, const char* sel, Option_t* o = "", Long64_t nent = -1, Long64_t fst = 0)
virtual Long64_tProcess(TFileCollection* fc, const char* sel, Option_t* o = "", Long64_t nent = -1, Long64_t fst = 0)
virtual Long64_tProcess(TDSet* dset, TSelector* sel, Option_t* o = "", Long64_t nent = -1, Long64_t fst = 0)
virtual Long64_tProcess(TFileCollection* fc, TSelector* sel, Option_t* o = "", Long64_t nent = -1, Long64_t fst = 0)
virtual Long64_tProcess(const char* dsname, const char* sel, Option_t* o = "", Long64_t nent = -1, Long64_t fst = 0, TObject* enl = 0)
virtual Long64_tProcess(const char* dsname, TSelector* sel, Option_t* o = "", Long64_t nent = -1, Long64_t fst = 0, TObject* enl = 0)
voidTProof::Progress(Long64_t total, Long64_t processed)SIGNAL
voidTProof::Progress(Long64_t total, Long64_t processed, Long64_t bytesread, Float_t initTime, Float_t procTime, Float_t evtrti, Float_t mbrti)SIGNAL
voidTProof::Progress(Long64_t total, Long64_t processed, Long64_t bytesread, Float_t initTime, Float_t procTime, Float_t evtrti, Float_t mbrti, Int_t actw, Int_t tses, Float_t eses)SIGNAL
voidTProof::PutLog(TQueryResult* qr)
voidTProof::QueryResultReady(const char* ref)SIGNAL
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
virtual Bool_tRegisterDataSet(const char* dsName, TFileCollection* ds, const char* opt = "")
Int_tRemove(const char* ref, Bool_t all)
voidTProof::RemoveChain(TChain* chain)
virtual Int_tRemoveDataSet(const char* uri, const char* = 0)
Int_tTProof::RemoveDynamicPath(const char* libpath, Bool_t onClient = kFALSE)
voidTProof::RemoveFeedback(const char* name)
Int_tTProof::RemoveIncludePath(const char* incpath, Bool_t onClient = kFALSE)
virtual Bool_tRequestStagingDataSet(const char* dataset)
static voidTProof::Reset(const char* url, Bool_t hard = kFALSE)
voidTObject::ResetBit(UInt_t f)
static voidTProof::ResetEnvVars()
voidTProof::ResetProgressDialog(const char* sel, Int_t sz, Long64_t fst, Long64_t ent)SIGNAL
voidTProof::ResetProgressDialogStatus()
Int_tTProof::Retrieve(Int_t query, const char* path = 0)
Int_tTProof::Retrieve(const char* queryref, const char* path = 0)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
Int_tTProof::SavePerfTree(const char* pf = 0, const char* qref = 0)
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
voidTProof::SendDataSetStatus(const char* msg, UInt_t n, UInt_t tot, Bool_t st)
Bool_tTProof::SendingLogToWindow() const
voidTProof::SendLogToWindow(Bool_t mode)
voidTProof::SetActive(Bool_t = kTRUE)
virtual voidTProof::SetAlias(const char* alias = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidTProof::SetDataPoolUrl(const char* url)
virtual Int_tSetDataSetTreeName(const char* dataset, const char* treename)
voidTProof::SetDrawFeedbackOption(TDrawFeedback* f, Option_t* opt)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidTProof::SetInputDataFile(const char* datafile)
voidTProof::SetLogLevel(Int_t level, UInt_t mask = TProofDebug::kAll)
voidTProof::SetManager(TProofMgr* mgr)
voidTProof::SetMaxDrawQueries(Int_t max)
virtual voidTNamed::SetName(const char* name)MENU
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
static voidTObject::SetObjectStat(Bool_t stat)
Int_tTProof::SetParallel(Int_t nodes = -1, Bool_t random = kFALSE)
voidTProof::SetParameter(const char* par, const char* value)
voidTProof::SetParameter(const char* par, Int_t value)
voidTProof::SetParameter(const char* par, Long_t value)
voidTProof::SetParameter(const char* par, Long64_t value)
voidTProof::SetParameter(const char* par, Double_t value)
voidTProof::SetPerfTree(const char* pf = "perftree.root", Bool_t withWrks = kFALSE)
voidTProof::SetPrintProgress(PrintProgress_t pp)
voidTProof::SetProgressDialog(Bool_t on = kTRUE)
voidTProof::SetQueryMode(TProof::EQueryMode mode)
voidTProof::SetRealTimeLog(Bool_t on = kTRUE)
virtual voidTNamed::SetTitle(const char* title = "")MENU
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowCache(Bool_t all = kFALSE)
virtual voidShowData()
voidTProof::ShowDataSet(const char* dataset = "", const char* opt = "filter:SsCc")
virtual voidShowDataSetCache(const char* dataset = 0)
voidTProof::ShowDataSetQuota(Option_t* opt = 0)
virtual voidShowDataSets(const char* uri = "", const char* = 0)
voidTProof::ShowEnabledPackages(Bool_t all = kFALSE)
voidTProof::ShowFeedback() const
voidTProof::ShowLog(Int_t qry = -1)
voidTProof::ShowLog(const char* queryref)
virtual voidShowMembers(TMemberInspector& insp) const
voidTProof::ShowMissingFiles(TQueryResult* qr = 0)
voidTProof::ShowPackages(Bool_t all = kFALSE, Bool_t redirlog = kFALSE)
voidTProof::ShowParameters(const char* wildcard = "PROOF_*") const
voidTProof::ShowQueries(Option_t* opt = "")
virtual voidTProof::ShowStagingStatusDataSet(const char* dataset, const char* optStr = "filter:SsCc")
virtual Int_tTNamed::Sizeof() const
voidTProof::StartupMessage(const char* msg, Bool_t status, Int_t done, Int_t total)SIGNAL
voidTProof::StopProcess(Bool_t abort, Int_t timeout = -1)
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
voidTProof::Touch()
TProofLite(const char* masterurl, const char* conffile = kPROOF_ConfFile, const char* confdir = kPROOF_ConfDir, Int_t loglevel = 0, const char* alias = 0, TProofMgr* mgr = 0)
Int_tTProof::UploadDataSet(const char*, TList*, const char* = 0, Int_t = 0, TList* = 0)
Int_tTProof::UploadDataSet(const char*, const char*, const char* = 0, Int_t = 0, TList* = 0)
Int_tTProof::UploadDataSetFromFile(const char*, const char*, const char* = 0, Int_t = 0, TList* = 0)
Int_tTProof::UploadPackage(const char* par, TProof::EUploadPackageOpt opt = kUntar, TList* workers = 0)
virtual voidTObject::UseCurrentStyle()
Bool_tTProof::UseDynamicStartup() const
virtual Int_tVerifyDataSet(const char* uri, const char* = 0)
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
Int_tTProof::AddWorkers(TList* wrks)
static Int_tTProof::AssertDataSet(TDSet* dset, TList* input, TDataSetManager* mgr, TString& emsg)
Int_tTProof::AssertPath(const char* path, Bool_t writable)
static Int_tTQObject::CheckConnectArgs(TQObject* sender, TClass* sender_class, const char* signal, TClass* receiver_class, const char* slot)
Int_tTProof::Collect(TProof::ESlaves list = kActive, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE)
Int_tTProof::Collect(TList* slaves, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE)
static Bool_tTQObject::ConnectToClass(TQObject* sender, const char* signal, TClass* receiver_class, void* receiver, const char* slot)
static Bool_tTQObject::ConnectToClass(const char* sender_class, const char* signal, TClass* receiver_class, void* receiver, const char* slot)
Int_tCopyMacroToCache(const char* macro, Int_t headerRequired = 0, TSelector** selector = 0, Int_t opt = 0)
TSlave*TProof::CreateSlave(const char* url, const char* ord, Int_t perf, const char* image, const char* workdir)
TSlave*TProof::CreateSubmaster(const char* url, const char* ord, const char* image, const char* msd, Int_t nwk = 1)
Int_tCreateSymLinks(TList* files)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
static Bool_tTProof::GetFileInCmd(const char* cmd, TString& fn)
static Int_tTProof::GetInputData(TList* input, const char* cachedir, TString& emsg)
TList*TProof::GetListOfActiveSlaves() const
TVirtualProofPlayer*TProof::GetPlayer() const
TPluginHandler*TProof::GetProgressDialog() const
Int_tTProof::GetSandbox(TString& sb, Bool_t assert = kFALSE, const char* rc = 0)
virtual void*TQObject::GetSender()
virtual const char*TQObject::GetSenderClassName() const
voidTProof::HandleLibIncPath(const char* what, Bool_t add, const char* dirs)
Int_tTProof::HandleOutputOptions(TString& opt, TString& target, Int_t action)
Int_tInit(const char* masterurl, const char* conffile, const char* confdir, Int_t loglevel, const char* alias = 0)
voidTProof::InitMembers()
virtual TVirtualProofPlayer*TProof::MakePlayer(const char* player = 0, TSocket* s = 0)
TProofQueryResult*MakeQueryResult(Long64_t nent, const char* opt, Long64_t fst, TDSet* dset, const char* selec)
voidTObject::MakeZombie()
voidTProof::PrepareInputDataFile(TString& dataFile)
Int_tTProof::RemoveWorkers(TList* wrks)
static Int_tTProof::SaveInputData(TQueryResult* qr, const char* cachedir, TString& emsg)
virtual voidTProof::SaveWorkerInfo()
Int_tTProof::SendFile(const char* file, Int_t opt = (kBinary | kForward | kCp | kCpBin), const char* rfile = 0, TSlave* sl = 0)
static Int_tTProof::SendInputData(TQueryResult* qr, TProof* p, TString& emsg)
voidTProof::SetDSet(TDSet* dset)
voidTProof::SetFeedback(TString& opt, TString& optfb, Int_t action)
voidTProof::SetPlayer(TVirtualProofPlayer* player)
voidSetQueryRunning(TProofQueryResult* pq)
Int_tSetupWorkers(Int_t opt = 0, TList* wrks = 0)
static void*TProof::SlaveStartupThread(void* arg)
virtual Bool_tTProof::StartSlaves(Bool_t attach = kFALSE)
static voidTProof::SystemCmd(const char* cmd, Int_t fdout)
TProofLite()
voidTProof::UpdateDialog()
virtual voidTProof::ValidateDSet(TDSet* dset)
Int_tTProof::VerifyDataSetParallel(const char* uri, const char* optStr)
private:
Int_tCleanupSandbox()
Int_tCreateSandbox()
virtual voidFindUniqueSlaves()
Int_tInitDataSetManager()
voidNotifyStartUp(const char* action, Int_t done, Int_t tot)
voidoperator=(const TProofLite&)
voidResolveKeywords(TString& s, const char* ord, const char* logfile)
virtual voidSendInputDataFile()
Int_tSetProofServEnv(const char* ord)
voidShowDataDir(const char* dirname)
TProofLite(const TProofLite&)

Data Members

public:
static TProof::ERunStatusTProof::kAborted
static TProof::EUploadOptTProof::kAppend
static TProof::EUploadOptTProof::kAskUser
static TProof::EQueryModeTProof::kAsync
static TProof::ESubMergerTProof::kBeMerger
static TObject::<anonymous>TObject::kBitMask
static TObject::EStatusBitsTObject::kCanDelete
static TObject::EStatusBitsTObject::kCannotPick
static TProof::EProofClearDataTProof::kDataset
static TProof::ERegisterOptTProof::kFailIfExists
static TProof::EProofClearDataTProof::kForceClear
static TObject::EStatusBitsTObject::kHasUUID
static TObject::EStatusBitsTObject::kInvalidObject
static TProof::EStatusBitsTProof::kIsClient
static TProof::EStatusBitsTProof::kIsMaster
static TObject::<anonymous>TObject::kIsOnHeap
static TObject::EStatusBitsTObject::kIsReferenced
static TProof::EStatusBitsTProof::kIsTopMaster
static TProof::ERegisterOptTProof::kMergeIfExists
static TProof::ESubMergerTProof::kMergerDown
static TObject::EStatusBitsTObject::kMustCleanup
static TProof::EStatusBitsTProof::kNewInputData
static TObject::EStatusBitsTObject::kNoContextMenu
static TProof::EUploadOptTProof::kNoOverwriteDataSet
static TObject::<anonymous>TObject::kNotDeleted
static TObject::EStatusBitsTObject::kObjInCanvas
static TProof::ESubMergerTProof::kOutputSent
static TProof::ESubMergerTProof::kOutputSize
static TObject::<anonymous>TObject::kOverwrite
static TProof::EUploadOptTProof::kOverwriteAllFiles
static TProof::EUploadOptTProof::kOverwriteDataSet
static TProof::ERegisterOptTProof::kOverwriteIfExists
static TProof::EUploadOptTProof::kOverwriteNoFiles
static TProof::EProofClearDataTProof::kPurge
static TProof::EUploadPackageOptTProof::kRemoveOld
static TProof::ERunStatusTProof::kRunning
static TProof::ESubMergerTProof::kSendOutput
static TObject::<anonymous>TObject::kSingleKey
static TProof::ESubMergerTProof::kStopMerging
static TProof::ERunStatusTProof::kStopped
static TProof::EQueryModeTProof::kSync
static TProof::EProofClearDataTProof::kUnregistered
static TProof::EUploadPackageOptTProof::kUntar
static TProof::EStatusBitsTProof::kUseProgressDialog
static TProof::EStatusBitsTProof::kUsingSessionGui
static TObject::<anonymous>TObject::kWriteDelete
static TObject::<anonymous>TObject::kZombie
protected:
TMonitor*TProof::fAllMonitormonitor activity on all valid slave sockets
TList*TProof::fAvailablePackageslist of available packages
TList*TProof::fBadSlavesdead slaves (subset of all slaves)
Long64_tTProof::fBytesReadynumber of bytes staged
Int_tTProof::fCollectTimeoutTimeout for (some) collect actions
TStringTProof::fConfDirdirectory containing cluster config information
TStringTProof::fConfFilefile containing config information
TStringTProof::fDataPoolUrldefault data pool entry point URL
Bool_tTProof::fDataReadytrue if data is ready to be analyzed
Bool_tTProof::fDynamicStartupare the workers started dynamically?
TList*TProof::fEnabledPackageslist of enabled packages
TStringTProof::fImagemaster's image name
TList*TQObject::fListOfConnections! list of connections to this object
TList*TQObject::fListOfSignals! list of signals from this object
TProofMgr*TProof::fManagermanager to which this session belongs (if any)
Bool_tTProof::fMasterServtrue if we are a master server
TStringTNamed::fNameobject identifier
Int_tTProof::fProtocolremote PROOF server protocol version number
TProof::EQueryModeTProof::fQueryModedefault query mode
TList*TProof::fRunningDSetsTemporary datasets used for async running
TSelector*TProof::fSelectorSelector to be processed, if any
TProofMgr::EServTypeTProof::fServTypetype of server: proofd, XrdProofd
Bool_tTQObject::fSignalsBlocked! flag used for suppression of signals
TList*TProof::fSlaveslist of all slave servers as in config file
TList*TProof::fTerminatedSlaveInfoslist of unique infos of terminated slaves
TStringTNamed::fTitleobject title
Long64_tTProof::fTotalBytesnumber of bytes to be analyzed
TUrlTProof::fUrlUrl of the master
static Bool_tTQObject::fgAllSignalsBlockedflag used for suppression of all signals
static TSemaphore*TProof::fgSemaphoresemaphore to control no of parallel startup threads
static TProof::ESlavesTProof::kActive
static TProof::ESlavesTProof::kAll
static TProof::ESlavesTProof::kAllUnique
static TProof::ESlavesTProof::kUnique
private:
TStringfCacheDirDirectory containing cache of user files
TProofLockPath*fCacheLockCache dir locker
TStringfDataSetDirDirectory containing info about known data sets
TDataSetManager*fDataSetManagerDataset manager
TDataSetManagerFile*fDataSetStgRepoDataset manager for staging requests
Bool_tfForkStartupStartup N-1 workers forking the first worker
Int_tfNWorkersNumber of workers
TQueryResultManager*fQMgrQuery-result manager
TStringfQueryDirDirectory containing query results and status
TProofLockPath*fQueryLockQuery dir locker
TPMERegexp*fReInvalidRegular expression matching invalid dataset URIs
TStringfSandboxPROOF sandbox root dir
TStringfSelectionInternal variable to pass drawing options
TServerSocket*fServSockServer socket to accept call backs
TStringfSockPathUNIX socket path for communication with workers
TStringfVarExpInternal variable to pass drawing options
static Int_tfgWrksMaxMax number of workers

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

TProofLite(const char* masterurl, const char* conffile = kPROOF_ConfFile, const char* confdir = kPROOF_ConfDir, Int_t loglevel = 0, const char* alias = 0, TProofMgr* mgr = 0)
 Create a PROOF environment. Starting PROOF involves either connecting
 to a master server, which in turn will start a set of slave servers, or
 directly starting as master server (if master = ""). Masterurl is of
 the form: [proof[s]://]host[:port]. Conffile is the name of the config
 file describing the remote PROOF cluster (this argument alows you to
 describe different cluster configurations).
 The default is proof.conf. Confdir is the directory where the config
 file and other PROOF related files are (like motd and noproof files).
 Loglevel is the log level (default = 1). User specified custom config
 files will be first looked for in $HOME/.conffile.
Int_t Init(const char* masterurl, const char* conffile, const char* confdir, Int_t loglevel, const char* alias = 0)
 Start the PROOF environment. Starting PROOF involves either connecting
 to a master server, which in turn will start a set of slave servers, or
 directly starting as master server (if master = ""). For a description
 of the arguments see the TProof ctor. Returns the number of started
 master or slave servers, returns 0 in case of error, in which case
 fValid remains false.
~TProofLite()
 Destructor
Int_t GetNumberOfWorkers(const char* url = 0)
 Static method to determine the number of workers giving priority to users request.
 Otherwise use the system information, if available, or just start
 the minimal number, i.e. 2 .
Int_t SetupWorkers(Int_t opt = 0, TList* wrks = 0)
 Start up PROOF workers.
void NotifyStartUp(const char* action, Int_t done, Int_t tot)
 Notify setting-up operation message
Int_t SetProofServEnv(const char* ord)
 Create environment files for worker 'ord'
void ResolveKeywords(TString& s, const char* ord, const char* logfile)
 Resolve some keywords in 's'
    <logfilewrk>, <user>, <rootsys>, <cpupin>
Int_t CreateSandbox()
 Create the sandbox for this session
void Print(Option_t* option = "") const
 Print status of PROOF-Lite cluster.
TProofQueryResult * MakeQueryResult(Long64_t nent, const char* opt, Long64_t fst, TDSet* dset, const char* selec)
 Create a TProofQueryResult instance for this query.
void SetQueryRunning(TProofQueryResult* pq)
 Set query in running state.
Long64_t DrawSelect(TDSet* dset, const char* varexp, const char* selection = "", Option_t* option = "", Long64_t nentries = -1, Long64_t firstentry = 0)
 Execute the specified drawing action on a data set (TDSet).
 Event- or Entry-lists should be set in the data set object using
 TDSet::SetEntryList.
 Returns -1 in case of error or number of selected events otherwise.
Long64_t Process(TDSet* dset, const char* sel, Option_t* o = "", Long64_t nent = -1, Long64_t fst = 0)
 Process a data set (TDSet) using the specified selector (.C) file.
 Entry- or event-lists should be set in the data set object using
 TDSet::SetEntryList.
 The return value is -1 in case of error and TSelector::GetStatus() in
 in case of success.
Int_t CreateSymLinks(TList* files)
 Create in each worker sandbox symlinks to the files in the list
 Used to make the cache information available to workers.
Int_t InitDataSetManager()
 Initialize the dataset manager from directives or from defaults
 Return 0 on success, -1 on failure
void ShowCache(Bool_t all = kFALSE)
 List contents of file cache. If all is true show all caches also on
 slaves. If everything is ok all caches are to be the same.
void ClearCache(const char* file = 0)
 Remove files from all file caches.
Int_t Load(const char* macro, Bool_t notOnClient = kFALSE, Bool_t uniqueOnly = kTRUE, TList* wrks = 0)
 Copy the specified macro in the cache directory. The macro file is
 uploaded if new or updated. If existing, the corresponding header
 basename(macro).h or .hh, is also uploaded. For the other arguments
 see TProof::Load().
 Returns 0 in case of success and -1 in case of error.
Int_t CopyMacroToCache(const char* macro, Int_t headerRequired = 0, TSelector** selector = 0, Int_t opt = 0)
 Copy a macro, and its possible associated .h[h] file,
 to the cache directory, from where the workers can get the file.
 If headerRequired is 1, return -1 in case the header is not found.
 If headerRequired is 0, try to copy header too.
 If headerRequired is -1, don't look for header, only copy macro.
 If the selector pionter is not 0, consider the macro to be a selector
 and try to load the selector and set it to the pointer.
 The mask 'opt' is an or of ESendFileOpt:
       kCpBin   (0x8)     Retrieve from the cache the binaries associated
                          with the file
       kCp      (0x10)    Retrieve the files from the cache
 Return -1 in case of error, 0 otherwise.
Int_t CleanupSandbox()
 Remove old sessions dirs keep at most 'Proof.MaxOldSessions' (default 10)
TList * GetListOfQueries(Option_t* opt = "")
 Get the list of queries.
Bool_t RegisterDataSet(const char* dsName, TFileCollection* ds, const char* opt = "")
 Register the 'dataSet' on the cluster under the current
 user, group and the given 'dataSetName'.
 Fails if a dataset named 'dataSetName' already exists, unless 'optStr'
 contains 'O', in which case the old dataset is overwritten.
 If 'optStr' contains 'V' the dataset files are verified (default no
 verification).
 Returns kTRUE on success.
Int_t SetDataSetTreeName(const char* dataset, const char* treename)
 Set/Change the name of the default tree. The tree name may contain
 subdir specification in the form "subdir/name".
 Returns 0 on success, -1 otherwise.
Bool_t ExistsDataSet(const char* uri)
 Returns kTRUE if 'dataset' described by 'uri' exists, kFALSE otherwise
TMap * GetDataSets(const char* uri = "", const char* = 0)
 lists all datasets that match given uri
void ShowDataSets(const char* uri = "", const char* = 0)
 Shows datasets in locations that match the uri
 By default shows the user's datasets and global ones
TFileCollection * GetDataSet(const char* uri, const char* = 0)
 Get a list of TFileInfo objects describing the files of the specified
 dataset.
Int_t RemoveDataSet(const char* uri, const char* = 0)
 Remove the specified dataset from the PROOF cluster.
 Files are not deleted.
Bool_t RequestStagingDataSet(const char* dataset)
 Allows users to request staging of a particular dataset. Requests are
 saved in a special dataset repository and must be honored by the endpoint.
 This is the special PROOF-Lite re-implementation of the TProof function
 and includes code originally implemented in TProofServ.
Bool_t CancelStagingDataSet(const char* dataset)
 Cancels a dataset staging request. Returns kTRUE on success, kFALSE on
 failure. Dataset not found equals to a failure. PROOF-Lite
 re-implementation of the equivalent function in TProofServ.
TFileCollection * GetStagingStatusDataSet(const char* dataset)
 Obtains a TFileCollection showing the staging status of the specified
 dataset. A valid dataset manager and dataset staging requests repository
 must be present on the endpoint. PROOF-Lite version of the equivalent
 function from TProofServ.
Int_t VerifyDataSet(const char* uri, const char* = 0)
 Verify if all files in the specified dataset are available.
 Print a list and return the number of missing files.
void ClearDataSetCache(const char* dataset = 0)
 Clear the content of the dataset cache, if any (matching 'dataset', if defined).
void ShowDataSetCache(const char* dataset = 0)
 Display the content of the dataset cache, if any (matching 'dataset', if defined).
void SendInputDataFile()
 Make sure that the input data objects are available to the workers in a
 dedicated file in the cache; the objects are taken from the dedicated list
 and / or the specified file.
 If the fInputData is empty the specified file is sent over.
 If there is no specified file, a file named "inputdata.root" is created locally
 with the content of fInputData and sent over to the master.
 If both fInputData and the specified file are not empty, a copy of the file
 is made locally and augmented with the content of fInputData.
Int_t Remove(const char* ref, Bool_t all)
 Handle remove request.
TTree * GetTreeHeader(TDSet* tdset)
 Creates a tree header (a tree with nonexisting files) object for
 the DataSet.
void FindUniqueSlaves()
 Add to the fUniqueSlave list the active slaves that have a unique
 (user) file system image. This information is used to transfer files
 only once to nodes that share a file system (an image). Submasters
 which are not in fUniqueSlaves are put in the fNonUniqueMasters
 list. That list is used to trigger the transferring of files to
 the submaster's unique slaves without the need to transfer the file
 to the submaster.
void ShowData()
 List contents of the data directory in the sandbox.
 This is the place where files produced by the client queries are kept
void ShowDataDir(const char* dirname)
 List contents of the data directory 'dirname'
TProofLite(const TProofLite& )
void operator=(const TProofLite& )
TProofLite()
{ }
Long64_t Process(TDSet* dset, const char* sel, Option_t* o = "", Long64_t nent = -1, Long64_t fst = 0)
{ return TProof::Process(fc, sel, o, nent, fst); }
Long64_t Process(const char* dsname, const char* sel, Option_t* o = "", Long64_t nent = -1, Long64_t fst = 0, TObject* enl = 0)
{ return TProof::Process(dsname, sel, o, nent, fst, enl); }
Long64_t Process(const char* sel, Long64_t nent, Option_t* o = "")
{ return TProof::Process(sel, nent, o); }
Long64_t Process(TDSet* dset, TSelector* sel, Option_t* o = "", Long64_t nent = -1, Long64_t fst = 0)
{ return TProof::Process(dset, sel, o, nent, fst); }
Long64_t Process(TFileCollection* fc, TSelector* sel, Option_t* o = "", Long64_t nent = -1, Long64_t fst = 0)
{ return TProof::Process(fc, sel, o, nent, fst); }
Long64_t Process(const char* dsname, TSelector* sel, Option_t* o = "", Long64_t nent = -1, Long64_t fst = 0, TObject* enl = 0)
{ return TProof::Process(dsname, sel, o, nent, fst, enl); }
Long64_t Process(TSelector* sel, Long64_t nent, Option_t* o = "")
{ return TProof::Process(sel, nent, o); }