mirror of
https://github.com/Steffo99/appunti-magistrali.git
synced 2024-11-24 03:04:18 +00:00
Complete 9 - Algoritmi distribuiti/5 - Leader election
This commit is contained in:
parent
24677523c8
commit
21f3695c13
GPG key ID:
2A24051445686895
23 changed files with 670 additions and 394 deletions
16
.obsidian/plugins/obsidian-file-color/data.json
vendored
16
.obsidian/plugins/obsidian-file-color/data.json
vendored
|
|
@ -277,18 +277,6 @@
|
|||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/2 - Su anello",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/3 - Su grafo generico",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/1 - Concetti",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "steffo-file-index.json",
|
||||
"color": "me4XBNQC4rwzQFLlvIAn0"
|
||||
|
|
@ -408,6 +396,10 @@
|
|||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/traversal protocol.md",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello controlled-distance.md",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
@ -143,3 +143,7 @@ In [[notazione asintotica]], è sempre:
|
|||
$$
|
||||
\Large O(Channels)
|
||||
$$
|
||||
|
||||
## Duale
|
||||
|
||||
Il duale di questo algoritmo è la [[leader election su grafo aciclico]].
|
||||
|
|
|
|||
|
|
@ -1,13 +1,13 @@
|
|||
{
|
||||
"nodes":[
|
||||
{"id":"f10431539991943d","x":620,"y":-500,"width":440,"height":2040,"color":"5","type":"group","label":"Saturazione"},
|
||||
{"id":"f10431539991943d","type":"group","x":620,"y":-500,"width":440,"height":2040,"color":"5","label":"Saturazione"},
|
||||
{"id":"d9e8c63362870000","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/computazione in grafi aciclici.md","x":-480,"y":-480,"width":960,"height":960},
|
||||
{"id":"eac3f8232a170480","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/tecnica di saturazione per grafi aciclici.md","x":640,"y":-480,"width":400,"height":960},
|
||||
{"id":"da6b01f674dba080","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/computazione in alberi.md","x":-480,"y":560,"width":960,"height":960},
|
||||
{"id":"c217a97b6c1f113a","x":640,"y":560,"width":400,"height":960,"type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/tecnica di saturazione per alberi.md"},
|
||||
{"id":"39e8d6989eaff333","x":-1280,"y":80,"width":400,"height":400,"type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/★ broadcast.canvas"},
|
||||
{"id":"4295118739ed5400","x":-1280,"y":560,"width":400,"height":400,"type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/★ spanning tree.canvas"},
|
||||
{"id":"810c6eab5eed44f9","x":-720,"y":480,"width":80,"height":80,"type":"text","text":"# +"}
|
||||
{"id":"c217a97b6c1f113a","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/tecnica di saturazione per alberi.md","x":640,"y":560,"width":400,"height":960},
|
||||
{"id":"39e8d6989eaff333","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/★ broadcast.canvas","x":-1280,"y":80,"width":400,"height":400},
|
||||
{"id":"4295118739ed5400","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/★ spanning tree.canvas","x":-1280,"y":560,"width":400,"height":400},
|
||||
{"id":"810c6eab5eed44f9","type":"text","text":"# +","x":-720,"y":480,"width":80,"height":80}
|
||||
],
|
||||
"edges":[
|
||||
{"id":"3cc5d31160347382","fromNode":"d9e8c63362870000","fromSide":"bottom","toNode":"da6b01f674dba080","toSide":"top","fromEnd":"arrow"},
|
||||
|
|
|
|||
|
|
@ -1,10 +0,0 @@
|
|||
#TODO [[8 - Crittografia applicata/1 - Concetti/1 - Trovare soluzioni crittografiche/problema]].
|
||||
|
||||
Roba della lezione scorsa.
|
||||
|
||||
Tanti nodi uguali devono decidere uno di loro che diventerà leader.
|
||||
|
||||
In base alla topologia del grafo, si ha che:
|
||||
- [[leader election su anello]]
|
||||
|
||||
I nodi hanno tutti un ID univoco, e solitamente si elegge leader il nodo con ID minore.
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
#TODO
|
||||
|
||||
Invia in una direzione il proprio ID finchè non è tornato indietro.
|
||||
|
||||
Per sapere quando è terminato, richiede che:
|
||||
- o i messaggi vengano consegnati in ordine
|
||||
- o sia conosciuto il numero di nodi nell'anello
|
||||
- contatore in messaggi
|
||||
- contatore in ogni entità
|
||||
|
||||
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
[[algoritmo]] di [[leader election su anello]].
|
||||
|
||||
#TODO Inoltra solo gli ID minori di quelli già inviati.
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
#TODO [[algoritmo]] di [[leader election su anello]].
|
||||
|
||||
## [[restrizioni al modello dei sistemi distribuiti]]
|
||||
|
||||
- [[full-duplex]]
|
||||
- [[affidabilità totale]]
|
||||
- [[orientamento locale]]
|
||||
- [[identificatori distinti]]
|
||||
- **non c'è bisogno di conoscere N**
|
||||
|
||||
## Funzionamento
|
||||
|
||||
I nodi possono essere *candidati* o *sconfitti*.
|
||||
|
||||
Ad ogni fase, ogni candidato cerca di sconfiggere alcuni nodi.
|
||||
|
||||
In particolare:
|
||||
|
||||
1. Ogni candidato manda il suo ID ai suoi vicini.
|
||||
2. Ogni vicino propaga il messaggio fino a quando non ha viaggiato per $2^{stage}$ archi.
|
||||
3. If
|
||||
- Il messaggio incontra un ID più piccolo, si ferma.
|
||||
- Il messaggio raggiunge la fine del suo viaggio, viene rimandato indietro.
|
||||
4. Se l'ID non torna indietro da entrambe le direzioni, il nodo è *sconfitto*.
|
||||
5. Se il messaggio inviato a sinistra viene ricevuto a destra o viceversa, allora è stato percorso tutto l'anello.
|
||||
## [[costo computazionale distribuito]]
|
||||
|
||||
### [[spazio]]
|
||||
|
||||
#TODO
|
||||
|
||||
## [[tempo]]
|
||||
|
||||
#TODO
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
#TODO [[leader election]] applicata a un [[grafo]] ad [[anello]].
|
||||
|
||||
> Studiata principalmente per motivi storici.
|
||||
|
||||
[[leader election all-the-way su anello]]
|
||||
[[leader election as-far-as-it-can su anello]]
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
#TODO [[algoritmo]] di [[leader election su grafo generico]].
|
||||
|
||||
## Funzionamento (del duale FloodMin)
|
||||
|
||||
Vengono effettuati $Diametro$ [[flooding v3]], ciascuno con l'id più basso incontrato da ciascun nodo nella fase precedente.
|
||||
|
||||
## [[costo computazionale]]
|
||||
|
||||
### [[spazio]]
|
||||
### [[tempo]]
|
||||
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
#TODO [[8 - Crittografia applicata/1 - Concetti/1 - Trovare soluzioni crittografiche/problema]] di [[leader election]] applicato a un qualsiasi [[grafo]].
|
||||
|
||||
## Algoritmi conosciuti
|
||||
|
||||
- [[FloodMax]]
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
[[Teorema]].
|
||||
|
||||
# Tesi
|
||||
|
||||
La [[leader election]] è irrisolvibile senza [[identificatori univoci]].
|
||||
|
||||
## Dimostrazione
|
||||
|
||||
In un [[sistema distribuito]] si hanno due [[entità]] senza [[identificatori univoci|identificatore univoco]].
|
||||
|
||||
Qualsiasi cosa avvenga a una, avverrà anche all'altra.
|
||||
|
||||
La simmetria non si può rompere.
|
||||
|
||||
Se una diventa leader, diventa leader anche l'altra.
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
---
|
||||
aliases:
|
||||
- FloodMin
|
||||
- leader election su grafo di diametro noto
|
||||
---
|
||||
|
||||
[[algoritmo]] di [[leader election]] per [[grafo]] qualsiasi di [[diametro di un grafo|diametro]] noto.
|
||||
|
||||
> [!Summary]
|
||||
>
|
||||
> Effettua tante iterazioni quante il [[diametro di un grafo|diametro del grafo]], in cui ogni [[entità]] invia ai suoi vicini l'[[identificatore]] minimo visto fino a quel momento, propagando così gli identificatori ovunque.
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
Dopo l'ultima iterazione, tutte le [[entità]] avranno ricevuto e identificato uno stesso minimo, permettendo di determinare quale eleggere [[leader]].
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
Ad ogni iterazione, ogni [[entità]] manda un [[messaggio]] ad ogni vicino, per un totale di:
|
||||
$$
|
||||
2 \cdot Channels
|
||||
$$
|
||||
Essendo le iterazioni dipendenti dal [[diametro di un grafo|diametro del grafo]], possiamo dire che i messaggi inviati siano:
|
||||
$$
|
||||
Diameter \cdot 2 \cdot Channels
|
||||
$$
|
||||
Ovvero:
|
||||
$$
|
||||
\Large O(Diameter \cdot Channels)
|
||||
$$
|
||||
|
||||
### [[Tempo]]
|
||||
|
||||
Considerando che ogni iterazione dura un'unità di tempo, l'algoritmo terminerà dopo tanto tempo quanto il [[diametro di un grafo|diametro del grafo]]:
|
||||
$$
|
||||
Diameter
|
||||
$$
|
||||
|
||||
Ovvero:
|
||||
$$
|
||||
\Large O(Diameter)
|
||||
$$
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
[[algoritmo]] di [[leader election]] per [[albero|alberi]].
|
||||
|
||||
> [!Summary]
|
||||
> La radice diventa automaticamente il [[leader]].
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
[[algoritmo]] di [[leader election]] su [[anello]].
|
||||
|
||||
> [!Summary]
|
||||
> Ogni [[entità]] invia il suo [[identificatore]] alla successiva, e gli inoltra gli identificatori ricevuti dalla precedente, tenendo traccia dell'identificatore minimo ricevuto.
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
> [!Error]
|
||||
>
|
||||
> L'algoritmo non giungerà mai a termine!
|
||||
>
|
||||
> Sono necessarie restrizioni aggiuntive, vedi:
|
||||
> - [[leader election su anello di dimensione conosciuta all-the-way]]
|
||||
> - [[leader election su anello first-in-first-out all-the-way]]
|
||||
|
||||
|
|
@ -0,0 +1,101 @@
|
|||
[[algoritmo]] di [[leader election]] su [[anello]].
|
||||
|
||||
> [!Summary]
|
||||
>
|
||||
> Ogni [[entità]] riceve identificatori dalla precedente, tenendo traccia dell'identificatore minimo ricevuto, e inoltra alla successiva qualsiasi cambiamento al proprio minimo.
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
Quando il futuro [[leader]] avrà ricevuto dalla precedente il suo stesso identificatore, l'algoritmo avrà terminato.
|
||||
|
||||
> [!Note]
|
||||
>
|
||||
> La [[terminazione locale|terminazione è locale solo per il leader]], le altre entità hanno bisogno di un [[broadcast problem|broadcast]].
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
==Includere la terminazione nel costo computazionale?==
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
#### Caso peggiore
|
||||
|
||||
Il caso peggiore è quello in cui le [[entità]] sono [[iniziatori multipli|tutte iniziatrici]] e in ordine crescente di [[identificatore]].
|
||||
|
||||
Assumendo un [[ritardo di comunicazione unitario]], avremo che:
|
||||
1. il massimo sarà propagato per $1$ messaggio
|
||||
2. il secondo massimo sarà propagato per $2$ messaggi
|
||||
3. $\dots$
|
||||
4. il minimo sarà propagato per $Entities$ messaggi
|
||||
|
||||
Totalizzando:
|
||||
$$
|
||||
\sum_{Identifier=1}^{Entities} Identifier
|
||||
$$
|
||||
|
||||
Ovvero:
|
||||
$$
|
||||
\frac
|
||||
{Entities \cdot (Entities + 1)}
|
||||
{2}
|
||||
$$
|
||||
|
||||
[[notazione asintotica|Asintoticamente]]:
|
||||
$$
|
||||
\Large O \left( Entities^2 \right)
|
||||
$$
|
||||
|
||||
#### Caso migliore
|
||||
|
||||
Il caso peggiore è quello in cui ==le [[entità]] sono [[iniziatori multipli|tutte iniziatrici]]== e in ordine decrescente di [[identificatore]].
|
||||
|
||||
==Assumendo un [[ritardo di comunicazione unitario]]==, avremo che:
|
||||
1. il minimo sarà propagato per $Entities$ messaggi
|
||||
2. tutti gli altri per $1$ messaggio
|
||||
|
||||
Totalizzando:
|
||||
$$
|
||||
Entities
|
||||
+
|
||||
\sum_{Identifier=2}^{Entities} 1
|
||||
$$
|
||||
|
||||
Ovvero:
|
||||
$$
|
||||
Entities + (Entities - 1)
|
||||
$$
|
||||
[[notazione asintotica|Asintoticamente]]:
|
||||
$$
|
||||
\Large \Omega \left( Entities \right)
|
||||
$$
|
||||
|
||||
### [[Tempo]]
|
||||
|
||||
#### Caso peggiore
|
||||
|
||||
Il caso peggiore è quello in cui l'[[entità]] [[iniziatore singolo|iniziatrice è unica]] e alla massima distanza possibile dal futuro [[leader]].
|
||||
|
||||
Essa dovrà svegliare il leader, richiedendo:
|
||||
$$
|
||||
\color{LightCoral} Entities-1
|
||||
$$
|
||||
|
||||
E poi l'identificatore del leader dovrà viaggiare per tutto l'anello, richiedendo:
|
||||
$$
|
||||
\color{SkyBlue} Entities
|
||||
$$
|
||||
|
||||
Per un totale di:
|
||||
$$
|
||||
{\color{LightCoral} Entities-1}
|
||||
+
|
||||
{\color{SkyBlue} Entities}
|
||||
$$
|
||||
Cioè:
|
||||
$$
|
||||
2 \cdot Entities - 1
|
||||
$$
|
||||
[[notazione asintotica|Asintoticamente]]:
|
||||
$$
|
||||
\Large O( Entities )
|
||||
$$
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
[[algoritmo]] di [[leader election]] su [[anello]].
|
||||
|
||||
> [!Summary]
|
||||
> Effettua iterazioni in cui ogni [[entità]] che potrebbe diventare potenzialmente [[leader]] diffonde il proprio [[identificatore]] a tutte le altre entro una certa distanza.
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
### `CANDIDATE`
|
||||
|
||||
All'inizio di ogni iterazione, invia e fa inoltrare il proprio [[identificatore]] ai vicini (in entrambe le direzioni) a distanza $2^{Iteration}$.
|
||||
|
||||
Se il [[messaggio]] raggiunge la distanza massima senza incontrare un [[identificatore]] minore, viene rimandato indietro.
|
||||
|
||||
Se il `CANDIDATE` riceve indietro il suo identificatore da entrambe le direzioni, allora passa all'iterazione successiva.
|
||||
|
||||
Se il `CANDIDATE` riceve indietro il suo identificatore da entrambe le direzioni, ma in direzione scambiate, allora esso diventa il [[leader]].
|
||||
|
||||
### `DEFEATED`
|
||||
|
||||
Sapendo sicuramente di non essere il leader, si limita a inoltrare messaggi.
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
Ad ogni iterazione, ogni candidato invia e riceve su ogni lato:
|
||||
$$
|
||||
\color{Gold} 2 ^ {Iteration}
|
||||
$$
|
||||
Sommando andata e ritorno:
|
||||
$$
|
||||
{\color{Gold} 2} \cdot 2 ^ {Iteration}
|
||||
$$
|
||||
Sommando i due lati:
|
||||
$$
|
||||
{\color{Gold} 2} \cdot 2 \cdot 2^{Iteration}
|
||||
$$
|
||||
Sommando tutti i `CANDIDATE`:
|
||||
$$
|
||||
{\color{Gold} \mathrm{floor} \left(
|
||||
\frac{n}{2^{Iteration - 1} + 1}
|
||||
\right)}
|
||||
\cdot 2 \cdot 2 \cdot 2 ^ {Iteration}
|
||||
$$
|
||||
|
||||
==Qui la prof fa dei calcoli. Ho troppo sonno per capirli.==
|
||||
|
|
@ -0,0 +1,65 @@
|
|||
[[algoritmo]] di [[leader election]] che risolve il problema di terminazione della [[leader election su anello all-the-way]] ***introducendo una [[restrizione di topologia]] aggiuntiva.***
|
||||
|
||||
> [!Summary]
|
||||
> Ogni [[entità]] invia il suo [[identificatore]] alla successiva, e gli inoltra gli identificatori ricevuti dalla precedente, tenendo traccia dell'identificatore minimo ricevuto, ***fino a quando non ne conosce tanti quante le [[entità]] del [[sistema distribuito]]***.
|
||||
|
||||
## [[Comportamento]] aggiuntivo
|
||||
|
||||
Si può effettuare il conteggio in due modi:
|
||||
- con un [[contatore]] su ogni [[entità]], che conta il numero di [[messaggio|messaggi]] transitati
|
||||
- ==con un contatore su un messaggio==
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
L'algoritmo termina quando tutte le [[entità]] hanno visto tanti [[messaggio|messaggi]] quante le [[entità]] del [[sistema distribuito]].
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
Ogni [[entità]] invia tanti [[messaggio|messaggi]] quanti le [[entità]] del sistema distribuito, ovvero:
|
||||
$$
|
||||
Entity \cdot Entity
|
||||
$$
|
||||
|
||||
In [[notazione asintotica]], è:
|
||||
$$
|
||||
\Large O \left( Entity^2 \right)
|
||||
$$
|
||||
|
||||
### [[Spazio]]
|
||||
|
||||
Nel caso peggiore, ciascun messaggio contiene tanti [[bit]] quanti quelli dell'identificatore più grande, ovvero, in [[notazione asintotica]]:
|
||||
$$
|
||||
\Large O \left( Entity^2 \cdot \log( \max(Identifier) ) \right)
|
||||
$$
|
||||
|
||||
### [[Tempo]]
|
||||
|
||||
Nel caso peggiore, solo una [[entità]] è [[iniziatori multipli|iniziatrice]], e in tal caso, dovrà svegliare le altre con il proprio messaggio.
|
||||
|
||||
Il messaggio dovrà prima arrivare alla sua precedente, richiedendo:
|
||||
$$
|
||||
\color{LightCoral} Entities -1
|
||||
$$
|
||||
|
||||
Poi, il messaggio della precedente dovrà fare un giro completo:
|
||||
$$
|
||||
\color{SkyBlue} Entities
|
||||
$$
|
||||
|
||||
Per un totale di:
|
||||
$$
|
||||
{\color{LightCoral} Entities -1}
|
||||
+
|
||||
{\color{SkyBlue} Entities}
|
||||
$$
|
||||
Ovvero:
|
||||
$$
|
||||
2 \cdot Entities - 1
|
||||
$$
|
||||
|
||||
Che in [[notazione asintotica]] è:
|
||||
$$
|
||||
\Large O(Entities)
|
||||
$$
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
[[algoritmo]] di [[leader election]] su [[grafo aciclico|grafi aciclici]].
|
||||
|
||||
> [!Summary]
|
||||
> Usa la [[tecnica di saturazione per grafi aciclici]] per trovare l'entità con [[identificatore]] minore, che viene poi scelta come [[leader]].
|
||||
|
||||
## Duale
|
||||
|
||||
Il duale di questo algoritmo è lo [[shout+ protocol]].
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
Problema per un [[sistema distribuito]].
|
||||
|
||||
## Definizione
|
||||
|
||||
Si vuole scegliere un'[[entità]] che diventerà il [[leader]] per un [[algoritmo]] futuro.
|
||||
|
||||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- [[iniziatori multipli]]
|
||||
- [[identificatori univoci]]
|
||||
- **[[Angluin 1980]]**: questo problema è irrisolvibile senza identificatori univoci
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[full-duplex|grafo indiretto]]
|
||||
- [[grafo connesso]]
|
||||
- [[half-duplex|grafo diretto]]
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- [[ritardo di comunicazione unitario]]
|
||||
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
||||
- **[[leader election su albero]]**
|
||||
- **[[leader election su grafo aciclico]]**
|
||||
- **leader election su anello**
|
||||
- [[leader election su anello all-the-way|all-the-way]]
|
||||
- [[leader election su anello as-far-as-it-can|as-far-as-it-can]]
|
||||
- [[leader election su anello controlled-distance|controlled-distance]]
|
||||
- **leader election su grafo qualsiasi**
|
||||
- [[FloodMax]]
|
||||
|
|
@ -1 +1,28 @@
|
|||
{}
|
||||
{
|
||||
"nodes":[
|
||||
{"id":"18ea906d1635d485","type":"group","x":660,"y":900,"width":920,"height":3080,"color":"5","label":"Anello"},
|
||||
{"id":"59e651b187da9388","type":"group","x":660,"y":4100,"width":920,"height":1000,"color":"5","label":"Grafo di diametro noto"},
|
||||
{"id":"740207a9a63c9513","type":"group","x":660,"y":340,"width":920,"height":440,"color":"5","label":"Grafo aciclico"},
|
||||
{"id":"e7d0f7c50e744dfe","type":"group","x":660,"y":-260,"width":920,"height":440,"color":"5","label":"Albero"},
|
||||
{"id":"26a2bda47738d7d8","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election.md","x":-440,"y":-240,"width":960,"height":5320},
|
||||
{"id":"b672c8042ef8c199","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader.md","x":-160,"y":-800,"width":400,"height":400},
|
||||
{"id":"c1f4d995f9345928","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su albero.md","x":680,"y":-240,"width":400,"height":400},
|
||||
{"id":"5c61b7c7c5e2883d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello all-the-way.md","x":680,"y":920,"width":400,"height":960},
|
||||
{"id":"855e7d4c6a36c000","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su grafo aciclico.md","x":680,"y":360,"width":400,"height":400},
|
||||
{"id":"1c59488cd9ea817b","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello di dimensione conosciuta all-the-way.md","x":1160,"y":920,"width":400,"height":960},
|
||||
{"id":"bf49d10d32c845a4","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello as-far-as-it-can.md","x":680,"y":1960,"width":400,"height":960},
|
||||
{"id":"90c13d04acf28d97","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/Angluin 1980.md","x":-1000,"y":2220,"width":400,"height":400},
|
||||
{"id":"060624bd1d86f910","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello controlled-distance.md","x":680,"y":3000,"width":400,"height":960},
|
||||
{"id":"57cedce16261c4ec","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/FloodMax.md","x":680,"y":4120,"width":400,"height":960}
|
||||
],
|
||||
"edges":[
|
||||
{"id":"76ba628c35000191","fromNode":"b672c8042ef8c199","fromSide":"bottom","toNode":"26a2bda47738d7d8","toSide":"top"},
|
||||
{"id":"cda326f2ebfde877","fromNode":"26a2bda47738d7d8","fromSide":"left","toNode":"90c13d04acf28d97","toSide":"right"},
|
||||
{"id":"a1a857c258bceb6c","fromNode":"26a2bda47738d7d8","fromSide":"right","toNode":"e7d0f7c50e744dfe","toSide":"left"},
|
||||
{"id":"07e67d6f2da22ee6","fromNode":"26a2bda47738d7d8","fromSide":"right","toNode":"740207a9a63c9513","toSide":"left"},
|
||||
{"id":"63b2664f9a3c7489","fromNode":"5c61b7c7c5e2883d","fromSide":"right","toNode":"1c59488cd9ea817b","toSide":"left"},
|
||||
{"id":"3d8a52267df701d9","fromNode":"5c61b7c7c5e2883d","fromSide":"bottom","toNode":"bf49d10d32c845a4","toSide":"top"},
|
||||
{"id":"34c21c398375393a","fromNode":"26a2bda47738d7d8","fromSide":"right","toNode":"18ea906d1635d485","toSide":"left"},
|
||||
{"id":"29ea3a738fc0be45","fromNode":"26a2bda47738d7d8","fromSide":"right","toNode":"59e651b187da9388","toSide":"left"}
|
||||
]
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue