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

                 

---

/BdbClustering/BdbAbsRegularClustH.cc

Go to the documentation of this file.

//------------------------------------------------------------------------------
// File:
//      BdbAbsRegularClustH.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 --
// ----------------------
#include "BdbClustering/BdbAbsRegularClustH.hh"

// ------------------------------
// Collaborating Class Headers --
// ------------------------------
#include "BdbApplication/BdbDomain.hh"
#include "BdbApplication/BdbDebug.hh"
#include "BdbApplication/BdbErrorSignal.hh"
#include "BdbApplication/BdbStatTimers.hh"
#include "BdbAccess/BdbFSMgr.hh"
#include "BdbAccess/BdbAccessErrors.hh"
#include "BdbAccess/BdbDbAccessMgr.hh"
#include "BdbAccess/BdbDomainSpec.hh"
#include "BdbAccess/BdbClustHintSetupMgr.hh"
#include "BdbAccess/BdbClusterConfigMgr.hh"
#include "BdbClustering/BdbComponent.hh"
#include "BdbClustering/BdbParamHandler.hh"
#include "BdbClustering/BdbClusteringErrors.hh"
#include "BdbClustering/BdbFullDbsMgr.hh"
#include "BdbClustering/BdbClustHAccess.hh"
#include "BdbClustering/BdbFullContInfo.hh"

// parallel database distribution broken



// ------------
// C Headers --
// ------------
extern "C" {
#include <unistd.h>   /* sleep */
#include <assert.h>
}



int      BdbAbsRegularClustH::_pid = getpid();


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



BdbAbsRegularClustH::BdbAbsRegularClustH(const BdbDomain& domain, 
                                         d_ULong maxWaitTime, 
                                         d_Boolean quiet) :
                              BdbAbsBaseClustH(domain, maxWaitTime, quiet)
{
    resetFullContainerFlag();
    enableOneContPerProcess();

    _nrPagesPerFullCont = 0;
    _forceNewDb    = d_False;
    _theStream     = 0;
    _reload        = d_True;
    _paramHandler  = new BdbParamHandler(this);
    _recentNrPages = 0;
    _maxContSize   = 0;
    _maxContNr     = 0;
    _dirWithRange  = 0;
    _curContNr     = 0;
    _createDb      = d_False;
}


BdbAbsRegularClustH::BdbAbsRegularClustH(const BdbAbsRegularClustH& ch)
    : BdbAbsBaseClustH(ch),
    _nrPagesPerFullCont(ch._nrPagesPerFullCont),
    _calcHintConstant(ch._calcHintConstant),
    _containerIsFull(ch._containerIsFull),
    _oneContainerPerProcess(ch._oneContainerPerProcess),
    _theStream(ch._theStream),
    _reload(ch._reload),
    _recentNrPages(ch._recentNrPages),
    _maxContSize(ch._maxContSize),
    _maxContNr(ch._maxContNr),
    _dirRange(ch._dirRange),
    _curContNr(ch._curContNr),
    _param(ch._param),
    _forceNewDb(ch._forceNewDb),
    _createDb(ch._createDb)
{
    if ( 0 == ch._dirWithRange ) {
        _dirWithRange = 0;
    } else {
        _dirWithRange = new char [strlen(ch._dirWithRange)+1];
        strcpy(_dirWithRange, ch._dirWithRange);
    }
      
    if ( 0 == ch._paramHandler ) {
        _paramHandler = 0;
    } else {
        _paramHandler = new BdbParamHandler(*(ch._paramHandler));
    }
}


BdbAbsRegularClustH::~BdbAbsRegularClustH()
{
    if ( _oneContainerPerProcess ) {
        registerExtraPages();
    }

    if ( _dirWithRange != (char*) 0 ) {
        delete [] _dirWithRange;
    }

    delete _paramHandler;
}


