Benchmark Runner for C Benchmarks

.github/workflows/ci.yml

@@ -26,7 +26,7 @@ jobs:
 
   # Run the C benchmark tests. 
   c-benchmark-tests:
-    uses: lf-lang/lingua-franca/.github/workflows/benchmark-tests.yml@master
+    uses: lf-lang/lingua-franca/.github/workflows/benchmark-tests.yml@c-benchmark-runner
     with:
       target: 'C'
 

benchmark/C/Savina/src/BenchmarkRunner.lf

@@ -16,48 +16,37 @@ target C;
  * 
  * How to use:
  * - Instantiate this reactor in the main reactor of the benchmark.
- * - Connect the ports inStart, outIterationStart, inIterationFinish with
+ * - Connect the ports start, finish with
  *   the appropriate reactors of the benchmark.
- * - Optionally connect the ports for initialization and cleanup.
  * - Create a startup reaction in the main reactor that calls printBenchmarkInfo(),
  * 
  * Prototype startup reaction in the main reactor of a benchmark:
  *     runner = new BenchmarkRunner(num_iterations=num_iterations);
- *     reaction(startup) -> runner.inStart {=
+ *     reaction(startup) {=
  *         printBenchmarkInfo("ThreadRingReactorLFCppBenchmark");
  *         printSystemInfo();
- *         SET(runner.inStart, true);
  *     =}
  * 
  * @param num_iterations How many times to execute the kernel of the benchmark to measure.
- * @param use_init Benchmarks needs initialization and handles the corresponding signals.
- * @param use_cleanup_iteration Benchmark needs cleanup after each iteration and handles the corresponding signals.
  * 
  * @author Hannes Klein
  * @author Shaokai Lin
+ * @author Matt Chorlian
+ * @author Arthur Deng
  */
-reactor BenchmarkRunner(num_iterations:int(12), use_init:bool(false), use_cleanup_iteration:bool(false)) {
+reactor BenchmarkRunner(num_iterations:int(12)) {
 
     /** Signal to start execution. Set this input from a startup reaction in the main reactor. */
     input inStart:bool;
 
     /** Signals for starting and finishing the kernel and runtime measurement. */
-    output outIterationStart:bool;
-    input inIterationFinish:bool;
-
-    /** Signals for initializations that are not part of the measured kernel. */
-    output outInitializeStart:bool;
-    input inInitializeFinish:bool;
-
-    /** Signals for cleanup operations after each iteration of the kernel. */
-    output outCleanupIterationStart:bool;
-    input inCleanupIterationFinish:bool;
+    output start:bool;
+    input finish:bool;
 
+
     /** Events to switch between the phases of running the iterations. */
-    logical action initBenchmark:bool;
-    logical action cleanupIteration:bool;
     logical action nextIteration:bool;
-    logical action finish:bool;
+    logical action done:bool;
 
     /** Number of iterations already executed. */
     state count:unsigned(0);
@@ -66,63 +55,38 @@ reactor BenchmarkRunner(num_iterations:int(12), use_init:bool(false), use_cleanu
     state startTime:instant_t;
 
     /** Runtime measurements. */
-    state measuredTimes:interval_t[];
+    state measuredTimes: interval_t[];
 
 
-    reaction(startup) {=
+    reaction(startup) -> nextIteration {=
         // Initialize an array of interval_t
-        self->measuredTimes = calloc(self->num_iterations, sizeof(interval_t));
-    =}
-
-    reaction(inStart) -> nextIteration, initBenchmark {=
-        if(self->use_init) {
-            schedule(initBenchmark, 0);
-        } else {
-            schedule(nextIteration, 0);
-        }
-    =}
-
-    reaction(initBenchmark) -> outInitializeStart {=
-        SET(outInitializeStart, true);
-    =}
-
-    reaction(inInitializeFinish) -> nextIteration {=
+        self->measuredTimes = (interval_t *) calloc(self->num_iterations, sizeof(interval_t));
         schedule(nextIteration, 0);
     =}
+
 
-    reaction(cleanupIteration) -> outCleanupIterationStart {=
-        SET(outCleanupIterationStart, true);
-    =}
-
-    reaction(inCleanupIterationFinish) -> nextIteration {=
-        schedule(nextIteration, 0);
-    =}
-
-    reaction(nextIteration) -> outIterationStart, finish {=
+    reaction(nextIteration) -> start, done {=
         if (self->count < self->num_iterations) { 
             self->startTime = get_physical_time();
-            SET(outIterationStart, true);
+            SET(start, true);
         } else {
-            schedule(finish, 0);
+            schedule(done, 0);
         }
     =}
 
-    reaction(inIterationFinish) -> nextIteration, cleanupIteration {=
+    reaction(finish) -> nextIteration {=
         interval_t end_time = get_physical_time();
         interval_t duration = end_time - self->startTime;
         self->measuredTimes[self->count] = duration;
         self->count += 1;
 
         printf("Iteration: %d\t Duration: %.3f msec\n", self->count, toMS(duration));
 
-        if(self->use_cleanup_iteration) {
-            schedule(cleanupIteration, 0);
-        } else {
-            schedule(nextIteration, 0);
-        }
+        schedule(nextIteration, 0);
+
     =}
 
-    reaction(finish) {=        
+    reaction(done) {=        
         double* measuredMSTimes = getMSMeasurements(self->measuredTimes, self->num_iterations);
         qsort(measuredMSTimes, self->num_iterations, sizeof(double), comp);
 
@@ -140,14 +104,14 @@ reactor BenchmarkRunner(num_iterations:int(12), use_init:bool(false), use_cleanu
         }
 
         int comp (const void * elem1, const void * elem2) {
-			int f = *((double*)elem1);
-			int s = *((double*)elem2);
-			if (f > s) return  1;
-			if (f < s) return -1;
-			return 0;
-		}
-		
-		static double median(double* execTimes, int size) {
+            int f = *((double*)elem1);
+            int s = *((double*)elem2);
+            if (f > s) return  1;
+            if (f < s) return -1;
+            return 0;
+        }
+        
+        static double median(double* execTimes, int size) {
             if (size == 0) {
                 return 0.0;
             }
@@ -162,7 +126,7 @@ reactor BenchmarkRunner(num_iterations:int(12), use_init:bool(false), use_cleanu
 
         static double* getMSMeasurements(interval_t* measured_times, int num_iterations) {
 
-            double* msMeasurements = calloc(num_iterations, sizeof(double));
+            double* msMeasurements = (double *) calloc(num_iterations, sizeof(double));
             for (int i = 0; i < num_iterations; i++) {
                 msMeasurements[i] = toMS(measured_times[i]);
             }

benchmark/C/Savina/src/concurrency/BoundedBuffer.lf

@@ -29,11 +29,16 @@ target C {
     ]]] */
     threads: 0,
     /// [[[end]]]
-    files: ["/lib/c/reactor-c/util/deque.h", "/lib/c/reactor-c/util/deque.c", "../include/PseudoRandom.h"],
+    files: ["../util/deque.h", 
+            "../util/deque.c", 
+            "../include/PseudoRandom.h"],
     flags: "-lm",
     logging: "warn"
 };
 
+import BenchmarkRunner from "../BenchmarkRunner.lf";
+
+
 preamble {=
     #include "PseudoRandom.h"
     #include <math.h>
@@ -47,11 +52,11 @@ preamble {=
         if(cost > 0) {
             for(size_t i = 0; i < cost; i++) {
                 for(size_t j = 0; j < 100; j++) {
-                    res += log(labs(nextDouble(&random)) + 0.01);
+                    res += log(fabs(nextDouble(&random)) + 0.01);
                 }
             }
         } else {
-            res += log(labs(nextDouble(&random)) + 0.01);
+            res += log(fabs(nextDouble(&random)) + 0.01);
         }
 
         return res;
@@ -65,6 +70,9 @@ reactor ManagerReactor(bufferSize: size_t(50), numProducers: size_t(40), numCons
         #include "deque.c"
     =}
 
+    input start: bool;
+    output finished: bool;
+
     state adjustedBuffersize: size_t(0);
     state pendingData: deque_t;
     state numTerminatedProducers: size_t(0);
@@ -78,7 +86,7 @@ reactor ManagerReactor(bufferSize: size_t(50), numProducers: size_t(40), numCons
     input[numConsumers] consumerAvailable: bool;
     output[numConsumers] consumerData: double;
 
-    reaction(startup) -> producerCommand {=
+    reaction(start) -> producerCommand {=
         // reset local state
         self->adjustedBuffersize = self->bufferSize - self->numProducers;
         self->numTerminatedProducers = 0;
@@ -94,9 +102,10 @@ reactor ManagerReactor(bufferSize: size_t(50), numProducers: size_t(40), numCons
         }
     =}
 
-    reaction(consumerAvailable) -> consumerData, producerCommand {=
+    reaction(consumerAvailable) -> consumerData, producerCommand, finished {=
         // abort if all producers have terminated and all data has been send
         if((self->numTerminatedProducers == self->numProducers) && deque_is_empty(&self->pendingData)) {
+            SET(finished, true);
             return;
         }
 
@@ -150,9 +159,10 @@ reactor ProducerReactor(bank_index: size_t(0), numItemsToProduce: size_t(1000),
     input produce: bool;
     output data: double
 
+    input reset: bool;
     output finished: bool;
 
-    reaction (startup) {=   
+    reaction (reset) {=   
         // reset local state
         self->prodItem = 0.0;
         self->itemsProduced = 0;
@@ -174,12 +184,14 @@ reactor ConsumerReactor(bank_index: size_t(0), consCost: size_t(25)) {
 
     state consItem: double(0.0);
 
+    input reset: bool;
+
     input data: double;
     output available: bool;
 
     logical action sendAvailable;
 
-    reaction (startup) -> sendAvailable {=
+    reaction (reset) -> sendAvailable {=
         // reset local state
         self->consItem = 0.0;
         schedule(sendAvailable, 0);
@@ -198,6 +210,7 @@ reactor ConsumerReactor(bank_index: size_t(0), consCost: size_t(25)) {
 
 /* [[[cog
   cog.outl('main reactor (')
+  cog.outl(f'    numIterations: size_t({numIterations}),')
   cog.outl(f'    bufferSize: size_t({bufferSize}),')
   cog.outl(f'    prodCost: size_t({prodCost}),')
   cog.outl(f'    consCost: size_t({consCost}),')
@@ -206,6 +219,7 @@ reactor ConsumerReactor(bank_index: size_t(0), consCost: size_t(25)) {
   cog.outl(f'    numProducers: size_t({numProducers})')
 ]]] */
 main reactor (
+    numIterations: size_t(12),
     bufferSize: size_t(50),
     prodCost: size_t(25),
     consCost: size_t(25),
@@ -215,7 +229,17 @@ main reactor (
 // [[[end]]]
 ) {
 
+    runner = new BenchmarkRunner(num_iterations=numIterations);
     manager = new ManagerReactor(bufferSize=bufferSize, numProducers=numProducers, numConsumers=numConsumers);
+
+    (runner.start)+ -> manager.start, producers.reset, consumers.reset;
+    manager.finished -> runner.finish;
+
+    reaction(startup) {=
+        printBenchmarkInfo("ProdConsBenchmark");
+        printSystemInfo();
+    =}
+
     producers = new[numProducers] ProducerReactor(numItemsToProduce=numItemsPerProducer, prodCost=prodCost);
     consumers = new[numConsumers] ConsumerReactor(consCost=consCost);
 
@@ -225,4 +249,4 @@ main reactor (
 
     consumers.available -> manager.consumerAvailable;
     manager.consumerData -> consumers.data;
-}
+}

benchmark/C/Savina/src/concurrency/CigaretteSmoker.lf

@@ -71,6 +71,8 @@ target C {
     files: "../include/PseudoRandom.h"
 };
 
+import BenchmarkRunner from "../BenchmarkRunner.lf";
+
 
 reactor ArbiterReactor(numRounds:size_t(1000), numSmokers:size_t(200)) {
 
@@ -80,13 +82,16 @@ reactor ArbiterReactor(numRounds:size_t(1000), numSmokers:size_t(200)) {
 
     state roundsSoFar: size_t(0);
     state random: PseudoRandom*;
+
+    input inStart:bool;
+    output outFinished:bool;
 
     output[numSmokers] startSmoking: size_t;
 
     logical action chooseSmoker;
     logical action stop;
 
-    reaction(startup) -> chooseSmoker {=
+    reaction(inStart) -> chooseSmoker {=
         // Initialize the random state variable
         self->random = (PseudoRandom*)malloc(sizeof(PseudoRandom));
         self->random->mValue = self->numRounds * self->numSmokers;
@@ -117,6 +122,10 @@ reactor ArbiterReactor(numRounds:size_t(1000), numSmokers:size_t(200)) {
         }
     =}
 
+    reaction(stop) -> outFinished {=
+        SET(outFinished, true);
+    =}
+
     reaction(shutdown) {=
         free(self->random);
     =}
@@ -149,15 +158,18 @@ reactor SmokerReactor {
 
 
 /* [[[cog
-    cog.outl(f'main reactor (numRounds:size_t({numRounds}), numSmokers:size_t({numSmokers}))')
+    cog.outl(f'main reactor (numIterations:size_t({numIterations}), numRounds:size_t({numRounds}), numSmokers:size_t({numSmokers}))')
 ]]] */
-main reactor (numRounds:size_t(1000), numSmokers:size_t(200))
+main reactor (numIterations:size_t(12), numRounds:size_t(1000), numSmokers:size_t(200))
 /// [[[end]]]
 
 {
 
     arbiter = new ArbiterReactor(numRounds=numRounds, numSmokers=numSmokers);
+    runner = new BenchmarkRunner(num_iterations=numIterations)
 
+    runner.start -> arbiter.inStart;
+    arbiter.outFinished -> runner.finish;
 
     reaction(startup) {=
         // based on the Savina implementation: