Bdb packages | Design docs | Source docs | Guidelines | Recent releases
	Search | Site Map .

                 

---

/BdbClustering/BdbAbsBaseClustH.cc

Go to the documentation of this file.

//------------------------------------------------------------------------------
// File:
//      BdbAbsBaseClustH.cc
//
// Description:
//
//      
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory
//
// Author List:
//      Jacek Becla                Original Author
//
// Copyright Information:
//      Copyright (C) 1997      Stanford Linear Accelerator Center
//
//------------------------------------------------------------------------------

// ----------------------
// This Class's Header --
// ----------------------
#ifndef BDBABSBASECLUSTH_HH
#include "BdbClustering/BdbAbsBaseClustH.hh"
#endif

// ------------------------------
// Collaborating Class Headers --
// ------------------------------
#include "BdbApplication/BdbDomain.hh"
#include "BdbApplication/BdbDebug.hh"
#include "BdbApplication/BdbErrorSignal.hh"
#include "BdbApplication/BdbStatTimers.hh"
#include "BdbAccess/BdbDbAccessMgr.hh"
#include "BdbAccess/BdbContAccessMgr.hh"
#include "BdbAccess/BdbFSMgr.hh"
#include "BdbAccess/BdbClustHintSetupMgr.hh"
#include "BdbClustering/BdbComponent.hh"
#include "BdbClustering/BdbClusteringErrors.hh"
#include "BdbClustering/BdbFullContInfo.hh"

#include <algorithm>
#include <set>
using std::string;
#include "BbrStdUtils/BbrCollectionUtils.hh"


// ------------
// C Headers --
// ------------
extern "C" {
#include <sys/stat.h>     /* umask   */
#include <stdlib.h>       /* getenv  */
}



d_Long BdbAbsBaseClustH::_ctxId = BdbcInValidNestingOptToken;



// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//           CONSTRUCTOR / DESTRUCTOR
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


BdbAbsBaseClustH::BdbAbsBaseClustH(const BdbDomain& domain, 
                                   d_ULong maxWaitTime, 
                                   d_Boolean quiet)
                 : BdbFSSupportClustH(domain, quiet),
                                 _contPercentGrowth(10),
                                 _hashCont(0),
                                 _initPages(1), 
                                 _maxWaitTime(maxWaitTime),
                                 _usedDbs( new set<string*,BbrPtrLess> ),
                                 _filledConts( new set<BdbFullContInfo*,BbrPtrLess> )
{
    umask(0x002) ;              // rwxrwxr-x

   _compObj         = new BdbComponent() ;
   _dbHint          = 0;
   _contHint        = 0;
   _newDbFlag       = d_False;
   _newContFlag     = d_False;
   _changeAuthLevel = d_False;
   _recentTransID   = 1 ;

   if ( BdbcInValidNestingOptToken ==_ctxId ) {
       d_ULong theNr;
       theNr = BdbApplicationOrDomain::activeInstance()->issueOptToken();
       _ctxId = theNr;
   }

   _noUpdHintCalls = 0;
   _noPagesUsed    = 0;
   _noContExpand   = 0;
   _nrContsCreated = 0;
   _nrDbsCreated   = 0;
}


BdbAbsBaseClustH::BdbAbsBaseClustH(const BdbAbsBaseClustH& obj)
                  : BdbFSSupportClustH(obj),
                    _usedDbs( new set<string*,BbrPtrLess> ), 
                    _filledConts( new set<BdbFullContInfo*,BbrPtrLess> )
{
   _compObj           = new BdbComponent( *(obj._compObj) ) ;
   _dbHint            = obj._dbHint ;
   _contHint          = obj._contHint ;
   _hashCont          = obj._hashCont ;
   _initPages         = obj._initPages ;
   _contPercentGrowth = obj._contPercentGrowth ;
   _newDbFlag         = obj._newDbFlag ;
   _newContFlag       = obj._newContFlag ;
   _recentTransID     = obj._recentTransID ;
   _noUpdHintCalls    = obj._noUpdHintCalls;
   _noPagesUsed       = obj._noPagesUsed;
   _noContExpand      = obj._noContExpand;
   _nrContsCreated    = obj._nrContsCreated; 
   _nrDbsCreated      = obj._nrDbsCreated; 
   *_usedDbs          = *(obj._usedDbs);
   *_filledConts      = *(obj._filledConts);
}


