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 "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.
    // Binary encoding of the branches that this reaction has upstream in the dependency graph. INSTANCE.
    unsigned long long chain_id;
    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 {
    instant_t time;           // Time of release.
    trigger_t* trigger;       // Associated trigger, NULL if this is a dummy event.
    size_t pos;               // Position in the priority queue.
    lf_token_t* token;        // Pointer to the token wrapping the value.
    bool is_dummy;            // Flag to indicate whether this event is merely a placeholder or an actual event.
#ifdef FEDERATED
    tag_t intended_tag;       // The intended tag.
#endif
    event_t* next;            // Pointer to the next event lined up in superdense time.
};
 
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.
    event_t* last;            // Pointer to the last event that was scheduled for this action.
    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;
} 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