PlexLoanPool.cxx

Go to the documentation of this file.

// $Id: PlexLoanPool.cxx,v 1.30 2005/08/26 18:47:03 rhatcher Exp $
//
// PlexLoanPool
//
// PlexLoanPool is Singleton for managing the "active" Plexii
//
// Author:  R. Hatcher 2000.05.15
//

#include "Plex/PlexLoanPool.h"

#include <vector>

#include "TSystem.h"
#include "TROOT.h"
#include "TClass.h"
#include "TFile.h"

class PlexusReroot;

#include "Plex/Plexus.h"
#include "Plex/PlexHandle.h"
#include "Validity/VldContext.h"
#include "Validity/VldRange.h"
#include "Util/UtilString.h"

#include "MessageService/MsgService.h"
CVSID("$Id: PlexLoanPool.cxx,v 1.30 2005/08/26 18:47:03 rhatcher Exp $");

#ifndef CSTDLIB
#include <cstdlib>
#define CSTDLIB
#endif

#include <cassert>

ClassImp(PlexLoanPool)

//_____________________________________________________________________________
// Initialize static member

PlexLoanPool *PlexLoanPool::fgInstance = 0;

const Int_t dfltMaxUnused = 1;

//_____________________________________________________________________________
PlexLoanPool *PlexLoanPool::Instance()
{
// 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::Config()
{
  // 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
{
 //======================================================================
  // 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;

}

//_____________________________________________________________________________
void PlexLoanPool::SetConfigFromEnvironment()
{
  // 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());
}

//_____________________________________________________________________________
void PlexLoanPool::ClearPool(Bool_t shared, Bool_t modifiable)
{
   if (shared)     fSharedPlexusList.Delete();
   if (modifiable) fPrivatePlexusList.Delete();
}

//_____________________________________________________________________________
void PlexLoanPool::PurgeComponents(UInt_t purgeMask)
{
  // 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::DoesValidPlexExist(const VldContext& vldc, Bool_t shared)
{
   // testing if ctor of PlexHandle will construct a new plexus.

   Plexus *plex = GetExistingPlexus(vldc,shared);
   if (plex) return true;
   else      return false;
}

//_____________________________________________________________________________
bool PlexLoanPool::PurgeDbiTableCache() const
{
   // 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;

}

//_____________________________________________________________________________
PlexLoanPool::PlexLoanPool()
   : 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)
  : TObject(plp), CfgConfigurable(plp)
{
   // copy constuctor should never get called
   MSG("Plex",Msg::kFatal) << 
               "PlexLoanPool copy constructor called" << endl;
   assert(0);
}

//_____________________________________________________________________________
PlexLoanPool::~PlexLoanPool()
{
  // 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();
}

//_____________________________________________________________________________
Plexus* PlexLoanPool::GetPlexus(const VldContext& vldc, Bool_t shared)
{
   // 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;

}

//_____________________________________________________________________________
Plexus* PlexLoanPool::GetExistingPlexus(const VldContext& vldc, Bool_t shared)
{
   // 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::BuildPlexus(const VldContext& vldc)
{
   // 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::Print(Option_t *option) const
{
// 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::SaveToFile(const char* filename, bool recreate)
{
  // 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::ReadFromFile(const char* filename)
{
  // 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;
  }

}

//_____________________________________________________________________________

---