trace.h

Go to the documentation of this file.

 
#ifdef RTI_TRACE
#define LF_TRACE
#endif
 
#ifndef TRACE_H
#define TRACE_H
 
#include "lf_types.h"
#include <stdio.h>
 
#ifdef FEDERATED
#include "net_common.h"
#endif // FEDERATED
 
typedef enum
{
    reaction_starts,
    reaction_ends,
    reaction_deadline_missed,
    schedule_called,
    user_event,
    user_value,
    worker_wait_starts,
    worker_wait_ends,
    scheduler_advancing_time_starts,
    scheduler_advancing_time_ends,
    federated, // Everything above this is tracing federated interactions.
    // Sending messages
    send_ACK,
    send_TIMESTAMP,
    send_NET,
    send_LTC,
    send_STOP_REQ,
    send_STOP_REQ_REP,
    send_STOP_GRN,
    send_FED_ID,
    send_PTAG,
    send_TAG,
    send_REJECT,
    send_RESIGN,
    send_PORT_ABS,
    send_CLOSE_RQ,
    send_TAGGED_MSG,
    send_P2P_TAGGED_MSG,
    send_MSG,
    send_P2P_MSG,
    send_ADR_AD,
    send_ADR_QR,
    // Receiving messages
    receive_ACK,
    receive_TIMESTAMP,
    receive_NET,
    receive_LTC,
    receive_STOP_REQ,
    receive_STOP_REQ_REP,
    receive_STOP_GRN,
    receive_FED_ID,
    receive_PTAG,
    receive_TAG,
    receive_REJECT,
    receive_RESIGN,
    receive_PORT_ABS,
    receive_CLOSE_RQ,
    receive_TAGGED_MSG,
    receive_P2P_TAGGED_MSG,
    receive_MSG,
    receive_P2P_MSG,
    receive_ADR_AD,
    receive_ADR_QR,
    receive_UNIDENTIFIED,
    NUM_EVENT_TYPES
} trace_event_t;
 
#ifdef LF_TRACE
 
static const char *trace_event_names[] = {
    "Reaction starts",
    "Reaction ends",
    "Reaction deadline missed",
    "Schedule called",
    "User-defined event",
    "User-defined valued event",
    "Worker wait starts",
    "Worker wait ends",
    "Scheduler advancing time starts",
    "Scheduler advancing time ends",
    "Federated marker",
    // Sending messages
    "Sending ACK",
    "Sending TIMESTAMP",
    "Sending NET",
    "Sending LTC",
    "Sending STOP_REQ",
    "Sending STOP_REQ_REP",
    "Sending STOP_GRN",
    "Sending FED_ID",
    "Sending PTAG",
    "Sending TAG",
    "Sending REJECT",
    "Sending RESIGN",
    "Sending PORT_ABS",
    "Sending CLOSE_RQ",
    "Sending TAGGED_MSG",
    "Sending P2P_TAGGED_MSG",
    "Sending MSG",
    "Sending P2P_MSG",
    "Sending ADR_AD",
    "Sending ADR_QR",
    // Receiving messages
    "Receiving ACK",
    "Receiving TIMESTAMP",
    "Receiving NET",
    "Receiving LTC",
    "Receiving STOP_REQ",
    "Receiving STOP_REQ_REP",
    "Receiving STOP_GRN",
    "Receiving FED_ID",
    "Receiving PTAG",
    "Receiving TAG",
    "Receiving REJECT",
    "Receiving RESIGN",
    "Receiving PORT_ABS",
    "Receiving CLOSE_RQ",
    "Receiving TAGGED_MSG",
    "Receiving P2P_TAGGED_MSG",
    "Receiving MSG",
    "Receiving P2P_MSG",
    "Receiving ADR_AD",
    "Receiving ADR_QR",
    "Receiving UNIDENTIFIED",
};
 
// FIXME: Target property should specify the capacity of the trace buffer.
#define TRACE_BUFFER_CAPACITY 2048
 
#define TRACE_OBJECT_TABLE_SIZE 1024
 
typedef struct trace_record_t {
    trace_event_t event_type;
    void* pointer;  // pointer identifying the record, e.g. to self struct for a reactor.
    int src_id;     // The ID number of the source (e.g. worker or federate) or -1 for no ID number.
    int dst_id;     // The ID number of the destination (e.g. reaction or federate) or -1 for no ID number.
    instant_t logical_time;
    microstep_t microstep;
    instant_t physical_time;
    trigger_t* trigger;
    interval_t extra_delay;
} trace_record_t;
 
typedef enum {
    trace_reactor,   // Self struct.
    trace_trigger,   // Timer or action (argument to schedule()).
    trace_user       // User-defined trace object.
} _lf_trace_object_t;
 
typedef struct object_description_t object_description_t;
struct object_description_t {
    void* pointer;      // Pointer to the reactor self struct or other identifying pointer.
    void* trigger;      // Pointer to the trigger (action or timer) or other secondary ID, if any.
    _lf_trace_object_t type;  // The type of trace object.
    char* description; // A NULL terminated string.
};
typedef struct trace_t {
    trace_record_t** _lf_trace_buffer;
    int* _lf_trace_buffer_size;
 
    int _lf_number_of_trace_buffers;
 
    int _lf_trace_stop;
 
    FILE* _lf_trace_file;
 
    char *filename;
 
    object_description_t _lf_trace_object_descriptions[TRACE_OBJECT_TABLE_SIZE];
    int _lf_trace_object_descriptions_size;
 
    bool _lf_trace_header_written;
 
    environment_t* env;
} trace_t;
 
 
trace_t* trace_new(environment_t *env, const char *filename);
 
void trace_free(trace_t *trace);
 
 
int _lf_register_trace_event(trace_t* trace, void* pointer1, void* pointer2, _lf_trace_object_t type, char* description);
 
int register_user_trace_event(void* self, char* description);
 
void start_trace(trace_t* trace);
 
void tracepoint(
        trace_t* trace,
        trace_event_t 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,
        bool is_interval_start
);
 
void tracepoint_reaction_starts(trace_t* trace, reaction_t* reaction, int worker);
 
void tracepoint_reaction_ends(trace_t* trace, reaction_t* reaction, int worker);
 
void tracepoint_schedule(trace_t* trace, 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);
 
void tracepoint_worker_wait_starts(trace_t* trace, int worker);
 
void tracepoint_worker_wait_ends(trace_t* trace, int worker);
 
void tracepoint_scheduler_advancing_time_starts(trace_t* trace);
 
void tracepoint_scheduler_advancing_time_ends(trace_t* trace);
 
void tracepoint_reaction_deadline_missed(trace_t* trace, reaction_t *reaction, int worker);
 
void stop_trace(trace_t* trace);
void stop_trace_locked(trace_t* trace);
 
 
#if defined(FEDERATED) || defined(LF_ENCLAVES)
 
void tracepoint_federate_to_rti(trace_t* trace, trace_event_t event_type, int fed_id, tag_t* tag);
 
void tracepoint_federate_from_rti(trace_t* trace, trace_event_t event_type, int fed_id, tag_t* tag);
 
void tracepoint_federate_to_federate(trace_t* trace, trace_event_t event_type, int fed_id, int partner_id, tag_t *tag);
 
void tracepoint_federate_from_federate(trace_t* trace, trace_event_t event_type, int fed_id, int partner_id, tag_t *tag);
 
#else
#define tracepoint_federate_to_rti(...);
#define tracepoint_federate_from_rti(...);
#define tracepoint_federate_to_federate(...);
#define tracepoint_federate_from_federate(...);
#endif // FEDERATED
 
 
#ifdef RTI_TRACE
 
void tracepoint_rti_to_federate(trace_t* trace, trace_event_t event_type, int fed_id, tag_t* tag);
 
void tracepoint_rti_from_federate(trace_t* trace, trace_event_t event_type, int fed_id, tag_t* tag);
 
#else
#define tracepoint_rti_to_federate(...);
#define tracepoint_rti_from_federate(...) ;
#endif // RTI_TRACE
 
#else
typedef struct trace_t trace_t;
 
// empty definition in case we compile without tracing
#define _lf_register_trace_event(...)
#define register_user_trace_event(...)
#define tracepoint(...)
#define tracepoint_reaction_starts(...)
#define tracepoint_reaction_ends(...)
#define tracepoint_schedule(...)
#define tracepoint_user_event(...)
#define tracepoint_user_value(...)
#define tracepoint_worker_wait_starts(...)
#define tracepoint_worker_wait_ends(...)
#define tracepoint_scheduler_advancing_time_starts(...);
#define tracepoint_scheduler_advancing_time_ends(...);
#define tracepoint_reaction_deadline_missed(...);
#define tracepoint_federate_to_rti(...);
#define tracepoint_federate_from_rti(...);
#define tracepoint_federate_to_federate(...) ;
#define tracepoint_federate_from_federate(...) ;
#define tracepoint_rti_to_federate(...);
#define tracepoint_rti_from_federate(...) ;
 
#define start_trace(...)
#define stop_trace(...)
#define stop_trace_locked(...)
#define trace_new(...) NULL
#define trace_free(...)
 
 
#endif // LF_TRACE
#endif // TRACE_H