3797
Comment:
|
← Revision 5 as of 2015-11-28 11:15:09 ⇥
5569
|
Deletions are marked like this. | Additions are marked like this. |
Line 1: | Line 1: |
= Modulo PeerServices - Appunti - Metodi helper = ==== 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. |
= Modulo PeerServices - Metodi helper = <<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 30: | Line 38: |
* Se NOT map.participant_list.contains(lp): | * Se lp ∉ map.participant_list: |
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 91: | Line 110: |
== 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. |
Modulo PeerServices - 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.