BdbAbsBaseClustH::~BdbAbsBaseClustH()
{
    COUT1 << "Clustering hint statistics, for \"" << compObj()->name() << "\":\n"
          << "    nr updatedHint calls      =  " << _noUpdHintCalls << endl;

    if ( 0 < _noUpdHintCalls ) {
        _noContExpand -= _nrContsCreated;
        if ( _noContExpand < 0 ) {
            _noContExpand = 0;
        }

        COUT1n << "    nr pages written          =  " << _noPagesUsed
               << "\n    nr of container expansion =  " << _noContExpand
               << "\n    nr of conts/dbs created   =  " << _nrContsCreated
               <<             "/" << _nrDbsCreated << endl; 
    }

    if ( _compObj != 0 ) {
        delete _compObj;
    }

    printUsedDbs();
    std::for_each(_usedDbs->begin(),_usedDbs->end(),babar::Collection::DeleteObject());
    delete _usedDbs;

    std::for_each(_filledConts->begin(),_filledConts->end(),babar::Collection::DeleteObject());
    delete _filledConts;
}



// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//           C U R R E N T     H I N T
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

BdbRefAny 
BdbAbsBaseClustH::hint()
{
   if ( BdbIsNull(contHint()) )
      updatedHint() ;

   return contHint() ;
}


void 
BdbAbsBaseClustH::prepareHint()
{
  if ( ! BdbIsNull(contHint()) )
      updatedHint() ;
}


// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//           S E T    C O M P O N E N T
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


BdbStatus 
BdbAbsBaseClustH::setComponent(const char* name)
{
#ifdef BDB_COLLECT_STATISTICS
    BdbApplicationOrDomain::activeInstance()->statTimers()._tinSetComp.start();
#endif
    const char* fn = "BdbAbsBaseClustH::setComponent";

    if ( name == 0 ) {
        return _es->BdbESig(BdbClusteringErrCompIsNul, fn);
    }

    if ( compObj()->isTheSameAs(name) ) {
#ifdef BDB_COLLECT_STATISTICS
    BdbApplicationOrDomain::activeInstance()->statTimers()._tinSetComp.stop();
#endif
        return BdbcSuccess ;
    }

   //d_Boolean applyRestr = d_False ;
   //if ( ! strcmp( domain()->domainName(), "events") )
   //    applyRestr = d_True ;
   d_Boolean applyRestr = d_True ;

   if ( compObj()->setC(name, applyRestr) != BdbcSuccess ) {
      return _es->BdbESig(BdbClusteringErrFunctionFailed, fn, name) ;
   }

#ifdef BDB_COLLECT_STATISTICS
    BdbApplicationOrDomain::activeInstance()->statTimers()._tinSetComp.stop();
#endif
   return BdbcSuccess ;
}



BdbStatus 
BdbAbsBaseClustH::changeAuthL(BdbDomain::AuthLevels authLevel, 
                              const char* name)
{
    const char* fn = "BdbAbsBaseClustH::changeAuthL";

    BdbDomain* theDomain = (BdbDomain*) domain() ;
    
    if ( theDomain->setAuthLevel(authLevel, name) != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                            "in setAuthLevel") ;
    }

    _changeAuthLevel = d_False ;

    return BdbcSuccess ;
}



BdbStatus
BdbAbsBaseClustH::setMaxWaitTime(d_ULong value)
{
    _maxWaitTime = value;
    return BdbcSuccess;
}


// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//       CREATE / OPEN / LOCK DB OR CONTAINER
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


// ----- database -----

BdbStatus 
BdbAbsBaseClustH::newDb(d_Boolean doReg, int dbid, d_Boolean isEvs)
{
   BdbDbAccessMgr aMgr ;
   BdbDbInfo dbInfoObj(currentDbName(), currentHost(), currentPath()) ;
   return aMgr.createDb(_dbHint, dbInfoObj, &_newDbFlag, doReg, dbid, 0, isEvs, ctxId()) ;
}


