tracepoint.h

Go to the documentation of this file.

#ifdef RTI_TRACE
#define LF_TRACE
#endif
 
#ifndef TRACEPOINT_H
#define TRACEPOINT_H
 
#include "lf_types.h"
#include <stdio.h>
 
#ifdef FEDERATED
#include "net_common.h"
#endif // FEDERATED
 
#include "trace_types.h"
 
#ifdef LF_TRACE
 
#include "trace.h"

typedef struct trace_record_t {
  trace_event_t event_type;

  void* pointer;

  int src_id;

  int dst_id;

  instant_t logical_time;

  microstep_t microstep;

  instant_t physical_time;

  trigger_t* trigger;

  interval_t extra_delay;
} trace_record_t;

void call_tracepoint(int event_type, void* reactor, tag_t tag, int worker, int src_id, int dst_id,
                     instant_t* physical_time, trigger_t* trigger, interval_t extra_delay);

int _lf_register_trace_event(void* pointer1, void* pointer2, _lf_trace_object_t type, char* description);

int register_user_trace_event(void* self, char* description);

#define tracepoint_reaction_starts(env, reaction, worker)                                                              \
  call_tracepoint(reaction_starts, reaction->self, env->current_tag, worker, worker, reaction->number, NULL, NULL,     \
                  reaction->deadline)

#define tracepoint_reaction_ends(env, reaction, worker)                                                                \
  call_tracepoint(reaction_ends, reaction->self, env->current_tag, worker, worker, reaction->number, NULL, NULL,       \
                  reaction->deadline)

void tracepoint_schedule(environment_t* env, trigger_t* trigger, interval_t extra_delay);

void tracepoint_user_event(void* self, char* description);

void tracepoint_user_value(void* self, char* description, long long value);

#define tracepoint_worker_wait_starts(env, worker)                                                                     \
  call_tracepoint(worker_wait_starts, NULL, env->current_tag, worker, worker, -1, NULL, NULL, 0)

#define tracepoint_worker_wait_ends(env, worker)                                                                       \
  call_tracepoint(worker_wait_ends, NULL, env->current_tag, worker, worker, -1, NULL, NULL, 0)

#define tracepoint_scheduler_advancing_time_starts(env)                                                                \
  call_tracepoint(scheduler_advancing_time_starts, NULL, env->current_tag, -1, -1, -1, NULL, NULL, 0);

#define tracepoint_scheduler_advancing_time_ends(env)                                                                  \
  call_tracepoint(scheduler_advancing_time_ends, NULL, env->current_tag, -1, -1, -1, NULL, NULL, 0)

#define tracepoint_reaction_deadline_missed(env, reaction, worker)                                                     \
  call_tracepoint(reaction_deadline_missed, reaction->self, env->current_tag, worker, worker, reaction->number, NULL,  \
                  NULL, 0)

void lf_tracing_check_version();

 
#if defined(FEDERATED) || defined(LF_ENCLAVES)

void tracepoint_federate_to_rti(trace_event_t event_type, int fed_id, tag_t* tag);

void tracepoint_federate_from_rti(trace_event_t event_type, int fed_id, tag_t* tag);

void tracepoint_federate_to_federate(trace_event_t event_type, int fed_id, int partner_id, tag_t* tag);

void tracepoint_federate_from_federate(trace_event_t event_type, int fed_id, int partner_id, tag_t* tag);
 
#else
static inline void tracepoint_federate_to_rti(trace_event_t event_type, int fed_id, tag_t* tag) {
  (void)event_type;
  (void)fed_id;
  (void)tag;
}
static inline void tracepoint_federate_from_rti(trace_event_t event_type, int fed_id, tag_t* tag) {
  (void)event_type;
  (void)fed_id;
  (void)tag;
}
static inline void tracepoint_federate_to_federate(trace_event_t event_type, int fed_id, int partner_id, tag_t* tag) {
  (void)event_type;
  (void)fed_id;
  (void)partner_id;
  (void)tag;
}
static inline void tracepoint_federate_from_federate(trace_event_t event_type, int fed_id, int partner_id, tag_t* tag) {
  (void)event_type;
  (void)fed_id;
  (void)partner_id;
  (void)tag;
}
#endif // FEDERATED

 
#ifdef RTI_TRACE

