src/Profile/hpcxx/HPCxx_ProfileImpl.C

Go to the documentation of this file.

//##########################################################################
// HPC++Lib: An object-oriented class library for high performance
//           parallel programming.
//
// Copyright (c) 1997
//      Indiana University
//      Los Alamos National Laboratory
//      University of Oregon
//
// http://www.cs.uoregon.edu/paracomp/tau
// http://www.acl.lanl.gov/Tulip
// http://www.extreme.indiana.edu/HPC++
//
// Sameer Shende, Aida Chouchane
// Pete Beckman, Dennis Gannon, Todd Green, Liz Johnson
//
// HPC++_VER:
// Changes : Need to remove parentFunctionId and start time from pFuncList
// and put it on a stack.
//##########################################################################

/********************************************************************/
/*     New Version of the Profiler class                            */
/* (compared to the profiler class defined for pC++)                */
/*     Profiling of hpc++lib-based programs                         */
/* February 1997 --  Aida Chouchane                                 */
/********************************************************************/
/* Description : hpc++ (lib) Profiler library  */


#ifdef PROFILING_ON
#       include <HPCxx_ProfileImpl.h>
#       include <vector.h>

/********************************************************
                  GLOBAL VARIABLES 
 *********************************************************/

#define MAX_THREADS 1024
/*function profiling*/
        int HPCXX_current_node;  /* node id */
        int HPCXX_current_context; /* context id */

        //map< int, HPCxx_ThProfiler, less<int> > thInfo; /* Thread info */ 
        // since index is tid 0..n-1 now, we can have a vector instead of map.
        //vector<HPCxx_ThProfiler> thInfo;
        HPCxx_ThProfiler thInfo[MAX_THREADS]; // instead of an STL map

        int HPCXX_threads; /*total number of created threads*/
        int HPCXX_exited_threads;/*total number of exited threads*/

/*control to access threads and HPCXX_exited_threads variables*/
        nexus_mutex_t HPCXX_counter_mutex; 
        nexus_cond_t HPCXX_counter_cond;

        nexus_mutex_t HPCXX_thinfo_mutex; 
        nexus_mutex_t HPCXX_numfunc_mutex; 
/* mutex to access no of functions in the context */
      int HPCXX_numfunc; 
/*number of functions, considered for all threads created inside this context*/

/* object-specific events*/
        nexus_mutex_t HPCXX_profile_event_mutex;
        int HPCXX_no_of_profile_events = 0 ;
/* no. of events defined in the system - libraries etc. - margin */
        int HPCXX_ProfileSysEventMargin = 0;
/* a mapping of event ids to event names */
        char * HPCXX_profile_event_table[HPCXX_MAX_PROFILE_EVENTS];
        map< int, int, less<int> > tidMap; 
/* Thread id mapping from nex to real thread id  */ 

/*********************************************************
                  GLOBAL FUNCTIONS

**********************************************************/
/* add only what you need */

int tid() {
//If tid returns the thread id as in 0..n-1 then we could just use an array
// or vector for thInfo. A map would be necessary for tid() to translate
// nexus tid to tid.
// return (int) nexus_thread_self();
  int thread_id;
  thread_id = tidMap[nexus_thread_self()];
#ifdef DEBUG_PROF
  cout << "tid returns " << thread_id <<endl;
#endif
  return thread_id; //now it returns 0..n-1.
}


// Set and get the current node and context ids 
void hpcxx_ProfileSetCurrentNodeId(const int& nid) {
  HPCXX_current_node = nid;
}

void hpcxx_ProfileSetCurrentContextId(const int& cid) {
  HPCXX_current_context = cid;
}

int hpcxx_ProfileThisNode() { 
  return HPCXX_current_node; 
}

int hpcxx_ProfileThisContext() {
  return HPCXX_current_context; 
}


void hpcxx_ProfileSetNumberOfFunc(const int& nr ) {
// Does just what it says - sets HPCXX_numfunc to nr so other threads can
// access it
  nexus_mutex_lock(&HPCXX_numfunc_mutex);
  HPCXX_numfunc = nr;
  nexus_mutex_unlock(&HPCXX_numfunc_mutex);
 
  return;
}

