mirror of
https://github.com/Steffo99/appunti-magistrali.git
synced 2024-11-21 18:34:18 +00:00
Complete 9 - Algoritmi distribuiti/6 - Routing
This commit is contained in:
parent
2eca871583
commit
8779441b47
GPG key ID:
2A24051445686895
51 changed files with 1168 additions and 669 deletions
42
.obsidian/plugins/obsidian-file-color/data.json
vendored
42
.obsidian/plugins/obsidian-file-color/data.json
vendored
|
|
@ -269,10 +269,6 @@
|
|||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "steffo-file-index.json",
|
||||
"color": "me4XBNQC4rwzQFLlvIAn0"
|
||||
|
|
@ -373,10 +369,6 @@
|
|||
"path": "9 - Algoritmi distribuiti/★ algoritmi distribuiti.md",
|
||||
"color": "7j7Pqog0VHMVVAfazMNlb"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/★ computazione.canvas",
|
||||
"color": "7j7Pqog0VHMVVAfazMNlb"
|
||||
},
|
||||
{
|
||||
"path": "0 - Piano di studi/★ piano di studi.md",
|
||||
"color": "7j7Pqog0VHMVVAfazMNlb"
|
||||
|
|
@ -386,15 +378,43 @@
|
|||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello controlled-distance.md",
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso con fallimenti bizantini.md",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello di dimensione conosciuta all-the-way.md",
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso con fallimenti su grafo completo.md",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello as-far-as-it-can.md",
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/edge-broadcast-possibility.md",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/ft-broad-election.md",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/leader election con fallimenti su grafo completo.md",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/teorema innominato.md",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/two steps.md",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/★ computazione.canvas",
|
||||
"color": "7j7Pqog0VHMVVAfazMNlb"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/4 - Strutture dati distribuite",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/centralized routing.md",
|
||||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
}
|
||||
]
|
||||
|
|
|
|||
|
|
@ -1,212 +0,0 @@
|
|||
{
|
||||
"main": {
|
||||
"id": "ea42b6c6a6ada42e",
|
||||
"type": "split",
|
||||
"children": [
|
||||
{
|
||||
"id": "353bd9b9e09f62d7",
|
||||
"type": "tabs",
|
||||
"children": [
|
||||
{
|
||||
"id": "6e2c961c3fbc766e",
|
||||
"type": "leaf",
|
||||
"state": {
|
||||
"type": "canvas",
|
||||
"state": {
|
||||
"file": "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti.canvas",
|
||||
"viewState": {
|
||||
"x": 569.2194349966362,
|
||||
"y": -1224.5487072802703,
|
||||
"zoom": -2.8
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
],
|
||||
"stacked": true
|
||||
}
|
||||
],
|
||||
"direction": "vertical"
|
||||
},
|
||||
"left": {
|
||||
"id": "3dc78bddd518c3f3",
|
||||
"type": "split",
|
||||
"children": [
|
||||
{
|
||||
"id": "d5fc1d7e0478ba75",
|
||||
"type": "tabs",
|
||||
"children": [
|
||||
{
|
||||
"id": "cc2c082e511eafc9",
|
||||
"type": "leaf",
|
||||
"state": {
|
||||
"type": "file-explorer",
|
||||
"state": {
|
||||
"sortOrder": "alphabetical"
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "4240e87522252410",
|
||||
"type": "leaf",
|
||||
"state": {
|
||||
"type": "search",
|
||||
"state": {
|
||||
"query": "stato di un'enti",
|
||||
"matchingCase": false,
|
||||
"explainSearch": false,
|
||||
"collapseAll": false,
|
||||
"extraContext": false,
|
||||
"sortOrder": "alphabetical"
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "7b02a464bd7f94f4",
|
||||
"type": "leaf",
|
||||
"state": {
|
||||
"type": "bookmarks",
|
||||
"state": {}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
"direction": "horizontal",
|
||||
"width": 282.5
|
||||
},
|
||||
"right": {
|
||||
"id": "4ef3f291c2866b38",
|
||||
"type": "split",
|
||||
"children": [
|
||||
{
|
||||
"id": "a0f58612eee5101f",
|
||||
"type": "tabs",
|
||||
"children": [
|
||||
{
|
||||
"id": "da0ecf3eab9f1146",
|
||||
"type": "leaf",
|
||||
"state": {
|
||||
"type": "backlink",
|
||||
"state": {
|
||||
"file": "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti.canvas",
|
||||
"collapseAll": false,
|
||||
"extraContext": false,
|
||||
"sortOrder": "alphabetical",
|
||||
"showSearch": false,
|
||||
"searchQuery": "",
|
||||
"backlinkCollapsed": false,
|
||||
"unlinkedCollapsed": true
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "517852a0c1eb77e0",
|
||||
"type": "leaf",
|
||||
"state": {
|
||||
"type": "outgoing-link",
|
||||
"state": {
|
||||
"file": "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti.canvas",
|
||||
"linksCollapsed": false,
|
||||
"unlinkedCollapsed": true
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "7e28c6b81ba7a75b",
|
||||
"type": "leaf",
|
||||
"state": {
|
||||
"type": "tag",
|
||||
"state": {
|
||||
"sortOrder": "frequency",
|
||||
"useHierarchy": true
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "d08b5edb3d762c99",
|
||||
"type": "leaf",
|
||||
"state": {
|
||||
"type": "outline",
|
||||
"state": {
|
||||
"file": "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti.canvas"
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "3da04ae84a020b40",
|
||||
"type": "leaf",
|
||||
"state": {
|
||||
"type": "all-properties",
|
||||
"state": {
|
||||
"sortOrder": "frequency"
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
"direction": "horizontal",
|
||||
"width": 300,
|
||||
"collapsed": true
|
||||
},
|
||||
"left-ribbon": {
|
||||
"hiddenItems": {
|
||||
"canvas:Create new canvas": true,
|
||||
"switcher:Open quick switcher": false,
|
||||
"graph:Open graph view": false,
|
||||
"templates:Insert template": false
|
||||
}
|
||||
},
|
||||
"active": "6e2c961c3fbc766e",
|
||||
"lastOpenFiles": [
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/criterio di costo sincrono.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/criterio di costo asincrono.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti.canvas",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di tempo.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione unitario.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione limitato.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/sistema distribuito asincrono.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/tick.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione illimitato.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione globale.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione locale.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/teorema innominato.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/sincronicità.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/edge-broadcast-possibility.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/ft-broad-election.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/leader election con fallimenti su grafo completo.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/two steps.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso con fallimenti su grafo completo.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/one step.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/flooding v3.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso broadcast.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di affidabilità.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/condiviso.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/X - Guasti/component failure.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/X - Guasti/temporary fault.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/X - Guasti/permanent fault.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/X - Guasti/crash fault.md",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/X - Guasti",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/Untitled",
|
||||
"9 - Algoritmi distribuiti/0 - Materiale di studio/Slides/07 - Routing.pdf",
|
||||
"steffo-file-index.sync-conflict-20231102-110633-UV5KNJL.json",
|
||||
"9 - Programmazione mobile/0 - Materiale di studio/Slides/2 - Computer graphics/6 - GLTextures.pdf",
|
||||
"9 - Programmazione mobile/0 - Materiale di studio/Slides/1 - Android/05 - MultiThread.pdf",
|
||||
"9 - Programmazione mobile/0 - Materiale di studio/Slides/1 - Android/01 - IntroMobileOS.pdf",
|
||||
"9 - Programmazione mobile/0 - Materiale di studio/Slides/2 - Computer graphics/8 - GLCS.pdf",
|
||||
"9 - Programmazione mobile/0 - Materiale di studio/Slides/1 - Android/06 - AndroidX&More.pdf",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/★ routing.canvas",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/★ leader election.canvas",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computation in trees/★ computation in trees.canvas",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Routing/★ routing.canvas",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/★ spanning tree.canvas",
|
||||
"9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/★ broadcast.canvas",
|
||||
"8 - Crittografia applicata/★ indice.canvas",
|
||||
"7 - Big data analytics/★ indice.canvas",
|
||||
"0 - Generale/★ esami.canvas",
|
||||
"8 - Sistemi complessi/3 - Automi cellulari/modello HPP · regola di transizione.png",
|
||||
"8 - Crittografia applicata/3 - Comunicazione/2 - Garanzie/2 - Indistinguibilità/Pasted image 20230331181648.png"
|
||||
]
|
||||
}
|
||||
9
0 - Generale/hash table.md
Normal file
9
0 - Generale/hash table.md
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
---
|
||||
aliases:
|
||||
- dizionario
|
||||
- oggetto JavaScript
|
||||
- dict
|
||||
- mappa
|
||||
---
|
||||
|
||||
[[struttura dati]] che associa una [[chiave]] a un [[valore]], utilizzando l'[[hash]] della [[chiave]] come indice.
|
||||
9
0 - Generale/indicizzazione a 0.md
Normal file
9
0 - Generale/indicizzazione a 0.md
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
Enumerazione che inizia dal valore `0`, e usa quel valore per il primo elemento conteggiato.
|
||||
|
||||
> [!Example]
|
||||
> Gli array nella maggior parte dei linguaggi di programmazione.
|
||||
|
||||
È possibile convertirlo in [[indicizzazione a 1]] sommando $1$ all'indice:
|
||||
$$
|
||||
Index_0 + 1
|
||||
$$
|
||||
9
0 - Generale/indicizzazione a 1.md
Normal file
9
0 - Generale/indicizzazione a 1.md
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
Enumerazione che inizia dal valore `1`, e usa quel valore per il primo elemento conteggiato.
|
||||
|
||||
> [!Example]
|
||||
> Gli array in [[Lua]].
|
||||
|
||||
È possibile convertirlo in [[indicizzazione a 0]] sottraendo $1$ all'indice:
|
||||
$$
|
||||
Index_1 - 1
|
||||
$$
|
||||
|
|
@ -1,36 +1,40 @@
|
|||
[[algoritmo]] di ==PROBLEMA==.
|
||||
|
||||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
|
||||
|
||||
==...==
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> ==...==
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
### ==`STATO1`==
|
||||
|
||||
==...==
|
||||
```rust
|
||||
|
||||
```
|
||||
|
||||
### ==`STATO2`==
|
||||
|
||||
==...==
|
||||
```rust
|
||||
|
||||
```
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
==...==
|
||||
> [!Success]
|
||||
> ==...==
|
||||
|
||||
> [!Failure]
|
||||
> ==...==
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione]] | ==...== |
|
||||
| [[tempo]] | ==...== |
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
==...==
|
||||
### [[Spazio]]
|
||||
|
||||
==...==
|
||||
### [[Tempo]]
|
||||
|
||||
==...==
|
||||
==...==
|
||||
|
|
|
|||
|
|
@ -0,0 +1,3 @@
|
|||
[[restrizione di comunicazione]].
|
||||
|
||||
Specifica che i [[messaggio|messaggi]] possono occupare qualsiasi [[9 - Algoritmi distribuiti/1 - Problemi/spazio|spazio]] sia necessario.
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
[[restrizione di comunicazione]].
|
||||
|
||||
Specifica che i [[messaggio|messaggi]] devono occupare [[9 - Algoritmi distribuiti/1 - Problemi/spazio|spazio]] inferiore di una certa costante.
|
||||
|
||||
> [!Note]
|
||||
> Spesso applicata assieme a [[ritardo di comunicazione unitario]] per non trivializzare i problemi.
|
||||
|
|
@ -6,3 +6,6 @@ aliases:
|
|||
[[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*.
|
||||
|
||||
> [!Tip]
|
||||
> Le entità iniziatrici potrebbero essere tutte!
|
||||
|
|
@ -1,3 +1,9 @@
|
|||
[[restrizione di tempo]].
|
||||
|
||||
Specifica che tutti i [[messaggio|messaggi]] sono consegnati esattamente dopo un [[tick]], e che se ciò non avviene, l'invio del messaggio è fallito.
|
||||
|
||||
> [!Tip]
|
||||
> È molto utile, perchè in assenza di [[guasto|guasti]], il fatto stesso di inviare o non inviare un messaggio diventa un bit di informazione!
|
||||
|
||||
> [!Note]
|
||||
> Spesso applicata assieme a [[dimensione dei messaggi limitata]] per non trivializzare i problemi.
|
||||
|
|
|
|||
|
|
@ -1,14 +1,7 @@
|
|||
{
|
||||
"nodes":[
|
||||
{"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},
|
||||
{"id":"0e88c8c55309b762","type":"group","x":220,"y":-2580,"width":2440,"height":2200,"label":"Restrizioni del modello"},
|
||||
{"id":"9ff0a423dbb281a0","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/rete di comunicazione.md","x":-320,"y":-160,"width":400,"height":400},
|
||||
{"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":"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},
|
||||
{"id":"44b1b735656f3c4b","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/azione.md","x":1360,"y":1520,"width":400,"height":400},
|
||||
|
|
@ -34,19 +27,19 @@
|
|||
{"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":"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":"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":"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":"5a382d3822a5736e","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/risveglio ignorato.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 multiplo.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":"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":"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":"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"},
|
||||
|
|
@ -54,10 +47,19 @@
|
|||
{"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":"7862502b2075f0a7","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/no failure detection.md","x":1280,"y":-2000,"width":400,"height":200,"color":"3"},
|
||||
{"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},
|
||||
{"id":"83b3be69f6f3d497","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/timeout.md","x":2000,"y":-160,"width":400,"height":400},
|
||||
{"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"}
|
||||
{"id":"961e2a0551edc3c5","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di comunicazione.md","x":800,"y":-2560,"width":400,"height":480},
|
||||
{"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"},
|
||||
{"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":"a7babffbb19e1b32","x":1280,"y":-2560,"width":400,"height":200,"color":"3","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/dimensione dei messaggi limitata.md"},
|
||||
{"id":"b5607837b4452d83","x":2240,"y":-2560,"width":400,"height":200,"color":"1","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/dimensione dei messaggi illimitata.md"}
|
||||
],
|
||||
"edges":[
|
||||
{"id":"1bb35cb60ca4ea15","fromNode":"afa296d887da4394","fromSide":"bottom","toNode":"904bb8e648bdcb90","toSide":"top"},
|
||||
|
|
@ -120,6 +122,8 @@
|
|||
{"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"}
|
||||
{"id":"ac5fdc2d569502ff","fromNode":"fc4c48607c9ae580","fromSide":"bottom","toNode":"83b3be69f6f3d497","toSide":"top"},
|
||||
{"id":"a8acecef3a9f4a45","fromNode":"961e2a0551edc3c5","fromSide":"right","toNode":"a7babffbb19e1b32","toSide":"left"},
|
||||
{"id":"57ba1c5dfab48bec","fromNode":"a7babffbb19e1b32","fromSide":"right","toNode":"b5607837b4452d83","toSide":"left"}
|
||||
]
|
||||
}
|
||||
|
|
@ -12,6 +12,7 @@ Una [[entità]] vuole comunicare un'informazione a tutto il resto del [[sistema
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- [[dimensione dei messaggi illimitata]]
|
||||
- [[half-duplex]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ Problema per un [[sistema distribuito]], variante del [[broadcast problem]].
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- [[dimensione dei messaggi illimitata]]
|
||||
- [[full-duplex|grafo indiretto]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
|
|
@ -14,7 +15,7 @@ Problema per un [[sistema distribuito]], variante del [[broadcast problem]].
|
|||
- [[grafo connesso]]
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- [[ritardo di comunicazione illimitato]]
|
||||
- ***[[risveglio parziale]]***
|
||||
- ***[[risveglio multiplo]]***
|
||||
- [[terminazione locale]]
|
||||
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ Si vuole ***minimizzare il [[diametro di un grafo|diametro]]*** di uno [[spannin
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- [[dimensione dei messaggi illimitata]]
|
||||
- [[full-duplex]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ Si vuole [[problema di ricerca|determinare]] uno [[spanning tree]] per il [[sist
|
|||
- ***[[identificatori univoci]]***
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- [[ritardo di comunicazione unitario]]
|
||||
- ***[[risveglio parziale]]***
|
||||
- ***[[risveglio multiplo]]***
|
||||
- [[terminazione locale]]
|
||||
|
||||
### [[Algoritmo|Algoritmi]]
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ Si vuole determinare uno [[spanning tree]] per il [[sistema distribuito]] in mod
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- [[dimensione dei messaggi illimitata]]
|
||||
- [[full-duplex]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ Si vuole calcolare qualcosa più efficientemente possibile, distribuendo gli [[9
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- [[dimensione dei messaggi illimitata]]
|
||||
- [[full-duplex]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ Si vuole calcolare qualcosa più efficientemente possibile, distribuendo gli [[9
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- [[dimensione dei messaggi illimitata]]
|
||||
- [[full-duplex|grafo indiretto]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
|
|
@ -15,7 +16,7 @@ Si vuole calcolare qualcosa più efficientemente possibile, distribuendo gli [[9
|
|||
- ***[[grafo aciclico]]***
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- [[ritardo di comunicazione illimitato]]
|
||||
- ***[[risveglio parziale]]***
|
||||
- ***[[risveglio multiplo]]***
|
||||
- [[terminazione locale]]
|
||||
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
|
|
|||
|
|
@ -29,6 +29,13 @@ Le [[entità]] `PROCESSING` che ricevono il [[messaggio]] ***lo accettano come [
|
|||
|
||||
Un'[[entità]] `DONE` conosce il [[risultato]] della computazione, e non fa nient'altro.
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
> [!Success]
|
||||
> Eventualmente, i messaggi convergeranno obbligatoriamente alla radice, e la sua notifica di terminazione raggiungerà eventualmente tutte le foglie.
|
||||
>
|
||||
> ==Come si chiamano i problemi risolvibili con la saturazione?==
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
|
|
|||
|
|
@ -27,6 +27,13 @@ Le [[entità]] `PROCESSING` che ricevono il [[messaggio]] ***effettuano nuovamen
|
|||
|
||||
Un'[[entità]] `DONE` conosce il [[risultato]] della computazione, e non fa nient'altro.
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
> [!Success]
|
||||
> Eventualmente, i messaggi convergeranno obbligatoriamente a due entità, e la loro notifica di terminazione raggiungerà eventualmente tutte le altre.
|
||||
>
|
||||
> ==Come si chiamano i problemi risolvibili con la saturazione?==
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
|
|
|||
|
|
@ -0,0 +1,25 @@
|
|||
Problema per un [[sistema distribuito]] che introduce maggiori [[restrizioni al modello dei sistemi distribuiti|restrizioni]] alla [[leader election]] per ottenere [[costo computazionale]] minore.
|
||||
|
||||
## 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]]**
|
||||
- ***[[dimensione dei messaggi limitata]]***
|
||||
- [[half-duplex]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[grafo connesso]]
|
||||
- [[identificatori univoci]]
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- ***[[ritardo di comunicazione unitario]]***
|
||||
- [[risveglio multiplo]]
|
||||
- [[terminazione locale]]
|
||||
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
||||
- [[leader election su anello speeding]]
|
||||
- [[leader election su anello waiting]]
|
||||
|
|
@ -4,3 +4,15 @@
|
|||
|
||||
> [!Summary]
|
||||
> La radice diventa automaticamente il [[leader]].
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
> [!Success]
|
||||
> L'algoritmo è triviale e termina immediatamente.
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione]] | $0$ |
|
||||
| [[tempo]] | $0$ |
|
||||
|
|
|
|||
|
|
@ -4,19 +4,23 @@
|
|||
|
||||
> [!Summary]
|
||||
>
|
||||
> Ogni [[entità]] riceve identificatori dalla precedente, tenendo traccia dell'identificatore minimo ricevuto, e inoltra alla successiva qualsiasi cambiamento al proprio minimo.
|
||||
> Ogni [[entità]] riceve identificatori dalla [[entità precedente in un anello|precedente]], tenendo traccia dell'identificatore minimo ricevuto, e inoltra alla [[entità successiva in un anello|successiva]] qualsiasi cambiamento al proprio minimo.
|
||||
>
|
||||
> Quando un'[[entità]] avrà ricevuto il suo stesso identificatore dalla [[entità precedente in un anello|precedente]], essa diventerà leader, e manderà un [[broadcast problem|broadcast]] di terminazione a tutte le altre.
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
Quando il futuro [[leader]] avrà ricevuto dalla precedente il suo stesso identificatore, l'algoritmo avrà terminato.
|
||||
|
||||
> [!Note]
|
||||
> [!Success]
|
||||
> È certo che l'identificatore minimo di tutto il [[sistema distribuito]] attraverserà tutte le [[entità]] in esso, fino a tornare al futuro [[leader]].
|
||||
>
|
||||
> La [[terminazione locale|terminazione è locale solo per il leader]], le altre entità hanno bisogno di un [[broadcast problem|broadcast]].
|
||||
> Avendo l'[[anello]] un numero finito di [[nodo di un grafo|nodi]] al suo interno, eventualmente sarà trovato un [[leader]], che a quel punto farà terminare l'esecuzione con il [[broadcast problem|broadcast]].
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
==Includere la terminazione nel costo computazionale?==
|
||||
| Costo | [[notazione O-grande]] | [[notazione Ω-grande]] |
|
||||
|-|-|-|
|
||||
| [[comunicazione]] | $O(Entities^2)$ | $\Omega(Entities)$ |
|
||||
| [[tempo]] | ... | ... |
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
|
|
@ -24,7 +28,7 @@ Quando il futuro [[leader]] avrà ricevuto dalla precedente il suo stesso identi
|
|||
|
||||
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:
|
||||
Nel caso peggiore, il [[ritardo di comunicazione unitario|ritardo di comunicazione sarà unitario]], quindi avremo che:
|
||||
1. il massimo sarà propagato per $1$ messaggio
|
||||
2. il secondo massimo sarà propagato per $2$ messaggi
|
||||
3. $\dots$
|
||||
|
|
@ -32,16 +36,35 @@ Assumendo un [[ritardo di comunicazione unitario]], avremo che:
|
|||
|
||||
Totalizzando:
|
||||
$$
|
||||
\sum_{Identifier=1}^{Entities} Identifier
|
||||
\color{LightCoral} \sum_{Identifier=1}^{Entities} Identifier
|
||||
$$
|
||||
|
||||
Ovvero:
|
||||
$$
|
||||
\color{LightCoral}
|
||||
\frac
|
||||
{Entities \cdot (Entities + 1)}
|
||||
{2}
|
||||
$$
|
||||
|
||||
In aggiunta, sarà necessaria anche un [[broadcast problem|broadcast]] di terminazione, che richiederà:
|
||||
$$
|
||||
\color{SkyBlue} Entities
|
||||
$$
|
||||
|
||||
Per un totale di:
|
||||
$$
|
||||
{
|
||||
\color{LightCoral}
|
||||
\frac
|
||||
{Entities \cdot (Entities + 1)}
|
||||
{2}
|
||||
}
|
||||
+
|
||||
{
|
||||
\color{SkyBlue} Entities
|
||||
}
|
||||
$$
|
||||
[[notazione asintotica|Asintoticamente]]:
|
||||
$$
|
||||
\Large O \left( Entities^2 \right)
|
||||
|
|
@ -49,22 +72,42 @@ $$
|
|||
|
||||
#### Caso migliore
|
||||
|
||||
Il caso peggiore è quello in cui ==le [[entità]] sono [[iniziatori multipli|tutte iniziatrici]]== e in ordine decrescente di [[identificatore]].
|
||||
Il caso migliore è quello in cui le [[entità]] sono [[risveglio multiplo|tutte iniziatrici]] e in ordine decrescente di [[identificatore]].
|
||||
|
||||
==Assumendo un [[ritardo di comunicazione unitario]]==, avremo che:
|
||||
Avremo che:
|
||||
1. il minimo sarà propagato per $Entities$ messaggi
|
||||
2. tutti gli altri per $1$ messaggio
|
||||
|
||||
Totalizzando:
|
||||
$$
|
||||
\color{LightCoral}
|
||||
Entities
|
||||
+
|
||||
\sum_{Identifier=2}^{Entities} 1
|
||||
$$
|
||||
|
||||
Ovvero:
|
||||
$$
|
||||
Entities + (Entities - 1)
|
||||
\color{LightCoral} Entities + (Entities - 1)
|
||||
$$
|
||||
|
||||
In aggiunta, sarà necessaria anche un [[broadcast problem|broadcast]] di terminazione, che richiederà:
|
||||
$$
|
||||
\color{SkyBlue} Entities
|
||||
$$
|
||||
|
||||
Per un totale di:
|
||||
$$
|
||||
{
|
||||
\color{LightCoral} Entities + (Entities - 1)
|
||||
}
|
||||
+
|
||||
{
|
||||
\color{SkyBlue} Entities
|
||||
}
|
||||
$$
|
||||
Ovvero:
|
||||
$$
|
||||
3 \cdot Entities - 1
|
||||
$$
|
||||
[[notazione asintotica|Asintoticamente]]:
|
||||
$$
|
||||
|
|
|
|||
|
|
@ -5,8 +5,6 @@
|
|||
> [!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}$.
|
||||
|
|
@ -23,26 +21,46 @@ Sapendo sicuramente di non essere il leader, si limita a inoltrare messaggi.
|
|||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione]] | $O(Entities \cdot \log (Entities))$ |
|
||||
| [[tempo]] | ... |
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
Ad ogni iterazione, ogni candidato invia e riceve su ogni lato:
|
||||
Il caso peggiore per le iterazioni sono le iterazioni intermedie (che non sono la prima o l'ultima o il broadcast di terminazione). ==Perchè?==
|
||||
|
||||
Ad ogni iterazione intermedia, ogni candidato invia e riceve su ogni lato:
|
||||
$$
|
||||
\color{Gold} 2 ^ {Iteration}
|
||||
\color{Gold} 2 ^ {Iteration_1}
|
||||
$$
|
||||
Sommando andata e ritorno:
|
||||
$$
|
||||
{\color{Gold} 2} \cdot 2 ^ {Iteration}
|
||||
{\color{Gold} 2} \cdot 2 ^ {Iteration_1}
|
||||
$$
|
||||
Sommando i due lati:
|
||||
$$
|
||||
{\color{Gold} 2} \cdot 2 \cdot 2^{Iteration}
|
||||
{\color{Gold} 2} \cdot 2 \cdot 2^{Iteration_1}
|
||||
$$
|
||||
Sommando tutti i `CANDIDATE`:
|
||||
I `CANDIDATE` si dimezzano ad ogni iterazione; considerando le iterazioni [[indicizzazione a 1|indicizzate a 1]], sommandoli si ottiene che:
|
||||
$$
|
||||
{\color{Gold} \mathrm{floor} \left(
|
||||
\frac{n}{2^{Iteration - 1} + 1}
|
||||
\frac{Entities}{2^{Iteration_1 - 1} + 1}
|
||||
\right)}
|
||||
\cdot 2 \cdot 2 \cdot 2 ^ {Iteration}
|
||||
\cdot 2 \cdot 2 \cdot 2 ^ {Iteration_1}
|
||||
$$
|
||||
Pertanto, in [[notazione asintotica]] abbiamo:
|
||||
$$
|
||||
O(Entities \cdot Iteration)
|
||||
$$
|
||||
|
||||
==Qui la prof fa dei calcoli. Ho troppo sonno per capirli.==
|
||||
Il numero di iterazioni è pari al [[logaritmo in base 2]] del numero di [[entità]] del [[sistema distribuito]]:
|
||||
$$
|
||||
\color{Gold} \mathrm{ceil} \left(
|
||||
\log (Entities)
|
||||
\right)
|
||||
$$
|
||||
Quindi, la [[notazione asintotica]] finale sarà:
|
||||
$$
|
||||
\large O(Entities \cdot {\color{Gold} \log (Entities)})
|
||||
$$
|
||||
|
|
|
|||
|
|
@ -1,19 +1,23 @@
|
|||
[[algoritmo]] di [[leader election]] che risolve il problema di terminazione della [[leader election su anello all-the-way]] ***introducendo una [[restrizione di topologia]] aggiuntiva.***
|
||||
[[algoritmo]] di [[leader election]] che risolve il problema di terminazione della [[leader election su anello all-the-way]].
|
||||
|
||||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
|
||||
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[anello]] di ***dimensione nota***
|
||||
|
||||
## [[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]]***.
|
||||
|
||||
## [[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==
|
||||
- con un [[contatore]] su ogni [[messaggio]], che conta il numero di [[entità]] transitate
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
L'algoritmo termina quando tutte le [[entità]] hanno visto tanti [[messaggio|messaggi]] quante le [[entità]] del [[sistema distribuito]].
|
||||
> [!Success]
|
||||
> L'algoritmo termina quando tutte le [[entità]] hanno visto tanti [[messaggio|messaggi]] quante le [[entità]] del [[sistema distribuito]].
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,54 @@
|
|||
[[algoritmo]] di [[fully synchronous leader election]] derivato dalla [[leader election su anello as-far-as-it-can]]
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
>
|
||||
> Ogni [[entità]] riceve identificatori dalla [[entità precedente in un anello|precedente]], tenendo traccia dell'identificatore minimo ricevuto, e inoltra alla [[entità successiva in un anello|successiva]] qualsiasi cambiamento ad esso, ***applicando però un ritardo dipendente dal valore dell'[[identificatore]]***.
|
||||
>
|
||||
> Quando un'[[entità]] avrà ricevuto il suo stesso identificatore dalla [[entità precedente in un anello|precedente]], essa diventerà leader, e manderà un [[broadcast problem|broadcast]] di terminazione a tutte le altre.
|
||||
|
||||
==Spiegare come scegliere il tempo?==
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
> [!Success]
|
||||
> È certo che l'identificatore minimo di tutto il [[sistema distribuito]] attraverserà tutte le [[entità]] in esso, fino a tornare al futuro [[leader]].
|
||||
>
|
||||
> Avendo l'[[anello]] un numero finito di [[nodo di un grafo|nodi]] al suo interno, eventualmente sarà trovato un [[leader]], che a quel punto farà terminare l'esecuzione con il [[broadcast problem|broadcast]].
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione]] | Dipende. |
|
||||
| [[tempo]] | Dipende. |
|
||||
|
||||
### [[Tempo]]
|
||||
|
||||
L'[[identificatore]] minore compie un giro completo dell'[[anello]] dopo:
|
||||
$$
|
||||
\color{LightCoral} \mathrm{delay}(\min (Identifier)) \cdot Entities
|
||||
$$
|
||||
|
||||
In più, il [[broadcast problem|broadcast]] di terminazione richiede:
|
||||
$$
|
||||
\color{SkyBlue} Entities
|
||||
$$
|
||||
|
||||
Per un totale di:
|
||||
$$
|
||||
{
|
||||
\color{LightCoral} \mathrm{delay}(\min (Identifier)) \cdot Entities
|
||||
}
|
||||
+
|
||||
{
|
||||
\color{SkyBlue} Entities
|
||||
}
|
||||
$$
|
||||
|
||||
La [[notazione asintotica]] risultante dipende dalla scelta effetuata di $\mathrm{delay}(Identifier)$.
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
Anche il costo di comunicazione dipende dalla scelta effettuata di $\mathrm{delay}(Identifier)$, pertanto il calcolo è completamente omesso da questa pagina.
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
[[algoritmo]] di [[fully synchronous leader election]].
|
||||
|
||||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
|
||||
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[anello]] di dimensione nota
|
||||
- **[[9 - Algoritmi distribuiti/1 - Problemi/tempo|Tempo]]**
|
||||
- ***[[risveglio multiplo]]***
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Ogni [[entità]] aspetta un tempo dipendente dal valore dell'identificatore, inviando il suo [[identificatore]] alla successiva al termine dell'attesa.
|
||||
>
|
||||
> Quando una [[entità]] in attesa riceve l'identificatore di un'altra, la accetta come [[leader]] e termina.
|
||||
|
||||
==***Cambia come scegliere il tempo!***== $2 \cdot Entities \cdot Identifier$
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
> [!Success]
|
||||
> Prima o poi, un'[[entità]] terminerà la sua attesa, e farà circolare il suo [[messaggio]] di terminazione da tutte le altre.
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione]] | $O(Entities)$ |
|
||||
| [[tempo]] | Dipende. |
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
Vengono inviati solamente:
|
||||
$$
|
||||
Entities
|
||||
$$
|
||||
|
||||
Quindi, il costo computazionale è di:
|
||||
$$
|
||||
\Large O(Entities)
|
||||
$$
|
||||
|
||||
### [[Tempo]]
|
||||
|
||||
L'[[identificatore]] minore deve terminare l'attesa per poter notificare della terminazione:
|
||||
$$
|
||||
\color{LightCoral} \mathrm{delay}(\min (Identifier))
|
||||
$$
|
||||
|
||||
Poi, deve trascorrere sufficiente tempo per il [[broadcast problem|broadcast]] di terminazione:
|
||||
$$
|
||||
\color{SkyBlue} Entities
|
||||
$$
|
||||
|
||||
Per un totale di:
|
||||
$$
|
||||
{
|
||||
\color{LightCoral} \mathrm{delay}(\min (Identifier))
|
||||
}
|
||||
+
|
||||
{
|
||||
\color{SkyBlue} Entities
|
||||
}
|
||||
$$
|
||||
|
||||
La [[notazione asintotica]] risultante dipende dalla scelta effetuata di $\mathrm{delay}(Identifier)$.
|
||||
|
|
@ -0,0 +1,66 @@
|
|||
[[algoritmo]] di [[fully synchronous leader election]].
|
||||
|
||||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
|
||||
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[anello]] di dimensione nota
|
||||
- **[[9 - Algoritmi distribuiti/1 - Problemi/tempo|Tempo]]**
|
||||
- [[risveglio ignorato]]
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Ogni [[entità]] aspetta un tempo dipendente dal valore dell'identificatore, inviando il suo [[identificatore]] alla successiva al termine dell'attesa.
|
||||
>
|
||||
> Quando una [[entità]] in attesa riceve l'identificatore di un'altra, la accetta come [[leader]] e termina.
|
||||
|
||||
==Spiegare come scegliere il tempo?==
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
> [!Success]
|
||||
> Prima o poi, un'[[entità]] terminerà la sua attesa, e farà circolare il suo [[messaggio]] di terminazione da tutte le altre.
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione]] | $O(Entities)$ |
|
||||
| [[tempo]] | Dipende. |
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
Vengono inviati solamente:
|
||||
$$
|
||||
Entities
|
||||
$$
|
||||
|
||||
Quindi, il costo computazionale è di:
|
||||
$$
|
||||
\Large O(Entities)
|
||||
$$
|
||||
|
||||
### [[Tempo]]
|
||||
|
||||
L'[[identificatore]] minore deve terminare l'attesa per poter notificare della terminazione:
|
||||
$$
|
||||
\color{LightCoral} \mathrm{delay}(\min (Identifier))
|
||||
$$
|
||||
|
||||
Poi, deve trascorrere sufficiente tempo per il [[broadcast problem|broadcast]] di terminazione:
|
||||
$$
|
||||
\color{SkyBlue} Entities
|
||||
$$
|
||||
|
||||
Per un totale di:
|
||||
$$
|
||||
{
|
||||
\color{LightCoral} \mathrm{delay}(\min (Identifier))
|
||||
}
|
||||
+
|
||||
{
|
||||
\color{SkyBlue} Entities
|
||||
}
|
||||
$$
|
||||
|
||||
La [[notazione asintotica]] risultante dipende dalla scelta effetuata di $\mathrm{delay}(Identifier)$.
|
||||
|
|
@ -5,6 +5,18 @@
|
|||
> [!Summary]
|
||||
> Usa la [[tecnica di saturazione per grafi aciclici]] per trovare l'entità con [[identificatore]] minore, che viene poi scelta come [[leader]].
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
> [!Success]
|
||||
> L'unica parte non-[[algoritmo triviale|triviale]] di questo [[algoritmo]] è la [[tecnica di saturazione per grafi aciclici]], ed essendo corretta, rende anche questo [[algoritmo]] corretto.
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione]] | $O(Entities)$ |
|
||||
| [[tempo]] | ... |
|
||||
|
||||
## [[Duale]]
|
||||
|
||||
- [[shout+ protocol]]
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@ Si vuole scegliere un'[[entità]] che diventerà il [[leader]] per un [[algoritm
|
|||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- [[dimensione dei messaggi illimitata]]
|
||||
- [[half-duplex]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
|
|
@ -15,8 +16,8 @@ Si vuole scegliere un'[[entità]] che diventerà il [[leader]] per un [[algoritm
|
|||
- [[identificatori univoci]]
|
||||
- il teorema [[Angluin 1980]] li pone come requisito per la risolvibilità
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- [[ritardo di comunicazione unitario]]
|
||||
- [[risveglio parziale]]
|
||||
- [[ritardo di comunicazione illimitato]]
|
||||
- [[risveglio multiplo]]
|
||||
- [[terminazione locale]]
|
||||
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
|
|
|||
|
|
@ -1,19 +1,24 @@
|
|||
{
|
||||
"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":"18ea906d1635d485","type":"group","x":660,"y":900,"width":920,"height":3080,"label":"Anello"},
|
||||
{"id":"59e651b187da9388","type":"group","x":660,"y":4100,"width":920,"height":1000,"label":"Grafo di diametro noto"},
|
||||
{"id":"8c32c2275213ea05","type":"group","x":660,"y":5220,"width":440,"height":2040,"label":"Anello"},
|
||||
{"id":"740207a9a63c9513","type":"group","x":660,"y":340,"width":920,"height":440,"label":"Grafo aciclico"},
|
||||
{"id":"e7d0f7c50e744dfe","type":"group","x":660,"y":-260,"width":920,"height":440,"label":"Albero"},
|
||||
{"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":"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":"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":"9f58039648a89105","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/fully synchronous leader election.md","x":-440,"y":5240,"width":960,"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},
|
||||
{"id":"e419946480096acc","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello speeding.md","x":680,"y":5240,"width":400,"height":960},
|
||||
{"id":"a94c943350a80ff7","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione unitario.md","x":-1000,"y":5520,"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":"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}
|
||||
{"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":"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":"6bb989c83e5ff0aa","x":680,"y":6280,"width":400,"height":960,"type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello waiting.md"}
|
||||
],
|
||||
"edges":[
|
||||
{"id":"76ba628c35000191","fromNode":"b672c8042ef8c199","fromSide":"bottom","toNode":"26a2bda47738d7d8","toSide":"top"},
|
||||
|
|
@ -23,6 +28,9 @@
|
|||
{"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"}
|
||||
{"id":"29ea3a738fc0be45","fromNode":"26a2bda47738d7d8","fromSide":"right","toNode":"59e651b187da9388","toSide":"left"},
|
||||
{"id":"ef87ea0f01bb48f4","fromNode":"26a2bda47738d7d8","fromSide":"bottom","toNode":"9f58039648a89105","toSide":"top"},
|
||||
{"id":"2d815c735e9b4772","fromNode":"a94c943350a80ff7","fromSide":"right","toNode":"9f58039648a89105","toSide":"left"},
|
||||
{"id":"78abf2a6f676f331","fromNode":"9f58039648a89105","fromSide":"right","toNode":"8c32c2275213ea05","toSide":"left"}
|
||||
]
|
||||
}
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
[[algoritmo]] di [[routing]] che sfrutta l'[[algoritmo di Dijkstra]].
|
||||
|
||||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
|
||||
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[canale di comunicazione|canali]] con [[funzione costo|costo]] ***non-negativo***
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Fintanto che non sono rimasti [[router]] fuori dallo [[spanning tree]], ad ogni iterazione:
|
||||
> 1. il [[leader]] usa la [[tecnica di saturazione per alberi]] all'interno dello [[spanning tree]] costruito fino a quel momento per determinare il [[canale di comunicazione|canale]] di [[costo]] minimo;
|
||||
> 2. il [[leader]] aggiunge allo [[spanning tree]] quel [[canale di comunicazione|canale]] e il relativo [[router]], notificandolo della cosa attraverso la route conosciuta;
|
||||
> 3. il [[router]] aggiunto notifica i [[vicini di un'entità|vicini]] della sua aggiunta all'albero, aspettando che tutti i vicini confermino l'operazione;
|
||||
> 4. il [[router]] notifica il [[leader]] della aggiunta completata.
|
||||
|
||||
> [!Tip]
|
||||
> Per ciascun [[router]], il genitore nell'albero diventa il [[default gateway]]!
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
> [!Success]
|
||||
> Deriva dalla [[algoritmo corretto|correttezza]] dell'[[algoritmo di Dijkstra]].
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione di routing]] | $O(Entities^2) |
|
||||
| [[tempo]] | ... |
|
||||
|
||||
### [[Comunicazione di routing]]
|
||||
|
||||
#### Inizio
|
||||
|
||||
Ciascuna [[entità]] scambia informazioni con i propri vicini:
|
||||
$$
|
||||
\color{LightCoral} 2 \cdot Channels
|
||||
$$
|
||||
|
||||
#### Iterazione singola
|
||||
|
||||
1. La [[tecnica di saturazione per alberi]] costa:
|
||||
$$4 \cdot Entities - 4$$
|
||||
2. L'*andata* della notifica di aggiunta costa:
|
||||
$$Entities$$
|
||||
3. La notifica ai [[vicini di un'entità|vicini]] costa:
|
||||
$$\mathrm{neighbours}(Entity)$$
|
||||
4. Il *ritorno* della notifica di aggiunta costa:
|
||||
$$Entities$$
|
||||
|
||||
Sommando per tutte le iterazioni, abbiamo:
|
||||
$$
|
||||
\sum_{Entity}^{Entities}
|
||||
(4 \cdot Entities - 4)
|
||||
+
|
||||
(Entities)
|
||||
+
|
||||
(\mathrm{neighbours}(Entity))
|
||||
+
|
||||
(Entities)
|
||||
$$
|
||||
|
||||
Considerando che i [[vicini di un'entità|vicini]] di una [[entità]] non possono essere più dei [[router]] totali:
|
||||
$$
|
||||
\sum_{Entity}^{Entities}
|
||||
(4 \cdot Entities - 4)
|
||||
+
|
||||
(Entities)
|
||||
+
|
||||
(Entities)
|
||||
+
|
||||
(Entities)
|
||||
$$
|
||||
|
||||
#### Totale
|
||||
|
||||
In totale, dunque, avremo una [[notazione asintotica]] di:
|
||||
$$
|
||||
O(Entities^2)
|
||||
$$
|
||||
|
||||
==C'è una dimostrazione diversa sulle slides, che non ho troppo capito perchè è tutta in notazione matematica.==
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
> [!Warning]
|
||||
> Per qualche motivo a me sconosciuto, nel calcolare il [[costo computazionale]] di [[comunicazione]] in [[routing]] viene usata una misura diversa, ibrida tra [[comunicazione]] e [[9 - Algoritmi distribuiti/1 - Problemi/spazio|spazio]], che considera **un [[messaggio]] ogni coppia chiave-valore della [[routing table]] scambiata***.
|
||||
|
|
@ -2,13 +2,15 @@
|
|||
aliases:
|
||||
- routing function
|
||||
---
|
||||
[[Funzione]] [[individuale]] che, in un problema di [[routing]], associa ogni [[entità]] con il [[canale di comunicazione]] da utilizzare per raggiungerla.
|
||||
[[Funzione]] [[individuale|specifica ogni singola entità]] che, associa ogni [[entità]] con il [[canale di comunicazione]] da utilizzare per raggiungerla.
|
||||
|
||||
$$
|
||||
\def \varSource {{\color{LimeGreen} Source}}
|
||||
\def \varEntity {{\color{LimeGreen} Entity}}
|
||||
\def \varDestination {{\color{IndianRed} Destination}}
|
||||
\def \varChannel {{\color{SkyBlue} Channel}}
|
||||
\Large
|
||||
\textrm{Channel}_{\varSource}(\varDestination)
|
||||
\textrm{Route}_{\varEntity}(\varDestination) \to \varChannel
|
||||
$$
|
||||
|
||||
Comunemente implementata come [[routing table]].
|
||||
> [!Example]
|
||||
> Comunemente implementata con una [[routing table]]!
|
||||
|
|
|
|||
|
|
@ -0,0 +1,66 @@
|
|||
[[algoritmo]] di [[routing]].
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> I [[router]] recuperano informazioni sul loro [[vicinato]].
|
||||
>
|
||||
> Si costruisce uno [[spanning tree]] non ottimizzato e lo si usa per permettere ai [[router]] di scambiarsi le informazioni raccolte.
|
||||
>
|
||||
> Ricevute le informazioni, ogni entità computa uno [[spanning tree]] ottimizzato, e ci deriva la [[routing table]].
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
> [!Success]
|
||||
> Eventualmente, il [[broadcast problem su grafo aciclico|broadcast]] termina, dando a tutti i [[router]] le informazioni necessarie per calcolare la loro [[routing table]].
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione del routing]] | $O(Entities \cdot Channels)$ |
|
||||
| [[tempo]] | ... |
|
||||
|
||||
### [[comunicazione del routing]]
|
||||
|
||||
Recuperare informazioni sul [[vicini di un'entità|vicinato]] richiede un'andata-e-ritorno attraverso ogni [[canale di comunicazione|canale]]:
|
||||
$$
|
||||
\color{LightCoral} 2 \cdot Channels
|
||||
$$
|
||||
|
||||
Creare lo [[spanning tree]] iniziale con [[shout+ protocol]] richiede:
|
||||
$$
|
||||
\color{SpringGreen} 2 \cdot Channels
|
||||
$$
|
||||
|
||||
Infine, inviare il [[broadcast problem su grafo aciclico|broadcast]] richiede:
|
||||
$$
|
||||
\sum_{Entity}^{Entities} (Entities - 1) \cdot \mathrm{neighbours}(Entity)
|
||||
$$
|
||||
Ovvero:
|
||||
$$
|
||||
\color{SkyBlue} (Entities - 1) \cdot (2 \cdot Channels)
|
||||
$$
|
||||
|
||||
Per un totale di:
|
||||
$$
|
||||
{\color{LightCoral} 2 \cdot Channels}
|
||||
+
|
||||
{\color{SpringGreen} 2 \cdot Channels}
|
||||
+
|
||||
{\color{SkyBlue} (Entities - 1) \cdot (2 \cdot Channels)}
|
||||
$$
|
||||
|
||||
Ovvero:
|
||||
$$
|
||||
(Entities + 3) \cdot (2 \cdot Channels)
|
||||
$$
|
||||
In [[notazione asintotica]]:
|
||||
$$
|
||||
\Large O(Entities \cdot Channels)
|
||||
$$
|
||||
|
||||
### [[routing memory]]
|
||||
|
||||
> [!Note]
|
||||
> Ogni [[entità]] si deve salvare le informazioni per *tutta* la [[rete di comunicazione]]!
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
[[algoritmo]] di [[routing]].
|
||||
|
||||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
|
||||
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[diametro di un grafo|diametro]] noto
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Ogni [[router]] crea una [[routing table]] con solo i suoi vicini.
|
||||
>
|
||||
> Ad ogni iterazione, la invia a tutti i suoi [[vicini di un'entità|vicini]], e riceve contemporaneamente le loro, con cui aggiorna la propria.
|
||||
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
> [!Success]
|
||||
> Dopo tante iterazioni quante il [[diametro di un grafo|diametro]] della [[rete di comunicazione]], tutti i [[router]] avranno aggregato le routing table di tutti gli altri, terminando cosí l'algoritmo.
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione del routing]] | $O(Entities \cdot Channels)$ |
|
||||
| [[tempo]] | ... |
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
Ogni [[router]] scambia informazioni con i suoi [[vicini di un'entità|vicini]]:
|
||||
$$
|
||||
\color{LightCoral} 2 \cdot Entities
|
||||
$$
|
||||
|
||||
Ad ogni iterazione, ogni [[router]] invia la sua [[routing table]] ai suoi [[vicini di un'entità|vicini]]:
|
||||
$$
|
||||
\sum_{Entity}^{Entities} \sum_{RoutingEntry}^{RoutingEntries} \mathrm{neighbours}(Entity)
|
||||
$$
|
||||
Cioè:
|
||||
$$
|
||||
Entities \cdot 2 \cdot Channels
|
||||
$$
|
||||
Riscritto meglio:
|
||||
$$
|
||||
\color{SpringGreen} 2 \cdot Entities \cdot Channels
|
||||
$$
|
||||
|
||||
In totale:
|
||||
$$
|
||||
{\color{LightCoral} 2 \cdot Entities}
|
||||
+
|
||||
{\color{SpringGreen} 2 \cdot Entities \cdot Channels}
|
||||
$$
|
||||
In [[notazione asintotica]]:
|
||||
$$
|
||||
\Large O(Entities \cdot Channels)
|
||||
$$
|
||||
|
|
@ -1,92 +0,0 @@
|
|||
[[algoritmo]] [[iterativo]] di [[routing]] che sfrutta la visita [[breadth-first]].
|
||||
|
||||
## Funzionamento
|
||||
|
||||
### Distanze a relazione
|
||||
|
||||
Consideriamo due [[entità]] vicine nel [[sistema distribuito]]:
|
||||
$$
|
||||
\def \varSource {{\color{LimeGreen} Source}}
|
||||
\def \varA {{\color{DarkGoldenrod} Entity_A}}
|
||||
\def \varB {{\color{Goldenrod} Entity_B}}
|
||||
\Large
|
||||
\varA\ \textrm{neighbours}\ \varB
|
||||
$$
|
||||
|
||||
Misuriamo la [[distanza]] di $\varA$ dalla sorgente $\varSource$:
|
||||
$$
|
||||
\Large
|
||||
\textrm{Distance}_{\varSource}(\varA)
|
||||
$$
|
||||
|
||||
Confrontiamola con la [[distanza]] di $\varB$, notando che ci si può trovare in tre casi:
|
||||
$$
|
||||
\Large
|
||||
\textrm{Distance}_{\varSource}(\varA) = \begin{cases}
|
||||
\textrm{Distance}_{\varSource}(\varB)-1\\
|
||||
\textrm{Distance}_{\varSource}(\varB)\\
|
||||
\textrm{Distance}_{\varSource}(\varB)+1
|
||||
\end{cases}
|
||||
$$
|
||||
|
||||
### Albero parziale
|
||||
|
||||
Definiamo un *albero parziale*, che ad ogni iterazione conterrà i nodi a distanza $Iterazione - 1$, e poi esploriamo i nodi vicini fino a raggiungere i nodi a distanza $Iterazione$.
|
||||
|
||||
## [[stato di un'entità|Stati]]
|
||||
|
||||
- `SOURCE`: il [[leader]]
|
||||
- `UNKNOWN`: una [[entità]] non parte dell'albero parziale
|
||||
- `EXPLORED`: una [[entità]] parte dell'albero parziale
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
### `SOURCE`
|
||||
|
||||
==...==
|
||||
|
||||
### `UNKNOWN`
|
||||
|
||||
==...==
|
||||
|
||||
### `EXPLORED`
|
||||
|
||||
==...==
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
Ogni iterazione dell'algoritmo è divisa in tre fasi:
|
||||
- broadcast
|
||||
- explore
|
||||
- convergecast
|
||||
|
||||
Definiamo il numero di nodi all'inizio di ogni iterazione come $\def \varNi {{\color{salmon} Nodes_{Iteration}}} \varNi$.
|
||||
|
||||
Definiamo l'iterazione attuale come $\def \varIter {{\color{Blue} Iteration_{Current}}} \varIter$.
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
==...==
|
||||
### [[Spazio]]
|
||||
|
||||
==...==
|
||||
### [[Tempo]]
|
||||
|
||||
Per ogni iterazione, abbiamo che:
|
||||
|
||||
| Fase | Costo |
|
||||
|--|--|
|
||||
| broadcast | $\varIter - 1$ |
|
||||
| explore | $2$ |
|
||||
| convergecast | $\varIter - 1$ |
|
||||
|
||||
In totale, avremo allora che il costo di tempo per una certa iterazione sarà:
|
||||
|
||||
$$
|
||||
(\varIter - 1) + 2 + (\varIter - 1) = 2 \cdot \varIter
|
||||
$$
|
||||
|
||||
Allora, il costo per l'intero algoritmo sarà:
|
||||
==quale?==
|
||||
$$
|
||||
|
||||
$$
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
[[algoritmo]] di [[routing]] che sfrutta la [[breadth-first search]].
|
||||
|
||||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
|
||||
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[canale di comunicazione|canali]] a [[costo]] ***unitario***
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> Ad ogni iterazione:
|
||||
> 1. il [[leader]] invia un [[broadcast]];
|
||||
> 2. le [[foglia di un albero|foglie]] che lo ricevono chiedono ai loro [[vicini di un'entità|vicini]] se sono già nell'albero;
|
||||
> 3. i [[vicini di un'entità|vicini]] che rispondono di no oppure con un altra domanda diventano le nuove [[foglia di un albero|foglie]], notificando il loro nuovo genitore della cosa;
|
||||
> 4. ogni [[router]] attende che tutti i suoi figli abbiano completato l'operazione, poi notifica il genitore, fino ad arrivare alla radice.
|
||||
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
> [!Success]
|
||||
> Essendo tutti i [[router]] a distanza finita dal [[leader]], eventualmente saranno aggiunti tutti allo [[spanning tree]], terminando cosí l'algoritmo.
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione di routing]] | $O(Entities^2 + Channels)$ |
|
||||
| [[tempo]] | ... |
|
||||
|
||||
### [[Comunicazione di routing]]
|
||||
|
||||
#### Singola iterazione
|
||||
|
||||
1. Il [[broadcast problem|broadcast]] iniziale costa, nel caso peggiore:
|
||||
$$Entities$$
|
||||
2. L'esplorazione costa, nel caso peggiore:
|
||||
$$\mathrm{neighbours}(Entity)$$
|
||||
3. Le risposte all'esplorazione costano, nel caso peggiore:
|
||||
$$\mathrm{neighbours}(Entity)$$
|
||||
4. Il [[messaggio]] di termine iterazione costa, nel caso peggiore:
|
||||
$$Entities$$
|
||||
|
||||
Per un totale di:
|
||||
$$
|
||||
(Entities)
|
||||
+
|
||||
(\mathrm{neighbours}(Entity))
|
||||
+
|
||||
(\mathrm{neighbours}(Entity))
|
||||
+
|
||||
(Entities)
|
||||
$$
|
||||
|
||||
Ovvero:
|
||||
$$
|
||||
2 \cdot Entities + 2 \cdot \mathrm{neighbours}(Entity)
|
||||
$$
|
||||
|
||||
#### Totale
|
||||
|
||||
Il numero totale di iterazione dipende dal [[diametro di un grafo|diametro]] della [[rete di comunicazione]], cioè:
|
||||
$$
|
||||
\sum_{Iteration}^{\mathrm{diameter}} (2 \cdot Entities + 2 \cdot \mathrm{neighbours}(Entity))
|
||||
$$
|
||||
|
||||
Visto che ogni [[canale di comunicazione|canale]] avrà esattamente una *andata-e-ritorno* di esplorazione, possiamo portarlo fuori dalla sommatoria, sostituendolo con $2 \cdot Channels$:
|
||||
$$
|
||||
4 \cdot Channels + \sum_{Iteration}^{\mathrm{diameter}} (2 \cdot Entities)
|
||||
$$
|
||||
|
||||
Nel caso peggiore, il [[diametro di un grafo]] è pari al numero totale di [[router]], quindi:
|
||||
$$
|
||||
4 \cdot Channels + 2 Entities^2
|
||||
$$
|
||||
|
||||
In [[notazione asintotica]]:
|
||||
$$
|
||||
\Large O(Entities^2 + Channels)
|
||||
$$
|
||||
|
|
@ -0,0 +1 @@
|
|||
In un problema di [[routing]], [[messaggio]] contenente l'[[identificatore]] del [[router]] a cui è destinato.
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
[[Corollario]] derivante dalla costruzione di uno [[spanning tree]].
|
||||
|
||||
Se un [[nodo di un grafo|nodo]] si trova tra altri due all'interno dello [[spanning tree]], allora tutti gli [[arco di un grafo|archi]] che connettono i due si trovano nello [[spanning tree]] del nodo.
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
In un contesto di [[routing]], [[associazione]] tra [[entità]] da raggiungere e [[canale di comunicazione]] da utilizzare più [[costo]] totale per raggiungerla.
|
||||
In un contesto di [[routing]], [[hash table|mappa]] da [[router]] destinatario a [[canale di comunicazione]] da utilizzare più [[costo]] totale per raggiungerla.
|
||||
|
||||
$$
|
||||
\def \varSource {{\color{LimeGreen} Source}}
|
||||
|
|
@ -13,3 +13,22 @@ $$
|
|||
$$
|
||||
|
||||
Implementazione semplice di [[funzione di routing]].
|
||||
|
||||
> [!Note]
|
||||
> ==Il [[principio di ottimalità]] è il motivo per cui è sufficiente salvare solo il [[canale di comunicazione]]!==
|
||||
|
||||
## [[Costo computazionale]]
|
||||
|
||||
### [[Search time]]
|
||||
|
||||
Un lookup nel [[hash table|dizionario]]:
|
||||
$$
|
||||
\Large O(\log(Entities))
|
||||
$$
|
||||
|
||||
### [[Routing memory]]
|
||||
|
||||
Lo spazio usato dal [[hash table|dizionario]]:
|
||||
$$
|
||||
\Large O(Entities \cdot \log(\max(Identifier)))
|
||||
$$
|
||||
|
|
|
|||
|
|
@ -1,28 +1,32 @@
|
|||
[[problema di ottimizzazione]] per un [[sistema distribuito]].
|
||||
|
||||
## Terminologia aggiuntiva
|
||||
|
||||
Le [[entità]] che partecipano al routing sono anche dette [[router]].
|
||||
|
||||
## Definizione
|
||||
|
||||
Date due qualsiasi [[entità]], si vuole determinare un [[cammino]] nella [[rete di comunicazione]] che permetta alle due di comunicare persistentemente.
|
||||
|
||||
### Terminologia
|
||||
|
||||
Le [[entità]] che partecipano alla risoluzione del problema sono dette anche [[router]].
|
||||
|
||||
Ogni entità ha una [[funzione di routing]], archiviata nella [[routing memory]], che richiede un dato [[tempo di ricerca]] per essere eseguita.e mi
|
||||
Si vuole determinare una [[funzione di routing]] per tutti i [[router]] del sistema.
|
||||
|
||||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- [[full-duplex]]
|
||||
- [[canale di comunicazione|canali di comunicazione]] con un [[costo]]
|
||||
- ==connettività?==
|
||||
- [[affidabilità totale]]
|
||||
- [[orientamento locale]]
|
||||
- [[identificatori univoci]]
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- [[dimensione dei messaggi illimitata]]
|
||||
- [[full-duplex]]
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- [[affidabilità totale]]
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- [[grafo connesso]]
|
||||
- [[identificatori univoci]]
|
||||
- [[canale di comunicazione|canali]] con un [[funzione costo|costo]]
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- [[ritardo di comunicazione illimitato]]
|
||||
- [[risveglio singolo]]
|
||||
- [[terminazione locale]]
|
||||
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
||||
- [[broadcast routing]]
|
||||
- [[routing table gossiping]]
|
||||
- [[routing table iterating]]
|
||||
- [[shortest path spanning tree]]
|
||||
- [[min-hop routing]]
|
||||
- [[gossiping routing]]
|
||||
- [[iterating routing]]
|
||||
- [[centralized routing]]
|
||||
- [[min-hops routing]]
|
||||
|
|
|
|||
|
|
@ -0,0 +1,3 @@
|
|||
[[risorsa]].
|
||||
|
||||
[[Tempo]] necessario a eseguire la [[funzione di routing]].
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
[[Risorsa]].
|
||||
|
||||
[[Tempo]] necessario a valutare la [[funzione di routing]].
|
||||
|
|
@ -1,4 +1,34 @@
|
|||
{
|
||||
"nodes":[],
|
||||
"edges":[]
|
||||
"nodes":[
|
||||
{"id":"1b02df69b1abf291","type":"group","x":2060,"y":-1100,"width":1560,"height":1560,"label":"Concetti"},
|
||||
{"id":"bb569fef44f295e1","x":2060,"y":580,"width":440,"height":1000,"type":"group","label":"Generale"},
|
||||
{"id":"68acbd213e07eb80","x":2060,"y":1700,"width":440,"height":1000,"type":"group","label":"Diametro noto"},
|
||||
{"id":"dfe1179e8607aab5","x":2060,"y":2820,"width":440,"height":1000,"type":"group","label":"Costo non-negativo"},
|
||||
{"id":"a2f4ec1d9ef4fca5","x":2060,"y":3940,"width":440,"height":1000,"type":"group","label":"Costo unitario"},
|
||||
{"id":"d89867fdda35cdde","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/routing.md","x":960,"y":-800,"width":960,"height":5720},
|
||||
{"id":"8bf228c354e56f9e","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/funzione di routing.md","x":2080,"y":-520,"width":400,"height":400},
|
||||
{"id":"977d445b9efd3c63","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/routing memory.md","x":2640,"y":-800,"width":400,"height":400},
|
||||
{"id":"c9ae37a9e586a72d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/search time.md","x":2640,"y":-240,"width":400,"height":400},
|
||||
{"id":"cb0fa8b1f3b67bdd","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/pacchetto.md","x":2080,"y":40,"width":400,"height":400},
|
||||
{"id":"a5fe4cabc58e4ded","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/router.md","x":2080,"y":-1080,"width":400,"height":400},
|
||||
{"id":"781c1e8e5acea10a","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/routing table.md","x":3200,"y":-800,"width":400,"height":960},
|
||||
{"id":"bb4745ef27a83d75","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/gossiping routing.md","x":2080,"y":600,"width":400,"height":960},
|
||||
{"id":"aad122a35d265477","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/iterating routing.md","x":2080,"y":1720,"width":400,"height":960},
|
||||
{"id":"a64242492150bbbd","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/centralized routing.md","x":2080,"y":2840,"width":400,"height":960},
|
||||
{"id":"5602d9da9f18a97d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/min-hops routing.md","x":2080,"y":3960,"width":400,"height":960},
|
||||
{"id":"ea475183f7c55a25","x":1240,"y":-1360,"width":400,"height":400,"color":"3","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/comunicazione del routing.md"}
|
||||
],
|
||||
"edges":[
|
||||
{"id":"58a76a4228ed6e62","fromNode":"d89867fdda35cdde","fromSide":"right","toNode":"8bf228c354e56f9e","toSide":"left"},
|
||||
{"id":"a9ded24e83178bcd","fromNode":"8bf228c354e56f9e","fromSide":"right","toNode":"977d445b9efd3c63","toSide":"left"},
|
||||
{"id":"cdab59da9351844e","fromNode":"8bf228c354e56f9e","fromSide":"right","toNode":"c9ae37a9e586a72d","toSide":"left"},
|
||||
{"id":"ba114b8d66b34d81","fromNode":"d89867fdda35cdde","fromSide":"right","toNode":"a5fe4cabc58e4ded","toSide":"left"},
|
||||
{"id":"820e0566dd3893d7","fromNode":"d89867fdda35cdde","fromSide":"right","toNode":"cb0fa8b1f3b67bdd","toSide":"left"},
|
||||
{"id":"951773f2dfb01c66","fromNode":"8bf228c354e56f9e","fromSide":"right","toNode":"781c1e8e5acea10a","toSide":"left"},
|
||||
{"id":"618c83092da33be8","fromNode":"d89867fdda35cdde","fromSide":"right","toNode":"bb4745ef27a83d75","toSide":"left"},
|
||||
{"id":"de8236f4437be009","fromNode":"d89867fdda35cdde","fromSide":"top","toNode":"ea475183f7c55a25","toSide":"bottom"},
|
||||
{"id":"5f2d6351f5f2f313","fromNode":"d89867fdda35cdde","fromSide":"right","toNode":"68acbd213e07eb80","toSide":"left"},
|
||||
{"id":"21d6efdf44e535fc","fromNode":"d89867fdda35cdde","fromSide":"right","toNode":"dfe1179e8607aab5","toSide":"left"},
|
||||
{"id":"a86bf78728816781","fromNode":"d89867fdda35cdde","fromSide":"right","toNode":"a2f4ec1d9ef4fca5","toSide":"left"}
|
||||
]
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
==Ovviamente TODO, questo è un glossario per le notazioni.==
|
||||
|
||||
- $n$
|
||||
- numero delle entità
|
||||
- $f$
|
||||
- massimo delle entità che possono fallire, sempre minore di $\frac{f}{9}$ per qualche motivo
|
||||
- $n - f$
|
||||
- il numero di vicini di un nodo che non possono avere un guasto
|
||||
- $n - 2f$
|
||||
- il numero di vicini in comune tra due nodi che non possono avere un guasto
|
||||
- $n - 4f$
|
||||
- il numero di vicini in comune tra due nodi che hanno sicuramente mandato lo stesso messaggio ==credo==
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
[[struttura dati distribuita]] basata su una [[hash table]].
|
||||
|
||||
L'[[hash]] della [[chiave]] viene usato per determinare quale [[entità]] ha controllo su di essa.
|
||||
|
|
@ -0,0 +1 @@
|
|||
[[struttura dati distribuita]] di dimensione variabile.
|
||||
|
|
@ -0,0 +1 @@
|
|||
[[struttura dati]] gestita da [[entità]].
|
||||
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue