# HG changeset patch
# User Merten Sach <msach@mailbox.tu-berlin.de>
# Date 1323235066 -3600
# Node ID 5d3b5e58456e325009300a03dd688333fb78d46e
# Parent  b2a84bc2b2743c6c5f3f7a2880b422a63357a28c
Working version, uses TSC for inner loop -- appears more stable

diff -r b2a84bc2b274 -r 5d3b5e58456e src/Application/main.c
--- a/src/Application/main.c	Mon Nov 28 23:58:58 2011 +0100
+++ b/src/Application/main.c	Wed Dec 07 06:17:46 2011 +0100
@@ -119,12 +119,17 @@
 
 
 
-struct WorkerParamsStr{
-    struct barrier_t* barrier;
-    uint64_t  totalWorkCycles;
-};
+typedef struct
+ { struct barrier_t* barrier;
+   uint64_t  totalWorkCycles;
+   uint64_t  totalBadCycles;
+   uint64_t  totalSyncCycles;
+   uint64_t  totalBadSyncCycles;
+   uint64     numGoodSyncs;
+   uint64     numGoodTasks;
+ }
+WorkerParams;
 
-typedef struct WorkerParamsStr WorkerParams;
 
 typedef struct
  { measurement_t *startExeCycles;
@@ -136,7 +141,7 @@
 char __ProgrammName[] = "overhead_test";
 char __DataSet[255];
 
-int repetitions, workload_size, num_threads;
+int outer_iters, inner_iters, num_threads;
 size_t chunk_size = 0;
 
 int cycles_counter_fd[NUM_CORES];
@@ -161,47 +166,72 @@
 } while (0) //macro magic for scoping
 
 
-void worker_TLF(void* _params, VirtProcr* animatingPr)
+double
+worker_TLF(void* _params, VirtProcr* animatingPr)
  {
    int i,o;
-   WorkerParams* params = (struct WorkerParamsStr*)_params;
-   unsigned int totalWorkCycles = 0;
-   unsigned int workspace1=0;
+   WorkerParams* params = (WorkerParams*)_params;
+   unsigned int totalWorkCycles = 0, totalBadCycles = 0;
+   unsigned int totalSyncCycles = 0, totalBadSyncCycles = 0;
+   unsigned int workspace1=0, numGoodSyncs = 0, numGoodTasks = 0;
    double workspace2=0.0;
    int32 privateMutex = VPThread__make_mutex(animatingPr);
    
    int cpuid = sched_getcpu();
-    
-   for(o=0; o<repetitions; o++)
+   
+   measurement_t startWorkload, endWorkload;
+   uint64 numCycles;
+   TSCountLowHigh startTask, endTask, endSync1, endSync2;
+   for(o=0; o < outer_iters; o++)
     {
        
-      //measure inner workload to determine synchronisation overhead by subtraction
-      measurement_t startWorkload, endWorkload;
-      saveCyclesAndInstrs(cpuid,startWorkload.cycles);
-
+//          saveCyclesAndInstrs(cpuid,startWorkload.cycles);
+          saveTSCLowHigh(startTask);
+       
       //workload
-      for(i=0; i<workload_size; i++)
+      for(i=0; i < inner_iters; i++)
        {
          workspace1 += (workspace1 + 32)/2;
          workspace2 += (workspace2 + 23.2)/1.4;
        }
       
-    
-      //measure end of inner workload
-      saveCyclesAndInstrs(cpuid,endWorkload.cycles);
-      uint64 numCycles = endWorkload.cycles - startWorkload.cycles;
+          saveTSCLowHigh(endTask);
+          numCycles = endTask.longVal - startTask.longVal;
+//          saveCyclesAndInstrs(cpuid,endWorkload.cycles);
+//          numCycles = endWorkload.cycles - startWorkload.cycles;
+
+          //sanity check (400K is about 20K iters)
+          if( numCycles < 400000 ) {totalWorkCycles += numCycles; numGoodTasks++;}
+          else                     {totalBadCycles  += numCycles; }
+
+      //mutex access often causes switch to different Slave VP
+      VPThread__mutex_lock(privateMutex, animatingPr);
+          saveTSCLowHigh(endSync1);
+          numCycles = endSync1.longVal - endTask.longVal;
+          //sanity check (400K is about 20K iters)
+          if( numCycles < 400000 ) {totalSyncCycles += numCycles; numGoodSyncs++;}
+          else                     totalBadSyncCycles  += numCycles;
       
-      
-     if( numCycles < 4000000 ) //sanity check (4M is about 200K iters)
-         totalWorkCycles += numCycles;
+      VPThread__mutex_unlock(privateMutex, animatingPr);
+          saveTSCLowHigh(endSync2);
+          numCycles = endSync2.longVal - endSync1.longVal;
+          //sanity check (400K is about 20K iters)
+          if( numCycles < 400000 ) {totalSyncCycles += numCycles; numGoodSyncs++;}
+          else                     totalBadSyncCycles  += numCycles;
 
-      //mutex access causes switch to different Slave VP
-      VPThread__mutex_lock(privateMutex, animatingPr);
-      VPThread__mutex_unlock(privateMutex, animatingPr);
     }
 
    params->totalWorkCycles = totalWorkCycles;
-   //printf("Cycles: %lu on CPU %lu\n", totalWorkCycles, cpuid);
+   params->totalBadCycles = totalBadCycles;
+   params->numGoodTasks   = numGoodTasks;
+   params->totalSyncCycles = totalSyncCycles;
+   params->totalBadSyncCycles = totalBadSyncCycles;
+   params->numGoodSyncs = numGoodSyncs;
+/*
+   params->totalSyncCycles = VMS__give_num_plugin_cycles();
+   params->totalBadSyncCycles = 0;
+   params->numGoodSyncs = VMS__give_num_plugin_animations();
+*/
    
    
    //Wait for all threads to end
@@ -209,9 +239,9 @@
    
    //Shutdown worker
    VPThread__dissipate_thread(animatingPr);
-     //below printfs never reached --> there for gcc
-   printf("%d", workspace1);  //This is to prevent gcc from optimizing out the
-   printf("%f", workspace2);  //two workspace variables
+   
+     //below return never reached --> there for gcc
+   return (workspace1 + workspace2);  //to prevent gcc from optimizing work out
  }
 
 
