lf_types.h

Go to the documentation of this file.

 
#ifndef TYPES_H
#define TYPES_H
 
#include <stdbool.h>
 
#include "modal_models/modes.h" // Modal model support
#include "utils/pqueue.h"
#include "utils/pqueue_tag.h"
#include "lf_token.h"
#include "tag.h"
#include "vector.h"
 
#ifndef _SYS_TYPES_H
typedef unsigned short int ushort;
#endif
 
#define SCHED_ADAPTIVE 1
#define SCHED_GEDF_NP 2
#define SCHED_NP 3
 
/*
 * A struct representing a barrier in threaded
 * Lingua Franca programs that can prevent advancement
 * of tag if
 * 1- Number of requestors is larger than 0
 * 2- Value of horizon is not (FOREVER, 0)
 */
typedef struct _lf_tag_advancement_barrier {
  int requestors; // Used to indicate the number of
                  // requestors that have asked
                  // for a barrier to be raised
                  // on tag.
  tag_t horizon;  // If semaphore is larger than 0
                  // then the runtime should not
                  // advance its tag beyond the
                  // horizon.
} _lf_tag_advancement_barrier;
 
typedef enum { defer, drop, replace } lf_spacing_policy_t;
 
typedef enum { absent = false, present = true, unknown } port_status_t;
 
typedef enum { inactive = 0, queued, running } reaction_status_t;
 
typedef int trigger_handle_t;
 
#ifndef string
typedef char* string;
#else
#warning "string typedef has been previously given."
#endif
 
typedef pqueue_pri_t index_t;
 
typedef void (*reaction_function_t)(void*);
 
typedef struct trigger_t trigger_t;
 
