event_t *scheduler_add_callback(uint64_t clock, call_t *c, callback_t callback, void *arg) {
event_t *event;
if ((scheduler_get_end()) && (clock > scheduler_get_end())) {
return NULL;
}
if ((event = (event_t *) mem_fs_alloc(mem_event)) == NULL) {
fprintf(stderr, "scheduler.c: add callback node %d : ERROR when allocating event\n", c->node);
return NULL;
}
event->clock = clock;
event->u.cb.call.entity = c->entity;
event->u.cb.call.node = c->node;
event->u.cb.call.from = c->from;
event->u.cb.callback = callback;
event->u.cb.arg = arg;
event->priority = PRIORITY_CALLBACK;
scheduler_add_event(event);
/* if worldsens mode save this event as rdv */
if (ws_count)
worldsens_add_rdv(clock, PRIORITY_CALLBACK);
return event;
}
/* ************************************************** */
void hadas_insert(void *s, void *key, void *data){
hadas_t *hadas = (hadas_t *) s;
hadas_elt_t *elt;
unsigned long hash = hadas->hash(key) % HASH_SIZE;
if ((elt = (hadas_elt_t *) mem_fs_alloc(mem_hadas_elts)) == NULL) {
return;
}
elt->key = key;
elt->data = data;
elt->next = NULL;
elt->previous = NULL;
if (hadas->elts[hash] == NULL) {
hadas->elts[hash] = elt;
} else {
elt->next = hadas->elts[hash];
hadas->elts[hash]->previous = elt;
hadas->elts[hash] = elt;
}
hadas->size++;
}
static void worldsens_add_rdv(ws_time clock, int priority) {
ws_rdv_t *rdv;
if ((rdv = (ws_rdv_t *) mem_fs_alloc(mem_ws_rdv)) == NULL) {
return;
}
rdv->clock = clock;
rdv->priority = priority;
sodas_insert(ws_rdvs, rdv, rdv);
}
void scheduler_add_mobility(uint64_t clock) {
event_t *event;
if ((event = (event_t *) mem_fs_alloc(mem_event)) == NULL) {
return;
}
event->clock = clock;
event->priority = PRIORITY_MOBILITY;
scheduler_add_event(event);
}
/* ************************************************** */
void scheduler_add_birth(uint64_t clock, nodeid_t id) {
event_t *event;
if ((event = (event_t *) mem_fs_alloc(mem_event)) == NULL) {
return;
}
event->clock = clock;
event->priority = PRIORITY_BIRTH;
event->u.nodeid = id;
scheduler_add_event(event);
}
double get_random_double_range(double min, double max) {
uniform_args_t *args;
if ((args = (uniform_args_t *) mem_fs_alloc(mem_rng)) == NULL) {
printf("Error: Error while allocating memory for rng. Exiting!\n");
exit(-1);
}
args->a = min;
args->b = max;
double result = get_random_double_gsl((void *)DEFAULT_RNG, UNIFORM, args);
mem_fs_dealloc(mem_rng, args);
return result;
}
int get_random_integer(void) {
uniform_args_t *args;
if ((args = (uniform_args_t *) mem_fs_alloc(mem_rng)) == NULL) {
printf("Error: Error while allocating memory for rng. Exiting!\n");
exit(-1);
}
args->a = INT_MIN;
args->b = INT_MAX;
int result = get_random_integer_gsl((void *)DEFAULT_RNG, UNIFORM, args);
mem_fs_dealloc(mem_rng, args);
return result;
}
double get_random_z_position(void) {
uniform_args_t *args;
if ((args = (uniform_args_t *) mem_fs_alloc(mem_rng)) == NULL) {
printf("Error: Error while allocating memory for rng. Exiting!\n");
exit(-1);
}
args->a = 0;
args->b = get_topology_area()->z;
double result = get_random_double_gsl((void *)DEFAULT_RNG, UNIFORM, args);
mem_fs_dealloc(mem_rng, args);
return result;
}
nodeid_t get_random_node(nodeid_t exclusion) {
uniform_args_t *args;
if ((args = (uniform_args_t *) mem_fs_alloc(mem_rng)) == NULL) {
printf("Error: Error while allocating memory for rng. Exiting!\n");
exit(-1);
}
args->a = 0;
/* GSL bounds are [min,max[, so we use nodes.size instead of nodes.size-1 */
args->b = nodes.size;
int result = get_random_node_gsl((void *)DEFAULT_RNG, UNIFORM, args, exclusion);
mem_fs_dealloc(mem_rng, args);
return result;
}
int get_random_integer_range(int min, int max) {
uniform_args_t *args;
if ((args = (uniform_args_t *) mem_fs_alloc(mem_rng)) == NULL) {
printf("Error: Error while allocating memory for rng. Exiting!\n");
exit(-1);
}
args->a = min;
/* GSL bounds are [min,max[, so we use max+1 to provide an
* integer in the [min,max] range */
args->b = max + 1;
int result = get_random_integer_gsl((void *)DEFAULT_RNG, UNIFORM, args);
mem_fs_dealloc(mem_rng, args);
return result;
}
/* ************************************************** */
void *das_create(void) {
das_t *das;
if ((das = (das_t *) mem_fs_alloc(mem_das)) == NULL) {
return NULL;
}
das->size = 0;
das->elts = NULL;
das->trav = NULL;
das->elts_end = NULL;
return (void *) das;
}
void scheduler_add_milestone(uint64_t clock) {
event_t *event;
if ((event = (event_t *) mem_fs_alloc(mem_event)) == NULL) {
return;
}
event->clock = clock;
event->priority = PRIORITY_MILESTONE;
scheduler_add_event(event);
/* if worldsens mode save this event as rdv */
if (ws_count)
worldsens_add_rdv(clock, PRIORITY_MILESTONE);
}
uint64_t get_random_time(void) {
uniform_args_t *args;
if ((args = (uniform_args_t *) mem_fs_alloc(mem_rng)) == NULL) {
printf("Error: Error while allocating memory for rng. Exiting!\n");
exit(-1);
}
args->a = 0;
/* GSL bounds are [min,max[, so we use cheduler_get_end()+1
* to provide an integer in the [min,max] range */
args->b = scheduler_get_end() + 1;
uint64_t result = get_random_time_gsl((void *)DEFAULT_RNG, UNIFORM, args);
mem_fs_dealloc(mem_rng, args);
return result;
}
void scheduler_add_tx_end(uint64_t clock, call_t *c, packet_t *packet) {
event_t *event;
if ((event = (event_t *) mem_fs_alloc(mem_event)) == NULL) {
return;
}
event->clock = clock;
event->u.rx.packet = packet;
event->u.rx.call.node = c->node;
event->u.rx.call.entity = c->entity;
event->u.rx.call.from = c->from;
event->priority = PRIORITY_TX_END;
scheduler_add_event(event);
return;
}
/* ************************************************** */
void *hadas_create(hash_hash_t hash, hash_equal_t equal) {
hadas_t *hadas;
int i;
if ((hadas = (hadas_t *) mem_fs_alloc(mem_hadas)) == NULL) {
return NULL;
}
hadas->size = 0;
hadas->equal = equal;
hadas->hash = hash;
for(i=0;i<HASH_SIZE;i++){
hadas->elts[i] = NULL;
}
return (void *) hadas;
}
/* ************************************************** */
void *spadas_create(position_t *area, double range) {
spadas_t *spadas;
int i = 0, j = 0, k = 0;
if ((spadas = (spadas_t *) mem_fs_alloc(mem_spadas)) == NULL) {
return NULL;
}
spadas->area.x = area->x;
spadas->area.y = area->y;
spadas->area.z = area->z;
spadas->range = range;
spadas->size = 0;
spadas->elts = NULL;
spadas->cell_width = (int) ceil((double) range / 2.0);
spadas->cell_nbr_x = MAX ((int) ceil((double)area->x / spadas->cell_width), 1);
spadas->cell_nbr_y = MAX ((int) ceil((double)area->y / spadas->cell_width), 1);
spadas->cell_nbr_z = MAX ((int) ceil((double)area->z / spadas->cell_width), 1);
/* dynamic allocation of the grid data structure */
spadas->elts = (spadas_elt_t ****) malloc(sizeof(spadas_elt_t ***) * spadas->cell_nbr_x);
for (i = 0; i < spadas->cell_nbr_x; i++) {
spadas->elts[i] = (spadas_elt_t ***) malloc(sizeof(spadas_elt_t **) * spadas->cell_nbr_y);
for (j = 0; j < spadas->cell_nbr_y; j++) {
spadas->elts[i][j] = (spadas_elt_t **) malloc(sizeof(spadas_elt_t *) * spadas->cell_nbr_z);
}
}
/* init the grid data structure */
for (i = 0; i < spadas->cell_nbr_x; i++) {
for (j = 0; j < spadas->cell_nbr_y; j++) {
for (k = 0; k < spadas->cell_nbr_z; k++) {
spadas->elts[i][j][k] = NULL;
}
}
}
return (void *) spadas;
}
/* ************************************************** */
void *sodas_create(sodas_compare_t compare) {
sodas_t *sodas;
if ((sodas = (sodas_t *) mem_fs_alloc(mem_sodas)) == NULL) {
return NULL;
}
if ((sodas->elts = (sodas_elt_t *) malloc((HEAP_MAX + 1) * sizeof(sodas_elt_t))) == NULL) {
return NULL;
}
sodas->m_capacity = HEAP_MIN;
sodas->capacity = HEAP_MAX;
sodas->size = 0;
sodas->compare = compare;
sodas->elts[0].key = NULL;
sodas->elts[0].data = NULL;
return (void *) sodas;
}
void scheduler_add_rx_end(uint64_t clock, call_t *c, packet_t *packet) {
event_t *event;
if ((event = (event_t *) mem_fs_alloc(mem_event)) == NULL) {
return;
}
event->clock = clock;
event->u.rx.packet = packet;
event->u.rx.call.entity = c->entity;
event->u.rx.call.node = c->node;
event->u.rx.call.from = c->from;
event->priority = PRIORITY_RX_END;
scheduler_add_event(event);
/* if worldsens mode save this event as rdv */
if (ws_count)
worldsens_add_rdv(clock, PRIORITY_RX_END);
return;
}
/* ************************************************** */
void das_insert(void *d, void *data){
das_t *das = (das_t *) d;
das_elt_t *elt;
if ((elt = (das_elt_t *) mem_fs_alloc(mem_das_elts)) == NULL) {
return;
}
elt->data = data;
elt->next = NULL;
elt->previous = NULL;
if (das->elts == NULL) {
das->elts = elt;
das->elts_end = elt;
} else {
elt->next = das->elts;
das->elts->previous = elt;
das->elts = elt;
}
das->size++;
}
/* ************************************************** */
void spadas_insert(void *s, void *key, position_t *position) {
spadas_t *spadas = (spadas_t *) s;
spadas_elt_t *elt;
int x = (int) position->x / spadas->cell_width;
int y = (int) position->y / spadas->cell_width;
int z = (int) position->z / spadas->cell_width;
if ((elt = (spadas_elt_t *) mem_fs_alloc(mem_spadas_elts)) == NULL) {
return;
}
elt->key = key;
elt->position.x = position->x;
elt->position.y = position->y;
elt->position.z = position->z;
elt->next = NULL;
elt->previous = NULL;
elt->next = spadas->elts[x][y][z];
if (spadas->elts[x][y][z] != NULL) {
spadas->elts[x][y][z]->previous = elt;
}
spadas->elts[x][y][z] = elt;
}
