Thread listener codes added for Load Balancers and Trace modules in
authorChee Wai Lee <cheelee@illinois.edu>
Mon, 27 Sep 2004 22:26:16 +0000 (22:26 +0000)
committerChee Wai Lee <cheelee@illinois.edu>
Mon, 27 Sep 2004 22:26:16 +0000 (22:26 +0000)
projections.

13 files changed:
doc/projections/manual.tex
src/ck-core/charm++.h
src/ck-core/ck.C
src/ck-core/cklocation.C
src/ck-core/cklocation.h
src/ck-core/ckreduction.h
src/ck-perf/trace-common.C
src/ck-perf/trace-projections.C
src/ck-perf/trace-projections.h
src/ck-perf/trace.h
src/conv-core/converse.h
src/conv-core/threads.c
src/xlat-i/xi-symbol.C

index af4ee2dadbae24a0e0fbb9e525c97c7fbf25245c..01d43aad9a826db9dc3fc61ef3e46b3c8ea83852 100644 (file)
@@ -291,9 +291,9 @@ The following is a list of runtime options available under this tracemode:
    Make sure the JDK commands ``java'', ``javac'' and ``jar''
    are in your path
 \item[2)]
-   Type ``make''
+   From {\tt PROJECTIONS\_LOCATION/}, type ``make''
 \item[3)]
-   The following files will be placed in `bin':
+   The following files are placed in `bin':
 
       {\tt projections}           : Starts projections, for UNIX machines
 
@@ -310,40 +310,22 @@ From any location, type
 where {\tt PROJECTIONS\_LOCATION} is the path to the main projections
 directory.
 
-Also, if you attach a .sts file after the command line, \projections{} will
-open the file and initialize immediately. This trick saves time selecting file
-from the GUI filechooser.
+Supplying the optional {\tt NAME.sts} file in the command line will
+cause projections to load data from the file at startup. This shortcut
+saves time selecting a set of data from the GUI's file dialog.
 
 \subsection{Using \projections{}}
-When \projections{} starts, you will see the main window with a title and
-six buttons:
 
 \begin{figure}[htb]
 \center
-\epsfig{figure=fig/mainwindow.eps,height=3in}
+\epsfig{figure=fig/front-with-summary.eps,height=3in}
 \caption{\projections{} main window}
 \label{mainwindow}
 \end{figure}
 
-1. Open File
+When \projections{} is started, it will display a main window as shown in figure \ref{mainwindow}. If summary (.sum) files are available in the set of data, a low-resolution utilization graph will be displayed as shown. Otherwise, the main window shows a blank screen.
 
-2. Graphs
 
-3. Timelines
-
-4. Usage Profile
-
-5. Animations
-
-6. View Log Files
-
-7. Histograms
-
-8. Overview
-
-Clicking on any of the buttons will bring up the appropriate next window, as
-described in the following sections.  Initially, only the Open File button
-will be active.
 
 \subsubsection{Open File}
 
index dbfd27fa278de355b7b9168ad91248b37795fce9..53b71dd4434d6fbf03c627716679da9c1b36dadc 100644 (file)
@@ -367,7 +367,7 @@ class Chare {
     virtual char *ckDebugChareName(void);
     virtual void ckDebugPup(PUP::er &p);
     /// Called when a [threaded] charm entry method is created:
-    virtual void CkAddThreadListeners(CthThread tid);
+    virtual void CkAddThreadListeners(CthThread tid, void *msg);
 };
 
 //Superclass of all Groups that cannot participate in reductions.
@@ -393,6 +393,7 @@ class IrrGroup : public Chare {
     virtual CmiBool isReductionMgr(void){ return CmiFalse; }
     static int isIrreducible(){ return 1;}
     virtual void flushStates() {}
+    virtual void CkAddThreadListeners(CthThread tid, void *msg);
 };
 
 #define CBASE_PROXY_MEMBERS(CProxy_Derived) \
index 4ee519ba77c59e407701e8e3c6c02c41c0952e32..2334c21eede2f8b9621839496a9a8beda94fe35f 100644 (file)
@@ -67,8 +67,9 @@ void Chare::ckDebugPup(PUP::er &p) {
 }
 
 /// This method is called before starting a [threaded] entry method.