void hpcxx_ProfileInit(HPCxx_Group *g) {

  hpcxx_ProfileObjectInit();
  hpcxx_ProfileDumpObjectEventNames();  

  return;
}

void hpcxx_ProfileThreadInit(HPCxx_Group *g) {

  HPCxx_ThProfiler *master_profiler; // used in other func using "this"

  // init mutexes
  nexus_cond_init(&HPCXX_counter_cond, NULL);
  nexus_mutex_init(&HPCXX_counter_mutex, NULL);
  nexus_mutex_init(&HPCXX_numfunc_mutex, NULL);
  nexus_mutex_init(&HPCXX_profile_event_mutex, NULL);

  nexus_mutex_init(&HPCXX_thinfo_mutex, NULL);
  nexus_mutex_lock(&HPCXX_counter_mutex);
  HPCXX_threads = 0;
  HPCXX_exited_threads = 0;
  nexus_mutex_unlock(&HPCXX_counter_mutex);

  // create a new ThProfiler object
  const char* p = "parent";
  master_profiler =  new HPCxx_ThProfiler(p);
  // this increments no of threads and adds the entry to thInfo too.
}

int hpcxx_ProfileIsFunctionTopLevel(const int & thread_id, const int & function_id)
{
// Now, we have a stack, all we have to do is see if this is the only item 
// on the stack and if its id matches.

  hpcxx_CurrentFuncInfo cf;

  cf = thInfo[thread_id].funcStack.top();

#ifdef DEBUG_PROFILE 
  cout << "IsFunctionTopLevel : top returns cf with id "<< cf.myId << " parent = "<< cf.parentFunction << " start " << cf.start << endl;
#endif /* DEBUG_PROFILE */

  if ((thInfo[thread_id].funcStack.size() == 1) && (cf.myId == function_id))
  { 
#ifdef DEBUG_PROF
    cout << "IsFunctionTopLevel: size of stack == 1, myId matches  this is top level" << endl;
#endif /* DEBUG_PROF */
    return 1;
  }
  else
    return 0;
}

void hpcxx_ProfileWaitChildren() {
/* Parent thread (or distinguished thread in a context should not exit before
the children - otherwise the children get killed */
  nexus_mutex_lock(&HPCXX_counter_mutex);
  while ((HPCXX_threads -1) != (HPCXX_exited_threads)) {
    nexus_cond_wait(&HPCXX_counter_cond, &HPCXX_counter_mutex);
  }
  nexus_mutex_unlock(&HPCXX_counter_mutex);
#ifdef DEBUG_PROF
  cout << "Wait Children - unlocking..." << endl;
#endif
}


void hpcxx_ProfileDecrChildren() {

  nexus_mutex_lock(&HPCXX_counter_mutex);
  HPCXX_exited_threads++;

#ifdef DEBUG_PROF
  cout << "DecrChildren:exited threads " << HPCXX_exited_threads << " total threads " << HPCXX_threads << endl;
#endif

  if (HPCXX_exited_threads == (HPCXX_threads-1) ) {
    //    cout << "signal condition" << endl;
    nexus_cond_signal(&HPCXX_counter_cond);
  } 

  // in either case, unlock the mutex 
  nexus_mutex_unlock(&HPCXX_counter_mutex);
 
#ifdef DEBUG_PROF
    cout << "HPCXX_exited_threads successfully incremented..." << endl;
#endif
}

void hpcxx_ProfileExit() {

// This is called by hpcxx_exit() - thread 0
  hpcxx_ProfileExitThread();
// Note for currentFunc to flow properly into IsFunctionTopLevel(), 
// we MUST NEVER instrument either 
// hpcxx_exit or hpcxx_ProfileExit or hpcxx_ProfileExitThread() routines.
  if (tid() == 0) { // master thread 0
    hpcxx_ProfileWaitChildren();
  } 
  else {
    hpcxx_ProfileDecrChildren();
  } 


  return;
}

