PlexLoanPool Class Reference

#include <PlexLoanPool.h>

Inheritance diagram for PlexLoanPool:

List of all members.

Public Member Functions
virtual void	Config ()
virtual const Registry &	DefaultConfig () const
virtual void	SetConfigFromEnvironment ()
void	ClearPool (Bool_t shared, Bool_t modifiable)
void	PurgeComponents (UInt_t purgeMask=0)
bool	DoesValidPlexExist (const VldContext &vldc, Bool_t shared=kTRUE)
bool	PurgeDbiTableCache () const
void	Print (Option_t *option="") const
	PlexLoanPool ()
Static Public Member Functions
PlexLoanPool *	Instance ()
void	SaveToFile (const char *filename, bool recreate=true)
void	ReadFromFile (const char *filename)
Private Member Functions
	PlexLoanPool (const PlexLoanPool &plp)
virtual	~PlexLoanPool ()
Plexus *	GetPlexus (const VldContext &vldc, Bool_t shared)
Plexus *	GetExistingPlexus (const VldContext &vldc, Bool_t shared)
Plexus *	BuildPlexus (const VldContext &vldc)
Private Attributes
TObjArray	fSharedPlexusList
TObjArray	fPrivatePlexusList
Int_t	fMaxSharedUnref
Static Private Attributes
PlexLoanPool *	fgInstance = 0
Friends
class	PlexHandle
struct	Cleaner

---

Constructor & Destructor Documentation

PlexLoanPool::PlexLoanPool (   )