BdbStatus 
BdbAbsBaseClustH::openDb(const char* name, ooMode openMode)
{
   BdbDbAccessMgr aMgr ;
   return aMgr.openDb(_dbHint, name, openMode);
}


BdbStatus 
BdbAbsBaseClustH::lockDb(BdbHandle(BdbDBObj)& dbH)
{
   BdbDbAccessMgr aMgr ;
   return aMgr.lockDb(dbH, fsMgr()) ;
}


// ---- container -----

BdbStatus 
BdbAbsBaseClustH::newContainer(const char* name)
{
   BdbContAccessMgr aMgr;
   return aMgr.createContainer(_dbHint, _contHint, name, &_newContFlag, 
                                _hashCont, _initPages, _contPercentGrowth);
}


BdbStatus 
BdbAbsBaseClustH::openContainer(const char* name, 
                                ooMode openMode, 
                                int lockWait)
{
   if ( lockWait == -2 ) {
      lockWait = _maxWaitTime;
   }
   BdbContAccessMgr aMgr ;
   return aMgr.openContainer(_dbHint, _contHint, name, openMode, lockWait) ;
}


BdbStatus
BdbAbsBaseClustH::reacquireLock()
{
    const char* fn = "BdbAbsBaseClustH::reacquireLock";

    if ( BdbIsNull(contHint()) ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn, 
                            "contHint not initialized");
    }
#ifdef BDB_COLLECT_STATISTICS
    BdbApplicationOrDomain::activeInstance()->statTimers()._tinReAcqLock.start();
#endif
    BdbStatus stat = _contHint.update();
#ifdef BDB_COLLECT_STATISTICS
    BdbApplicationOrDomain::activeInstance()->statTimers()._tinReAcqLock.stop();
#endif
    return stat; 
}


// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//            R E S E T    H I N T S
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


BdbStatus  
BdbAbsBaseClustH::resetContHint()
{
   if ( ! BdbIsNull(_contHint) )
   {  _contHint.close() ;
      _contHint = 0 ;
   }

   return BdbcSuccess ;
}

BdbStatus 
BdbAbsBaseClustH::resetDbHint()
{
   const char* fn = "BdbAbsBaseClustH::resetDbHint";

   if ( ! BdbIsNull(_dbHint) )
   {  BdbStatus stat = lockDb(_dbHint) ;
      _dbHint = 0 ;
      if ( stat != BdbcSuccess )
         return _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                             _dbHint.name()) ;
   }

   return BdbcSuccess;
}

BdbStatus 
BdbAbsBaseClustH::resetHints()
{
    const char* fn = "BdbAbsBaseClustH::resetHints";

    if ( resetContHint() != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn, "in resetContHint") ;
    }

    if ( resetDbHint() != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn, "in resetDbHint") ;
    }

   return BdbcSuccess ;
}


// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//         R E S T A R T    T R A N S A C T I O N
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

BdbStatus 
BdbAbsBaseClustH::restartTransaction()
{
   const char* name = domain()->domainName() ;

   BdbApplicationOrDomain* app = BdbApplicationOrDomain::activeInstance() ;

   if ( app->commit(name) != BdbcSuccess )
      return _es->BdbESig(BdbClusteringErrTransactionError, "BdbAbsBaseClustH::restartTransaction", "commiting") ;

   if ( app->startUpdate(name) != BdbcSuccess )
      return _es->BdbESig(BdbClusteringErrTransactionError, "BdbAbsBaseClustH::restartTransaction", "starting") ;

        return BdbcSuccess ;
}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//          SET  CONTAINER  PARAMETERS
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


BdbStatus 
BdbAbsBaseClustH::setContainerParameters(d_ULong hashC, d_ULong initP, d_ULong percG)
{
    const char* fn = "BdbAbsBaseClustH::setContainerParameters";

    if (initP>=65535) { // objy limits
        return _es->BdbESig(BdbClusteringErrValueOutOfRange, fn, "initPages") ;
    }
    if (percG>1000) {
        return _es->BdbESig(BdbClusteringErrValueOutOfRange, fn, "percentageGrowth") ;
    }
    _hashCont = hashC ;
    _initPages = initP ;
    _contPercentGrowth = percG ;

    return BdbcSuccess ;
}


