---

CdbBdbObjectProfilerImpl.cc

Go to the documentation of this file.

// File and Version Information:
//      $Id: CdbBdbObjectProfilerImpl.cc,v 1.5 2004/10/21 20:35:50 gapon Exp $
#include "BaBar/BaBar.hh"

/// The implementation of the CdbBdbObjectProfilerImpl.
/**
  * @see CdbBdbObjectProfilerImpl
  */

#include "BaBar/BaBar.hh"

#include "CdbBdb/CdbBdbObjectProfilerImpl.hh"

#include "CdbBdb/CdbBdbObjectProfilerUserAction.hh"
#include "CdbBdb/CdbBdbSimpleCache.hh"

#include <assert.h>

#include <iostream>     // Use STD I/O streams to avoid conflicts with
                        // Objectivity/DB Active Schema API caused by a bug
                        // in its header file at version 7.

#include <ooMap.h>      // Objectivity/DB core API for the Map Dictionary class
using std::cerr;
using std::cout;
using std::endl;


//////////////////////////////////////
// CdbBdbObjectProfilerImpl::Prefix //
//////////////////////////////////////

CdbBdbObjectProfilerImpl::Prefix::Prefix(               int& theLevel,
                                         const std::string& theStep ) :
    _level(theLevel),
    _str  ("")
{
    ++_level;
    for( int i = 0; i < _level; ++i ) _str += theStep;
}

CdbBdbObjectProfilerImpl::Prefix::~Prefix( )
{
    --_level;
}
        
const char*
CdbBdbObjectProfilerImpl::Prefix::c_str( ) const
{
    return _str.c_str( );
}

///////////////////////
// CdbBdbObjectProfiler //
///////////////////////

CdbBdbObjectProfilerImpl::CdbBdbObjectProfilerImpl( CdbBdbObjectProfilerUserAction* theUserAction,
                                                                               bool verboseMode,
                                                                               bool debugMode ) :
    _verboseMode(verboseMode),
    _debugMode  (debugMode),
    _userAction (theUserAction),
    _dictionary (new CdbBdbSimpleCache( )),
    _level      (0),
    _size       (0),
    _topObjects (0)
{
    if( 0 == theUserAction ) {
        cerr << "CdbBdbObjectProfilerImpl::CdbBdbObjectProfilerImpl() -- a null pointer instead of a user action object" << endl
             << "passed to the method." << endl;
        ::abort( );
    }

  // Force verbose mode if the debug mode is srequired

    if( _debugMode ) _verboseMode = true;
}

CdbBdbObjectProfilerImpl::~CdbBdbObjectProfilerImpl( )
{
    if( 0 != _dictionary ) {
        delete _dictionary;
        _dictionary = 0;
    }
}

bool
CdbBdbObjectProfilerImpl::profile( const ooHandle(ooObj)& theInputH )
{
    const char* context = "CdbBdbObjectProfilerImpl::profile() : ";

  // Accept only valid objects to begin with

    if( !theInputH.isValid( )) {
        cerr << context << "ERROR: invalid object passed to the procedure: " << theInputH.sprint( ) << endl;
        return false;
    }

  // Reset the profiler's context

    _level = 0;

  // Proceed with the copy

    return profileObject( theInputH );
}

CdbBdbObjectProfilerUserAction*
CdbBdbObjectProfilerImpl::setUserAction( CdbBdbObjectProfilerUserAction* theUserAction )
{
    if( 0 == theUserAction ) {
        cerr << "CdbBdbObjectProfilerImpl::setUserAction() -- a null pointer instead of a user action object" << endl
             << "passed to the method." << endl;
        ::abort( );
    }
    CdbBdbObjectProfilerUserAction* previousAction = _userAction;
    _userAction = theUserAction;

    return previousAction;
}

uint64
CdbBdbObjectProfilerImpl::getSize( ) const
{
    return _size;
}

uint64
CdbBdbObjectProfilerImpl::getTopObjects( ) const
{
    return _topObjects;
}