-void Chare::CkAddThreadListeners(CthThread th) {
-  /* FIXME: add tracing here */
+void Chare::CkAddThreadListeners(CthThread th, void *msg) {
+  CthSetThreadID(th, thishandle.onPE, (int)thishandle.objPtr, 0);
+  traceAddThreadListeners(th, UsrToEnv(msg));
 }
 
 
@@ -103,6 +104,15 @@ void IrrGroup::ckJustMigrated(void)
 {
 }
 
+void IrrGroup::CkAddThreadListeners(CthThread tid, void *msg) {
+  /* FIXME: **CW** not entirely sure what we should do here yet */
+}
+
+void Group::CkAddThreadListeners(CthThread th, void *msg) {
+  Chare::CkAddThreadListeners(th, msg);
+  CthSetThreadID(th, thisgroup.idx, 0, 0);
+}
+
 void Group::pup(PUP::er &p)
 {
   CkReductionMgr::pup(p);
index 9cdedc9291009f8a2ee473867f6a9da5ae4380ff..3970a533a7a01112a8faa50a4ad7bb23d291a22f 100644 (file)
@@ -662,6 +662,45 @@ void CkMigratable::setMigratable(int migratable)
 {
        myRec->setMigratable(migratable);
 }
+
+struct CkArrayThreadListener {
+        struct CthThreadListener base;
+        CkMigratable *mig;
+};
+
+extern "C"
+void CkArrayThreadListener_suspend(struct CthThreadListener *l)
+{
+        CkArrayThreadListener *a=(CkArrayThreadListener *)l;
+        a->mig->ckStopTiming();
+}
+
+extern "C"
+void CkArrayThreadListener_resume(struct CthThreadListener *l)
+{
+        CkArrayThreadListener *a=(CkArrayThreadListener *)l;
+        a->mig->ckStartTiming();
+}
+
+extern "C"
+void CkArrayThreadListener_free(struct CthThreadListener *l)
+{
+        CkArrayThreadListener *a=(CkArrayThreadListener *)l;
+        delete a;
+}
+
+void CkMigratable::CkAddThreadListeners(CthThread tid, void *msg)
+{
+        Chare::CkAddThreadListeners(tid, msg);
+        CthSetThreadID(tid, thisIndexMax.data()[0], thisIndexMax.data()[1], 
+                      thisIndexMax.data()[2]);
+       CkArrayThreadListener *a=new CkArrayThreadListener;
+       a->base.suspend=CkArrayThreadListener_suspend;
+       a->base.resume=CkArrayThreadListener_resume;
+       a->base.free=CkArrayThreadListener_free;
+       a->mig=this;
+       CthAddListener(tid,(struct CthThreadListener *)a);
+}
 #endif
 
 
index b71d989961017f6df671888c6fe731af2e9daaee..2a7471174038eb0d18e101c30269c438385784ff 100644 (file)
@@ -250,6 +250,7 @@ public:
   CkMigratable(CkMigrateMessage *m);
   virtual ~CkMigratable();
   virtual void pup(PUP::er &p);
+  virtual void CkAddThreadListeners(CthThread tid, void *msg);
 
   inline int ckGetChareType(void) const {return thisChareType;}
   const CkArrayIndex &ckGetArrayIndex(void) const {return myRec->getIndex();}
index 1dee2ae3785cfff6621dad7de8b7ae1c8a713035..73d63d0232e0a2384f8714c9ddec2feeb79f5396 100644 (file)
@@ -318,6 +318,7 @@ class Group : public CkReductionMgr
                CkReductionMgr::flushStates();
                reductionInfo.redNo = 0;
        }
+       virtual void CkAddThreadListeners(CthThread tid, void *msg);
 
        CK_REDUCTION_CONTRIBUTE_METHODS_DECL
 };
index 73b719a7ab21eff59ea34adc12f0999646296ed6..2898fe0365c0dde02cea7f0915b04b5ef30a8d85 100644 (file)
@@ -147,13 +147,12 @@ extern void traceWriteSTS(FILE *stsfp,int nUserEvents) {
     fprintf(stsfp, "MESSAGE %d %d\n", i, _msgTable[i]->size);
 }
 
-
 extern "C"
 void traceCommonBeginIdle(void *proj,double curWallTime)
 {
   ((TraceArray *)proj)->beginIdle(curWallTime);
 }
-
 extern "C"
 void traceCommonEndIdle(void *proj,double curWallTime)
 {
@@ -341,6 +340,14 @@ void traceCharmClose(void)
 #endif
 }
 
