adding a new test to commbench
authorNikhil Jain <nikhil@illinois.edu>
Wed, 26 Oct 2011 21:10:42 +0000 (16:10 -0500)
committerNikhil Jain <nikhil@illinois.edu>
Wed, 26 Oct 2011 21:10:42 +0000 (16:10 -0500)
net-linux-x86_64/tests/converse/commbench/memoryAccess.c [new file with mode: 0755]
tests/converse/commbench/Makefile
tests/converse/commbench/commbench.c

diff --git a/net-linux-x86_64/tests/converse/commbench/memoryAccess.c b/net-linux-x86_64/tests/converse/commbench/memoryAccess.c
new file mode 100755 (executable)
index 0000000..5c25e64
--- /dev/null
@@ -0,0 +1,190 @@
+#include <converse.h>
+#include "commbench.h"
+
+#define CLUBMALLOC 10000
+#define RANDMALLOC 100000
+#define RANDOPS 10000
+#define POWER 15
+#define MAXSIZE 16384
+typedef double myType;
+myType value = 10;
+int dist[] = {1,5,9,10};
+
+CpvStaticDeclare(int, memoryIdx);
+
+double memoryTest(){
+  double starttime, endtime;  
+  double extraOverhead;
+  myType **ptrs = NULL;
+  int i,j,k,size;
+  myType sums[200];
+  double times[POWER][4];
+  int sizes[RANDMALLOC];
+  int ops[RANDOPS][3];
+
+  ptrs = (myType **)malloc(CLUBMALLOC*sizeof(myType *));
+  for(i=0; i<CLUBMALLOC; i++) ptrs[i] = 0;
+  starttime = CmiWallTimer();
+  for(i=0; i<CLUBMALLOC; i++) ptrs[i] = (myType *)0xabcd;
+  endtime = CmiWallTimer();
+  extraOverhead = endtime - starttime;
+  
+  size = 1;
+  for(i = 0; i < POWER; i++,size*=2) {
+
+    for(j=0; j<CLUBMALLOC; j++) ptrs[j] = 0;
+    starttime = CmiWallTimer();
+    for(j=0; j<CLUBMALLOC; j++) {
+      ptrs[j] = (myType *)CmiAlloc(size*sizeof(myType));
+    }
+    endtime = CmiWallTimer();
+    times[i][0] = endtime - starttime - extraOverhead;
+    
+    for(j=0; j<CLUBMALLOC; j++) {
+      for(k = 0; k < size; k++) {
+        ptrs[j][k] = value;
+      }
+    }
+
+    starttime = CmiWallTimer();
+    for(j=0; j<CLUBMALLOC; j++) {
+      for(k = 0; k < size; k++) {
+        ptrs[j][k] = value;
+      }
+    }
+    endtime = CmiWallTimer();
+    times[i][1] = endtime - starttime - extraOverhead;
+
+    for(j = 0; j < 200; j++) {
+      sums[j] = 0;
+    }
+
+    starttime = CmiWallTimer();
+    for(j=0; j<CLUBMALLOC; j++) {
+      for(k = 0; k < size; k++) {
+        sums[k%200] += ptrs[j][k];
+      }
+    }
+    endtime = CmiWallTimer();
+    times[i][2] = endtime - starttime - extraOverhead;
+
+    starttime = CmiWallTimer();
+    for(j=0; j<CLUBMALLOC; j++) CmiFree(ptrs[j]);
+    endtime = CmiWallTimer();
+    times[i][3] = endtime - starttime - extraOverhead;
+  }
+
+  if(CmiMyPe()==0){
+    CmiPrintf("Performance number of clubbed malloc-traversal-free\n");
+    CmiPrintf("Size\tIterations\tMalloc\tWrite\tRead\tFree\n");
+    size = 1;
+    for(i = 0; i < POWER; i++,size*=2) {
+      CmiPrintf("%d\t%d\t%E\t%E\t%E\t%E\n",size,CLUBMALLOC,times[i][0],
+               times[i][1],times[i][2],times[i][3]);
+    }
+  }
+
+  free(ptrs);
+  ptrs = (myType **)malloc(RANDMALLOC*sizeof(myType *));
+
+  srand(7187);
+  for(i=0; i<RANDMALLOC; i++) {
+    sizes[i] = rand() % MAXSIZE;
+  }
+
+  for(i=0; i<RANDMALLOC; i++) {
+      ptrs[i] = (myType *)CmiAlloc(sizes[i]*sizeof(myType));
+  }
+
+  for(i=0; i<RANDOPS; i++) {
+    ops[i][0] = rand()%RANDMALLOC;
+    ops[i][1] = rand()%dist[3];
+    if(ops[i][1] < dist[0]) {
+      ops[i][1] = 0;
+      ops[i][2] =rand()%MAXSIZE;
+    } else if(ops[i][1] < dist[1]) {
+      ops[i][1] = 1;
+      ops[i][2] = sizes[ops[i][0]];
+    } if(ops[i][1] < dist[2]) {
+      ops[i][1] = 2;
+      ops[i][2] = sizes[ops[i][0]];
+    } else {
+      ops[i][1] = 3;
+    }
+  }
+
+  starttime = CmiWallTimer();
+  for(i=0; i<RANDOPS; i++) {
+    switch(ops[i][1]) {
+      case 0:
+        if(ptrs[ops[i][0]] != NULL)
+          CmiFree(ptrs[ops[i][0]]);
+        ptrs[ops[i][0]] = (myType *)CmiAlloc(ops[i][2]*sizeof(myType));
+        break;
+      case 1:
+        if(ptrs[ops[i][0]] == NULL)
+          ptrs[ops[i][0]] = (myType *)CmiAlloc(ops[i][2]*sizeof(myType));
+        for(j = 0; j < ops[i][2]; j++) {
+          ptrs[ops[i][0]][j] = value;
+        }
+        break;
+     case 2:
+        if(ptrs[ops[i][0]] == NULL)
+          ptrs[ops[i][0]] = (myType *)CmiAlloc(ops[i][2]*sizeof(myType));
+        for(j = 0; j < ops[i][2]; j++) {
+          sums[k%200] += ptrs[ops[i][0]][j];
+        }
+        break;
+    case 3:
+      if(ptrs[ops[i][0]] != NULL){
+        CmiFree(ptrs[ops[i][0]]);
+        ptrs[ops[i][0]] = NULL;
+      }
+    }
+  }
+  endtime = CmiWallTimer();
+
+  if(CmiMyPe()==0){
+    CmiPrintf("Time taken by random malloc-traversal-free benchmark with following commutative distribution: malloc %d, write %d, read %d, free %d, max malloc size %d, length of table %d, number of ops %d is %E.\n",dist[0],dist[1],dist[2],dist[3],MAXSIZE,RANDMALLOC,RANDOPS, (endtime-starttime));
+  }
+
+  for(i=0; i<RANDMALLOC; i++) {
+    if(ptrs[i] != NULL)
+      CmiFree(ptrs[i]);
+  }
+  free(ptrs);
+}
+
+static void memoryHandler(EmptyMsg *msg){
+       /* Make sure the memory contention on a node happens roughly at the same time */
+       CmiNodeBarrier();
+       memoryTest();   
+       CmiNodeBarrier();
+       
+       if(CmiMyPe()==0){
+    CmiSetHandler(msg, CpvAccess(ack_handler));
+    CmiSyncSend(0, sizeof(EmptyMsg), msg);
+       }
+       else {
+         CmiFree(msg);
+       }
+}
+
+void memoryAccess_init(void)
+{
+  EmptyMsg msg;
+
+  CmiPrintf("Single core malloc/free/traversal performance numbers\n");
+  memoryTest();
+             
+  CmiPrintf("Multi core malloc/free/traversal performance numbers\n");
+  CmiSetHandler(&msg, CpvAccess(memoryIdx));
+  CmiSyncBroadcastAll(sizeof(EmptyMsg), &msg);
+}
+
+void memoryAccess_moduleinit(void)
+{
+  CpvInitialize(int, memoryIdx);
+  CpvAccess(memoryIdx) = CmiRegisterHandler((CmiHandler)memoryHandler);
+}
+
index 1a144e78619b5956e347e0868f68b167b3dc408c..68bd4200a1c8c1644b6d2577d4df637be3a8fe1e 100644 (file)
@@ -1,6 +1,6 @@
 CHARMC=../../../bin/charmc $(OPTS)
 
-OBJS=commbench.o overhead.o timer.o proc.o smputil.o pingpong.o ctxt.o
+OBJS=memoryAccess.o commbench.o overhead.o timer.o proc.o smputil.o pingpong.o ctxt.o
 
 all: pgm
 
@@ -10,6 +10,9 @@ pgm: $(OBJS)
 test: pgm
        ./charmrun ./pgm +p4 $(TESTOPTS)
 
+memoryAccess.o: memoryAccess.c
+       $(CHARMC) memoryAccess.c
+
 commbench.o: commbench.c
        $(CHARMC) commbench.c
 
index eaa609f737d0139b5ce67daae2913b2ab150920b..e4b0e53502971673a4d3fb614fc4df4ed9757063 100644 (file)
@@ -20,6 +20,7 @@
  *
  *****************************************************************************/
 
+extern void memoryAccess_init(void);
 extern void overhead_init(void);
 extern void timer_init(void);
 extern void proc_init(void);
@@ -27,6 +28,7 @@ extern void smputil_init(void);
 extern void pingpong_init(void);
 extern void ctxt_init(void);
 
+extern void memoryAccess_moduleinit(void);
 extern void overhead_moduleinit(void);
 extern void timer_moduleinit(void);
 extern void proc_moduleinit(void);
@@ -40,6 +42,7 @@ struct testinfo
   void (*initiator)(void);
   void (*initializer)(void);
 } tests[] = {
+  { "memoryAccess",  memoryAccess_init,  memoryAccess_moduleinit },
   { "overhead",  overhead_init,  overhead_moduleinit },
   { "timer",     timer_init,     timer_moduleinit },
   { "proc",      proc_init,      proc_moduleinit },