# HG changeset patch
# User kshalle
# Date 1322521138 -3600
# Node ID b2a84bc2b2743c6c5f3f7a2880b422a63357a28c
# Parent  28650a4df2b96093d24ffb8b36ebfc4fa1358e2c
working version of exe time vs task size

diff -r 28650a4df2b9 -r b2a84bc2b274 src/Application/main.c
--- a/src/Application/main.c	Mon Nov 21 21:39:03 2011 +0100
+++ b/src/Application/main.c	Mon Nov 28 23:58:58 2011 +0100
@@ -61,6 +61,11 @@
 #endif
 
 //======================== Defines =========================
+typedef struct perfData measurement_t;
+struct perfData{
+    uint64 cycles;
+    uint64 instructions;
+};
 
 const char *usage = {
 	"Usage: malloc_test [options]\n"
@@ -78,6 +83,8 @@
     int nthreads;
     int32 mutex;
     int32 cond;
+    measurement_t endBarrierCycles;
+
 };
 typedef struct barrier_t barrier;
 
@@ -89,13 +96,18 @@
    barr->cond    = VPThread__make_cond(barr->mutex, animatingPr);
  }
 
+int cycles_counter_main_fd;
 void inline barrier_wait(barrier *barr, VirtProcr *animatingPr)
  { int i;
 
    VPThread__mutex_lock(barr->mutex, animatingPr);
    barr->counter++;
    if(barr->counter == barr->nthreads)
-    { barr->counter = 0;
+    { 
+      read(cycles_counter_main_fd, &(barr->endBarrierCycles.cycles), \
+                sizeof(barr->endBarrierCycles.cycles));
+       
+      barr->counter = 0;
       for(i=0; i < barr->nthreads; i++)
          VPThread__cond_signal(barr->cond, animatingPr);
     }
@@ -105,18 +117,20 @@
    VPThread__mutex_unlock(barr->mutex, animatingPr);
  }
 
-struct perfData{
-    uint64 cycles;
-    uint64 instructions;
+
+
+struct WorkerParamsStr{
+    struct barrier_t* barrier;
+    uint64_t  totalWorkCycles;
 };
 
-typedef struct perfData measurement_t;
+typedef struct WorkerParamsStr WorkerParams;
 
-struct input_t{
-    struct barrier_t* barrier;
-    uint64  totalWorkCycles;
-};
-
+typedef struct
+ { measurement_t *startExeCycles;
+   measurement_t *endExeCycles;
+ }
+BenchParams;
 
 //======================== Globals =========================
 char __ProgrammName[] = "overhead_test";
@@ -126,9 +140,10 @@
 size_t chunk_size = 0;
 
 int cycles_counter_fd[NUM_CORES];
-int cycles_counter_main_fd;
 struct perf_event_attr* hw_event;
 
+WorkerParams *workerParamsArray;
+
 //======================== App Code =========================
 /*
  * Workload
@@ -146,13 +161,13 @@
 } while (0) //macro magic for scoping
 
 
-void work(void* input, VirtProcr* animatingPr)
+void worker_TLF(void* _params, VirtProcr* animatingPr)
  {
    int i,o;
-   struct input_t* in = (struct input_t*)input;
+   WorkerParams* params = (struct WorkerParamsStr*)_params;
    unsigned int totalWorkCycles = 0;
-   unsigned int workspace1;
-   double workspace2;
+   unsigned int workspace1=0;
+   double workspace2=0.0;
    int32 privateMutex = VPThread__make_mutex(animatingPr);
    
    int cpuid = sched_getcpu();
@@ -185,12 +200,12 @@
       VPThread__mutex_unlock(privateMutex, animatingPr);
     }
 
-   in->totalWorkCycles = totalWorkCycles;
-   printf("Cycles: %lu on CPU %lu\n", totalWorkCycles, cpuid);
+   params->totalWorkCycles = totalWorkCycles;
+   //printf("Cycles: %lu on CPU %lu\n", totalWorkCycles, cpuid);
    
    
    //Wait for all threads to end
-   barrier_wait(in->barrier, animatingPr);
+   barrier_wait(params->barrier, animatingPr);
    
    //Shutdown worker
    VPThread__dissipate_thread(animatingPr);
@@ -199,46 +214,55 @@
    printf("%f", workspace2);  //two workspace variables
  }
 
+
 /* this is run after the VMS is set up*/
-void benchmark(void *in, VirtProcr *animatingPr)
+void benchmark(void *_params, VirtProcr *animatingPr)
  {
    int i, cpuID;
-   struct input_t input[num_threads];
-   struct barrier_t barr;
+   struct barrier_t  barr;
+   BenchParams      *params;
+   
+   params = (BenchParams *)_params;
+
    barrier_init(&barr, num_threads+1, animatingPr);
-   
-   
-   
+      
    //prepare input
    for(i=0; i<num_threads; i++)
     { 
-       input[i].barrier = &barr;
+       workerParamsArray[i].barrier = &barr;
     }
      
-   printf("just before first counter read, inside benchmark\n");
+         //printf("just before first counter read, inside benchmark\n");
   
-   //save cycles before execution of threads to get longest runtime
-   measurement_t startBenchTime, endBenchTime;
-   int nread = read(cycles_counter_main_fd,&(startBenchTime.cycles),
-                sizeof(startBenchTime.cycles));
-   if(nread<0){                                         
-       perror("Error reading cycles counter");
-   }
-   printf("finished first counter read, inside benchmark\n");
+   //save cycles before execution of threads, to get total exe cycles
+   measurement_t *startExeCycles, *endExeCycles;
+   startExeCycles = params->startExeCycles;
+   //endExeCycles   = params->endExeCycles;
+   
+    //printf("finished first counter read, inside benchmark\n");
    //create all threads
    for(i=0; i<num_threads; i++)
-    { VPThread__create_thread((VirtProcrFnPtr)work, (void*)&input[i], animatingPr);}
+    { VPThread__create_thread((VirtProcrFnPtr)worker_TLF, &(workerParamsArray[i]), animatingPr);
+    }
+   
+   int nread = read(cycles_counter_main_fd, &(startExeCycles->cycles),
+                sizeof(startExeCycles->cycles));
+   if(nread<0)
+    { perror("Error reading cycles counter");
+    }
    //wait for all threads to finish
    barrier_wait(&barr, animatingPr);
   
    
    //accumulated cycles of all cores
-   nread = read(cycles_counter_main_fd,&(endBenchTime.cycles),
-                sizeof(endBenchTime.cycles));
-   if(nread<0){                                         
-       perror("Error reading cycles counter");
-   }
+ //  nread = read(cycles_counter_main_fd, &(endExeCycles->cycles), \
+                sizeof(endExeCycles->cycles));
+ //  if(nread<0){                                         
+ //      perror("Error reading cycles counter");
+   params->endExeCycles->cycles = barr.endBarrierCycles.cycles;
+   
 
+/*
    uint64_t overallWorkCycles = 0;
    for(i=0; i<num_threads; i++){ 
        printf("WorkCycles: %lu\n",input[i].totalWorkCycles);
@@ -247,6 +271,9 @@
    
    printf("Sum across threads of work cycles: %lu\n", overallWorkCycles);
    printf("Total Execution: %lu\n", endBenchTime.cycles-startBenchTime.cycles);
+   printf("Runtime/Workcycle Ratio %lu\n", 
+   ((endBenchTime.cycles-startBenchTime.cycles)*100)/overallWorkCycles);
+*/
 
    //======================================================
 
@@ -256,6 +283,10 @@
 int main(int argc, char **argv)
  {
    int i;
+   measurement_t startExeCycles, endExeCycles;
+   BenchParams *benchParams;
+   
+   benchParams = malloc(sizeof(BenchParams)); 
 
    //set global static variables, based on cmd-line args
    for(i=1; i<argc; i++)
@@ -267,7 +298,7 @@
             case 't':
                if(!isdigit(argv[++i][0]))
                 {
-                  fprintf(stderr, "-t mus be followed by the number of worker threads to spawn\n");
+                  fprintf(stderr, "-t must be followed by the number of worker threads to spawn\n");
                   return EXIT_FAILURE;
                 }
                num_threads = atoi(argv[i]);
@@ -312,6 +343,7 @@
        }
     }//for
    
+   
    //setup performance counters
     hw_event = malloc(sizeof(struct perf_event_attr));
     memset(hw_event,0,sizeof(struct perf_event_attr));
@@ -353,7 +385,6 @@
          perror("Failed to open cycles counter");
        }
     }
