spaced out just now and tried to check in trace-summary instead.
authorChee Wai Lee <cheelee@illinois.edu>
Sat, 13 Sep 2008 20:41:01 +0000 (20:41 +0000)
committerChee Wai Lee <cheelee@illinois.edu>
Sat, 13 Sep 2008 20:41:01 +0000 (20:41 +0000)
src/ck-perf/trace-simple.C [new file with mode: 0644]
src/ck-perf/trace-simple.ci [new file with mode: 0644]
src/ck-perf/trace-simple.h [new file with mode: 0644]
src/ck-perf/trace-simpleBOC.h [new file with mode: 0644]

diff --git a/src/ck-perf/trace-simple.C b/src/ck-perf/trace-simple.C
new file mode 100644 (file)
index 0000000..2d2ba2f
--- /dev/null
@@ -0,0 +1,155 @@
+#include "charm++.h"
+#include "trace-simple.h"
+#include "trace-simpleBOC.h"
+
+// Charm++ "processor"(user thread)-private global variable
+CkpvStaticDeclare(TraceSimple*, _trace);
+
+// This global variable is required for any post-execution 
+// parallel analysis or activities the trace module might wish to perform.
+CkGroupID traceSimpleGID;
+
+/**
+  For each TraceFoo module, _createTraceFoo() must be defined.
+  This function is called in _createTraces() generated in moduleInit.C
+*/
+void _createTracesimple(char **argv)
+{
+  CkpvInitialize(TraceSimple*, _trace);
+  CkpvAccess(_trace) = new TraceSimple(argv);
+  CkpvAccess(_traces)->addTrace(CkpvAccess(_trace));
+}
+
+TraceSimple::TraceSimple(char **argv)
+{
+  if (CkpvAccess(traceOnPe) == 0) return;
+
+  // Process runtime arguments intended for the module
+  CmiGetArgIntDesc(argv,"+SimplePar0", &par0, "Fake integer parameter 0");
+  CmiGetArgDoubleDesc(argv,"+SimplePar1", &par1, "Fake double parameter 1");
+}
+
+void TraceSimple::userEvent(int eventID) 
+{
+  CkPrintf("[%d] User Point Event id %d encountered\n", CkMyPe(), eventID);
+}
+
+void TraceSimple::userBracketEvent(int eventID, double bt, double et) {
+  CkPrintf("[%d] User Bracket Event id %d encountered\n", CkMyPe(), eventID);
+}
+
+void TraceSimple::creation(envelope *, int epIdx, int num) {
+  CkPrintf("[%d] Point-to-Point Message for Entry Method id %d sent\n",
+          CkMyPe(), epIdx);
+}
+
+void TraceSimple::creationMulticast(envelope *, int epIdx, int num, 
+                                   int *pelist) {
+  CkPrintf("[%d] Multicast Message for Entry Method id %d sent to %d pes\n",
+          CkMyPe(), epIdx, num);
+}
+
+void TraceSimple::creationDone(int num) {
+  CkPrintf("[%d] Last initiated send completes\n", CkMyPe());
+}
+  
+void TraceSimple::messageRecv(char *env, int pe) {
+  CkPrintf("[%d] Message from pe %d received by scheduler\n", 
+          CkMyPe(), pe);
+}
+  
+void TraceSimple::beginExecute(CmiObjId *tid)
+{
+  // CmiObjId is a 4-integer tuple uniquely identifying a migratable
+  //   Charm++ object. Note that there are other non-migratable Charm++
+  //   objects that CmiObjId will not identify.
+  CkPrintf("[%d] Entry Method invoked using object id\n", CkMyPe());
+}
+
+void TraceSimple::beginExecute(envelope *e)
+{
+  // no message means thread execution
+  if (e == NULL) {
+    CkPrintf("[%d] Entry Method invoked via thread id %d\n", CkMyPe(),
+            _threadEP);
+    // Below is what is found in trace-summary.
+    // beginExecute(-1,-1,_threadEP,-1);
+  } else {
+    CkPrintf("[%d] Entry Method %d invoked via message envelope\n", 
+            CkMyPe(), e->getEpIdx());
+    // Below is what is found in trace-summary.
+    // beginExecute(-1,-1,e->getEpIdx(),-1);
+  }  
+}
+
+void TraceSimple::beginExecute(int event,int msgType,int ep,int srcPe, 
+                              int mlen, CmiObjId *idx)
+{
+  CkPrintf("[%d] Entry Method %d invoked by parameters\n", CkMyPe(),
+          ep);
+}
+
+void TraceSimple::endExecute(void)
+{
+  CkPrintf("[%d] Previously executing Entry Method completes\n", CkMyPe());
+}
+
+void TraceSimple::beginIdle(double curWallTime) {
+  CkPrintf("[%d] Scheduler has no useful user-work\n", CkMyPe());
+}
+
+void TraceSimple::endIdle(double curWallTime) {
+  CkPrintf("[%d] Scheduler now has useful user-work\n", CkMyPe());
+}
+  
+void TraceSimple::beginComputation(void)
+{
+  CkPrintf("[%d] Computation Begins\n", CkMyPe());
+  // Code Below shows what trace-summary would do.
+  // initialze arrays because now the number of entries is known.
+  // _logPool->initMem();
+}
+
+void TraceSimple::endComputation(void)
+{
+  CkPrintf("[%d] Computation Ends\n", CkMyPe());
+}
+
+void TraceSimple::malloc(void *where, int size, void **stack, int stackSize)
+{
+  CkPrintf("[%d] Memory allocation of size %d occurred\n", CkMyPe(), size);
+}
+
+void TraceSimple::free(void *where, int size) {
+  CkPrintf("[%d] %d-byte Memory block freed\n", CkMyPe(), size);
+}
+
+void TraceSimple::traceClose(void)
+{
+  CkpvAccess(_trace)->endComputation();
+  // remove myself from traceArray so that no tracing will be called.
+  CkpvAccess(_traces)->removeTrace(this);
+}
+
+extern "C" void traceSimpleExitFunction() {
+  // The exit function of any Charm++ module must call CkExit() or
+  // the entire exit process will hang if multiple modules are linked.
+  // FIXME: This is NOT a feature. Something needs to be done about this.
+  CkExit();
+}
+
+// Initialization of the parallel trace module.
+void initTraceSimpleBOC() {
+#ifdef __BLUEGENE__
+  if (BgNodeRank()==0) {
+#else
+    if (CkMyRank() == 0) {
+#endif
+      registerExitFn(traceSimpleExitFunction);
+    }
+}
+
+#include "TraceSimple.def.h"
+
+
+/*@}*/
diff --git a/src/ck-perf/trace-simple.ci b/src/ck-perf/trace-simple.ci
new file mode 100644 (file)
index 0000000..c4193ce
--- /dev/null
@@ -0,0 +1,15 @@
+module TraceSimple {
+
+  mainchare TraceSimpleInit {
+    entry TraceSimpleInit(CkArgMsg *m);
+  };
+
+  initnode void initTraceSimpleBOC();
+  readonly CkGroupID traceSimpleGID;
+
+  group [migratable] TraceSimpleBOC {
+    entry TraceSimpleBOC(void);
+  };
+
+};
+
diff --git a/src/ck-perf/trace-simple.h b/src/ck-perf/trace-simple.h
new file mode 100644 (file)
index 0000000..ae7dc70
--- /dev/null
@@ -0,0 +1,70 @@
+#ifndef _VERBOSE_H
+#define _VERBOSE_H
+
+#include <stdio.h>
+#include <errno.h>
+
+#include "trace.h"
+#include "envelope.h"
+#include "register.h"
+#include "trace-common.h"
+
+/**
+ *  TraceSimple is a template for an instrumentation module making use of
+ *    the tracing framework hooks provided in Charm++.
+ *
+ *  Only the more common hooks are listened to in this module.
+ */
+class TraceSimple : public Trace {
+ public:
+  int par0;
+  double par1;
+ public:
+  TraceSimple(char **argv);
+  
+  // a user event has just occured
+  void userEvent(int eventID);
+  // a pair of begin/end user event has just occured
+  void userBracketEvent(int eventID, double bt, double et);
+  
+  // "creation" of message(s) - message Sends
+  void creation(envelope *, int epIdx, int num=1);
+  void creationMulticast(envelope *, int epIdx, int num=1, int *pelist=NULL);
+  void creationDone(int num=1);
+  
+  void messageRecv(char *env, int pe);
+  
+  // **************************************************************
+  // begin/end execution of a Charm++ entry point
+  // NOTE: begin/endPack and begin/endUnpack can be called in between
+  //       a beginExecute and its corresponding endExecute.
+  void beginExecute(envelope *);
+  void beginExecute(CmiObjId *tid);
+  void beginExecute(
+                   int event,   // event type defined in trace-common.h
+                   int msgType, // message type
+                   int ep,      // Charm++ entry point id
+                   int srcPe,   // Which PE originated the call
+                   int ml,      // message size
+                   CmiObjId* idx);    // index
+  void endExecute(void);
+  
+  // begin/end idle time for this pe
+  void beginIdle(double curWallTime);
+  void endIdle(double curWallTime);
+  
+  // begin/end of execution
+  void beginComputation(void);
+  void endComputation(void);
+  
+  /* Memory tracing */
+  void malloc(void *where, int size, void **stack, int stackSize);
+  void free(void *where, int size);
+  
+  // do any clean-up necessary for tracing
+  void traceClose();
+};
+
+#endif
+
+/*@}*/
diff --git a/src/ck-perf/trace-simpleBOC.h b/src/ck-perf/trace-simpleBOC.h
new file mode 100644 (file)
index 0000000..b413b81
--- /dev/null
@@ -0,0 +1,31 @@
+#include "TraceSimple.decl.h"
+
+extern CkGroupID traceSimpleGID;
+
+// We typically declare parallel object classes here for the purposes of
+// performing parallel operations for the trace module after the main
+// application has completed execution (and calls CkExit()).
+//
+// TraceSimpleInit is an initialization class.
+//
+// TraceSimpleBOC is a one-per-processor object (defined in the .ci file as
+//    a "group" instead of a "chare") which hosts the methods for the
+//    parallel operations. In this case, there are no methods defined.
+//    Otherwise, one may write any Charm++ code here.
+
+class TraceSimpleInit : public Chare {
+  public:
+  TraceSimpleInit(CkArgMsg*) {
+    traceSimpleGID = CProxy_TraceSimpleBOC::ckNew();
+    CProxy_TraceSimpleBOC simpleProxy(traceSimpleGID);
+  }
+  TraceSimpleInit(CkMigrateMessage *m):Chare(m) {}
+};
+
+class TraceSimpleBOC : public CBase_TraceSimpleBOC {
+public:
+  TraceSimpleBOC(void) {};
+  TraceSimpleBOC(CkMigrateMessage *m) {};
+};
+
+