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

                 

---

/BdbApplMgmt/BdbContextPool.cc

Go to the documentation of this file.

//------------------------------------------------------------------------------
// File:
//      BdbContextPool.hh
//
// Description:
//      Class BdbContextPool
//
//      The class manages a pool of ooContext objects and associated
//      information.
//
// Environment:
//      Software developed for the BaBar Detector at the SLAC B-Factory
//
// Author List:
//      Igor Gaponenko          Original Author
//
// Copyright Information:
//      Copyright (C) 1999      Lowrence Berkeley National Laboratory
//
//------------------------------------------------------------------------------

//---------------
// C++ headers --
//---------------

#include <iostream.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <stropts.h>
#include <assert.h>

//-----------------------
// This Class's Header --
//-----------------------

#include "BdbApplMgmt/BdbContextPool.hh"

// ------------------------------
// Collaborating Class Headers --
// ------------------------------

#include "BdbApplMgmt/BdbApplicationErrors.hh"
#include "BdbDomainOODB/BdbDomainOODB.hh"
#include "BdbDomainOODB/BdbHandleCacheMgr.hh"

extern void BaBarObjyMessageHandler(char*) ;
extern ooStatus BaBarObjyErrorHandler(ooErrorLevel, ooError&, ooHandle(ooObj)*, char*) ;

///////////////////////////////////////////
// Nested class Context:: implementation //
///////////////////////////////////////////

BdbContextPool::Context::Context( d_ULong id,
                                  d_ULong nPages,
                                  d_ULong nMaxPages ) :
    _next(0),
    _prev(0),
    _prevInTransStack(0),
    _used(0),
    _reloaded(0),
    _need2reload(d_False),
    _transID( 0 ),
    _handleCache( 0 ),
    _id(id),
    _isAllocated(d_False),
    _transIsActive(d_False)
{
}

BdbContextPool::Context::~Context( )
{
    delete _theContext;
    delete _handleCache;
}

////////////////////////////////
// Evaluate reload conditions //
////////////////////////////////

BdbStatus
BdbContextPool::evaluateReloadConditions( )
{
    struct rlimit rlp;
    int cur;
    int max;
    int use = 0;
    int fd;

  // STEP I: Obtain current limits of the number of file descriptors
  //         and current usage of the descriptors.
 
    if( 0 != getrlimit( RLIMIT_NOFILE, &rlp )) {
        return BdbcError;
    }
 
    cur = rlp.rlim_cur;
    max = rlp.rlim_max;

    for( fd = 0; fd < cur; fd++ ) {

        int state = isastream( fd );
 
        switch( state ) {
        case 0:
            use++;
            break;
        case 1:
            use++;
            break;
        }
    }

  // STEP II: increase the current limit if (both):
  //
  //    - it's required (75% CURRENT limit is reached)
  //    - it's possible (50% MAXIMUM limit is NOT reached)
  //
  //    NOTE: We will increase this limit by 25% of CURRENT limit
  //          but no more the
  //


    float usage = 100.0 * (float) use / (float) cur;

    if( usage < 75.0 ) {
        return BdbcSuccess;     // Not required.
    }
    
    float occupancy = 100.0 * (float) cur / (float) max;
    
    if( occupancy < 50.0 ) {
    
        int limit = (int) ( 0.5 * max );
        int increment = (int) ( 0.25 * cur );

        if(( cur + increment ) > limit ) {
            increment = limit - cur;
        }

        if( increment > 0 ) {

            rlp.rlim_cur = rlp.rlim_cur + increment;

            if( 0 != setrlimit( RLIMIT_NOFILE, &rlp )) {
                return BdbcError;
            } else {
                return BdbcSuccess;
            }
        } else {
            ;   // Proceed on the next step.
        }
    }

  // STEP II: We are running out of limit. IN this case we should
  //          turn on contexts reloading (delete/new) operation.
  //
  //    NOTE_1: In a current implementation of algorithm we will
  //            tell each context to reload himself just once.
  //
  //    NOTE_2: The context is told to be reloaded if it was ever
  //            been used.

    Context* ptr = _first;

    while( ptr != (Context*) 0 ) {
        if( 0 != ptr->_used ) {
            ptr->_need2reload = d_True;
        }
        ptr = ptr->_next;
    }

    return BdbcSuccess;
}

/////////////////////////////////////////////////
// Print some context and fds usage statistics //
/////////////////////////////////////////////////