-   printf("counters now set up\n");
 
    //Set up counter to accumulate total cycles to process, across all CPUs
 
@@ -374,10 +405,30 @@
       fprintf(stderr,"in main ");
       perror("Failed to open cycles counter");
     }
+   
+   //printf("counters now set up\n");
+   workerParamsArray =  (WorkerParams *)malloc( (num_threads + 1) * sizeof(WorkerParams) );
+   if(workerParamsArray == NULL ) printf("error mallocing worker params array\n");
+   
+   workerParamsArray[0].totalWorkCycles = 0;
+   
+   benchParams->startExeCycles = &startExeCycles;
+   benchParams->endExeCycles   = &endExeCycles;
 
+   //This is the transition to the VMS runtime
+   VPThread__create_seed_procr_and_do_work( &benchmark, benchParams );
+   
+   uint64_t totalWorkCyclesAcrossCores = 0;
+   for(i=0; i<num_threads; i++){ 
+       printf("WorkCycles: %lu\n",workerParamsArray[i].totalWorkCycles);
+       totalWorkCyclesAcrossCores += workerParamsArray[i].totalWorkCycles;
+    }
 
-    //This is the transition to the VMS runtime
-   VPThread__create_seed_procr_and_do_work(benchmark, NULL);
+   uint64_t totalExeCycles = endExeCycles.cycles - startExeCycles.cycles;
+   printf("Sum across threads of work cycles: %lu\n", totalWorkCyclesAcrossCores);
+   printf("Total Execution Cycles: %lu\n", totalExeCycles);
+   printf("ExeCycles/WorkCycles Ratio %f\n", 
+          (double)totalExeCycles / (double)totalWorkCyclesAcrossCores);
 
    return 0;
  }