reactor_common.h

Go to the documentation of this file.

 
#ifndef REACTOR_COMMON_H
#define REACTOR_COMMON_H
 
#include "lf_types.h"
#include "environment.h"
#include "tag.h"
#include "pqueue.h"
#include "vector.h"
#include "util.h"
#include "modes.h"
#include "port.h"


typedef enum {
  CLI_TIME,   
  CLI_INT,    
  CLI_DOUBLE, 
  CLI_FLOAT,  
  CLI_BOOL,   
  CLI_STRING  
} lf_cli_type_t;

typedef struct {
  const char* name;        
  lf_cli_type_t type;      
  void* value;             
  bool* given;             
  const char* description; 
  bool is_width;           
} lf_cli_param_t;
 
extern lf_cli_param_t* _lf_cli_params;
extern int _lf_cli_params_count;


#define MIN_SLEEP_DURATION USEC(10)

 
// The following variables are defined in reactor_common.c and used in reactor.c,
// reactor_threaded.c, modes.c, and by the code generator.
extern bool _lf_normal_termination;
extern unsigned int _lf_number_of_workers;
extern int default_argc;
extern const char** default_argv;
extern instant_t duration;
extern bool fast;
extern bool keepalive_specified;
 
#ifdef FEDERATED_DECENTRALIZED
extern interval_t lf_fed_STA_offset;
#endif
 
// The following is defined by the code generator.
extern struct allocation_record_t* _lf_reactors_to_free;


index_t lf_combine_deadline_and_level(interval_t deadline, int level);

void lf_create_environments(void);

void lf_free(struct allocation_record_t** head);

event_t* lf_get_new_event(environment_t* env);

void lf_recycle_event(environment_t* env, event_t* e);

void lf_replace_token(event_t* event, lf_token_t* token);

void lf_set_default_command_line_options(void);

void _lf_start_time_step(environment_t* env);

void lf_terminate_execution(environment_t* env);

void _lf_initialize_trigger_objects();

void termination(void);

void _lf_trigger_reaction(environment_t* env, reaction_t* reaction, int worker_number);

bool _lf_initialize_timer(environment_t* env, trigger_t* timer);

bool _lf_initialize_timers(environment_t* env);

void _lf_trigger_startup_reactions(environment_t* env);

void _lf_trigger_shutdown_reactions(environment_t* env);

event_t* _lf_create_dummy_events(environment_t* env, tag_t tag);

trigger_handle_t _lf_schedule_at_tag(environment_t* env, trigger_t* trigger, tag_t tag, lf_token_t* token);

trigger_handle_t _lf_schedule_token(environment_t* env, void* action, interval_t extra_delay, lf_token_t* token);

trigger_handle_t _lf_schedule_copy(environment_t* env, void* action, interval_t offset, void* value, size_t length);

trigger_handle_t _lf_insert_reactions_for_trigger(environment_t* env, trigger_t* trigger, lf_token_t* token);

void _lf_advance_tag(environment_t* env, tag_t next_tag);

void _lf_pop_events(environment_t* env);

void _lf_invoke_reaction(environment_t* env, reaction_t* reaction, int worker);

void schedule_output_reactions(environment_t* env, reaction_t* reaction, int worker);

int process_args(int argc, const char* argv[]);

int process_user_args(int argc, const char* argv[], int* newargc, const char** newargv);

void usage(int argc, const char* argv[]);

void initialize_global();
 
#endif