+/* **CW** Support for thread listeners. This makes a call to each
+   trace module which must support the call.
+*/
+extern "C"
+void traceAddThreadListeners(CthThread tid, envelope *e) {
+  CkpvAccess(_traces)->traceAddThreadListeners(tid, e);
+}
+
 #if 0
 // helper functions
 int CkIsCharmMessage(char *msg)
index 39e9ce7c2a7921416c90fce4e3d0441ea0c97eb2..6528fb6ff82cffc2a3fc51e4fe7fcddfe79176ca 100644 (file)
@@ -67,6 +67,67 @@ int numPAPIEvents = 2;
 int papiEvents[] = {PAPI_TOT_INS, PAPI_L1_DCM};
 char *papiEventNames[] = {"PAPI_TOT_INS", "PAPI_L1_DCM"};
 #endif
+/* ****** CW TEMPORARY LOCATION ***** Support for thread listeners */
+
+struct TraceThreadListener {
+  struct CthThreadListener base;
+  int event;
+  int msgType;
+  int ep;
+  int srcPe;
+  int ml;
+  CmiObjId idx;
+};
+
+
+extern "C"
+void traceThreadListener_suspend(struct CthThreadListener *l)
+{
+  TraceThreadListener *a=(TraceThreadListener *)l;
+  /* here, we activate the appropriate trace codes for the appropriate
+     registered modules */
+  traceSuspend();
+}
+
+extern "C"
+void traceThreadListener_resume(struct CthThreadListener *l) 
+{
+  TraceThreadListener *a=(TraceThreadListener *)l;
+  /* here, we activate the appropriate trace codes for the appropriate
+     registered modules */
+  _TRACE_BEGIN_EXECUTE_DETAILED(a->event,a->msgType,a->ep,a->srcPe,a->ml,
+                               CthGetThreadID(a->base.thread));
+  a->event=-1;
+  a->srcPe=CkMyPe(); /* potential lie to migrated threads */
+  a->ml=0;
+}
+
+extern "C"
+void traceThreadListener_free(struct CthThreadListener *l) 
+{
+  TraceThreadListener *a=(TraceThreadListener *)l;
+  delete a;
+}
+
+void TraceProjections::traceAddThreadListeners(CthThread tid, envelope *e)
+{
+#ifndef CMK_OPTIMIZE
+  /* strip essential information from the envelope */
+  TraceThreadListener *a= new TraceThreadListener;
+  
+  a->base.suspend=traceThreadListener_suspend;
+  a->base.resume=traceThreadListener_resume;
+  a->base.free=traceThreadListener_free;
+  a->event=e->getEvent();
+  a->msgType=e->getMsgtype();
+  a->ep=e->getEpIdx();
+  a->srcPe=e->getSrcPe();
+  a->ml=e->getTotalsize();
+
+  CthAddListener(tid, (CthThreadListener *)a);
+#endif
+}
 
 void LogPool::openLog(const char *mode)
 {
@@ -358,6 +419,8 @@ void LogPool::writeSts(void)
   // for whining compilers
   int i;
   char name[30];
+  // generate an automatic unique ID for each log
+  fprintf(stsfp, "PROJECTIONS_ID %s\n", "");
   fprintf(stsfp, "VERSION %s\n", PROJECTION_VERSION);
 #if CMK_HAS_COUNTER_PAPI
   fprintf(stsfp, "TOTAL_PAPI_EVENTS %d\n", numPAPIEvents);
@@ -374,21 +437,20 @@ void LogPool::writeSts(void)
 }
 
 void LogPool::writeSts(TraceProjections *traceProj){
-       writeSts();
-       if(traceProj != NULL){
-               CkHashtableIterator  *funcIter = traceProj->getfuncIterator();          
-               funcIter->seekStart();
-               int numFuncs = traceProj->getFuncNumber();
-               fprintf(stsfp,"TOTAL FUNCTIONS %d \n",numFuncs);
-               while(funcIter->hasNext()){
-                       StrKey *key;
-                       int *obj = (int *)funcIter->next((void **)&key);
-                       fprintf(stsfp,"FUNCTION %s %d \n",key->getStr(),*obj);
-               }
-       }
-       fprintf(stsfp, "END\n");
-       fclose(stsfp);
-       
+  writeSts();
+  if (traceProj != NULL) {
+    CkHashtableIterator  *funcIter = traceProj->getfuncIterator();
+    funcIter->seekStart();
+    int numFuncs = traceProj->getFuncNumber();
+    fprintf(stsfp,"TOTAL_FUNCTIONS %d \n",numFuncs);
+    while(funcIter->hasNext()) {
+      StrKey *key;
+      int *obj = (int *)funcIter->next((void **)&key);
+      fprintf(stsfp,"FUNCTION %d %s \n",*obj,key->getStr());
+    }
+  }
+  fprintf(stsfp, "END\n");
+  fclose(stsfp);
 }
 
 