void
BdbAbsRegularClustH::registerExtraPages()
{
    int dbid = 0;
    int ocid = 0;
    
    // if possible, collect information about recently used
    // container
    if ( ! BdbIsNull(contHint()) ) {
        BdbApplicationOrDomain* app = BdbApplicationOrDomain::activeInstance();
        d_Boolean hasExactNr = d_False;
        BdbRef(BdbContObj) theRef = contHint();
        d_Boolean transStarted = app->mode() != BdbcNoOpen;
        d_ULong oldWait = app->lockWait();
        if ( ! transStarted ) {
            app->startNestedUpdate() ;
        }
        app->setLockWait(1);
        if ( theRef.update() == BdbcSuccess ) {
            _recentNrPages = theRef.nPage();
            hasExactNr = d_True;
            _noPagesUsed += _recentNrPages;
        }
        if ( ! transStarted ) {
            app->commitNested() ;
        }
        app->setLockWait(oldWait);

        if ( ! hasExactNr ) {
            int adjustment = 0;
            if ( _noPagesUsed > 0 ) {
                adjustment += (int) (_noUpdHintCalls / _noPagesUsed);
            }
            if ( _noUpdHintCalls < 10 ) { // if not enough statistics was 
                adjustment ++;            // collected, for safety add 1
            }
            COUT1 << "Adjusting (recentNoPages=" << _recentNrPages << ") +"
                  << adjustment << endl;
            _recentNrPages += adjustment;
        }

        dbid = theRef.get_DB();
        ocid = theRef.get_OC();
        
        COUT1 << "DBSIZE: most recently used cont [" << theRef.get_DB() 
              << "-" << theRef.get_OC() << "] has " << _recentNrPages << " pages" << endl;

        registerContAsFull(dbid, ocid, _recentNrPages);

        _recentNrPages = 0;
    }

    // now we are ready to go through the list of all containers
    // touched during the run and adjust page counters

    if( 0 >= _filledConts->size() ) {
        COUT1 << "DBSIZE: no containers registered" << endl;
        return;
    }

    set<BdbFullContInfo*,BbrPtrLess>::iterator next=_filledConts->begin();
    BdbFullContInfo* item;
    long extraP = 0;
    BdbFullContInfo* prevItem = 0;
    ooTVArray(d_ULong) closedConts;
    closedConts.resize(0);
    
    while( next!=_filledConts->end() ) {
      item=*next;
        dbid = item->dbid();
        if ( (prevItem != 0) && (dbid != prevItem->dbid()) ) {
            COUT1 << "DBSIZE: Switching to dbid " << item->dbid() << endl;
            if ( extraP > 0 ) {
                if ( extraP > 62500 ) {
                    _es->BdbESig(BdbClusteringErrFunctionFailed, "~BdbAbsRegularClustH",
                                 "number of extra pages > 62500 (1 GB)");
                } else {
                     COUT1 << "DBSIZE: Incrementing counter for dbid " << prevItem->dbid()
                           << " by " << extraP << " (pcN: " << prevItem->paramContName()
                           << ", sN: " << prevItem->streamName() << ")" << endl;
                     // since paraContName or streamName can be different now
                     // use cached values
                     _paramHandler->incrPageCounter(extraP, prevItem->dbid(), 
                                                    prevItem->paramContName(), 
                                                    prevItem->streamName());
                }
            }
            extraP = 0;
            closedConts.resize(0);
        }
        prevItem = item;

        long regPg = _nrPagesPerFullCont - item->noPg();
        COUT1 << "DBSIZE: [" << item->dbid() << "-" << item->ocid() << "] has "
              << item->noPg() << " pages, register "
              << _nrPagesPerFullCont << "-" << item->noPg() << "=" << regPg << endl;
        extraP += regPg;
        int s = closedConts.size();
        closedConts.resize(s+1);
        closedConts[s] = item->ocid();
        next++;
    }

    if ( (extraP > 0) && (prevItem != 0) ) {
        if ( extraP > 62500 ) {
            _es->BdbESig(BdbClusteringErrFunctionFailed, "~BdbAbsRegularClustH",
                         "number of extra pages > 62500 (1 GB)");
        } else {
             COUT1 << "DBSIZE: Incrementing counter for dbid " << prevItem->dbid()
                   << " by " << extraP << " (pcN: " << prevItem->paramContName()
                           << ", sN: " << prevItem->streamName() << ")" << endl;
             _paramHandler->incrPageCounter(extraP, prevItem->dbid(), 
                                            prevItem->paramContName(), 
                                            prevItem->streamName());
        }
    }
    extraP = 0;

}



BdbStatus 
BdbAbsRegularClustH::setComponent(const char* name)
{
    const char* fn = "BdbAbsRegularClustH::setComponent";

    if ( BdbAbsBaseClustH::setComponent(name) != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                            name);
    }

    return BdbcSuccess;
}



BdbStatus 
BdbAbsRegularClustH::setStream(const char* name)
{
    const char* fn = "BdbAbsRegularClustH::setStream";
    if ( name == 0 ) {
        return _es->BdbESig(BdbClusteringErrCompIsNul, fn); 
    }

    if ( streamName() != 0 ) {
        if ( ! strcmp(name, streamName()) ) {
            return BdbcSuccess;
        }
    }

    _theStream.resize(strlen(name)+1);
    _theStream = name;
    _reload    = d_True;

    return BdbcSuccess;
}

void
BdbAbsRegularClustH::forceNewContainer()
{
    setFullContainerFlag();
}


// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//     F I N A L    H I N T S    F U N C T I O N S
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



BdbRefAny 
BdbAbsRegularClustH::updatedHint()
{
#ifdef BDB_COLLECT_STATISTICS
    BdbApplicationOrDomain::activeInstance()->statTimers()._tinUpdHint1.start();
#endif

    _noUpdHintCalls++;

    const char* fn = "BdbAbsRegularClustH::updatedHint";

    if ( compObj()->isIllegal() ) {
        _es->BdbFSig(BdbClusteringErrComponentNotValid, fn);
        return 0;
    }

    if ( _changeAuthLevel ) {
        if ( changeAuthL(BdbDomain::Group, compObj()->name()) != BdbcSuccess ) {
            _es->BdbFSig(BdbClusteringErrFunctionFailed, fn,
                         "in changeAuthL");
            return 0;
        }
    }

    BdbApplicationOrDomain* theApp = BdbApplicationOrDomain::activeInstance();
    d_Long oldWait = theApp->lockWait();
    if ( oldWait != maxWaitTime() ) {
        theApp->setLockWait( maxWaitTime() );
    }

    if ( compObj()->componentChanged() || authLevelChanged() || authNameChanged() ) {

#ifdef BDB_COLLECT_STATISTICS
    BdbApplicationOrDomain::activeInstance()->statTimers()._tinRebFSInfo.start();
#endif
        if ( fsMgr()->rebuildFSInfo( domain()->domainName(), 
                                     domain()->authLevelName(),
                                     domain()->authName(), 
                                     ccompObj()->name() )) {
           ;  // be quiet on errors
        }
#ifdef BDB_COLLECT_STATISTICS
        BdbApplicationOrDomain::activeInstance()->statTimers()._tinRebFSInfo.stop();
#endif
#ifdef BDB_COLLECT_STATISTICS
        BdbApplicationOrDomain::activeInstance()->statTimers()._tinRelCompSp.start();
#endif
        BdbStatus stat = reloadCompSpecInfo();
#ifdef BDB_COLLECT_STATISTICS
        BdbApplicationOrDomain::activeInstance()->statTimers()._tinRelCompSp.stop();
#endif
        if ( stat != BdbcSuccess ) {
            theApp->setLockWait(oldWait);
            _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                         "in reloadCompSpecInfo");
            return 0;
        }

        if ( authLevelChanged() || authNameChanged() ) {
            resetHints();  // current dbHint is no longer valid
        }
        resetContHint();
    }
    refreshCurrentAuthLevel();
    refreshCurrentAuthName();

    if ( _reload ) {
        resetContHint();
        _reload = d_False;
    }

    d_Boolean allDone = d_False;
    do {
        if ( newDbRequested() ) {
            resetHints();
        }

        if ( BdbIsNull(contHint()) ) {
            if ( reload() != BdbcSuccess ) {
                theApp->setLockWait(oldWait);
                _es->BdbESig(BdbClusteringErrFunctionFailed, fn, "in reload");
                return 0;
            }
        }
        else {
            if ( transactionChanged() ) {
                COUT1 << "Transaction changed, reacquiring lock." << endl; 

                // The lock on the container has not been lost because the main 
                // transaction has been restarted. 
                // I need to reopen the container (lock has been lost).
                if ( reacquireLock() != BdbcSuccess ) {
                    theApp->setLockWait(oldWait);
                    _es->BdbESig(BdbClusteringErrFunctionFailed, fn, "in reacquireLock");
                    return 0;
                }
            } else {
                    // COUT1 << "no need to reopen a container" << endl; 
            }
        }

        if ( BdbIsNull(contHint()) ) {
            theApp->setLockWait(oldWait);
            _es->BdbESig(BdbClusteringErrHandleNotValid, fn, "container");
            return 0;
        }

        if ( currentContainerIsFull() ) {
            registerCurrentContAsFull();
            resetContHint();
            setFullContainerFlag();
        } else {
            allDone = d_True;
        }
    } while ( ! allDone );
    // this will handle situation, where updatedHint reloads info from 
    // db and opens a full container (useful eg. if only one object per 
    // job is created 

    theApp->setLockWait(oldWait);

    BdbRef(ooObj) theRef = contHint();

    oovTopDB = dbHint();
#ifdef BDB_COLLECT_STATISTICS
    BdbApplicationOrDomain::activeInstance()->statTimers()._tinUpdHint1.stop();
#endif
    return contHint();
}



BdbStatus
BdbAbsRegularClustH::reloadCompSpecInfo()
{
    const char* fn = "BdbAbsRegularClustH::reloadCompSpecInfo";

    // cache locally some limits
    BdbClustHintSetupMgr* chsMgr = BdbClustHintSetupMgr::instance();

    chsMgr->setStrings(BdbClusterConfigMgr::getClusterName(),
                       domain()->domainName(), 
                       domain()->authLevelName(),
                       domain()->authName(),
                       ccompObj()->name());

    _maxContSize = chsMgr->retrieveMaxContSize();
    if ( _maxContSize == 0 ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                            "in retrieveDirRange");
    }

    _maxContNr = chsMgr->retrieveMaxContNr();
    if ( _maxContNr == 0 ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                            "in retrieveMaxContNr");
    }

    _dirRange = chsMgr->retrieveDirRange();
    if ( _dirRange == 0 ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                            "in retrieveDirRange");
    }

    d_ULong nr = chsMgr->retrieveInitNoPages();
    if ( nr > 0 ) {
        _initPages = nr;
    }
    nr = chsMgr->retrieveContPercGr();
    if ( nr > 0 ) { 
        _contPercentGrowth = nr;
    } 
    nr = chsMgr->retrieveHashCont();
    if ( nr > 0 ) {
        _hashCont = nr;
    }

    setCalcHintConstant();

    return _paramHandler->initializeCompSpecData();
}


// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//                  R E L O A D
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


BdbStatus 
BdbAbsRegularClustH::reload()
{
    const char* fn = "BdbAbsRegularClustH::reload";

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

    d_Boolean diskFull = d_False;
    if ( verifyDiskSpace(&diskFull) != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                            "in verifyDiskSpace");
    }

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

    d_Boolean forceNewCont = oneContPerProcess() || contFullFlagSet();

    if ( _forceNewDb || forceNewCont ) {
            // it may not be accurate, because one object was
            // created after _recentNrPages was resynchronized
            // which means that container might have been extended
        if ( ! BdbIsNull(contHint()) ) {
            _noPagesUsed += contHint().nPage();
        } else {
            _noPagesUsed += _recentNrPages;
        }
    }
#ifdef BDB_COLLECT_STATISTICS
    BdbApplicationOrDomain::activeInstance()->statTimers()._tinGetPObj.start();
#endif
    d_ULong oldDbId = _param.dbNr();
    if ( _forceNewDb ) {
        _paramHandler->updateForceNewDb();
        _forceNewDb = d_False;
    } else if ( _param.dbNr() != 0 && diskFull ) {
        _paramHandler->updateForceChangeDb();
    } else if ( forceNewCont ) {
        _paramHandler->updateForceNewCont();
    } else {
        _paramHandler->doResynch();
    }
#ifdef BDB_COLLECT_STATISTICS
    BdbApplicationOrDomain::activeInstance()->statTimers()._tinGetPObj.stop();
#endif
    compObj()->resetComponentChanged();

    if ( initializeDbHint() != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                            "in initializeDbHint");
    }
#ifdef BDB_COLLECT_STATISTICS
    BdbApplicationOrDomain::activeInstance()->statTimers()._tinOpenCont.start();
#endif
    BdbStatus stat = initializeContHint(forceNewCont);
#ifdef BDB_COLLECT_STATISTICS
    BdbApplicationOrDomain::activeInstance()->statTimers()._tinOpenCont.stop();
#endif

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






// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//           R E B U I L D    H I N T S
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


BdbStatus 
BdbAbsRegularClustH::rebuildHints(d_Boolean forceNewContainer)
{
    const char* fn = "BdbAbsRegularClustH::rebuildHints";

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

    return initializeContHint(forceNewContainer);
}




BdbStatus  
BdbAbsRegularClustH::initializeDbHint()
{
    const char* fn = "BdbAbsRegularClustH::initializeDbHint";

    if ( ! BdbIsNull(dbHint()) ) {
        _curContNr = dbHint().numContObjs();
        return BdbcSuccess;
    }

    _curContNr = 999999; // invalid number

#ifdef BDB_COLLECT_STATISTICS
    BdbApplicationOrDomain::activeInstance()->statTimers()._tinOpenDb.start();
#endif
    BdbApplicationOrDomain::activeInstance()->ignoreErrors() ; // db may not exist, it is not an error
    BdbDbAccessMgr dbMgr;
    BdbStatus stat = dbMgr.openDb(dbHint(), _param.dbNr(), BdbcUpdate);
    BdbApplicationOrDomain::activeInstance()->noticeErrors() ;
#ifdef BDB_COLLECT_STATISTICS
    BdbApplicationOrDomain::activeInstance()->statTimers()._tinOpenDb.stop();
#endif
    if ( stat == BdbcSuccess ) {
        _createDb = d_False;
        _curContNr = dbHint().numContObjs();
        registerCurrentDbAsUsed();
        setDbNameAndPath(dbHint().name(), dbHint().pathName());
        return BdbcSuccess;
    }

    if ( ! _createDb ) {   // this process is NOT responsible for db creation
        int delay = 15 + getpid() % 30;   // randomize delay time, since many processes may decide
        // to create a db in the same time
        for ( int i=0 ; i<delay ; i++ ) {
            BdbApplicationOrDomain::activeInstance()->ignoreErrors() ;
            BdbDbAccessMgr dbMgr;
            BdbStatus status =  dbMgr.openDb(dbHint(), _param.dbNr(), BdbcUpdate, 0);
            BdbApplicationOrDomain::activeInstance()->noticeErrors() ;

            if ( status == BdbcSuccess ) {
                _curContNr = dbHint().numContObjs();
                setDbNameAndPath(dbHint().name(), dbHint().pathName());
                return BdbcSuccess;
            }

            COUT1 << "Db : " << currentDbName()
                  <<  " should be created by other process, waiting 5 seconds" << endl ;
            sleep(5) ;              // give other process 60 seconds
        }
    }                       // this process will try to create db only if:
                            // 1) it owns the first container
                            // 2) during last 60 sec db has not been created by other process

    if ( prepareFinalDbName() != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                            "in prepareFinalDbName");
    } 
    ooVString dbName = currentDbName();
    buildComponentDirectories();
    strcpyDbName(dbName);

    BdbStatus status = newDb(d_True, _param.dbNr());
    if ( status != 98789 ) {
        _createDb = d_False;
    }
    if ( _newDbFlag ) {
        if ( _paramHandler->initPageCounter(_param.dbNr()) != BdbcSuccess ) {
            _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                         "in initPageCounter");
        }
        _nrDbsCreated ++; 
    }

    if ( status != BdbcSuccess ) {
        if ( openDb(currentDbName(), BdbcUpdate) == BdbcSuccess ) {
            _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                         "ignore \"newDb\" errors, recovered");

        } else {
            return _es->BdbFSig(BdbClusteringErrFunctionFailed, fn,
                                "in newDb") ;
        }
    }

    _curContNr = dbHint().numContObjs();

    return BdbcSuccess ;
}




