void dijkstra(graph* g, unsigned int source) {
unsigned int u, v, edge_count;
node *n, *d;
edge *e;
heap *Q;
g->nodes[source].distance = 0;
Q = heap_make(compare, g);
while(!heap_is_empty(Q)) {
u = heap_delete_min(Q);
n = &g->nodes[u];
edge_count = n->edge_count;
for(v = 0; v < edge_count; v++) {
e = &n->edges[v];
d = &g->nodes[e->destination];
if(d->distance > n->distance + e->weight) {
/*
Relajo los vertices
*/
d->distance = n->distance + e->weight;
/*
Actualizo el nodo con la distancia optima a este
*/
d->previous = u;
/*
Actualizo la cola de prioridad (el vertice solo puede
haber subido en prioridad, entonces solo hago heapify-up
*/
heap_heapify_up(Q, d->heap_index);
}
}
}
heap_destroy(Q);
}
int * dijkstra(graph g, int from, int*tree, int (*add)(int, int)){
int * somme, i, act;/*Commistione linguistica che bonato ama! xD*/
heap_t *heap;
somme = malloc(sizeof(int) * g->v);
assert(somme != NULL);
/*Piazzo tutto a -1 che in binario è 11111111....1111 ... fino alla nausea... 1111*/
memset(somme, 0xff, g->v * sizeof(int));
/*Good! Ora però la prima va a 0!*/
somme[from] = 0;
/*Ci siamo quasi...*/
/*ora le heap!*/
heap = heap_make(somme, g->v, heapcmp, sizeof(int));
/*Metto a TRUE la flag *connected*/
g->connesso = 1;
/*Ultimissima cosa: inizializzo l'albero delle visite ad una foresta di alberi di un solo elemento*/
for(i = 0; i < g->v; i++)
tree[i] = i;
/* Ora il ciclo, prepariamo l'assorbente xD*/
while(!heap_is_empty(heap)){
/* Estraggo il primo elemento*/
from = heap_extract(heap);
/* Se la distanza per arrivare è ancora infinita (-1), significa che questa parte del
* Grafo non è mai stata raggiunta da nessun arco e quindi è disconnessa dalla componente
* In cui è presente il nodo di partenza, e quindi, visto che questo è il massimo possibili
* tutti gli altri elementi nella heap avranno lo stesso valore, quindi interrompo qui
* l'esecuzione */
if(somme[from] == -1) {
g->connesso = 0;/* Segno che il grafo non è connesso*/
/*interrompo il ciclo*/
break;
}
/*E itero tra tutto */
for(i = 0; i < g->v; i++){
if(g->adj[from][i]){
/*Mi calcolo la distanza attuale + quella dell'arco tramite una funzione esterna*/
act = add(somme[from], g->adj[from][i]);
/*Se la somma è a -1 (non è ancora stato aggiornato) oppure il nuovo valore
e' inferiore a quello vecchio, lo metto uguale e aggiorno l'albero delle visite*/
if(somme[i] == -1 || somme[i] > act){
somme[i] = act;
tree[i] = from;
/*Ho aggiornato: devo fare un fix della heap che potrebbe essere andata a farsi fottere!*/
heap_fix(heap, i);
}
}
}
}
heap_free(heap);/*Questa non mi cancella l'array somme, quindi sono contento xD*/
/*Bene! abbiamo finito! :)*/
return somme;
}
void FinderActor::start(){
lock();
heap_make(shortlist);
heap_make(foundPeers);
//Initialize the shortlist and foundPeers
std::vector<Peer::SPtr> nearest;
n.kbucket.findNearestNodes(requestedId, nearest, countToFind);
for(auto it = nearest.begin(); it != nearest.end(); it ++) {
addToShortList(*it);
addToFoundPeers(*it);
}
//Send queries to the nodes closest to the target
for(auto i = shortlist.begin(); i != shortlist.end(); i++) {
sendFindQueryTo((*i).second);
}
unlock();
}
void
heap_list_append(struct malloc_chunk **chunk) {
if (heapListStart) {
heapptr cur = heapListStart;
do {
if (cur->end + 1 == (void*)*chunk) {
cur->end = (void*)*chunk + OVERHEAD + (*chunk)->size;
return;
}
} while((cur = cur->next) != NULL);
heapptr heap = heap_make(chunk);
cur = heapListStart;
while(cur->next != NULL) { cur = cur->next; }
cur->next = heap;
heap->prev = cur;
} else {
heapListStart = heap_make(chunk);
}
}
int code_base_load(code_base_t *self, named_tuples_t *nm_tuples,
term_t module, term_t exports, term_t fun_table, term_t attrs, term_t preloaded, term_t misc)
{
module_t *m;
apr_pool_t *pool;
apr_pool_create(&pool, 0);
m = apr_palloc(pool, sizeof(*m));
m->mod_pool = pool;
m->literals = heap_make(pool);
m->key.module = module;
m->key.is_old = 0;
m->code_size = 0;
m->code = 0;
m->exports = apr_hash_make(pool);
m->nfuns = 0;
m->funs = 0;
m->files = 0;
m->source = 0;
if (preloaded != nil)
{
int i;
int n = list_length(preloaded);
term_t cons = preloaded;
int ok = 1;
m->code = apr_palloc(pool, n*sizeof(codel_t));
m->code_size = n;
i = 0;
while (ok && is_cons(cons))
{
term_box_t *cbox = peel(cons);
if (is_int(cbox->cons.head))
{
m->code[i].i = int_value(cbox->cons.head);
}
else if (is_tuple(cbox->cons.head))
{
term_box_t *tbox = peel(cbox->cons.head);
if (tbox->tuple.size == 2)
{
term_t selector = tbox->tuple.elts[0];
term_t value = tbox->tuple.elts[1];
switch (selector)
{
case AT__: // {'@',Offset}
m->code[i].l = m->code + int_value(value);
break;
case A_T: // {t,Literal}
m->code[i].t = heap_marshal(value, m->literals);
break;
case A_B:
m->code[i].bif = builtins[int_value(value)].entry;
break;
case A_N: // {n,{N,F}}
if (is_tuple(value))
{
term_box_t *vb = peel(value);
if (vb->tuple.size == 2)
{
term_t name = vb->tuple.elts[0];
term_t field = vb->tuple.elts[1];
int index = named_tuples_set(nm_tuples, name, field);
m->code[i].t = tag_int(index);
}
else
ok = 0;
}
else
ok = 0;
break;
default:
ok = 0;
}
}
}
else if (is_bignum(cbox->cons.head))
{
mp_int mp = bignum_to_mp(cbox->cons.head);
m->code[i].i = mp_get_int(&mp);
}
else
ok = 0;
i++;
cons = cbox->cons.tail;
}
if (!ok)
{
apr_pool_destroy(pool);
return 1;
}
}
// misc:
// source line info:
// {file,Files}
// {source,[{F,L,S,E}]}
if (misc != nil)
{
term_t cons = misc;
while (is_cons(cons))
{
term_box_t *cb = peel(cons);
term_t t = cb->cons.head;
if (is_tuple(t))
{
term_box_t *tb = peel(t);
if (tb->tuple.size >= 2)
{
term_t selector = tb->tuple.elts[0];
term_t info = tb->tuple.elts[1];
switch (selector)
{
case A_FILES:
m->files = source_files_names(info, pool);
break;
case A_SOURCE:
m->source = source_line_blocks(info, pool);
break;
}
}
}
cons = cb->cons.tail;
}
}
if (fun_table != nil)
{
int i;
int nfuns = list_length(fun_table);
term_t cons = fun_table;
int ok = 1;
m->funs = apr_palloc(pool, nfuns*sizeof(fun_slot_t));
m->nfuns = nfuns;
for (i = 0; ok && i < nfuns; i++)
{
term_box_t *cbox = peel(cons);
if (is_tuple(cbox->cons.head))
{
term_box_t *tbox = peel(cbox->cons.head);
if (tbox->tuple.size == 2)
{
term_t uniq = tbox->tuple.elts[0];
term_t offset = tbox->tuple.elts[1];
if ((is_int(uniq) || is_bignum(uniq)) && is_int(offset))
{
fun_slot_t *slot = &m->funs[i];
if (is_int(uniq))
slot->uniq = int_value(uniq);
else
{
mp_int mp = bignum_to_mp(uniq);
slot->uniq = (uint)mp_get_int(&mp);
}
slot->entry = m->code + int_value(offset);
}
else
ok = 0;
}
else
ok = 0;
}
else
ok = 0;
cons = cbox->cons.tail;
}
if (!ok)
{
apr_pool_destroy(pool);
return 1;
}
}
//TODO: attrs ingnored
if (exports != nil)
{
int ok = 1;
term_t cons = exports;
while (ok && is_cons(cons))
{
term_box_t *cbox = peel(cons);
// {Function,Arity,Offset}
if (is_tuple(cbox->cons.head))
{
term_box_t *tbox = peel(cbox->cons.head);
if (tbox->tuple.size == 3)
{
term_t function = tbox->tuple.elts[0];
term_t arity = tbox->tuple.elts[1];
term_t offset = tbox->tuple.elts[2];
if (is_atom(function) && is_int(arity) && is_int(offset))
{
export_t *exp = apr_palloc(pool, sizeof(*exp));
exp->key.function = function;
exp->key.arity = int_value(arity);
exp->entry = m->code + int_value(offset);
apr_hash_set(m->exports, &exp->key, sizeof(exp->key), exp);
}
else
ok = 0;
}
else
ok = 0;
}
else
ok = 0;
cons = cbox->cons.tail;
}
if (!ok)
{
apr_pool_destroy(pool);
return 1;
}
}
apr_hash_set(self->modules, &m->key, sizeof(m->key), m);
return 0;
}