src/Profile/hpcxx/HPCxx_Profile.h

Go to the documentation of this file.

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 * This program was prepared by PSI. 
 * All rights in the program are reserved by PSI.
 * Neither PSI nor the author(s)
 * makes any warranty, express or implied, or assumes any liability or
 * responsibility for the use of this software
 *
 * Visit http://www.acl.lanl.gov/POOMS for more details
 *
 ***************************************************************************/

//##########################################################################
// 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: 
//##########################################################################

#ifndef __HPCXX_PROFILE_H_
#define __HPCXX_PROFILE_H_


#define HPCXX_MAX_COUNTERS      256
#define HPCXX_MAX_PROFILE_EVENTS        HPCXX_MAX_COUNTERS
#define HPCXX_MAX_COUNTER_STRING        8*HPCXX_MAX_COUNTERS


      /*hpc++ lib relevant events to be registered for profiling */


      /*3 counters for a Cond*/
#define HPCXX_PROFILE_Wait_HPCxx_Cond         0
#define HPCXX_PROFILE_Signal_HPCxx_Cond       1
#define HPCXX_PROFILE_Broadcast_HPCxx_Cond    2

      /*2 counters for a GlobalPtr*/
#define HPCXX_PROFILE_Read_HPCxx_GlobalPtr    3
#define HPCXX_PROFILE_Write_HPCxx_GlobalPtr   4

      /*3 counters for a SyncQ*/
#define HPCXX_PROFILE_Write_HPCxx_SyncQ       5
#define HPCXX_PROFILE_Read_HPCxx_SyncQ        6
#define HPCXX_PROFILE_WaitAndCopy_HPCxx_SyncQ 7

      /*6 counters for a Thread*/
#define HPCXX_PROFILE_Create_HPCxx_Thread     8
#define HPCXX_PROFILE_Suspend_HPCxx_Thread    9
#define HPCXX_PROFILE_Resume_HPCxx_Thread     10
#define HPCXX_PROFILE_Join_HPCxx_Thread       11
/*#define HPCXX_PROFILE_Stop_HPCxx_Thread       12
  #define HPCXX_PROFILE_Sleep_HPCxx_Thread      13
  #define HPCXX_PROFILE_Yield_HPCxx_Thread      14*/

      /*2 counters for a CSem*/
#define HPCXX_PROFILE_Increment_HPCxx_CSem    12
#define HPCXX_PROFILE_Wait_HPCxx_CSem         13

      /*2 counters for a Sync*/
#define HPCXX_PROFILE_Write_HPCxx_Sync        14
#define HPCXX_PROFILE_Read_HPCxx_Sync         15

      /*2 counters for a Mutex*/
#define HPCXX_PROFILE_Lock_HPCxx_Mutex        16
#define HPCXX_PROFILE_Unlock_HPCxx_Mutex      17

class HPCxx_Thread;
class HPCxx_Runnable;
class HPCxx_Group;

#ifdef PROFILING_ON
// map is used in a class member data field. 
#ifndef PARSE_ONLY
#include <map.h>
#include <vector.h>
#include <deque.h>
#include <stack.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

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

  /* THREAD PROFILING*/

void hpcxx_ProfileInit(HPCxx_Group *g);
void hpcxx_ProfileThreadInit(HPCxx_Group *g);
void hpcxx_ProfileExit();
void hpcxx_ProfileExitThread();
void hpcxx_ProfileDecrChildren();
void hpcxx_ProfileWaitChildren();
int  tid();

   /* FUNCTION PROFILING*/

int  hpcxx_ProfileIsFunctionTopLevel(const int &, const int &);
void hpcxx_ProfileSetNumberOfFunc( const int& );

void hpcxx_ProfileSetCurrentNodeId(const int& nid);
void hpcxx_ProfileSetCurrentContextId(const int& cid);
int  hpcxx_ProfileThisNode();
int  hpcxx_ProfileThisContext();

   /* AGGREGATE-SPECIFIC EVENT TRACING */
int  hpcxx_ProfileGetEventCounter(void);
int  hpcxx_ProfileShowEventTable(void);
//void hpcxx_ProfileInitNrOfSysEvents();
int  hpcxx_ProfileObjectInit(void);
int  hpcxx_ProfileDumpObjectEventNames();

/*API for user, to register new events to be traced dynamically*/
int  hpcxx_ProfileRegisterEvent(int eventid, char *event_name);
void hpcxx_ProfileIncrementCounter(void *addr,int counter_id);

/*API for user, to register aggregates into the system*/
void hpcxx_ProfileCollNames(char *coll, char *elem, 
                            char *var, void *var_addr); 
void hpcxx_ProfileCollAttr(void *var_addr, int no_of_elements, 
                           int dimension, int size_of_aggregate);
 



/*************************************************************************
**************************************************************************/
inline char* strnew(const char* str) {
    char* newstr = 0;
    if (str) {
        newstr = new char[strlen(str) + 1];
        strcpy(newstr, str);
    }
    return newstr;
}

struct lptr
{
  bool operator()(void* s1, void* s2) const
  {
    return s1 < s2;
  }
}; 

typedef struct  hpcxx_ProfileFuncDescr {
  int numcalls;
  double usec;
  double cumusec;
} hpcxx_ProfileFuncDescr;