BdbStatus 
BdbAbsRegularClustH::initializeContHint(d_Boolean forceNewContainer)
{
    const char* fn = "BdbAbsRegularClustH::initializeContHint";

    assert(_curContNr>0);

    if ( ! BdbIsNull(contHint()) ) {
        return BdbcSuccess;
    }

    char contNameBuf[32]; strcpy(contNameBuf, "---");
    char* contName;

    if ( oneContPerProcess() ) {
        if( forceNewContainer ) {
            contName = 0; // container will have no name 
        } else {
            // build container handle and open the container
            return contHint().update();
        }
    } else {
        if ( ! forceNewContainer ) {
            sprintf(contNameBuf, "%i", (int) _curContNr-1);
            if ( ! contHint().exist(dbHint(), contNameBuf, BdbcNoOpen) ) {
                sprintf(contNameBuf, "%i", (int) _curContNr);
                forceNewContainer = d_True;
            }
        } else {
            sprintf(contNameBuf, "%i", (int) _curContNr);
        }
        contName = contNameBuf;
    }


    if ( ! forceNewContainer ) {
        return openContainer(contName, BdbcUpdate);
    }

    if ( newContainer(contName) != BdbcSuccess ) {
        return BdbcError; // be quiet on error
    }
    numContObjs();

    BdbRef(BdbContObj) contRef = contHint();
    d_ULong db = contRef.get_DB();
    d_ULong oc = contRef.get_OC();
    if ( oc > 32700 ) { // check if we are close to max cont id (32766)
        COUT1 << "DBSIZE: Close to max cont ID [" << db << "-" << oc << "], "
              << "forcing new database" << endl;
        _forceNewDb = d_True;
        return reload();            
    }

    // it is safer to check nr (not oid), because if container
    // is deleted and a new one gets created, oid is too large
    // and will always indicate overflow
    if ( ! _paramHandler->contNrWithinLimit(_curContNr) ) {
        COUT1 << "DBSIZE: Created container [" << db << "-" << oc 
              << "] overflows the database "
              << ", looking for space..." << endl;
        // ooDelete(contRef);
        // do not reset db hint, since it may happen that
        // we will be able to reuse the same db, and if not
        // the hint will be reset anyway somewhere else
        resetContHint();
        // make sure a new container will be created
        setFullContainerFlag();                    
        return reload();
    }
    resetFullContainerFlag();
    _nrContsCreated ++;
    preregisterCurrentContAsFull(_nrPagesPerFullCont, 
                                 _paramHandler->paramContName(d_False), 
                                 streamName());

    return BdbcSuccess;
}





// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//           P R E P A R E     P A T H S
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


BdbStatus 
BdbAbsRegularClustH::prepareComponentNameSpec(d_Boolean defaultFS)
{
    const char* fn = "BdbAbsRegularClustH::prepareComponentNameSpec";

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

    // Here we will avoid creating intermediate component subdirectory
    // if it's required by our domain.

    if ((( BdbDomain*) domain())->getDBFSUseComponentSubDir()) {
        strcatPath( dirName() );
    }

    return BdbcSuccess;
}


BdbStatus 
BdbAbsRegularClustH::prepareCompWithNrSpec(d_Boolean defaultFS)
{
    const char* fn = "BdbAbsRegularClustH::prepareCompWithNrSpec";

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

    strcatPath( dirName() );
    strcatDbName( dbName() );

    strcatPath(dirWithRange(), d_False);

    char buf[7];
    sprintf(buf, "%06X", _param.dbNr());
    strcatDbName(buf, d_False);

    return BdbcSuccess;
}




// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//
//               BUILD DIRECTORIES
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



BdbStatus 
BdbAbsRegularClustH::buildComponentDirectories()
{
    const char* fn = "BdbAbsRegularClustH::buildComponentDirectories";

    d_Boolean defaultFS = allowRemoteFS();

    // maybe the whole structure already exist...
    if ( prepareCompWithNrSpec(defaultFS) != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                            "in prepareCompWithNrSpec");
    }
    if ( fsMgr()->checkExist( currentPath(), defaultFS ) ) {
        return BdbcSuccess;
    }


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

    if ( prepareComponentNameSpec(defaultFS) != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                            "in prepareComponentNameSpec");
    }
    if ( fsMgr()->mkDir(currentPath(), defaultFS) != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                            "in mkDir");
    }

    if ( prepareCompWithNrSpec(defaultFS) != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                            "in prepareCompWithNrSpec");
    }
    if ( fsMgr()->mkDir(currentPath(), defaultFS) != BdbcSuccess ) {
        return _es->BdbESig(BdbClusteringErrFunctionFailed, fn,
                            "in mkDir");
    }

    return BdbcSuccess;
}


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


BdbStatus 
BdbAbsRegularClustH::setCalcHintConstant()
{
    assert(_maxContSize!=0);

    d_ULong maxNoPages = (_maxContSize<<10) / BdbApplicationOrDomain::activeInstance()->fd().pageSize();
    _calcHintConstant = ( 100 * maxNoPages )  / (100 + contPercentGrowth());

    COUT1 << "CALCSIZE: " << domain()->authLevelName() << " - "
          << domain()->authName() << " - " <<  compObj()->name()
          << ": maxCSize=" << _maxContSize
          << ", contPG=" << contPercentGrowth()
          << ", pSize=" << BdbApplicationOrDomain::activeInstance()->fd().pageSize()
          << ", CONST=" << _calcHintConstant << endl;

    if ( _nrPagesPerFullCont == 0 ) {
        _nrPagesPerFullCont = (1024 * _maxContSize) / BdbApplicationOrDomain::activeInstance()->fd().pageSize();
        COUT1 << "CALCSIZE: noPagesPerFullCont=" << _nrPagesPerFullCont
              << " (1024*" << _maxContSize << "/" <<  BdbApplicationOrDomain::activeInstance()->fd().pageSize() << ")" 
              << " (" << compObj()->name() << ")" << endl;
    }

    return BdbcSuccess;
}


