adding errors to reactor-uc

lf-lang · Sep 12, 2024 · 17102a9 · 17102a9
1 parent 6565cb8
commit 17102a9
Show file tree

Hide file tree

Showing 9 changed files with 92 additions and 25 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -20,7 +20,8 @@ else ()
 endif()
 file(GLOB SOURCES "src/*.c")
 message(${SOURCES})
-add_library(reactor-uc STATIC ${SOURCES})
+add_library(reactor-uc STATIC ${SOURCES}
+        include/reactor-uc/errors.h)
 target_compile_options(reactor-uc PRIVATE -Wall -Wextra -pedantic -Werror)
 add_compile_options (-fdiagnostics-color=always)
 add_compile_definitions(POSIX)

diff --git a/examples/hello_action.c b/examples/hello_action.c
@@ -19,7 +19,7 @@ struct MyAction {
 
   int values[3];
   int value_size;
-  int current_value_ready;
+  int current_value_read;
   int current_value_write;
 };
 
@@ -29,6 +29,8 @@ struct MyReactor {
   struct MyStartup startup;
   struct MyAction my_action;
 
+  int state;
+
   Reaction *reactions[1];
   Trigger *triggers[2];
 };
@@ -45,21 +47,37 @@ void MyStartup_ctor(MyStartup* self, Reactor *parent, Reaction *effects) {
 
 void MyAction_ctor(struct MyAction *self, Reactor *parent, Reaction** effects, Reaction** sources) {
   self->value_size = 3;
-  self->current_value_ready = 0;
+  self->current_value_read = 0;
   self->current_value_write = 0;
+  self->values[0] = 0;
+  self->values[1] = 0;
+  self->values[2] = 0;
   LogicalAction_ctor(&self->super, parent, effects, 1, sources, 1);
 }
 
 int MyReactor_0_body(Reaction *untyped_reaction) {
   // reactor
   struct MyReactor *self = (struct MyReactor*) untyped_reaction->parent->typed;
   struct MyAction* my_action = &self->my_action;
+  struct MyStartup* my_startup = &self->startup;
 
   // Start User Code
 
-  printf("Hello World\n");
-  LogicalAction_schedule(&my_action->super, SEC(1));
+  int value_scheduled = 0;
+  if (my_action->super.super.is_present) {
+    value_scheduled = lf_action_get(my_action);
+  }
+
+  printf("Logical Action Scheduled Value w: %i, i: %i v: %i \n",
+         my_action->current_value_write,
+         my_action->current_value_read,
+         value_scheduled);
 
+  TriggerReply reply = lf_schedule_value(my_action, MSEC(self->state), value_scheduled + 1);
+
+  if (reply == SCHEDULED) {
+    self->state *= 0.9;
+  }
 
   // End User Code
   return 0;
@@ -89,6 +107,8 @@ void MyReactor_ctor(MyReactor* self, Environment *env) {
   // constructing reactor
   Reactor_ctor(&self->super, env, self, NULL, 0, self->reactions, 1, self->triggers, 1);
 
+  self->state = 5000;
+
   // reaction list
   self->reactions[0] = (Reaction *)&self->reaction_0.super;
 

diff --git a/include/reactor-uc/builtin_triggers.h b/include/reactor-uc/builtin_triggers.h
@@ -17,11 +17,12 @@ void Startup_ctor(Startup *self, Reactor *parent, Reaction **effects, size_t eff
 struct LogicalAction {
   Trigger super;
 
-  void (*schedule)(LogicalAction *self, interval_t in);
+  TriggerReply (*schedule)(LogicalAction *self, interval_t in);
 };
 
 void LogicalAction_ctor(LogicalAction *self, Reactor *parent, Reaction **effects, size_t effects_size,
                         Reaction **sources, size_t source_size);
-void LogicalAction_schedule(LogicalAction *self, interval_t in);
+
+TriggerReply LogicalAction_schedule(LogicalAction *self, interval_t in);
 
 #endif
diff --git a/include/reactor-uc/macros.h b/include/reactor-uc/macros.h
@@ -1,19 +1,41 @@
 #ifndef REACTOR_UC_MACROS_H
 #define REACTOR_UC_MACROS_H
 
-#define max(left, right)                                                                                                      \
+#include "errors.h"
+
+#define max(left, right)                                                                                               \
   ({                                                                                                                   \
-    __typeof__(left) _left = (left);                                                                                            \
-    __typeof__(right) _right = (right);                                                                                            \
-    _left > _right ? _left : _right;                                                                                                 \
+    __typeof__(left) _left = (left);                                                                                   \
+    __typeof__(right) _right = (right);                                                                                \
+    _left > _right ? _left : _right;                                                                                   \
   })
 
 #define lf_set(port, input)                                                                                            \
-  port->value = input;                                                                                                 \
-  port->super.trigger_reactions(&port->super);
-#define lf_get(port) port->value
-#define lf_schedule(logical_action, interval_time, value)                                                              \
-  logical_action->values[logical_action->current_value_write++] = value;                                               \
-  logical_action->current_
+  ({                                                                                                                   \
+    port->value = input;                                                                                               \
+    port->super.trigger_reactions(&port->super);                                                                       \
+  })
+
+#define lf_get(port) ({ port->value; })
+
+#define lf_schedule_value(logical_action, interval_time, value)                                                        \
+  ({                                                                                                                   \
+    if ((logical_action->current_value_write + 1) % logical_action->value_size ==                                      \
+        logical_action->current_value_read) {                                                                          \
+      NOTSCHEDULED;                                                                                                    \
+    }                                                                                                                  \
+    logical_action->values[logical_action->current_value_write] = value;                                               \
+    logical_action->current_value_write = (logical_action->current_value_write + 1) % logical_action->value_size;      \
+    LogicalAction_schedule(&logical_action->super, interval_time);                                                     \
+  })
+
+#define lf_schedule(logical_action, interval_time) ({ LogicalAction_schedule(&logical_action->super, interval_time); })
+
+#define lf_action_get(logical_action)                                                                                  \
+  ({                                                                                                                   \
+    __typeof__(logical_action->values[0]) temp = logical_action->values[logical_action->current_value_read];           \
+    logical_action->current_value_read = (logical_action->current_value_read + 1) % logical_action->value_size;        \
+    temp;                                                                                                              \
+  })
 
 #endif // REACTOR_UC_MACROS_H
diff --git a/include/reactor-uc/queues.h b/include/reactor-uc/queues.h
@@ -15,11 +15,12 @@
 
 typedef struct EventQueue EventQueue;
 typedef struct ReactionQueue ReactionQueue;
+typedef enum { INSERTED, FULL } QueueReply;
 
 struct EventQueue {
   // methods
   tag_t (*next_tag)(EventQueue *self);
-  void (*insert)(EventQueue *self, Event event);
+  QueueReply (*insert)(EventQueue *self, Event event);
   Event (*pop)(EventQueue *self);
   bool (*empty)(EventQueue *self);
   void (*heapify)(EventQueue *self, size_t idx);

diff --git a/include/reactor-uc/trigger.h b/include/reactor-uc/trigger.h
@@ -8,12 +8,13 @@
 typedef struct Trigger Trigger;
 
 typedef enum { ACTION, TIMER, BUILTIN, INPUT, OUTPUT } TriggerType;
+typedef enum { SCHEDULED, NOTSCHEDULED } TriggerReply;
 
 typedef void (*Trigger_update_value)(Trigger *self);
 
 struct Trigger {
   // methods
-  void (*schedule_at)(Trigger *, tag_t);
+  TriggerReply (*schedule_at)(Trigger *, tag_t);
   void (*register_effect)(Trigger *, Reaction *);
   void (*register_source)(Trigger *, Reaction *);
 

diff --git a/src/builtin_triggers.c b/src/builtin_triggers.c
@@ -12,10 +12,11 @@ void Startup_ctor(Startup *self, Reactor *parent, Reaction **effects, size_t eff
 
 void LogicalAction_ctor(LogicalAction *self, Reactor *parent, Reaction **effects, size_t effects_size,
                         Reaction **sources, size_t source_size) {
+  self->schedule = LogicalAction_schedule;
   Trigger_ctor((Trigger *)self, BUILTIN, parent, effects, effects_size, sources, source_size, NULL);
 }
 
-void LogicalAction_schedule(LogicalAction *self, interval_t in) {
+TriggerReply LogicalAction_schedule(LogicalAction *self, interval_t in) {
   tag_t next_tag = lf_delay_tag(self->super.parent->env->current_tag, in);
-  self->super.schedule_at(&self->super, next_tag);
+  return self->super.schedule_at(&self->super, next_tag);
 }
diff --git a/src/queues.c b/src/queues.c
@@ -14,8 +14,13 @@ tag_t EventQueue_next_tag(EventQueue *self) {
   return FOREVER_TAG;
 }
 
-void EventQueue_insert(EventQueue *self, Event event) {
-  assert(self->size_ < EVENT_QUEUE_SIZE);
+QueueReply EventQueue_insert(EventQueue *self, Event event) {
+  assert(self->size_ < EVENT_QUEUE_SIZE); // debug check
+
+  if (self->size_ >= EVENT_QUEUE_SIZE) {
+    return FULL;
+  }
+
   if (self->size_ == 0) {
     self->array_[0] = event;
     self->size_++;
@@ -26,6 +31,8 @@ void EventQueue_insert(EventQueue *self, Event event) {
       self->heapify(self, i);
     }
   }
+
+  return INSERTED;
 }
 
 void EventQueue_heapify(EventQueue *self, size_t idx) {
@@ -58,6 +65,8 @@ Event EventQueue_pop(EventQueue *self) {
   return ret;
 }
 
+bool EventQueue_full(EventQueue *self) { return self->size_ >= EVENT_QUEUE_SIZE; }
+
 bool EventQueue_empty(EventQueue *self) { return self->size_ == 0; }
 void EventQueue_ctor(EventQueue *self) {
   self->insert = EventQueue_insert;

diff --git a/src/trigger.c b/src/trigger.c
@@ -1,10 +1,20 @@
 #include "reactor-uc/trigger.h"
 #include "reactor-uc/environment.h"
+#include "reactor-uc/errors.h"
 #include "reactor-uc/util.h"
 
-void Trigger_schedule_at(Trigger *self, tag_t tag) {
+TriggerReply Trigger_schedule_at(Trigger *self, tag_t tag) {
   Event event = {.tag = tag, .trigger = self};
-  self->parent->env->scheduler.event_queue_.insert(&self->parent->env->scheduler.event_queue_, event);
+
+  EventQueue *queue = &self->parent->env->scheduler.event_queue_;
+
+  QueueReply reply = queue->insert(queue, event);
+
+  if (reply == FULL) {
+    return NOTSCHEDULED;
+  }
+
+  return SCHEDULED;
 }
 
 void Trigger_register_effect(Trigger *self, Reaction *reaction) {
@@ -28,6 +38,7 @@ void Trigger_ctor(Trigger *self, TriggerType type, Reactor *parent, Reaction **e
   self->sources_size = sources_size;
   self->sources_registered = 0;
   self->update_value = update_value_func;
+  self->is_present = false;
 
   self->schedule_at = Trigger_schedule_at;
   self->register_effect = Trigger_register_effect;