typedef struct hpcxx_CurrentFuncInfo {
  int parentFunction; // fid of calling function
  int myId; // current function id
  double start; // starting time of myId function
} hpcxx_CurrentFuncInfo; 

#ifdef __cplusplus
}
#endif  


class HPCxx_ProfileVarInfo
{
public:
        char *containerName;
        char *containerType;
        char *varName;

        int  numelems ;
        int  dim ;
        int  size  ;
        long counters[HPCXX_MAX_COUNTERS]; 
        nexus_mutex_t counterLocks[HPCXX_MAX_COUNTERS];
/* for keeping track of events that take place on an object */
        HPCxx_ProfileVarInfo(); 
        HPCxx_ProfileVarInfo(const char *cname, const char *ctype, const char *vname);
        void incrementCounter(int counter_id);
        void registerAttributes(int no_of_elements, int dimension, int size_of_aggregate);
        const  HPCxx_ProfileVarInfo& operator = ( const HPCxx_ProfileVarInfo& t) ;
}; 




class  HPCxx_ThProfiler {


#ifndef PARSE_ONLY
    map<void*, HPCxx_ProfileVarInfo, lptr>* contNameDb_; 
#endif

    int parentTh_;
    int id_;

    void checkFunctionList_();
public:
    hpcxx_ProfileFuncDescr *pFuncList_;
    stack<hpcxx_CurrentFuncInfo, vector<hpcxx_CurrentFuncInfo> > funcStack;
    int currentFunc;
    
    HPCxx_ThProfiler() {}; /*default constructor*/
    HPCxx_ThProfiler( int );
    HPCxx_ThProfiler(const char* p);
    ~HPCxx_ThProfiler() {};

    const HPCxx_ThProfiler& operator = ( const HPCxx_ThProfiler& );

    int getThreadId();
    int getParentId();

    void initFunctionList(const int&);
    void exitFunctionProfiling(const double&);
    void dumpInformationProfiling();
    void setFunctionTime(const int& , const double&);
    void incrFunctionCalls(const int&);
    void updateFunctions(const int& , const double&);
    void setStartTime(const int& , const double &);

    int getNumberOfCollections();
    void collNames( char *, char *, char *, void *);
    void collAttr(void *, int, int, int);
    void incrementAggregateCounter(void *,int );
};

class HPCxx_FuncProfiler {
  int ident_;
  int nf_;
  double start_;

public:
  HPCxx_FuncProfiler(int id);
  HPCxx_FuncProfiler(int id, int num);
  HPCxx_FuncProfiler(int id, char countonly);
  HPCxx_FuncProfiler(int id, int num , char countonly);
  ~HPCxx_FuncProfiler() ;

};


#else /* PROFILING_ON */
// Profiling is turned off - default mode
#   define hpcxx_ProfileInit(g)
#   define hpcxx_ProfileThreadInit(g)
#   define hpcxx_ProfileExit()
#   define hpcxx_ProfileExitThread()
#   define hpcxx_ProfileDecrChildren()
#   define hpcxx_ProfileWaitChildren()
#   define tid()
#   define hpcxx_ProfileIsFunctionTopLevel(thread_id, function_id)
#   define hpcxx_ProfileSetNumberOfFunc(fn)
//#   define hpcxx_ProfileFuncEnter(fid ) 
//#   define hpcxx_ProfileFuncExit(fid,d)
#   define hpcxx_ProfileSetCurrentNodeId(nid)
#   define hpcxx_ProfileSetCurrentContextId(cid)
#   define hpcxx_ProfileThisNode()
#   define hpcxx_ProfileThisContext()
#   define hpcxx_ProfileGetEventCounter()
#   define hpcxx_ProfileShowEventTable()
#   define hpcxx_ProfileObjectInit()
#   define hpcxx_ProfileInitNrOfSysEvents()
#   define hpcxx_ProfileDumpObjectEventNames()
#   define hpcxx_ProfileRegisterEvent(eventid,event_name)
#   define hpcxx_ProfileIncrementCounter(addr,counter_id)
#   define hpcxx_ProfileCollNames(coll,elem,var,var_addr) 
#   define hpcxx_ProfileCollAttr(var_addr,no_of_elements,dimension,size_of_aggregate)

// Define dummy classes that do not do anything 
class HPCxx_FuncProfiler {
  int ident_;
  int nf_;
  double start_;

public:
  HPCxx_FuncProfiler(int id) {};
  HPCxx_FuncProfiler(int id, int num) {};
  HPCxx_FuncProfiler(int id, char countonly) {};
  HPCxx_FuncProfiler(int id, int num , char countonly ) {};
  ~HPCxx_FuncProfiler() {};
};

class  HPCxx_ThProfiler {
public:
    HPCxx_ThProfiler() {}; /*default constructor*/
    HPCxx_ThProfiler( int ) {};
    HPCxx_ThProfiler(const char* p) {};
    ~HPCxx_ThProfiler() {};
};


#endif /*PROFILING_ON*/


#endif /* __HPCXX_PROFILE_H_ */


/***************************************************************************
 * $RCSfile: addheaderfooter,v $   $Author: adelmann $
 * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:17 $
 * IPPL_VERSION_ID: $Id: addheaderfooter,v 1.1.1.1 2003/01/23 07:40:17 adelmann Exp $ 
 ***************************************************************************/

---