Port benchmarks to align with bodyless-reactions a1c98f6f73e88d0dfecd5dfaf5e24a4439984f34

petervdonovan · petervdonovan · commit 01407e6481e6 · 2023-03-03T13:01:31.000-08:00
diff --git a/C/Savina/src/concurrency/SleepingBarber.lf b/C/Savina/src/concurrency/SleepingBarber.lf
@@ -62,8 +62,9 @@ import BenchmarkRunner from "../BenchmarkRunner.lf";
 preamble {=
 
     #include "PseudoRandom.h"
+    #include "deque.h"
 
-    size_t busyWait(size_t limit) {
+    static size_t busyWait(size_t limit) {
         size_t test = 0;
         for(size_t k = 0; k < limit; k++) {
             // The Java Math.random() is used as workload in the original Akka Savina benchmark suite.
@@ -171,9 +172,6 @@ reactor CustomerFactory(numCustomers:size_t(2000), averageProductionRate:size_t(
  * to the customer ID.
  */
 reactor WaitingRoom(capacity:size_t(1000), numCustomers:size_t(2000)) {
-    preamble {=
-        #include "deque.c"
-    =}
 
     input reset_state:bool;
     input receiveCustomer: size_t;
diff --git a/C/Savina/src/concurrency/SortedList.lf b/C/Savina/src/concurrency/SortedList.lf
@@ -42,6 +42,10 @@ preamble {=
         access_type type;
         int value;
     } message_t;
+
+    template <typename T>
+    class SortedLinkedList;
+    #include "PseudoRandom.h"
 =}
 
 reactor Manager(numWorkers: size_t(20)) {
diff --git a/C/Savina/src/micro/Big.lf b/C/Savina/src/micro/Big.lf
@@ -40,6 +40,10 @@ target C{
 
 import BenchmarkRunner from "../BenchmarkRunner.lf";
 
+preamble {=
+    #include "PseudoRandom.h"
+=}
+
 // Despite the name, this only collects "finished" messages from all workers
 // and lets the benchmark runner know when all the workers finished
 reactor Sink(num_workers:size_t(10)) {
diff --git a/C/Savina/src/micro/Chameneos.lf b/C/Savina/src/micro/Chameneos.lf
@@ -55,7 +55,7 @@ target C {
 import BenchmarkRunner from "../BenchmarkRunner.lf";
 
 preamble {=
-    char const* color_names[] = {"Red", "Yellow", "Blue", "Faded"};
+    static char const* color_names[] = {"Red", "Yellow", "Blue", "Faded"};
 
     typedef enum {
       RED,
@@ -79,7 +79,7 @@ preamble {=
       int id;
     } msg_t;
 
-    color_t complement(const color_t color, const color_t otherColor) {
+    static color_t complement(const color_t color, const color_t otherColor) {
         switch(color) {
           case RED:
             switch(otherColor) {
diff --git a/C/Savina/src/micro/Counting.lf b/C/Savina/src/micro/Counting.lf
@@ -47,13 +47,18 @@ target C {
       else:
           cog.outl("threading: false,")
     ]]] */
+    files: ["../include/benchmark_runner.h"],
     threading: false,
     /// [[[end]]]
     fast: true
 }
 
 import BenchmarkRunner from "../BenchmarkRunner.lf";
 
+preamble {=
+    #include "benchmark_runner.h"
+=}
+
 reactor ProducerReactor(countTo:int(1000000)) {
 
 
diff --git a/C/Savina/src/micro/PingPong.lf b/C/Savina/src/micro/PingPong.lf
@@ -31,13 +31,18 @@ target C {
       else:
           cog.outl("threading: false,")
     ]]] */
+    files: ["../include/benchmark_runner.h"],
     threading: false,
     /// [[[end]]]
     fast: true
 };
 
 import BenchmarkRunner from "../BenchmarkRunner.lf";
 
+preamble {=
+    #include "benchmark_runner.h"
+=}
+
 reactor Ping(count:int(1000000)) {
     input receive:int;
     input start:bool;
diff --git a/C/Savina/src/micro/ThreadRing.lf b/C/Savina/src/micro/ThreadRing.lf
@@ -60,6 +60,7 @@ target C {
       else:
           cog.outl("threading: false,")
     ]]] */
+    files: ["../include/benchmark_runner.h"],
     threading: false,
     /// [[[end]]]
     fast: true,
@@ -69,21 +70,22 @@ target C {
 import BenchmarkRunner from "../BenchmarkRunner.lf";
 
 preamble {=
-    int ping;
+    #include "benchmark_runner.h"
+    static int ping;
 
-    bool hasNext(int ping) {
+    static bool hasNext(int ping) {
         if (ping > 0) {
             return true;
         } else {
             return false;
         }
     }
 
-    int getPingsLeft(int ping) {
+    static int getPingsLeft(int ping) {
         return ping;
     }
 
-    int ping_next(int ping) {
+    static int ping_next(int ping) {
         return ping - 1;
     }
 =}
diff --git a/C/Savina/src/micro/Throughput.lf b/C/Savina/src/micro/Throughput.lf
@@ -61,6 +61,7 @@ target C {
       else:
           cog.outl("threading: false,")
     ]]] */
+    files: ["../include/benchmark_runner.h"],
     threading: false,
     /// [[[end]]]
     flags: "-lm",
@@ -69,6 +70,10 @@ target C {
 
 import BenchmarkRunner from "../BenchmarkRunner.lf";
 
+preamble {=
+    #include "benchmark_runner.h"
+=}
+
 reactor ThroughputReactor(totalMessages:int(10000)) {
 
     preamble {=
diff --git a/C/Savina/src/parallelism/Apsp.lf b/C/Savina/src/parallelism/Apsp.lf
@@ -30,18 +30,19 @@ target C {
     /// [[[end]]]
     build-type : RelWithDebInfo,
     cmake-include: ["../lib/matrix.cmake"],
-    files: ["../include/matrix.h", "../lib/matrix.c", "../include/PseudoRandom.h"],
+    files: ["../include/matrix.h", "../lib/matrix.c", "../include/PseudoRandom.h", "../include/benchmark_runner.h"],
     fast: true
 };
 
 import BenchmarkRunner from "../BenchmarkRunner.lf";
 
 preamble {=
+    #include "benchmark_runner.h"
     #include "matrix.h"
     #include "PseudoRandom.h"
     #include <math.h>
 
-    long min(long a, long b) {
+    static long min(long a, long b) {
         return a < b ? a : b;
     }
 =}
diff --git a/C/Savina/src/parallelism/FilterBank.lf b/C/Savina/src/parallelism/FilterBank.lf
@@ -38,13 +38,18 @@ target C {
       else:
           cog.outl("threading: false,")
     ]]] */
+    files: ["../include/benchmark_runner.h"],
     threading: false,
     /// [[[end]]]
     fast: true
 };
 
 import BenchmarkRunner from "../BenchmarkRunner.lf";
 
+preamble {=
+    #include "benchmark_runner.h"
+=}
+
 /**
  * Send an output every 1 msec.
  */
diff --git a/C/Savina/src/parallelism/GuidedSearch.lf b/C/Savina/src/parallelism/GuidedSearch.lf
@@ -74,14 +74,16 @@ target CCpp {
     files: ["GuidedSearch/GuidedSearchCommon.cc",
         "GuidedSearch/GuidedSearchCommon.hh",
         "GuidedSearch/GridNode.cc",
-        "GuidedSearch/GridNode.hh"],
+        "GuidedSearch/GridNode.hh",
+        "../include/benchmark_runner.h"],
     logging: "warn",
     fast: true
 };
 
 import BenchmarkRunner from "../BenchmarkRunner.lf";
 
 preamble {=
+    #include "benchmark_runner.h"
     #include "GuidedSearchCommon.hh"
     #include <deque>
     #include <list>
diff --git a/C/Savina/src/parallelism/MatMul.lf b/C/Savina/src/parallelism/MatMul.lf
@@ -18,16 +18,19 @@ target C {
     threading: false,
     /// [[[end]]]
     cmake-include: "../lib/matrix.cmake",
-    files: ["../lib/matrix.c", "../include/matrix.h"],
+    files: ["../lib/matrix.c", "../include/matrix.h", "../include/benchmark_runner.h"],
     build-type: RelWithDebInfo,
     fast: true
 };
 
 import BenchmarkRunner from "../BenchmarkRunner.lf";
 
 preamble {=
+    #include "benchmark_runner.h"
+    #include "matrix.h"
     #include <stddef.h>
     #include <assert.h>
+    #include <math.h>
 
     typedef struct work_item_t {
         size_t srA; // srA = start row in matrix A
@@ -55,7 +58,7 @@ preamble {=
     /*
      * Allocates and initializes a work stack.
      */
-    work_stack_t work_stack_new() {
+    static work_stack_t work_stack_new() {
         // 2^53 - 8 WorkItems is more than can fit in a computer, and it is fine for
         //  work stacks to be initialized with space for 50 pointers because for every
         //  work_stack_t that exists, at least one expensive parallel computation is
@@ -71,7 +74,7 @@ preamble {=
      * Frees the memory required by the work stack. This operation invalidates the work
      * stack.
      */
-    void work_stack_free(work_stack_t work) {
+    static void work_stack_free(work_stack_t work) {
         for (size_t i = 1; i <= work.current_n_stacks; ++i) {
             free((work.stacks)[i]);
         }
@@ -82,7 +85,7 @@ preamble {=
      * @param work A work stack.
      * @param w A new work item.
      */
-    void work_stack_push(work_stack_t* work, work_item_t w) {
+    static void work_stack_push(work_stack_t* work, work_item_t w) {
         if (work->next_item == work->current_stack_end) {
             size_t current_height = 8L << (++work->current_n_stacks);
             work_item_t* current_stack = (work_item_t*) malloc(
@@ -101,7 +104,7 @@ preamble {=
      * Pops (removes) an item from the given work stack.
      * @return The work item at the top of the stack.
      */
-    work_item_t work_stack_pop(work_stack_t* work) {
+    static work_item_t work_stack_pop(work_stack_t* work) {
         if (work->next_item == work->current_stack) {
             assert(work->current_n_stacks > 1);
             size_t current_height = 8L << (--work->current_n_stacks);
@@ -118,43 +121,39 @@ preamble {=
     /*
      * Returns whether the given work stack is empty.
      */
-    bool work_stack_empty(work_stack_t* work) {
+    static bool work_stack_empty(work_stack_t* work) {
         return work->current_n_stacks <= 1 && (work->next_item == work->current_stack);
     }
-=}
-
-reactor Manager(num_workers: int(20), data_length: size_t(1024)) {
-    preamble {=
-        #include <math.h>
-        #include "matrix.h"
 
-        /*
-         * Accesses the given matrix using the assumption that it is the
-         * transpose of the matrix that we wish to represent.
-         */
-        double* transposed_mat_at_d(matrix_t matrix, size_t i, size_t j) {
-            return mat_at_d(matrix, j, i);
-        }
+    /*
+    * Accesses the given matrix using the assumption that it is the
+    * transpose of the matrix that we wish to represent.
+    */
+    static double* transposed_mat_at_d(matrix_t matrix, size_t i, size_t j) {
+        return mat_at_d(matrix, j, i);
+    }
 
-        /*
-         * Prints a message if there exists an incorrect entry in the given matrix.
-         */
-        void check_if_valid(matrix_t C, size_t data_length) {
-            for (size_t i = 0; i < data_length; ++i) {
-                for (size_t j = 0; j < data_length; ++j) {
-                    double actual = *mat_at_d(C, i, j);
-                    double expected = 1.0 * data_length * i * j;
-                    if (fabs(actual - expected) > 0.0001) {
-                        printf(
-                            "Validation failed for (i,j)=(%li, %li) with (%f, %f)\n",
-                            i, j, actual, expected
-                        );
-                        return;
-                    }
+    /*
+        * Prints a message if there exists an incorrect entry in the given matrix.
+        */
+    static void check_if_valid(matrix_t C, size_t data_length) {
+        for (size_t i = 0; i < data_length; ++i) {
+            for (size_t j = 0; j < data_length; ++j) {
+                double actual = *mat_at_d(C, i, j);
+                double expected = 1.0 * data_length * i * j;
+                if (fabs(actual - expected) > 0.0001) {
+                    printf(
+                        "Validation failed for (i,j)=(%li, %li) with (%f, %f)\n",
+                        i, j, actual, expected
+                    );
+                    return;
                 }
             }
         }
-    =}
+    }
+=}
+
+reactor Manager(num_workers: int(20), data_length: size_t(1024)) {
 
     input[num_workers] more_work: {= work_item_t* =};
     input start: bool;
diff --git a/C/Savina/src/parallelism/NQueens.lf b/C/Savina/src/parallelism/NQueens.lf
@@ -50,14 +50,15 @@ target C {
     /// [[[end]]]
     logging: warn,
     cmake-include: "/lib/c/reactor-c/util/deque.cmake",
-    files: ["/lib/c/reactor-c/util/deque.h", "/lib/c/reactor-c/util/deque.c"],
+    files: ["/lib/c/reactor-c/util/deque.h", "/lib/c/reactor-c/util/deque.c", "../include/benchmark_runner.h"],
     fast: true
 };
 
 import BenchmarkRunner from "../BenchmarkRunner.lf";
 
 preamble {=
     #include "deque.h"
+    #include "benchmark_runner.h"
     typedef struct work_item_t {
         size_t *data;
         size_t depth;
@@ -69,7 +70,7 @@ preamble {=
      * Checks whether the board is a valid configuration of queens where no two queens are on the same
      * straight or diagonal line.
      */
-    int board_valid(size_t n, size_t *a) {
+    static int board_valid(size_t n, size_t *a) {
         size_t p = 0, q = 0;
         size_t x = 0, y = 0;
         for (x = 0; x < n; x++) {
@@ -88,7 +89,7 @@ preamble {=
      * Function to recursively solve the problem. Called inside the Worker reactor when depth is greater than
      * or equal to "threshold" (parameter passed in to the benchmark)
      */
-    size_t nqueens_kernel_seq(size_t *a, size_t depth, size_t size) {
+    static size_t nqueens_kernel_seq(size_t *a, size_t depth, size_t size) {
         if(size == depth) {
             return 1;
         }
diff --git a/C/Savina/src/parallelism/PiPrecision.lf b/C/Savina/src/parallelism/PiPrecision.lf
diff --git a/C/Savina/src/parallelism/RadixSort.lf b/C/Savina/src/parallelism/RadixSort.lf
diff --git a/C/Savina/src/parallelism/Trapezoidal.lf b/C/Savina/src/parallelism/Trapezoidal.lf