index 430e5c513b75af0434ce3c618bf1e33499000fd2..b4667ee8ec0a95e0cef72a73045175c2c896bd47 100644 (file)
@@ -275,6 +275,9 @@ class TraceProjections : public Trace {
     void regFunc(char *name);
     void beginFunc(char *name,char *file,int line);
     void endFunc(char *name);
+
+    /* for overiding basic thread listener support in Trace class */
+    virtual void traceAddThreadListeners(CthThread tid, envelope *e);
 };
 
 using namespace PUP;
index ddec972b3946c0c2a793e8827f101992be7dcf5e..c915df0432d2dc82d2f7f7cfcdcef291023fd4fb 100644 (file)
@@ -25,6 +25,9 @@ extern double CmiTraceTimer();
 
 extern int _dummyMsg, _dummyChare, _dummyEP;
 
+/* CW Support for Thread Listener interface */
+extern "C" void traceAddThreadListeners(CthThread tid, envelope *e);
+
 // trace_in_charm means only do trace for Charm++ level
 // traceOnPe controls if charm pe will generate trace logs
 #if CMK_TRACE_IN_CHARM
@@ -120,6 +123,9 @@ class Trace {
     virtual void beginFunc(char *name,char *file,int line){}
     virtual void endFunc(char *name){}
 
+    /* for implementing thread listeners */
+    virtual void traceAddThreadListeners(CthThread tid, envelope *e) {}
+
     virtual ~Trace() {} /* for whining compilers */
 };
 
@@ -197,10 +203,15 @@ public:
     void traceBegin();
     void traceEnd();
 
-               /*Calls for tracing function begins and ends*/
+    /*Calls for tracing function begins and ends*/
     inline void regFunc(char *name){ ALLDO(regFunc(name)); }
     inline void beginFunc(char *name,char *file,int line){ ALLDO(beginFunc(name,file,line)); };
     inline void endFunc(char *name){ ALLDO(endFunc(name)); }
+
+    /* calls for thread listener registration for each trace module */
+    inline void traceAddThreadListeners(CthThread tid, envelope *e) {
+      ALLDO(traceAddThreadListeners(tid, e));
+    }
 };
 
 CkpvExtern(TraceArray*, _traces);
index 6b50be1e3724278afdb5809d3045b164842d3583..8acab1db0dde59e178d06acfd1b7b81e86238df5 100644 (file)
@@ -1248,6 +1248,10 @@ typedef struct {
 int id[3];
 } CmiObjId;
 
+/* public interface for thread id acquisition */
+CmiObjId *CthGetThreadID(CthThread th);
+void CthSetThreadID(CthThread th, int a, int b, int c);
+
 void CthTraceResume(CthThread t);
 
 #include "conv-cpm.h"
index 0f96134c7ef251b65ed7b0145e7cd8f3abca67e7..df2678111ce06657a1d845983c8eb19a9cd98760 100644 (file)
@@ -262,6 +262,12 @@ void CthSetThreadID(CthThread th, int a, int b, int c)
   B(th)->tid.id[2] = c;
 }
 
+/* possible hack? CW */
+CmiObjId *CthGetThreadID(CthThread th)
+{
+  return &(B(th)->tid);
+}
+
 char *CthGetData(CthThread t) { return B(t)->data; }
 
 /* Ensure this thread has at least enough 
index a2924aebc704db007e414bec91981f01e189527e..1f92abe5b954fff095c806f3d7797aa7edd54f3c 100644 (file)
@@ -2589,7 +2589,8 @@ XStr Entry::callThread(const XStr &procName,int prependEntryName)
   
   str << "  CthThread tid = CthCreate((CthVoidFn)"<<procFull
    <<", new CkThrCallArg(impl_msg,impl_obj), "<<getStackSize()<<");\n";
-  str << "  ((Chare *)impl_obj)->CkAddThreadListeners(tid);\n";
+  str << "  ((Chare *)impl_obj)->CkAddThreadListeners(tid,impl_msg);\n";
+  // str << "  CkpvAccess(_traces)->CkAddThreadListeners(tid);\n";
 #if CMK_BLUEGENE_CHARM
   str << "  BgAttach(tid);\n";
 #endif