Operazione che potrebbe avvenire in più momenti della rete e deve funzionare.
In che contesto possiamo metterci?
Assumiamo che non ci siano fallimenti di link o entità e abbiamo link bidirezionali. Assumiamo che il grafo sia connesso affinché sia possibile andare a risolvere il problema. Cerchiamo di mettere meno restrizioni perché così ho una soluzione più generale possibile. Non faccio assunzioni sulla topologia del grafo, niente casi particolari e non faccio assunzioni sul numero di entità.
Idea semplice: ognuno manda tutto ai propri vicini, molto semplice senza beghe particolari. Abbiamo una serie di stati che possono essere Initiator, Sleeping. Come informazioni abbiamo I e il set di azioni di B(E) è:
Initiator
spontaneously
send(I) to N(x)
receving(I)
NIL
Spontaneously è un evento spontaneo. Che cosa deve fare? manda l’informazione a tutti quanti i vicini. Che cosa succede? Gira questo messaggio e se gli torna indietro non deve fare niente.
Sleeping
send(I) to N(x)
In questo modo si mandano più volte gli stessi più volte e si creano dei loop. Serve un modo per non mandare i messaggi tante volte e inutilmente. Abbiamo un problema di terminazione.
Che cosa posso fare per andare a cambiare le cose? Devo aggiungere un altro stato: Done, in cui non faccio nulla essenzialmente, così blocco i loop tra i nodi di tipologia diversa da ≠ initiator.
Devo essere in grado di descrivere il comportamento della singola entità senza dover andare ad assumere che cosa facciano gli altri. Poi alla fine devo andare a considerare il comportamento complessivo della mia rete essenzialmente.
In questo modo come codice cambia la fine della funzione sleeping in cui si aggiunge una riga e diventa
Become(DONE)
Possiamo fare di meglio, per cui non mando il messaggio inutilmente indietro a chi me lo ha mandato:
Sleeping
send(I) to N(x) - sender
Become(done)
Mettendo tutto quando insieme creiamo un protocollo che definiamo Flooding.
La questione delle propagazione dei messaggi, in termini di tempo, non è per nulla scontata, ci potrebbe essere problemi hardware e software e alla fine abbiamo una situazione con ritardi impredicibili.
Osservazione su quella che è la terminazione: prima o poi tutti quanto finiscono per forza.
Quando un nodo si mette in done, si dice che arriva ad una terminazione locale.
I nostri nodi hanno la coscienza di quando, su tutto il sistema di quando il protocollo è terminato? No, non hanno alcuna idea di quanto manchi al sistema per arrivare a tutti i nodi. Loro sanno soltanto che lo hanno ricevuto e mandato ai vicini. Manca una terminazione globale. I singoli nodi non sanno quando il protocollo su tutto il sistema è terminato, sanno solamente quando hanno finito di lavorare.