void  hpcxx_ProfileExitThread( ){
// Called by exit routine for threads 1..n-1.
int my_tid = tid();
int ident_ = thInfo[my_tid].currentFunc;
double start_, duration ;  // typically done in ~HPCxx_FuncProfiler()
hpcxx_CurrentFuncInfo cf; 
int top_level_ = 0;

  /* Algo  with stack  : While size of stack != 0, do  what the destructor 
     would do */
    
  while (!thInfo[my_tid].funcStack.empty()) { // while stack is not empty

#ifdef DEBUG_PROF 
  cout << "hpcxx_ProfileExitThread() : tid " << my_tid << " ident_ " << ident_ << endl; 
#endif /* DEBUG_PROF */

    // do what the dtor of FuncProfiler does 
    thInfo[my_tid].incrFunctionCalls(ident_);   

    // get the start time;
    cf = thInfo[my_tid].funcStack.top(); // get the top record  
    start_ = cf.start; 

    if (start_ != 0.0) { //if "count only" is used, we put start as 0.0 
    //timing data 
      duration = pcxx_GetUSecD() - start_;
      thInfo[my_tid].setFunctionTime(ident_, duration);
    }

    top_level_ = hpcxx_ProfileIsFunctionTopLevel(my_tid, ident_);

    thInfo[my_tid].exitFunctionProfiling(duration);
    ident_ = thInfo[my_tid].currentFunc;

    if (top_level_) { // if I'm top level
      thInfo[my_tid].dumpInformationProfiling(); // dump all data to disk 
    } 
  } // while (!funcstack.empty)
  return;
    
}

int  hpcxx_ProfileGetAndIncrNoThreads() {
// returns thread id and *then* increments the no of threads.
  nexus_mutex_lock(&HPCXX_counter_mutex); 
  int res = HPCXX_threads;
  HPCXX_threads ++;
  if (HPCXX_threads > MAX_THREADS) {
    cout << " ERROR: Increase size of MAX_THREADS, HPCXX_threads = " << HPCXX_threads << endl;
  }
  nexus_mutex_unlock(&HPCXX_counter_mutex);
#ifdef DEBUG_PROF
  cout << "hpcxx_ProfileGetAndIncrNoThreads returns " << res << endl;
#endif
  return res;
}

void hpcxx_ProfileCollNames(char *container, char *datatype, char *var_name, void *var_addr) {
  thInfo[tid()].collNames( container, datatype, var_name, var_addr);
}
void hpcxx_ProfileCollAttr(void *var_addr, int no_of_elements,
                             int dimension, int size_of_aggregate)  {
  thInfo[tid()].collAttr( var_addr,no_of_elements,dimension, size_of_aggregate);

}
void hpcxx_ProfileIncrementCounter(void *addr,int counter_id) {
/* increment a counter associated with an object whose address is addr */
  thInfo[tid()].incrementAggregateCounter( addr, counter_id);
}

int hpcxx_ProfileRegisterEvent(int eventid, char *event_name) { 
 nexus_mutex_init(&HPCXX_profile_event_mutex, NULL);
  
  /* In the table profile_event_table, add the event name and id */
    if ((eventid < 0) || (eventid > HPCXX_MAX_PROFILE_EVENTS ))
    {
        printf("Error in hpcxx_ProfileRegisterEvent : event id %d %s illegal", eventid, event_name);
        return -1;
    }

#ifdef DEBUG_PROF
    cout << "HPCXX_no_of_profile_events = " << HPCXX_no_of_profile_events << endl;
#endif
    /*if user event, convert to the actual event-id in the event-table*/
    //if (HPCXX_ProfileUserEventMargin != -1)
     //eventid = eventid + HPCXX_ProfileUserEventMargin;
    //if (HPCXX_ProfileSysEvents!= -1)
#ifdef DEBUG_PROF
    cout << "HPCXX_ProfileSysEventMargin = " << HPCXX_ProfileSysEventMargin <<endl; 
#endif
      eventid = eventid + HPCXX_ProfileSysEventMargin;
      //else
      //HPCXX_ProfileUserEventMargin ++;

    //    cout << "event to add "  << eventid << endl;
    /*Safety check: register event only if it hasn't already 
      been register by some other thread*/

#ifdef DEBUG_PROF
      cout << "HPCXX_profile_event_table[" << eventid << "] == NULL:: " <<  (HPCXX_profile_event_table[eventid] == NULL) << endl;
#endif
    if ( HPCXX_profile_event_table[eventid] == NULL) {
      HPCXX_profile_event_table[eventid] = strnew(event_name);

      nexus_mutex_lock(&HPCXX_profile_event_mutex);
      HPCXX_no_of_profile_events ++;
      nexus_mutex_unlock(&HPCXX_profile_event_mutex);                
    }
  return 1;
}

int hpcxx_ProfileGetEventCounter(void)
{
  int res;
  nexus_mutex_lock(&HPCXX_profile_event_mutex);
  res = HPCXX_no_of_profile_events;
  nexus_mutex_unlock(&HPCXX_profile_event_mutex);
  return res;
}

int hpcxx_ProfileShowEventTable(void)
{ /* for debugging */
    int i;

    nexus_mutex_lock(&HPCXX_profile_event_mutex);
    for (i = 0; i < HPCXX_no_of_profile_events; i++)
    {
        printf("show_profile_event_table: Event id %d event =%s \n",i, HPCXX_profile_event_table[i]);
    }
    nexus_mutex_unlock(&HPCXX_profile_event_mutex);
    return 1;
}

int hpcxx_ProfileObjectInit(void)
{

  HPCXX_ProfileSysEventMargin =  HPCXX_no_of_profile_events ;

  //   hpcxx_ProfileInitNrOfSysEvents();
/* During startup, on node 0, register the profiling events */

   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Wait_HPCxx_Cond          ,"cond_wait");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Signal_HPCxx_Cond    ,"cond_signal");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Broadcast_HPCxx_Cond ,"cond_broadcast");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Read_HPCxx_GlobalPtr ,"global_ptr_read");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Write_HPCxx_GlobalPtr ,"global_ptr_write");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Write_HPCxx_SyncQ,"sync_q_write");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Read_HPCxx_SyncQ ,"sync_q_read");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_WaitAndCopy_HPCxx_SyncQ,
                              "sync_q_wait_and_copy");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Create_HPCxx_Thread,
                              "thread_create");
   /*   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Stop_HPCxx_Thread,"thread_stop");
        hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Yield_HPCxx_Thread,"thread_yield");
        hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Sleep_HPCxx_Thread,"thread_sleep");
   */
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Suspend_HPCxx_Thread,
                              "thread_suspend");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Resume_HPCxx_Thread,
                              "thread_resume");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Join_HPCxx_Thread,"thread_join");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Wait_HPCxx_CSem,"csem_wait");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Increment_HPCxx_CSem,"csem_incr");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Read_HPCxx_Sync,"sync_read");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Write_HPCxx_Sync,"sync_write");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Lock_HPCxx_Mutex,"mutex_lock");
   hpcxx_ProfileRegisterEvent(HPCXX_PROFILE_Unlock_HPCxx_Mutex,"mutex_unlock");

#ifdef DEBUG_PROF
   hpcxx_ProfileShowEventTable();
#endif
   return 1;
}

/*  void hpcxx_ProfileInitNrOfSysEvents() {
    if (HPCXX_ProfileUserEventMargin == 0)
    HPCXX_ProfileSysEvents = 0;
    else
    HPCXX_ProfileSysEvents = HPCXX_ProfileUserEventMargin - 1;
    }*/

int  hpcxx_ProfileDumpObjectEventNames()
{
  /* dump in profile.ctab object profile event id and its name */
  int  out, nevents,i;
  char buf[256];
  char profname[16];
        
  sprintf (profname, "profile.ctab");
  if ( (out = creat (profname, 0644)) == -1 ) {
  perror (profname);
  exit (1);
  }
        
  nevents = hpcxx_ProfileGetEventCounter();
  sprintf(buf,"%d\n", nevents);
  write(out, buf,strlen(buf));

  for(i = 0; i < nevents; i++)
  { 
    sprintf(buf,"%d \"%s\"\n",i, HPCXX_profile_event_table[i]);
    write(out, buf, strlen(buf));
  }
  close(out);
  return 1;
}


// HPCxx_ProfileVarInfo member functions

HPCxx_ProfileVarInfo:: HPCxx_ProfileVarInfo() 
{ 
  for(int i = 0; i< HPCXX_MAX_COUNTERS; i++) {
    nexus_mutex_init(&counterLocks[i], NULL);
    nexus_mutex_lock(&counterLocks[i]);
    counters[i] = 0;
    nexus_mutex_unlock(&counterLocks[i]);
  }
  numelems = size = 0;
  dim = 1; /* defaults */
}

HPCxx_ProfileVarInfo:: HPCxx_ProfileVarInfo(const char *cname, const char *ctype, const char *vname)
{ 
  containerName = strnew(cname);
  containerType = strnew(ctype);
  varName = strnew(vname);
  for(int i = 0; i< HPCXX_MAX_COUNTERS; i++) {
    nexus_mutex_init(&counterLocks[i], NULL);
          nexus_mutex_lock(&counterLocks[i]);
          counters[i] = 0;
          nexus_mutex_unlock(&counterLocks[i]);
  }
  numelems = size = 0;
  dim = 1; /* defaults */
}

void HPCxx_ProfileVarInfo:: incrementCounter(int counter_id)
{
  if((counter_id > HPCXX_MAX_COUNTERS) || (counter_id < 0))
    {
      cerr << "Range error counter id = " << counter_id << endl;        
    }   
  else {
    nexus_mutex_lock(&counterLocks[counter_id]);
    counters[counter_id] ++;
    nexus_mutex_unlock(&counterLocks[counter_id]);
  }
}

void HPCxx_ProfileVarInfo:: registerAttributes(int no_of_elements, int dimension, int size_of_aggregate)
{
        numelems = no_of_elements;
        dim = dimension;
        size = size_of_aggregate;

        return;
}

const  HPCxx_ProfileVarInfo& HPCxx_ProfileVarInfo:: operator = ( const HPCxx_ProfileVarInfo& t) {
  containerName = t.containerName;
  containerType = t.containerType;
  varName = t.varName;
  numelems = t.numelems;
  dim = t.dim;
  size = t.size;
  return *this;
}


// ThProfiler member function definitions 
HPCxx_ThProfiler:: HPCxx_ThProfiler(int pid ){
  id_ = hpcxx_ProfileGetAndIncrNoThreads();
  // id_ and nexus_tid mapping is preserved in tidMap
  tidMap[nexus_thread_self()] = id_;
  parentTh_ = pid ;
  contNameDb_ = new map<void*, HPCxx_ProfileVarInfo, lptr>();
  currentFunc = -1; // Do not remove. Used later to set parent = -1 in 
                    // updateFunctions
  
  nexus_mutex_lock(&HPCXX_thinfo_mutex);
  thInfo[tid()] = *this;  // add ThProfiler to the thInfo map  
  nexus_mutex_unlock(&HPCXX_thinfo_mutex);
}

HPCxx_ThProfiler:: HPCxx_ThProfiler(const char* p  ){
  id_ = hpcxx_ProfileGetAndIncrNoThreads();
  // id_ and nexus_tid mapping is preserved in tidMap
  tidMap[nexus_thread_self()] = id_;
  parentTh_ = -1;
  contNameDb_ = new map<void*, HPCxx_ProfileVarInfo, lptr>();
  currentFunc = -1; // Do not remove. Used later to set parent = -1 in 
                    // updateFunctions

  nexus_mutex_lock(&HPCXX_numfunc_mutex);
  thInfo[tid()] = *this;
  nexus_mutex_unlock(&HPCXX_numfunc_mutex);
}

void HPCxx_ThProfiler:: initFunctionList(const int& n) {
// n is the number of functions registered in this context
  pFuncList_ = new hpcxx_ProfileFuncDescr [n];

  for (int i = 0 ; i < n ; (i)++)
    {
      pFuncList_[i].numcalls = 0;
      pFuncList_[i].usec = 0.0;
      pFuncList_[i].cumusec = 0.0;
    }
}

const  HPCxx_ThProfiler& HPCxx_ThProfiler:: operator = ( const HPCxx_ThProfiler& t) {
  id_ = t.id_;
  pFuncList_ = t.pFuncList_;
  currentFunc = t.currentFunc;
  parentTh_ = t.parentTh_ ;
  contNameDb_ = t.contNameDb_;
  return *this;
}

