Added a memory contention benchmark in smputil;
authorChao Mei <chaomei09@gmail.com>
Fri, 19 Mar 2010 22:16:52 +0000 (17:16 -0500)
committerChao Mei <chaomei09@gmail.com>
Fri, 19 Mar 2010 22:16:52 +0000 (17:16 -0500)
Fixed a bug in commbench when skipping a test;

tests/converse/commbench/commbench.c
tests/converse/commbench/smputil.c [changed mode: 0644->0755]

index a6ff7b4847c4629ab7a591ffcdbbd3e21b7db55e..4e55ef94aad0374bf7d7cc7c74e56194b16ea8d1 100644 (file)
@@ -76,10 +76,10 @@ int commbench_skip(char *test)
   char **skip;
   skip = CpvAccess(tests_to_skip);
   for (i=0; i<num_skip; i++) {
-    if ((skip[i][0]=='-')&&(strcmp(skip[i]+1, test)==0))
-      return 1 - CpvAccess(test_negate_skip);
+    if (strcmp(skip[i+2], test)==0)
+      return 0; 
   }
-  return CpvAccess(test_negate_skip);
+  return 1;
 }
 
 void commbench_next()
@@ -138,8 +138,10 @@ void commbench_init(int argc, char **argv)
   CpvAccess(num_tests_to_skip) = argc;
   if(CpvAccess(test_negate_skip)) {
     CpvAccess(num_tests_to_skip)--;
+    CpvAccess(num_tests_to_skip)--;
   }
   CpvAccess(tests_to_skip) = argv;
+
   if (CmiMyPe()==0)
     commbench_next();
 }
old mode 100644 (file)
new mode 100755 (executable)
index 2d32d12..573518c
@@ -5,8 +5,12 @@
 #define NLOCKITER 1000000
 #define NBARRITER 10000
 
+#define NMALLOCITER 100000
+#define MALLOCSIZE 257
+
 CpvStaticDeclare(double, privateVar);
 CpvStaticDeclare(int, barrIdx);
+CpvStaticDeclare(int, memIdx);
 CsvStaticDeclare(double, sharedVar);
 
 static void barrierHandler(EmptyMsg *msg)
@@ -33,11 +37,52 @@ static void barrierHandler(EmptyMsg *msg)
   }
 }
 
+double memoryAllocTest(){
+  double starttime, endtime;  
+  double extraOverhead;
+  void **ptrs = NULL;
+  int i;       
+       /* Estimate the malloc overhead */
+  ptrs = (void **)malloc(NMALLOCITER*sizeof(void *));
+  /* Warm the cache first before estimating the overheads */
+  for(i=0; i<NMALLOCITER; i++) ptrs[i] = 0;
+  
+  starttime = CmiWallTimer();
+  for(i=0; i<NMALLOCITER; i++) ptrs[i] = (void *)0xabcd;
+  endtime = CmiWallTimer();
+  extraOverhead = endtime - starttime;
+  
+  starttime = CmiWallTimer();
+  for(i=0; i<NMALLOCITER; i++) ptrs[i] = malloc(MALLOCSIZE);
+  for(i=0; i<NMALLOCITER; i++) free(ptrs[i]);
+  endtime = CmiWallTimer();
+  free(ptrs);
+  
+  return (endtime-starttime-extraOverhead*2)/NMALLOCITER;      
+}
+
+static void memAllocHandler(EmptyMsg *msg){
+       /* Make sure the memory contention on a node happens roughly at the same time */
+       CmiNodeBarrier();
+       double overhead = memoryAllocTest();    
+       CmiNodeBarrier();
+       
+       if(CmiMyPe()==0){
+               CmiPrintf("[smputil] Estimated Malloc/Free Overhead (w contention): %le seconds\n",overhead);
+               CmiSetHandler(&msg, CpvAccess(barrIdx));
+         CmiSyncBroadcastAll(sizeof(EmptyMsg), &msg);
+       }else{
+               CmiFree(msg);   
+       }
+}
+
 void smputil_init(void)
 {
   EmptyMsg msg;
   double starttime, endtime;
   double stackVar=0.0, loopOverhead;
+  double extraOverhead;
+  void **ptrs = NULL;
   int i;
   CmiNodeLock lock;
 
@@ -74,7 +119,11 @@ void smputil_init(void)
   endtime = CmiWallTimer();
   CmiPrintf("[smputil] LockUnlock Overhead: %le seconds\n",
              (endtime - starttime - loopOverhead)/NLOCKITER);
-  CmiSetHandler(&msg, CpvAccess(barrIdx));
+
+       endtime = memoryAllocTest();
+  CmiPrintf("[smputil] Estimated Malloc/Free Overhead (w/o contention): %le seconds\n",endtime);
+             
+  CmiSetHandler(&msg, CpvAccess(memIdx));
   CmiSyncBroadcastAll(sizeof(EmptyMsg), &msg);
 }
 
@@ -82,8 +131,10 @@ void smputil_moduleinit(void)
 {
   CpvInitialize(double, privateVar);
   CpvInitialize(int, barrIdx);
+  CpvInitialize(int, memIdx);
   CsvInitialize(double, sharedVar);
 
   CpvAccess(barrIdx) = CmiRegisterHandler((CmiHandler)barrierHandler);
+  CpvAccess(memIdx) = CmiRegisterHandler((CmiHandler)memAllocHandler);
 }