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 scheduler types as integers. This way we can conditionally
 * include/exclude code with the preprocessor with
 * #if SCHEDULER == SCHED_ADAPTIVE etc
 * This means that `lf_types.h` MUST be included before doing any preprocessing
 * on SCHEDULER compile def.
 */

#define SCHED_ADAPTIVE 1

#define SCHED_GEDF_NP 2

#define SCHED_NP 3

typedef struct lf_tag_advancement_barrier_t {
  int requestors;

  tag_t horizon;
} lf_tag_advancement_barrier_t;

typedef enum { defer, drop, replace, update } 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*);
 
/* Trigger struct representing an output, timer, action, or input. */
typedef struct trigger_t trigger_t;
 
typedef struct reaction_t reaction_t;

struct reaction_t {
  reaction_function_t function;

  void* self;

  int number;

  index_t index;

  size_t pos;

  reaction_t* last_enabling_reaction;

  size_t num_outputs;

  bool** output_produced;

  int* triggered_sizes;

  trigger_t*** triggers;

  reaction_status_t status;

  interval_t deadline;

  bool is_STP_violated;

  reaction_function_t deadline_violation_handler;

  reaction_function_t STP_handler;

  bool is_an_input_reaction;

  size_t worker_affinity;

  const char* name;

  reactor_mode_t* mode;
};

typedef struct event_t event_t;

struct event_t {
  pqueue_tag_element_t base;

  trigger_t* trigger;

  lf_token_t* token;
 
#ifdef FEDERATED
  tag_t intended_tag;
#endif
};

struct trigger_t {
  token_template_t tmplt;

  reaction_t** reactions;

  int number_of_reactions;

  bool is_timer;

  interval_t offset;

  interval_t period;

  bool is_physical;

  tag_t last_tag;

  lf_spacing_policy_t policy;

  port_status_t status;

  reactor_mode_t* mode;
 
#ifdef FEDERATED
  tag_t last_known_status_tag;

  tag_t intended_tag;

  instant_t physical_time_of_arrival;
#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;

  environment_t* environment;

  char* name;

  char* full_name;

  self_base_t* parent;
 
#if !defined(LF_SINGLE_THREADED)
  void* reactor_mutex;
#endif
 
#if defined(MODAL_REACTORS)
  reactor_mode_state_t _lf__mode_state;
#endif
} self_base_t;

typedef struct {
  token_template_t tmplt;

  bool is_present;

  trigger_t* trigger;

  self_base_t* parent;

  bool has_value;

  int source_id;
} 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