int HPCxx_ThProfiler:: getNumberOfCollections() {
  return contNameDb_->size();
}

void HPCxx_ThProfiler:: incrFunctionCalls(const int& fid) {
  // checkFunctionList_();   // is it needed? 
  pFuncList_[fid].numcalls++;
#ifdef DEBUG_PROF
  cout << "incrFunctionCalls: tid = "<< id_ << " fid = " << fid << " numcalls = "<< pFuncList_[fid].numcalls << endl;
#endif /* DEBUG_PROF */
}

void HPCxx_ThProfiler:: setFunctionTime(const int& fid , const double& duration) {
  // set cumulative inclusive (cumusec) and exclusive (usec) fields
  pFuncList_[fid].usec += duration;
  pFuncList_[fid].cumusec += duration;
#ifdef DEBUG_PROF
  cout << "setFunctionTime: tid = "<< id_ << " pFuncList_["<< fid << "].usec = "<< pFuncList_[fid].usec << "cumusec = " << pFuncList_[fid].cumusec << endl; 
#endif /* DEBUG_PROF */
}

void HPCxx_ThProfiler:: updateFunctions(const int&  fct_id, const double& start) {
  // set function ids for parent and current function and flag it as active
  // parentFunc_ = currentFunc;
  hpcxx_CurrentFuncInfo cf;
  cf.parentFunction = currentFunc;
  cf.myId = fct_id;
  cf.start = start; 
  // sets parentFunctionId to currentFunction, id to fct_id and the start time
  funcStack.push(cf);

  currentFunc = fct_id; 

#ifdef DEBUG_PROF
  cout << "updateFunctions: tid = "<< id_ << " fid = "<< fct_id << " parent = " << cf.parentFunction << endl;
#endif /* DEBUG_PROF */

}

void HPCxx_ThProfiler:: exitFunctionProfiling(const double& duration) {
  // Let exitFunctionProfiling do the "pop" on the stack
  hpcxx_CurrentFuncInfo cf;
  // While exiting, set the function as inactive

  cf = funcStack.top();
#ifdef DEBUG_PROF 
  cout << "exitFunctionProfiling tid = "<< id_ << " cf.par = "<< cf.parentFunction << " cf.myId " << cf.myId << " duration = " << duration << endl;
#endif /* DEBUG_PROF */
  funcStack.pop(); // This record removed from the stack
  currentFunc = cf.parentFunction; // sets it. 
 

  // decrement the time spent exclusively in the parent function
  if (duration > 1e6)  // double - if resolution is positive microsecs.
    pFuncList_[cf.parentFunction].usec -= duration;
#ifdef DEBUG_PROF
  cout << "exitFunctionProfiling: tid = "<< id_ << " currentFunc = " << currentFunc  << endl;
#endif  /* DEBUG_PROF */

}

void HPCxx_ThProfiler:: collNames(char *container, char *datatype, 
                                         char *var_name, void *var_addr) {
  (*contNameDb_)[var_addr] = HPCxx_ProfileVarInfo(container, datatype, var_name);
  /* register the name e.g., "distributed_vector", "int", "row", &row */
  
  /*   for(map<void*, HPCxx_ProfileVarInfo, lptr>::const_iterator it = contNameDb_->begin();
       it != contNameDb_->end();
       ++it) {}*/
}

void HPCxx_ThProfiler:: collAttr(void *var_addr, int no_of_elements, 
                                   int dimension, int size_of_aggregate) {
  map<void*, HPCxx_ProfileVarInfo, lptr>::iterator 
   it = contNameDb_->find(var_addr);
  if ( (it == contNameDb_->end()) && ((*it).first != var_addr) )
    return;

  (*contNameDb_)[var_addr].registerAttributes(no_of_elements, dimension, 
                                                size_of_aggregate);
/*   for(map<void*, HPCxx_ProfileVarInfo, lptr>::const_iterator itc = contNameDb_->begin();
      itc != contNameDb_->end();
      ++itc) {}*/  
}

void HPCxx_ThProfiler:: incrementAggregateCounter(void *addr,
                                                     int counter_id) {
  map<void*, HPCxx_ProfileVarInfo, lptr>::iterator 
    it = contNameDb_->find(addr);
  if (it == contNameDb_->end())
    return;
  (*contNameDb_)[addr].incrementCounter(counter_id);
}  


