4543
Comment:
|
5579
|
Deletions are marked like this. | Additions are marked like this. |
Line 2: | Line 2: |
==== bool my_gnode_participates(int p_id, int lvl) ==== * Questo metodo dice se il mio g-nodo di livello lvl partecipa attivamente al servizio con identificativo p_id. |
<<TableOfContents(4)>> == my_gnode_participates == Questo metodo dice se il mio g-nodo di livello lvl partecipa attivamente al servizio con identificativo p_id. Firma: '''bool my_gnode_participates(int p_id, int lvl)''' |
Line 14: | Line 19: |
==== List<HCoord> get_non_participant_gnodes(int p_id) ==== * Questo metodo restituisce una lista con tutte le istanze di HCoord che rappresentano i g-nodi a me visibili nella topologia della rete che, stando alle mie conoscenze, non partecipano al servizio con identificativo p_id. |
== get_non_participant_gnodes == Questo metodo restituisce una lista con tutte le istanze di HCoord che rappresentano i g-nodi a me visibili nella topologia della rete che, stando alle mie conoscenze, non partecipano al servizio con identificativo p_id. Firma: '''List<HCoord> get_non_participant_gnodes(int p_id)''' |
Line 34: | Line 42: |
==== List<HCoord> get_all_gnodes_up_to_lvl(int lvl) ==== * Questo metodo restituisce una lista con tutte le istanze di HCoord che rappresentano i g-nodi a me visibili nella topologia della rete che sono dentro il mio g-nodo di livello lvl. Compresi i singoli nodi e compreso me stesso (0, pos[0]). |
== get_all_gnodes_up_to_lvl == Questo metodo restituisce una lista con tutte le istanze di HCoord che rappresentano i g-nodi a me visibili nella topologia della rete che sono dentro il mio g-nodo di livello lvl. Compresi i singoli nodi e compreso me stesso (0, pos[0]). Firma: '''List<HCoord> get_all_gnodes_up_to_lvl(int lvl)''' |
Line 44: | Line 55: |
==== void convert_tuple_gnode(PeerTupleGNode t, out int case, out HCoord ret) ==== * Ricordiamo che un'istanza ''t'' di PeerTupleGNode rappresenta un g-nodo ''h'' di livello ''ε'' all'interno di un g-nodo (che chiamiamo g-nodo di riferimento) ''g'' di livello ''l''. Il valore di l è memorizzato in t.top. Il valore di ε si calcola come t.top - t.tuple.size. * Dato t il cui g-nodo di riferimento è uno dei g-nodi a cui il nodo corrente appartiene, questo metodo restituisce le seguenti informazioni: |
== convert_tuple_gnode == Data un'istanza ''t'' di PeerTupleGNode il cui g-nodo di riferimento è uno dei g-nodi a cui il nodo corrente appartiene, questo metodo restituisce le seguenti informazioni: |
Line 56: | Line 66: |
Ricordiamo che un'istanza ''t'' di PeerTupleGNode rappresenta un g-nodo ''h'' di livello ''ε'' all'interno di un g-nodo (che chiamiamo g-nodo di riferimento) ''g'' di livello ''l''. Il valore di l è memorizzato in t.top. Il valore di ε si calcola come t.top - t.tuple.size. Firma: '''void convert_tuple_gnode(PeerTupleGNode t, out int case, out HCoord ret)''' |
|
Line 78: | Line 94: |
==== PeerTupleGNode make_tuple_gnode(HCoord h, int top) ==== * Questo metodo produce un'istanza di PeerTupleGNode che rappresenta ''h'' nel nostro g-nodo di livello ''top''. |
== make_tuple_gnode == Questo metodo produce un'istanza di PeerTupleGNode che rappresenta ''h'' nel nostro g-nodo di livello ''top''. Firma: '''PeerTupleGNode make_tuple_gnode(HCoord h, int top)''' |
Line 92: | Line 111: |
==== PeerTupleNode make_tuple_node(HCoord h, int top) ==== * Questo metodo produce un'istanza di !PeerTupleNode che rappresenta ''h'' nel nostro g-nodo di livello ''top''. In realtà h è un g-nodo ma il risultato deve essere un !PeerTupleNode perché va usato nel calcolo di ''dist''. I valori delle posizioni inferiori a h.lvl non sono significativi purché rientrino nella topologia, quindi li impostiamo a 0. |
== make_tuple_node == Questo metodo produce un'istanza di !PeerTupleNode che rappresenta ''h'' nel nostro g-nodo di livello ''top''. In realtà h è un g-nodo ma il risultato deve essere un !PeerTupleNode perché va usato nel calcolo di ''dist''. I valori delle posizioni inferiori a h.lvl non sono significativi purché rientrino nella topologia, quindi li impostiamo a 0. Firma: '''!PeerTupleNode make_tuple_node(HCoord h, int top)''' |
Line 97: | Line 119: |
* While i ≥ 0: | * While i > 0: |
Line 106: | Line 128: |
== visible_by_someone_inside_my_gnode == Dato un g-nodo rappresentato da t, decidere se qualcuno dei nodi dentro il mio g-nodo di livello lvl può rappresentare quel g-nodo in forma di HCoord. Firma: '''bool visible_by_someone_inside_my_gnode(PeerTupleGNode t, int lvl)''' * ''ε'' = t.top - t.tuple.size * ''l'' = ε. * Se l ≥ lvl-1: * l = l + 1. * Altrimenti: * l = lvl. * Se t.top ≤ l: * Return True. * # Calcola ''h'' il g-nodo di livello l in cui si trova g. * PeerTupleGNode ''h'' = new PeerTupleGNode(t.tuple.slice(l-ε, t.tuple.size), t.top). * # Ora scopriamo se h è uno dei g-nodi a cui appartiene n. * int ''case'', HCoord ''ret''. * convert_tuple_gnode(h, out case, out ret). * Se case = 1: * Return True. * Return False. |
Modulo PeerServices - Appunti - Metodi helper
Contents
my_gnode_participates
Questo metodo dice se il mio g-nodo di livello lvl partecipa attivamente al servizio con identificativo p_id.
Firma: bool my_gnode_participates(int p_id, int lvl)
- Se services.has_key(p_id):
- Return True.
- Se (! participant_maps.has_key(p_id)):
- Return False.
map = participant_maps[p_id].
Per ogni HCoord g in map.participant_list:
Se g.lvl < lvl:
- Return True.
- Return False.
get_non_participant_gnodes
Questo metodo restituisce una lista con tutte le istanze di HCoord che rappresentano i g-nodi a me visibili nella topologia della rete che, stando alle mie conoscenze, non partecipano al servizio con identificativo p_id.
Firma: List<HCoord> get_non_participant_gnodes(int p_id)
ret = new ArrayList di HCoord.
bool opzionale = False.
- Se services.has_key(p_id):
- opzionale = services[p_id].p_is_optional.
- Altrimenti:
- opzionale = True.
- Se opzionale:
map = null.
- Se (participant_maps.has_key(p_id)):
map = participant_maps[p_id].
Per ogni HCoord lp in get_all_gnodes_up_to_lvl(levels):
- Se map = null:
- Aggiungi a ret lp.
- Altrimenti:
- Se lp ∉ map.participant_list:
- Aggiungi a ret lp.
- Se lp ∉ map.participant_list:
- Se map = null:
- Return ret.
get_all_gnodes_up_to_lvl
Questo metodo restituisce una lista con tutte le istanze di HCoord che rappresentano i g-nodi a me visibili nella topologia della rete che sono dentro il mio g-nodo di livello lvl. Compresi i singoli nodi e compreso me stesso (0, pos[0]).
Firma: List<HCoord> get_all_gnodes_up_to_lvl(int lvl)
ret = new ArrayList di HCoord.
Per l da 0 a lvl-1:
Per p da 0 a gsizes[l]-1:
- Se pos[l] ≠ p:
- Aggiungi a ret HCoord(l, p).
- Se pos[l] ≠ p:
- Aggiungi a ret HCoord(0, pos[0]).
- Return ret.
convert_tuple_gnode
Data un'istanza t di PeerTupleGNode il cui g-nodo di riferimento è uno dei g-nodi a cui il nodo corrente appartiene, questo metodo restituisce le seguenti informazioni:
- int case:
- Vale 1 se t rappresenta un g-nodo di cui il nodo corrente fa parte.
- Vale 2 se t rappresenta un g-nodo visibile nella mia topologia come istanza di HCoord.
- Vale 3 se t rappresenta un g-nodo non visibile nella mia topologia.
- HCoord ret:
- Il g-nodo che il nodo corrente ha in comune con h.
- Nel caso 1 abbiamo ret.lvl = ε. Inoltre pos[ret.lvl] = ret.pos.
- Nel caso 2 abbiamo ret.lvl = ε. Inoltre pos[ret.lvl] ≠ ret.pos.
Nel caso 3 abbiamo ret.lvl > ε.
Ricordiamo che un'istanza t di PeerTupleGNode rappresenta un g-nodo h di livello ε all'interno di un g-nodo (che chiamiamo g-nodo di riferimento) g di livello l. Il valore di l è memorizzato in t.top. Il valore di ε si calcola come t.top - t.tuple.size.
Firma: void convert_tuple_gnode(PeerTupleGNode t, out int case, out HCoord ret)
- int lvl = t.top.
- int i = t.tuple.size.
assert(i > 0).
- assert(i ≤ lvl).
trovato = False.
- While True:
- decrementa lvl di 1.
- decrementa i di 1.
- Se pos[lvl] ≠ t.tuple[i]:
- ret = HCoord(lvl, t.tuple[i]).
- trovato = True.
- Se i = 0:
- case = 2.
- Altrimenti:
- case = 3.
- Esci dal ciclo.
- Se i = 0:
- ret = HCoord(lvl, t.tuple[i]).
- case = 1.
- Esci dal ciclo.
- Return case, ret.
make_tuple_gnode
Questo metodo produce un'istanza di PeerTupleGNode che rappresenta h nel nostro g-nodo di livello top.
Firma: PeerTupleGNode make_tuple_gnode(HCoord h, int top)
assert(top > h.lvl).
tuple = [].
i = top.
- While True:
- Decrementa i di 1.
- Se i = h.lvl:
- Inserisci h.pos in posizione 0 in tuple.
- Esci dal ciclo.
- Altrimenti:
- Inserisci pos[i] in posizione 0 in tuple.
- Return new PeerTupleGNode(tuple, top).
make_tuple_node
Questo metodo produce un'istanza di PeerTupleNode che rappresenta h nel nostro g-nodo di livello top. In realtà h è un g-nodo ma il risultato deve essere un PeerTupleNode perché va usato nel calcolo di dist. I valori delle posizioni inferiori a h.lvl non sono significativi purché rientrino nella topologia, quindi li impostiamo a 0.
Firma: PeerTupleNode make_tuple_node(HCoord h, int top)
assert(top > h.lvl).
tuple = [].
i = top.
While i > 0:
- Decrementa i di 1.
Se i > h.lvl:
- Inserisci pos[i] in posizione 0 in tuple.
- Se i = h.lvl:
- Inserisci h.pos in posizione 0 in tuple.
Se i < h.lvl:
- Inserisci 0 in posizione 0 in tuple.
Return new PeerTupleNode(tuple).
visible_by_someone_inside_my_gnode
Dato un g-nodo rappresentato da t, decidere se qualcuno dei nodi dentro il mio g-nodo di livello lvl può rappresentare quel g-nodo in forma di HCoord.
Firma: bool visible_by_someone_inside_my_gnode(PeerTupleGNode t, int lvl)
ε = t.top - t.tuple.size
l = ε.
- Se l ≥ lvl-1:
- l = l + 1.
- Altrimenti:
- l = lvl.
- Se t.top ≤ l:
- Return True.
# Calcola h il g-nodo di livello l in cui si trova g.
PeerTupleGNode h = new PeerTupleGNode(t.tuple.slice(l-ε, t.tuple.size), t.top).
- # Ora scopriamo se h è uno dei g-nodi a cui appartiene n.
int case, HCoord ret.
- convert_tuple_gnode(h, out case, out ret).
- Se case = 1:
- Return True.
- Return False.