rti_common.h

Go to the documentation of this file.

#if defined STANDALONE_RTI || defined LF_ENCLAVES
#ifndef RTI_COMMON_H
#define RTI_COMMON_H
 
#include <errno.h> // Defines perror(), errno
#include <assert.h>
#include "low_level_platform.h" // Platform-specific types and functions
#include "util.h"               // Defines print functions (e.g., lf_print).
#include "tag.h"                // Time-related types and functions.
#include "tracepoint.h"         // Tracing related functions

typedef enum execution_mode_t { FAST, REALTIME } execution_mode_t;

typedef enum scheduling_node_state_t {
  NOT_CONNECTED,
  GRANTED,
  PENDING
} scheduling_node_state_t;

typedef struct minimum_delay_t {
  int id;
  tag_t min_delay;
} minimum_delay_t;

typedef struct scheduling_node_t {
  uint16_t id;
  tag_t completed;
  tag_t last_granted;
  tag_t last_provisionally_granted;
  tag_t next_event;
  tag_t last_DNET;
  scheduling_node_state_t state;
  uint16_t* immediate_upstreams;
  interval_t* immediate_upstream_delays;
  uint16_t num_immediate_upstreams;
  uint16_t* immediate_downstreams;
  uint16_t num_immediate_downstreams;
  execution_mode_t mode;
  int flags;
} scheduling_node_t;

typedef struct rti_common_t {
  scheduling_node_t** scheduling_nodes;
  uint16_t number_of_scheduling_nodes;
  tag_t* min_delays;
  tag_t max_stop_tag;
  int num_scheduling_nodes_handling_stop;
  bool tracing_enabled;
  bool dnet_disabled;
  lf_mutex_t* mutex;
} rti_common_t;
 
typedef struct {
  tag_t tag;
  bool is_provisional;
} tag_advance_grant_t;

void initialize_rti_common(rti_common_t* rti_common);

void _logical_tag_complete(scheduling_node_t* e, tag_t completed);

void initialize_scheduling_node(scheduling_node_t* e, uint16_t id);

void notify_downstream_advance_grant_if_safe(scheduling_node_t* e, bool visited[]);

void notify_tag_advance_grant(scheduling_node_t* e, tag_t tag);

void notify_advance_grant_if_safe(scheduling_node_t* e);

void notify_provisional_tag_advance_grant(scheduling_node_t* e, tag_t tag);

tag_advance_grant_t tag_advance_grant_if_safe(scheduling_node_t* e);

void update_scheduling_node_next_event_tag_locked(scheduling_node_t* e, tag_t next_event_tag);

tag_t earliest_future_incoming_message_tag(scheduling_node_t* e);

tag_t eimt_strict(scheduling_node_t* e);

void update_min_delays();

tag_t get_dnet_candidate(tag_t next_event_tag, tag_t minimum_delay);

tag_t downstream_next_event_tag(scheduling_node_t* node, uint16_t node_sending_new_net_id);

void notify_downstream_next_event_tag(scheduling_node_t* e, tag_t tag);

bool is_in_zero_delay_cycle(scheduling_node_t* node);

bool is_in_cycle(scheduling_node_t* node);

void invalidate_min_delays();

void free_scheduling_nodes(scheduling_node_t** scheduling_nodes, uint16_t number_of_scheduling_nodes);
 
#endif // RTI_COMMON_H
#endif // STANDALONE_RTI || LF_ENCLAVES