void HPCxx_ThProfiler:: setStartTime(const int & fid, const double & s) {
/* old code - we may remove this function  */

//  pFuncList_[fid].start = s;

#ifdef DEBUG_PROF
 // cout << "setStartTime: tid = "<< id_ << " pFuncList_["<< fid << "].start = "<< pFuncList_[fid].start << endl; 
#endif /* DEBUG_PROF */
} 

void HPCxx_ThProfiler:: dumpInformationProfiling() {
  int i;
  char buf[256];
  char* filename;
  int f;

  char counter_info[32];
  char counter_string[HPCXX_MAX_COUNTER_STRING]; 
  int numcoll;
  int no_active_counters;  
  
  nexus_mutex_lock(&HPCXX_numfunc_mutex);
  int n = HPCXX_numfunc;
  nexus_mutex_unlock(&HPCXX_numfunc_mutex);

  filename = new char [256];
  sprintf (filename, "profile.%d.%d.%d",hpcxx_ProfileThisNode(),
           hpcxx_ProfileThisContext(), id_ );  // id_ is the tid  

  if ( (f = creat (filename, 0644)) == -1 ) {
    cout << " Error in creating " << filename << " !!!!!!!!!!!!!!!!!!!!!!" << endl;
    perror (filename);
    exit (1);
  }

#ifdef DEBUG_PROF
  cout << " before dumping function data " << endl; 
#endif /* DEBUG_PROF */
  sprintf (buf, "%d func\n",n);

  write(f, buf, strlen(buf) );  
  // checkFunctionList_();
  // should we check?

  for (i = 0; i<n; i++) {
    if (pFuncList_[i].numcalls > 0 ) { // instead of usec > 0.0
      sprintf (buf, "%d %G %G\n", 
               pFuncList_[i].numcalls,
               pFuncList_[i].usec,
               pFuncList_[i].cumusec); 
      write(f, buf, strlen(buf) );
    }
    else {
      sprintf (buf, "%d 0 0 \n", 
               pFuncList_[i].numcalls); 
      write(f, buf, strlen(buf) );
    }
  }

#ifdef DEBUG_PROF
  cout << " before dumping coll data " << endl; 
#endif /* DEBUG_PROF */
  //numcoll = hpcxx_ProfileGetNumberOfCollection();
  numcoll = thInfo[id_].getNumberOfCollections(); 
  sprintf (buf, "%d aggregates\n", numcoll);
  write (f, buf, strlen(buf));
  if (numcoll > 0) { 
    for(map<void*, HPCxx_ProfileVarInfo, lptr>::const_iterator it = contNameDb_->begin();
        it != contNameDb_->end();
        ++it) 
      { 
        const map<void*, HPCxx_ProfileVarInfo, lptr>::value_type& elem = *it;
  
  #ifdef DEBUG_PROF
      cout << "printing into buffer" << endl;
  #endif
      sprintf(counter_string,""); /* NULL - clean it*/
      no_active_counters = 0; 
      for(i = 0; i < HPCXX_MAX_COUNTERS; i++)
        {               
        if(elem.second.counters[i] != 0)
          {
            no_active_counters ++;
            sprintf(counter_info,"%d %ld ", i, elem.second.counters[i]);
            /* note space after %ld (sp between nos) is imp */
            strcat(counter_string,counter_info);
  #ifdef DEBUG_PROF
            printf("thread %d: active %d, id %d no %d\n",
                   tid(), 
                   no_active_counters, i, elem.second.counters[i]);
  #endif /* DEBUG_PROF */
            
          }
        } /* now no_active_counters and counter_string can be used */
  #ifdef DEBUG_PROF
      printf("thread %d: string =%s\n",
           tid(), 
           counter_string);
  #endif /* DEBUG_PROF */
      
      
      sprintf(buf, "%d %d %d %d %s %s %s %s\n",
            no_active_counters,
            elem.second.numelems,
            elem.second.dim,
            elem.second.size,
            counter_string,
            elem.second.containerName,
            elem.second.containerType,
            elem.second.varName);
     
      write (f, buf, strlen(buf));
    }
  } // numcoll > 0
  close (f);
}




HPCxx_FuncProfiler:: HPCxx_FuncProfiler(int id){
int my_tid = tid();
#ifdef DEBUG_PROF
  printf("Inside HPCxx_FuncProfiler ctor 1 arg id  = %d, thread = %d\n",id, my_tid);
#endif
  
  // function identifier
  ident_ = id;

  // no. of functions field initialized.
  // if nf_ is -1, then it stands for "count only" no timing data to be collected.
  nf_ = 0; // collect timing data

  start_ = pcxx_GetUSecD();
  thInfo[my_tid].updateFunctions(id, start_); 
  // no need to go thru' hpcxx_ProfileFuncEnter 
  // this sets parent function ids and active flag for id.

    
  // thInfo[my_tid].setStartTime(id, start_);
  // no need to go through hpcxx_ProfileSetStartTime(id, start_);

}


HPCxx_FuncProfiler:: HPCxx_FuncProfiler(int id, int num ) {
  int my_tid = tid();
#ifdef DEBUG_PROF
  printf("Inside HPCxx_FuncProfiler ctor 2 arg id  = %d, num = %d, thread %d\n",id, num, my_tid);
#endif
  ident_ = id;  

  nf_ = num;

  hpcxx_ProfileSetNumberOfFunc(num );
  //necessary for initializing the number of functions 
  //in other threads... same address space!

  thInfo[my_tid].initFunctionList(num) ;
  // init Function List creates pFuncList and initializes entries

  start_ = pcxx_GetUSecD();
  thInfo[my_tid].updateFunctions(id, start_); 
  // update Functions sets parent id, current id, and also sets id as "active"

  
  // thInfo[my_tid].setStartTime(id, start_);
  // instead of using hpcxx_ProfileSetThreadStartTime(start_);


}

HPCxx_FuncProfiler:: HPCxx_FuncProfiler(int id,char countonly){
 int my_tid = tid();
#ifdef DEBUG_PROF
  printf("Inside countonly HPCxx_FuncProfiler ctor 2 arg id  = %d, countonly = %c, thread %d\n",id, countonly, my_tid);
#endif
  ident_ = id;

  nf_ = -1; // count only

  thInfo[my_tid].updateFunctions(id, 0.0);
  // update Functions sets parent id, current id, and also sets id as "active"

  // In this ctor - no timing information is collected "count only"
}

HPCxx_FuncProfiler:: HPCxx_FuncProfiler(int id, int num , char countonly ) {
  int my_tid = tid();
#ifdef DEBUG_PROF
  printf("Inside counonly HPCxx_FuncProfiler ctor 3 arg id  = %d, num = %d, thread %d\n",id, num, my_tid);
#endif
  ident_ = id;  

  nf_ = -1; // count only  - nf_ == -1, start = 0.0

  hpcxx_ProfileSetNumberOfFunc(num );
  //necessary for initializing the number of functions 
  //in other threads... same address space!

  thInfo[my_tid].initFunctionList(num) ;
  // init Function List creates pFuncList and initializes entries

  thInfo[my_tid].updateFunctions(id, 0.0); 
  // update Functions sets parent id, current id, and also sets id as "active"

}



HPCxx_FuncProfiler:: ~HPCxx_FuncProfiler() {
   double duration = 0.0;
   int my_tid = tid();
#ifdef DEBUG_PROF
   printf("DESCTRUCTOR HPCxx_FuncProfiler id = %d, thread = %d\n", ident_, my_tid );
#endif
  
  thInfo[my_tid].incrFunctionCalls(ident_);   
     
  if (!hpcxx_ProfileIsFunctionTopLevel(my_tid, ident_)) {
    if (nf_ != -1) { // counts only is -1  then we don't need to incr time
      duration = pcxx_GetUSecD() - start_;
      thInfo[my_tid].setFunctionTime(ident_, duration);
    }

    thInfo[my_tid].exitFunctionProfiling(duration);
  } 
  // Top level functions are taken care of elsewhere
  // removed if (ident_ == 0) restriction here.  
}


#endif /* PROFILING_ON */

---