const char* 
BdbAbsRegularClustH::dirName() const 
{  return ccompObj()->name(); }


const char* 
BdbAbsRegularClustH::dirWithRange()
{
    assert(_dirRange!=0);
    assert(_param.dbNr()!=0);

    int leftRange  = ( _param.dbNr() /  _dirRange ) * _dirRange;
    int rightRange = leftRange + _dirRange;

    if ( _dirWithRange == 0 ) {
        _dirWithRange = new char [16];
    }

    sprintf(_dirWithRange, "%06X-%06X", leftRange, rightRange) ;
    
    return _dirWithRange;
}


const char* 
BdbAbsRegularClustH::dbName() const
{  return ccompObj()->name();  }


const char* 
BdbAbsRegularClustH::streamName() const
{
    if ( _theStream.head() == 0 ) {
        return BdbClustHAccess::DEF_STREAM_NAME;
    }

    return _theStream;
}



d_ULong
BdbAbsRegularClustH::numContObjs()
{
    // make sure db is opened, on error set _curContNr to 
    // something invalid
    initializeDbHint();

    return _curContNr;
}
    


d_Boolean
BdbAbsRegularClustH::currentContainerIsFull()
{
    if ( contFullFlagSet() ) {
        return d_True;
    }
 
    d_ULong nr = contHint().nPage();
    if ( nr > _recentNrPages ) {
        _noContExpand ++;
    }
    _recentNrPages = nr;
    return _recentNrPages >= calcHintConstant();
}




BdbStatus
BdbAbsRegularClustH::getAllFullDbs(ooTVArray(d_ULong)& theTVArray)
{
    BdbApplicationOrDomain* app = BdbApplicationOrDomain::activeInstance();
    assert(app->startNestedRead(ctxId())==BdbcSuccess);

    _maxContNr = 1; // not used, avoid assertion
    _paramHandler->initializeCompSpecData();

    BdbFullDbsMgr theMgr(domain()->shortDomainName(), quietMode(), maxWaitTime());
    BdbStatus stat = theMgr.getAllFullDbs(theTVArray);

    assert(app->commitNested(ctxId())==BdbcSuccess);

    return stat;
}


BdbStatus
BdbAbsRegularClustH::removeFullDbsFromRegistry(const ooTVArray(d_ULong)& theTVArray)
{
    BdbApplicationOrDomain* app = BdbApplicationOrDomain::activeInstance();
    assert(app->startNestedUpdate(ctxId())==BdbcSuccess);

    _paramHandler->initializeCompSpecData();

    BdbFullDbsMgr theMgr(domain()->shortDomainName(), quietMode(), maxWaitTime()); 
    if ( theMgr.removeFromRegistry(theTVArray) != BdbcSuccess ) {
       ::abort() ;
//        app->abortMiniTransaction();
        return BdbcError;
    }

    assert(app->commitNested(ctxId())==BdbcSuccess);

    return BdbcSuccess;
}



void 
BdbAbsRegularClustH::printSetting()
{
    const char* dN  = domain()->domainName();
    const char* alN = domain()->authLevelName();
    const char* aN  = domain()->authName();
    const char* cN  = ccompObj()->name();
    
    fsMgr()->rebuildFSInfo(dN, alN, aN, cN);
    
    reloadCompSpecInfo();
    
    cout << "Setting for: " << dN << "-" << alN << "-" << aN << "-" << cN << endl;

    cout << "    MaxContSize = " << _maxContSize << "\n"
         << "    MaxContNr   = " << _maxContNr   << "\n"
         << "    DirRange    = " << _dirRange    << "\n"
         << "    InitNoPages = " << _initPages   << "\n"
         << "    ContPercGr  = " << _contPercentGrowth << "\n"
         << "    HashedCont  = " << _hashCont    << "\n"
         << "---------------------------" << endl;
}

 

---

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

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