Merge pull request #55 from lf-lang/c-separate-gen-files

Changes to accommodate refactoring of C runtime

Author: lhstrh

C/Savina/src/BenchmarkRunner.lf

@@ -34,6 +34,11 @@ target C;
  * @author Matt Chorlian
  * @author Arthur Deng
  */
+
+preamble {=
+    #include <stdio.h>
+=}
+
 reactor BenchmarkRunner(num_iterations:int(12)) {
 
     /** Signal to start execution. Set this input from a startup reaction in the main reactor. */

C/Savina/src/concurrency/Banking.lf

@@ -61,19 +61,22 @@
     threading: false,
     /// [[[end]]]
     files: ["../include/PseudoRandom.h",
+            "../include/benchmark_runner.h",
             "/lib/c/reactor-c/util/deque.h",
             "/lib/c/reactor-c/util/deque.c"],
+    cmake-include: ["../include/deque.cmake"],
     logging: warn,
     fast: true
 };
 
 import BenchmarkRunner from "../BenchmarkRunner.lf";
 
 preamble {=
+    #include "benchmark_runner.h"
     #include "PseudoRandom.h"
-    #include "deque.c"
+    #include "deque.h"
     #include <float.h>
-    long seed = 123456;
+    extern long seed;
     typedef deque_t message_queue_t;
     typedef struct CreditMessage {
         size_t recipient;
@@ -84,6 +87,10 @@ preamble {=
 
 reactor Teller(numAccounts:int(1000), numBankings:int(50000)) {
 
+    preamble {=
+        long seed = 123456;
+    =}
+
     state message_queues : {=message_queue_t*=};
     state random_gen : {=PseudoRandom *=};
     input start: bool;

C/Savina/src/concurrency/BoundedBuffer.lf

@@ -33,7 +33,9 @@ target C {
     /// [[[end]]]
     files: ["/lib/c/reactor-c/util/deque.h",
             "/lib/c/reactor-c/util/deque.c",
+            "../include/benchmark_runner.h",
             "../include/PseudoRandom.h"],
+    cmake-include: ["../include/deque.cmake"],
     flags: "-lm",
     logging: "warn",
     fast: true
@@ -45,32 +47,33 @@ import BenchmarkRunner from "../BenchmarkRunner.lf";
 preamble {=
     #include "PseudoRandom.h"
     #include <math.h>
-
-    double processItem(double curTerm, size_t cost) {
-        double res = curTerm;
-
-        PseudoRandom random;
-        random.mValue = cost;
-
-        if(cost > 0) {
-            for(size_t i = 0; i < cost; i++) {
-                for(size_t j = 0; j < 100; j++) {
-                    res += log(fabs(nextDouble(&random)) + 0.01);
-                }
-            }
-        } else {
-            res += log(fabs(nextDouble(&random)) + 0.01);
-        }
-
-        return res;
-    }
+    #include "deque.h"
+    #include "benchmark_runner.h"
+    double processItem(double curTerm, size_t cost);
 =}
 
 
 reactor ManagerReactor(bufferSize: size_t(50), numProducers: size_t(40), numConsumers: size_t(40)) {
 
     preamble {=
-        #include "deque.c"
+        double processItem(double curTerm, size_t cost) {
+            double res = curTerm;
+
+            PseudoRandom random;
+            random.mValue = cost;
+
+            if(cost > 0) {
+                for(size_t i = 0; i < cost; i++) {
+                    for(size_t j = 0; j < 100; j++) {
+                        res += log(fabs(nextDouble(&random)) + 0.01);
+                    }
+                }
+            } else {
+                res += log(fabs(nextDouble(&random)) + 0.01);
+            }
+
+            return res;
+        }
     =}
 
     input start: bool;

C/Savina/src/concurrency/CigaretteSmoker.lf

@@ -70,19 +70,18 @@ target C {
     ]]] */
     threading: false,
     /// [[[end]]]
-    files: "../include/PseudoRandom.h",
+    files: ["../include/PseudoRandom.h", "../include/benchmark_runner.h"],
     fast: true
 };
 
 import BenchmarkRunner from "../BenchmarkRunner.lf";
 
+preamble {=
+    #include "PseudoRandom.h"
+=}
 
 reactor ArbiterReactor(numRounds:size_t(1000), numSmokers:size_t(200)) {
 
-    preamble {=
-        #include "PseudoRandom.h"
-    =}
-
     state roundsSoFar: size_t(0);
     state random: PseudoRandom*;
 

C/Savina/src/concurrency/Dictionary.lf

@@ -47,6 +47,7 @@ preamble {=
     #include <map>
     #include <vector>
     #include <memory>
+    #include <random>
     enum class AccessType {
       Read,
       Write
@@ -151,10 +152,6 @@ reactor DictionaryImpl(numWorkers: size_t(20)) {
 
 reactor Worker(bank_index: size_t(0), numMessagesPerWorker: size_t(10000), writePercentage: int(10)) {
 
-    preamble {=
-        #include <random>
-    =}
-
     state messageCount: size_t(0);
     state random: std::minstd_rand;
 

C/Savina/src/concurrency/SleepingBarber.lf

@@ -53,7 +53,8 @@ target C {
     ]]] */
     threading: false,
     /// [[[end]]]
-    files: ["/lib/c/reactor-c/util/deque.h", "/lib/c/reactor-c/util/deque.c", "../include/PseudoRandom.h"]
+    files: ["/lib/c/reactor-c/util/deque.h", "/lib/c/reactor-c/util/deque.c", "../include/PseudoRandom.h"],
+    cmake-include: ["../include/deque.cmake"]
 };
 
 import BenchmarkRunner from "../BenchmarkRunner.lf";
@@ -62,8 +63,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 +173,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;

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)) {

C/Savina/src/include/PseudoRandom.h

@@ -15,37 +15,37 @@ typedef struct PseudoRandom {
 /**
  * Initialize the random number generator to the specified seed.
  */
-void initPseudoRandom(struct PseudoRandom* random, long seed) {
+static void initPseudoRandom(struct PseudoRandom* random, long seed) {
     random->mValue = seed;
 }
 
 /**
  * Return a random number between 0 and 65535
  */
-long nextLong(struct PseudoRandom *random) {
+static long nextLong(struct PseudoRandom *random) {
     random->mValue = ((random->mValue * 1309) + 13849) & 65535;
     return random->mValue;
 }
 
 /**
  * Return a random number between 0 and 65535
  */
-int nextInt(struct PseudoRandom *random) {
+static int nextInt(struct PseudoRandom *random) {
     return (int)nextLong(random);
 }
 
 /**
  * Return a random number between 1.0/65536
  * and 1.0.
  */
-double nextDouble(struct PseudoRandom *random) {
+static double nextDouble(struct PseudoRandom *random) {
     return 1.0 / (nextLong(random) + 1);
 }
 
 /**
  * Return a random number between 0 and exclusive_max - 1.
  */
-int nextIntEMax(struct PseudoRandom *random, int exclusive_max) {
+static int nextIntEMax(struct PseudoRandom *random, int exclusive_max) {
     return nextInt(random) % exclusive_max;
 }
 

C/Savina/src/include/benchmark_runner.h

@@ -0,0 +1,3 @@
+void printBenchmarkInfo(char* benchmarkId);
+
+void printSystemInfo();

C/Savina/src/include/deque.cmake

@@ -0,0 +1 @@
+target_sources(${LF_MAIN_TARGET} PRIVATE deque.c)