Modal Models

.github/workflows/ci.yml

@@ -33,15 +33,15 @@ jobs:
 
   lf-gedf-np:
     needs: fetch-lf
-    uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@c-new-scheduler
+    uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master
     with:
       runtime-ref: ${{ github.ref }}
       compiler-ref: ${{ needs.fetch-lf.outputs.ref }}
       scheduler: GEDF_NP
 
   lf-gedf-np-ci:
     needs: fetch-lf
-    uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@c-new-scheduler
+    uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master
     with:
       runtime-ref: ${{ github.ref }}
       compiler-ref: ${{ needs.fetch-lf.outputs.ref }}

core/reactor.c

@@ -158,6 +158,13 @@ void print_snapshot() {
  *  worker number does not make sense (e.g., the caller is not a worker thread).
  */
 void _lf_trigger_reaction(reaction_t* reaction, int worker_number) {
+#ifdef MODAL_REACTORS
+    // Check if reaction is disabled by mode inactivity
+    if (!_lf_mode_is_active(reaction->mode)) {
+        DEBUG_PRINT("Suppressing downstream reaction %s due inactivity of mode %s.", reaction->name, reaction->mode->name);
+        return; // Suppress reaction by preventing entering reaction queue
+    }
+#endif
     // Do not enqueue this reaction twice.
     if (reaction->status == inactive) {
         DEBUG_PRINT("Enqueing downstream reaction %s, which has level %lld.",
@@ -233,6 +240,11 @@ int _lf_do_step() {
         reaction->status = inactive;
     }
 
+#ifdef MODAL_REACTORS
+    // At the end of the step, perform mode transitions
+    _lf_handle_mode_changes();
+#endif
+
     // No more reactions should be blocked at this point.
     //assert(pqueue_size(blocked_q) == 0);
 

core/reactor.h

@@ -247,6 +247,21 @@ do { \
 #endif
 
 
+/**
+ * Sets the next mode of a modal reactor. Same as SET for outputs, only
+ * the last value will have effect if invoked multiple times.
+ * Works only in reactions with the target mode declared as effect.
+ *
+ * @param mode The target mode to set for activation.
+ */
+#ifdef MODAL_REACTORS
+#define _LF_SET_MODE(mode) \
+do { \
+    self->_lf__mode_state.next_mode = mode; \
+    self->_lf__mode_state.mode_change = _lf_##mode##_change_type; \
+} while(0)
+#endif
+
 /**
  * Macro for extracting the deadline from the index of a reaction.
  * The reaction queue is sorted according to this index, and the
@@ -442,6 +457,45 @@ typedef struct token_present_t {
     bool reset_is_present; // True to set is_present to false after calling done_using().
 } token_present_t;
 
+
+#ifdef MODAL_REACTORS
+/** Typedef for reactor_mode_t struct, used for representing a mode. */
+typedef struct reactor_mode_t reactor_mode_t;
+/** Typedef for reactor_mode_state_t struct, used for storing modal state of reactor and/or its relation to enclosing modes. */
+typedef struct reactor_mode_state_t reactor_mode_state_t;
+/** Typedef for mode_state_variable_reset_data_t struct, used for storing data for resetting state variables nested in modes. */
+typedef struct mode_state_variable_reset_data_t mode_state_variable_reset_data_t;
+
+/** A struct to represent a single mode instace in a reactor instance. */
+struct reactor_mode_t {
+    reactor_mode_state_t* state;    // Pointer to a struct with the reactor's mode state. INSTANCE.
+    string name;                    // Name of this mode.
+    instant_t deactivation_time;    // Time when the mode was left.
+};
+/** A struct to store state of the modes in a reactor instance and/or its relation to enclosing modes. */
+struct reactor_mode_state_t {
+    reactor_mode_t* parent_mode;    // Pointer to the next enclosing mode (if exsits).
+    reactor_mode_t* initial_mode;   // Pointer to the initial mode.
+    reactor_mode_t* active_mode;    // Pointer to the currently active mode.
+    reactor_mode_t* next_mode;      // Pointer to the next mode to activate at the end of this step (if set).
+    char mode_change;               // A mode change type flag (0: no change, 1: reset, 2: history).
+};
+/** A struct to store data for resetting state variables nested in modes. */
+struct mode_state_variable_reset_data_t {
+    reactor_mode_t* mode;           // Pointer to the enclosing mode.
+    void* target;                   // Pointer to the target variable.
+    void* source;                   // Pointer to the data source.
+    size_t size;                    // The size of the variable.
+};
+#else
+/*
+ * Reactions and triggers must have a mode pointer to set up connection to enclosing modes,
+ * also when they are precompiled without modal reactors in order to later work in modal reactors.
+ * Hence define mode type as void in the absence of modes to treat mode pointer as void pointers for that time being.
+ */
+typedef void reactor_mode_t;
+#endif
+
 /**
  * Reaction activation record to push onto the reaction queue.
  * Some of the information in this struct is common among all instances
@@ -487,6 +541,8 @@ struct reaction_t {
     char* name;                 // If logging is set to LOG or higher, then this will
                                 // point to the full name of the reactor followed by
     							// the reaction number.
+    reactor_mode_t* mode;       // The enclosing mode of this reaction (if exists).
+                                // If enclosed in multiple, this will point to the innermost mode.
 };
 
 /** Typedef for event_t struct, used for storing activation records. */
@@ -537,6 +593,8 @@ struct trigger_t {
                               //   coordination. 
                               // - Finally, if status is 'present', then this is an error since multiple 
                               //   downstream messages have been produced for the same port for the same logical time.
+    reactor_mode_t* mode;     // The enclosing mode of this reaction (if exists).
+                              // If enclosed in multiple, this will point to the innermost mode.
 #ifdef FEDERATED
     tag_t last_known_status_tag;        // Last known status of the port, either via a timed message, a port absent, or a
                                         // TAG from the RTI.
@@ -717,6 +775,13 @@ void terminate_execution(void);
  */
 bool _lf_trigger_shutdown_reactions(void);
 
+/**
+ * Function (to be code generated) to handle mode changes.
+ */
+#ifdef MODAL_REACTORS
+void _lf_handle_mode_changes();
+#endif
+
 /**
  * Create a new token and initialize it.
  * The value pointer will be NULL and the length will be 0.