/**
 **  BdbAbsBaseClustH::transactionChanged()
 **
 **  The function returns d_True if current (main) transaction changed 
 **  since that function was called last time. It automatically changes 
 **  the "recent transaction ID", so it should not be called to often
 **/

d_Boolean
BdbAbsBaseClustH::transactionChanged()
{
    d_ULong currentID = BdbApplicationOrDomain::activeInstance()->transId();
    if ( _recentTransID < currentID ) {
        _recentTransID = currentID;
        return d_True;
    }
   return d_False;
}


// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//                   O T H E R S
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


d_Long
BdbAbsBaseClustH::ctxId()
{
    return _ctxId;
}


/**
 **  The function assumes, that the _dbHint handle is
 **  valid, and the db is already opened
 **/
BdbStatus
BdbAbsBaseClustH::registerCurrentDbAsUsed()
{
    if ( BdbClustHintSetupMgr::instance()->collectUsedDbsStats() ) {
        BdbRef(BdbDBObj) dbRef = dbHint();
        char str[16];
        sprintf(str, "%i", dbRef.get_DB());
        string *theDb = new string(str);
    
        if ( find(_usedDbs->begin(),_usedDbs->end(),theDb)==_usedDbs->end()) {
            _usedDbs->insert(theDb);
            COUT1 << "Db: \"" << dbHint().name() << "\" [" << str 
                  << "] registered on list of used dbs" << endl;
        }
    }
    return BdbcSuccess;
}



void
BdbAbsBaseClustH::printUsedDbs() const
{
    if ( ! BdbClustHintSetupMgr::instance()->collectUsedDbsStats() ) {
        return;    
    }
   
    set<string*,BbrPtrLess>::iterator next=_usedDbs->begin();
    string* item;
    while( next != _usedDbs->end() ) {
      item=*next;
        cout << "USEDDB: " << *item << endl;
        next++;
    }
}



void
BdbAbsBaseClustH::preregisterContAsFull(int db, int oc, long noP, const char* pcName, const char* sName)
{
    COUT1 << "DBSIZE: pre-registering full cont [" << db << "-" << oc 
          << "] with " << noP << " pages, pcN: " << pcName << ", sName: " << sName << endl;
    _filledConts->insert( new BdbFullContInfo(db, oc, noP, pcName, sName));
}

void
BdbAbsBaseClustH::registerContAsFull(int db, int oc, long noP) 
{
    set<BdbFullContInfo*,BbrPtrLess>::iterator next=_filledConts->begin();
    BdbFullContInfo* item;
    while( next != _filledConts->end() ) {
      item=*next;
        if ( item->dbid() == db && item->ocid() == oc ) {
            COUT1 << "DBSIZE: registering full cont [" << db << "-" << oc 
                  << "] with " << noP << " pages, (pcN: " << item->paramContName()
                  << ", sName: " << item->streamName() << ")" << endl;
            item->setNoPg(noP);
            return;
        }
        next++;
    }
    COUT1 << "[" << db << "-" << oc << "] not found, cannot register" << endl;
}


void
BdbAbsBaseClustH::preregisterCurrentContAsFull(long noP, const char* pcName, const char* sName)
{
    BdbRef(BdbContObj) contRef = contHint();
    if ( ! BdbIsNull(contRef) ) {
        int dbid   = contRef.get_DB();
        int contid = contRef.get_OC();
        preregisterContAsFull(dbid, contid, noP, pcName, sName);
        return;
    }
}




void
BdbAbsBaseClustH::registerCurrentContAsFull()
{
    BdbRef(BdbContObj) contRef = contHint();
    if ( ! BdbIsNull(contRef) ) {
        int dbid   = contRef.get_DB();
        int contid = contRef.get_OC();
        long noP   = contRef.nPage();
        registerContAsFull(dbid, contid, noP);
        return;
    }
}

 

---

BaBar Public Site | SLAC | News | Links | Who's Who | Contact Us

Page Owner: Jacek Becla
Last Update: October 04, 2002