@@ -232,33 +262,22 @@
        workerParamsArray[i].barrier = &barr;
     }
      
-         //printf("just before 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)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");
+   if(nread<0) perror("Error reading cycles counter");
+   
+   //create (which starts running) all threads
+   for(i=0; i<num_threads; i++)
+    { VPThread__create_thread((VirtProcrFnPtr)worker_TLF, &(workerParamsArray[i]), animatingPr);
     }
    //wait for all threads to finish
    barrier_wait(&barr, animatingPr);
   
-   
-   //accumulated cycles of all cores
- //  nread = read(cycles_counter_main_fd, &(endExeCycles->cycles), \
-                sizeof(endExeCycles->cycles));
- //  if(nread<0){                                         
- //      perror("Error reading cycles counter");
+   //endBarrierCycles read in barrier_wait()!  Merten, email me if want to chg
    params->endExeCycles->cycles = barr.endBarrierCycles.cycles;
    
 
@@ -283,10 +302,6 @@
 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++)
@@ -309,21 +324,21 @@
                 }
                num_threads *= NUM_CORES;
             break;
-            case 'i':
+            case 'o':
                if(!isdigit(argv[++i][0]))
                 {
                   fputs("-i must be followed by a number\n", stderr);
                   return EXIT_FAILURE;
                 }
-               repetitions = atoi(argv[i]);
+               outer_iters = atoi(argv[i]);
 				break;
-            case 'o':
+            case 'i':
                if(!isdigit(argv[++i][0]))
                 {
                   fputs("-o must be followed by a number (workload size)\n", stderr);
                   return EXIT_FAILURE;
                 }
-               workload_size = atoi(argv[i]);
+               inner_iters = atoi(argv[i]);
 				break;
             case 'h':
                fputs(usage, stdout);
@@ -406,27 +421,41 @@
       perror("Failed to open cycles counter");
     }
    
-   //printf("counters now set up\n");
+   measurement_t startExeCycles, endExeCycles;
+   BenchParams *benchParams;
+   
+   benchParams = malloc(sizeof(BenchParams)); 
+   
+   benchParams->startExeCycles = &startExeCycles;
+   benchParams->endExeCycles   = &endExeCycles;
+   
    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;
+   uint64_t totalWorkCyclesAcrossCores = 0, totalBadCyclesAcrossCores = 0;
+   uint64_t totalSyncCyclesAcrossCores = 0, totalBadSyncCyclesAcrossCores = 0;
    for(i=0; i<num_threads; i++){ 
        printf("WorkCycles: %lu\n",workerParamsArray[i].totalWorkCycles);
+//       printf("Num Good Tasks: %lu\n",workerParamsArray[i].numGoodTasks);
+//       printf("SyncCycles: %lu\n",workerParamsArray[i].totalSyncCycles);
+//       printf("Num Good Syncs: %lu\n",workerParamsArray[i].numGoodSyncs);
        totalWorkCyclesAcrossCores += workerParamsArray[i].totalWorkCycles;
+       totalBadCyclesAcrossCores  += workerParamsArray[i].totalBadCycles;
+       totalSyncCyclesAcrossCores += workerParamsArray[i].totalSyncCycles;
+       totalBadSyncCyclesAcrossCores  += workerParamsArray[i].totalBadSyncCycles;
     }
 
    uint64_t totalExeCycles = endExeCycles.cycles - startExeCycles.cycles;
+   totalExeCycles -= totalBadCyclesAcrossCores;
+   
    printf("Sum across threads of work cycles: %lu\n", totalWorkCyclesAcrossCores);
    printf("Total Execution Cycles: %lu\n", totalExeCycles);
+   printf("Sum across threads of Sync cycles: %lu\n", totalSyncCyclesAcrossCores);
+   printf("Sum across threads of Bad Sync cycles: %lu\n", totalBadSyncCyclesAcrossCores);
    printf("ExeCycles/WorkCycles Ratio %f\n", 
           (double)totalExeCycles / (double)totalWorkCyclesAcrossCores);