clock-sync.h

Go to the documentation of this file.

 
#ifndef CLOCK_SYNC_H
#define CLOCK_SYNC_H
 
#include "low_level_platform.h"
 
// Clock synchronization defaults to performing clock synchronization only at initialization.
#define LF_CLOCK_SYNC_OFF 1
#define LF_CLOCK_SYNC_INIT 2
#define LF_CLOCK_SYNC_ON 3
 
#ifndef LF_CLOCK_SYNC
#define LF_CLOCK_SYNC LF_CLOCK_SYNC_INIT
#endif
 
#ifndef _LF_CLOCK_SYNC_EXCHANGES_PER_INTERVAL
#define _LF_CLOCK_SYNC_EXCHANGES_PER_INTERVAL 10
#endif
 
#ifndef _LF_CLOCK_SYNC_ATTENUATION
#define _LF_CLOCK_SYNC_ATTENUATION 10
#endif
 
#ifndef _LF_CLOCK_SYNC_COLLECT_STATS
#define _LF_CLOCK_SYNC_COLLECT_STATS true
#endif
 
#define CLOCK_SYNC_GUARD_BAND USEC(100)
 
typedef struct socket_stat_t {
  instant_t remote_physical_clock_snapshot_T1;     // T1 in PTP. The first snapshot of the physical
                                                   // clock of the remote device (the RTI).
  instant_t local_physical_clock_snapshot_T2;      // T2 in PTP. The first snapshot of the physical
                                                   // clock of the local device (the federate).
  interval_t local_delay;                          // T3 - T2. Estimated delay between a consecutive
                                                   // receive and send on the socket for one byte.
  int received_T4_messages_in_current_sync_window; // Checked against _LF_CLOCK_SYNC_EXCHANGES_PER_INTERVAL
                                                   // Must be reset to 0 every time it reaches the threshold.
  interval_t history;                              // A history of clock synchronization data. For AVG
                                                   // strategy, this is a running partially computed average.
 
 
 
  interval_t network_stat_round_trip_delay_max; // Maximum estimated delay between the local socket and the
                                                // remote socket.
  int network_stat_sample_index;                // Current index of network_stat_samples
 
  interval_t clock_synchronization_error_bound; // A bound on the differences between this federate's clock and
                                                // the remote clock.
  // Note: The following array should come last because g++ will not allow
  // designated initialization (e.g., .network_stat_sample_index = 0) out of
  // order and we do not want to (and cannot) initialize this array statically
  interval_t network_stat_samples[_LF_CLOCK_SYNC_EXCHANGES_PER_INTERVAL]; // Samples gathered during a clock sync
                                                                          // period
} socket_stat_t;
 
#ifdef _LF_CLOCK_SYNC_COLLECT_STATS
struct lf_stat_ll;
 
void update_socket_stat(struct socket_stat_t* socket_stat, long long network_delay,
                        long long clock_synchronization_error);
 
struct lf_stat_ll calculate_socket_stat(struct socket_stat_t* socket_stat);
#endif // _LF_CLOCK_SYNC_COLLECT_STATS
 
void reset_socket_stat(struct socket_stat_t* socket_stat);
 
uint16_t setup_clock_synchronization_with_rti(void);
 
void synchronize_initial_physical_clock_with_rti(int* rti_socket_TCP);
 
int handle_T1_clock_sync_message(unsigned char* buffer, int socket, instant_t t2);
 
void handle_T4_clock_sync_message(unsigned char* buffer, int socket, instant_t r4);
 
void* listen_to_rti_UDP_thread(void* args);
 
int create_clock_sync_thread(lf_thread_t* thread_id);
 
void clock_sync_add_offset(instant_t* t);
 
void clock_sync_subtract_offset(instant_t* t);
 
void clock_sync_set_constant_bias(interval_t offset);
 
#endif // CLOCK_SYNC_H