bool
CdbBdbObjectProfilerImpl::profileObject( const ooHandle(ooObj)& theInputH )
{
    const char* context = "CdbBdbObjectProfilerImpl::profileObject() : ";

    Prefix prefix( _level );

////////////////////////////////////////////////////////////////
if( _verboseMode ) {
    std::string  inStr = theInputH.sprint( );
    cout << prefix.c_str( ) << inStr.c_str( ) << " >> " << endl;
}
////////////////////////////////////////////////////////////////

  // Simply ignore the null objects. It's not a error conditions since its quite
  // normal for persistent objects to have null references.

    if( theInputH == 0 ) {

/////////////////////////////////////////////////////////////////////////////////////////////////////
if( _verboseMode ) {
    std::string  inStr = theInputH.sprint( );
    cout << prefix.c_str( ) << inStr.c_str( ) << " (NULL) \"\"" << endl;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////

    } else {

      // Find an object in the transient cache first if the cache is present
      // in the current test's environment.

        if( 0 != _dictionary->findObject( theInputH )) {

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if( _verboseMode ) {
    std::string  inStr = theInputH.sprint( );
    cout << prefix.c_str( ) << inStr.c_str( ) << " (CACHED) \"" << theInputH.typeName( ) << "\"" << endl;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        } else {

          // Engage a user action to see what has to be done next

            switch( _userAction->action( theInputH )) {

            default :

                cerr << context << "ERROR: unrecognized user action for: " << theInputH.sprint( ) << endl;
                ::abort( );

            case CdbBdbObjectProfilerUserAction::ACTION_ERROR :

                cerr << context << "ERROR: user action failed for: " << theInputH.sprint( ) << endl;
                return false;

            case CdbBdbObjectProfilerUserAction::ACTION_STOP :

                _dictionary->addObject( theInputH, theInputH );

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if( _verboseMode ) {
    std::string  inStr = theInputH.sprint( );
    cout << prefix.c_str( ) << inStr.c_str( ) << " (STOP BY USER ACTION)" << endl;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                break;

            case CdbBdbObjectProfilerUserAction::ACTION_PROCEED :

                {
                  // Now we're diving into another object which has been successfully
                  // validated by the user action.


                  // Check for special case of the ooMap class. Use regular (as opposed to the Active
                  // Schema API) to browse the map.
                  //
                  // IMPLEMENTATION NOTE: In theory this operation could also be resolved for
                  //                      user defined subclasses of the ooMap class. Besides we have
                  //                      a set of other internal classes defined by Objectivity itself
                  //                      (containers, sets, B-Trees, etc.) It's unclear whether they
                  //                      can also be browsed in this way.

                    ooTypeNumber typeN = theInputH.typeN( );

                    if( ooTypeN(ooMap) == typeN ) {

                        ooHandle(ooMap) inputMapH;      // non-const handle is needed to set up an iterator
                        inputMapH = (ooHandle(ooMap))theInputH;

                      // ATTENTION: update the cache _before_ copying the object to prevent
                      //            "profile self" loop. This may cause crashes in the algorithm.

                        _dictionary->addObject( theInputH, theInputH );

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if( _verboseMode ) {
    std::string  inStr = theInputH.sprint( );
    cout << prefix.c_str( ) << inStr.c_str( ) << " (PROFILE) \"" << theInputH.typeName( ) << "\"" << endl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                        {
                            ooMapItr itr( inputMapH );
                            while( itr.next( )) {

                                ooRef(ooObj) inputRef = itr->oid( );

                                ooHandle(ooObj) inputH;
                                inputH = inputRef;

                                if( ! profileObject( inputH )) return false;
                            }
                        }

                    } else {

                      // Profile the persisten object using recursive algorithm.
                      //
                      // NOTE: The cast is needed as a workaround of the buggy interface
                      //       of the "ooas::Class_Object" class. It does not really need
                      //       non-const handle.

                        ooas::Class_Object classObj((ooHandle(ooObj)&)theInputH );
                        if( !classObj ) {
                            cerr << context << "ERROR: no ooas::Class_Object for the input object reference: " << theInputH.sprint( ) << endl;
                            ::abort( );
                        }

                      // ATTENTION: update the cache _before_ prifiling the object to prevent
                      //            "copy self" loop. This may cause crashes in the code.

                        _dictionary->addObject( theInputH, theInputH );

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if( _verboseMode ) {
    std::string  inStr = theInputH.sprint( );
    cout << prefix.c_str( ) << inStr.c_str( ) << " (PROFILE) \"" << theInputH.typeName( ) << "\"" << endl;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                        if( !profileObjectContents( classObj, prefix )) return false;

                      // Update the counter of 'top-level' objects processed by the current
                      // object contents profiler.
                      //
                      // Note, that the constructor of Prefix class called at the begining
                      // of the current method would always increment the current level. That's
                      // why we're using '1' in the comparision expression below.

                        if( 1 == _level ) ++_topObjects;
                    }
                }
            }
        }
    }

////////////////////////////////////////////////////////////////
if( _verboseMode ) {
    std::string  inStr = theInputH.sprint( );
    cout << prefix.c_str( ) << inStr.c_str( ) << " << " << endl;
}
////////////////////////////////////////////////////////////////

    return true;
}

bool
CdbBdbObjectProfilerImpl::profileObjectContents( const ooas::Class_Object& theClassObject,
                                                             const Prefix& thePrefix )
{
    if( !theClassObject ) {
        cerr << "CdbBdbObjectProfilerImpl::profileObjectContents() -- invalid class object passed to the method." << endl;
        ::abort( );
    }

  // Get the class object

    const ooas::d_Class& classDsc = theClassObject.type_of( );

  // We're only interested in a user defined (non-internal) classes.

    if( !classDsc.is_class   ( )) return true;
    if(  classDsc.is_internal( )) return true;

  // Browse all attributes

    {
        attribute_iterator itr = classDsc.defines_attribute_begin( );
        while( classDsc.defines_attribute_end( ) != itr ) {

            const ooas::d_Attribute& attrDsc = *itr;

            if( attrDsc.is_base_class( )) {

///////////////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( ) << "BASE CLASS" << endl;
}
///////////////////////////////////////////////////////

                ooas::Class_Object inputClassObj = theClassObject.get_class_obj( attrDsc.position( ));

                profileObjectContents( inputClassObj, thePrefix );

            } else if( attrDsc.is_relationship( )) {

                const d_Relationship&     relDsc          = (const d_Relationship&)attrDsc;
                ooas::Relationship_Object relationshipObj =  theClassObject.get_relationship( attrDsc.position( ));
                assert( relationshipObj );  // an inconsistency bug in the Objectivity/DB Active Schema API

                if( relDsc.is_to_many( )) {

///////////////////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( ) << "n-RELATIONSHIP" << endl;
}
///////////////////////////////////////////////////////////

                    uint32 num = 0;     // The cardinality of the association

                    ooItr(ooObj) itr;
                    relationshipObj.get_iterator( itr );

                    while( itr.next( )) {

                        ooHandle(ooObj) inputH;
                        inputH = itr;

                        if( !profileObject( inputH )) return false;

                        ++num;
                    }
                    if( 0 != num ) _size += num * sizeOfReference( );

                } else {

///////////////////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( ) << "1-RELATIONSHIP" << endl;
}
///////////////////////////////////////////////////////////

                    ooHandle(ooObj) inputH;
                    inputH = relationshipObj.get_ooref( );

                    if( !profileObject(inputH )) return false;

                    _size += sizeOfReference( );
                }

            } else {

                const ooas::d_Type& typeDsc = attrDsc.type_of( );

                size_t fixedArraySize = attrDsc.array_size( );

                if( typeDsc.is_ref_type( )) {

//////////////////////////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( ) << "REFERENCE";
    if( fixedArraySize > 1 ) cout << "[" << fixedArraySize << "]";
    cout << endl;
}
//////////////////////////////////////////////////////////////////

                    for( size_t i = 0; i < fixedArraySize; ++i ) {

                        ooHandle(ooObj) inputH;
                        inputH = theClassObject.get_ooref( attrDsc.position( ), i );

                        if( !profileObject( inputH )) return false;
                    }

                    _size += fixedArraySize * sizeOfReference( );

                } else if( typeDsc.is_basic_type( )) {

                    _size += fixedArraySize * sizeOfNumericValue( theClassObject.get( attrDsc.position( ), 0 ));

                } else if( typeDsc.is_string_type( )) {     // It may also be an embedded string class,
                                                            // so we make this scheck before the next one.

                    for( size_t i = 0; i < fixedArraySize; ++i ) {
                        _size += sizeOfStringValue( theClassObject.get_string( attrDsc.position( ), i ));
                    }

                } else if( typeDsc.is_class( ) && !typeDsc.is_string_type( )) {     // strings may also be represented
                                                                                    // by embedded classes.

//////////////////////////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( ) << "EMBEDDED OBJECT";
    if( fixedArraySize > 1 ) cout << "[" << fixedArraySize << "]";
    cout << endl;
}
//////////////////////////////////////////////////////////////////

                    for( size_t i = 0; i < fixedArraySize; ++i ) {

                        ooas::Class_Object inputClassObj = theClassObject.get_class_obj( attrDsc.position( ), i );

                        if( !profileObjectContents( inputClassObj, thePrefix )) return false;
                    }

                } else if( typeDsc.is_varray_type( )) {

                    ooas::VArray_Object inputVArrayObject = theClassObject.get_varray( attrDsc.position( ));

                    uint32 varraySize = inputVArrayObject.size( );

                    if( typeDsc.is_varray_basic_type( )) {

///////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( )
         << "V-ARRAY OF BASIC OBJECTS" << endl;
}
///////////////////////////////////////////////

                      // Measure the size of the very first element only if there is at least one.

                        if( 0 != varraySize ) _size += varraySize * sizeOfNumericValue( inputVArrayObject.get( 0 ));

                    } else if( typeDsc.is_varray_ref_type( )) {

////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( )
         << "V-ARRAY OF REFERENCES" << endl;
}
////////////////////////////////////////////

                        for( uint32 i = 0; i < varraySize; ++i ) {

                            ooHandle(ooObj) inputH;
                            inputH = inputVArrayObject.get_ooref( i );

                            if( !profileObject( inputH )) return false;
                        }

                        _size += varraySize * sizeOfReference( );


                    } else if( typeDsc.is_string_type( )) {     // It may also be an embedded string class,
                                                                // so we make this scheck before the next one.

/////////////////////////////////////
if( _debugMode ) {
cout << thePrefix.c_str( )
     << "V-ARRAY OF STRINGS" << endl;
}
/////////////////////////////////////

                      // Measure each string's size
                      //
                      // NOTE: We know that in reality there is no such thing as "v-array of strings",
                      //       however we have to be consistent with the Objy API.

                        for( uint32 i = 0; i < varraySize; ++i )
                            _size += sizeOfStringValue( inputVArrayObject.get_string( i ));

                    } else if(  typeDsc.is_varray_embedded_class_type( ) &&
                               !typeDsc.is_string_type( )) {

//////////////////////////////////////////////////
if( _debugMode ) {
    cout << thePrefix.c_str( )
         << "V-ARRAY OF EMBEDDED OBJECTS" << endl;
}
//////////////////////////////////////////////////

                      // NOTE: In theory embedded objects should have the same size, so we could
                      //       speed up the profiling. Unfortunatelly it's hard to get this size
                      //       of these objects are of a hierarhical class and/or if these objects
                      //       have external references.
                      //
                      //       Therefore we're using the bruit force method when profiling these
                      //       objects.

                        for( uint32 i = 0; i < varraySize; ++i )
                            if( !profileObjectContents(  inputVArrayObject.get_class_obj( i ),
                                                         thePrefix )) return false;

                    } else {

                        bool isKnownTypeOfVarrayElements = false;
                        assert( isKnownTypeOfVarrayElements );
                    }

                } else {

                    bool isKnownElementType = false;
                    assert( isKnownElementType );
                }
            }
            ++itr;
        }
    }
    return true;
}

