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
static PlexLoanPool *	Instance ()
static void	SaveToFile (const char *filename, bool recreate=true)
static 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
static PlexLoanPool *	fgInstance = 0
Friends
class	PlexHandle
struct	Cleaner
Classes
struct	Cleaner

---

Detailed Description

Definition at line 23 of file PlexLoanPool.h.

---

Constructor & Destructor Documentation

PlexLoanPool::PlexLoanPool

(

)

Definition at line 189 of file PlexLoanPool.cxx.

References fgInstance, fPrivatePlexusList, fSharedPlexusList, Msg::kSynopsis, Msg::kWarning, 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::kFatal, and 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::kInfo, Msg::kSynopsis, 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(), Detector::kCalDet, Detector::kFar, Msg::kFatal, Detector::kNear, SimFlag::kReroot, 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(), Msg::kDebug, 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

(

)

const [virtual]

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 fPrivatePlexusList, fSharedPlexusList, Plexus::IsCompatible(), Msg::kVerbose, 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(), fMaxSharedUnref, fPrivatePlexusList, fSharedPlexusList, GetExistingPlexus(), Msg::kFatal, Msg::kVerbose, 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(), Msg::kSynopsis, 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::kVerbose, MSG, option, Plexus::Print(), and Registry::Print().

Referenced by 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().

{
   // 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::kInfo, Msg::kWarning, 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::kInfo, MSG, 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 71 of file PlexLoanPool.h.

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(), and GetPlexus().

TObjArray PlexLoanPool::fPrivatePlexusList [private]

Definition at line 79 of file PlexLoanPool.h.

Referenced by ClearPool(), GetExistingPlexus(), GetPlexus(), PlexLoanPool(), Print(), PurgeComponents(), ReadFromFile(), and ~PlexLoanPool().

TObjArray PlexLoanPool::fSharedPlexusList [private]

Definition at line 78 of file PlexLoanPool.h.

Referenced by ClearPool(), GetExistingPlexus(), GetPlexus(), PlexLoanPool(), Print(), PurgeComponents(), ReadFromFile(), and ~PlexLoanPool().

---

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

• PlexLoanPool.h
• PlexLoanPool.cxx

---