void
BdbContextPool::printStatistics( const char* prefix, d_ULong level )
{
    int status;
    struct rlimit rlp;
    int cur;
    int max;
    int nstreams = 0;   // Number of FDs associated with streams.
    int nothers = 0;    // Number of FDs associated with something else.
    int fd;

  // Just do nothing if the statistics monitor is not enabled.

    if( ! _statMonIsEnabled ) {
        return;
    }

    status = getrlimit( RLIMIT_NOFILE, &rlp );
 
    cur = rlp.rlim_cur;
    max = rlp.rlim_max;
  
    for( fd = 0; fd < cur; fd++ ) {

        int state = isastream( fd );
 
        switch( state ) {
        case 0:
            nothers++;
            break;
        case 1:
            nstreams++;
            break;
        }
    }
    
    cout << "BdbContextPool::printStatistics() - " << level << ":" << prefix << endl
         << "    max:" << max
         << " cur:" << cur
         << " ava:" << ( cur - nstreams - nothers )
         << " str:" << nstreams
         << " oth:" << nothers
         << endl;

    cout << "    used:";

    Context* ptr;

    ptr = _first;
    while( ptr != (Context*) 0 ) {
        cout << " " << ptr->_used;
        ptr = ptr->_next;
    }
    cout << endl;

    cout << "    contexts reloaded:";

    ptr = _first;
    while( ptr != (Context*) 0 ) {
        cout << " " << ptr->_reloaded;
        ptr = ptr->_next;
    }
    cout << endl;

    cout << "    need to reload contexts:";

    ptr = _first;
    while( ptr != (Context*) 0 ) {
        if( ptr->_need2reload ) {
            cout << " 1";
        } else {
            cout << " 0";
        }
        ptr = ptr->_next;
    }
    cout << endl;

}

/////////////////
// Constructor //
/////////////////

BdbContextPool::BdbContextPool( d_ULong nContexts,
                                d_ULong nPages,
                                d_ULong nMaxPages) :
    _elements(0),
    _first(0),
    _current(0),
    _last(0),
    _depth(0),
    _nPages(nPages),
    _nMaxPages(nMaxPages),
    _statMonIsEnabled(d_False)
{
    for( d_ULong i = 0; i < nContexts; i++ ) {
        allocate( );
    }

    char* str = getenv( "BDBCONTEXTPOOL_ENABLE_STATMON" );

    if( str != (char*) 0 ) {
        _statMonIsEnabled = d_True;
    }
}

////////////////
// Destructor //
////////////////

BdbContextPool::~BdbContextPool()
{
    Context* ptr = _first;

    while( ptr != (Context*) 0 ) {
        delete ptr;
        ptr = ptr->_next;
    }
}

d_ULong
BdbContextPool::depth( )
{
    return _depth;
}

ooHandle(ooFDObj)&
BdbContextPool::fd( )
{
    assert( 0 != _depth );
    return _current->_fdb;
}

d_ULong
BdbContextPool::transID( )
{
    assert( 0 != _depth );
    return _current->_transID;
}

BdbHandleCacheMgr*
BdbContextPool::handleCache( )
{
    assert( 0 != _depth );
    return _current->_handleCache;
}

void
BdbContextPool::allocate( )
{
  // Create an instance of a context object.

   // the '+ 1' means that 0 is NOT a valid ID for a context.
    Context* ptr = new Context( _elements + 1, _nPages, _nMaxPages );
    ptr->_theContext  = new ooContext( _nPages, _nMaxPages);
    ptr->_handleCache = new BdbHandleCacheMgr( );

  // Append a new element by the end of the list.

    if( _last != (Context*) 0 ) {
        _last->_next = ptr;
    }
    ptr->_prev = _last;
    ptr->_next = (Context*) 0;

  // Tune a "last" pointer to point onto the new element.

    _last = ptr;

  // If the first was not set yet - the set it
  // to point onto this (presumably) first element in the list.
    
    if( _first == (Context*) 0 ) {
        _first = _last;
    }

  // Increment the number of elements in a list

    _elements++;
}

BdbStatus
BdbContextPool::allocate( d_ULong& id )
{
  // Find out a spare (not allocated) context or allocate
  // a new one if not found.

    Context* ptr = _first;

    while( ptr != (Context*) 0 ) {
        if( ! ptr->_isAllocated ) {

            ptr->_isAllocated = d_True;
            id = ptr->_id;

            return BdbcSuccess;
        }
        ptr = ptr->_next;
    }

  // Alocate one more context.

    allocate( );

    _last->_isAllocated = d_True;
    id = _last->_id;

    return BdbcSuccess;
}

BdbStatus
BdbContextPool::release( d_ULong id )
{
  // Find out a spare (not allocated) context or allocate
  // a new one if not found.

    Context* ptr = _first;

    while( ptr != (Context*) 0 ) {
        if( id == ptr->_id ) {

            if( ! ptr->_isAllocated ) {
                cout << "BdbContextPool::release() -- error." << endl
                     << "    The context with ID = " << id << " is not allocated." << endl;
                return BdbcError;
            }
            if( ptr->_transIsActive ) {
                cout << "BdbContextPool::release() -- error." << endl
                     << "    There is an active transaction for the context ID = " << id << endl;
                return BdbcError;
            }

            ptr->_isAllocated = d_False;
            return BdbcSuccess;
        }
        ptr = ptr->_next;
    }

  // Print error because such a context was not found.

    cout << "BdbContextPool::release() -- error." << endl
         << "    The context with ID = " << id << " does not exists." << endl;

    return BdbcError;
}