Definition at line 189 of file PlexLoanPool.cxx. References dfltMaxUnused, fgInstance, fPrivatePlexusList, fSharedPlexusList, and MSG. : fMaxSharedUnref(dfltMaxUnused) { // Default ctor -- called by self only if (fgInstance && fgInstance != this) { MSG("Plex",Msg::kWarning) << "PlexLoanPool ctor() called but global already exists" << " -- memory leak (existing one will be lost)" << endl; } fgInstance = this; MSG("Plex",Msg::kSynopsis) << "PlexLoanPool ctor" << endl; fSharedPlexusList.SetOwner(true); fPrivatePlexusList.SetOwner(true); }

PlexLoanPool::PlexLoanPool (  const PlexLoanPool &  plp  )  [private]

Definition at line 209 of file PlexLoanPool.cxx. References MSG. : TObject(plp), CfgConfigurable(plp) { // copy constuctor should never get called MSG("Plex",Msg::kFatal) << "PlexLoanPool copy constructor called" << endl; assert(0); }

PlexLoanPool::~PlexLoanPool (   )  [private, virtual]

Definition at line 219 of file PlexLoanPool.cxx. References fPrivatePlexusList, fSharedPlexusList, Registry::Get(), CfgConfigurable::GetConfig(), Registry::KeyExists(), MSG, and SaveToFile(). { // Destroy PlexLoanPool // Write out to Cache first (if requested) MSG("Plex",Msg::kSynopsis) << "PlexLoanPool shutdown" << endl; Registry& r = GetConfig(); if ( r.KeyExists("Cache") ) { const char* cache_location = ""; if ( r.Get("Cache",cache_location) && strlen(cache_location) ) { int dowrite = true; if ( ! r.Get("CacheWrite",dowrite) ) { MSG("Plex",Msg::kInfo) << "PlexLoanPool not configured for 'CacheWrite', assume " << dowrite << "." << endl; } if (dowrite) { MSG("Plex",Msg::kInfo) << "PlexLoanPool writing file " << cache_location << " ..." << flush; PlexLoanPool::SaveToFile(cache_location); MSG("Plex",Msg::kInfo) << " done" << endl; } } } // delete all the owned sub-objects fSharedPlexusList.Delete(); fPrivatePlexusList.Delete(); }

---

Member Function Documentation

Plexus * PlexLoanPool::BuildPlexus (  const VldContext &  vldc  )  [private]

Definition at line 336 of file PlexLoanPool.cxx. References Detector::AsString(), VldContext::GetDetector(), VldContext::GetSimFlag(), MSG, and Plexus::Plexus(). Referenced by GetPlexus(). { // create a new Plexus from whereever Bool_t use_dbi = true; switch (vldc.GetDetector()) { case Detector::kNear: break; case Detector::kFar: break; case Detector::kCalDet: break; default: // not a detector that has DBI info use_dbi = false; break; } Plexus *plexus = 0; if (use_dbi) { plexus = new Plexus(vldc); } else if (vldc.GetSimFlag() == SimFlag::kReroot) { // use the PlexusReroot if it's reroot data and the database // isn't in place (which is the preferred option) // // was: plexus = new PlexusReroot(vldc); // remove circular dependency by using RTTI-like info // for PlexusReroot default ctor picks up vldc from RerootExodus static bool first = true; if (first) { first = false; gROOT->LoadClass("PlexusReroot","libRerootExodus.so"); } void *ptr = gROOT->GetClass("PlexusReroot",kTRUE)->New(); if (!ptr) { MSG("Plex",Msg::kFatal) << "BuildPlexus failed to instantiate PlexusReroot " << vldc << endl; assert(0); } // can't dynamic_cast void* pointers // plexus = dynamic_cast<PlexusReroot*>(ptr); // plexus = dynamic_cast<Plexus *>(ptr); // PlexusReroot isn't know to be a base type for Plexus // plexus = (PlexusReroot *)(ptr); plexus = (Plexus *)(ptr); } else { // the database isn't there and it's not reroot data TString detname = Detector::AsString(vldc.GetDetector()); TString detNAME = detname; detNAME.ToUpper(); MSG("Plex",Msg::kFatal) << "BuildPlexus " << endl << " vldc "<< vldc << endl << " no database info for the " << detname << " detector (or this VldContext) is available yet" << endl << " or NO_" << detNAME << "_PLEX_DATABASE needs to be switched off in GNUmakefile" << endl; exit(1); } return plexus; }

void PlexLoanPool::ClearPool (  Bool_t  shared, Bool_t  modifiable )

Definition at line 141 of file PlexLoanPool.cxx. References fPrivatePlexusList, and fSharedPlexusList. { if (shared) fSharedPlexusList.Delete(); if (modifiable) fPrivatePlexusList.Delete(); }

void PlexLoanPool::Config (   )  [virtual]

Implements CfgConfigurable. Definition at line 79 of file PlexLoanPool.cxx. References fMaxSharedUnref, Registry::Get(), CfgConfigurable::GetConfig(), and MSG. { // Reconfigure after internal registry update MSG("Plex",Msg::kDebug) << "PlexLoanPool::Config " << endl; Registry& r = GetConfig(); // r.Print(); int tmpi; if (r.Get("MaxUnref",tmpi)) fMaxSharedUnref = tmpi; }

const Registry & PlexLoanPool::DefaultConfig (  void   )  const [virtual]

====================================================================== Eventually this might go in the database and load the configuration. This would take a name or something. ====================================================================== Reimplemented from CfgConfigurable. Definition at line 94 of file PlexLoanPool.cxx. References dfltMaxUnused, Nav::GetName(), Registry::LockValues(), Registry::Set(), and Registry::UnLockValues(). { //====================================================================== // The default configuration for this framework component //====================================================================== int itrue = 1; // Work around for Registry's lack of bool //int ifalse = 0; // Work around for Registry's lack of bool static Registry r; std::string name = this->GetName(); name += ".config.default"; r.SetName(name.c_str()); r.UnLockValues(); r.Set("MaxUnref", dfltMaxUnused); r.Set("Cache", ""); // use no cache by default r.Set("CacheWrite", itrue); // if cache used, write at job end r.Set("PurgeDbiTableCache", itrue); // purge Dbi cache when Plexus filled r.Set("Paranoia", 0); // paranoia level for input checking r.LockValues(); return r; }

bool PlexLoanPool::DoesValidPlexExist (  const VldContext &  vldc, Bool_t  shared = kTRUE )

Definition at line 166 of file PlexLoanPool.cxx. References GetExistingPlexus(). { // testing if ctor of PlexHandle will construct a new plexus. Plexus *plex = GetExistingPlexus(vldc,shared); if (plex) return true; else return false; }

Plexus * PlexLoanPool::GetExistingPlexus (  const VldContext &  vldc, Bool_t  shared )  [private]

Definition at line 308 of file PlexLoanPool.cxx. References Plexus::IsCompatible(), and MSG. Referenced by DoesValidPlexExist(), and GetPlexus(). { // Find the right plexus if it exists Plexus *plexus = 0; // plex should come from one of the two lists TObjArray* plexList = &fSharedPlexusList; if (!shared) plexList = &fPrivatePlexusList; // iterate from the back as that is what was added most recently // and thus most likely what we want TObjArrayIter iter(plexList,kIterBackward); // search the current list while ( ( plexus = dynamic_cast<Plexus *>(iter.Next()) ) ) { // check if it is compatible if ( plexus->IsCompatible(vldc) ) { // create another handle to this plexus MSG("Plex",Msg::kVerbose) << "GetPlexus returned found handle " << endl; return plexus; } } return 0; // found nothing appropriate }

Plexus * PlexLoanPool::GetPlexus (  const VldContext &  vldc, Bool_t  shared )  [private]

Definition at line 252 of file PlexLoanPool.cxx. References BuildPlexus(), Plexus::CountRef(), fSharedPlexusList, GetExistingPlexus(), MSG, and VldContext::Print(). Referenced by PlexHandle::PlexHandle(). { // Create/Find the right plexus to give to a handle Plexus *plexus = GetExistingPlexus(vldc,shared); if (plexus) return plexus; // no valid Plexus available, choose oen of the managed lists // plexus should be placed in TObjArray* plexList = &fSharedPlexusList; if (!shared) plexList = &fPrivatePlexusList; // first count the # of (other) unreferenced plexii Plexus *other_plex = 0; Int_t todelete = -fMaxSharedUnref; TObjArrayIter iter_cnt(plexList); while ( ( other_plex = (Plexus *)iter_cnt.Next() ) ) { if ( other_plex->CountRef() <= 0 ) todelete ++; } // if more unreferenced plexii than desired clean them out // iterate from the front (default) so oldest get cleaned out first if (todelete > 0) { TObjArrayIter iter_rm(plexList); while ( ( other_plex = (Plexus *)iter_rm.Next() ) && todelete > 0 ) { if (other_plex->CountRef() <= 0 ) { fSharedPlexusList.Remove(other_plex); delete other_plex; todelete--; } } // remove the spaces we freed up plexList->Compress(); MSG("Plex",Msg::kVerbose) << "GetPlexus removed old unref'd plexii" << endl; } // no valid Plexus available need to build one plexus = BuildPlexus(vldc); if ( !plexus ) { MSG("Plex",Msg::kFatal) << "PlexLoanPool failed to build for: " << endl; vldc.Print(); assert(plexus); } // append this new plexus into the list MSG("Plex",Msg::kVerbose) << "GetPlexus returned created new 'shared' Plexus " << endl; plexList->AddLast(plexus); return plexus; }

PlexLoanPool * PlexLoanPool::Instance (   )  [static]

Definition at line 49 of file PlexLoanPool.cxx. References PlexLoanPool::Cleaner::ClassIsUsed(), Registry::Get(), Registry::KeyExists(), Registry::LockKeys(), Registry::Merge(), MSG, and ReadFromFile(). Referenced by Plexus::BuildLedMaps(), Plexus::BuildPinDiodeMap(), Plexus::BuildPixelMaps(), Plexus::BuildReadoutMap(), PlexHandle::PlexHandle(), Plexus::Plexus(), SaveToFile(), and ExodusValidate::TestPlexHandle(). { // protect Singleton to ensure there is only one if (fgInstance == 0) { MSG("Plex",Msg::kSynopsis) << "PlexLoanPool instance creation" << endl; static PlexLoanPool::Cleaner c; // end-of-run clean up c.ClassIsUsed(); fgInstance = new PlexLoanPool; // initialize default configuration Registry& r = fgInstance->GetConfig(); r.SetName("PlexLoanPool Configuration"); r.Merge(fgInstance->DefaultConfig()); r.LockKeys(); fgInstance->SetConfigFromEnvironment(); fgInstance->Update(); // if Config has 'Cache' try reading that // do this here rather than in Config() so that it only happens // on the first creation (i.e. later Config's don't redo this) if ( r.KeyExists("Cache") ) { const char* cache_location = ""; if ( r.Get("Cache",cache_location) && strlen(cache_location) ) PlexLoanPool::ReadFromFile(cache_location); } } return fgInstance; }

void PlexLoanPool::Print (  Option_t *  option = ""  )  const

Definition at line 405 of file PlexLoanPool.cxx. References fPrivatePlexusList, fSharedPlexusList, CfgConfigurable::GetConfig(), MSG, option, Plexus::Print(), and Registry::Print(). Referenced by LoadPlex::Reco(), and ExodusValidate::TestPlexHandle(). { // Print info about the current loan pool Plexus *plexus; MSG("Plex",Msg::kVerbose) << "Print" << endl; GetConfig().Print(); cout << " --- Shared PlexLoanPool ---" << endl; TIter shared(&fSharedPlexusList); while ( ( plexus = (Plexus *)shared.Next() ) ) plexus->Print(option); cout << " --- Private PlexLoanPool ---" << endl; TIter nonshared(&fPrivatePlexusList); while ( ( plexus = (Plexus *)nonshared.Next() ) ) plexus->Print(option); cout << " --- End of PlexLoanPool ---" << endl; }

void PlexLoanPool::PurgeComponents (  UInt_t  purgeMask = 0  )

Definition at line 148 of file PlexLoanPool.cxx. References fPrivatePlexusList, fSharedPlexusList, and Plexus::PurgeComponents(). { // loop through plexii held by the loan pool and // have them purge themselves of unwanted components // (generally only done before writing loan pool out) Plexus *plexus = 0; TObjArrayIter iter_shared(&fSharedPlexusList); while (( plexus = dynamic_cast<Plexus*>(iter_shared.Next()) )) plexus->PurgeComponents(purgeMask); TObjArrayIter iter_private(&fPrivatePlexusList); while (( plexus = dynamic_cast<Plexus*>(iter_private.Next()) )) plexus->PurgeComponents(purgeMask); }

bool PlexLoanPool::PurgeDbiTableCache (   )  const

Definition at line 176 of file PlexLoanPool.cxx. References fgInstance, Registry::Get(), and CfgConfigurable::GetConfig(). Referenced by Plexus::BuildLedMaps(), Plexus::BuildPinDiodeMap(), Plexus::BuildPixelMaps(), and Plexus::BuildReadoutMap(). { // Does the config suggest that DbiTable caches should be purged // after the Plexus has been constructed? Registry& r = fgInstance->GetConfig(); int dopurge = true; // default r.Get("PurgeDbiTableCache",dopurge); return dopurge; }

void PlexLoanPool::ReadFromFile (  const char *  filename  )  [static]

Definition at line 442 of file PlexLoanPool.cxx. References fgInstance, fPrivatePlexusList, fSharedPlexusList, CfgConfigurable::GetConfig(), gSystem(), MSG, and Registry::RemoveKey(). Referenced by Instance(). { // read a PlexLoanPool from a file // ensure that there isn't a memory leak if a PlexLoanPool already exists // by merging the two if ( gSystem->AccessPathName(filename,kFileExists) ) { // note funky return value: FALSE is you _can_ access file MSG("Plex",Msg::kInfo) << "PlexLoanPool::ReadFromFile() no such file: " << filename << endl; return; } // bitch in general because it really isn't a good idea! MSG("Plex",Msg::kInfo) << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl << "PlexLoanPool::ReadFromFile() used to build some plexii. " << endl << "This is really not a safe thing to do in that it bypasses the" << endl << "database and thus is not subject to rolling updates. Any plex" << endl << "will thus reflect the status at the time the file was written" << endl << "and may be outdated. Use at your own risk." << endl << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << endl; PlexLoanPool* plpPrev = fgInstance; // save any existing global fgInstance = 0; // so we don't complain about a memory leak TFile f(filename); PlexLoanPool* plp = dynamic_cast<PlexLoanPool*>(f.Get("PlexLoanPool")); if (!plp) { // file didn't have any PlexLoanPool! MSG("Plex",Msg::kWarning) << "PlexLoanPool::ReadFromFile() found no pool in file:" << filename << endl; // revert to old fgInstance = plpPrev; } else if (plpPrev) { // file had a PlexLoanPool, but we already had one as well // merge the two MSG("Plex",Msg::kInfo) << "PlexLoanPool::ReadFromFile() will now merge newly read data " << "into prior loan pool" << endl; // make old loan pool the global one to preserve order fgInstance = plpPrev; // loop over elements of newly read pool and move them to global copy TObjArray *from, *to; for (int pubpriv = 0; pubpriv <= 1; ++pubpriv) { if (pubpriv) { from = &plp->fSharedPlexusList; to = &fgInstance->fSharedPlexusList; } else { from = &plp->fPrivatePlexusList; to = &fgInstance->fPrivatePlexusList; } for (int indx = 0; indx <= from->GetLast(); ++indx) { TObject* plexus = from->RemoveAt(indx); if (plexus) to->Add(plexus); } // loop over elements } // shared/private // delete newly read, but now empty, pool // inhibit writing it out though plp->GetConfig().RemoveKey("Cache"); delete plp; } }

void PlexLoanPool::SaveToFile (  const char *  filename, bool  recreate = true )  [static]

Definition at line 427 of file PlexLoanPool.cxx. References Instance(). Referenced by ~PlexLoanPool(). { // save a PlexLoanPool to a file PlexLoanPool* plp = PlexLoanPool::Instance(); // make sure there is one const char* fmode = "RECREATE"; if (!recreate) fmode = "UPDATE"; TFile f(filename,fmode); plp->Write(); f.Write(); f.Close(); }

void PlexLoanPool::SetConfigFromEnvironment (   )  [virtual]

Definition at line 120 of file PlexLoanPool.cxx. References gSystem(), MSG, CfgConfigurable::Set(), and UtilString::StringTok(). { // Setup configuration from ENV_PLEX environment variable // which conists of a semi-colon separated list of DBI // configuration requests. const char* strENV_PLEX = gSystem->Getenv("ENV_PLEX"); if ( strENV_PLEX == 0 || strlen(strENV_PLEX) == 0 ) return; MSG("Plex",Msg::kInfo) << "Configuring Plex from the environment variable ENV_PLEX:" << endl << " " << strENV_PLEX << endl; std::vector<std::string> configRequests; UtilString::StringTok(configRequests, strENV_PLEX, ";"); for (unsigned entry = 0; entry < configRequests.size(); ++entry) this->Set(configRequests[entry].c_str()); }

---

Friends And Related Function Documentation

friend struct Cleaner [friend]

Definition at line 64 of file PlexLoanPool.h.

friend class PlexHandle [friend]

Definition at line 25 of file PlexLoanPool.h.

---

Member Data Documentation

PlexLoanPool * PlexLoanPool::fgInstance = 0 [static, private]

Definition at line 44 of file PlexLoanPool.cxx. Referenced by PlexLoanPool(), PurgeDbiTableCache(), ReadFromFile(), and PlexLoanPool::Cleaner::~Cleaner().

Int_t PlexLoanPool::fMaxSharedUnref [private]

Definition at line 81 of file PlexLoanPool.h. Referenced by Config().

TObjArray PlexLoanPool::fPrivatePlexusList [private]

Definition at line 79 of file PlexLoanPool.h. Referenced by ClearPool(), PlexLoanPool(), Print(), PurgeComponents(), ReadFromFile(), and ~PlexLoanPool().

TObjArray PlexLoanPool::fSharedPlexusList [private]

Definition at line 78 of file PlexLoanPool.h. Referenced by ClearPool(), GetPlexus(), PlexLoanPool(), Print(), PurgeComponents(), ReadFromFile(), and ~PlexLoanPool().

---

The documentation for this class was generated from the following files:

• PlexLoanPool.h
• PlexLoanPool.cxx

---