Add example programs and a short README

examples/C/src/TOMACS/Consistency.lf

@@ -0,0 +1,42 @@
+/** This test has two coupled cycles. In this variant, both are a zero-delay cycles (ZDC). */
+target C {
+  timeout: 1 sec,
+  tracing: true
+}
+
+import PhysicalPlant from "Feedback.lf"
+
+reactor Controller {
+  input remote_update: double
+  input local_update: double
+  output control: double
+
+  state latest_control: double = 0.0
+  state first: bool = true
+
+  reaction(local_update, remote_update) {=
+  =}
+
+  reaction(local_update) -> control {=
+  =}
+}
+
+reactor Platform {
+  input update: double
+  output publish: double
+
+  c = new Controller()
+  p = new PhysicalPlant()
+  p.sensor -> c.local_update
+  p.sensor -> publish
+  update -> c.remote_update
+  c.control -> p.control
+}
+
+federated reactor {
+  p1 = new Platform()
+  p2 = new Platform()
+
+  p1.publish -> p2.update
+  p2.publish -> p1.update
+}

examples/C/src/TOMACS/Evaluation.lf

@@ -0,0 +1,41 @@
+target C {
+  timeout: 1 sec,
+  // tracing: true,
+  coordination: centralized
+}
+
+reactor A (offset:time = 0, period:time = 100 msec){
+  timer t(offset, period)
+  input in: int
+  output out: int
+
+  reaction (t) -> out {=
+    lf_set(out, 42);
+  =}
+
+  reaction(in) {=
+    instant_t logical_time = lf_time_logical_elapsed();
+    instant_t physical_time = lf_time_physical_elapsed();
+
+    lf_print("The lag is " PRINTF_TIME ".", physical_time - logical_time);
+  =}
+}
+
+reactor B {
+  input in: int
+  output out: int
+
+  reaction(in) -> out {=
+    lf_set(out, in->value);
+  =}
+}
+
+federated reactor at localhost {
+  a = new A(offset = 0, period = 10 msec)
+  b = new B()
+
+  a.out -> b.in
+  b.out -> a.in
+  // Replace preceeding line with the following to observe overhead introduced by coordinating
+  // b.out -> a.in after 0
+}

examples/C/src/TOMACS/Feedback.lf

@@ -0,0 +1,72 @@
+/** This test has two coupled cycles. In this variant, both are a zero-delay cycles (ZDC). */
+target C {
+  timeout: 1 sec,
+  tracing: true
+}
+
+reactor PhysicalPlant {
+  input control: double
+  output sensor: double
+  timer t(0, 100 ms)
+  state last_sensor_time: time = 0
+  state previous_sensor_time: time = 0
+  state count: int = 0
+
+  reaction(t) -> sensor {=
+    lf_set(sensor, 42);
+    self->previous_sensor_time = self->last_sensor_time;
+    self->last_sensor_time = lf_time_physical();
+  =}
+
+  reaction(control) {=
+    self->count++;
+    lf_print("Control input: %f", control->value);
+    instant_t control_time = lf_time_physical();
+    lf_print("Latency: " PRINTF_TIME ".", control_time - self->previous_sensor_time);
+    lf_print("Logical time: " PRINTF_TIME ".", lf_time_logical_elapsed());
+  =}
+}
+
+reactor Planner {
+  input request: double
+  output response: double
+
+  reaction(request) -> response {=
+    lf_sleep(MSEC(10));
+    lf_set(response, request->value);
+  =}
+}
+
+reactor Controller {
+  input sensor: double
+  output control: double
+
+  state latest_control: double = 0.0
+  state first: bool = true
+
+  output request_for_planning: double
+  input planning: double
+
+  reaction(sensor) -> control, request_for_planning {=
+    if (!self->first) {
+      lf_set(control, self->latest_control);
+    }
+    self->first = false;
+    lf_set(request_for_planning, sensor->value);
+  =}
+
+  reaction(planning) {=
+    self->latest_control = planning->value;
+  =}
+}
+
+federated reactor {
+  p = new PhysicalPlant()
+  c = new Controller()
+  pl = new Planner()
+
+  p.sensor -> c.sensor
+  c.request_for_planning -> pl.request
+  pl.response -> c.planning
+  c.control -> p.control
+}

examples/C/src/TOMACS/README.md

@@ -0,0 +1,3 @@
+# Example LF programs from "Strongly-Consistent Distributed Discrete-Event Systems"
+This folder contains the example LF programs found in the publication "Strongly-Consistent Distributed Discrete-Event
+Systems".