BdbStatus
BdbContextPool::start( d_ULong id, BdbMode theMode, ooIndexMode theIndexMode )
{
    BdbStatus status = BdbcError;

  // Find out if such an id is in the list and it's marked as current.

    Context* ptr = _first;

    while( ptr != (Context*) 0 ) {
        if( id == ptr->_id ) {

            if( ! ptr->_isAllocated ) {
                cout << "BdbContextPool::start() -- error." << endl
                     << "    The context with ID = " << id << " is not allocated." << endl;
                return BdbcError;
            }
            if( ptr->_transIsActive ) {
                cout << "BdbContextPool::start() -- error." << endl
                     << "    There is an active transaction for the context ID = " << id << endl;
                return BdbcError;
            }

          // OK. We've got this.

            status = BdbcSuccess;
            break;
        }
        ptr = ptr->_next;
    }
    if( BdbcSuccess != status ) {
        cout << "BdbContextPool::start() -- error." << endl
             << "    The context with ID = " << id << " does not exists." << endl;
    }

  // Push the stack of nested transactions..

    ptr->_prevInTransStack = _current;
    _current = ptr;

  // Update use counter for this context.
  
    _current->_used++;

  // Switch context

    _current->_oldContext = ooContext::current( );

    ooContext::setCurrent( 0 );
    ooContext::setCurrent( _current->_theContext );

    ooRegMsgHandler( BaBarObjyMessageHandler );
    ooRegErrorHandler( BaBarObjyErrorHandler );

  // Start transction with first two parameters set
  // to default values and the third one - to a value
  // specified by a user.
  // Then open FDB in specified mode.
  // And finally increment the corresponding transaction ID.

    _current->_theTransaction.start( oocNoMROW, oocTransNoWait, theIndexMode );
    _current->_fdb.open( BdbDomainOODB::activeDomainOODB()->bootName(), theMode );

    (_current->_transID)++;
    _current->_transIsActive = d_True;

  // Increase current depth of the nested stack of transactions. Later on this value
  // will be decreased by "::stop".

    _depth++;

  // Print some statistics

    printStatistics( "START", _depth );

    return BdbcSuccess;
}

BdbStatus
BdbContextPool::stop( d_ULong id, Action action )
{
  // Remember a reference to the current context.
  // We will use this reference in the end of the procedure
  // in order to reload context (if desired).
    
    Context* cxt = _current;

  // Check if the current context is non-zero and if it has
  // the same identifier.

    if(( 0 == _depth ) || ( _current == (Context*) 0 )) {
        cout << "BdbContextPool::stop() -- error." << endl
             << "    No active transaction for context ID = " << id << endl;
        return BdbcError;
    }
    if( id != _current->_id ) {
        cout << "BdbContextPool::stop() -- error." << endl
             << "    Internal bug for the context ID = " << id << endl;
        return BdbcError;
    }
    
  // Check if the transaction is active.

    if( ! _current->_transIsActive ) {
        cout << "BdbContextPool::stop() -- error." << endl
             << "    No active transaction for the context ID = " << id << endl;
        return BdbcError;
    }

  // Finish current transaction.

    switch( action ) {
    case commitTransaction:

        _current->_theTransaction.commit( );
        break;

    case abortTransaction:

        _current->_theTransaction.abort( );
        break;
    }

  // Close federation

    _current->_fdb.close( );

  // Set back a previous context.

    ooContext::setCurrent( 0 );
    ooContext::setCurrent( _current->_oldContext );

  // Roll back the stack of transactions.

    _current->_transIsActive = d_False;
    _current = _current->_prevInTransStack;

    _depth--;

  // Print some statistics before evaluation and possible context reload.
  
    printStatistics( "STOP - before context reload", _depth + 1 );

  // Evaluare reload conditions and reload context if needed.
  
    BdbStatus status;

    status = evaluateReloadConditions( );
    if( BdbcSuccess != status ) {
        cout << "BdbContextPool::stop() - failed to evaluate reload conditions." << endl;
        return status;
    }
    
    if( cxt->_need2reload ) {

        delete cxt->_theContext;
        delete cxt->_handleCache;

        cxt->_theContext  = new ooContext( _nPages, _nMaxPages );
        cxt->_handleCache = new BdbHandleCacheMgr( );

        cxt->_reloaded++;
        cxt->_need2reload = d_False;
    }

  // Print some statistics after evaluation and possible context reload.
  
    printStatistics( "STOP - after  context reload", _depth + 1 );
   
    return BdbcSuccess;
}

/////////////////
// End Of File //
/////////////////

 

---

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

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