---

CdbBdbMemoryUsageTest.cc

Go to the documentation of this file.

/// A test of using transient memory in the ROOT I/O based implementation of the CDB API.
/**
  * The application would browse the contents of CDB, find out all PID efficiency
  * conditions and load one object from them using "now" as the validity key.
  * The objects will be converted into a transient form and cached (in a transient form),
  * including metadata object CdbObject (it caches the persistent object).
  *
  * A goal of the test is to see how much memory this would require, and how
  * to improve the memory usage.
  */

#include "BaBar/BaBar.hh"

#include "CdbBase/CdbView.hh"
#include "CdbBase/CdbFolder.hh"
#include "CdbBase/CdbCondition.hh"
#include "CdbBase/CdbObject.hh"
#include "CdbBase/CdbTimeUtils.hh"
#include "CdbBase/CdbEnvironment.hh"
#include "CdbBase/CdbTransaction.hh"

#include "CdbTable/CdbNTupleBase.hh"

#include "CdbBdb/CdbBdbObjectConvertor.hh"

#include "BdbCond/BdbObject.hh"

#include "CdbBdbShared/CdbBdbShared.hh"

#include "CdbBdbTable/CdbBdbNTupleSimpleImplP_ooFloat64.hh"

#include <iostream>
#include <string>
using std::cout;
using std::cerr;
using std::endl;
#include <vector>
#include <map>

#include <stdio.h>

namespace {

  /// Loader for Objectivity/DB dictionary of persistent classes
  /**
    * Default constructors of the 'payload' classes to be loaded from CDB
    * needs to be executed at least one to bring in the corresponding dictionary.
    * Otherwise the loaded objects will have incomplete shape (no virtual tables
    * and subsequent crashes).
    */
    //void loadPayloadClassesDictionary( )
    //{
    //    const std::vector<std::string> columns;
    //    CdbBdbNTupleSimpleImplP<ooFloat64> tuple( 0, "", "", columns);
    //}

  // Find all know conditions and fill the vector with their full names.

    bool find_conditions( std::vector<std::string>&           theListOfConditions,
                          std::map<std::string,CdbFolderPtr>& theMapOfFolders,
                          const std::string&                  theFolderName );

    bool
    translate_int( int&        theValue,
                   const char* theBuf )
    {
        assert( 0 != theBuf );

        int v;

        if( 1 == sscanf( theBuf, "%d", &v )) {
            theValue = v;
            return true;
        }
        return false;
    }
};