void tracepoint_rti_to_federate(trace_event_t event_type, int fed_id, tag_t* tag);

void tracepoint_rti_from_federate(trace_event_t event_type, int fed_id, tag_t* tag);
 
#else
static inline void tracepoint_rti_to_federate(trace_event_t event_type, int fed_id, tag_t* tag) {
  (void)event_type;
  (void)fed_id;
  (void)tag;
}
static inline void tracepoint_rti_from_federate(trace_event_t event_type, int fed_id, tag_t* tag) {
  (void)event_type;
  (void)fed_id;
  (void)tag;
}
#endif // RTI_TRACE
 
#else
typedef struct trace_t trace_t;
static inline int register_user_trace_event(void* self, char* description) {
  (void)self;
  (void)description;
  return 0;
}
static inline void tracepoint_schedule(environment_t* env, trigger_t* trigger, interval_t extra_delay) {
  (void)env;
  (void)trigger;
  (void)extra_delay;
}
static inline void tracepoint_user_event(void* self, char* description) {
  (void)self;
  (void)description;
}
static inline void tracepoint_user_value(void* self, char* description, long long value) {
  (void)self;
  (void)description;
  (void)value;
}
static inline void tracepoint_rti_to_federate(trace_event_t event_type, int fed_id, tag_t* tag) {
  (void)event_type;
  (void)fed_id;
  (void)tag;
}
static inline void tracepoint_rti_from_federate(trace_event_t event_type, int fed_id, tag_t* tag) {
  (void)event_type;
  (void)fed_id;
  (void)tag;
}
static inline void tracepoint_federate_to_rti(trace_event_t event_type, int fed_id, tag_t* tag) {
  (void)event_type;
  (void)fed_id;
  (void)tag;
}
static inline void tracepoint_federate_from_rti(trace_event_t event_type, int fed_id, tag_t* tag) {
  (void)event_type;
  (void)fed_id;
  (void)tag;
}
static inline void tracepoint_federate_to_federate(trace_event_t event_type, int fed_id, int partner_id, tag_t* tag) {
  (void)event_type;
  (void)fed_id;
  (void)partner_id;
  (void)tag;
}
static inline void tracepoint_federate_from_federate(trace_event_t event_type, int fed_id, int partner_id, tag_t* tag) {
  (void)event_type;
  (void)fed_id;
  (void)partner_id;
  (void)tag;
}

// The following is defined in trace.h, so ask Doxygen to ignore this.
 
static inline void lf_tracing_global_init(char* process_name, char* process_names, int process_id,
                                          int max_num_local_threads) {
  (void)process_name;
  (void)process_names;
  (void)process_id;
  (void)max_num_local_threads;
}
static inline void lf_tracing_global_shutdown() {}
static inline void lf_tracing_set_start_time(int64_t start_time) { (void)start_time; }

 
#define tracepoint_reaction_starts(env, reaction, worker)                                                              \
  while (0) {                                                                                                          \
    (void)env;                                                                                                         \
    (void)reaction;                                                                                                    \
    (void)worker;                                                                                                      \
  }
#define tracepoint_reaction_ends(env, reaction, worker)                                                                \
  while (0) {                                                                                                          \
    (void)env;                                                                                                         \
    (void)reaction;                                                                                                    \
    (void)worker;                                                                                                      \
  }
#define tracepoint_worker_wait_starts(env, worker)                                                                     \
  while (0) {                                                                                                          \
    (void)env;                                                                                                         \
    (void)worker;                                                                                                      \
  }
#define tracepoint_worker_wait_ends(env, worker)                                                                       \
  while (0) {                                                                                                          \
    (void)env;                                                                                                         \
    (void)worker;                                                                                                      \
  }
#define tracepoint_scheduler_advancing_time_starts(env)                                                                \
  while (0) {                                                                                                          \
    (void)env;                                                                                                         \
  }
#define tracepoint_scheduler_advancing_time_ends(env)                                                                  \
  while (0) {                                                                                                          \
    (void)env;                                                                                                         \
  }
#define tracepoint_reaction_deadline_missed(env, reaction, worker)                                                     \
  while (0) {                                                                                                          \
    (void)env;                                                                                                         \
    (void)reaction;                                                                                                    \
    (void)worker;                                                                                                      \
  }
 
#endif // LF_TRACE
#endif // TRACEPOINT_H