federate.h

Go to the documentation of this file.

 
#ifndef FEDERATE_H
#define FEDERATE_H
 
#include <stdbool.h>
 
#include "tag.h"
#include "lf_types.h"
#include "environment.h"
#include "low_level_platform.h"
#include "socket_common.h"
 
#ifndef ADVANCE_MESSAGE_INTERVAL
#define ADVANCE_MESSAGE_INTERVAL MSEC(10)
#endif

// Data types

typedef struct federate_instance_t {
  int socket_TCP_RTI;

  lf_thread_t RTI_socket_listener;

  size_t number_of_inbound_p2p_connections;

  lf_thread_t* inbound_socket_listeners;

  size_t number_of_outbound_p2p_connections;

  int sockets_for_inbound_p2p_connections[NUMBER_OF_FEDERATES];

  int sockets_for_outbound_p2p_connections[NUMBER_OF_FEDERATES];

  lf_thread_t inbound_p2p_handling_thread_id;

  int server_socket;

  int server_port;

  tag_t last_TAG;

  bool is_last_TAG_provisional;

  bool has_upstream;

  bool has_downstream;

  bool received_stop_request_from_rti;

  tag_t last_sent_LTC;

  tag_t last_sent_NET;

  tag_t last_skipped_NET;

  bool received_any_DNET;

  tag_t last_DNET;

  instant_t min_delay_from_physical_action_to_federate_output;
 
#ifdef FEDERATED_DECENTRALIZED
  lf_thread_t staaSetter;
#endif
} federate_instance_t;
 
#ifdef FEDERATED_DECENTRALIZED
typedef struct staa_t {
  lf_action_base_t** actions;
  size_t STAA;
  size_t num_actions;
} staa_t;
#endif

typedef struct federation_metadata_t {
  const char* federation_id;
  char* rti_host;
  int rti_port;
  char* rti_user;
} federation_metadata_t;

typedef enum parse_rti_code_t { SUCCESS, INVALID_PORT, INVALID_HOST, INVALID_USER, FAILED_TO_PARSE } parse_rti_code_t;

// Global variables

extern lf_mutex_t lf_outbound_socket_mutex;

extern lf_cond_t lf_port_status_changed;

// Public functions (in alphabetical order)

void lf_connect_to_federate(uint16_t remote_federate_id);

void lf_connect_to_rti(const char* hostname, int port_number);

void lf_create_server(int specified_port);

void lf_enqueue_port_absent_reactions(environment_t* env);

void* lf_handle_p2p_connections_from_federates(void* ignored);

void lf_latest_tag_confirmed(tag_t tag_to_send);

parse_rti_code_t lf_parse_rti_addr(const char* rti_addr);

void lf_reset_status_fields_on_input_port_triggers(void);

int lf_send_message(int message_type, unsigned short port, unsigned short federate, const char* next_destination_str,
                    size_t length, unsigned char* message);

void lf_send_neighbor_structure_to_RTI(int socket_TCP_RTI);

tag_t lf_send_next_event_tag(environment_t* env, tag_t tag, bool wait_for_reply);

void lf_send_port_absent_to_federate(environment_t* env, interval_t additional_delay, unsigned short port_ID,
                                     unsigned short fed_ID);

int lf_send_stop_request_to_rti(tag_t stop_tag);

int lf_send_tagged_message(environment_t* env, interval_t additional_delay, int message_type, unsigned short port,
                           unsigned short federate, const char* next_destination_str, size_t length,
                           unsigned char* message);

void lf_set_federation_id(const char* fid);
 
#ifdef FEDERATED_DECENTRALIZED
void lf_spawn_staa_thread(void);
#endif

void lf_stall_advance_level_federation(environment_t* env, size_t level);

void lf_stall_advance_level_federation_locked(size_t level);

void lf_synchronize_with_other_federates(void);

bool lf_update_max_level(tag_t tag, bool is_provisional);
 
#ifdef FEDERATED_DECENTRALIZED
instant_t lf_wait_until_time(tag_t tag);
#endif // FEDERATED_DECENTRALIZED
 
#endif // FEDERATE_H