int
main( int argc, char* argv[] )
{
    CdbBdbShared::forceLoad( );

  // Translate command-line parameters and set up default environment

    int numArgs = argc - 1;
    int nextArg = 1;

  // Start read-mode transaction and execute the found command

    CdbTransaction transaction;

  // Check if debug mode is present

    int debugMode = 0;

    if( numArgs >= 2 ) {
        if( 0 == strcmp( argv[nextArg], "-debug" )) {
            if( translate_int( debugMode, argv[nextArg+1] )) {
                nextArg = nextArg + 2;
                numArgs = numArgs - 2;
            } else {
                cout << "Error:\n"
                     << "  Failed to translate '-debug <mode>' in a list of\n"
                     << "  command-line arguments." << endl;
                return 1;
            }
        }
    }
    CdbEnvironment::setDebugMode( debugMode );
    CdbStatus result = CdbStatus::Error;

  // Browse the contents of this folder and all its subfolders to find out
  // all relevant conditions.

    std::vector<std::string>           listOfConditions;
    std::map<std::string,CdbFolderPtr> mapOfFolders;

    const std::string baseFolderName = "/physicstools/pid/";

    if( !find_conditions( listOfConditions,
                          mapOfFolders,
                          baseFolderName )) return 1;

    cout << "Found the following conditions:\n"
         << "\n";

    const unsigned int nConditions = listOfConditions.size( );
    for( unsigned int iCondition = 0; iCondition < nConditions; ++iCondition ) {
//      cout << "  " << listOfConditions[iCondition] << "\n";
    }
    cout << "\n"
         << "Total of " << nConditions << " found.\n"
         << endl;

    CdbViewPtr viewPtr;
    if( CdbStatus::Success != ( result = CdbView::instance( viewPtr ))) {
        cerr << "Failed to find the default view because of: " << result << "." << endl;
        return 1;
    }

/*
  // Cached objects

   std::map< std::string, CdbObjectPtr >             metaObjects;       // also caches a persistent object behind the scene
   std::map< std::string, CdbCPtr< CdbNTupleBase > > transientObjects;  // converted N-Tuple object
*/

  // Now browse through the list of found conditions and load objects at "now"

 //   const BdbTime now = BdbTime::now( );
    const BdbTime now = BdbTime( 2450894400, 0000000000 );

    unsigned int totalBytes = 0;

    for( unsigned int iCondition = 0; iCondition < nConditions; ++iCondition ) {

        CdbPathName fullPath( listOfConditions[iCondition] );
        CdbPathName folderPath( fullPath.beforeLast( ));
        CdbPathName conditionPath( fullPath.last( ));

        const std::string folderName    = folderPath.toString( ) + CdbPathName::separator( );
        const std::string conditionName = conditionPath.toString( ) ;

        CdbFolderPtr folderPtr = mapOfFolders[folderName];
        if( folderPtr.isNull( )) {
            cout << "no folder found in the map for: '" << folderName << "'" << endl;
            continue;
        }

        CdbConditionPtr conditionPtr;
        if( CdbStatus::Success != ( result = folderPtr->findCondition( conditionPtr,
                                                                       conditionName.c_str( )))) {
            cerr << "Failed to find the condition '" << folderName + conditionName << "' because of: " << result << "." << endl;
            return 1;
        }
        //if( CdbStatus::Success != ( result = CdbCondition::instance( conditionPtr,
        //                                                             conditionName.c_str( )))) {
        //    cerr << "Failed to find the condition \"" << folderName + conditionName << "\" because of: " << result << "." << endl;
        //    return 1;
        //}
        cout << "'" << conditionPtr->name( ) << "':" << endl;

        CdbObjectPtr objectPtr;
        if( CdbStatus::Success != ( result = conditionPtr->findObject( objectPtr,
                                                                       now ))) {
            cerr << "Failed to find an object from the condition '" << conditionName << "'\n"
                << "at the validity point: " << CdbTimeUtils::time2string2( now ) << "\n"
                << "because of: " << result << "." << endl;
            return 1;
        }

        BdbHandle(BdbObject) persistentObjectH;
        if( CdbStatus::Success != ( result = CdbBdbObjectConvertor::narrow( persistentObjectH,
                                                                            objectPtr ))) {
            cerr << "Failed to narrow the found API object into the corresponding persistent one" << endl
                 << "because of the following error: " << result << endl;
            return 1;
        }

      //// Try to get to the actual class specific contents of the found payload object

      //  const std::string className = persistentObjectH.typeName( );
      //  cout << iCondition << " : '" << className << "'";

      //  if( className == CdbRooNTupleSimpleImplR<Double_t>::Class( )->GetName( )) {
      //      const CdbCPtr< CdbRooNTupleSimpleImplR<Double_t> >& testObjectPtr
      //          = (const CdbCPtr< CdbRooNTupleSimpleImplR<Double_t> >&)persistentObjectPtr;
      //      unsigned int bytes = sizeof( Double_t ) * testObjectPtr->columns( ) * testObjectPtr->rows( );
      //      totalBytes += bytes;
      //      cout << " : " << bytes << " : " << totalBytes;
      //  } else {
      //      cerr << " : * : *";
      //  }
      //  cout << endl;
    }
    return 0;
}

namespace {

    bool
    find_conditions( std::vector<std::string>&           theListOfConditions,
                     std::map<std::string,CdbFolderPtr>& theMapOfFolders,
                     const std::string&                  theFolderName )
    {
        CdbStatus result = CdbStatus::Error;

      // Find the base folder itself

        CdbFolderPtr folderPtr;
        if( CdbStatus::Success != ( result = CdbFolder::instance( folderPtr,
                                                                  theFolderName.c_str( )))) {
            cerr << "Failed to find the folder '" << theFolderName << "'\n"
                 << "because of: " << result << "." << endl;
            return false;
        }
        theMapOfFolders[theFolderName] = folderPtr;
        //cout << "added folder to the map: '" << theFolderName << "'" << endl;

      // Find all conditions in that folder and register them in the vector

        CdbConditionItr conditionItr;
        if( CdbStatus::Success != folderPtr->conditionIterator( conditionItr )) {
            cerr << "Failed to set up an iterator of conditions within the folder '" << theFolderName << "'\n"
                 << "because of: " << result << "." << endl;
            return false;
        }
        while( conditionItr.next( )) {
            const std::string conditionName = conditionItr.value( );
            theListOfConditions.push_back( theFolderName + conditionName );
        }

      // Find all sub-folders in that folder and propagate the operation down to them

        CdbFolderItr folderItr;
        if( CdbStatus::Success != folderPtr->folderIterator( folderItr )) {
            cerr << "Failed to set up an iterator of sub-folders within the folder '" << theFolderName << "'\n"
                 << "because of: " << result << "." << endl;
            return false;
        }
        while( folderItr.next( ))
            if( !find_conditions( theListOfConditions,
                                  theMapOfFolders,
                                  theFolderName + folderItr.value( ) + std::string( "/" )));

        return true;
    }
}

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

---