Non-tested Fortran MPI function tracing API.
authorChee Wai Lee <cheelee@illinois.edu>
Sat, 5 Feb 2005 23:35:06 +0000 (23:35 +0000)
committerChee Wai Lee <cheelee@illinois.edu>
Sat, 5 Feb 2005 23:35:06 +0000 (23:35 +0000)
src/ck-perf/trace-common.C
src/ck-perf/trace-converse.c
src/ck-perf/trace-projections.C
src/ck-perf/trace-projections.h
src/ck-perf/trace.h
src/ck-perf/tracef.C
src/ck-perf/tracef_f.f90
src/conv-core/conv-trace.h
src/libs/ck-libs/armci/armci.h

index 4dbdb75219a9dab3b88799f8b7f68407c223d5b8..bf29333c74109df583e18752d3354ea78e204dca 100644 (file)
@@ -409,18 +409,40 @@ void TraceArray::creationMulticast(envelope *env, int ep, int num,
     ALLDO(creationMulticast(env, ep, num, pelist));
 }
 
+/*
 extern "C" 
 void registerFunction(char *name){
        _TRACE_ONLY(CkpvAccess(_traces)->regFunc(name));
 }
+*/
+
+extern "C"
+int registerFunction(char* name) {
+#ifndef CMK_OPTIMIZE
+  return CkpvAccess(_traces)->regFunc(name);
+#else
+  return 0;
+#endif
+}
 
 extern "C" 
 void beginFuncProj(char *name,char *file,int line){
         _TRACE_ONLY(CkpvAccess(_traces)->beginFunc(name,file,line));
 }
 
+extern "C"
+void beginFuncIndexProj(int idx,char *file,int line){
+        _TRACE_ONLY(CkpvAccess(_traces)->beginFunc(idx,file,line));
+}
+
 extern "C" 
 void endFuncProj(char *name){
         _TRACE_ONLY(CkpvAccess(_traces)->endFunc(name));
 }
+
+extern "C" 
+void endFuncIndexProj(int idx){
+        _TRACE_ONLY(CkpvAccess(_traces)->endFunc(idx));
+}
+
 /*@}*/
index 0c4d581ada31a3d18ac5ef33d96d232df60f2ca2..fa22d67c0d1c5705aabc9f5794d7eb2bd7b29341 100644 (file)
@@ -40,10 +40,10 @@ void traceEnd(void) {}
 void traceWriteSts(void) {}
 void traceFlushLog(void) {}
 int  traceAvailable() {return 0;}
-void registerFunction(char *name){
-}
-void beginFuncProj(char *name,char *file,int line){
-}
-void endFuncProj(char *name){
-}
+
+int registerFunction(char *name) {}
+void beginFuncIndexProj(int idx, char* name, int lineNo) {}
+void endFuncIndexProj(int idx) {}
+void beginFuncProj(char *name,char *file,int line){}
+void endFuncProj(char *name){}
 
index ea8ea454bd216aaead2e91089c0fa230b5f8570d..80cbffc01aa5b7052eeae96240f5b34c4eba700b 100644 (file)
@@ -1048,7 +1048,7 @@ void TraceProjections::endComputation(void)
   _logPool->add(END_COMPUTATION, 0, 0, TraceTimer(), -1, -1);
 }
 
-void TraceProjections::regFunc(char *name){
+int TraceProjections::regFunc(char *name){
        StrKey k(name,strlen(name));
        int num = funcHashtable.get(k);
        if(num == 0){
@@ -1057,31 +1057,38 @@ void TraceProjections::regFunc(char *name){
                StrKey *newKey = new StrKey(st,strlen(st));
                int &ref = funcHashtable.put(*newKey);
                ref=funcCount;
+               num = funcCount;
                funcCount++;
        }
-
+       return num;     
 }
 
 void TraceProjections::beginFunc(char *name,char *file,int line){
        StrKey k(name,strlen(name));    
        unsigned short  num = (unsigned short)funcHashtable.get(k);
-       if(num == 0){
-               CmiError("Unregistered function %s being used in %s:%d \n",name,file,line);
-       }
-       _logPool->add(BEGIN_FUNC,TraceTimer(),num,line,file);
+       beginFunc(num,file,line);
+}
+
+void TraceProjections::beginFunc(int idx,char *file,int line){
+       if(idx <= 0){
+               CmiError("Unregistered function id %d being used in %s:%d \n",idx,file,line);
+       }       
+       _logPool->add(BEGIN_FUNC,TraceTimer(),idx,line,file);
 }
 
 void TraceProjections::endFunc(char *name){
        StrKey k(name,strlen(name));    
        int num = funcHashtable.get(k);
-       if(num == 0){
+       endFunc(num);   
+}
+
+void TraceProjections::endFunc(int num){
+       if(num <= 0){
                printf("endFunc without start :O\n");
        }
-       _logPool->add(END_FUNC,TraceTimer(),num,0,NULL);        
+       _logPool->add(END_FUNC,TraceTimer(),num,0,NULL);
 }
 
-
-
 // specialized PUP:ers for handling trace projections logs
 void toProjectionsFile::bytes(void *p,int n,size_t itemSize,dataType t)
 {
index b4667ee8ec0a95e0cef72a73045175c2c896bd47..397df7b78258452dc3454137f13622935520b893 100644 (file)
@@ -272,9 +272,11 @@ class TraceProjections : public Trace {
     //functions that perform function tracing
     CkHashtableIterator *getfuncIterator(){return funcHashtable.iterator();};
     int getFuncNumber(){return funcHashtable.numObjects();};
-    void regFunc(char *name);
+    int regFunc(char *name);
     void beginFunc(char *name,char *file,int line);
+               void beginFunc(int idx,char *file,int line);
     void endFunc(char *name);
+               void endFunc(int num);
 
     /* for overiding basic thread listener support in Trace class */
     virtual void traceAddThreadListeners(CthThread tid, envelope *e);
index b78a628e3189b02e80c1aa3fa966dae29d5f977b..ccd4dc704bc309be8170a91bde1a78e3553d79ea 100644 (file)
@@ -119,9 +119,11 @@ class Trace {
     virtual void traceFlushLog() {}
 
     //for tracing function calls
-    virtual void regFunc(char *name){}
+    virtual int regFunc(char *name){}
     virtual void beginFunc(char *name,char *file,int line){}
-    virtual void endFunc(char *name){}
+    virtual void beginFunc(int idx,char *file,int line){}
+    virtual void endFunc(char *name){}    
+    virtual void endFunc(int idx){}
 
     /* for implementing thread listeners */
     virtual void traceAddThreadListeners(CthThread tid, envelope *e) {}
@@ -205,9 +207,11 @@ public:
     void traceEnd();
 
     /*Calls for tracing function begins and ends*/
-    inline void regFunc(char *name){ ALLDO(regFunc(name)); }
+    inline int regFunc(char *name){ ALLDO(regFunc(name)); }
     inline void beginFunc(char *name,char *file,int line){ ALLDO(beginFunc(name,file,line)); };
+    inline void beginFunc(int idx,char *file,int line){ ALLDO(beginFunc(idx,file,line)); };
     inline void endFunc(char *name){ ALLDO(endFunc(name)); }
+    inline void endFunc(int idx){ ALLDO(endFunc(idx)); }
 
     /* calls for thread listener registration for each trace module */
     inline void traceAddThreadListeners(CthThread tid, envelope *e) {
index 3517011128ab9397c7a54094d231d22cd5f55b95..2929b6952f59e20daed95d00998cec63acd78ee3 100644 (file)
@@ -16,6 +16,15 @@ static void checkInit(void) {
         CpvAccess(a)=0;
 }
 
+static char * FortrantoCString(char *x,int len){
+       char *newstr = new char[len + 1];
+  _MEMCHECK(newstr);
+  strncpy(newstr, x, len);
+  newstr[len] = 0;
+       return newstr;
+}
+
+
 FDECL {
 
 #define ftracebegin              FTN_NAME(FTRACEBEGIN, ftracebegin)
@@ -24,6 +33,9 @@ FDECL {
 #define ftraceuserbracketevent   FTN_NAME(FTRACEUSERBRACKETEVENT, ftraceuserbracketevent)
 #define ftraceUserEvent         FTN_NAME(FTRACEUSEREVENT, ftraceuserevent)
 #define ftraceFlushLog          FTN_NAME(FTRACEFLUSHLOG, ftraceflushlog)
+#define ftraceRegisterFunc      FTN_NAME(FTRACEREGISTERFUNC,ftraceregisterfunc) 
+#define ftraceBeginFunc                 FTN_NAME(FTRACEBEGINFUNC,ftracebeginfunc)
+#define ftraceEndFunc           FTN_NAME(FTRACEENDFUNC,ftraceendfunc)
 
 void ftracebegin()
 {
@@ -75,5 +87,20 @@ void ftraceFlushLog()
   traceFlushLog();
 }
 
+void ftraceRegisterFunc(char *name,int *outIdx,int lenName){
+       char *newstr = FortrantoCString(name,lenName);
+       *outIdx = registerFunction(newstr);
+       delete [] newstr;
+}
+
+void ftraceBeginFunc(int idx){
+       beginFuncIndexProj(idx,"FORTRAN",0);
+}
+
+void ftraceEndFunc(int idx){
+       endFuncIndexProj(idx);
+}
+
+
 }  // FDECL
 
index 712db06e1c1d86141b65606ece56686f5bf4656b..ec01bc89328e2941efef8906559efd938caa4d2e 100644 (file)
         end subroutine
         subroutine ftraceFlushLog()
         end subroutine
+        subroutine ftraceRegisterFunc(str, outidx)
+          character(*), intent(in) :: str
+          integer, intent(in) :: outidx
+        end subroutine
+        subroutine ftraceBeginFunc(idx)
+          integer, intent(in) :: idx
+        end subroutine
+        subroutine ftraceEndFunc(idx)
+          integer, intent(in) :: idx
+        end subroutine
       end interface
       end module
 
index c7ca0806823c28120df4bd24650d9b5c26c5ac5a..64647f399c827386a75a32d886d4014b9f007e2d 100644 (file)
@@ -30,6 +30,11 @@ int  traceRegisterUserEvent(const char*, int e
 =-1
 #endif
 );
+
+int registerFunction(char*);
+void beginFuncIndexProj(int, char*, int);
+void endFuncIndexProj(int);
+
 void traceClose(void);
 void traceCharmClose(void);          /* close trace in ck */
 void traceBegin(void);
index 141a44e0b4a6df108cc5499152e8de73f7b24bd9..f0f335f58abacdbeeda7be5688cf25450ae2b3bb 100644 (file)
 #ifdef __cplusplus
 extern "C" {
 #endif
-
+  
 /* user's thread start routine */
 void armciStart(int argc, char **argv);
-
+  
 /* redefine global variables used by armci */
 #define armci_me TCHARM_Element()
 #define armci_master 0
@@ -34,97 +34,170 @@ typedef struct {
   int bytes;
 } armci_giov_t;
 
+typedef struct {
+  int data[4];
+  double dummy;
+} armci_hdl_t;
+
 /* virtual processor aggregated shared memory API */
 
 /* basic copy operations */
+/* ********************* */
+
 void ARMCI_Copy(void *src, void *dst, int n);
 int ARMCI_Put(void *src, void* dst, int bytes, int proc);
+int ARMCI_NbPut(void *src, void* dst, int bytes, int proc, 
+               armci_hdl_t *handle);
 int ARMCI_Put_flag(void *src, void* dst,int bytes,int *f,int v,int proc);
 int ARMCI_Get(void *src, void* dst, int bytes, int proc);
-
+int ARMCI_NbGet(void *src, void* dst, int bytes, int proc, 
+               armci_hdl_t *handle);
+  
 /* strided copy operations */
-int ARMCI_PutS(void *src_ptr,        /* ptr to 1st segment at source */
-                    int src_stride_arr[], /* array of strides at source  */
-                    void* dst_ptr,        /* ptr to 1st segment at dest */
-                    int dst_stride_arr[], /* array of strides at destination */
-                    int count[],          /* number of units at each stride  */
-                                          /* level count[0]=bytes  */
-                    int stride_levels,    /* number of stride levels */
-                    int proc              /* remote process(or) ID  */
-                    );
-int ARMCI_PutS_flag(void *src_ptr,        /* ptr to 1st segment at source */
-                         int src_stride_arr[], /* array of strides at source */
-                         void* dst_ptr,        /* ptr to 1st segment at dest */
-                         int dst_stride_arr[], /* array of strides at dest */
-                         int count[],          /* num segments at each stride */
-                                               /* levels: count[0]=bytes */
-                         int stride_levels,    /* number of stride levels */
-                         int *flag,            /* pointer to remote flag */
-                         int val,              /* value to set flag upon  */
-                                               /* completion of data transfer */
-                         int proc              /* remote process(or) ID */
-                         );
+/* *********************** */
+int ARMCI_PutS(
+              void *src_ptr,        /* ptr to 1st segment at source */
+              int src_stride_arr[], /* array of strides at source  */
+              void* dst_ptr,        /* ptr to 1st segment at dest */
+              int dst_stride_arr[], /* array of strides at destination */
+              int count[],          /* number of units at each stride  */
+                                     /* level count[0]=bytes  */
+              int stride_levels,    /* number of stride levels */
+              int proc,             /* remote process(or) ID  */
+              armci_hdl_t *handle   /* pointer to descriptor associated */
+                                    /* with a particular non-blocking */
+                                    /* transfer. Passing NULL value */
+                                    /* makes this function do an */
+                                     /* implicit handle non-blocking */
+                                     /* transfer */
+              );
+
+int ARMCI_PutS_flag(
+                   void *src_ptr,        /* ptr to 1st segment at source */
+                   int src_stride_arr[], /* array of strides at source */
+                   void* dst_ptr,        /* ptr to 1st segment at dest */
+                   int dst_stride_arr[], /* array of strides at dest */
+                   int count[],          /* num segments at each stride */
+                                         /* levels: count[0]=bytes */
+                   int stride_levels,    /* number of stride levels */
+                   int *flag,            /* pointer to remote flag */
+                   int val,              /* value to set flag upon  */
+                                         /* completion of data transfer */
+                   int proc              /* remote process(or) ID */
+                   );
+
+int ARMCI_NbPutS(
+                void *src_ptr,        /* ptr to 1st segment at source */
+                int src_stride_arr[], /* array of strides at source  */
+                void* dst_ptr,        /* ptr to 1st segment at dest */
+                int dst_stride_arr[], /* array of strides at destination */
+                int count[],          /* number of units at each stride  */
+                                      /* level count[0]=bytes  */
+                int stride_levels,    /* number of stride levels */
+                int proc,             /* remote process(or) ID  */
+                armci_hdl_t *handle   /* pointer to descriptor associated */
+                                      /* with a particular non-blocking */
+                                       /* transfer. Passing NULL value */
+                                      /* makes this function do an */
+                                       /* implicit handle non-blocking */
+                                       /* transfer */
+                );
+
 int ARMCI_AccS(
-                    int  optype,          /* operation */
-                    void *scale,          /* scale factor x += scale*y */
-                    void *src_ptr,        /* pointer to 1st segment at source */
-                    int src_stride_arr[], /* array of strides at source */
-                    void* dst_ptr,        /* ptr to 1st segment at destination */
-                    int dst_stride_arr[], /* array of strides at destination */
-                    int count[],          /* number of units at each stride  */
-                                          /* level count[0]=bytes */
-                    int stride_levels,    /* number of stride levels */
-                    int proc              /* remote process(or) ID */
-                    );
-int ARMCI_GetS(void *src_ptr,        /* pointer to 1st segment at source */
-                    int src_stride_arr[], /* array of strides at source */
-                    void* dst_ptr,        /* ptr to 1st segment at destination */
-                    int dst_stride_arr[], /* array of strides at destination */
-                    int count[],          /* number of units at each stride  */
-                                          /* level count[0]=bytes */
-                    int stride_levels,    /* number of stride levels */
-                    int proc              /* remote process(or) ID */
-                    );
+              int  optype,          /* operation */
+              void *scale,          /* scale factor x += scale*y */
+              void *src_ptr,        /* pointer to 1st segment at source */
+              int src_stride_arr[], /* array of strides at source */
+              void* dst_ptr,        /* ptr to 1st segment at destination */
+              int dst_stride_arr[], /* array of strides at destination */
+              int count[],          /* number of units at each stride  */
+                                    /* level count[0]=bytes */
+              int stride_levels,    /* number of stride levels */
+              int proc              /* remote process(or) ID */
+              );
+
+int ARMCI_GetS(
+              void *src_ptr,        /* pointer to 1st segment at source */
+              int src_stride_arr[], /* array of strides at source */
+              void* dst_ptr,        /* ptr to 1st segment at destination */
+              int dst_stride_arr[], /* array of strides at destination */
+              int count[],          /* number of units at each stride  */
+                                    /* level count[0]=bytes */
+              int stride_levels,    /* number of stride levels */
+              int proc              /* remote process(or) ID */
+              );
+
+/* Functions for Non-blocking support */
+/* ********************************** */
+
+int ARMCI_Wait(armci_hdl_t *handle);
+int ARMCI_Test(armci_hdl_t *handle);
 
 /* vector IO-type copy operations */
-int ARMCI_GetV(armci_giov_t darr[], /* descriptor array */
-                    int len,             /* length of descriptor array */
-                    int proc             /* remote process(or) ID */
-                    );
-int ARMCI_PutV(armci_giov_t darr[], /* descriptor array */
-                    int len,             /* length of descriptor array */
-                    int proc             /* remote process(or) ID */
-                    );
-int ARMCI_AccV(int op,              /* operation code */
-                    void *scale,         /* scaling factor for accumulate */
-                    armci_giov_t darr[], /* descriptor array */
-                    int len,             /* length of descriptor array */
-                    int proc             /* remote process(or) ID */
-                    );
+/* ****************************** */
+
+int ARMCI_GetV(
+              armci_giov_t darr[], /* descriptor array */
+              int len,             /* length of descriptor array */
+              int proc             /* remote process(or) ID */
+              );
+
+int ARMCI_PutV(
+              armci_giov_t darr[], /* descriptor array */
+              int len,             /* length of descriptor array */
+              int proc             /* remote process(or) ID */
+              );
+
+int ARMCI_AccV(
+              int op,              /* operation code */
+              void *scale,         /* scaling factor for accumulate */
+              armci_giov_t darr[], /* descriptor array */
+              int len,             /* length of descriptor array */
+              int proc             /* remote process(or) ID */
+              );
 
 /* fence operations (for synchronizing with put operations) */
+/* ******************************************************** */
+
 int ARMCI_Fence(int proc);
 int ARMCI_AllFence(void);
+int ARMCI_Barrier();
 
 /* memory operations */
+/* ***************** */
+
 int ARMCI_Malloc(void* ptr_arr[], int bytes);
 int ARMCI_Free(void *ptr);
+void *ARMCI_Malloc_local(int bytes);
+int ARMCI_Free_local(void *ptr);
  
 /* misc operations */
-int  ARMCI_Rmw(int op, int *ploc, int *prem, int extra, int proc);
+/* *************** */
+
+int ARMCI_Rmw(int op, int *ploc, int *prem, int extra, int proc);
 
 /* system operations */
+/* ***************** */
+
 int ARMCI_Init(void);
 int ARMCI_Finalize(void);
 void ARMCI_Error(char *msg, int code);
 void ARMCI_Cleanup(void);
 
 /* mutex operations */
+/* **************** */
+
 int ARMCI_Create_mutexes(int num);
 int ARMCI_Destroy_mutexes(void);
 void ARMCI_Lock(int mutex, int proc);
 void ARMCI_Unlock(int mutex, int proc);
 
+/* notify operations */
+/* ***************** */
+
+int armci_notify(int proc);
+int armci_notify_wait(int proc, int *pval);
+
 /* this is highly platform specific and I don't think it needs to be
    included. */
 /* extern void ARMCI_Set_shm_limit(unsigned long shmemlimit); */