typedef struct reaction_t reaction_t;
struct reaction_t {
  reaction_function_t function; // The reaction function. COMMON.
  void* self;                   // Pointer to a struct with the reactor's state. INSTANCE.
  int number;                   // The number of the reaction in the reactor (0 is the first reaction).
  index_t index;                // Inverse priority determined by dependency analysis. INSTANCE.
  size_t pos;                   // Current position in the priority queue. RUNTIME.
  reaction_t*
      last_enabling_reaction; // The last enabling reaction, or NULL if there is none. Used for optimization. INSTANCE.
  size_t num_outputs;         // Number of outputs that may possibly be produced by this function. COMMON.
  bool** output_produced;     // Array of pointers to booleans indicating whether outputs were produced. COMMON.
  int* triggered_sizes;       // Pointer to array of ints with number of triggers per output. INSTANCE.
  trigger_t*** triggers;      // Array of pointers to arrays of pointers to triggers triggered by each output. INSTANCE.
  reaction_status_t status;   // Indicator of whether the reaction is inactive, queued, or running. RUNTIME.
  interval_t deadline;        // Deadline relative to the time stamp for invocation of the reaction. INSTANCE.
  bool is_STP_violated; // Indicator of STP violation in one of the input triggers to this reaction. default = false.
                        // Value of True indicates to the runtime that this reaction contains trigger(s)
                        // that are triggered at a later logical time that was originally anticipated.
                        // Currently, this is only possible if logical
                        // connections are used in a decentralized federated
                        // execution. COMMON.
  reaction_function_t deadline_violation_handler; // Deadline violation handler. COMMON.
  reaction_function_t STP_handler;                // STP handler. Invoked when a trigger to this reaction
                                                  // was triggered at a later logical time than originally
                                                  // intended. Currently, this is only possible if logical
                                                  // connections are used in a decentralized federated
                                                  // execution. COMMON.
  bool is_an_input_reaction; // Indicates whether this reaction is a network input reaction of a federate. Default is
                             // false.
  size_t worker_affinity;    // The worker number of the thread that scheduled this reaction. Used
                             // as a suggestion to the scheduler.
  const 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 struct event_t event_t;
 
struct event_t {
  pqueue_tag_element_t base; // Elements of pqueue_tag. It contains tag of release and position in the priority queue.
  trigger_t* trigger;        // Associated trigger, NULL if this is a dummy event.
  lf_token_t* token;         // Pointer to the token wrapping the value.
#ifdef FEDERATED
  tag_t intended_tag; // The intended tag.
#endif
};
 
struct trigger_t {
  token_template_t tmplt;  // Type and token information (template is a C++ keyword).
  reaction_t** reactions;  // Array of pointers to reactions sensitive to this trigger.
  int number_of_reactions; // Number of reactions sensitive to this trigger.
  bool is_timer;           // True if this is a timer (a special kind of action), false otherwise.
  interval_t offset;       // Minimum delay of an action. For a timer, this is also the maximum delay.
  interval_t period; // Minimum interarrival time of an action. For a timer, this is also the maximal interarrival time.
  bool is_physical;  // Indicator that this denotes a physical action.
  tag_t last_tag;    // Tag of the last event that was scheduled for this action.
                     // This is only used for actions and will otherwise be NEVER.
  lf_spacing_policy_t policy; // Indicates which policy to use when an event is scheduled too early.
  port_status_t status;       // Determines the status of the port at the current logical time. Therefore, this
                              // value needs to be reset at the beginning of each logical time.
                              //
  // This status is especially needed for the distributed execution because the receiver logic
  // will need to know what it should do if it receives a message with 'intended tag = current
  // tag' from another federate.
  // - If status is 'unknown', it means that the federate has still no idea what the status of
  //   this port is and thus has refrained from executing any reaction that has that port as its
  //   input. This means that the receiver logic can directly inject the triggered reactions into
  //   the reaction queue at the current logical time.
  // - If the status is absent, it means that the federate has assumed that the port is 'absent'
  //   for the current logical time. Therefore, receiving a message with 'intended tag = current
  //   tag' is an error that should be handled, for example, as a violation of the STP offset in
  //   the decentralized 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.
  tag_t intended_tag;          // The amount of discrepency in logical time between the original intended
                               // trigger time of this trigger and the actual trigger time. This currently
                               // can only happen when logical connections are used using a decentralized coordination
                               // mechanism (@see https://github.com/icyphy/lingua-franca/wiki/Logical-Connections).
  instant_t physical_time_of_arrival; // The physical time at which the message has been received on the network
                                      // according to the local clock. Note: The physical_time_of_arrival is only passed
                                      // down one level of the hierarchy. Default: NEVER.
#endif
};
 
typedef struct allocation_record_t {
  void* allocated;
  struct allocation_record_t* next;
} allocation_record_t;
 
typedef struct environment_t environment_t;
 
typedef struct self_base_t {
  struct allocation_record_t* allocations;
  struct reaction_t* executing_reaction; // The currently executing reaction of the reactor.
  environment_t* environment;
#if !defined(LF_SINGLE_THREADED)
  void* reactor_mutex; // If not null, this is expected to point to an lf_mutex_t.
                       // It is not declared as such to avoid a dependence on platform.h.
#endif
#if defined(MODAL_REACTORS)
  reactor_mode_state_t _lf__mode_state; // The current mode (for modal models).
#endif
} self_base_t;
 
typedef struct {
  token_template_t tmplt; // Type and token information (template is a C++ keyword).
  bool is_present;
  trigger_t* trigger; // THIS HAS TO MATCH lf_action_internal_t
  self_base_t* parent;
  bool has_value;
  int source_id; // Used only for federated network input actions.
} lf_action_base_t;
 
typedef struct {
  trigger_t* trigger;
} lf_action_internal_t;
 
typedef struct {
  lf_sparse_io_record_t* sparse_record; // NULL if there is no sparse record.
  int destination_channel;              // -1 if there is no destination.
  int num_destinations;                 // The number of destination reactors this port writes to.
  self_base_t* source_reactor;          // Pointer to the self struct of the reactor that provides data to this port.
                                        // If this is an input, that reactor will normally be the container of the
                                        // output port that sends it data.
} lf_port_internal_t;
 
#endif