Example #1
0
void spadas_destroy(void *s) {
    spadas_t *spadas = (spadas_t *) s;
    int i = 0, j = 0, k = 0; 

    /* remove entries */
    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_elt_t *elt = spadas->elts[i][j][k];
                spadas_elt_t *p_elt = NULL;
	    
                while (elt != NULL) {
                    p_elt = elt;
                    elt = elt->next;
                    mem_fs_dealloc(mem_spadas_elts, p_elt);
                }
            }
        }
    }
    
    for (i = 0; i < spadas->cell_nbr_x; i++) {
        for (j = 0; j < spadas->cell_nbr_y; j++) {
            mem_fs_dealloc(mem_spadas_elts, spadas->elts[i][j]);
        }
        mem_fs_dealloc(mem_spadas_elts, spadas->elts[i]);
    }
    
    /* free the data structures */
    mem_fs_dealloc(mem_spadas_elts, spadas->elts);
    mem_fs_dealloc(mem_spadas, spadas);
}
Example #2
0
void hadas_destroy(void *s) {
    hadas_t *hadas = (hadas_t *) s;
    hadas_elt_t *elt;
    int i;

    if (hadas != NULL) {
      for (i = 0; i < HASH_SIZE; i++) {
        while ((elt = hadas->elts[i]) != NULL) {
	  hadas->elts[i] = elt->next;
	  mem_fs_dealloc(mem_hadas_elts, elt);       
        }
      }
      mem_fs_dealloc(mem_hadas, hadas);
    }
}
Example #3
0
/* ************************************************** */
void spadas_delete(void *s, void *key, position_t *position) {
    spadas_t *spadas = (spadas_t *) s;
    int x = (int) position->x / spadas->cell_width;
    int y = (int) position->y / spadas->cell_width;
    int z = (int) position->z / spadas->cell_width;
    spadas_elt_t *elt = spadas->elts[x][y][z];
    
    while ((elt != NULL) && (elt->key != key)) {
        elt = elt->next;
    }
    
    if (elt == NULL) {
        return;
    }

    if (elt->previous != NULL) {
        elt->previous->next = elt->next;
    } else {
        spadas->elts[x][y][z] = elt->next;
    }
    if (elt->next != NULL) {
        elt->next->previous = elt->previous;
    } 
    
    mem_fs_dealloc(mem_spadas_elts, elt);
}
void scheduler_clean(void) {
    event_t *event;
    
    if (scheduler == NULL) {
        return;
    }

    while ((event = (event_t *) sodas_pop(scheduler)) != NULL) {
        switch (event->priority) {
        case PRIORITY_RX_END:
            packet_dealloc(event->u.rx.packet);
            break;
        case PRIORITY_RX_BEGIN:
            packet_dealloc(event->u.rx.packet);
            break;
        case PRIORITY_TX_END:
            packet_dealloc(event->u.rx.packet);
            break;
        default:
            break;
        }

        mem_fs_dealloc(mem_event, event);
    }

    sodas_destroy(scheduler);

    worldsens_clean();
}
Example #5
0
void hadas_delete(void *h, void *key) {
    hadas_t *hadas = (hadas_t *) h;
    unsigned long hash = hadas->hash(key) % HASH_SIZE;
    hadas_elt_t *elt = hadas->elts[hash], *o_elt = NULL;
    
    while (elt != NULL) {
        if (hadas->equal(elt->key, key)) {
            /* delete from the begining*/
            if (o_elt == NULL) {
                hadas->elts[hash] = elt->next;
                if (hadas->elts[hash] != NULL) {
                    hadas->elts[hash]->previous = NULL;
                }
            } else {
                o_elt->next = elt->next;
                if (elt->next != NULL){ 
                    elt->next->previous = o_elt;
                }
            }
            
            hadas->size--;
            mem_fs_dealloc(mem_hadas_elts, elt);
            return;
        }
        o_elt = elt;
        elt = elt->next;
    }
    
    return;
}
Example #6
0
void das_destroy(void *d) {
    das_t *das = (das_t *) d;
    das_elt_t *elt;

    if (das == NULL) {
        return;
    }

    while ((elt = das->elts) != NULL) {
        das->elts = elt->next;
        mem_fs_dealloc(mem_das_elts, elt);       
        das->size--;
    }
    
    mem_fs_dealloc(mem_das, das);
    return;
}
Example #7
0
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;
}
Example #8
0
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;
}
Example #9
0
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;
}
Example #10
0
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;
}
/* edit by Ibrahim Amadou <*****@*****.**> */
void scheduler_delete_callback(call_t *c, event_t *event) {
  event_t *event1 = NULL;

  if((event->clock > get_time()) && (event->clock < scheduler_get_end())) {
      event1 = (event_t *) sodas_delete(scheduler, event);
      if(event1 != NULL) {
         dbg.c_events--;
	 mem_fs_dealloc(mem_event, event1);
      }
      return;
  }
 
  return;
}
Example #12
0
void *das_pop_FIFO(void *d) {
    das_t *das = (das_t *) d;
    das_elt_t *elt;
    void *data;
    
    if ((elt = das->elts_end) == NULL) {
        return NULL;
    } else if (das->elts_end == das->elts) {
        data = elt->data;
        das->elts_end = NULL;
        das->elts = NULL;
        das->size--;
        mem_fs_dealloc(mem_das_elts, elt);
        return (void *) data;
    } else {
        data = elt->data;
        das->elts_end = das->elts_end->previous;
        das->elts_end->next = NULL;
        das->size--;
        mem_fs_dealloc(mem_das_elts, elt);
        return (void *) data;
    }
}
Example #13
0
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;
}
Example #14
0
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 do_event(event_t *event) {

    if (ws_count)    /* WORLDSENS MODE? */
        worldsens_rdv_update(event);

    switch (event->priority) {
    case PRIORITY_BIRTH:
        node_birth(event->u.nodeid);
        break;
    case PRIORITY_MOBILITY:
        mobility_event(g_clock);
        break;
    case PRIORITY_RX_BEGIN:
        medium_cs(event->u.rx.packet, &(event->u.rx.call));
	worldsens_rm_duplicate_pk(event);
        break;
    case PRIORITY_RX_END:
        medium_rx(event->u.rx.packet, &(event->u.rx.call));
        break;
    case PRIORITY_TX_END:
        medium_tx_end(event->u.rx.packet, &(event->u.rx.call));
        break;
    case PRIORITY_CALLBACK:
        if ((event->u.cb.call.node != -1) && (!is_node_alive(event->u.cb.call.node))) {
            break;
        }
        event->u.cb.callback(&(event->u.cb.call), event->u.cb.arg);
        break;
    case PRIORITY_MILESTONE:
        scheduler_stats();
	if (ws_count) {  /* WORLDSENS MODE? */
	    scheduler_add_milestone(g_clock + WORLDSENS_SYNC_PERIOD);
	}
	else {
	    scheduler_add_milestone(g_clock + SCHEDULER_MILESTONE_PERIOD);
	}
       break;
    case PRIORITY_QUIT:
        worldsens_quit();
        exception = EXCEPTION_QUIT;
        break;
    default:
        break;
    }

    mem_fs_dealloc(mem_event, event);
    dbg.c_events--;
    dbg.d_events++;
}
static void worldsens_rdv_update(event_t *event) {
    if ( (event->priority == PRIORITY_QUIT)     || 
	 (event->priority == PRIORITY_RX_BEGIN) || 
	 (event->priority == PRIORITY_RX_END)   ||
	 (event->priority == PRIORITY_CALLBACK) ||
	 (event->priority == PRIORITY_MILESTONE) ) {
        ws_rdv_t *rdv;
        rdv = worldsens_rdv_next();
	if (rdv->clock != event->clock) {
	    WSNET_S_DBG_DBG ("WSNET2:: === ==================================================\n");
	    WSNET_S_DBG_DBG ("WSNET2:: === ERROR: CORE DESYNCHRONIZATION, RDV TIME %"PRId64" != EVENT TIME %"PRId64" (rp seq: %"PRId64")\n", rdv->clock, event->clock, ws_csyncseq);
	    WSNET_S_DBG_DBG ("WSNET2:: === ==================================================\n");
	}
        worldsens_event_dump(event);
	mem_fs_dealloc(mem_ws_rdv, rdv);
    }
}
static void worldsens_clean(void) {
    if (ws_count) {
        wsens_srv_finalize();

	/* free node informations space */
	ws_node_features_t *p_temp = ws_nodes_feat;
	ws_node_features_t *p_free = NULL;
	while(p_temp != NULL) {
	    p_free = p_temp;
	    p_temp = p_temp->next;
	    free(p_free);
	}
	
	/* free rdvs */
	ws_rdv_t *rdv;
	while ((rdv = (ws_rdv_t *) sodas_pop(ws_rdvs)) != NULL) {
	    mem_fs_dealloc(mem_ws_rdv, rdv);
	}
    }
}
/* ************************************************** */
static void worldsens_rm_duplicate_pk(event_t *event) {

    if (ws_count) {
        event_t *next_event = scheduler_see_next();

	/* A packet sent by a node has the same id for each receiving nodes.
	   So if we find a packet with same source node, same clock and differents ids,
	   it is a duplicated packet (because of a backtrack) and we have to skip it. */

	while(next_event->priority            == PRIORITY_RX_BEGIN          && 
	      next_event->u.rx.packet->node   == event->u.rx.packet->node   && 
	      next_event->u.rx.packet->clock0 == event->u.rx.packet->clock0 && 
	      next_event->u.rx.packet->id     != event->u.rx.packet->id)  {
 	    /* get out of the fifo the duplicated packet */
	    event_t *trash_event = scheduler_next();
	    worldsens_rdv_update(trash_event);
	    WSNET_S_DBG_DBG("WSNET2:: --> RX BEGIN: same packet found in fifo, skip it (src ip:%d, data:0x%02x, freq:%ghz, wsim modul:%d)\n", worldsens_get_wsim_node_id(next_event->u.rx.packet->node), *(next_event->u.rx.packet->data), next_event->u.rx.packet->worldsens_freq, next_event->u.rx.packet->worldsens_mod);
	    mem_fs_dealloc(mem_event, trash_event);
	    dbg.c_events--;
	    next_event = scheduler_see_next();
	}
    }    
}
Example #19
0
void das_delete(void *d, void *data) {
    das_t *das = (das_t *) d;
    das_elt_t *elt = das->elts, *o_elt = NULL;
    
    while (elt != NULL) {
        
        if (elt->data == data) {
            /* delete from the begining*/
            if (o_elt == NULL) {
                das->elts = elt->next;
                if (das->elts != NULL) {
                    das->elts->previous = NULL;
                } else {
                    das->elts_end = NULL;
                }
            } else if (elt == das->elts_end) {
                das->elts_end = das->elts_end->previous;
                das->elts_end->next = NULL;
            } else {
                o_elt->next = elt->next;
                if (elt->next != NULL){ 
                    elt->next->previous = o_elt;
                }
            }
            
            das->size--;
	    free(elt->data);
            mem_fs_dealloc(mem_das_elts, elt);
            return;
        }
        o_elt = elt;
        elt = elt->next;
    }

    return;
}
Example #20
0
void sodas_destroy(void *s) {
    sodas_t *sodas = (sodas_t *) s;

    free(sodas->elts);
    mem_fs_dealloc(mem_sodas, sodas);
}