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).
  scheduling_node_state_t state;    // State of the scheduling node.
  uint16_t* upstream;               // Array of upstream scheduling node ids.
  interval_t* upstream_delay;       // Minimum delay on connections from upstream scheduling nodes.
                                    // Here, NEVER encodes no delay. 0LL is a microstep delay.
  int num_upstream;                 // Size of the array of upstream scheduling nodes and delays.
  uint16_t* downstream;             // Array of downstream scheduling node ids.
  int num_downstream;               // Size of the array of downstream scheduling nodes.
  execution_mode_t mode;            // FAST or REALTIME.
  minimum_delay_t* min_delays;      // Array of minimum delays from upstream nodes, not including this node.
  size_t num_min_delays;            // Size of min_delays array.
  int flags;                        // Or 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
  int32_t number_of_scheduling_nodes;
 
  // 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;
 
  // 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);
 
bool is_in_zero_delay_cycle(scheduling_node_t* node);
 
bool is_in_cycle(scheduling_node_t* node);
 
void update_min_delays_upstream(scheduling_node_t* node);
 
void invalidate_min_delays_upstream(scheduling_node_t* node);
 
void free_scheduling_nodes(scheduling_node_t** scheduling_nodes, uint16_t number_of_scheduling_nodes);
 
#endif // RTI_COMMON_H
#endif // STANDALONE_RTI || LF_ENCLAVES