uint64
CdbBdbObjectProfilerImpl::sizeOfNumericValue( const Numeric_Value& theNumericValue )
{
    uint64 result = 0;

    ooBaseType baseType = theNumericValue.type( );

    switch( baseType ) {

    case ooCHAR    : result = 1; break;
    case ooINT8    : result = 1; break;
    case ooUINT8   : result = 1; break;
    case ooINT16   : result = 2; break;
    case ooUINT16  : result = 2; break;
    case ooINT32   : result = 4; break;
    case ooUINT32  : result = 4; break;
    case ooINT64   : result = 8; break;
    case ooUINT64  : result = 8; break;
    case ooFLOAT32 : result = 4; break;
    case ooFLOAT64 : result = 8; break;
    case ooPTR     : result = sizeof( void* );  break;

    default:
        {
            bool isKnownNumericType = false;
            assert( isKnownNumericType );
        }
    }

    return result;
}

uint64
CdbBdbObjectProfilerImpl::sizeOfStringValue( String_Value theStringValue )
{
    const char* context = "CdbBdbObjectProfilerImpl::sizeOfStringValue()";

  // Note, that when a null string is found then we're returning 1 byte
  // as the string size since this can also be treated as "user data".

    uint64 result = 0;

    switch( theStringValue.type( )) {

    case ooAsStringVSTRING:
        {
            ooVString* vStr = theStringValue;
            const char* str = (const char*)(*vStr);
            result = 1 + ( 0 == str ? 0 : strlen( str ));
            break;
        }

    case ooAsStringUTF8:
        {
            ooUtf8String* utf8Str = theStringValue;
            const char* str = (const char*)(*utf8Str);
            result = 1 + ( 0 == str ? 0 : strlen( str ));
            break;
        }

    case ooAsStringOPTIMIZED:
        {
          // NOTE: get_copy() allocates new string

            char* str = Optimized_String_Value(theStringValue).get_copy( );
            result = 1 + ( 0 == str ? 0 : strlen( str ));
            delete [] str;
            break;
        }

    case ooAsStringST:
        {
            cerr << context << " - a Smalltalk string found in an object. These strings can't be measured." << endl;
            ::exit( 1 );
        }

    default:
        {
            bool isKnownStringClass = false;
            assert( isKnownStringClass );
        }
    }

    return result;
}

uint64
CdbBdbObjectProfilerImpl::sizeOfReference( )
{
    return 8;
}

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

---