ROOT-Sim.h

Go to the documentation of this file.

#pragma once

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>
#include <float.h>
#include <limits.h>
#include <argp.h>

#ifdef INIT
#undef INIT
#endif
#define INIT    0

typedef double simtime_t;

#define INFTY DBL_MAX

extern unsigned int n_prc_tot;

__attribute((weak))
extern struct argp model_argp;

// Expose to the application level the rollbackable numerical library
double Random(void);
int RandomRange(int min, int max);
int RandomRangeNonUniform(int x, int min, int max);
double Expent(double mean);
double Normal(void);
double Gamma(int ia);
double Poisson(void);
int Zipf(double skew, int limit);

// ROOT-Sim core API
extern void (*ScheduleNewEvent)(unsigned int receiver, simtime_t timestamp, unsigned int event_type, void *event_content, unsigned int event_size);
extern void SetState(void *new_state);

/*********************************/
/********TOPOLOGY*LIBRARY*********/
/*********************************/

enum _topology_geometry_t {
    TOPOLOGY_GEOMETRY_OFFSET = 1000,            
    TOPOLOGY_HEXAGON = TOPOLOGY_GEOMETRY_OFFSET,
    TOPOLOGY_SQUARE,                            
    TOPOLOGY_RING,                              
    TOPOLOGY_BIDRING,                           
    TOPOLOGY_TORUS,                             
    TOPOLOGY_STAR,                  
    TOPOLOGY_GRAPH,                             
};

typedef enum _direction_t {
    DIRECTION_E =   0,  
    DIRECTION_W =   1,  

    DIRECTION_N =   2,  
    DIRECTION_S =   3,  

    DIRECTION_NE =  2,  
    DIRECTION_SW =  3,  
    DIRECTION_NW =  4,  
    DIRECTION_SE =  5,  

    DIRECTION_INVALID = UINT_MAX    
} direction_t;

enum _topology_type_t{
    TOPOLOGY_OBSTACLES, 
    TOPOLOGY_COSTS,     
    TOPOLOGY_PROBABILITIES  
};

__attribute((weak)) extern struct _topology_settings_t{
    const char * const topology_path;
    const enum _topology_type_t type;           
    const enum _topology_geometry_t default_geometry;   
    const unsigned out_of_topology;             
    const bool write_enabled;               
}topology_settings;

double      GetValueTopology(unsigned from, unsigned to);

void        SetValueTopology(unsigned from, unsigned to, double value);

// finds a receiver with probabilities weighted on neighbours link (works only for topology type TOPOLOGY_PROBABILITIES)
unsigned int    FindReceiver    (void);

// returns the count of regions involved in the topology (can be less than n_prc_tot)
unsigned int    RegionsCount    (void);

// returns the maximum count of neighbours this region has, this is made to simplify direction handling (need to explain better xxx)
unsigned int    DirectionsCount (void);

// returns the actual count of neighbours this region has (if this is called from a region on the edge of the topology
unsigned int    NeighboursCount (unsigned int region);

// Returns DIRECTION_INVALID if a movement is not possible according to the given topology
unsigned int    GetReceiver (unsigned int from, direction_t direction, bool reachable);

// this returns the next hop to reach region to following a minimum cost path: it's far less costly than to recompute a new path with ComputeMinTour()
unsigned int FindReceiverToward (unsigned int to);

// Function to return a list of LP IDs to be visited in order to reach a given cell with minimum cost.
// -1.0 is returned is no path is available else the total cost is returned
double      ComputeMinTour  (unsigned int source, unsigned int dest, unsigned int result[RegionsCount()]);

/*********************************/
/************ABM*LIBRARY**********/
/*********************************/

typedef unsigned long long agent_t;

__attribute((weak)) extern struct _abm_settings_t{
    const unsigned neighbour_data_size;
    const unsigned traverse_handler;
    const bool keep_history;
} abm_settings;

int         GetNeighbourInfo    (direction_t i, unsigned int *region_id, void **data_p);
void            TrackNeighbourInfo  (void *neighbour_data);

bool            IterAgents      (agent_t *agent_p);
unsigned        CountAgents     (void);

agent_t         SpawnAgent      (unsigned user_data_size);
void            KillAgent       (agent_t agent);

void*           DataAgent       (agent_t agent, unsigned *data_size_p);

void            ScheduleNewLeaveEvent   (simtime_t time, unsigned int event_type, agent_t agent);

unsigned        CountVisits     (const agent_t agent);
void            GetVisit        (const agent_t agent, unsigned *region_p, unsigned *event_type_p, unsigned i);
void            SetVisit        (const agent_t agent, unsigned region, unsigned event_type, unsigned i);
void            EnqueueVisit        (agent_t agent, unsigned region, unsigned event_type);
void            AddVisit        (agent_t agent, unsigned region, unsigned event_type, unsigned i);
void            RemoveVisit     (agent_t agent, unsigned i);

unsigned        CountPastVisits     (const agent_t agent);
void            GetPastVisit        (const agent_t agent, unsigned *region_p, unsigned *event_type_p, simtime_t *time_p, unsigned i);


/************* CAPABILITIES ************/

enum capability_t
{
    /* Capabilities always enabled */
    CAP_SCHEDULER,
    CAP_CKTRM_MODE,
    CAP_LPS_DISTRIBUTION,
    CAP_STATS,
    CAP_STATE_SAVING,
    CAP_THREADS,
    CAP_LPS,
    CAP_OUTPUT_DIR,
    CAP_P,
    CAP_GVT,
    CAP_GVT_SNAPSHOT_CYCLES,
    CAP_SEED,
    CAP_VERBOSE,

    /* Optional capabilities */
    CAP_NPWD,
    CAP_FULL,
    CAP_INC,
    CAP_A,
    CAP_SIMULATION_TIME,
    CAP_DETERMINISTIC_SEED,
    CAP_SERIAL,
    CAP_CORE_BINDING,
    CAP_PREEMPTION,
    CAP_ECS,
    CAP_LINUX_MODULES,
    CAP_LP_REBINDING,
    CAP_MPI,
    CAP_SILENT
};

struct capability_info_t {
    enum capability_t capability;
    union {
        const char *output_dir;  
        int scheduler;       
        int gvt_time_period;     
        int simulation_time;     
        int lps_distribution;    
        int state_saving;    
        int checkpointing;   
        int ckpt_period;     
        int termination_mode;    
        int verbose;         
        int stats;       
        int lps;         
        uint64_t seed;       
    };
};

bool CapabilityAvailable(enum capability_t which, struct capability_info_t *info);