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, // The scheduling node has not connected.
  GRANTED,       // Most recent MSG_TYPE_NEXT_EVENT_TAG has been granted.
  PENDING        // Waiting for upstream scheduling nodes.
} scheduling_node_state_t;

typedef struct minimum_delay_t {
  int id;          // ID of the upstream node.
  tag_t min_delay; // Minimum delay from upstream.
} minimum_delay_t;

typedef struct scheduling_node_t {
  uint16_t id;                      // ID of this scheduling node.
  tag_t completed;                  // The largest logical tag completed by the scheduling node
                                    // (or NEVER if no LTC has been received).
  tag_t last_granted;               // The maximum TAG that has been granted so far (or NEVER if none granted)
  tag_t last_provisionally_granted; // The maximum PTAG that has been provisionally granted (or NEVER if none granted)
  tag_t next_event;                 // Most recent NET received from the scheduling node (or NEVER if none received).
  tag_t last_DNET;                  // Most recent DNET.
  scheduling_node_state_t state;    // State of the scheduling node.
  uint16_t* immediate_upstreams;    // Array of immediate upstream scheduling node ids.
  interval_t* immediate_upstream_delays; // Minimum delay on connections from immdediate upstream scheduling nodes.
                                         // Here, NEVER encodes no delay. 0LL is a microstep delay.
  uint16_t num_immediate_upstreams;      // Size of the array of immediate upstream scheduling nodes and delays.
  uint16_t* immediate_downstreams;       // Array of immediate downstream scheduling node ids.
  uint16_t num_immediate_downstreams;    // Size of the array of immediate downstream scheduling nodes.
  execution_mode_t mode;                 // FAST or REALTIME.
  int flags;                             // One of IS_IN_ZERO_DELAY_CYCLE, IS_IN_CYCLE
} scheduling_node_t;

typedef struct rti_common_t {
  // The scheduling nodes.
  scheduling_node_t** scheduling_nodes;
 
  // Number of scheduling nodes
  uint16_t number_of_scheduling_nodes;
 
  // Matrix of minimum delays between pairs of nodes.
  // Rows represent upstream nodes and Columns represent downstream nodes.
  // FOREVER_TAG means there is no path, and ZERO_TAG means there is no delay.
  // This could be NULL if the matrix is not being used, so accesses should test for NULL first.
  tag_t* min_delays;
 
  // RTI's decided stop tag for the scheduling nodes
  tag_t max_stop_tag;
 
  // Number of scheduling nodes handling stop
  int num_scheduling_nodes_handling_stop;
 
  // Boolean indicating that tracing is enabled.
  bool tracing_enabled;
 
  // Boolean indicating that DNET is enabled.
  bool dnet_disabled;
 
  // The RTI mutex for making thread-safe access to the shared state.
  lf_mutex_t* mutex;
} rti_common_t;
 
typedef struct {
  tag_t tag;           // NEVER if there is no tag advance grant.
  bool is_provisional; // True for PTAG, false for TAG.
} 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