mirror of
https://github.com/Steffo99/appunti-magistrali.git
synced 2024-11-24 03:04:18 +00:00
Refine and unify terms
This commit is contained in:
parent
21f3695c13
commit
2eca871583
GPG key ID:
2A24051445686895
50 changed files with 692 additions and 827 deletions
22
.obsidian/plugins/obsidian-file-color/data.json
vendored
22
.obsidian/plugins/obsidian-file-color/data.json
vendored
|
|
@ -273,10 +273,6 @@
|
|||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "steffo-file-index.json",
|
||||
"color": "me4XBNQC4rwzQFLlvIAn0"
|
||||
|
|
@ -378,7 +374,7 @@
|
|||
"color": "7j7Pqog0VHMVVAfazMNlb"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/★ computation in trees.canvas",
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/★ computazione.canvas",
|
||||
"color": "7j7Pqog0VHMVVAfazMNlb"
|
||||
},
|
||||
{
|
||||
|
|
@ -389,17 +385,17 @@
|
|||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/traversal+ protocol.md",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"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"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello di dimensione conosciuta all-the-way.md",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello as-far-as-it-can.md",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
}
|
||||
]
|
||||
}
|
||||
1
0 - Generale/albero.md
Normal file
1
0 - Generale/albero.md
Normal file
|
|
@ -0,0 +1 @@
|
|||
[[grafo aciclico]] con [[radice di un albero|radice]] specificata.
|
||||
1
0 - Generale/grafo aciclico.md
Normal file
1
0 - Generale/grafo aciclico.md
Normal file
|
|
@ -0,0 +1 @@
|
|||
[[grafo]] in cui non esistono [[ciclo|cicli]].
|
||||
|
|
@ -4,4 +4,4 @@ aliases: ["PKI"]
|
|||
|
||||
Approccio [[centralizzazione|centralizzato]] alla [[delegated verification]].
|
||||
|
||||
[[Albero]] delle relazioni di [[fiducia]] tra alcuni [[user agent]], la cui [[trust anchor]] è detta [[certification authority]].
|
||||
[[albero]] delle relazioni di [[fiducia]] tra alcuni [[user agent]], la cui [[trust anchor]] è detta [[certification authority]].
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
[[restrizione di affidabilità]].
|
||||
|
||||
Specifica che da un certo momento in poi non ci saranno ulteriori [[guasto|guasti]], ma che potrebbero esserci stati in passato.
|
||||
Specifica che ***da un certo momento in poi non ci saranno ulteriori [[guasto|guasti]]***.
|
||||
|
||||
> [!Tip]
|
||||
> Potrebbero essere avvenuti in passato, però!
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
[[restrizione di affidabilità]].
|
||||
|
||||
Specifica che non potranno mai avvenire [[guasto|guasti]].
|
||||
Specifica che non potranno ***mai*** avvenire [[guasto|guasti]].
|
||||
|
|
|
|||
|
|
@ -4,6 +4,8 @@ Un'[[entità]] può sempre distinguere nel suo [[vicinato]]:
|
|||
- quanti sono i vicini
|
||||
- quali sono i vicini
|
||||
|
||||
==Perchè si chiama così? Abbiamo usato "orientamento locale" anche in altri modi...==
|
||||
|
||||
> [!EXAMPLE]
|
||||
> Conoscono l'indirizzo IP dei loro vicini, ma non quello di tutti gli altri.
|
||||
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
[[restrizione di affidabilità]].
|
||||
|
||||
Specifica che tutti i [[messaggio|messaggi]] inviati sono ricevuti senza [[guasto|guasti]].
|
||||
Specifica che tutti i [[messaggio|messaggi]] inviati saranno ricevuti senza [[guasto|guasti]].
|
||||
|
|
|
|||
|
|
@ -13,3 +13,6 @@ Ha:
|
|||
- [[stato di un'entità|stato]]: **[[individuale]]**
|
||||
- [[comportamento]]: **[[condiviso]]**
|
||||
- [[output]]: **[[condiviso]]**
|
||||
|
||||
> [!Tip]
|
||||
> Nell'analogia [[sistema distribuito]]-[[grafo]], un'entità è un [[nodo di un grafo|nodo]].
|
||||
|
|
|
|||
|
|
@ -3,6 +3,6 @@ aliases:
|
|||
- grafo indiretto
|
||||
---
|
||||
|
||||
[[restrizione di topologia]] applicabile a un [[canale di comunicazione]].
|
||||
[[restrizione di comunicazione]] applicabile a un [[canale di comunicazione]].
|
||||
|
||||
Determina che entrambe le [[entità]] possono inviare e ricevere [[messaggio|messaggi]] in esso.
|
||||
|
|
|
|||
|
|
@ -3,6 +3,6 @@ aliases:
|
|||
- grafo diretto
|
||||
---
|
||||
|
||||
[[restrizione di topologia]] applicabile a un [[canale di comunicazione]].
|
||||
[[restrizione di comunicazione]] applicabile a un [[canale di comunicazione]].
|
||||
|
||||
Determina che una sola delle due [[entità]] può inviare [[messaggio|messaggi]] in esso, e che l'altra può solo riceverli.
|
||||
|
|
|
|||
|
|
@ -1,3 +0,0 @@
|
|||
[[restrizione di comunicazione]].
|
||||
|
||||
Prevede che sia già stato selezionato un singolo [[leader]] che dia il via all'[[algoritmo]].
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
[[restrizione di comunicazione]].
|
||||
|
||||
Prevede che qualsiasi [[entità]] possa dare il via all'algoritmo, anche se un'altra lo ha già fatto.
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
[[restrizione di affidabilità]].
|
||||
|
||||
Specifica che le [[entità]] non hanno modo di determinare quando avviene un [[guasto]].
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
---
|
||||
aliases:
|
||||
- iniziatori multipli
|
||||
---
|
||||
|
||||
[[restrizione di tempo]].
|
||||
|
||||
Specifica che, ai fini della risoluzione del [[problema]], la computazione necessaria all'avvio dell'esecuzione di un [[algoritmo]] è ***ignorata per determinate [[entità]]***, dette *iniziatrici*.
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
---
|
||||
aliases:
|
||||
- iniziatore singolo
|
||||
---
|
||||
|
||||
[[restrizione di tempo]].
|
||||
|
||||
Specifica che, ai fini della risoluzione del [[problema]], la computazione necessaria all'avvio dell'esecuzione di un [[algoritmo]] è ***ignorata per una singola [[entità]]***, detta [[leader]].
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
[[restrizione di tempo]].
|
||||
|
||||
Specifica che, ai fini della risoluzione del [[problema]], la computazione necessaria all'avvio dell'esecuzione di un [[algoritmo]] è ***ignorata***.
|
||||
|
|
@ -1,5 +1,6 @@
|
|||
[[restrizione di tempo]].
|
||||
|
||||
Specifica che le [[entità]] partecipanti vengono a conoscenza di quando l'algoritmo è terminato per tutti i partecipanti.
|
||||
Specifica che, ai fini della risoluzione del [[problema]], il [[algoritmo corretto|requisito di terminazione di un algoritmo]] è soddisfatto quando ***tutte le [[entità]] partecipanti conoscono quando l'intera computazione è terminata***.
|
||||
|
||||
È un problema a sè stante, il [[termination detection problem]].
|
||||
> [!Example]
|
||||
> L'abbiamo visto in [[★ sistemi complessi]]: la [[sincronizzazione del plotone di esecuzione]]!
|
||||
|
|
|
|||
|
|
@ -0,0 +1,6 @@
|
|||
[[restrizione di tempo]].
|
||||
|
||||
Specifica che, ai fini della risoluzione del [[problema]], il [[algoritmo corretto|requisito di terminazione di un algoritmo]] è ***ignorato***.
|
||||
|
||||
> [!Warning]
|
||||
> In tal caso, sarebbe più una [[procedura]] che un [[algoritmo]]...
|
||||
|
|
@ -1,3 +1,6 @@
|
|||
[[restrizione di tempo]].
|
||||
|
||||
Specifica che le [[entità]] partecipanti conoscono quando la loro partecipazione è terminata, ma non quando è terminata quella di tutte le altre.
|
||||
Specifica che, ai fini della risoluzione del [[problema]], il [[algoritmo corretto|requisito di terminazione di un algoritmo]] è soddisfatto quando ***tutte le [[entità]] partecipanti conoscono quando la loro partecipazione individuale è terminata***.
|
||||
|
||||
> [!Tip]
|
||||
> È quello usato più di frequente!
|
||||
|
|
|
|||
|
|
@ -0,0 +1,8 @@
|
|||
---
|
||||
aliases:
|
||||
- vicino
|
||||
- vicinato
|
||||
- vicini
|
||||
---
|
||||
|
||||
Relativamente ad una data [[entità]], sono *vicini* tutte le altre [[entità]] a cui è direttamente [[rete di comunicazione|connessa]] attraverso un [[canale di comunicazione]].
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"nodes":[
|
||||
{"id":"0e88c8c55309b762","type":"group","x":220,"y":-2860,"width":2440,"height":2480,"label":"Restrizioni del modello"},
|
||||
{"id":"0e88c8c55309b762","type":"group","x":220,"y":-2300,"width":2440,"height":1920,"label":"Restrizioni del modello"},
|
||||
{"id":"de6e2a65c63084c7","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/stato di un'entità.md","x":800,"y":-160,"width":400,"height":400},
|
||||
{"id":"7126bfdd6ead22a9","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/insieme degli stati di un'entità.md","x":1360,"y":-160,"width":400,"height":400},
|
||||
{"id":"c986480451be1efe","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/entità.md","x":240,"y":-160,"width":400,"height":400},
|
||||
|
|
@ -8,7 +8,6 @@
|
|||
{"id":"40f55b66f9214ecd","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/sistema distribuito.md","x":-320,"y":-1360,"width":400,"height":400},
|
||||
{"id":"97624a26a3c7d126","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/sistema sequenziale.md","x":-320,"y":-2480,"width":400,"height":400},
|
||||
{"id":"97d5f142a5c95ce3","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/sistema parallelo.md","x":-320,"y":-1920,"width":400,"height":400},
|
||||
{"id":"961e2a0551edc3c5","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di comunicazione.md","x":800,"y":-2840,"width":400,"height":200},
|
||||
{"id":"bdeb2e85bcb32f7e","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizioni al modello dei sistemi distribuiti.md","x":240,"y":-800,"width":400,"height":400},
|
||||
{"id":"d8754617f38feb06","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/canale di comunicazione.md","x":-320,"y":400,"width":400,"height":400},
|
||||
{"id":"afa296d887da4394","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/evento.md","x":-600,"y":1520,"width":400,"height":400},
|
||||
|
|
@ -35,25 +34,30 @@
|
|||
{"id":"7307a3e6d21d094d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/criterio di costo asincrono.md","x":-2000,"y":-1120,"width":400,"height":200},
|
||||
{"id":"3c2d2701a7095e82","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/criterio di costo sincrono.md","x":-2000,"y":-1400,"width":400,"height":200},
|
||||
{"id":"9abf440226d21d98","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/assioma dell'orientamento locale.md","x":-880,"y":-160,"width":400,"height":400},
|
||||
{"id":"5f79f222c02d34a4","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/iniziatore singolo.md","x":1280,"y":-2840,"width":400,"height":200},
|
||||
{"id":"8feba6ce763a0898","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/iniziatori multipli.md","x":1760,"y":-2840,"width":400,"height":200},
|
||||
{"id":"55006dcc3b515353","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione locale.md","x":1280,"y":-1160,"width":400,"height":200},
|
||||
{"id":"d12cedf357c12705","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione globale.md","x":1760,"y":-1160,"width":400,"height":200},
|
||||
{"id":"4a1b9354e73b16bc","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/identificatori univoci.md","x":1280,"y":-1440,"width":400,"height":200},
|
||||
{"id":"2d21a7ed903a16e7","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di tempo.md","x":800,"y":-1160,"width":400,"height":760},
|
||||
{"id":"83b3be69f6f3d497","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/timeout.md","x":2000,"y":-880,"width":400,"height":200},
|
||||
{"id":"dbe3b5d5f2baeb7f","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione illimitato.md","x":1280,"y":-600,"width":400,"height":200},
|
||||
{"id":"472610beeef20101","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione limitato.md","x":1760,"y":-600,"width":400,"height":200},
|
||||
{"id":"ca6adc368f6aed21","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/channel failure detection.md","x":1280,"y":-2560,"width":400,"height":200},
|
||||
{"id":"887f1f52394b3721","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/affidabilità parziale.md","x":1280,"y":-2280,"width":400,"height":200},
|
||||
{"id":"b69def8d92ba28df","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/consegna garantita.md","x":1280,"y":-2000,"width":400,"height":200},
|
||||
{"id":"281bcf7f0a4b5be1","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di affidabilità.md","x":800,"y":-2560,"width":400,"height":760},
|
||||
{"id":"7d0f048f4b43f33d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/full-duplex.md","x":1760,"y":-1720,"width":400,"height":200},
|
||||
{"id":"ce3d37417ee5bf4d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/half-duplex.md","x":1280,"y":-1720,"width":400,"height":200},
|
||||
{"id":"0951993b4f64f1b4","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di topologia.md","x":800,"y":-1720,"width":400,"height":480},
|
||||
{"id":"fc4c48607c9ae580","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione unitario.md","x":2240,"y":-600,"width":400,"height":200},
|
||||
{"id":"a16e77231955a7a3","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/entity failure detection.md","x":1760,"y":-2560,"width":400,"height":200},
|
||||
{"id":"6b3170059dad55ef","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/affidabilità totale.md","x":1760,"y":-2280,"width":400,"height":200}
|
||||
{"id":"dbe3b5d5f2baeb7f","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione illimitato.md","x":1280,"y":-600,"width":400,"height":200,"color":"3"},
|
||||
{"id":"472610beeef20101","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione limitato.md","x":1760,"y":-600,"width":400,"height":200,"color":"2"},
|
||||
{"id":"fc4c48607c9ae580","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione unitario.md","x":2240,"y":-600,"width":400,"height":200,"color":"1"},
|
||||
{"id":"02d82dc7842e6fc9","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/vicini di un'entità.md","x":-880,"y":400,"width":400,"height":400},
|
||||
{"id":"83b3be69f6f3d497","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/timeout.md","x":2000,"y":-160,"width":400,"height":400},
|
||||
{"id":"d58b2d089a2e67be","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione ignorata.md","x":1280,"y":-880,"width":400,"height":200,"color":"3"},
|
||||
{"id":"e61c5ee7f8dd35a5","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione locale.md","x":1760,"y":-880,"width":400,"height":200,"color":"2"},
|
||||
{"id":"6dc8e5e24bfa2114","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione globale.md","x":2240,"y":-880,"width":400,"height":200,"color":"1"},
|
||||
{"id":"5a382d3822a5736e","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/risveglio totale.md","x":1280,"y":-1160,"width":400,"height":200,"color":"3"},
|
||||
{"id":"00b0016663a07f0b","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/risveglio parziale.md","x":1760,"y":-1160,"width":400,"height":200,"color":"2"},
|
||||
{"id":"aa511f4700f8c6f7","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/risveglio singolo.md","x":2240,"y":-1160,"width":400,"height":200,"color":"1"},
|
||||
{"id":"4a1b9354e73b16bc","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/identificatori univoci.md","x":1760,"y":-1440,"width":400,"height":200,"color":"2"},
|
||||
{"id":"0951993b4f64f1b4","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di topologia.md","x":800,"y":-1440,"width":400,"height":200},
|
||||
{"id":"887f1f52394b3721","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/affidabilità parziale.md","x":1280,"y":-1720,"width":400,"height":200,"color":"3"},
|
||||
{"id":"6b3170059dad55ef","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/affidabilità totale.md","x":2240,"y":-1720,"width":400,"height":200,"color":"1"},
|
||||
{"id":"1ab217c2b661bb7d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/consegna garantita.md","x":1760,"y":-1720,"width":400,"height":200,"color":"2"},
|
||||
{"id":"281bcf7f0a4b5be1","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di affidabilità.md","x":800,"y":-2000,"width":400,"height":480},
|
||||
{"id":"093e569da1a08d91","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/entity failure detection.md","x":2240,"y":-2000,"width":400,"height":200,"color":"1"},
|
||||
{"id":"5888f088a7849b69","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/channel failure detection.md","x":1760,"y":-2000,"width":400,"height":200,"color":"2"},
|
||||
{"id":"7862502b2075f0a7","x":1280,"y":-2000,"width":400,"height":200,"color":"3","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/no failure detection.md"},
|
||||
{"id":"4f299bd36fec0431","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/half-duplex.md","x":1280,"y":-2280,"width":400,"height":200,"color":"3"},
|
||||
{"id":"961e2a0551edc3c5","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di comunicazione.md","x":800,"y":-2280,"width":400,"height":200},
|
||||
{"id":"7bf268e3d7b311a7","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/full-duplex.md","x":1760,"y":-2280,"width":400,"height":200,"color":"2"}
|
||||
],
|
||||
"edges":[
|
||||
{"id":"1bb35cb60ca4ea15","fromNode":"afa296d887da4394","fromSide":"bottom","toNode":"904bb8e648bdcb90","toSide":"top"},
|
||||
|
|
@ -87,14 +91,8 @@
|
|||
{"id":"4e22445bef4f3751","fromNode":"9ff0a423dbb281a0","fromSide":"bottom","toNode":"d8754617f38feb06","toSide":"top"},
|
||||
{"id":"c0e7edefcb021bbe","fromNode":"d8754617f38feb06","fromSide":"bottom","toNode":"6b49f0fc996cb192","toSide":"top"},
|
||||
{"id":"5956ff40fae387a3","fromNode":"c986480451be1efe","fromSide":"left","toNode":"d8754617f38feb06","toSide":"right"},
|
||||
{"id":"e25ad17df986933d","fromNode":"281bcf7f0a4b5be1","fromSide":"right","toNode":"ca6adc368f6aed21","toSide":"left"},
|
||||
{"id":"d17369530cedcf91","fromNode":"ca6adc368f6aed21","fromSide":"right","toNode":"a16e77231955a7a3","toSide":"left"},
|
||||
{"id":"bd17cdba235c81af","fromNode":"281bcf7f0a4b5be1","fromSide":"right","toNode":"b69def8d92ba28df","toSide":"left"},
|
||||
{"id":"d56cbf4dce71a7f3","fromNode":"281bcf7f0a4b5be1","fromSide":"right","toNode":"887f1f52394b3721","toSide":"left"},
|
||||
{"id":"d75e4e97c723ecbb","fromNode":"887f1f52394b3721","fromSide":"right","toNode":"6b3170059dad55ef","toSide":"left"},
|
||||
{"id":"2e95c9b13ce50fd0","fromNode":"472610beeef20101","fromSide":"top","toNode":"83b3be69f6f3d497","toSide":"bottom"},
|
||||
{"id":"d63be18341405890","fromNode":"472610beeef20101","fromSide":"right","toNode":"fc4c48607c9ae580","toSide":"left"},
|
||||
{"id":"17033b6f222151a8","fromNode":"fc4c48607c9ae580","fromSide":"top","toNode":"83b3be69f6f3d497","toSide":"bottom"},
|
||||
{"id":"b9abeefc64ec5360","fromNode":"806b3a8cfb46e427","fromSide":"bottom","toNode":"ce14b5c90fd5e953","toSide":"top"},
|
||||
{"id":"26e0891ec4447f53","fromNode":"40f55b66f9214ecd","fromSide":"left","toNode":"0663141369318ae1","toSide":"right"},
|
||||
{"id":"ec682837ca5406eb","fromNode":"0663141369318ae1","fromSide":"left","toNode":"5cb928eebbce8c85","toSide":"right"},
|
||||
|
|
@ -104,14 +102,24 @@
|
|||
{"id":"4e6bc2efe53e4e17","fromNode":"0663141369318ae1","fromSide":"left","toNode":"68d2646884fe10e3","toSide":"right"},
|
||||
{"id":"11e3f0f7f9977138","fromNode":"68d2646884fe10e3","fromSide":"left","toNode":"7307a3e6d21d094d","toSide":"right"},
|
||||
{"id":"0a39548d5dde3f7e","fromNode":"68d2646884fe10e3","fromSide":"left","toNode":"3c2d2701a7095e82","toSide":"right"},
|
||||
{"id":"459233fc20cad1e7","fromNode":"961e2a0551edc3c5","fromSide":"right","toNode":"5f79f222c02d34a4","toSide":"left"},
|
||||
{"id":"862f0a43ddf5a87a","fromNode":"5f79f222c02d34a4","fromSide":"right","toNode":"8feba6ce763a0898","toSide":"left"},
|
||||
{"id":"92889f0a7be5f7d4","fromNode":"55006dcc3b515353","fromSide":"right","toNode":"d12cedf357c12705","toSide":"left"},
|
||||
{"id":"02d76934b8ed7603","fromNode":"2d21a7ed903a16e7","fromSide":"right","toNode":"55006dcc3b515353","toSide":"left"},
|
||||
{"id":"7b82b81786037fe6","fromNode":"2d21a7ed903a16e7","fromSide":"right","toNode":"dbe3b5d5f2baeb7f","toSide":"left"},
|
||||
{"id":"13ecf8445dea426a","fromNode":"dbe3b5d5f2baeb7f","fromSide":"right","toNode":"472610beeef20101","toSide":"left"},
|
||||
{"id":"81615994263f9203","fromNode":"0951993b4f64f1b4","fromSide":"right","toNode":"4a1b9354e73b16bc","toSide":"left"},
|
||||
{"id":"946800279c546347","fromNode":"ce3d37417ee5bf4d","fromSide":"right","toNode":"7d0f048f4b43f33d","toSide":"left"},
|
||||
{"id":"60e9ac87e9ce4fc1","fromNode":"0951993b4f64f1b4","fromSide":"right","toNode":"ce3d37417ee5bf4d","toSide":"left"}
|
||||
{"id":"883f51fdca0cae63","fromNode":"d8754617f38feb06","fromSide":"left","toNode":"02d82dc7842e6fc9","toSide":"right"},
|
||||
{"id":"524c88f5c49126c8","fromNode":"2d21a7ed903a16e7","fromSide":"right","toNode":"d58b2d089a2e67be","toSide":"left"},
|
||||
{"id":"8edd4cd421b796c6","fromNode":"d58b2d089a2e67be","fromSide":"right","toNode":"e61c5ee7f8dd35a5","toSide":"left"},
|
||||
{"id":"ca3addc3261f366b","fromNode":"e61c5ee7f8dd35a5","fromSide":"right","toNode":"6dc8e5e24bfa2114","toSide":"left"},
|
||||
{"id":"b9d158fea7f2db64","fromNode":"2d21a7ed903a16e7","fromSide":"right","toNode":"5a382d3822a5736e","toSide":"left"},
|
||||
{"id":"b0b6bca60aa9b551","fromNode":"5a382d3822a5736e","fromSide":"right","toNode":"00b0016663a07f0b","toSide":"left"},
|
||||
{"id":"77a97e5a4f4671bd","fromNode":"00b0016663a07f0b","fromSide":"right","toNode":"aa511f4700f8c6f7","toSide":"left"},
|
||||
{"id":"6c788cd758713395","fromNode":"4f299bd36fec0431","fromSide":"right","toNode":"7bf268e3d7b311a7","toSide":"left"},
|
||||
{"id":"50384fcf0b6d5450","fromNode":"961e2a0551edc3c5","fromSide":"right","toNode":"4f299bd36fec0431","toSide":"left"},
|
||||
{"id":"24c8ccec6bcc6278","fromNode":"887f1f52394b3721","fromSide":"right","toNode":"1ab217c2b661bb7d","toSide":"left"},
|
||||
{"id":"652ed21c4a649f54","fromNode":"1ab217c2b661bb7d","fromSide":"right","toNode":"6b3170059dad55ef","toSide":"left"},
|
||||
{"id":"e360a93b41662c61","fromNode":"5888f088a7849b69","fromSide":"right","toNode":"093e569da1a08d91","toSide":"left"},
|
||||
{"id":"e49aefbf6eb92718","fromNode":"281bcf7f0a4b5be1","fromSide":"right","toNode":"7862502b2075f0a7","toSide":"left"},
|
||||
{"id":"a3aca459de8a94ba","fromNode":"7862502b2075f0a7","fromSide":"right","toNode":"5888f088a7849b69","toSide":"left"},
|
||||
{"id":"675055018ef6483c","fromNode":"472610beeef20101","fromSide":"bottom","toNode":"83b3be69f6f3d497","toSide":"top"},
|
||||
{"id":"ac5fdc2d569502ff","fromNode":"fc4c48607c9ae580","fromSide":"bottom","toNode":"83b3be69f6f3d497","toSide":"top"}
|
||||
]
|
||||
}
|
||||
|
|
@ -12,14 +12,14 @@ Una [[entità]] vuole comunicare un'informazione a tutto il resto del [[sistema
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- [[iniziatore singolo]]
|
||||
- [[half-duplex]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[grafo connesso]]
|
||||
- [[full-duplex|grafo indiretto]]
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- [[ritardo di comunicazione illimitato]]
|
||||
- [[risveglio singolo]]
|
||||
- [[terminazione locale]]
|
||||
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
|
@ -29,7 +29,7 @@ Una [[entità]] vuole comunicare un'informazione a tutto il resto del [[sistema
|
|||
- [[flooding v2]] ([[algoritmo corretto|corretto]].)
|
||||
- [[flooding v3]] (ottimizzato!)
|
||||
|
||||
## [[notazione Ω-grande|Lower bound]] [[costo computazionale|costo computazionale]]
|
||||
## [[costo computazionale|Costo computazionale]]
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
|
|
@ -59,7 +59,7 @@ $$
|
|||
\Large Nodes
|
||||
$$
|
||||
|
||||
### [[tempo]]
|
||||
### [[Tempo]]
|
||||
|
||||
#### In un [[grafo]] qualsiasi
|
||||
|
||||
|
|
|
|||
|
|
@ -1,38 +1,24 @@
|
|||
[[algoritmo]] ***[[algoritmo corretto|incorretto]]*** di [[broadcast problem]].
|
||||
[[algoritmo]] di [[broadcast problem]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Il [[leader]] invia il suo messaggio iniziale a tutti i vicini, e loro lo inoltrano a loro volta ai loro vicini.
|
||||
|
||||
## [[Comportamento]]
|
||||
Il [[leader]] è inizializzato allo stato `LEADER`, mentre tutti gli altri sono inizializzati allo stato `SLEEPING`.
|
||||
|
||||
### `LEADER`
|
||||
|
||||
All'[[impulso spontaneo|inizio dell'algoritmo]], invia il suo messaggio:
|
||||
```rust
|
||||
spontaneously! {
|
||||
send!(*, Message {...});
|
||||
}
|
||||
```
|
||||
All'[[impulso spontaneo|inizio dell'algoritmo]], invia il suo [[messaggio]] a tutti i vicini.
|
||||
|
||||
Se lo riceve indietro, non fa niente:
|
||||
```rust
|
||||
on_receive! {
|
||||
_ => {},
|
||||
}
|
||||
```
|
||||
Ignora qualsiasi altra cosa riceva.
|
||||
|
||||
### `SLEEPING`
|
||||
|
||||
Se riceve il messaggio, lo inoltra a tutti i suoi vicini:
|
||||
```rust
|
||||
on_receive! {
|
||||
_ => send!(*, msg)
|
||||
}
|
||||
```
|
||||
Se riceve il [[messaggio]] del `LEADER`, lo inoltra a tutti i vicini.
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
> [!DANGER] Algoritmo incorretto
|
||||
> [!Failure]
|
||||
>
|
||||
> Questo algoritmo non termina mai!
|
||||
> È riportato qui solo come base per le due versioni successive.
|
||||
> Questo algoritmo potrebbe non terminare mai, in quanto due [[entità]] potrebbero inoltrarsi il [[messaggio]] del [[#`LEADER`]] all'infinito.
|
||||
|
|
|
|||
|
|
@ -1,51 +1,37 @@
|
|||
[[algoritmo]] di [[broadcast problem]] che risolve l'incorrettezza del [[flooding v1]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Il [[leader]] invia il suo messaggio iniziale a tutti i vicini, e, ***se è la prima volta che lo ricevono***, loro lo inoltrano a loro volta ai loro vicini.
|
||||
|
||||
## [[Comportamento]]
|
||||
Il [[leader]] è inizializzato allo stato `LEADER`, mentre tutti gli altri sono inizializzati allo stato `SLEEPING`.
|
||||
|
||||
### `LEADER`
|
||||
|
||||
All'[[impulso spontaneo|inizio dell'algoritmo]], invia il suo messaggio:
|
||||
```rust
|
||||
spontaneously! {
|
||||
send!(*, Message {...});
|
||||
state!(DONE);
|
||||
}
|
||||
```
|
||||
|
||||
Se lo riceve indietro, non fa niente:
|
||||
```rust
|
||||
on_receive! {
|
||||
_ => {},
|
||||
}
|
||||
```
|
||||
All'[[impulso spontaneo|inizio dell'algoritmo]], invia il suo [[messaggio]] a tutti i vicini, ***poi passa allo stato `DONE`***.
|
||||
|
||||
### `SLEEPING`
|
||||
|
||||
Se riceve il messaggio, lo inoltra a tutti i suoi vicini, poi passa allo stato `DONE`:
|
||||
```rust
|
||||
on_receive! {
|
||||
_ => {
|
||||
send!(*, msg);
|
||||
state!(DONE);
|
||||
},
|
||||
}
|
||||
```
|
||||
Se riceve il [[messaggio]] del `LEADER`, lo inoltra a tutti i vicini, ***poi passa allo stato `DONE`***.
|
||||
|
||||
### `DONE`
|
||||
### ***`DONE`***
|
||||
|
||||
Non fa niente.
|
||||
***Ignora qualsiasi cosa riceva.***
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
Per via dell'ipotesi di [[grafo connesso]], tutte le [[entità]] riceveranno eventualmente il [[messaggio]] inviato.
|
||||
|
||||
Con la ricezione del [[messaggio]], eventualmente tutte le [[entità]] diventeranno `DONE`, raggiungendo [[terminazione locale]].
|
||||
> [!Success]
|
||||
>
|
||||
> Per via dell'ipotesi di [[grafo connesso]], tutte le [[entità]] eventualmente riceveranno e inoltreranno il [[messaggio]] del [[leader]], diventando `DONE`.
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione]] | $O(Channels)$ |
|
||||
| [[tempo]] | $O(Channels)$ |
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
Attraverso ogni [[canale di comunicazione|canale]] passeranno al massimo due [[messaggio|messaggi]]:
|
||||
|
|
@ -63,13 +49,12 @@ $$
|
|||
\Large O(Channels)
|
||||
$$
|
||||
|
||||
### [[Spazio]]
|
||||
### [[Tempo]]
|
||||
|
||||
Un multiplo del [costo di comunicazione](#Comunicazione), sempre [[notazione asintotica|asintotico]] a:
|
||||
Il [[grafo]] potrebbe essere un [[cammino]], che richiederebbe che ogni arco venisse attraversato, quindi sicuramente:
|
||||
$$
|
||||
\Large O(Channels)
|
||||
$$
|
||||
|
||||
### [[Tempo]]
|
||||
|
||||
Coincide con il lower bound del [[broadcast problem]].
|
||||
> [!Note]
|
||||
> Coincide con il lower bound del [[broadcast problem]].
|
||||
|
|
|
|||
|
|
@ -1,38 +1,19 @@
|
|||
[[algoritmo]] di [[broadcast problem]] che riduce il [[comunicazione|numero di messaggi]] rispetto al [[flooding v2]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Il [[leader]] invia il suo [[messaggio]] iniziale a tutti i vicini, e, se è la prima volta che lo ricevono, loro lo inoltrano a loro volta ai loro vicini ***tranne quello che gliel'ha inviato***.
|
||||
|
||||
## [[Comportamento]]
|
||||
Il [[leader]] è inizializzato allo stato `LEADER`, mentre tutti gli altri sono inizializzati allo stato `SLEEPING`.
|
||||
|
||||
### `LEADER`
|
||||
|
||||
All'[[impulso spontaneo|inizio dell'algoritmo]], invia il suo [[messaggio]]:
|
||||
```rust
|
||||
spontaneously! {
|
||||
send!(*, Message {...});
|
||||
state!(DONE);
|
||||
}
|
||||
```
|
||||
|
||||
Se lo riceve indietro, non fa niente:
|
||||
```rust
|
||||
on_receive! {
|
||||
_ => {},
|
||||
}
|
||||
```
|
||||
All'[[impulso spontaneo|inizio dell'algoritmo]], invia il suo [[messaggio]] a tutti i vicini, poi passa allo stato `DONE`***.
|
||||
|
||||
### `SLEEPING`
|
||||
|
||||
Se riceve il [[messaggio]], lo inoltra a tutti i suoi vicini, poi passa allo stato `DONE`:
|
||||
```rust
|
||||
on_receive! {
|
||||
_ => {
|
||||
send!(!sender, msg);
|
||||
state!(DONE);
|
||||
},
|
||||
}
|
||||
```
|
||||
Se riceve il [[messaggio]] del `LEADER`, lo inoltra a tutti i vicini ***tranne quello che gliel'ha inviato***, poi passa allo stato `DONE`.
|
||||
|
||||
### `DONE`
|
||||
|
||||
|
|
@ -40,13 +21,20 @@ Non fa niente.
|
|||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
Vedi [[flooding v2]].
|
||||
> [!Success]
|
||||
>
|
||||
> Per via dell'ipotesi di [[grafo connesso]], tutte le [[entità]] eventualmente riceveranno e inoltreranno il [[messaggio]] del [[leader]], diventando `DONE`.
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione]] | $O(Channels)$ |
|
||||
| [[tempo]] | $O(Channels)$ |
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
Il costo computazionale è lo stesso del [[flooding v2]], ma con un trasferimento in meno per ogni [[entità]] che non è il [[leader]]:
|
||||
Il costo computazionale è lo stesso del [[flooding v2]], ma ***con un trasferimento in meno per ogni [[entità]] che non è il [[leader]]***:
|
||||
$$
|
||||
2 \cdot Channels - (Entities - 1)
|
||||
$$
|
||||
|
|
@ -56,13 +44,16 @@ $$
|
|||
\Large O(Channels)
|
||||
$$
|
||||
|
||||
### [[Spazio]]
|
||||
> [!Note]
|
||||
>
|
||||
> ***Coincide con il lower bound del [[broadcast problem]].***
|
||||
|
||||
Un multiplo del [costo di comunicazione](#Comunicazione), sempre [[notazione asintotica|asintotico]] a:
|
||||
### [[Tempo]]
|
||||
|
||||
Il [[grafo]] potrebbe essere un [[cammino]], che richiederebbe che ogni arco venisse attraversato, quindi sicuramente:
|
||||
$$
|
||||
\Large O(Channels)
|
||||
$$
|
||||
|
||||
### [[Tempo]]
|
||||
|
||||
Vedi [[flooding v2]].
|
||||
> [!Note]
|
||||
>Coincide con il lower bound del [[broadcast problem]].
|
||||
|
|
|
|||
|
|
@ -7,14 +7,14 @@ Problema per un [[sistema distribuito]], variante del [[broadcast problem]].
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- ***[[iniziatori multipli]]***
|
||||
- [[full-duplex|grafo indiretto]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[grafo connesso]]
|
||||
- [[full-duplex|grafo indiretto]]
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- [[ritardo di comunicazione illimitato]]
|
||||
- ***[[risveglio parziale]]***
|
||||
- [[terminazione locale]]
|
||||
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
|
@ -24,7 +24,7 @@ Problema per un [[sistema distribuito]], variante del [[broadcast problem]].
|
|||
- [[flooding v2]] ([[algoritmo corretto|corretto]].)
|
||||
- [[flooding v3]] (ottimizzato!)
|
||||
|
||||
## [[notazione Ω-grande|Lower bound]] [[costo computazionale|costo computazionale]]
|
||||
## [[costo computazionale|Costo computazionale]]
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"nodes":[
|
||||
{"id":"1ae79343ecdc2ecf","type":"group","x":1040,"y":540,"width":1640,"height":1000,"color":"5","label":"Flooding"},
|
||||
{"id":"1ae79343ecdc2ecf","type":"group","x":1040,"y":540,"width":1640,"height":1000,"label":"Flooding"},
|
||||
{"id":"1bf892659093d611","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/flooding v1.md","x":1060,"y":560,"width":480,"height":960},
|
||||
{"id":"a1841455be06b505","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/flooding v2.md","x":1620,"y":560,"width":480,"height":960},
|
||||
{"id":"ea39c9f9c9d31ba6","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/flooding v3.md","x":2180,"y":560,"width":480,"height":960},
|
||||
|
|
|
|||
|
|
@ -7,14 +7,14 @@ Si vuole ***minimizzare il [[diametro di un grafo|diametro]]*** di uno [[spannin
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- [[iniziatore singolo]]
|
||||
- [[full-duplex]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[grafo connesso]]
|
||||
- [[full-duplex|grafo indiretto]]
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- [[ritardo di comunicazione illimitato]]
|
||||
- [[risveglio singolo]]
|
||||
- [[terminazione locale]]
|
||||
|
||||
## Idea degli [[algoritmo|algoritmi]]
|
||||
|
|
|
|||
|
|
@ -7,15 +7,15 @@ Si vuole [[problema di ricerca|determinare]] uno [[spanning tree]] per il [[sist
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- ***[[iniziatori multipli]]***
|
||||
- ***[[identificatori univoci]]***
|
||||
- [[full-duplex]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[grafo connesso]]
|
||||
- [[full-duplex|grafo indiretto]]
|
||||
- ***[[identificatori univoci]]***
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- [[ritardo di comunicazione unitario]]
|
||||
- ***[[risveglio parziale]]***
|
||||
- [[terminazione locale]]
|
||||
|
||||
### [[Algoritmo|Algoritmi]]
|
||||
|
|
|
|||
|
|
@ -1,117 +1,76 @@
|
|||
[[algoritmo]] di [[spanning tree construction]], basato sul [[flooding v3]].
|
||||
|
||||
> [!Summary]
|
||||
> Ciascuna [[entità]] chiede ai propri vicini se può entrare a fare parte dello [[spanning tree]], e loro ***rispondono sì oppure no***.
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Ciascuna [[entità]] chiede ai propri vicini se può entrare a fare parte dello [[spanning tree]], e loro ***rispondono di sì oppure di no***.
|
||||
|
||||
Il [[leader]] viene inizializzato a `LEADER`, le altre [[entità]] vengono inizializzate a `IDLE`.
|
||||
|
||||
### `LEADER`
|
||||
|
||||
Il [[leader]] chiede [[impulso spontaneo|spontaneamente]] alle [[entità]] se possono entrare a fare parte dello [[spanning tree]], poi si attiva in attesa di risposte:
|
||||
```rust
|
||||
spontaneously!({
|
||||
self.received = 0;
|
||||
send!(*, Question);
|
||||
state!(ACTIVE);
|
||||
})
|
||||
```
|
||||
[[messaggio|Chiede]] [[impulso spontaneo|spontaneamente]] ai suoi [[vicini di un'entità|vicini]] se possono entrare a fare parte dello [[spanning tree]] con `Question`, poi diventa `ACTIVE`.
|
||||
|
||||
### `IDLE`
|
||||
|
||||
Un'[[entità]] `IDLE` è in attesa di domande.
|
||||
In attesa di ricevere `Question`.
|
||||
|
||||
Quando ne riceve una, risponde positivamente, poi ripete la domanda e si attiva a sua volta:
|
||||
```rust
|
||||
on_receive!(
|
||||
Question => {
|
||||
self.received = 1;
|
||||
self.parent = sender;
|
||||
send!(sender, Answer::Yes);
|
||||
send!(!sender, Question);
|
||||
if self.neighbours.length() > self.received {
|
||||
state!(DONE)
|
||||
}
|
||||
else {
|
||||
state!(ACTIVE)
|
||||
};
|
||||
},
|
||||
)
|
||||
```
|
||||
Quando ne riceve una, risponde `Yes`, poi ripete `Question` ai propri [[vicini di un'entità|vicini]] (tranne il mittente) e diventa `ACTIVE`.
|
||||
|
||||
### `ACTIVE`
|
||||
|
||||
Un [[entità]] `ACTIVE` è in attesa di risposte.
|
||||
In attesa di risposte `Yes` o `No`.
|
||||
|
||||
Se la risposta è positiva, aggiunge il mittente allo spanning tree:
|
||||
```rust
|
||||
on_receive!(
|
||||
Answer::Yes => {
|
||||
self.neighbours_in_tree.insert(sender);
|
||||
}
|
||||
)
|
||||
```
|
||||
Se la risposta è `Yes`, aggiunge il mittente allo [[spanning tree]].
|
||||
|
||||
E poi la conteggia:
|
||||
```rust
|
||||
on_receive!(
|
||||
Answer => {
|
||||
self.received += 1
|
||||
if self.neighbours.length() > self.received {
|
||||
state!(DONE);
|
||||
}
|
||||
},
|
||||
)
|
||||
```
|
||||
Inoltre, [[contatore|conta]] tutte le risposte che ha ricevuto, passando a `DONE` quando sono tante quante i vicini a cui ha inviato la domanda.
|
||||
|
||||
Inoltre, risponde alle domande con `Answer::No`:
|
||||
```rust
|
||||
on_receive!(
|
||||
Question => {
|
||||
send!(sender, Answer::No);
|
||||
}
|
||||
)
|
||||
```
|
||||
Essendo già parte dello [[spanning tree]], risponde alle `Question` con `No`.
|
||||
|
||||
### `DONE`
|
||||
|
||||
Un [[entità]] `DONE` sa tutte le informazioni possibili sui suoi vicini.
|
||||
|
||||
Non fa nient'altro.
|
||||
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
Dato che:
|
||||
1. Tutte le [[entità]] tranne il [[leader]] inviano esattamente un `Answer::Yes`.
|
||||
2. L'invio e la ricezione di `Answer::Yes` [[arco di un grafo|collegano]] le due [[entità]] coinvolte.
|
||||
|
||||
Allora, il [[grafo]] risultante è un [[albero]] [[grafo connesso|connesso]].
|
||||
> [!Success]
|
||||
>
|
||||
> Dato che:
|
||||
> 1. Tutte le [[entità]] tranne il [[leader]] rispondono affermativamente una sola volta.
|
||||
> 2. Una domanda e una risposta affermativa [[arco di un grafo|collegano]] le due [[entità]] coinvolte.
|
||||
>
|
||||
> Allora, il [[grafo]] risultante è un [[albero]] [[grafo connesso|connesso]].
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
Questo protocollo è equivalente al [[flooding v3]], ma con le ***[[entità]] raggiunte che inviano anche una risposta***.
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione]] | $O(Channels)$ |
|
||||
| [[tempo]] | $O(Channels)$ |
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
#### Singoli scambi di messaggi
|
||||
Si osserva che questo [[algoritmo]] è simile al [[flooding v3]], ma con le ***[[entità]] raggiunte che inviano anche una risposta***.
|
||||
|
||||
#### Singoli scambi di [[messaggio|messaggi]]
|
||||
|
||||
Controlliamo che e quanti messaggi attraversano i [[canale di comunicazione|canali]].
|
||||
|
||||
##### Scoperta di un nuovo nodo
|
||||
##### Scoperta di una nuova [[entità]]
|
||||
|
||||
Un nodo invia `Question`, l'altro risponda con `Answer::Yes`:
|
||||
Un'[[entità]] invia `Question`, l'altra risponde con `Yes`:
|
||||
$$
|
||||
\color{LightCoral} (2 \cdot (Entities - 1))
|
||||
$$
|
||||
##### Incontro di due nodi conosciuti
|
||||
##### Incontro di due [[entità]] conosciute
|
||||
|
||||
Entrambi i nodi inviano `Question` in tutti i casi che non sono quello precedente:
|
||||
Entrambe inviano `Question` in tutti i casi che non sono quello precedente:
|
||||
$$
|
||||
\color{SpringGreen} (2 \cdot (Channels - (Entities - 1)))
|
||||
$$
|
||||
|
||||
Entrambi i nodi poi rispondono `Answer::No`:
|
||||
Entrambe poi rispondono `Answer::No`:
|
||||
$$
|
||||
\color{SkyBlue} (2 \cdot (Channels - (Entities - 1)))
|
||||
$$
|
||||
|
|
@ -150,3 +109,11 @@ In [[notazione asintotica]], è sempre:
|
|||
$$
|
||||
\Large O(Channels)
|
||||
$$
|
||||
|
||||
### [[Tempo]]
|
||||
|
||||
Il [[grafo]] potrebbe essere un [[cammino]], che richiederebbe che ogni arco venisse attraversato, quindi sicuramente:
|
||||
$$
|
||||
\Large O(Channels)
|
||||
$$
|
||||
|
||||
|
|
|
|||
|
|
@ -1,117 +1,73 @@
|
|||
[[algoritmo]] di [[spanning tree construction]] che migliora lo [[shout protocol]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Ciascuna [[entità]] chiede ai propri vicini se può entrare a fare parte dello [[spanning tree]], e loro rispondono sì ***oppure nulla***.
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
Il [[leader]] viene inizializzato a `LEADER`, le altre [[entità]] vengono inizializzate a `IDLE`.
|
||||
|
||||
### `LEADER`
|
||||
|
||||
Il [[leader]] chiede [[impulso spontaneo|spontaneamente]] alle [[entità]] se possono entrare a fare parte dello [[spanning tree]], poi si attiva in attesa di risposte:
|
||||
```rust
|
||||
spontaneously!({
|
||||
self.received = 0;
|
||||
send!(*, Question);
|
||||
state!(ACTIVE);
|
||||
})
|
||||
```
|
||||
[[messaggio|Chiede]] [[impulso spontaneo|spontaneamente]] ai suoi [[vicini di un'entità|vicini]] se possono entrare a fare parte dello [[spanning tree]] con `Question`, poi diventa `ACTIVE`.
|
||||
|
||||
### `IDLE`
|
||||
|
||||
Un'[[entità]] `IDLE` è in attesa di domande.
|
||||
In attesa di ricevere `Question`.
|
||||
|
||||
Quando ne riceve una, risponde positivamente, poi ripete la domanda e si attiva a sua volta:
|
||||
```rust
|
||||
on_receive!(
|
||||
Question => {
|
||||
self.received = 1;
|
||||
self.parent = sender;
|
||||
send!(sender, Answer::Yes);
|
||||
send!(!sender, Question);
|
||||
if self.neighbours.length() > self.received {
|
||||
state!(DONE)
|
||||
}
|
||||
else {
|
||||
state!(ACTIVE)
|
||||
};
|
||||
},
|
||||
)
|
||||
```
|
||||
Quando ne riceve una, risponde `Yes`, poi ripete `Question` ai propri [[vicini di un'entità|vicini]] (tranne il mittente) e diventa `ACTIVE`.
|
||||
|
||||
### `ACTIVE`
|
||||
|
||||
Un [[entità]] `ACTIVE` è in attesa di risposte.
|
||||
In attesa di risposte `Yes`.
|
||||
|
||||
Se la risposta è positiva, aggiunge il mittente allo spanning tree:
|
||||
```rust
|
||||
on_receive!(
|
||||
Answer::Yes => {
|
||||
self.neighbours_in_tree.insert(sender);
|
||||
}
|
||||
)
|
||||
```
|
||||
Se la risposta è `Yes`, aggiunge il mittente allo [[spanning tree]].
|
||||
|
||||
E poi la conteggia:
|
||||
```rust
|
||||
on_receive!(
|
||||
Answer => {
|
||||
self.received += 1
|
||||
if self.neighbours.length() > self.received {
|
||||
state!(DONE);
|
||||
}
|
||||
},
|
||||
)
|
||||
```
|
||||
Inoltre, [[contatore|conta]] ***tutti i messaggi*** che ha ricevuto, passando a `DONE` quando sono tante quante i vicini a cui ha inviato la domanda.
|
||||
|
||||
***Invece che rispondere alle domande, esse vengono interpretate come una risposta negativa***:
|
||||
```rust
|
||||
on_receive!(
|
||||
Question => {
|
||||
self.received += 1
|
||||
if self.neighbours.length() > self.received {
|
||||
state!(DONE);
|
||||
}
|
||||
}
|
||||
)
|
||||
```
|
||||
> [!Tip]
|
||||
> Le `Question` provenienti dai vicini sono considerate dei `No`.
|
||||
|
||||
### `DONE`
|
||||
|
||||
Un [[entità]] `DONE` sa tutte le informazioni possibili sui suoi vicini.
|
||||
|
||||
Non fa nient'altro.
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
Dato che:
|
||||
1. Tutte le [[entità]] tranne il [[leader]] inviano esattamente un `Answer::Yes`.
|
||||
2. L'invio e la ricezione di `Answer::Yes` [[arco di un grafo|collegano]] le due [[entità]] coinvolte.
|
||||
|
||||
Allora, il [[grafo]] risultante è un [[albero]] [[grafo connesso|connesso]].
|
||||
> [!Success]
|
||||
>
|
||||
> Dato che:
|
||||
> 1. Tutte le [[entità]] tranne il [[leader]] rispondono affermativamente una sola volta.
|
||||
> 2. Una domanda e una risposta affermativa [[arco di un grafo|collegano]] le due [[entità]] coinvolte.
|
||||
>
|
||||
> Allora, il [[grafo]] risultante è un [[albero]] [[grafo connesso|connesso]].
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
Questo protocollo è equivalente al [[flooding v3]], ma con le [[entità]] raggiunte che inviano anche una risposta.
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione]] | $O(Channels)$ |
|
||||
| [[tempo]] | $O(Channels)$ |
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
Si osserva che questo [[algoritmo]] è simile al [[flooding v3]], ma con le ***[[entità]] raggiunte che inviano anche una risposta***.
|
||||
|
||||
#### Singoli scambi di messaggi
|
||||
|
||||
Controlliamo che e quanti messaggi attraversano i [[canale di comunicazione|canali]].
|
||||
|
||||
##### Scoperta di un nuovo nodo
|
||||
##### Scoperta di una nuova [[entità]]
|
||||
|
||||
Un nodo invia `Question`, l'altro risponda con `Answer::Yes`.
|
||||
Un'[[entità]] invia `Question`, l'altra risponde con `Yes`.
|
||||
|
||||
Si verifica in:
|
||||
$$
|
||||
\color{LightCoral} (2 \cdot (Entities - 1))
|
||||
$$
|
||||
##### Incontro di due nodi conosciuti
|
||||
##### Incontro di due [[entità]] conosciute
|
||||
|
||||
Entrambi i nodi inviano `Question` in tutti i casi che non sono quello precedente:
|
||||
Entrambe inviano `Question` in tutti i casi che non sono quello precedente:
|
||||
$$
|
||||
\color{SpringGreen} (2 \cdot (Channels - (Entities - 1)))
|
||||
$$
|
||||
|
|
@ -144,6 +100,14 @@ $$
|
|||
\Large O(Channels)
|
||||
$$
|
||||
|
||||
## Duale
|
||||
|
||||
Il duale di questo algoritmo è la [[leader election su grafo aciclico]].
|
||||
### [[Tempo]]
|
||||
|
||||
Il [[grafo]] potrebbe essere un [[cammino]], che richiederebbe che ogni arco venisse attraversato, quindi sicuramente:
|
||||
$$
|
||||
\Large O(Channels)
|
||||
$$
|
||||
|
||||
## [[Duale]]
|
||||
|
||||
- [[leader election su grafo aciclico]]
|
||||
|
|
|
|||
|
|
@ -7,19 +7,21 @@ Si vuole determinare uno [[spanning tree]] per il [[sistema distribuito]] in mod
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- [[iniziatore singolo]]
|
||||
- [[full-duplex]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[grafo connesso]]
|
||||
- [[full-duplex|grafo indiretto]]
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- [[ritardo di comunicazione illimitato]]
|
||||
- [[risveglio singolo]]
|
||||
- [[terminazione locale]]
|
||||
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
||||
- [[shout protocol]]
|
||||
- [[shout+ protocol]]
|
||||
- [[traversal protocol]]
|
||||
- [[traversal+ protocol]]
|
||||
- **Flooding-based**
|
||||
- [[shout protocol]]
|
||||
- [[shout+ protocol]]
|
||||
- **Depth-first-search-based**
|
||||
- [[traversal protocol]]
|
||||
- [[traversal+ protocol]]
|
||||
|
|
|
|||
|
|
@ -0,0 +1,6 @@
|
|||
---
|
||||
aliases:
|
||||
- token
|
||||
---
|
||||
|
||||
[[Privilegio]] [[trasferibile]] posseduto da un'[[entità]] di un [[sistema distribuito]].
|
||||
|
|
@ -1,101 +1,62 @@
|
|||
[[algoritmo]] di [[spanning tree construction]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Le [[entità]] del grafo vengono visitate sequenzialmente attraverso una [[depth-first search]].
|
||||
>
|
||||
> In ogni momento, a solo una [[entità]] è permesso eseguire codice, e questo permesso è tracciato attraverso un [[token metaforico]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
L'[[entità]] [[iniziatore singolo|iniziatrice]] viene inizializzata a `LEADER`, mentre le altre vengono inizializzate a `IDLE`.
|
||||
|
||||
==Questo modello è brutto...==
|
||||
|
||||
### `visit_next(self)`
|
||||
|
||||
Definiamo una funzione che si ripeterà più volte che invia il token al primo nodo non visitato dal nodo attuale, e quando non rimangono più token, notifica il nodo genitore.
|
||||
```rust
|
||||
impl Entity {
|
||||
fn visit_next(self) {
|
||||
if self.unvisited.length() > 0 {
|
||||
state!(VISITED);
|
||||
let entity = self.unvisited.pop();
|
||||
send!(entity, Token::Forward);
|
||||
}
|
||||
else {
|
||||
if(self.parent) {
|
||||
send!(self.parent, Token::Finished);
|
||||
}
|
||||
state!(DONE);
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
Il [[leader]] viene inizializzato a `LEADER`, le altre [[entità]] vengono inizializzate a `IDLE`.
|
||||
|
||||
### `LEADER`
|
||||
|
||||
L'[[entità]] `LEADER` inizia la visita:
|
||||
```rust
|
||||
spontaneously!({
|
||||
self.unvisited = self.neighbours.clone();
|
||||
self.parent = null;
|
||||
self.children = vec![];
|
||||
state!(VISITED);
|
||||
self.visit_next();
|
||||
})
|
||||
```
|
||||
Inizia possedendo il [[token metaforico]].
|
||||
|
||||
Inizia la visita inviando il [[token metaforico|token]] al primo [[vicini di un'entità|vicino]] non visitato con il tag `Forward`, diventando `VISITED`.
|
||||
|
||||
### `IDLE`
|
||||
|
||||
Una [[entità]] `IDLE` è in attesa di ricevere il [[token metaforico]]:
|
||||
```rust
|
||||
on_receive!(
|
||||
Token::Forward => {
|
||||
self.parent = sender;
|
||||
self.unvisited.remove(sender);
|
||||
state!(VISITED);
|
||||
self.visit_next();
|
||||
}
|
||||
)
|
||||
```
|
||||
In attesa di ricevere il [[token metaforico]].
|
||||
|
||||
Quando riceve il token `Forward`:
|
||||
1. memorizza il mittente come genitore;
|
||||
2. procede con la visita inviando il [[token metaforico|token]] al primo suo [[vicini di un'entità|vicino]] non visitato con il tag `Forward`;
|
||||
3. diventa `VISITED`.
|
||||
|
||||
### `VISITED`
|
||||
|
||||
Una [[entità]] `VISITED` ha già ricevuto il [[token metaforico]] in precedenza, e se lo riceve, lo rifiuta con `Token::BackEdge`, che porta a una nuova visita da parte del mittente:
|
||||
```rust
|
||||
on_receive!(
|
||||
Token::Forward => {
|
||||
self.unvisited.remove(sender);
|
||||
send!(sender, Token::BackEdge);
|
||||
}
|
||||
Token::BackEdge => {
|
||||
self.visit_next();
|
||||
}
|
||||
)
|
||||
```
|
||||
Ha già ricevuto il [[token metaforico]] in precedenza.
|
||||
|
||||
Può anche ricevere un `Token::Finished`, che indica che l'[[entità]] mittente ha terminato l'elaborazione; essa viene aggiunta all'albero, e poi la visita continua:
|
||||
```rust
|
||||
on_receive!(
|
||||
Token::Finished => {
|
||||
self.children.push(sender);
|
||||
self.visit_next();
|
||||
}
|
||||
)
|
||||
```
|
||||
Se lo riceve con il tag `Forward`, lo rimanda al mittente con il tag `AlreadyVisited`.
|
||||
|
||||
Se lo riceve con il tag `AlreadyVisited`, invia il [[token metaforico|token]] al prossimo [[vicini di un'entità|vicino]] non visitato con il tag `Forward`.
|
||||
|
||||
Se lo riceve con il tag `Backward`, aggiunge all'[[albero]] il mittente, e poi invia il [[token metaforico|token]] al prossimo [[vicini di un'entità|vicino]] non visitato con il tag `Forward`.
|
||||
|
||||
Se riceve nuovamente il [[token metaforico|token]], e non ha altri vicini da visitare, restituisce il [[token metaforico|token]] al genitore, poi diventa `DONE`.
|
||||
|
||||
### `DONE`
|
||||
|
||||
Un [[entità]] `DONE` sa tutte le informazioni possibili sui suoi vicini.
|
||||
|
||||
Non fa nient'altro.
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
==...==
|
||||
> [!Success]
|
||||
>
|
||||
> Dato che:
|
||||
> 1. Tutte le [[entità]] tranne il [[leader]] inviano `Finished` una sola volta.
|
||||
> 2. Un `Forward` e un `Backward` [[arco di un grafo|collegano]] le due [[entità]] coinvolte.
|
||||
>
|
||||
> Allora, il [[grafo]] risultante è un [[albero]] [[grafo connesso|connesso]].
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione]] | $O(Channels)$ |
|
||||
| [[tempo]] | $O(Channels)$ |
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
Tutti i [[canale di comunicazione|canali]] vengono visitati due volte, uno da `Token::Forward`, e uno da `Token::BackEdge` o `Token::Finished`:
|
||||
|
|
@ -108,9 +69,6 @@ $$
|
|||
\Large O(Channels)
|
||||
$$
|
||||
|
||||
> [!Note]
|
||||
> Coincide strettamente con il lower bound.
|
||||
|
||||
### [[Tempo]]
|
||||
|
||||
Essendo la visita del grafo sequenziale, il tempo richiesto coincide con il costo di comunicazione:
|
||||
|
|
@ -122,6 +80,3 @@ In [[notazione asintotica]], è:
|
|||
$$
|
||||
\Large O(Channels)
|
||||
$$
|
||||
|
||||
> [!Warning]
|
||||
> Non coincide con il lower bound!
|
||||
|
|
|
|||
|
|
@ -1,126 +1,66 @@
|
|||
[[algoritmo]] di [[spanning tree construction]] che migliora il [[traversal protocol]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Le [[entità]] del grafo vengono visitate sequenzialmente attraverso una [[depth-first search]].
|
||||
>
|
||||
> In ogni momento, a solo una [[entità]] è permesso ***visitarne altre***, e questo permesso è tracciato attraverso un [[token metaforico]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
L'[[entità]] [[iniziatore singolo|iniziatrice]] viene inizializzata a `LEADER`, mentre le altre vengono inizializzate a `IDLE`.
|
||||
|
||||
==Questo modello è brutto e sbagliato nel caso ci sia un grafo di un nodo solo...==
|
||||
|
||||
### `visit_next(self)`
|
||||
|
||||
Definiamo una funzione che si ripeterà più volte che invia il token al primo nodo non visitato dal nodo attuale, e quando non rimangono più token, notifica il nodo genitore.
|
||||
```rust
|
||||
impl Entity {
|
||||
fn visit_next(self) {
|
||||
if self.unvisited.length() > 0 {
|
||||
state!(VISITED);
|
||||
let entity = self.unvisited.pop();
|
||||
send!(entity, Token::Forward);
|
||||
}
|
||||
else {
|
||||
if(self.parent) {
|
||||
send!(self.parent, Token::Finished);
|
||||
}
|
||||
state!(DONE);
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### `LEADER`
|
||||
|
||||
L'[[entità]] `LEADER` ***notifica tutti i suoi vicini che è stata visitata***:
|
||||
```rust
|
||||
spontaneously!({
|
||||
self.unacknowledged = self.neighbours.clone();
|
||||
self.unvisited = self.neighbours.clone();
|
||||
self.parent = null;
|
||||
self.children = vec![];
|
||||
send!(self.unvisited, Visited::Sender);
|
||||
})
|
||||
```
|
||||
Inizia possedendo il [[token metaforico]].
|
||||
|
||||
***Quando tutti i vicini hanno risposto, inizia la visita:***
|
||||
```rust
|
||||
on_receive!(
|
||||
Visited::Receiver => {
|
||||
self.unacknowledged.remove(sender);
|
||||
if self.unacknowledged.length() == 0 {
|
||||
state!(VISITED);
|
||||
self.visit_next();
|
||||
}
|
||||
}
|
||||
)
|
||||
```
|
||||
***Parte notificando tutti i suoi [[vicini di un'entità|vicini]] di possedere il token con il tag `Own`.***
|
||||
|
||||
Poi, inizia la visita inviando il [[token metaforico|token]] al primo [[vicini di un'entità|vicino]] non visitato con il tag `Forward`, diventando `VISITED`.
|
||||
|
||||
### `IDLE`
|
||||
|
||||
Una [[entità]] `IDLE` è in attesa di ricevere il [[token metaforico]].
|
||||
***Quando lo riceve, notifica tutti i vicini della cosa, come fatto dal leader***:
|
||||
```rust
|
||||
spontaneously!({
|
||||
self.unacknowledged = self.neighbours.clone();
|
||||
self.unvisited = self.neighbours.clone();
|
||||
self.children = vec![];
|
||||
})
|
||||
In attesa di ricevere il [[token metaforico]], ***e in ascolto per notifiche `Own`***.
|
||||
|
||||
on_receive!(
|
||||
Token::Forward => {
|
||||
self.parent = sender;
|
||||
self.unvisited.remove(sender);
|
||||
send!(self.unvisited, Visited::Sender);
|
||||
}
|
||||
***Quando riceve una notifica `Own`***:
|
||||
1. ***esclude il mittente dai [[vicini di un'entità|vicini]] da visitare.***
|
||||
|
||||
Visited::Receiver => {
|
||||
self.unacknowledged.remove(sender);
|
||||
if self.unacknowledged.length() == 0 {
|
||||
state!(VISITED);
|
||||
self.visit_next();
|
||||
}
|
||||
}
|
||||
|
||||
Visited::Sender => {
|
||||
self.unvisited.remove(sender);
|
||||
send!(sender, Visited::Receiver);
|
||||
}
|
||||
)
|
||||
```
|
||||
Quando riceve il token `Forward`:
|
||||
1. memorizza il mittente come genitore;
|
||||
2. notifica tutti i [[vicini di un'entità|vicini]] con il tag `Own`;
|
||||
3. procede con la visita inviando il [[token metaforico|token]] al primo suo [[vicini di un'entità|vicino]] non visitato con il tag `Forward`;
|
||||
4. diventa `VISITED`.
|
||||
|
||||
### `VISITED`
|
||||
|
||||
Una [[entità]] `VISITED` ha già ricevuto il [[token metaforico]] in precedenza.
|
||||
Ha già ricevuto il [[token metaforico]] in precedenza.
|
||||
|
||||
Può ricevere ***solo*** un `Token::Finished`, che indica che l'[[entità]] mittente ha terminato l'elaborazione; essa viene aggiunta all'albero, e poi la visita continua:
|
||||
```rust
|
||||
on_receive!(
|
||||
Token::Finished => {
|
||||
self.children.push(sender);
|
||||
self.visit_next();
|
||||
}
|
||||
)
|
||||
```
|
||||
> [!Note]
|
||||
> ***È impossibile che riceva `Forward` o `AlreadyVisited` per via del meccanismo di `Own`.***
|
||||
|
||||
***Non è possibile che riceva `Visited::Sender`, in quanto è già stata rimossa da `self.unvisited`.***
|
||||
Se lo riceve con il tag `Backward`, aggiunge all'[[albero]] il mittente, e poi invia il [[token metaforico|token]] al prossimo [[vicini di un'entità|vicino]] non visitato con il tag `Forward`.
|
||||
|
||||
***Per lo stesso motivo, `Token::BackEdge` sono stati rimossi dall'algoritmo.***
|
||||
Se riceve nuovamente il [[token metaforico|token]], e non ha altri vicini da visitare, restituisce il [[token metaforico|token]] al genitore, poi diventa `DONE`.
|
||||
|
||||
### `DONE`
|
||||
|
||||
Un [[entità]] `DONE` sa tutte le informazioni possibili sui suoi vicini.
|
||||
|
||||
Non fa nient'altro.
|
||||
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
==...==
|
||||
> [!Success]
|
||||
>
|
||||
> Dato che:
|
||||
> 1. Tutte le [[entità]] tranne il [[leader]] inviano `Finished` una sola volta.
|
||||
> 2. Un `Forward` e un `Backward` [[arco di un grafo|collegano]] le due [[entità]] coinvolte.
|
||||
>
|
||||
> Allora, il [[grafo]] risultante è un [[albero]] [[grafo connesso|connesso]].
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione]] | $O(Channels)$ |
|
||||
| [[tempo]] | $O(Channels)$ |
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
Tutti i [[canale di comunicazione|canali]] vengono visitati due volte, uno da `Visited::Sender`, e uno da `Visited::Receiver`:
|
||||
|
|
@ -156,7 +96,7 @@ $$
|
|||
$$
|
||||
|
||||
> [!Note]
|
||||
> Coincide ***asintoticamente*** con il lower bound.
|
||||
> Coincide ***asintoticamente*** con il [[notazione Ω-grande|lower bound]] della [[spanning tree construction]].
|
||||
|
||||
### [[Tempo]]
|
||||
|
||||
|
|
@ -185,4 +125,4 @@ $$
|
|||
$$
|
||||
|
||||
> [!Note]
|
||||
> ***Coincide asintoticamente*** con il lower bound.
|
||||
> ***Coincide asintoticamente*** con il [[notazione Ω-grande|lower bound]] della [[spanning tree construction]].
|
||||
|
|
|
|||
|
|
@ -1,22 +1,20 @@
|
|||
{
|
||||
"nodes":[
|
||||
{"id":"f48243a62762bc6a","type":"group","x":780,"y":-1300,"width":920,"height":1000,"color":"5","label":"shout protocol"},
|
||||
{"id":"a7b374601b504754","type":"group","x":780,"y":-180,"width":920,"height":1000,"color":"5","label":"traversal protocol"},
|
||||
{"id":"f48243a62762bc6a","type":"group","x":780,"y":-1300,"width":920,"height":1000,"label":"shout protocol"},
|
||||
{"id":"a7b374601b504754","type":"group","x":780,"y":-180,"width":920,"height":1000,"label":"traversal protocol"},
|
||||
{"id":"e4db85d4dd9cb928","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/spanning tree construction.md","x":-320,"y":-1280,"width":960,"height":2080},
|
||||
{"id":"42f2908da34c9d4d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/spanning tree.md","x":-40,"y":-1840,"width":400,"height":400},
|
||||
{"id":"975c4e916151d0da","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/shout protocol.md","x":800,"y":-1280,"width":400,"height":960},
|
||||
{"id":"6affd8da4f6f750a","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/flooding v3.md","x":800,"y":-1840,"width":400,"height":400},
|
||||
{"id":"1942e37fcdb3b040","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/shout+ protocol.md","x":1280,"y":-1280,"width":400,"height":960},
|
||||
{"id":"7f269696427c2c8e","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/traversal protocol.md","x":800,"y":-160,"width":400,"height":960},
|
||||
{"id":"b59b4cc2872c280d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/broadcast tree construction.md","x":-320,"y":960,"width":960,"height":960},
|
||||
{"id":"1ccd23a5dd951996","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/multiple spanning tree construction.md","x":-320,"y":2080,"width":960,"height":960},
|
||||
{"id":"899da42b0ed0d514","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/selective spanning tree transform.md","x":800,"y":2080,"width":400,"height":400},
|
||||
{"id":"e12fb2819e6c8318","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/traversal+ protocol.md","x":1280,"y":-160,"width":400,"height":960},
|
||||
{"id":"899da42b0ed0d514","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/selective spanning tree transform.md","x":800,"y":2080,"width":400,"height":400},
|
||||
{"id":"289f00f041183fee","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/multiple spanning tree transform.md","x":800,"y":2640,"width":400,"height":400}
|
||||
],
|
||||
"edges":[
|
||||
{"id":"0b872430734f1f17","fromNode":"42f2908da34c9d4d","fromSide":"bottom","toNode":"e4db85d4dd9cb928","toSide":"top"},
|
||||
{"id":"0987f6cc5f169aff","fromNode":"6affd8da4f6f750a","fromSide":"bottom","toNode":"975c4e916151d0da","toSide":"top"},
|
||||
{"id":"1def3d7fb4e72c80","fromNode":"975c4e916151d0da","fromSide":"right","toNode":"1942e37fcdb3b040","toSide":"left"},
|
||||
{"id":"d6cdc039af788cc2","fromNode":"e4db85d4dd9cb928","fromSide":"right","toNode":"f48243a62762bc6a","toSide":"left"},
|
||||
{"id":"10b12980f5c61ace","fromNode":"e4db85d4dd9cb928","fromSide":"right","toNode":"a7b374601b504754","toSide":"left"},
|
||||
|
|
|
|||
|
|
@ -7,16 +7,17 @@ Si vuole calcolare qualcosa più efficientemente possibile, distribuendo gli [[9
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- ***[[iniziatore singolo]]***
|
||||
- ***[[identificatori univoci]]***
|
||||
- [[full-duplex]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[full-duplex|grafo indiretto]]
|
||||
- [[grafo connesso]]
|
||||
- ***[[identificatori univoci]]***
|
||||
- ***[[albero]]***
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- [[ritardo di comunicazione illimitato]]
|
||||
- [[risveglio singolo]]
|
||||
- [[terminazione locale]]
|
||||
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
||||
|
|
|
|||
|
|
@ -7,15 +7,16 @@ Si vuole calcolare qualcosa più efficientemente possibile, distribuendo gli [[9
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- ***[[iniziatori multipli]]***
|
||||
- [[full-duplex|grafo indiretto]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[full-duplex|grafo indiretto]]
|
||||
- [[grafo connesso]]
|
||||
- ***[[grafo aciclico]]***
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- [[ritardo di comunicazione illimitato]]
|
||||
- ***[[risveglio parziale]]***
|
||||
- [[terminazione locale]]
|
||||
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
||||
|
|
|
|||
|
|
@ -1,12 +1,14 @@
|
|||
[[algoritmo]] di [[computazione in grafi aciclici]].
|
||||
|
||||
> [!Summary]
|
||||
> Si distribuisce un dato a ogni [[entità]], che effettua la computazione per i dati dei suoi figli e ne invia il risultato al genitore.
|
||||
>
|
||||
> Processati tutti i dati, viene effettuato un [[broadcast problem|broadcast]] ***dalla radice-[[leader]]*** per distribuire i risultati dell'algoritmo a tutti.
|
||||
[[algoritmo]] di [[computazione in alberi]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Si distribuisce un dato a ogni [[entità]].
|
||||
>
|
||||
> Ogni [[entità]] effettua la computazione richiesta con il suo dato, più i dati ricevuti dai figli, inviando successivamente il risultato al genitore.
|
||||
>
|
||||
> Una volta che la [[radice di un albero|radice]] ha processato i propri dati, effettua un [[broadcast problem|broadcast]] per distribuire il [[risultato]] a tutti.
|
||||
|
||||
### ***`LEADER`***
|
||||
|
||||
Invia un ***[[broadcast problem|broadcast]]*** a tutte le altre [[entità]], poi tutte passano ad `ACTIVE`.
|
||||
|
|
|
|||
|
|
@ -1,21 +1,14 @@
|
|||
{
|
||||
"nodes":[
|
||||
{"id":"f10431539991943d","type":"group","x":620,"y":-500,"width":440,"height":2040,"color":"5","label":"Saturazione"},
|
||||
{"id":"f10431539991943d","type":"group","x":620,"y":-500,"width":440,"height":2040,"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","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}
|
||||
{"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}
|
||||
],
|
||||
"edges":[
|
||||
{"id":"3cc5d31160347382","fromNode":"d9e8c63362870000","fromSide":"bottom","toNode":"da6b01f674dba080","toSide":"top","fromEnd":"arrow"},
|
||||
{"id":"a42fc5dd73c9697e","fromNode":"d9e8c63362870000","fromSide":"right","toNode":"eac3f8232a170480","toSide":"left"},
|
||||
{"id":"a4aa89137c417d7c","fromNode":"da6b01f674dba080","fromSide":"right","toNode":"c217a97b6c1f113a","toSide":"left"},
|
||||
{"id":"e8ceea408a7b8113","fromNode":"39e8d6989eaff333","fromSide":"right","toNode":"810c6eab5eed44f9","toSide":"left"},
|
||||
{"id":"9af232a35509d74c","fromNode":"4295118739ed5400","fromSide":"right","toNode":"810c6eab5eed44f9","toSide":"left"},
|
||||
{"id":"081976471054dfad","fromNode":"810c6eab5eed44f9","fromSide":"right","toNode":"d9e8c63362870000","toSide":"left"},
|
||||
{"id":"b970bd9a8d0081cd","fromNode":"810c6eab5eed44f9","fromSide":"right","toNode":"da6b01f674dba080","toSide":"left"}
|
||||
{"id":"a4aa89137c417d7c","fromNode":"da6b01f674dba080","fromSide":"right","toNode":"c217a97b6c1f113a","toSide":"left"}
|
||||
]
|
||||
}
|
||||
|
|
@ -1,4 +1,6 @@
|
|||
[[algoritmo]] di [[leader election]] per [[albero|alberi]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> La radice diventa automaticamente il [[leader]].
|
||||
|
|
|
|||
|
|
@ -1,15 +1,17 @@
|
|||
[[algoritmo]] di [[leader election]] su [[anello]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!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]
|
||||
> [!Failure]
|
||||
>
|
||||
> 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]]
|
||||
|
||||
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]]
|
||||
|
|
|
|||
|
|
@ -1,5 +1,7 @@
|
|||
[[algoritmo]] di [[leader election]] su [[anello]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
>
|
||||
> Ogni [[entità]] riceve identificatori dalla precedente, tenendo traccia dell'identificatore minimo ricevuto, e inoltra alla successiva qualsiasi cambiamento al proprio minimo.
|
||||
|
|
|
|||
|
|
@ -1,5 +1,7 @@
|
|||
[[algoritmo]] di [[leader election]] su [[anello]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Effettua iterazioni in cui ogni [[entità]] che potrebbe diventare potenzialmente [[leader]] diffonde il proprio [[identificatore]] a tutte le altre entro una certa distanza.
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,7 @@
|
|||
[[algoritmo]] di [[leader election]] che risolve il problema di terminazione della [[leader election su anello all-the-way]] ***introducendo una [[restrizione di topologia]] aggiuntiva.***
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!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]]***.
|
||||
|
||||
|
|
|
|||
|
|
@ -1,8 +1,10 @@
|
|||
[[algoritmo]] di [[leader election]] su [[grafo aciclico|grafi aciclici]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Usa la [[tecnica di saturazione per grafi aciclici]] per trovare l'entità con [[identificatore]] minore, che viene poi scelta come [[leader]].
|
||||
|
||||
## Duale
|
||||
## [[Duale]]
|
||||
|
||||
Il duale di questo algoritmo è lo [[shout+ protocol]].
|
||||
- [[shout+ protocol]]
|
||||
|
|
|
|||
|
|
@ -7,17 +7,17 @@ Si vuole scegliere un'[[entità]] che diventerà il [[leader]] per un [[algoritm
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- [[iniziatori multipli]]
|
||||
- [[identificatori univoci]]
|
||||
- **[[Angluin 1980]]**: questo problema è irrisolvibile senza identificatori univoci
|
||||
- [[half-duplex]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[full-duplex|grafo indiretto]]
|
||||
- [[grafo connesso]]
|
||||
- [[half-duplex|grafo diretto]]
|
||||
- [[identificatori univoci]]
|
||||
- il teorema [[Angluin 1980]] li pone come requisito per la risolvibilità
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- [[ritardo di comunicazione unitario]]
|
||||
- [[risveglio parziale]]
|
||||
- [[terminazione locale]]
|
||||
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
||||
|
|
|
|||
|
|
@ -8,6 +8,6 @@ Appunti del corso di ***Algoritmi distribuiti***, tenuto da [[Manuela Montangero
|
|||
1. [[★ concetti.canvas|★ concetti]]
|
||||
2. [[★ broadcast.canvas|★ broadcast]]
|
||||
3. [[★ spanning tree.canvas|★ spanning tree]]
|
||||
4. [[★ computation in trees.canvas|★ computation in trees]]
|
||||
4. [[★ computazione.canvas|★ computation in trees]]
|
||||
5. [[★ leader election.canvas|★ leader election]]
|
||||
6. [[★ routing.canvas|★ routing]]
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue