UNIVERSITÀ DEGLI STUDI DI FERRARA
FACOLTÀ DI INGEGNERIA
Corso di Laurea Specialistica in Ingegneria Informatica e
dell’Automazione
ALGORITMI PER IL PEER TO PEER REALTIME
Tesi di Laurea di:
Relatore:
Danilo Merlanti
Prof. Ing. Gianluca Mazzini
ANNO ACCADEMICO 2007
200 – 2008
1
Indice
1
ITRODUZIOE ____________________________________________________________________ 5
1.1
MODELLI DI COMUNICAZIONE [1] ___________________________________________________ 5
1.1.1
IL MODELLO CLIET/SERVER __________________________________________________ 5
1.1.2
ASPETTI PRICIPALI DEL MODELLO CLIET – SERVER ____________________________ 6
1.1.3
ALTRE CARATTERISTICHE DEL MODELLO CLIET – SERVER: “MODALITA’ DI
FUZIOAMETO PUSH E PULL” __________________________________________________________ 6
1.1.4
MODELLO CLIET SERVER: “ITERAZIOE TRA I DUE PROCESSI” _________________ 7
1.1.5
ALTRI MODELLI DI ITERAZIOE OLTRE AL CLIET/SERVER ______________________ 7
1.1.6
IL MODELLI PEER TO PEER ____________________________________________________ 7
1.1.7
ALTRI MODELLI O CLIET/SERVER __________________________________________ 12
1.2
DAL MODELLO CLIENT – SERVER AL MODELLO PEER TO PEER [6] _____________________ 13
1.2.1
PROBLEMATICHE DEL MODELLO CLIET – SERVER _____________________________ 13
1.2.2
UTILIZZO DEI PEER PER LA DIFFUSIOE DI FILE DI GRADI DIMESIOI _________ 14
1.2.3
COFROTO TRA I DUE MODELLI _____________________________________________ 14
1.2.4
ITRODUZIOE ALLE TIPOLOGIE DI RETI PEER TO PEER ________________________ 15
1.2.5
APSTER ___________________________________________________________________ 15
1.2.6
GUTELLA __________________________________________________________________ 17
1.2.7
KaZaA ______________________________________________________________________ 21
1.2.8
BitTorrent ___________________________________________________________________ 24
1.3
UTILIZZO DEL PEER TO PEER NELLA DIFFUSIONE DI CONTENUTI MULTIMEDIALI _____ 28
1.3.1
UICAST, BROADCAST E MULTICAST [7]_________________________________________ 28
1.3.2
MULTICAST E PROTOCOLLO IGMP [7] __________________________________________ 29
1.3.3
FUZIOAMETO DEL MULTICAST A LIVELLO LOCALE [7] ________________________ 30
1.3.4
FUZIOAMETO DEL MULTICAST A LIVELLO GEOGRAFICO [7] ___________________ 32
1.3.5
PROBLEMATICHE DEL MULTICAST [7][8]_________________________________________ 32
1.4
PEER TO PEER SU CANALE ASIMMETRICO __________________________________________ 34
PEER TO PEER DISTRIBUTIO O ASYMMETRIC CHAELS [9] ______________________ 35
2
2.1
TOPOLOGIA DELLE RETI__________________________________________________________ 35
2.2
DESCRIZIONE DELL’ALGORITMO [9] _______________________________________________ 36
3
UOVI ALGORITMI ________________________________________________________________ 39
3.1
TOPOLOGIA DELLE RETI GENERATE: SEQUENZA DI NODI CHE ACCEDONO ALLA RETE_ 39
3.2
PRIMO ALGORITMO DI PEER TO PEER: ALGORITMO MAZZINI / ROVATTI ADATTATO ALLE
NUOVE CONDIZIONE DI RETE ______________________________________________________________ 45
3.3
SECONDO ALGORITMO DI PEER TO PEER CON RISTRUTTURAZIONE LOCALE DELLA RETE
CON BLOCCO ALL’INGRESSO _______________________________________________________________ 47
2
3.4
TERZO ALGORITMO SENZA RISTRUTTURAZIONE LOCALE ___________________________ 55
3.4.1
DESCRIZIOE DETTAGLIATA DELL’ALGORITMO 3 _______________________________ 56
3.4.2
SVATAGGI DELL’ALGORITMO3 E ITRODUZIOE ALL’ALGORITMO4 _____________ 60
3.4.3
OTA IMPORTATE __________________________________________________________ 61
3.5
QUARTO ALGORITMO CON RISTRUTTURAZIONE LOCALE CON BLOCCO ALL’INGRESSO 62
3.6
QUINTO ALGORITMO SENZA BLOCCO ALL’INGRESSO _______________________________ 63
3.7
SESTO ALGORITMO CON RISTRUTTURAZIONE SENZA BLOCCO ALL’INGRESSO________ 63
4
ESEMPI E COFROTI _____________________________________________________________ 65
4.1
ALGORITMI 1,2,3 E 4 ______________________________________________________________ 65
4.1.1
UTILIZZO DEL SOFTWARE IMPLEMETATO _____________________________________ 66
4.1.2
UMERO DI ODI ISERIBILI ELLA RETE I FUZIOE DELLA OUTPUT BAD
FORITA DAL ODO SORGETE ___________________________________________________________ 67
4.1.3
BADA TOTALE RESIDUA DELLA RETE I FUZIOE DELLA OUTPUT BAD FORITA
DAL ODO SORGETE ___________________________________________________________________ 78
4.1.4
STIMA DEL COSTO DELLE RISTRUTTURAZIOI I FUZIOE DELLA OUTPUT BAD
FORITA DAL ODO SORGETE ___________________________________________________________ 86
4.2
ALGORITMI 5 E 6 _________________________________________________________________ 93
4.2.1
UTILIZZO DEL SOFTWARE IMPLEMETATO _____________________________________ 95
4.2.2
UMERO DI ODI ISERIBILI I FUZIOE DELLA PERCETUALE DI ODI CHE
HAO OUTPUT BAD < 1 ELLA SEQUEZA DI IGRESSO __________________________________ 96
4.2.3
STIMA DEL COSTO DELLE RISTRUTTURAZIOI LOCALI I FUZIOE DELLA
PERCETUALE DI ODI CHE HAO OUTPUT BAD < 1 ELLA SEQUEZA DI IGRESSO _______ 102
4.2.4
BADA DISPOIBILE O RESIDUA I FUZIOE DELLA PERCETUALE DI ODI CHE
HAO OUTPUT BAD < 1 ELLA SEQUEZA DI IGRESSO _________________________________ 107
4.2.5
UMERO ODI I ATTESA I FUZIOE DELLA PERCETUALE DI ODI CHE HAO
OUTPUT BAD < 1 ELLA SEQUEZA DI IGRESSO _________________________________________ 112
5
COCLUSIOI____________________________________________________________________ 119
6
BIBLIOGRAFIA ___________________________________________________________________ 125
7
RIGRAZIAMETI _______________________________________________________________ 127
3
4
1 INTRODUZIONE
L’obiettivo di questa tesi è la creazione e la realizzazione di nuovi algoritmi per la costruzione
di reti peer to peer adottate per la diffusione di contenuti su linee asimmetriche; questi algoritmi
sono stati ideati basandosi su un algoritmo di peer to peer, per la diffusione di contenuti su canale
asimmetrico, sviluppato dal prof. Ing. Gianluca Mazzini e Riccardo Rovatti [9].
Nei capitoli successivi vengono trattati i seguenti argomenti:
nel primo capitolo viene fornita una descrizione dei vari modelli di comunicazione ed
in particolare del modello peer to peer. Inoltre in questo capitolo: vengono descritte le
problematiche del modello client/server, nella diffusione di file e contenuti, che portano
a considerare il modello peer to peer; viene fornita una descrizione delle varie tipologia
di reti peer to peer, quali ad esempio Napster, Gnutella, KaZaA e BitTorrent; viene
effettuata una descrizione delle problematiche che portano a scegliere le reti peer to
peer, per effettuare la diffusione di contenuti multimediali; vengono descritte le
problematiche del peer to peer su canali asimmetrici e viene introdotto il conseguente
algoritmo per la creazione di reti peer to peer che si adatta a tale problematica;
nel secondo capitolo viene effettuata la descrizione dell’algoritmo di Mazzini/Rovatti
[9]
, utilizzato per la creazione e gestione delle reti peer to peer adottate per la diffusione
di contenuti su linee asimmetriche, con particolari condizioni per quanto riguarda i peer
che vogliono accedere alla rete;
nel terzo capitolo si fornisce una descrizione degli algoritmi realizzati in questa tesi, che
sono stati ottenuti basandosi sull’algoritmo descritto nel secondo capitolo ;
infine nel quarto e nel quinto capitolo si presentano alcuni esempi su parametri
significativi (quali il numero massimo di nodi inseribili nella rete, la banda totale
residua della rete quando non è più in grado di accettare nodi, ecc…), al fine di poter
confrontare i vari algoritmi realizzati e poter fornire le conclusioni dello studio che si è
condotto in questa tesi.
1.1 MODELLI DI COMUNICAZIONE [1]
1.1.1 IL MODELLO CLIENT/SERVER
Il modello client/server prevede la presenza di due entità:
1.
l’entità client: consente di accedere ad una macchina server (remota) che eroga un
certo servizio. Per fare questo il client effettua una richiesta di un servizio
all’applicazione server residente sulla macchina server;
5
2.
l’entità server: è un applicazione che permane nell’attesa che arrivino delle richieste di
servizio provenienti da applicazioni client. Nel momento in cui il server riceve una
richiesta di servizio la soddisfa erogando il servizio richiesto al client richiedente.
Un esempio di comunicazione client – server è rappresentata dalla richiesta di una pagina web
che può effettuare un client web al desiderato server web.
1.1.2 ASPETTI PRINCIPALI DEL MODELLO CLIENT – SERVER
Il modello client – server prevede una comunicazione:
1.
asimmetrica, poiché
il client designa esplicitamente il server destinatario attraverso l’indirizzo IP del
server e la sua porta, ossia il client, per richiedere un servizio al server, deve
conoscere l’indirizzo del server;
invece il server non deve nominare o identificare il client ossia tale macchina
server, per definizione, rimane in attesa di ricevere le richieste di servizio e
quando le riceve risponde erogando un particolare servizio; quindi il server non
deve avere l’indirizzo del client poiché è in attesa che un client effettui una
richiesta di servizio;
2.
molti a 1 poiché: molti client possono richiedere lo stesso servizio ad un solo servitore
(o server).
1.1.3 ALTRE CARATTERISTICHE DEL
MODELLO CLIENT – SERVER:
“MODALITA’ DI FUNZIONAMENTO PUSH E PULL”
Il modello client – server può funzionare in modalità push o in modalità pull cioè:
1.
modello pull (tirare): in tal caso il client recupera il servizio dal sistema server ossia il
client invia una richiesta di servizio al sistema server con la quale preleva direttamente
dal server il servizio richiesto;
2.
modello push (spingere): in tal caso il server si preoccupa di spedire al client il
pacchetto di risposta al servizio richiesto decidendo autonomamente quando mandare
al client le informazioni da lui richieste al server stesso. Quindi in tal caso il server,
quando ritiene opportuno, trasmette le informazioni richieste verso il client
(richiedente) collegato o connesso al server stesso. In tal modo quando il client
interrompe la connessione con il server accade che il server non è più in grado di
spedire i dati precedentemente richiesti dal client stesso.
6
1.1.4 MODELLO CLIENT SERVER: “INTERAZIONE TRA I DUE PROCESSI”
Il modello client – server stabilisce quando si ha l’interazione tra il processo client ed il
processo server. La comunicazione tra processo client e processo server, in generale, è soggetta al
problema del rendez-vous, ossia il problema di stabilire quando sincronizzare i processi
comunicanti (ossia quando avviene l’incontro tra il processo client e quello server ).
Il modello client – server risolve il problema del rendez-vous definendo il server come un
processo che rimane sempre in attesa di richieste di servizio da parte di processi client.
Quindi nel caso del modello client – server la sincronizzazione tra il processo client e quello
server avviene secondo le seguenti modalità: quando il client effettua una richiesta di servizio al
server (attraverso un pacchetto di richiesta servizio) accade che il server, che era in attesa della
richiesta di un servizio, esegue la richiesta ed invia i risultati, di tale esecuzione, al client
richiedente.
La risoluzione del problema del rendez-vous (dell’incontro tra client e server) si ottiene
con un processo mandato in esecuzione al boot della macchina server, il quale rimane in attesa che
arrivi la richiesta di servizio da un client.
1.1.5 ALTRI MODELLI DI INTERAZIONE OLTRE AL CLIENT/SERVER
Il modello client – server non è l’unico modello di comunicazione disponibile. Altri modelli
esistenti sono i seguenti:
1. peer to peer: dove si ha una interazione tra processi pari (peer) ed in tal modo ogni
entità può essere sia client che server;
2. modelli ad eventi e Publish/Subscribe: dove il server prende l’iniziativa e segnala
il verificarsi di un evento. Sono modelli Push.
1.1.6 IL MODELLI PEER TO PEER
Nel modello client/server, il server può rappresentare un colo di bottiglia. Il modello peer to
peer supera il punto di centralizzazione del server poiché prevede che le comunicazioni avvengano
da pari a pari e quindi tutti i nodi o processi sono allo stesso livello dal punto di vista delle
responsabilità e dei protocolli; di conseguenza ogni processo può giocare contemporaneamente sia
il ruolo di client che quello di server.
7
In questo modo scompare il ruolo di centralizzazione del server e quindi tutti i pari si possono
scambiare i file tra loro. Gli obiettivi applicativi di tale sistema sono: alta disponibilità ed alto
grado di replicazione.
1.1.6.1 FUZIOAMETO
Tipicamente , un sistema peer to peer, per reperire un file, richiede due passi:
1. localizzazione: viene effettuata la localizzazione del file di interesse ossia si cerca tale
file in tutti i possibili utenti pari disponibili in quel momento (tale argomento è di grande
complessità e sono possibili diverse soluzioni architetturali);
2. trasferimento del file: trovato l’utente pari che possiede il file desiderato (attraverso
l’operazione di localizzazione), e quindi conoscendo il suo indirizzo IP, il trasferimento
del file avviene direttamente tra i due pari ossia con una comunicazione diretta tra loro.
1.1.6.2 IL MODELLO PEER TO PEER: LOCALIZZAZIOE COTEUTI
I metodi di localizzazione della macchina dalla quale prelevare il file (o il contenuto)
desiderato seguono modelli architetturali diversi che hanno un diverso grado di distribuzione cioè:
1. nel caso di apster si ha una directory centralizzata, contenuta su un server diretto
centralizzato, che contiene per ogni utente conosciuto gli identificativi dei file che esso
possiede;
2. nel caso di KaZaA si ha una directory decentralizzata;
3. nel caso di Gnutella si ha un processo detto di Query Flooding.
Questi sistemi offrono diversi vantaggi/svantaggi da vari punti di vista:
tolleranza ai guasti;
prestazioni;
“Responsabilità Legali”.
1.1.6.3 MODELLO PEER TO PEER CO DIRECTORY CETRALIZZATA
(apster)
Il modello peer to peer con directory centralizzata (come Napster) ha un sistema di
localizzazione del file desiderato con una directory centralizzata che contiene le informazioni sui
file disponibili con il relativo nodo di residenza. A tale directory centralizzata tutti gli utenti si
collegano per localizzare, e richiedere, il file desiderato.
8
Quindi la richiesta del file viene effettuata al server che contiene la directory centralizzata dei
file e se il server trova nel suo data base un utente che ha tale file allora viene fornito al richiedente
l’indirizzo IP dell’utente che ha il file di modo che il richiedente stesso, possa prelevare
direttamente il file desiderato dall’utente che lo possiede.
1.1.6.4 MODELLO
PEER
TO
PEER
CO
DIRECTORY
DECETRALIZZATA(KaZaA)
Nel caso di modello peer to peer con directory decentralizzata le funzioni di Directory vengono
distribuite direttamente ad alcuni nodi peer chiamati leader di gruppo ai quali si possono collegare
gli utenti.
Quindi i peer leader di un gruppo contengono la directory con le informazioni sui file
disponibili sui vari nodi del gruppo stesso.
Quindi quando un utente richiede un file, lo chiede al nodo leader del suo gruppo il quale:
1. se conosce un nodo del suo gruppo che possiede tale file allora fornisce all’utente
richiedente l’indirizzo del nodo che possiede tale file. In tal modo l’utente richiedente
può effettuare il prelievo del file dal nodo specificato del suo stesso gruppo;
2. se invece il leader del gruppo non trova un nodo del suo gruppo che contiene il file
desiderato allora il leader richiederà tale file ad un altro leader di gruppo. Quando il
leader del gruppo considerato otterrà da un altro qualsiasi leader di gruppo l’indirizzo
del nodo che contiene il file desiderato allora il leader invierà tale indirizzo al nodo
richiedente il quale preleverà direttamente il file considerato dal nodo appartenente ad un
altro gruppo specificato.
Quando un utente si accede a tale sistema distribuito si collega ad un qualunque leader di
gruppo che possiede l’elenco (o directory) dei file contenuti nei nodi di tale gruppo.
Quindi in questo modello di peer to peer esistono dei nodi di bootstrap allo scopo di:
1. indicare i peer leader ai nodi che si vogliono connettere alla rete;
2. e selezionare i peer leader cioè ad esempio: se in un gruppo il peer leader “muore”
allora il nodo di bootsdrap designerà come nuovo peer leader uno di quelli del gruppo
considerato.
9
1.1.6.5 MODELLO PEER TO PEER CO QUERY FLOODIG (Gnutella)
È il modello di peer to peer adottato da Gnutella. In questo caso non si ha un sistema di
decentralizzazione ossia non si ha una directory decentralizzata che consenta di reperire l’indirizzo
degli utenti o nodi che posseggono tale file, in quanto in tale modello si ha che:
quando un nodo o utente effettua la richiesta di ricerca di un file tale richiesta viene
mandata (inoltrata) a tutti i suoi nodi vicini, i quali a loro volta inviano tale messaggio di
richiesta file ai loro nodi successivi (della catena) o nodi vicini;
in tal modo la localizzazione del file richiede un broadcast del messaggio di richiesta del
file o un flooding di messaggi e quindi la richiesta di un file si propagherà in tutti i nodi
del sistema;
quando, con tale tecnica, si trova un nodo che possiede il file desiderato accade che viene
mandato un messaggio di ritorno al nodo richiedente con il quale si specifica l’indirizzo
del nodo che possiede il file, di modo che il nodo richiedente possa prelevare tale file
direttamente dal nodo che lo possiede con un collegamento diretto tra loro;
affinché il messaggio di “ricerca file” non percorra tutti i nodi della rete, determinando un
tempo di ricerca troppo elevato e determinando l’intasamento della rete, viene fissato
arbitrariamente un numero massimo di salti o HOP superato il quale il messaggio di
“richiesta file” viene soppresso;
in questo modello si ha sempre un nodo di bootsdrap che comunica, al nodo che si vuole
collegare alla rete, solamente il nome dei nodi pari più vicini a cui collegarsi;
se il nodo al quale è collegato il nodo considerato si spegne allora vi sono particolari
protocolli che consentono di collegare il nodo considerato ad un altro nodo vicino attivo
(cioè non spento).
1.1.6.6 TOLLERAZA AI GUASTI EI TRE MODELLI
1. modello peer to peer con directory centralizzata: tale sistema è poco tollerante ai
guasti, avendo un unico server che contiene le informazioni sui file disponibili con il
relativo nodo, in quanto se il server (contenente la directory centralizzata) va in crash
allora non funzione più nulla, poiché gli utenti non possono più localizzare il nodo
contenete il file desiderato;
2. modello peer to peer con directory decentralizzata: la tolleranza ai guasti è buona in
quanto se il nodo leader di un gruppo “muore” accade che il nodo di bootsdrap
10
riorganizza la rete definendo un nodo di tale gruppo come nodo leader e collegando tutti
gli altri nodi al nuovo leader designato;
3. modello peer to peer con query flooding: tolleranza ai guasti è buona in quanto se il
nodo al quale è collegato il nodo considerato si spegne allora vi sono particolari
protocolli che consentono di collegare il nodo considerato ad un altro nodo vicino attivo
(cioè non spento).
1.1.6.7 PRESTAZIOI EI TRE MODELLI
Nel peer to peer le prestazioni sono diverse e dipendono solamente dalla fase di ricerca dati o
localizzazione del file desiderato, in quanto in tutti i modelli peer to peer la fase di trasferimento
dati avviene direttamente tra il pari richiedente ed il pari che possiede il file. Quindi nel caso del
modello peer to peer con directory centralizzata la fase di localizzazione sarà in genere più veloce
rispetto agli altri due modelli.
1.1.6.8 SISTEMI PEER TO PEER
I maggiori sistemi peer to peer attuali sono: Napster, Gnutella, KaZaA, Winmx e consentono la
condivisione di file con un’architettura caratterizzata da gradi di distribuzione crescente.
Il peer to peer è la causa di maggiore traffico nella rete internet. Esistono molti altri sistemi
peer to peer quali:
JXTA: ambiente SUN per lo sviluppo di applicazioni peer to peer in java;
Freenet: filesystem con elevato grado di replicazione e a diffusione derivante dalle
richieste. Strategie di propagazione ispirate al routing globale. Sistema di nomi basato su
indici (integrità via hash);
Freeheaven: informazioni più suddivise per robustezza e con un alto grado di sicurezza;
Publius: condivisione di informazioni con diversi gradi di sicurezza e privatezza;
SETI@home: peer to peer che elabora ed analizza segnali trasmessi e provenienti dallo
spazio, controllando i pattern di tali segnali per verificare se provengono da una
intelligenza extraterrestre. Tale ricerca ed analisi viene effettuata su nodi distribuiti cioè:
quando un utente si collega a tale rete peer to peer riceve una porzione di dati dalla
stazione centrale e li elabora. I dati elaborati (durante i cicli di idle della cpu) dall’utente
connesso vengono, infine, inviati alla stazione centrale e quindi si ha la ripartizione del
lavoro tra i calcolatori appartenenti a tale rete peer to peer;
Jabber supporto alla conversazione e cooperazione tra utenti.
11
1.1.7 ALTRI MODELLI NON CLIENT/SERVER
Oltre ai modelli client/server ed ai modelli peer to peer vi sono altri modelli quali: il modello
ad eventi ed il modello publish/subscribe.
1.1.7.1 IL MODELLO A EVETI
Tale modello si contrappone al modello di richiesta e di attesa della risposta che si ha nel
modello client – server.
Si gestisce la possibilità di inviare messaggi su necessità disaccoppiando gli interessati cioè:
il client segnala al server il proprio interesse verso un determinato servizio, e poi passa a
fare altro;
il server invia l’informazione o un evento se e quando è disponibile;
un servizio di notifica eventi segnala l’occorrenza degli eventi significativi agli
interessati.
Fissando un’altra terminologia si può dire che:
Client = è “il consumatore”;
Server = è “il produttore di un determinato servizio”.
Funzionamento: un consumatore decide di essere interessato ad un determinato evento e quindi
specifica al produttore tale interesse registrandosi con la specifica dell’evento che gli interessa.
Quando il produttore produce (o riceve) l’evento tale evento viene spedito al Servizio di Notifica
Eventi, il quale segnala l’occorrenza degli eventi significativi agli interessati, ossia forza il push
dell’evento alle entità (o consumatori) che si sono registrate per tale evento; quindi il servizio di
notifica eventi inoltra l’evento (servizio) prodotto dal produttore (o server) a tutti i consumatori (o
client) che si erano registrati per tale evento.
1.1.7.2 IL MODELLO PUBLISH/SUBSCRIBE
Quando un utente si interessa ad un particolare evento lo indica ad un server, che tiene traccia
degli utenti che si sono registrati per un particolare evento. Quando il gestore o server ha l’evento lo
inoltra, con una notifica, a tutti gli utenti che sono interessati all’evento considerato.
Riassumendo: da una parte si ha una serie di utenti (chiamati consumatori) che specificano il
proprio interesse verso alcuni eventi (chiamati subscribe); dall’altra parte si ha un gestore (chiamato
produttore) che registra le loro richieste di evento e notifica gli eventi ai consumatori interessati a
tali eventi (esempio mailing list).
12
1.2 DAL MODELLO CLIENT – SERVER AL MODELLO PEER TO PEER [6]
1.2.1 PROBLEMATICHE DEL MODELLO CLIENT – SERVER
Supponiamo che un server debba inviare un file di grandi dimensioni a N client differenti. Si
effettuano le seguenti ipotesi:
il file ha una dimensione pari a F bit;
si ha un unico server con velocità di upload pari a us;
per i = 1…N, la velocità di download dell’i-esimo ricevitore è pari a di.
Quindi il server trasmette il file agli N ricevitori e quindi deve trasmette un numero
complessivo di bit pari a N·F e ciò richiede un tempo di trasmissione di almeno N·F/us.
Dal lato dei ricevitori, bisogna però considerare che:
il ricevitore più lento riceve il file ad una velocità pari a: dmin = mini{di};
e quindi il tempo necessario per riceve l’intero file è almeno pari a F/ dmin;
Quindi il tempo che serve agli N ricevitori per riceve l’intero file di dimensione F è pari al
massimo tra il tempo che necessita il server per trasmettere il file di dimensione F agli N ricevitori
(N·F/us) ed il tempo che impiega il ricevitore più lento ad ottenere il file di dimensione F (F/ dmin).
Quindi in questa situazione per accelerare la velocità di distribuzione del file è sufficiente
aumentare la banda in upload del server:
aumentando l’ampiezza di banda del link (collegato) di un server;
uso di server multipli che erogano lo stesso file, ed ognuno di questi ha un proprio link
attraverso il quale distribuisce il file considerato;
tutto ciò richiede l’impiego di una maggiore infrastruttura di rete.
Una soluzione alternativa, nella quale non viene aumentata la banda di upload del nodo
sorgente, è quella di utilizzare i ricevitori per distribuire il file ad altri ricevitori, utilizzando la loro
upload band:
i ricevitori ottengono una copia dei dati relativi al file considerato;
e successivamente ridistribuiscono i dati agli altri ricevitori che richiedono lo stesso file,
sfruttando la banda in upload che hanno a disposizione;
in questo modo si riduce il carico sul server ossia si riducono le richieste che il server
riceve e che deve soddisfare.
13
1.2.2 UTILIZZO DEI PEER PER LA DIFFUSIONE DI FILE DI GRANDI
DIMENSIONI
Si inizia con una singola copia di un file di grandi dimensioni:
si suppone di avere un file di grandi dimensioni costituito da F bits e si suppone che il
server abbia una banda in upload pari a us;
si suppone che ogni peer i-esimo abbia una banda in download pari a di ed una banda in
upload pari a ui;
Si hanno due componenti relativamente al tempo necessario per distribuire il file (a livello del
server):
il server deve inviare ogni bit del file di dimensione F e l’intera trasmissione del file
viene effettuata in un tempo minimo pari a: F/us;
il peer più lento che riceve ogni bit del file impiega, per riceve l’intero file, un tempo
minimo pari a: F/ dmin;
Con le precedenti considerazioni si determina il tempo di upload totale che si ha utilizzando
tutte le risorse di upload che sono date dalla banda di upload del server + le bande di upload di tutti
i peer della rete:
il numero totale di bit che devono essere recapitati agli N ricevitori è pari a: N·F;
la banda di upload totale è pari alla upload band del nodo sorgente + le bande di upload
di tutti i peer della rete cioè: [totalUpBand ] = u s + ∑i u i
quindi il tempo complessivo necessario per trasferire il file agli N peer della rete è:
F F
⋅ F
max ,
,
u s d min u s + ∑i ui
1.2.3 CONFRONTO TRA I DUE MODELLI
Nel caso del modello client server il tempo necessario per effettuare il download del file su N
⋅F F
,
client è pari a : max
.
us d min
Invece nel caso del modello peer to peer il tempo necessario per effettuare il trasferimento del
F F
⋅ F
file su N pari è: max ,
,
.
u s d min u s + ∑i ui
Il modello peer to peer è scalabile cioè:
consente di avere molto meno richieste sulla banda offerta dal server;
14
il tempo necessario per distribuire il file cresce solo lentamente con N;
Ma il modello peer to peer presenta alcun difficoltà:
i peer possono facilmente entrare nella rete ed uscirne poiché:
o i peer sono collegati alla rete peer to peer in maniera intermittente;
o possono entrare ed uscire dalla rete in un qualunque istante di tempo;
o o possono ritornare nella rete con un differente indirizzo IP (se l’assegnamento
dell’indirizzo IP al peer avviene in maniera dinamica);
i peer necessitano di trovarsi l’un l’altro per permettere lo scambio di file; quindi il
problema fondamentale è quello di localizzare i peer pertinenti ossia è necessario:
o determinare i peer che sono attualmente on line al fine di chiedergli se
posseggono il file desiderato;
o e determinare i peer che hanno il file o contenuto desiderato;
i peer necessitano di essere aiutati l’un l’altro. Bisogna cercare un modo per motivare i
peer a rimanere nel sistema ossia:
o occorre trovare una motivazione che induca il peer a non lasciare il sistema non
appena che terminano i suoi download;
o occorre trovare una motivazione che induca il peer a non preoccuparsi
nell’uploading dei contenuti che esso possiede a qualunque altro peer.
1.2.4 INTRODUZIONE ALLE TIPOLOGIE DI RETI PEER TO PEER
Le reti peer to peer si suddividono nelle seguenti tipologie:
Centralized Directory Model (CDM), ad esempio: Napster e BitTorrent;
Flooded Requests Model (FRM), ad esempio: Gnutella;
Selective Queries Model (SQM) o anche detto Overlay Gerarchico, ad esempio:
KaAZaA.
Nei seguenti capitoli viene presentata una descrizione più dettagliata delle reti peer to peer
appena indicate.
1.2.5 NAPSTER
STORIA [2]
Napster era un servizio di condivisione di file musicali creato da Shawn Fanning mentre stava
frequentando la Northeastern University sita a Boston. Il sistema fu operativo dal giugno 1999 a
luglio 2001. Nel gennaio 1999 fu rilasciata la versione 1.0 di Napster. Nel maggio dello stesso anno
15
fu fondata l’omonima compagnia e nel settembre dello stesso anno ebbe inizio la prima causa legale
contro Napster. Nel 2000 Napster contava 80 milioni di utenti. La sua tecnologia consentiva alle
persone di condividere facilmente tra loro i file musicali in formato MP3 con dei server centrali che
contenevano informazioni riguardanti i file condivisivi e gli utenti che condividevano tali file; per
tali motivazioni l’industria della musica accusò Napster per violazione del copyright. Sebbene il
servizio originario era stato chiuso dal tribunale nel luglio del 2001, tale evento aprì la strada, nello
stesso anno, ai programmi di peer to peer decentralizzati utilizzati per la condivisione di file, il cui
controllo risultò essere più difficoltoso. La marca ed il logo di Napster furono venduti nel 2003,
dopo che la compagnia chiuse i battenti, e Napster fu ricostituito come un servizio a pagamento.
1.2.5.1 APSTER TECHOLOGY: SERVIZIO DI DIRECTORY [6]
La tecnologia sulla quale si basa Napster è un Servizio di Directory ossia: l’utente installa il
software, scaricando il programma client e registrandosi al sistema indicando la username, la
password e la directory locale nella quale vengono mantenuti i file condivisi ed i file scaricati da
altri utenti di Napster. Il client contatta Napster (ossia uno dei server centralizzati di Napster),
attraverso il protocollo di trasporto TCP, e gli fornisce la lista di file musicali che condivide. In
questo modo il server centrale di Napster aggiorna (con la lista dei file ricevuti) la directory.
Attraverso il servizio di directory il client ricerca il file desiderato specificando il titolo della
canzone o l’artista al server centrale: il server centrale di Napster individua i client on line che
posseggono tale file e fornisce i loro indirizzi IP al client richiedente; in questo modo avendo gli
indirizzi IP degli host che posseggono il file desiderato, il client scarica direttamente il file da tali
host usando, quindi, una comunicazione peer to peer. Quindi il client richiede il file desiderato al
fornitore scelto: in questo modo il fornitore trasmette il file desiderato al client e sia il client che il
fornitore riportano lo stato della transazione a Napster.
1.2.5.2 APSTER TECHOLOGY: SERVIZIO DI PROPRIETA’ [6]
La directory del server è continuamente aggiornata con le informazione relative ai file
condivisi provenienti dai client. In questo modo si consoce sempre quale contenuto musicale è
correntemente disponibile. Il fatto di avere un server centralizzato che contiene le informazioni
relative ai file condivisi e ai peer che condividono tali file rappresenta una vulnerabilità per quanto
riguarda le azioni legali da parte di case discografiche.
Il trasferimento del file desiderato dal client che possiede il file al client richiedente viene
effettuato con un trasferimento peer to peer ed in questo modo non vi è alcun carico sul server
16
centrale e vi è la negabilità plausibile per quanto riguarda le azioni legali, ma questo non è
abbastanza poiché le trasmissione di file tra due client possono essere tracciate osservando le
comunicazioni che riceve il server centrale dai client.
Napster utilizza un protocollo proprietario per quanto riguarda le operazioni di: login, ricerca
file, upload di file, download di file e le operazioni di stato. Con tale protocollo vi è un basso livello
di sicurezza poiché le password vengono trasmesse in chiaro e non in maniera crittografata e poiché
vi sono altre vulnerabilità nel sistema.
Nel sistema utilizzato da Napster vi sono problemi riguardanti l’ampiezza di banda poiché i
client che forniscono file condivisi vengono classificati in base alla loro ampiezza di banda ed in
base al loro tempo di risposta apparente o stimato.
1.2.5.3 LIMITAZIOI DEL SISTEMA A DIRECTORY CETRALIZZATA
DI APSTER [6]
Le limitazioni del sistema utilizzato da Napster sono rappresentate dal fatto che:
si ha un singolo punto di guasto rappresentato dal server centrale e quindi il sistema ha
una bassa tolleranza ai guasti;
si ha un colo di bottiglia nelle prestazioni rappresentato dal server centrale poiché il
trasferimento del file desiderato tra due peer è completamente decentralizzato, ma la
localizzazione del contenuto è fortemente centralizzata poiché è il servizio di directory
centralizzato che localizza il contenuto;
vi è un servizio di directory centralizzato che localizza il contenuto desiderato e quindi le
violazioni di copyright sono facilmente individuabili analizzando i file conosciuti dal
servizio di directory stesso.
Quindi per tali limitazioni i sistemi di peer to peer più recenti sono maggiormente distribuiti
fino ad arrivare ad alcuni sistemi di peer to peer, come ad esempio Gnutella, che sono
completamente distribuiti.
1.2.6 GNUTELLA
STORIA [3]
Gnutella è una rete utilizzata per la condivisione di file. Gnutella è la più popolare rete per il
file sharing su internet con un mercato di condivisione di più del 40%. Nel giugno del 2005 la
popolazione di Gnutella era di 1.81 milioni di computer.
17
Il primo client fu sviluppato da Justin Frankel e Tom Pepper (della compagnia Nullsoft) nel
2000, e la compagnia in questione fu successivamente acquisita da AOL. Il 14 marzo del 2000 il
software fu reso disponibile per il download sui servers della Nullsoft. Il giorno dell’evento fu
prematuramente annunciato e in quel giorno si ebbe un numero molto elevato di download del
client di file sharing. Per tale motivo il giorno successivo, AOL fermò la disponibilità del
programma per possibili cause legali analoghe a quella del caso Napster, ed inoltre limitò NullSoft
dal fornire qualunque ulteriore sviluppo o lavoro relativo al progetto. Questo comportamento della
compagnia AOL non fermò lo sviluppo di Gnutella; infatti dopo pochi giorni, venne effettuato il
reverse enginiring del protocollo e conseguentemente, iniziarono ad apparire dei cloni free e open
source compatibili con la rete di Gnutella. Quindi molto presto vennero sviluppati molti altri client
(come ad esempio Morpheus, Limewire, Bearshare) basati sul protocollo di Gnutella. Lo sviluppo
in parallelo di differenti client da parte di differenti gruppi rimane tutt’oggi la modalità di sviluppo
di Gnutella.
La rete di Gnutella è completamente distribuita ed è quindi alternativa a quei sistemi semicentralizzati come KazAa e quei sistemi centralizzati come Napster o BitTorrent. Inizialmente la
popolarità della rete era fortemente accresciuta dalla chiusura di Napster per cause legali nel 2001.
Questa enorme crescita di popolarità di Gnutella svelarono le limitazioni di scalabilità del
protocollo iniziale. Nel 2001 le modifiche apportate al protocollo consentirono il miglioramento del
sistema in termini di scalabilità. Ad esempio uno dei miglioramenti consiste nella seguente
considerazione: invece di trattare ogni utente come client e server, certi utenti vengono trattati come
“ultrapeer” ai quali vengono inoltrate le richieste di ricerca da parte degli utenti collegati a tali
ultrapeer e questi inoltrano agli utenti che sono a loro collegati le risposte relative alle richieste che
loro avevano effettuato. Questo consentì alla rete di aumentare di dimensione.
Oggigiorno la parola “Gnutella” non fa riferimento ad un particolare progetto o ad una
porzione di software ma fa riferimento al protocollo aperto utilizzato dai vari client.
1.2.6.1 PROTOCOLLO DI QUERY FLOODIG [6]
Il protocollo di query flooding utilizzato da Gnutella consente di effettuare le seguenti
operazioni:
Join: operazione con la quale, il peer che vuole accedere alla rete, contatta alcuni nodi di
modo che questi diventino dei suoi vicini; per fare questo si ha un nodo di bootsdrap che
ha lo scopo di indicare al nodo considerato i suoi vicini;
18
Publish: in questo caso la pubblicazioni dei file che possiede l’utente considerato non è
necessaria poiché non si ha una directory centralizzata nel quale pubblicare i file che
possiede;
Search: un utente per cercare un file lo richiede ai suoi vicini i quali a loro volta
chiederanno il file desiderato ai loro vicini. Ogni volta che in questa ricerca si trova un
nodo che possiede il file desiderato si verifica che l’indirizzo IP di tale nodo viene
comunicato all’utente che ha generato la ricerca;
Fetch: il nodo considerato ottiene il file desiderato direttamente da un altro nodo della
rete peer to peer che possiede tale file.
Quindi Gnutella prevede un sistema:
completamente distribuito ossia non vi è alcun server centrale, come invece accade nel
caso di Napster;
con un protocollo di pubblico dominio ossia noto a tutti;
molti client di Gnutella che implementano tale protocollo.
Nella rete peer to peer di Gnutella si ha una rete di overlay che consiste in un grafo nel quale
ogni suo nodo corrisponde ad un peer partecipante della rete peer to peer stessa:
vi è un collegamento TCP tra due nodi della rete, se questi due nodi si conoscono tra
loro;
se un peer partecipante conosce la locazione di un altro peer nella rete peer to peer, allora
vi è un arco diretto tra il primo nodo ed il secondo nodo nella rete di overlay; quindi vi è
un arco tra il peer X ed il peer Y se vi è una connessione TCP tra i due;
tutti i peer attivi ed gli archi che li collegano formano la rete di overlay;
dato un peer questo sarà collegato, tipicamente, con un numero di vicini della rete di
overlay inferiore a 10.
19
1.2.6.2 PROTOCOLLO DI QUERY FLOODIG [6]
Quando uno nodo X della rete richiede un file si verifica che:
un messaggio di richiesta (o “Query Message”) è inviato a tutti i vicini del nodo
considerato attraverso le connessioni TCP già esistenti tra il nodo X ed i suoi vicini, con
il quale si richiede se i nodi che lo ricevono hanno il file desiderato;
ogni nodo che riceve la richiesta effettua due operazioni:
o inoltra il messaggio di richiesta ai propri vicini (o “Query Message”) sfruttando le
connessioni TCP già esistenti con loro;
o se ha il file considerato allora invia, nel percorso inverso che lo collega al nodo
richiedente, un messaggio di “Query Hit” che contiene ad esempio l’indirizzo IP
del nodo a cui è appena giunta la richiesta, di modo che il nodo X possa scaricare
direttamente il file dai peer che lo posseggono già.
La scalabilità di questo protocollo è limitata all’ambito di questo flooding ossia di quanto
inondare la rete con questi messaggi di richiesta.
1.2.6.3 GUTELLA: JOIIG DEL PEER ALLA RETE [6]
Un peer X per potersi unire alla rete peer to peer di Gnutella, deve trovare degli altri nodi peer
che ne fanno parte. Per fare ciò il nodo X esegue i seguenti passi:
inizia con una lista di peer candidati;
il nodo X prova sequenzialmente a creare una connessione TCP con ogni peer della lista
considerata fino a che non riesce a mettere in piedi una connessione con un nodo Y (della
lista).
A questo punto il nodo X invia un messaggio di Ping al nodo Y:
il nodo Y inoltra il messaggio di Ping a tutti gli altri suoi vicini;
tutti i peer che ricevono il messaggio di Ping rispondono con un messaggio di Pong che
viene inoltrato al peer X.
In questo modo il nodo X riceve molti messaggi di Pong (un messaggio di Pong per ogni nodo
che Y conosce) e quindi X può mettere in piedi ulteriori connessioni TCP verso i nodi che gli
hanno inviato il messaggio di Pong.
20
1.2.6.4 VATAGGI E SVATAGGI DI GUTELLA [6]
I vantaggi di Gnutella sono i seguenti:
si ha un sistema completante decentralizzato;
il costo della ricerca di un file è distribuito tra tutti i nodi della rete che vengono
interpellati con il protocollo di flooding;
l’elaborazione distribuita tra i vari nodi permette potenti ricerche semantiche.
Gli svantaggi di Gnutella sono i seguenti:
l’area di ricerca del file desiderato è abbastanza vasta;
il tempo necessario alla ricerca dei nodi che posseggono il contenuto desiderato può
essere molto lungo, siccome la richiesta deve essere propagata in tutta la rete di Overlay
della rete peer to peer;
si ha un alto contenuto di overhead nei messaggi e i nodi entrano ed escono dalla rete
molto spesso.
1.2.7 KaZaA
STORIA [4]
La rete peer o peer KaZaA fu creata nel marzo del 2001 dalla Dutch company, vicino alla fine
della prima generazione di reti peer to peer di prima generazione, che ha fine con la chiusura di
Napster nel luglio 2002. In questo sistema si ha una singola rete chiamata FastTrack utilizzata anche
da altri client.
Inizialmente molti utenti di KaZaA utilizzavano un client alternativo, che utilizzava lo stesso
protocollo e accedeva alla stessa rete di KaZaA. Ma una volta che il client ufficiale di KaZaA
divenne molto più diffuso di tutti gli altri, gli sviluppatori di KaZaA utilizzarono la loro abilità per
far sì che il client si aggiornasse automaticamente. In questo modo, attraverso la funzionalità di
aggiornamento automatico, venne cambiato il protocollo su cui si basava la rete di KaZaA in modo
da rendere inutilizzabili i Morpheus client, quando i suoi sviluppatori mancarono il pagamento della
licenza. Successivamente Morpheus divenne un client della rete peer to peer Gnutella.
Quindi, eventualmente, il protocollo può essere cambiato o modificato cosicché altri client
(non prodotti dagli sviluppatori di KaZaA) non possono più comunicare attraverso tale protocollo, e
ciò è possibile senza intaccare le funzionalità dei client di KaZaA poiché questi ultimi si aggiornano
automaticamente acquisendo in questo modo la conoscenza del comportamento del nuovo
protocollo.
Come tutti i produttori di prodotti simili, i proprietari di KaZaA sono stati citati in tribunale
dalle case discografiche per restringere il suo uso nella condivisione di materiale soggetto a
21
copyright. Nel novembre 2001, il tribunale ordinò ai proprietari di KaZaA di prendere
provvedimenti in modo tale da prevenire la presenza nella rete di KaZaA di utenti che violino il
copyright o in alternativa subire una pesante multa. I proprietari di KaZaA risposero a tale
ordinanza vendendo l’applicazione di KaZaA ad una complicata rete di compagnie offshore. Alla
fine di marzo del 2002 la corte d’appello della Dutch company rovesciò il primo giudizio, e stabilì
che KaZaA non era responsabile per le azioni dei suoi utenti, ed il conseguente appello delle case
discografiche fu perso nel dicembre 2003. In ogni modo i problemi legali di KaZaA erano
solamente all’inizio. I nuovi proprietari di KaZaA furono citati nel tribunale di Los Angeles da varie
compagnie discografiche e compagnie cinematografiche. La causa fu persa dai proprietari di
KaZaA dopo un controverso processo. Dopo questa decisione, a favore delle compagnie
discografiche e quelle cinematografiche, i proprietari di KaZaA si accordano con le case
discografiche e cinematografiche con il pagamento di una penale di 100 milioni di dollari per i
danni subiti delle quattro maggiori compagnie discografiche (Universal Music, Sony BMG, EMI e
Warner Music) e un ammontare non conosciuto per le case cinematografiche. Successivamente i
proprietari di KaZaA ebbero altri problemi giudiziari che non verranno qui descritti.
1.2.7.1 SMART QUERY FLOODIG [6]
Il protocollo utilizzato da KaZaA è detto “Smart Query Flooding” e prevede le seguenti
operazioni:
Join: all’avvio il client contatta un super – node e successivamente potrebbe lui stesso
diventare un super – node;
Publish: il client invia la lista dei file che possiede al proprio super – node ed in questo
modo pubblica la lista dei suoi file;
Search: il nodo richiedente invia al super – node il messaggio di query, e i super – node si
propagano tra loro la query;
Fetch: il nodo richiedente ottiene il file direttamente dal peer o dai peer che posseggono il
file desiderato; in questo modo il nodo richiedente recuperare il file da più peer alla volta.
1.2.7.2 KaZaA: SFRUTTARE L’ETEROGEEITA’ [6]
Nella rete Peer To Peer di KaZaA viene sfruttata l’eterogeneità esistente tra i nodi della rete, in
quanto vi possono essere due tipologie di nodi differenti i super – node ed i nodi ordinari, che
assolvono compiti leggermente diversi: ogni nodo della rete è un leader di un gruppo di nodi oppure
22
è assegnato ad un gruppo leader ed in questo caso è un peer ordinario. Quindi in questa situazione si
verifica che:
viene creata una connessione TCP tra ogni peer ordinario ed il suo nodo leader del
gruppo a cui appartiene;
vi sono delle connessioni TCP tra alcune coppie di nodi leader di gruppo.
Quindi ogni group leader è un nodo che tiene traccia dei contenuti presenti nei suoi nodi figli
ossia nei nodi che gli sono associati.
ordinary peer
group-leader peer
neighoring relationships
in overlay network
Figura 1
1.2.7.3 COSOLIDAMETO DELLE QUERY [6]
Il consolidamento delle query di richiesta file viene effettuato considerando che: molti nodi
collegati ad un super nodo potrebbero avere solamente un numero molto piccolo di file e quindi la
propagazione della query ad un sub-node (ad un nodo ordinario) potrebbe richiedere più tempo
rispetto alla risposta che si ottiene direttamente al super – node.
Quindi avendo nella rete dei nodi particolari detti super – node si ha un miglioramento del
protocollo di query flooding poiché è sufficiente propagare il messaggio di richiesta ai soli super
node e non a tutti i nodi della rete peer to peer.
23
1.2.7.4 STABILITA’ [6]
I super node favoriscono i nodi aventi un tempo di up elevato ossia un tempo in cui sono attivi
più elevato, poiché la durata di tempo in cui il nodo è attivo è una buona predizione di quanto tempo
sarà attivo in futuro.
1.2.8 BitTorrent
STORIA [5]
Il client BitTorrent è un programma che gestisce il download e l’upload di torrent
(letteralmente “torrenti”) utilizzando il protocollo BitTorrent.
Il primo client, conosciuto come BitTorrent, fu creato da Bram Cohen nell’estate del 2002.
Molti client successivi sono stati, almeno parzialmente, basati sul primo client di BitTorrent.
All’inizio non tutti i client erano stati implementati per il protocollo BitTorrent e a questi client è
stato aggiunto il supporto per tale protocollo solo successivamente.
1.2.8.1 OBIETTIVI DI BITTORET [6]
L’obiettivo di BitTorrent è quello di consentire un recupero, ossia un download, efficiente del
contenuto desiderato. Quindi non si ha come scopo quello di migliorare il ricerca dei contenuti. In
questo modo si vuole ottimizzare la distribuzione dei file a molti peer, considerando che si ha un
singolo editore (del file) e molti downloader. Un altro obiettivo di BitTorrent è quello di prevenire il
problema di Free – Riding.
1.2.8.2 DOWLOAD SIMULTAEI I BITTORRET [6]
Per consentire ai peer di scaricare il file desiderato in maniera simultanea da altri peer, sono
effettuate le due seguenti operazioni:
viene diviso il file in molte porzioni:
o le varie porzioni vengono replicate su differenti peer;
o un peer avente una porzione completa del file può contrattare con altri peer per
ottenere altre porzioni;
o in questo modo si spera che ogni peer possa riassemblare l’intero file;
viene consentito il download simultaneo di porzioni diverse ossia:
o ogni peer può recuperare le differenti parti del file desiderato da peers differenti
allo stesso tempo;
24
o ogni peer può fornire le parti del file che possiede agli altri peer richiedenti;
o questa gestione delle porzioni dei file è molto importante per file di grandi
dimensioni.
1.2.8.3 BITTORRET: TRACKER [6]
Il traker è un’infrastruttura di nodi che tiene traccia dei peer che stanno partecipando al torrent
considerato. I peer si registrano al tracker ossia: quando un peer entra a far parte del torrent
considerato si registra sul tracker. Inoltre ogni peer, periodicamente, informa il tracker che è ancora
attivo o presente nel torrent. Quando un nuovo peer entra a far parte del torrent il tracker seleziona
l’insieme dei nodi dai quali il nuovo peer potrà scaricare il file del torrent considerato. Quindi il
tracker fornisce al nuovo peer un insieme casuale di peer da cui scaricare il torrent includendo gli
indirizzi IP dei peer selezionati. In questo modo il nuovo peer conosce chi contattare per scaricare i
dati.
1.2.8.4 BITTORET: CHUK [6]
In BitTorrent i file di grandi dimensioni sono divisi in pezzi più piccoli detti chunk. I chunck
sono porzioni del file considerato di dimensione fissa, tipicamente ogni chunk ha una dimensione di
256 Kbyte.
L’utilizzo dei chunk consente il trasferimento simultaneo delle varie porzioni del file cioè: ogni
nodo può scaricare i vari chunk dai suoi vicini e i chunk che possiede li può fornire ad altri suoi
vicini.
Ogni nodo deve essere in grado di imparare quali chunk posseggono i suoi vicini ossia:
periodicamente richiede ai propri vicini la lista dei blocchi che posseggono, relativamente al file
considerato. Il download del file è completato quando sono stati acquisiti tutti i chunk relativi.
1.2.8.5 BITTORET: ARCHITETTURA GEERALE [6]
Si consideri un peer X che voglia scaricare un dato torrent; per fare questo il peer accede al
web server che contiene la pagina web avente il link al file .torrent desiderato, e scarica tale file
.torrent. Nel file .torrent vie è la lista dei tracker che gestiscono i peer che posseggono il file
desiderato. Quindi il peer X effettua la richiesta verso i tracker (indicati nel file .torrent) con la
quale si registra in questi ed ottiene come risposta la lista dei peer che posseggono il file
considerato. A questo punto il peer X effettua la richiesta delle porzioni o chunk ai nodi della lista
25
che ha ricevuto e si mette d’accordo con essi per ottenere chunk diversi dai vari nodi contattati. I
peer che ricevono la richiesta di download dal peer X rispondono inviandogli le porzioni del file
concordate. Inoltre il peer X, nel momento in cui acquisisce almeno un chunk, fornisce (in upload) i
chunk che ha acquisito agli altri peer che non posseggono l’intero file; tali peer sono detti leecher
mentre i peer che posseggono l’intero file sono detti seeder. Periodicamente il peer X invia degli
annunci al tracker per dirgli che è ancora attivo e disponibile ed attraverso tali annunci ottiene la
lista aggiornata dei peer che posseggono il torrent considerato.
1.2.8.6 BITTORRET:
SCELTA
DELL’ORDIE
DEI
CHUK
DA
RICHIEDERE [6]
Il problema che si presenta è quello di stabilire quale ordine si deve fissare per i chunk
richiesti: una possibile soluzione può essere quella di scaricare le varie porzioni del file nell’ordine
con il quale compaiono nell’intero file. Però, adottando tale soluzioni, si incorre al seguente
problema: scaricando i vari chunk del file nell’ordine in cui appaiono nel file stesso si verifica che
molti peer hanno solamente i primi chunk del file stesso. In questo modo, i peer avendo tutti i primi
chunk hanno poche porzioni da condividere con gli altri peer. Inoltre tale soluzione limita la
scalabilità del sistema. Un ulteriore problema è rappresentato dal fatto che, con tale soluzione,
nessuno avrà i chunck più rari, cioè ad esempio si può verificare che i chunk, richiesti dalla maggior
parte dei nodi, siano quelli relativi alla parte finale del file ed in questo modo viene limitata la
capacità del download dell’intero file.
Quindi la soluzione migliore è quella di selezionare i chunk in maniera casuale e fornire prima
i chunk che risultano essere più rari di modo che aumenti la probabilità di completamento del file
considerato.
1.2.8.7 BITTORET: SCELTA DEI CHUK PIU’ RARI [6]
Quale chunk richiedere per primo? Si richiede il chunk che ha il minor numero di copie
disponibili, cioè ad esempio si richiedono prima i chunk più rari.
Con questa soluzione si hanno dei benefici a livello di ogni peer, poiché si evita la starvation
ossia l’attesa di chunk non più disponibili a causa del fatto che i peers che li possedevano se ne sono
andati dal torrent, poiché ogni peer della rete richiede per primi i chunck aventi meno copie
disponibili.
26
Inoltre con tale soluzione si hanno dei benefici a livello di sistema poiché: si evita la starvation
di tutti i peer che stanno aspettando un file e viene bilanciato il carico rendendo uguali il numero di
copie per ogni chunk.
1.2.8.8 IL PROBLEMA DEI FREE–RIDIG ELLE RETI PEER TO PEER [6]
L’enorme maggioranza degli utenti sono free – rider, ossia la maggior parte degli utenti non
condividono file e non effettuano query di richiesta. Altri peer sono considerati free – rider poiché
hanno un numero di connessioni limitate o una velocità di upload limitata.
Essenzialmente vi sono solamente pochi peer che si comportano da server e quindi vi sono
pochi contributi individuali al bene pubblico. A tale scopo BitTorrent previene il fenomeno del free
– riding consentendo ai peer veloci di scaricare dai peer che si comportano da server, ed ogni tanto
si permette anche ai free – riding di effettuare il download del contenuto desiderato.
1.2.8.9 BITTORET: PREVEZIOE DEL FREE – RIDIG [6]
Bisogna considerare che i peer che hanno una banda di upload limitata la devono condividere
tra peer multipli. Quindi le tecniche per prevenire il fenomeno del free – riding sono le seguenti:
dare una maggiore priorità alla banda di upload, ossia favorire i vicini che stanno
uploadando ad una velocità maggiore;
ricompensare i migliori 4 vicini ossia:
o viene misurata la velocità di download che si ha verso ogni vicino;
o i nodi si scambiano tra loro inviandosi i migliori quattro peer;
o il calcolo dei migliori quattro vicini e la riallocazione del download viene
effettuata ogni 10 secondi.
Optimistic unchoking:
o casualmente si prova un nuovo vicino ogni 30 secondi;
o in questo modo un nuovo vicino ha la possibilità di diventare un migliore
partner nella comunicazione.
1.2.8.10
BITTORET: PROBLEMI ATTUALI [6]
Il maggiore problema è quello dei download incompleti: di solito i peer lasciano il sistema
quando terminano il loro download. In questo modo certi peer non saranno mai in grado di
27
completare il download del desiderato; soprattutto, tale problema si verifica per i contenuti meno
popolari.
Un altro problema riguarda il fatto che una percentuale significativa (stimata nel 30%) del
traffico su internet è assorbita dallo scambio file attraverso peer to peer.
Infine vi sono ancora molte questioni legali in sospeso per quanto riguarda lo scambio di file
protetti da copyright.
1.3 UTILIZZO DEL PEER TO PEER NELLA DIFFUSIONE DI CONTENUTI
MULTIMEDIALI
Una modalità attraverso la quale un nodo sorgente può diffondere un contenuto multimediale
(in streaming) ad un dato gruppo di nodi è rappresentato dal protocollo multicast a livello IP. In
questo capitolo verrà fornita una breve descrizione del multicast e verranno esposte le ragioni e le
problematiche che determinano il passaggio dalla distribuzione di contenuti multimediali attraverso
multicast alla distribuzione di contenuti multimediali attraverso opportune reti peer to peer.
1.3.1 UNICAST, BROADCAST E MULTICAST [7]
La versione classica del protocollo IP contempla solamente l’unicast ed il broadcast, mentre il
supporto al multicast è stato aggiunto solamente in tempi successivi. Ogni router presente in
internet è configurato in modo tale che blocchi il traffico di tipo broadcast poiché se si farebbe
passare tutto il traffico broadcast si rischierebbe di irrorare tutta la rete di pacchetti, portandola ad
una possibile congestione. Quindi il broadcast è utilizzato a livello IP ma è mantenuto solamente a
livello locale. Le tre modalità di instradamento pacchetti unicast, broadcast e multicast si
differenziano tra loro in base a coloro i quali è destinato il pacchetto prodotto dal nodo sorgente,
ossia: nel caso dell’unicast il nodo sorgente invia il pacchetto ad uno ed un solo nodo di
destinazione; mentre nel caso broadcast il pacchetto emesso dal nodo sorgente è destinato a tutti i
nodi presenti nella rete locale; ed infine il multicast prevede la definizione di un insieme di
destinatari multicast ai quali viene inviato opportunamente il pacchetto emesso dal nodo sorgente.
Da queste considerazioni le tre modalità di instradamento dei pacchetti presentano anche piani di
indirizzamento differenti cioè: nel caso dell’unicast ogni macchina ha un è proprio indirizzo IP; nel
caso del broadcast il relativo indirizzo (broadcast) non individua una sola macchina ma tutte le
macchine che appartengono ad una rete; invece nel caso del multicast si deve identificare il gruppo
di macchina a cui inoltrare il pacchetto emesso dal nodo sorgente e quindi occorre identificare
28
l’affiliazione delle macchine al gruppo multicast considerato. Quindi per il multicast si ha uno
spazio di indirizzamento che è rappresentato dalla classe di indirizzi D: 224.0.0.0 ÷
239.255.255.255. Questa classe di indirizzi è riservata al multicast e di conseguenza per ogni
gruppo si ha un solo indirizzo IP multicast che lo individua. Inoltre occorre considerare che ogni
indirizzo IP di tipo multicast è solamente un indirizzo destinatario che individua un gruppo di
macchine destinatarie appartenenti al gruppo multicast considerato.
1.3.2 MULTICAST E PROTOCOLLO IGMP [7]
Per permettere alle macchine di entrare a far parte di un gruppo o lasciare un gruppo occorre un
protocollo particolare detto IGMP (“Internet Group Management Protocol”). Attraverso tale
protocollo ogni macchina dichiara al router che afferisce alla sua rete, con una particolare procedura
di segnalazione, l’interesse di appartenere al gruppo desiderato o l’interesse a non appartenere più a
tale gruppo. Il nodo sorgente o trasmettitore non è a conoscenza degli indirizzi unicast dei singoli
ricevitori che appartengono al gruppo ma conosce solamente l’indirizzo multicast del gruppo dei
ricevitori. Quindi è responsabilità dei ricevitori effettuare la richiesta di associazione al gruppo
multicast desiderato sfruttando il protocollo IGMP, il cui scopo è quello di informare il router della
presenza di almeno una macchina, nella rete locale considerata, interessata al dato gruppo. Si
osserva che in un generico gruppo vi possono essere più trasmettitori e di conseguenza quando una
macchina di un gruppo si comporta da trasmettitore tutte le altre macchine del medesimo gruppo si
comportano da ricevitori. Per il protocollo IGMP l’associazione di una macchina ad un dato gruppo
può avvenire in due modi diversi:
1.
prima modalità: la macchina A richiede al router di confine R l’affiliazione al gruppo
desiderato mentre il router R non consoce tale gruppo;
2.
seconda modalità: il router R, determina periodicamente i gruppi conosciuti e li indica
alle macchina della propria rete locale ed in questo modo le macchine della rete locale
fanno richieste al router stesso per potersi affiliare ad uno dei gruppi che gli sono stati
indicati dal router stesso.
Inoltre il protocollo IGMP prevede che un router possa chiedere alle macchine connesse di
indicare tutti i gruppi ai quali sono affiliati o se sono affiliati ad un gruppo specifico; a tale richiesta
le macchine della rete gestita dal router rispondono con un pacchetto uguale a quello utilizzato per
segnalare la volontà di associarsi ad un gruppo per la prima volta.
Infine l’IGMP prevede un pacchetto per indicare al router di confine la volontà di una
macchina di lasciare un particolare gruppo. Questa segnalazione non è strettamente necessaria in
quanto le macchine rinnovano periodicamente la loro affiliazione ad un gruppo ossia il router di
29
confine aspetta una risposta periodica di rinnovo dell’appartenenza al gruppo corrispondente dalle
sue macchine e se tale rinnovo non giunge al router in tempo utile allora il router assume
automaticamente che la macchina abbia abbandonato il gruppo a cui apparteneva.
A livello locale la gestione del multicast attraverso il protocollo IGMP avviene nel seguente
modo:
1.
la macchina A che vuole entrare a far parte di un dato gruppo, effettua la prima
richiesta di appartenenza al gruppo multicast desiderato verso il proprio router di
confine R;
2.
a questo punto il router R vede se esistono pacchetti, in internet, relativi a tale gruppo
e se sì li inoltra verso le macchine richiedenti della propria rete locale;
3.
successivamente il router R richiede periodicamente, a livello locale, chi vuole il
traffico del gruppo multicast considerato ed i client che vogliono effettivamente tale
traffico lo accettano rispondendo alle richieste del router. In questo modo quando il
router riceve i pacchetti multicast del gruppo considerato, li inoltra opportunamente
alla propria rete locale;
4.
se invece le macchine locali non rispondono più alle richieste periodiche del ruoter R
allora il router non farà passare più nulla alla propria rete locale, per quanto riguarda
tale traffico multicast.
Nel caso del multicast si verifica che: la gestione dell’instradamento dei pacchetti a livello
locale è diversa da quella che si adotta a livello geografico.
1.3.3 FUNZIONAMENTO DEL MULTICAST A LIVELLO LOCALE [7]
Per ogni pacchetto multicast che il router di confine R invia alla propria rete locale è necessario
capire come funziona il multicast a livello 2, all’interno delle reti locali. Dovendo inviare un
pacchetto multicast nella rete locale il router R lo può effettuare nei seguenti modi:
1.
caso unicast di livello 2. Siccome il router R conosce l’indirizzo MAC delle macchine
che appartengono al gruppo multicast considerato, allora per ogni macchina locale
appartenente al gruppo il router invia il pacchetto al MAC address della macchina
locale di destinazione considerata; in questo modo la scheda di rete del destinatario
vede un pacchetto con il suo MAC address e quindi lo passa a livello applicativo
scatenando un interrupt verso il sistema operativo. In questo modo il pacchetto viene
passato al sistema operativo senza appesantire quest’ultimo poiché non deve
controllare tutti i pacchetti che circolano sulla rete, in quanto tale operazione è
effettuata dalla scheda di rete per conto del sistema operativo stesso. Occorre notare
30
che, in questa soluzione, il router R invia il pacchetto multicast alla rete locale
inviandolo ad ogni macchina locale, appartenente al gruppo multicast considerato,
come un pacchetto unicast di livello 2 e di conseguenza ciò provoca uno spreco di
risorse e di banda delle rete locale;
2.
caso broadcast di livello 2. Un’altra soluzione può essere la seguente: quando il router
R riceve dall’esterno un pacchetto multicast e lo deve inoltrare alla propria rete locale,
il router trasforma tale pacchetto in un corrispondente pacchetto broadcast di livello 2
(all’interno del quale vi è l’indirizzo IP del gruppo multicast associato) e lo invia alla
propria rete locale. In questo modo ogni macchina della rete locale si comporta nel
seguente modo:
la scheda di rete, di ogni macchina della rete locale, ricevendo un pacchetto di
tipo broadcast di livello 2, interrompe il sistema operativo il quale a seguito di
tale evento determina se il pacchetto ricevuto è rivolto alla sua macchina
controllando se l’indirizzo IP multicast, contenuto nel payload del pacchetto
stesso, è quello del gruppo multicast a cui appartiene la macchina considerata;
in questo modo il sistema operativo di ogni macchina della rete locale viene
interrotto, ogni volta che il router inoltra nella rete locale un pacchetto multicast
sottoforma di un pacchetto broadcast di livello 2, anche se tale pacchetto non è
rivolto alla macchina locale considerata.
In questo modo tutte le macchine della rete locale diventano lente poiché il sistema
operativo di ognuna di esse si dovrà occupare solamente di determinare se i pacchetti
broadcast di livello 2 che riceve sono effettivamente rivolti a lui o meno. Quindi
questa soluzione ha come vantaggio quello di essere semplice da realizzare e come
svantaggio quello che determina un notevole rallentamento delle macchine della rete
locale;
3.
caso multicast di livello 2. Un possibile rimedio alle problematiche introdotte dalle
due precedenti soluzioni è quello di utilizzare un multicast di livello 2. In questo caso
occorre che ogni singola scheda di rete possa programmare al suo interno n indirizzi
multicast di livello 2 ed in questo modo quando la scheda di rete riconosce un
pacchetto multicast di livello 2, avente indirizzo multicast (di livello 2) appartenete
alla lista degli indirizzi gestiti dalla scheda di rete, allora si verifica che tale scheda di
rete inoltra un’interruzione verso il sistema operativo di modo che questo possa gestire
il pacchetto ricevuto. In questa tecnica l’indirizzo IP del gruppo multicast considerato
31
viene mappato opportunamente in un corrispondente indirizzo multicast di livello 2
(per questioni di brevità non verrà descritto in dettaglio tale mapping).
Quindi considerando il multicast a livello locale il router di confine della rete locale deve avere
funzionalità aggiuntive rispetto al semplice instradamento, in particolare deve essere in grado di
gestire l’affiliazione e la rimozione di un nodo della rete locale ad un gruppo e l’inoltro dei
pacchetti relativi ad un gruppo multicast alla propria rete locale.
1.3.4 FUNZIONAMENTO DEL MULTICAST A LIVELLO GEOGRAFICO [7]
Per poter instradare i pacchetti emessi dal nodo sorgente del gruppo multicast ai router di
confine, che gestiscono le reti locali nelle quali vi è almeno un nodo che è affiliato al gruppo
multicast considerato, occorre costruire e mantenere aggiornato l’albero multicast. Tale albero ha
come radice il nodo sorgente (o il router di confine del nodo sorgente), ha come nodi foglie i router
di confine delle reti locali che contengono almeno un nodo interessato al gruppo considerato, ed ha
come nodi intermedi i router che collegano il nodo sorgente ai router foglia. A livello geografico,
quando il pacchetto multicast giunge ad un router intermedio (dell’albero) viene replicato su tutte le
sue interfacce sulle quali si hanno dei router (o nodi) figli interessati al gruppo relativo al pacchetto
considerato. Per fare questo i router devono avere anche le funzionalità necessarie per la gestione
dei pacchetti multicast sia a livello locale (nel caso dei router di confine) che a livello geografico
(nel caso dei router presenti nell’albero di instradamento multicast), oltre alle funzionalità di
instradamento di base. La creazione e la gestione dell’albero multicast può essere effettuata con
protocolli differenti (che in questa sede verranno solamente citati e non descritti) quali ad esempio:
Reverse Path Forwarding, Distance Vector Multicast Routing Protocol e Protocol Indipendent
Multicast.
1.3.5 PROBLEMATICHE DEL MULTICAST [7][8]
Le maggiori problematiche che si riscontrano utilizzando il multicast, per la diffusione di
contenuti multimediali, sono le seguenti:
1. il multicast a livello IP richiede che tutti i router mantengano lo stato per ogni gruppo
multicast che conoscono e tale fatto introduce nei router un’elevata complessità ed
impone dei forti vincoli di scalabilità dei router stessi. I router delle dorsali sono stati,
originariamente progettati per avere un’architettura senza stato e sono dedicati
solamente al forwarding dei pacchetti. Quindi per supportare il multicast a livello IP
ogni router deve essere in grado di riconoscere i gruppi multicast sui quali ognuna delle
32
sue interfacce di rete ha almeno un partecipante e deve essere in grado di gestire le
richieste delle macchine che vogliono entrare a far parte o che vogliono lasciare un dato
gruppo multicast. Queste nuove funzionalità complicano la progettazione dei router;
2. il multicast a livello IP non ha un meccanismo di allocazione degli indirizzi. Gli
indirizzi multicast possono essere assegnati o da un’autorità centralizzata o dalla
particolare applicazione. Se si ha un’autorità centrale che assegna e ricicla (quando non
sono più in uso) gli indirizzi multicast, allora tale autorità deve essere in grado di
gestire tali indirizzi IP multicast in maniera scalabile, consistente e distribuita. Questo è
molto difficile da ottenere specialmente quando un elevato numero di gruppi multicast
sono frequentemente costituiti e rilasciati su tutta la rete internet. Se invece ogni
applicazione individuale è responsabile dell’assegnamento del relativo indirizzo IP
multicast allora potenzialmente vi potrebbe essere la contesa dello stesso indirizzo IP
multicast da parte di differenti applicazioni, e senza la gestione opportuna di questa
situazione si otterrebbe come risultato che il traffico generato da differenti gruppi, che
utilizzano lo stesso indirizzo IP multicast, verrebbe erroneamente mescolato;
3. il multicast a livello IP ha delle vulnerabilità per quanto riguarda la sicurezza, che
possono essere ricondotti al problema del Denial of Service e attacchi flooding
provenienti da utenti malevoli. Il multicast a livello IP differisce dalle comunicazioni IP
unicast nelle sue implicazioni di sicurezza cioè: il corrente modello dell’IP multicast
consente ad una sorgente arbitraria (che è entrata a far parte del relativo gruppo) di
inviare dati ad un gruppo arbitrario e tale fatto determina la vulnerabilità della rete ad
attacchi flooding generati da sorgenti malintenzionate. Per risolvere tale problema è
necessario implementare delle politiche di sicurezza molto complicate prima che il
multicast a livello IP venga ampiamente impiegato;
4. il multicast a livello IP è un servizio di tipo “Best Effort” ossia si consegnano i
pacchetti nel miglior modo possibile utilizzando il protocollo a livello di trasporto
UDP. Quindi attualmente non vi è un protocollo a livello di trasporto efficace e
scalabile che opera per il multicast a livello IP al fine di garantire la consegna affidabile
dei pacchetti e garantire un’implementazione del meccanismo del controllo di flusso e
di congestione. Per tali motivi l’utilizzo del multicast IP è ristretto solamente ad alcune
particolari applicazioni (ad esempio diffusione e distribuzione di contenuti
multimediali, che per le loro caratteristiche non possono avere un meccanismo
affidabile di consegna dei pacchetti e un meccanismo di controllo di flusso e di
congestione);
33
5. l’IP multicast richiede molti cambiamenti a livello di infrastruttura di rete. Per tali
motivi la maggior parte degli Internet Service Provider non sono disposti a fornire il
supporto al multicast a livello IP a causa del fatto che dovrebbero effettuare
significativi investimenti. Ma d’altro canto, la forte necessità delle funzionalità offerte
dal multicast ed il consumo inefficiente di banda che si verifica nelle tradizionali
applicazioni client – server, richiedono un modo alternativo per fornire le funzionalità
offerte dal multicast.
Una possibile soluzione alternativa al multicast a livello IP, per la diffusione di contenuti
multimediali generati a partire da un nodo sorgente, è quello di utilizzare reti peer to peer nelle quali
vi è un unico nodo sorgente che fornisce il contenuto multimediale ed ogni nodo altro nodo che
entra nella rete acquisisce il contenuto da un altro peer o dal nodo sorgente e sfrutta la sua output
band per fornire il servizio ad altri peer che successivamente entreranno nella rete stessa; in questo
modo non è necessario avere una infrastruttura di rete che supporti una data tecnologia o uno
specifico meccanismo di comunicazione come accade per il multicast a livello IP.
1.4 PEER TO PEER SU CANALE ASIMMETRICO
Utilizzi più innovativi del peer to peer prevedono l'impiego delle reti peer to peer per la
diffusione di elevati flussi di dati generati in tempo reale, come per esempio programmi televisivi,
film o comunque contenuti multimediali in genere. Questi sistemi si basano sull'utilizzo delle banda
di trasmissione che i singoli utenti dispongono e la banda viene utilizza per trasmettere agli altri
fruitori il flusso dati. Questa tipologia di sistemi, in linea di principio, non richiedono server dotati
di elevate prestazioni dato che il server fornisce a un numero molto limitato di utenti i flussi video,
e poi i singoli utenti ridistribuiscono agli altri utenti i flussi video.
Questo metodo di diffusione permette in teoria la trasmissione in tempo reale di contenuti
video ma richiedono che i singoli utenti siano dotati di connessioni che oltre ad avere elevata banda
in ricezione siano anche dotati di elevata banda in trasmissione, altrimenti il primo nodo della rete
(il server) dovrebbe fornire la larghezza di banda mancante portando rapidamente a una saturazione
della banda fornita dal server. Questo limita la diffusione di questa tecnologia in Italia dove sono
molto diffusione le linee asimmetrica (quali ad esempio le adsl) che forniscono elevata banda di
ricezione ma scarsa banda in trasmissione. Per tali motivi è utile studiare, ed eventualmente
realizzare, algoritmi per la costruzione incrementale di reti peer to peer adottate per la diffusione di
contenuti multimediali erogati da un unico nodo sorgente e supponendo che i nodi che accedono a
34
questa rete siano caratterizzati da collegamenti asimmetrici (o linee asimmetriche)
[9]
. Quindi lo
scopo di questi algoritmi è quello di gestire l’inserimento nella rete peer to peer di ogni nodo che
vuole accedere al contenuto.
Nel capitolo successivo viene descritto l’algoritmo per la creazione di reti peer to peer adottate
per la diffusione di contenuti (ideato da Gianluca Mazzini e Riccardo Rovatti) nel quale si ha come
ipotesi principale che: tutti i nodi che vogliono accedere alla rete hanno la medesima banda in
upload, hanno una banda in download sufficiente ad acquisire il contenuto multimediale (ossia la
input band di ogni nodo è almeno pari alla banda richiesta dal contenuto) e si suppone che tutte le
bande disponibili di ogni nodo della rete peer to peer siano non variabili nel tempo [9].
2 PEER
TO
PEER
DISTRIBUTION
ON
ASYMMETRIC
CHANNELS [9]
I metodi di peer to peer sono comunemente impiegati per la distribuzione di un contenuto ad
un gran numero di utenti interessati, nel miglior modo possibile dati certi vincoli di ampiezza di
banda che dipendono dalla banda richiesta dal contenuto da diffondere. In questo capitolo verrà
descritto un semplice metodo per creare una rete peer to peer per applicazioni di streaming nelle
quali vi è una sorgente che fornisce continuamente un contenuto che deve essere utilizzato da un
elevato e sconosciuto numero di utenti entro un dato ritardo di tempo massimo.
2.1 TOPOLOGIA DELLE RETI
Nella nostra rete, il nodo sorgente emette il contenuto mentre i nodi utente, o anche detti peer,
sono in grado di accettare stream parziali (o contenuti parziali) provenienti da più di un nodo
attraverso il loro collegamento d'ingresso e di ridistribuire tale contenuto ad uno o più ulteriori peer
attraverso il loro link di uscita. Questo crea una rete di distribuzione del contenuto modellata
attraverso un grafo diretto orientato dalla sorgente. Tale grafo deve essere creato ed aggiornato
dinamicamente quando un nuovo peer entra nella rete e tale aggiornamento deve essere effettuato
senza cambiare i collegamenti dei peer che si stanno servendo attualmente.
Il meccanismo di gestione dinamica della rete peer to peer, che verrà introdotto e descritto nella
sezione successiva, ha i seguenti obiettivi:
il primo obiettivo è rappresentato dalla minimizzazione della banda totale disponibile
che il nodo sorgente fornisce alla rete;
35
il secondo obiettivo considera la banda sorgente come un vincolo e minimizza il ritardo
massimo in termini di link intermedi.
Quindi nell’algoritmo, che viene descritto nella sezione successiva, non si considera come
obiettivo la massimizzazione del numero di nodi inseribili nella rete ma tale obiettivo verrà
considerato negli algoritmi che verranno analizzati e decritti nel capitolo 3.
Le ipotesi sulle quali si basa l’algoritmo per la creazione della peer to peer in analisi sono le
seguenti:
tutti i peer sono caratterizzati da una stessa ampiezza di banda in output, Ω, e sono
sempre disponibili durante lo streaming; inoltre si ipotizza che Ω sia inferiore a 1;
l'ampiezza di banda in ingresso di tutti i peer è sufficiente ad accettare il contenuto e
tutte le ampiezze di banda sono normalizzate rispetto alla banda Bc richiesta dal
contenuto che deve essere distribuito. Quindi la banda richiesta dal contenuto
multimediale è normalizzata a 1;
con il rispetto di tale ampiezza di banda, l'ampiezza di banda massima di ogni peer è
minore o uguale a 1;
il nodo sorgente ha un'ampiezza di banda massima pari a B;
la banda disponibile di ogni nodo della rete peer to peer è tempo invariante.
I nuovi algoritmi che vengono proposti, analizzati e descritti nel capitolo 3 di questa tesi, non
contemplano l’ipotesi per la quale tutti i nodi che accedono alla rete sono caratterizzati da uno
stesso valore di output band e quindi si suppone che tali nodi possano avere valori di output band
differenti.
2.2 DESCRIZIONE DELL’ALGORITMO [9]
Come già specificato nel capitolo precedente si suppone che le bande di upload e di download
di tutti i nodi siano normalizzate rispetto alla banda Bc del contenuto. In questo modo l’output band
di ogni nodo rappresenta il numero di nodi che tale peer è in grado di alimentare al fine di erogare il
contenuto multimediale considerato. Naturalmente, se l’output band che ha a disposizione il nodo
considerato è inferiore all’unità allora tale nodo non sarà in grado di alimentare un ulteriore nodo e
di conseguenza quest’ultimo dovrà acquisire il contenuto multimediale dal nodo considerato e da
ulteriori nodi.
Secondo questo algoritmo di inserimento nodi nella rete si considera che: la rete peer to peer di
distribuzione del contenuto è organizzata in "tier" o file numerate a partire da 1. I peer contenuti
nel primo tier sono alimentati dal nodo sorgente. Mentre i peer del j-esimo tier ricevono il contenuto
solamente dai peer presenti nel (j-1)-esimo tier. Il numero di tier presenti nella rete di distribuzione
36
del contenuto è indicato dal parametro T, che rappresenta anche il massimo ritardo della rete in
termini di link (o collegamenti) intermedi.
Si indica con Pj il numero di peer presenti nel j-esimo tier. Considerando che la banda del
contenuto è normalizzata all'unità allora la banda complessiva richiesta per distribuire il contenuto
al j-esimo tier è Pj. Mentre considerando che ogni nodo fornisce una output band pari a Ω allora
l'intera ampiezza di banda messa a disposizione dal j-esimo tier è pari a Ω·Pj. L'ampiezza di banda
fornita in output dal nodo sorgente è data dal parametro P1.
Il passo elementare comune ai due algoritmi che verranno successivamente descritti, è
"l'inserimento di un peer nel j-esimo tier se è possibile" e questa porzione di codice è indicata con
A(j). Un pseodocodice per la procedura A(j) è il seguente:
Algoritmo (1)
case j=1
if (P1 < B)
then P1++; else failed
case j=2,...,T
if (Ω·(Pj-1) ≥ Pj+1)
then Pj++; else failed
case j=T+1
if (Ω·(PT) >=1)
then PT+1=1; T++; else failed
Figura 2
Dove un peer è inserito nel j-esimo tier se e solo se l'output bandwidth fornita dal tier
precedente (se j=1 allora il tier precedente è rappresentato dal nodo sorgente) è sufficiente per
accoglierlo.
Ora si assume che la banda B fornita dal nodo sorgente sia tendente a infinito e che si vogliano
servire i nodi che vogliono unirsi alla rete in modo tale che la banda P1 (ossia l'ampiezza di banda
effettiva del nodo sorgente) sia minimizzata senza cambiare i peers ed i loro link, che sono già
presenti nella rete. Se vi sono due reti aventi la stessa banda del nodo sorgente P1 allora si vuole
scegliere tra queste due la rete avente il minore valore del parametro T, per minimizzare il ritardo
massimo della rete. Viene effettuato ciò attraverso il seguente semplice algoritmo:
Algoritmo (2)
for j=2 to T+1
if A(j) not failed then stop
next
Figura 3
A(1)
37
Questo primo algoritmo prova ad aggiungere il nuovo peer nel tier avente il minimo ritardo
complessivo non considerando il tier collegato direttamente al nodo sorgente; in questo modo se,
per i vincoli sull'ampiezza di banda, il nodo non può essere inserito nei tier successivi al primo
allora tale nodo viene inserito nel primo tier poiché il nodo sorgente alimenta tale tier con una
upload band disponibile infinita.
Ora si assume che la banda fornita dal nodo sorgente B sia finita e che si vogliano servire i
nodi, che vogliono unirsi alla rete, in modo tale che venga minimizzato il parametro T che
rappresenta il ritardo massimo che subisce la rete. Viene effettuato ciò attraverso il seguente
algoritmo:
Algoritmo (3)
for j=1 to T+1
if A(j) not failed then stop
next
failed
Figura 4
Questo algoritmo prova ad aggiungere il nuovo peer nel tier caratterizzato dal ritardo minimo
in modo tale da soddisfare i vincoli sull'ampiezza di banda e quindi tale algoritmo viene terminato
con insuccesso (fallisce) se non si possono alimentare ulteriori peers da parte dei peers che vi sono
nei vari tiers della rete di diffusione del contenuto.
Entrambi questi approcci sono sub-ottimi nel numero di peer serviti. Infatti, si potrebbe
racimolare l'output band non utilizzata dai differenti tier per alimentare un nuovo nodo. Gli
algoritmi (2) e (3) producono una struttura nella quale ogni nodo alimenta al massimo due ulteriori
nodi nel tier successivo. Più formalmente, ad ogni istante, ogni peer è in uno dei seguenti 3 stati:
(1) stato del nodo nel quale non invia il contenuto ad ulteriori nodi;
(2) stato del nodo nel quale invia il contenuto ad un ulteriore nodo fornendo un'ampiezza di
banda effettiva pari a ω ≤ Ω (dove Ω è la banda totale disponibile offerta da ogni nodo);
(3) stato del nodo nel quale invia il contenuto a due ulteriori peers saturando completamente la
sua output bandwidth Ω.
Per capire il perché si verifica ciò, si assume che questo è vero per una data rete e si assume
che un nuovo peer entra nella rete e viene assegnato al (j+1)-esimo tier. Se vi è un nodo nel j-esimo
tier che sta già fornendo in uscita un'ampiezza di banda pari a ω < Ω allora tale nodo satura
completamente la sua output band alimentando il nuovo nodo fornendogli la sua banda residua che
è pari a Ω - ω (quindi tale nodo è nello stato (3)). Il quantitativo di banda rimanente ρ = 1 - (Ω - ω),
38
necessario al nuovo nodo per completare il contenuto, viene preso da ulteriori nodi presenti nel jesimo tier: considerando che la banda richiesta dal contenuto, (che è pari a 1), è superiore alla banda
Ω complessiva, che può fornire ogni nodo della rete, allora il nuovo nodo completa il contenuto
prellevando la banda rimanente da un numero di nodi pari a ρ / Ω (considerando che la banda
rimanente ρ è > Ω), e per tali nodi sarà completamente saturata la loro banda, mentre un ulteriore
nodo fornirà l'ultimo quantitativo di banda restante pari a ρ − ρ / Ω ⋅ Ω < Ω . Con queste
considerazioni, tutti i peer presenti nella rete sono in uno dei tre stati descritti precedentemente.
3 NUOVI ALGORITMI
Questa tesi si occupa della realizzazione di nuovi algoritmi per la creazione di peer to peer,
dove i nodi che andranno a formare la rete non presentano output band uguale ma differente. Quindi
viene meno un ipotesi del precedente algoritmo su canale asimmetrico. In questo modo, a partire
dall’algoritmo per la creazione di reti peer to peer per la diffusione di contenuti (descritto nel
capitolo precedente) si vogliono realizzare nuovi algoritmi per i quali tutti i nodi che accedono alla
rete possano avere valori di output band differenti.
I meccanismi di gestione dinamica della rete peer to peer, che verranno introdotto e descritti
nelle sezioni successive, hanno i seguenti obiettivi:
massimizzare il numero di nodi inseribili nella rete in funzione della banda del nodo
sorgente (Bs);
minimizzazione della banda totale disponibile che fornisce il nodo sorgente alla rete;
minimizzazione dei possibili costi delle ristrutturazioni che si hanno nella rete peer to
peer all’atto dell’inserimento di un nuovo nodo (questa funzione obiettivo è valida
solamente nei nuovi algoritmi di creazione della rete peer to peer che prevedono
l’inserimento dei peer nella rete con eventuale ristrutturazione locale di questa).
3.1 TOPOLOGIA DELLE RETI GENERATE: SEQUENZA DI NODI CHE
ACCEDONO ALLA RETE
Nella rete peer to peer di diffusione del contenuto che si va a considerare, il nodo sorgente
emette il contenuto mentre i nodi utente, o anche detti peer, sono in grado di accettare stream
parziali (o contenuti parziali) provenienti da più di un nodo attraverso il loro collegamento
d'ingresso e di ridistribuire tale contenuto ad uno o più ulteriori peer attraverso il loro link di uscita.
39
Questo crea una rete di distribuzione del contenuto modellata attraverso un grafo diretto
orientato dalla sorgente. Tale grafo deve essere creato ed aggiornato dinamicamente quando un
nuovo peer entra nella rete.
Gli algoritmi che vengono proposti, analizzati e descritti nelle sezioni successivi, non
contemplano l’ipotesi per la quale tutti i nodi che accedono alla rete sono caratterizzati da uno
stesso valore di output band e quindi si suppone che tali nodi possano avere valori di output band
differenti. Inoltre l’output band dei nodi che accedono alla rete possono avere valori superiori
all’unità ossia superiori alla banda normalizzata richiesta dal contenuto.
Per generare la sequenza di nodi che accedono alla rete è stato implementato un algoritmo
basandosi sulle seguenti considerazioni: come già specificato la caratteristica fondamentale dei nodi
è rappresentata dal fatto che essi possono avere un valore di output band qualunque anche superiore
all’unità. Quindi effettuando la generazione della sequenza dei nodi che accedono alla rete si
potrebbe pensare di generare un sequenza di peer aventi valori di output band casuali, ed in
particolare uniformemente distribuite tra una banda minima (definita come la banda del contenuto
multimediale divisa per un parametro K≥2) ed una banda massima (definita come la banda del
contenuto moltiplicata per un parametro m≥1). Ma in questo modo molti nodi della sequenza
avrebbero output band superiori alla banda del contenuto multimediale da diffondere e quindi
applicando uno qualunque dei successivi algoritmi si otterrebbe che: all’aumentare della banda
fornita dal nodo sorgente la rete continuerebbe ad accettare nodi. In questo modo non si
verificherebbe mai la situazione nella quale la rete non è più in grado di accettare nodi e quindi non
si riuscirebbe a stabilire il numero massimo di nodi inseribili nella rete, dove questo valore
rappresenta un parametro fondamentale per il confronto dei vari algoritmi.
Quindi per eliminare tale problema è stato implementato un algoritmo di generazione della
sequenza di nodi che vogliono accedere alla rete, nel quale ogni nodo della sequenza ha:
una data percentuale Pc1 di possibilità di avere un output band < 1 (ossia della banda
richiesta dal contenuto);
una data percentuale Pc2 di possibilità di avere una output band ≥ 1 e < 2;
ed una data percentuale Pc3 (pari a 100%-Pc1-Pc2)di possibilità di avere una output
band ≥ 2.
Occorre notare che Pc1 + Pc2 + Pc3 = 100%.
Un esempio di valori per i parametri Pc1, Pc2 e Pc3 è rappresentato dal seguente caso, nel
quale ogni nodo della sequenza che viene generata ha:
il 75% delle possibilità di avere una output band <1;
il 15% delle possibilità di avere una output band ≥ 1 e < 2;
40
e il 10% delle possibilità di avere una output band ≥ 2.
Sfruttando questa strategia per generare i nodi che vogliono accedere alla rete si limita il
numero di peer che hanno una output band elevata (ossia ≥ 1).
Con percentuali Pc1 elevate (ossia ≥ 75%) , Pc2 dell’ordine di 20% e Pc3 dell’ordine delle
decine (ossia da 5 a 10) si nota che la sequenza di nodi generati porta la rete nello stato in cui essa
non è più in grado di accettare ulteriori nodi. Quindi in questa situazione si è in grado di stabilire il
numero massimo di nodi inseribili nella rete.
L’algoritmo di generazione della sequenza dei nodi prevede:
come parametri di ingresso:
o il fattore moltiplicativo attraverso il quale si stabilisce il valore massimo di
output band che i vari peer generati possono assumere;
o il fattore di divisione attraverso il quale si stabilisce il valore minimo di output
band che i vari nodi possono assumere;
o il numero di peer che vogliono accedere alla rete (numNodi);
o e le due percentuali di possibilità Pc1 e Pc2; occorre notare che Pc3 non viene
richiesto come parametro d’ingresso poiché lo si ricava considerando che Pc1 +
Pc2 + Pc3 = 100%; quindi Pc3 = 100% – (Pc1 + Pc2);
come risultato si ottiene un file di testo contenente le output band dei peer che vogliono
accedere alla rete.
L’algoritmo può essere descritto attraverso il seguente pseudocodice:
…
int Bmax=Bc*fattMolt;
int Bmin=(int) (((double) Bc)/((double) fattDiv));
Random rm=new Random();
//tale divisione fornisce l’intero inferiore come risultato
Random pRm=new Random();
for (int k=0;k<numNodi;k++)
//ciclo for di generazione delle bande di upload dei nodi che tentano di entrare nella rete peer to peer
{
//si deve generare un numero random che va da 0 a 99 (facendo random 100)
int randomPercentuale=pRm.nextInt(100);
int value=Bmin;
if (randomPercentuale<Pc1) //allora si deve generare un numero casuale
//con valori tra Bmin e Bc con il valore generato che va da Bmin a
//Bmax e quindi si generano numeri finchè non si ottiene un numero < Bc
{ do
{ value=generateRandom(Bmax,Bmin,rm);
}while(value>=Bc);
Figura 5
}//end if
41
else if((randomPercentuale>=Pc1)&&(randomPercentuale<(Pc1+Pc2)))
{ //allora si deve generare un numero casuale con valori >=Bc e <2*Bc e siccome il valore generato
//va da Bmin a Bmax e quindi si generano numeri finché non si ottiene un numero >=Bc e < 2*Bc
do
{ value=generateRandom(Bmax,Bmin,rm);
}while((value<Bc)&&(value>=(2*Bc)));
}//end if
else if (randomPercentuale>=(Pc1+Pc2))
{ //allora si deve generare un numero casuale con valori >=2*Bc e siccome il valore generato va
//da Bmin a Bmax e quindi si generano numeri finché non si ottiene un numero >= 2*Bc
do
{ value=generateRandom(Bmax,Bmin,rm);
}while(value<(2*Bc));
}//end if
< scrittura sul file di output della variabile value appena generate >
}//end for
Figura 6
Questo algoritmo, per ogni nodo che accede alla rete, genera la relativa output band nel
seguente modo:
1. viene generato un numero casuale uniformemente distribuito tra 0 e 99;
2. si confronta questo valore casuale con i parametri Pc1 e Pc2:
a. se il valore casuale è < di Pc1 allora si genera un valore di output band casuale
uniformemente distribuito tra la banda minima (inclusa) e la banda del
contenuto multimediale (esclusa);
b. se il valore casuale è ≥ Pc1 e < Pc2 allora si genera un valore di output band
casuale uniformemente distribuito tra la banda del contenuto (inclusa) e il
doppio della banda del contenuto (esclusa);
c. se invece il valore casuale è ≥ Pc1 + Pc2 allora si genera un valore di output
band casuale ≥ del doppio della banda richiesta dal contenuto multimediale
stesso;
3. il valore di output band così generato viene scritto nel file di testo contente i valori di
output band della sequenza di nodi che vogliono accedere alla rete.
42
IMPLEMENTAZIONE DELL’ALGORITMO
L’algoritmo di generazione della sequenza dei nodi è stato implementato in ambiente Java. Si
hanno due implementazioni per questo algoritmo poiché:
la prima implementazione “NodeSeqGen.java” è utilizzata per generare un solo file di
testo, contenente la sequenza di nodi che vogliono accedere alla rete. Tale sequenza è
generata specificando, in modo iterativo da standard input, i seguenti parametri: banda
fornita dal nodo sorgente non normalizzata (rappresentata in kbit/sec); il fattore
moltiplicativo con il quale si fissa la banda massima che i nodi possono assumere; il
fattore di divisione con il quale si fissa la banda minima che i nodi possono assumere; il
numero di nodi da generare in questa sequenza; e le percentuali Pc1 e Pc2. Con
l’esecuzione di questo componente software si ottiene come risultato un file di testo
(con nome: “NodeSequencePc1=<valore di Pc1>Pc2=<valore di Pc2>.txt” ) avente:
nella prima riga la banda necessaria per la diffusione del contenuto (non normalizzata)
e nelle righe successive le output band, generate in maniera pseudocasuale , dei vari
nodi che vogliono accedere alla rete. Questo file è utilizzato per analizzare i primi
quattro algoritmi per la creazione delle reti peer to peer, poiché questi vengono
confrontati analizzando il loro comportamento in termini di: numero di nodi inseribili,
stima del costo delle ristrutturazioni e banda totale residua al variare della banda fornita
dal nodo sorgente, mantenendo inalterata la sequenza di nodi che vogliono accedere
alla rete ossia utilizzando lo stesso file di testo contenente la sequenza di nodi (si veda
la sezione 4.1);
la seconda implementazione “NodeSeqGen1_1.java” è utilizzata per generare una
successione di file di testo, contenenti ciascuna una sequenza di nodi che vogliono
accedere alla rete. Questa successione di file (dove ogni file rappresenta una
successione di nodi) è generata specificando, in modo interativo da standard input, i
seguenti parametri: banda fornita dal nodo sorgente non normalizzata (rappresentata in
kbit/sec); il fattore moltiplicativo con il quale si fissa la banda massima che i nodi
possono assumere; il fattore di divisione con il quale si fissa la banda minima che i nodi
possono assumere; il numero di nodi da generare in ciascuna sequenza; e la percentuale
iniziale Pc1_init, inoltre non è necessari avere anche un valore iniziale per Pc2 poiché
si suppone che Pc2 sia pari a 100-Pc1, mentre Pc3 è sempre pari a 0. Con l’esecuzione
di questo componente software si ottiene come risultato la creazione di un dato numero
di file di testo ossia: viene generato un file di testo (contente una sequenza di nodi
rappresentati dalle relative output band) per ogni possibile valore che può assumere la
43
coppia di parametri (Pc1,Pc2), dove l’insieme di valori che questa coppia può assumere
è rappresentato da: {( Pc1, Pc 2), ( Pc1 + 1, Pc 2 − 1),..., (99,1)} . Questa sequenza di file è
utilizzata per analizzare gli ultimi due algoritmi per la creazione delle reti peer to peer,
poiché questi vengono confrontati analizzando il loro comportamento in termini di:
numero di nodi inseribili, stima del costo delle ristrutturazioni, banda totale residua e
numero di nodi in attesa al variare del parametro Pc1 (si veda la sezione 4.2).
I file sorgenti “NodeSeqGen.java” e “NodeSeqGen1_1.java” sono compilati, a linea di
comando, nel seguente modo:
E:\Tesi_src>javac NodeSeqGen.java
E:\Tesi_src>javac NodeSeqGen1_1.java
Figura 7
I file .class generati da tale compilazione vengono eseguiti nel seguente modo:
E:\Tesi_src>java NodeSeqGen
…
<esecuzione del software>
…
E:\Tesi_src>java NodeSeqGen1_1
…
<esecuzione del software>
Figura 8
…
Questi due componenti software generano dei file di testo caratterizzati dalla seguente
struttura:
NodeSequencePc1=<valore di Pc1>Pc2=<valore di Pc2>.txt
<La prima riga contiene la banda non normalizzata, richiesta dal contenuto>
<La seconda riga contiene l’output band non normalizzata del primo nodo>
<La terza riga contiene l’output band non normalizzata del secondo nodo>
…
<L’n-esima riga contiene l’output band non normalizzata dell’n-esimo nodo>
Figura 9
Esempio di file di testo, generato dai due componenti software appena descritti:
44
NodeSequencePc1=75 Pc2=25.txt
48
32
27
15
…
Figura 10
22
3.2 PRIMO ALGORITMO DI PEER TO PEER: ALGORITMO MAZZINI /
ROVATTI ADATTATO ALLE NUOVE CONDIZIONE DI RETE
Il primo algoritmo, per la creazione di reti peer to peer atte alla diffusione di contenuti, è
derivato dall’algoritmo descritto nel capitolo 2 con adattamento alle nuove condizioni di rete:
i nodi che vogliono accedere alla rete hanno input band sufficiente per acquisire il
contenuto;
ed hanno output band caratterizzate da valori diversi.
Quindi modificando e generalizzando opportunamente le condizioni dell’algoritmo di peer to
peer Mazzini/Rovatti
[9]
si è in grado di inserire nella rete nodi con output band diverse. Le
assunzioni e le ipotesi di questo algoritmo sono le seguenti:
si suppone che la banda richiesta per la diffusione del contenuto sia normalizzata
all’unità;
l’output band dei differenti peer che accedono alla rete è pari a Ωi, per i che va da 1 al
numero di nodi della rete stessa.
Secondo questo algoritmo di inserimento nodi nella rete si considera che: la rete peer to peer di
distribuzione del contenuto è organizzata in "tiers" o file numerate a partire da 1. I peer contenuti
nel primo tier sono alimentati dal nodo sorgente. Mentre i peers del j-esimo tier ricevono il
contenuto solamente dai peer presenti nel (j-1)-esimo tier. Il numero di tiers presenti nella rete di
distribuzione del contenuto è indicato dal parametro T.
Si indica con Pj il numero di peers presenti nel j-esimo tier. Considerando che la banda del
contenuto è normalizzata all'unità allora la banda complessiva richiesta per distribuire il contenuto
al j-esimo tier è Pj. Mentre considerando che ogni nodo fornisce una output band pari a Ωi (con i
che varia nell’insieme dei nodi della rete) allora l'intera ampiezza di banda messa a disposizione dal
45
Pj −1
j-esimo tier è pari a
∑ Ωi . L'ampiezza di banda fornita in output dal nodo sorgente è data dal
i =0
parametro P1, mentre la banda totale che fornisce il nodo sorgente per alimentare il primo tier è
indicata dal parametro B. Inoltre si suppone che la banda B sia finita.
Il passo elementare, è "l'inserimento di un peer nel j-esimo tier se è possibile" e questa
porzione di codice è indicata con A(j). Un pseodocodice per la procedura A(j) è il seguente:
case j = 1
if ( p1 + 1) < B then p1 + +; else failed
case j = 2, …, T
p j −1 −1
if
∑ Ωi ≥
( p j + 1) then p j + +; else failed
i =0
(somma sui Pj-1 peer
del j-1 – esimo tier)
case j = T+1
pT
if
∑ Ωi ≥ 1 then
pT +1 = 1 ; T++; else failed
i =0
(somma sui PT peer
del T – esimo tier)
Figura 11
L’algoritmo che effettua l’inserimento di un nuovo peer nella rete è rappresentato dal seguente
pseudocodice:
for j=1 to T+1
if A(j) not failed then stop
next
failed
Figura 12
Questo algoritmo prova ad aggiungere il nuovo peer nel tier caratterizzato dal ritardo minimo,
ossia nel tier più vicino possibile al nodo sorgente, in modo tale da soddisfare i vincoli
sull'ampiezza di banda e quindi tale algoritmo viene terminato con insuccesso (fallisce) se non si
46
possono alimentare ulteriori peer da parte dei peer che vi sono nei vari tiers della rete di diffusione
del contenuto.
Gli algoritmi di inserimento nodi nella rete, visti nel capitolo 2, producono una struttura nella
quale ogni nodo alimenta al massimo due ulteriori nodi nel tier successivo; mentre nell’algoritmo
descritto in questo capitolo non vi è questa limitazione poiché i nodi che accedono alla rete possono
avere una output band superiore all’unità (ossia superiore alla banda richiesta dal contenuto
normalizzata a 1).
Questo algoritmo è sub-ottimo nel numero di peer serviti. Infatti, si potrebbe racimolare
l'output band non utilizzata dai differenti tier per alimentare un nuovo nodo o in alternativa si
potrebbe fare la seguente considerazione: data una sequenza di nodi con output band diverse, questi
nodi accedono successivamente alla rete e questa accetta nodi finché l’ultimo tier che ha banda a
disposizione è in grado di alimentare un nuovo nodo; quindi la rete non è più in grado di accettare
nodi quando l’ultimo tier disponibile non ha una banda sufficiente (ossia ≥ 1) in grado di alimentare
un nuovo nodo.
Quindi in questo caso si può notare che:
1.
data una sequenza di nodi con le seguenti output band: B1, B2, … , Bn con
B1<B2<…<Bn≤Bc=1 allora si suppone che il numero massimo di nodi che la rete è in
grado di accettare sia pari a K;
2.
se invece si considerano gli stessi nodi con le stesse output band ma con una sequenza
di accesso dei nodi alla rete tale per cui vengono inseriti prima i peer con output band
maggiore, ossia se i nodi con bande di output maggiori vanno a finire nei tiers più
vicini al nodo sorgente, allora si verifica che il numero massimo di nodi che la rete
peer to peer è in grado di accettare risulterà essere > K o al più uguale a K.
In questo modo la situazione ideale sarebbe quella di avere un algoritmo che inserisca, di volta
in volta, il nuovo nodo nella rete, determinando in che tier inserirlo in base alla sua output band. Per
tale motivo è stato ideato l’algoritmo descritto nella sezione 3.3.
3.3 SECONDO
ALGORITMO
RISTRUTTURAZIONE
DI
LOCALE
PEER
DELLA
TO
RETE
PEER
CON
CON
BLOCCO
ALL’INGRESSO
Il secondo algoritmo per la creazione di reti peer to peer derivata dal primo algoritmo
presentato con l’aggiunta di un’eventuale ristrutturazione locale, nel caso dell’inserimento di un
nuovo nodo.
47
In questo algoritmo si cercano di risolvere le limitazioni che affliggono il primo algoritmo
presentato in questo capitolo ed ha il seguente comportamento: dato un nodo con output band pari a
Bj allora tale nodo viene inserito:
nel primo tier se Bj è superiore al output band del peer avente banda minima per tale
tier;
altrimenti il nodo viene inserito nel tier avente output band minima < Bj ed avente
output band minima del tier precedente ≥ Bj.
Per notazione il tier dove viene inserito il nodo considerato viene indicato come tier i-esimo.
Quindi in questa situazione se, per i requisiti di banda del i-esimo tier il nodo da inserire può
essere direttamente inserito nell’i-esimo tier stesso allora lo si inserisce senza effettuare
ristrutturazioni della rete.
Se invece nel tier i-esimo non possono essere inseriti ulteriori nodi, per i requisiti di banda
(poiché la banda disponibile nel tier i-esimo è inferiore all’unità), allora si determina il nodo Nm
avente banda in output minima presente nel tier i-esimo, lo si estrae dal tier e lo si sostituisce con il
nuovo nodo.
In questo modo il nodo Nm estratto viene inserito nel tier successivo, inserendolo direttamente
pi −1
nel tier se vi è posto (ossia se ∑ Ω k ≥ ( pi +1 + 1) ), altrimenti si determina il nodo avente output band
k =0
minore, in tale tier, e questo viene sostituito con il nodo Nm. Tale procedura ricorsiva si termina se:
1.
il nodo che deve essere inserito nel tier a cui si è giunti può essere inserito
direttamente (senza ristrutturazione locale) poiché i requisiti di banda lo consentono;
2.
oppure se si giunge all’ultimo tier e si riesce ad inserire il nodo prelevato dal tier
precedente, poiché per l’ultimo tier sono garantiti i requisiti di banda richiesti dal
contenuto multimediale (ossia banda totale in upload dell’ultimo tier ≥ 1);
3.
oppure se la rete non è in grado di accettare più nodi; ciò si verifica se, con la
procedura ricorsiva, si giunge all’ultimo tier e se per questo non sono garantiti i
requisiti di banda richiesti dal contenuto multimediale (ossia output band totale
dell’ultimo tier < 1). Quindi a causa di tale evento prima di effettuare l’inserimento si
controllano tutte le condizioni sui requisiti di banda che vengono considerate a causa
dell’inserimento ricorsivo dei nodi.
L’algoritmo di inserimento in pseudocodice auto commentato è il seguente:
48
int insertNodeInTiers(Nodo n,int B,int Bc,Vector tiers)
{//procedura che restituisce -1 se l’inserimento fallisce, mentre restituisce il costo complessivo
//della ristrutturazione (≥0) che si può verificare a seguito dell’inserimento del nuovo nodo
int T=tiers.size();
/*(1) si deve determinare in che tier dei T tiers inserire il nodo*/
int posTier=-1; //posizione del tier dove inserire il nuovo nodo e va da 1 a T+1
//occorre notare che pero' i tier hanno indice da 0 a T
for (int j=1;j<=T+1;j++)
{ posTier=functionB(j,n,B,Bc,tiers);
if (posTier!=-1)
{/*posizione trovata*/
break; }//end if
}//end for
// inserimento del nuovo nodo nell’ultimo tier
if (posTier==(T+1)) {
return functionAA(T+1,n,B,Bc,tiers,0);
}//end if
//altrimenti si inserisce il nuovo nodo nel tier di poszione posTier-1
//e se non c'e' posto in posTier si sposta il nodo con output band minima di tale tier
//nel tier successivo e si inserisce il nuovo nodo nel tier considerato,
//tale procedura si ripete in maniera ricorsiva (functionAA)
//--- per determinare se tale inserimento va a buon fine si utilizza una procedura che
//--- testa ricorsivamente l'inserimento del nodo nel tier considerato (posTier-1)
//--- e se necessario effettua un test ricorsivo ossia: se il tier dove viene
//--- inserito il nuovo nodo è pieno allora si stabilisce se il nodo con output band
//--- minima può essere inserito nel tier successivo e così via in maniera ricorsiva
int incrementoBanda=0; //incremento di banda iniziale per il tier successivo
// a causa del test di inserimento di un nuovo nodo nel tier corrente
boolean result=testInsert(posTier,n,B,Bc,tiers,incrementoBanda);
if (result==true) {//allora l'inserimento può essere effettuato poiche' non si genera la
// saturazione della rete ossia la rete è in grado di accettare ulteriori nodi
return functionAA(posTier,n,B,Bc,tiers,0); //l’ultimo parametro di questa
//procedura è un parametro iniziale di conteggio che rappresenta il costo totale delle
//ristrutturazioni che si hanno a seguito dell'inserimento del nodo
}//end if
else{
/*se invece la funzione di testInsert da esito negativo allora la rete è satura e
quindi return -1*/ return -1; }//end else
Figura 13
}
49
/* Procedura che determina in che tier inserire il nuovo Nodo (con tiers numerati da 1 a T) */
int functionB(int j,Nodo n,int B,int Bc,Vector tiers)
{int T=tiers.size();
if (j==1) {//si determina se il nodo ha una output band maggiore della banda minima del
//primo tier o 0-esimo tier (in OR con il vincolo di banda)
if(((Output Band Minima del (j-1)-esimo tier)<n.getUploadBand()) OR ( Bc ⋅ ( p 0 + 1) < B ))
{ /*se è soddisfatta questa condizione allora si restituisce j*/ return j; }
else{/*il tier ha banda minima di output >= a quella del nodo considerato e quindi tale tier non
va bene per inserire il nuovo nodo*/ return -1; }//end else
}else
if ((j>=2)&&(j<=T))
{/*j-1 varia dal tier 1-esimo a (T-1)-esimo: si determina se il nodo ha output band maggiore
della output band minima del tier (corrente) j-1-esimo e minore o uguale al massimo tra l’output
band minima del tier precedente e l’output band massima del tier corrente*/
int minTierPrec=<Output band Minima del tier precedente, (j-2)-esimo>;
int maxTierCurr=<Output band massima del tier corrente, (j-1)-esimo>;
int maxBandTier=max(minTearPrec,maxTearCurr);
if ( (((Output Band Minima del (j-1)-esimo tier)<n.getUploadBand()) &&
p j − 2 −1
(n.getUploadBand()<=maxBandTier) ) || (
∑ Ωi ≥
Bc ⋅ ( p j −1 + 1) ) )
i =0
{/*se è soddisfatta la condizione allora si restituisce il numero del tier dove inserire il
nodo che è pari a j*/ return j; }//end if
else{/*il tier ha output band minima ≥ di quella del nodo considerato e quindi tale tier
non va bene per inserire il nuovo nodo*/ return -1;
}//end else
}//end if
else if (j==(T+1))
{/*quindi se si è giunti al T+1-esimo tier allora il nodo deve essere aggiunto ad un nuovo tiers
che è il (T+1)-esimo*/ return T+1;
}//end if
return -1; //si giunge qua in fondo solo in caso di errore
}
Figura 14
50
int functionAA(int j,Nodo n,int B,int Bc,Vector tiers,int CostoRicIn)
{int T=tiers.size();
if (j==1){//si testa la condizione relativa ai requisiti di banda sul primo tier o 0-esimo tier
if ( Bc ⋅ ( p 0 + 1) < B )
{
<allora si aggiunge il Nodo n nel primo tier o 0-esimo tier>
return CostoRicIn+0; //inserimento effettuato con successo
}
else{/* se la condizione sui requisiti di banda non è soddisfatta allora si estrae il nodo
con output band minima e si aggiunge il nuovo nodo nel primo tier*/
Nodo nodoRimosso=<nodo avente output band minima presente nel tier (j-1)-esimo>;
<si elimina il nodo avente output band minima dal tier (j-1)-esimo>
int CostoRist = <N° Nodi padri del nodoRimosso> + <N° Nodi figli del nodoRimosso>;
<si sostituisce il nodoRimosso con il nuovo nodo n imponendo che n abbia come nodi
padri quelli del nodoRimosso e come nodi figli quelli del nodoRimosso stesso>
/* si imposta la banda residua che può fornire il nodo n ad ulteriori successivi nodi */
<Output band residua del nodo n> = <Output band totale disponibile del nodo n> –
(<Output band totale disponibile del nodo Rimosso> – <Output band residua del
nodoRimosso>);
nodoRimosso.emptyLists(); /*Svuotamento della lista dei padri del nodoRimosso*/
<Output band residua del nodoRimosso> = <Output band totale disponibile del nodo
rimosso>; /*si restituisce al nodoRimosso tutta la banda che può fornire*/
<(a) scansione del tier precedente considerando che: per ogni nodo del tier precedente,
nella lista dei figli di tale nodo si deve sostituire l'Id del nodoRimosso con l’Id del nuovo
nodo n >
<b) scansione del tier successivo (se c'e') considerando che: per ogni nodo del tier
successivo, nella lista dei padri di tale nodo si deve sostituire l'Id del nodoRimosso
con l'Id del nuovo nodo n>
/*si aggiunge il nuovo nodo al tier j-esimo (o j-1 esimo in base, da dove parte l'indice)*/
((Tier) tiers.elementAt(j-1)).add(n);
/* si reinvoca ricorsivamente la functionAA relativamente al nodoRimosso e
relativamente al tier successivo j+1 */
return functionAA(j+1,nodoRimosso,B,Bc,tiers,CostoRist+CostoRicIn);
}//end else
Figura 15
}//end if
51
else if ((j>=2)&&(j<=T))
{//si testa la condizione relativa ai requisiti di banda sul (j-1)-esimo tier
p j − 3 −1
if (
∑ Ωi ≥
Bc ⋅ ( p j −1 + 1) ){<allora si aggiunge il Nodo n nel (j-1)-esimo tier stabilendo i
i =0
suoi nodi padri presenti nel tier precedente, (j-2)-esimo>
return CostoRicIn+0; //inserimento effettuato con successo
}
else{/* se la condizione sui requisiti di banda non è soddisfatta allora si estrae il nodo
con output band minima e si aggiunge il nuovo nodo nel tier (j-1)-esimo*/
Nodo nodoRimosso=<nodo avente output band minima presente nel tier (j-1)-esimo>;
<si elimina il nodo avente output band minima dal tier (j-1)-esimo>
int CostoRist = <N° Nodi padri del nodoRimosso> + <N° Nodi figli del nodoRimosso>;
<si sostituisce il nodoRimosso con il nuovo nodo n imponendo che n abbia come nodi
padri quelli del nodoRimosso e come nodi figli quelli del nodoRimosso stesso>
/*si imposta la banda residua che può fornire il nodo n ad ulteriori successivi nodi */
<Output band residua del nodo n> = <Output band totale disponibile del nodo n> –
(<Output band totale disponibile del nodo Rimosso> – <Output band residua del
nodoRimosso>);
nodoRimosso.emptyLists(); /*Svuotamento della lista dei padri del nodoRimosso*/
<Output band residua del nodoRimosso> = <Output band totale disponibile del nodo
rimosso>; /*si restituisce al nodoRimosso tutta la banda che può fornire*/
<(a) scansione del tier precedente considerando che: per ogni nodo del tier precedente,
nella lista dei figli di tale nodo si deve sostituire l'Id del nodoRimosso con l’Id del nuovo
nodo n >
<b) scansione del tier successivo (se c'e') considerando che: per ogni nodo del tier
successivo, nella lista dei padri di tale nodo si deve sostituire l'Id. del nodoRimosso
con l'Id del nuovo nodo n>
/*si aggiunge il nuovo nodo al tier j-esimo (o j-1 esimo in base, da dove parte l'indice)*/
((Tier) tiers.elementAt(j-1)).add(n);
/*si reinvoca ricorsivamente la functionAA relativamente al nodoRimosso e
relativamente al tier successivo j+1*/
return functionAA(j+1,nodoRimosso,B,Bc,tiers,CostoRist+CostoRicIn);
}//end else
Figura 16
}//end if
52
else if (j==(T+1))
{/*si testa la condizione relativa ai requisiti di banda per poter allocare un nuovo tier nel quale
inserire il nodo n*/
/*se l'ultimo tier ossia il tier (T-1)-esimo offre una banda sufficiente a un nuovo utente nel tier T,
da aggiungere, allora si crea il T-esimo tier e si inserisce il nuovo nodo in esso ossia:*/
pT −1
if ( ∑ Ωi ≥ Bc )
i =0
{
<allora si aggiunge il Nodo n nel T-esimo tier stabilendo i suoi nodi padri presenti
nel tier precedente, (T-1)-esimo>
return CostoRicIn+0; //inserimento effettuato con successo
}
else
{ /* se il vincolo di banda non è soddisfatto allora l’inserimento del nuovo nodo non ha
successo e di conseguenza la rete non è in grado di accettare ulteriori nodi */
return -1;
}//end else
}//end if
}//fine procedura
Figura 17
Il fatto che il nuovo nodo venga inserito in un tier sostituendo il nodo a banda minima del tier
considerato con il nuovo nodo stesso, rappresenta una situazioni di ristrutturazione locale della rete
che si propaga eventualmente ai tier successivi.
Il costo della ristrutturazione o sostituzione di due nodi viene stimata nel seguente modo:
[Stima del costo di ristrutturazione] = [(1)° di nodi padri del nodo da sostituire] + [(2) °
di nodi figli del nodo da sostituire]
Figura 18
Dove:
(1) = “ si stima il numero di comunicazioni verso i nodi padri necessarie per indicare che
il nodo figlio è cambiato con il numero di nodi padri del nodo da sostituire”;
(2) = “si stima il numero di comunicazioni verso i nodi figli necessarie per indicare che il
nodo padre è cambiato con il numero di nodi figli che ha il nodo da sostituire”.
Il costo totale della ristrutturazione relativa all’inserimento di un nuovo nodo è dato dalla
somma delle stime dei costi di ristrutturazione che si hanno a causa:
53
dell’inserimento del nuovo nodo in un tier con eventuale sostituzione del nodo a banda
minima con il nuovo nodo stessa;
e a causa della propagazione degli inserimenti, con eventuale sostituzione, dei nodi
estratti dai tier successivi a quello in cui è stato inserito il nuovo nodo.
In altri termini: considerando che il costo di una sostituzione è pari alla somma tra il numero
dei nodi figli ed il numero dei nodi padri del nodo che sostituisco con quello nuovo o con quello a
banda minima proveniente dal tier precedente, allora il costo complessivo dell’inserimento di un
nuovo nodo è dato dalla somma di tutti questi costi di sostituzione, necessari per portare a termine
l’inserimento del nuovo nodo.
Quindi tale costo è calcolato ricorsivamente, se vi sono dei nodi da fare scorrere nei tier
successivi a causa dell'inserimento del nuovo nodo; in questi termini, il costo dell’inserimento del
nuovo nodo con ristrutturazioni è dato dalla somma dei costi di tutte le sostituzioni che si devono
effettuare per portare a termine l’inserimento.
Per permettere il calcolo del costo dello scambio di due nodi, per ogni nodo si mantiene:
la lista dei nodi da cui riceve il contenuto multimediale;
e la lista dei nodi a cui fornisce il contenuto.
In questo modo si stima il costo dello scambio di due nodi come la somma del numero di nodi
padri con il nodi figli, che il peer da sostituire deve interpellare per indicargli il nuovo nodo che lo
sostituisce ossia:
[Costo dello scambio] = [N° nodi padri] + [N° nodi figli]
Indicando con Ci l’i-esimo scambio, necessario per poter inserire il nuovo nodo nella rete,
allora il costo totale di queste sostituzioni è pari a:
[Costo Totale della ristruttur azione ] = ∑ Ci ,per i che varia su tutti gli scambi effettuati.
i
Questo algoritmo presenta, rispetto al primo algoritmo, un possibile aumento del numero di
nodi inseribili nella rete a scapito di un onere rappresentato dal costo delle varie ristrutturazioni
locali della rete che potenzialmente si possono verificare ad ogni inserimento.
Sia nel primo algoritmo che nel secondo algoritmo presentato vale la seguente considerazione:
siccome inserendo un nodo in un tier si considera solo la banda ancora disponibile del solo tier
precedente e non l’intera banda disponibile di tutta la rete allora, se la banda del tier precedente non
è sufficiente e se la procedura di inserimento ricorsivo dei nodi sostituiti fallisce si verifica che il
nuovo nodo non è inseribile anche se la banda totale disponibile di tutti i tier è ≥ 1 ossia
teoricamente la rete sarebbe in grado di alimentare un nuovo nodo; per capire meglio questa
considerazione è sufficiente considerare il seguente esempio:
54
Tier 1 BandaDisponibile1 < 1
Tier 2 BandaDisponibile2 < 1
…
Tier n BandaDisponibilen < 1
Figura 19
Quindi in questo caso la rete non è in grado di accettare più nodi anche se:
BtotaleDisponibile = BandaDispnobile1 + … + BandaDispnobilen ≥ 1
Figura 20
ossia anche se teoricamente la rete sarebbe in grado di alimentare almeno un nodo in più.
Quindi per eliminare questo problema è stato introdotto il terzo algoritmo per la creazione di
reti peer to peer.
3.4 TERZO ALGORITMO SENZA RISTRUTTURAZIONE LOCALE
Il terzo algoritmo è ottenuto considerando che si potrebbe racimolare l'output band non
utilizzata dai differenti tier per alimentare un nuovo nodo anche se la strutturazione in tier della rete
non consentirebbe l’inserimento di un nuovo peer.
In questo algoritmo di peer to peer l’inserimento di nuovi nodi nella rete è effettuato senza la
ristrutturazione locale della rete stessa.
Quindi per eliminare il problema di cui è affetto il secondo algoritmo è stato introdotto il terzo
algoritmo nel quale:
la rete è rappresentata da una lista di nodi, dove ogni nodo è caratterizzato da un
identificativo (coincidente con la posizione del nodo nella lista), dalla sua output band
disponibile e la lista degli identificativi dei nodi figli;
inizialmente, nella lista dei nodi vi è solo il nodo sorgente, avente identificativo pari a 0
(essendo in posizione 0 della lista dei nodi che formano la rete);
nel momento in cui si inserisce un nuovo nodo N, questo richiede, ai nodi presenti nella
rete, un quantitativo di banda in modo da raggiungere la banda richiesta dal contenuto
cioè:
o il nuovo nodo scandisce la sequenza dei nodi della lista, a partire dal primo,
chiedendo ad ogni nodo a cui giunge:
1. il massimo quantitativo di banda che gli può fornire, se l’output band
disponibile del nodo è inferiore al quantitativo di banda richiesta dal
contenuto non ancora ottenuto;
55
2. oppure solo il quantitativo di banda richiesta dal contenuto non ancora
ottenuto, se l’output band disponibile del nodo è superiore al
quantitativo di banda richiesta dal contenuto non ancora ottenuta;
o tale scansione termina quando:
1. il nuovo nodo N ha racimolato il quantitativo di banda richiesta per
ottenere il contenuto e conseguentemente viene aggiunto alla rete; quindi
in questo caso, i nodi della rete che forniscono della banda al nuovo
nodo, lo aggiungono alla lista dei propri figli e decrementano la loro
banda disponibile del quantitativo di banda che hanno fornito al nodo N;
2. oppure quando il nuovo nodo ha scandito tutta la lista dei nodi ma non
ha racimolato la banda richiesta dal contenuto e quindi la rete non è più
in grado di accettare il nuovo peer.
I vantaggi del terzo algoritmo, rispetto al secondo, sono i seguenti:
nel caso di inserimento di un nuovo nodo non vi sono possibili ristrutturazioni locali
della rete peer to peer;
nel caso in cui la rete non è in grado di accettare più nodi, la banda totale disponibile di
essa è sempre inferiore all’unità (ossia alla banda richiesta dal contenuto normalizzata a
1); per vedere tale fenomeno si vedano gli esempi descritti nel capitolo 4.
Lo svantaggio che si ha nel terzo algoritmo è dovuto al fatto che: modificando,
opportunamente,
l’algoritmo 3 di modo che l’inserimento dei nodi venga effettuato con una
eventuale ristrutturazione locale della rete, si ottiene un nuovo algoritmo che consente di aumentare
il numero massimo di nodi inseribili nella rete, a scapito di un onere dovuto alle ristrutturazioni.
3.4.1 DESCRIZIONE DETTAGLIATA DELL’ALGORITMO 3
Il terzo algoritmo gestisce l’inserimento di un nuovo nodo nella rete con le seguenti modalità:
ogni volta che vi è un nuovo nodo da inserire nella rete si verifica che tale peer interpella
successivamente tutti i nodi della rete finché non racimola tutta la banda che desidera, dove la
banda desiderata è pari alla banda richiesta dal contenuto.
Il terzo algoritmo è caratterizzato dalle seguenti strutture dati:
struttura dati nodo che contiene:
o l’output band complessiva che fornisce tale nodo (OutputBandTotale);
o l’output band attualmente disponibile, che è data dalla differenza tra l’output
band complessiva del nodo e quella che sta attualmente servendo ai propri nodi
figli (OutputBandDisponibile);
56
o la lista degli identificativi dei nodi figli, dove l’identificativo di un nodo
coincide con la posizione del nodo nella lista dei nodi che costituiscono la rete
peer to peer;
lista L dei nodi della rete peer to peer: ogni elemento di questa struttura dati è di tipo
nodo;
struttura dati che rappresenta un nodo padre che contiene:
o l’identificativo del nodo padre, che rappresenta la posizione di tale nodo nella
lista L;
o quantitativo di output band che il nodo padre fornisce al nuovo nodo N;
lista Lp dei nodi padri: ogni elemento di questa struttura dati è di tipo nodo padre.
Questa lista contiene le caratteristiche dei nodi padri del nuovo nodo da inserire.
Quindi nel terzo algoritmo di creazione della rete peer to peer adottata per la diffusione di
contenuti, si hanno le seguenti strutture dati ed ipotesi:
lista L dei nodi contenuti nella rete: tale lista viene inizializzata con il solo nodo
sorgente, prima di inserire un qualunque peer nella rete;
sia il nuovo nodo da inserire nella rete peer to peer;
sia Lp la lista che conterrà i nodi pari del nodo N: prima di eseguire l’algoritmo di
inserimento del nuovo nodo N, questa lista viene inizializzata a lista vuota;
si suppone che Bc sia la banda non normalizzata richiesta dal contenuto da diffondere;
si suppone di avere una variabile Br che rappresenta la banda totale che il nuovo nodo
N deve racimolare per riuscire ad acquisire il contenuto desiderato. Quindi Br viene
inizializzata al valore Bc;
si suppone di avere una variabile booleana denominata trovato che assume valore
“true” solamente quando il nodo N è riuscito ad acquisire, dai nodi correntemente
presenti nella rete, un quantitativo sufficiente di banda per ottenere il contenuto
richiesto (ossia quando Br diventa pari a 0). Quindi prima di eseguire l’algoritmo di
inserimento di un nuovo nodo tale variabile è inizializzata a false;
sia n il numero di nodi presenti nella rete, ossia il numero di elementi presenti nella
lista L.
Con queste ipotesi l’algoritmo di inserimento di un nuovo nodo nella rete è rappresentato dal
seguente pseudocodice:
57
for (int i=0;i<n;i++) //ossia per ogni nodo Ni appartenente a L
{
if (Ni.OutputBandDisponibile≥Br) then
{ Lp = Lp ∪ {(i, Br )}; //dove Br è la banda che il nodo Ni fornisce al nodo N
//ed i rappresenta l’identificativo del nodo Ni
trovato=true;
Br=0;
break;
//uscita dal ciclo di scansione dei nodi avendo trovato
//tutta la banda richiesta
}
else if (Ni.OutputBandDisponibile<Br)AND(Ni.OutputBandDisponibile!=0) then
{//Ni fornisce tutta la banda che ha al nodo N quindi:
Lp = Lp ∪ {(i, i.OutputBandDisponibile)};
Br = Br – Ni.OutputBandDisponibile;
}//end else
}//end for
if (trovato==false) then <La rete non è in grado di accettare il nuovo nodo non avendo a
disposizione banda a sufficienza (ossia la banda totale disponibile è inferiore a Bc)>
else //ossia trovato uguale a true
{
<allora il nuovo nodo N è inseribile nella rete e quindi lo si inserisce attraverso la seguente
procedura>
< 1) inserimento del nodo nella rete:>
L = L ∪ {( Identifica tivo odo , Output band fornita dal nodo )};
//dove l’identificativo del nodo N è n, che rappresenta il numero di nodi presenti nella lista
// L
n++;
< 2) scansione della lista Lp dei nodi padri: “per ogni nodo padre si aggiunge N come figlio
e conseguentemente si decrementa la banda che ha a disposizione tale nodo padre in
base alla banda che gli fornisce al nodo N”>
for (k=0;k<Lp.size();k++) //dove Lp.size() = “è il numero di elementi della lista dei padri”
{
L.elementAt(Lp.elementAt(k).Id()).ListaFigli.add(Indetificativo_del_nodo_N);
58
/* Si aggiunge alla lista dei nodi figli, del nodo avente come posizione nella lista L
l’identificativo del k-esimo nodo padre di N, il nodo N stesso. In altri termini si
inserisce l’identificativo del nodo N nella lista dei nodi figli del k-esimo nodo padre
di N*/
L.elementAt(Lp.elementAt(k).Id()).OutputBandDisponibile=Lp.elementAt(k).OutputBand;
/*Si decrementa l’output band che fornisce il k-esimo nodo padre del quantitativo
di banda che tale nodo fornisce al nuovo nodo N*/
}//end for
}//end else
Questo algoritmo effettua l’inserimento di un nuovo nodo N, determinando i nodi, presenti
attualmente nella rete, che possono fornire al peer N il quantitativo di banda necessario per poter
acquisire il contenuto diffuso in questa rete peer to peer. Per fare ciò, si scandiscono tutti i nodi
della rete al fine di racimolare la banda necessaria al nodo N:
ciclo di scansione della lista dei nodi della rete: per ogni nodo Ni appartenente alla lista
L dei nodi della rete si effettuano i seguenti controlli:
o se la banda fornita dal nodo Ni è maggiore o uguale alla banda richiesta dal
nodo N allora si aggiunge nella lista dei nodi padri la coppia rappresentata
dall’identificativo del nodo Ni (che rappresenta la posizione di tale peer nella
lista L) e dalla banda che tale nodo fornisce ad N (in questo caso il nodo Ni
fornisce ad N tutta la banda di cui ha bisogno N stesso). Siccome tutta la banda
che il nodo N richiedeva è stata fornita dal peer Ni allora termina il ciclo di
scansione dei nodi presenti nella lista L. Inoltre viene posta la variabile trovato
al valore “true” per indicare che il nodo N è riuscito ad acquisire, dai nodi
correntemente presenti nella rete, un quantitativo sufficiente di banda per
ottenere il contenuto richiesto (ossia quando Br diventa pari a 0);
o se invece la banda disponibile che il nodo Ni può fornire non è nulla ed è
inferiore a quella richiesta dal nodo N (ossia è < Br) allora Ni fornisce ad N
tutta la banda che ha a disposizione. In questo modo si aggiunge nella lista dei
59
nodi padri la coppia rappresentata dall’identificativo del nodo Ni (che
rappresenta la posizione di tale peer nella lista L) e dalla banda che tale nodo
fornisce ad N (in questo caso il nodo Ni fornisce ad N tutta la banda che ha a
disposizione). Siccome in questa situazione il nodo N non è ancora riuscito ad
ottenere il quantitativo di banda necessario per acquisire il contenuto allora è
necessario continuare la scansione dei nodi presenti nella lista L.
se all’uscita del ciclo di scansione della lista dei nodi presenti nella rete la variabile
booleana trovato ha valore false allora la rete non è in grado di accettare il nuovo nodo,
poiché la banda totale disponibile della rete è inferiore alla banda richiesta per la
diffusione del contenuto;
se invece la variabile trovato ha valore true allora si inserisce il nuovo nodo nella lista
L, dei nodi della rete, e si scandisce la lista dei padri di N per effettuare la seguente
operazione: per ogni nodo padre Ni si aggiunge il peer N come figlio e
conseguentemente si decrementa la banda che Ni ha a disposizione di un quantitativo
pari alla banda che fornisce ad N.
3.4.2 SVANTAGGI DELL’ALGORITMO3 E INTRODUZIONE ALL’ALGORITMO4
La ristrutturazione che in questo algoritmo 3 non è impiegata può portare ad aumentare il
numero di nodi inseribili nella rete stessa cioè:
sia Bi l’output band del nuovo nodo da inserire nella rete;
sia BtotDisp l’output band disponibile dell’intera rete (ossia la somma delle output
band residue di tutti i nodi della rete);
se BtotDisp – [La banda del nodo a banda minima della rete] + Bi ≥ 1
(1)
allora il nuovo nodo può essere inserito nella rete con un’opportuna ristrutturazione
anche se l’attuale banda totale disponibile dell’intera rete è < 1.
Quindi questa situazione si verifica se la banda del nuovo nodo è talmente elevata che è in
grado di garantire la condizione (1).
In questo caso se la condizione (1) è verificata allora:
1.
si estrae dalla rete il nodo avente output band minima e lo si sostituisce con il nuovo
nodo Ni;
2.
il nodo estratto o sostituito viene reinserito nella rete secondo la procedura di
inserimento mostrata nella descrizione dell’algoritmo 3.
60
Quindi in base a queste considerazioni viene realizzato l’algoritmo 4. Anche in questo caso il
costo della ristrutturazione locale, dovuto alla sostituzione del nodo a banda minima con quello da
inserire è dato dalla seguente somma:
[Stima del costo di ristrutturazione] = [° di nodi padri del nodo da sostituire] + [° di
nodi figli del nodo da sostituire]
Figura 21
In ogni modo tali ristrutturazioni si verificano più di rado rispetto a quelle che si hanno
nell’algoritmo 2 poiché:
1.
nell’algoritmo 2 ogni volta che si inserisce un nuovo nodo si può verificare una
ristrutturazione locale;
2.
invece nell’algoritmo 4 (che è rappresenta un’evoluzione dell’algoritmo) si verifica
una ristrutturazione locale solamente quando la rete non è più in grado di accettare
nodi, ma il nuovo nodo che vuole accedere alla rete ha una output band talmente
elevata che rende vera la condizione (1), dove questa rappresenta la banda totale
disponibile della rete nel caso in cui nella rete si ha il nuovo nodo al posto del nodo a
banda minima.
3.4.3 NOTA IMPORTANTE
Occorre notare che negli algoritmi 2 e 4, che presentano ristrutturazioni locali, si potrebbe
pensare che:
se la rete non accetta più nodi poiché ha una banda totale disponibile < 1 allora si può
pensare di mettere in attesa tutti i nodi successivi che tentano di accedere alla rete
aspettando che arrivi un nodo che garantisca il verificarsi della condizione (1), ossia di un
nodo che è in grado di aumentare la banda totale disponibile della rete;
quando si verifica tale condizione si inserisce nella rete il nodo a banda elevata (che
verifica la condizione (1)) con ristrutturazione locale e successivamente si provano ad
inserire i nodi in attesa, che erano stati sospesi poiché la banda totale disponibile della
rete prima dell’ultimo inserimento era < 1.
In base a questa considerazione sono nati gli algoritmi 5 e 6.
61
3.5 QUARTO ALGORITMO CON RISTRUTTURAZIONE LOCALE CON
BLOCCO ALL’INGRESSO
Il quarto algoritmo è del tutto analogo a quello precedente con l’aggiunta della ristrutturazione
locale della rete, nel caso in cui l’inserimento di un nuovo nodo può essere effettuato solo
sostituendo il nodo avente output band minima con il nuovo nodo e reinserendo il nodo avente
banda minima. In questo caso si ferma l’inserimento di nuovi nodi, se il nuovo nodo entrante risulta
essere non inseribile nella rete anche con la sostituzione di questo con il nodo a banda di upload
minima. Quando si verifica tale evento il sistema rifiuta l’inserimento di nuovi nodi nella rete anche
se questi potrebbero essere inseriti con ristrutturazione locale.
L’algoritmo 4 ha lo stesso comportamento dell’algoritmo 3, tranne nel caso in cui il nuovo
nodo non è inseribile nella rete poiché questa fornisce un quantitativo di banda inferiore a quello
richiesto dal contenuto. Quindi in questa situazione l’algoritmo 4 si comporta nel seguente modo:
sia Bi l’output band del nuovo nodo da inserire nella rete;
sia BtotDisp l’output band disponibile dell’intera rete (ossia la somma delle output
band residue di tutti i nodi della rete);
se BtotDisp – [La banda del nodo a banda minima della rete] + Bi ≥ 1
(1)
allora il nuovo nodo viene inserito nella rete con un’opportuna ristrutturazione anche se
l’attuale banda totale disponibile dell’intera rete è < 1.
Quindi questa situazione si verifica se la banda del nuovo nodo è talmente elevata che è in
grado di garantire la condizione (1).
In questo caso se la condizione (1) è verificata allora:
1.
si estrae dalla rete il nodo avente output band minima e lo si sostituisce con il nuovo
nodo Ni;
2.
il nodo estratto o sostituito viene reinserito nella rete secondo la procedura di
inserimento mostrata nella descrizione dell’algoritmo 3.
Se invece la condizione (1) non è verificata allora il sistema non è in grado di accettare ulteriori
nodi.
Anche in questo caso il costo della ristrutturazione locale, dovuto alla sostituzione del nodo a
banda minima con quello da inserire è dato dalla seguente somma:
[Stima del costo di ristrutturazione] = [° di nodi padri del nodo da sostituire] + [° di
nodi figli del nodo da sostituire]
Figura 22
62
3.6 QUINTO ALGORITMO SENZA BLOCCO ALL’INGRESSO
Il quinto algoritmo è derivato dal secondo algoritmo presentato, con l’ipotesi aggiuntiva di non
avere il blocco all’ingresso della rete, ossia si inseriscono tutti i nodi inseribili nella sequenza di
nodi di ingresso scartando quelli non inseribili. Per fare questo si modifica il comportamento del
secondo algoritmo, per quanto riguarda la situazione nella quale il nuovo nodo non è inseribile nella
rete, cioè:
se la rete non accetta più nodi poiché ha una banda totale disponibile < 1, in tutti i suoi
tier, allora si mettono in attesa tutti i nodi successivi che tentano di accedere alla rete,
aspettando che arrivi un nodo che sia in grado di aumentare la banda totale disponibile in
almeno un tier della rete;
quando si verifica tale condizione si inserisce nella rete il nodo a banda elevata con
ristrutturazione locale e successivamente si provano ad inserire i nodi in attesa che erano
stati sospesi.
3.7 SESTO ALGORITMO CON RISTRUTTURAZIONE SENZA BLOCCO
ALL’INGRESSO
Il sesto algoritmo è derivato dal quarto algoritmo presentato con l’ipotesi aggiuntiva di non
avere il blocco all’ingresso della rete, ossia si inseriscono tutti i nodi inseribili nella sequenza di
nodi di ingresso scartando quelli non inseribili.
Per fare questo si modifica il comportamento del quarto algoritmo, per quanto riguarda la
situazione nella quale il nuovo nodo non è inseribile nella rete, cioè:
si consideri la seguente condizione:
BtotDisp – [La banda del nodo a banda minima della rete] + Bi ≥ 1
(1)
se la rete non accetta più nodi poiché ha una banda totale disponibile < 1 allora si
mettono in attesa tutti i nodi successivi che tentano di accedere alla rete aspettando che
arrivi un nodo che garantisca il verificarsi della condizione (1), ossia di un nodo che sia
in grado di aumentare la banda totale disponibile della rete;
quando si verifica tale condizione si inserisce nella rete il nodo a banda elevata (che
verifica la condizione (1)) con ristrutturazione locale e successivamente si provano ad
inserire i nodi in attesa, che erano stati sospesi poiché la banda totale disponibile della
rete prima dell’ultimo inserimento era < 1.
63
Quindi sia nel quinto che nel sesto algoritmo non si giunge mai in una situazione nella quale la
rete non è in grado di accettare nuovi nodi poiché prima o poi giungerà un nodo con output band
sufficientemente elevata da consentire l’inserimento dei nodi sospesi.
64
4 ESEMPI E CONFRONTI
4.1 ALGORITMI 1,2,3 E 4
I vari algoritmi, descritti nel capitolo precedente, sono stati implementati nel linguaggio di
programmazione orientato agli oggetti Java, utilizzando l’ambiente di sviluppo NetBeans. La scelta
del linguaggio di programmazione è ricaduta sul Java poiché consente di avere delle strutture dati
astratte (LinkedList e Vector) che permettono di modellare, in modo veloce ed efficiente, la rete
peer to peer di diffusione del contenuto. In particolare per gli algoritmi 1,2 e 5 sono state utilizzate
le seguenti strutture di dati astratte:
ogni tier della rete viene modellato attraverso una LinkedList che contiene al suo
interno tutti i nodi afferenti a tale tier;
l’insieme di tutti i tier che costituiscono la rete sono contenuti all’interno di un Vector;
per tale struttura dati astratta Vector si ha un metodo (o procedura) che consente
l’inserimento di un nuovo nodo nella rete ossia nel tier opportuno, contenuto nel
Vector;
ogni nodo è a sua volta una struttura dati astratta che contiene (nel caso degli algoritmi
con ristrutturazione locale 2 e 5) al suo interno la lista degli identificativi dei suoi nodi
figli e la lista degli identificativi dei suoi nodi padri. Negli algoritmi 2 e 5, ogni nodo ha
queste due liste per consentire la stima del costo di ristrutturazione locale della rete, e
tale ristrutturazione si verifica nel caso in cui il nodo considerato viene sostituito con il
nuovo nodo da inserire, e ricorsivamente il nodo sostituito viene inserito nel tier
successivo.
Per gli algoritmi 3,4 e 6 sono state utilizzate le seguenti strutture di dati astratte:
una LinkedList che contiene al suo interno la lista di tutti i nodi che fanno parte della
rete peer to peer, ed un metodo che implementa l’algoritmo di inserimento di un nuovo
nodo nella rete;
ogni nodo è a sua volta una struttura dati astratta che contiene al suo interno la lista
degli identificativi dei suoi nodi figli; tale lista è rappresentata attraverso una
LinkedList;
struttura dati ausiliaria di tipo LinkedList Lp, utilizzata solo all’atto dell’inserimento
del nuovo nodo N, per contenere la lista degli identificativi dei nodi padri del peer N. In
questo modo, nella lista dei figli di ogni nodo padre, appartenente alla LinkedList Lp, si
aggiunge il nuovo nodo N al fine di portare a termine l’inserimento del nuovo peer
nella rete.
65
4.1.1 UTILIZZO DEL SOFTWARE IMPLEMENTATO
Sia X una variabile intera che indica il numero dell’algoritmo che si vuole eseguire. Se ad
esempio si vuole eseguire il primo algoritmo, X varrà 1 mentre, se si vuole eseguire il secondo
algoritmo X varrà 2, e così via … .
Tutti gli algoritmi di costruzione delle reti peer to peer adottati per la diffusione di contenuti
sono stati realizzati in ambiente Java. Il file sorgente che contiene l’implementazione dell’algoritmo
X è denominato “AlgoritmoX.java”; la sua compilazione avviene nel seguente modo:
E:\Tesi_src\AlgoritmoX>javac AlgoritmoX.java
Figura 23
Per poter eseguire il file .class, generato dalla compilazione del file sorgente
“AlgoritmoX.java”, è necessario che nella directory che contiene il file .class vi sia anche il file di
testo contente la sequenza di nodi che vogliono accedere alla rete. Tale file può essere generato
eseguendo il componente software NodeSeqGen (visto nella sezione 3.1) nel seguente modo:
E:\Tesi_src>java NodeSeqGen
Figura 24
…
Attraverso tale esecuzione si ottiene un file di testo denominato: “NodeSequencePc1=<valore
di Pc1>Pc2=<valore di Pc2>.txt”. Per poter eseguire l’implementazione dell’algoritmo X è
sufficiente rinominare il file di testo appena creato dandogli come nome “NodeSequence.txt”,
posizionarlo nella directory dell’algoritmo X ed eseguire il seguente comando da console:
E:\Tesi_src\AlgoritmoX>java AlgoritmoX
Figura 25
…
Al termine dell’esecuzione dell’algoritmo si ottiene, sulla console, la tabella dei risultati ed in
particolare si può notare che in tale tabella sono indicati il numero di nodi inseribili nella rete, il
costo delle eventuali ristrutturazioni locali necessarie per effettuare l’inserimento dei nuovi nodi e la
banda totale che può rendere disponibile l’intera rete peer to peer creata, dove tutti questi parametri
sono rappresentati in funzione della banda fornita dal nodo sorgente che varia da 1 a 10.
Nelle sezioni successive di questo capitolo, si spiegano su che basi e su quali parametri
vengono effettuati i confronti tra i vari algoritmi implementati.
66
4.1.2 NUMERO DI NODI INSERIBILI NELLA RETE IN FUNZIONE DELLA
OUTPUT BAND FORNITA DAL NODO SORGENTE
Per gli algoritmi 1,2,3 e 4 si analizza, come primo parametro prestazionale, il numero massimo
di nodi inseribili nella rete in funzione alla output band del nodo sorgente: per fare questo il
componente software (realizzato in Java), che implementa ciascun algoritmo, effettua l’inserimento
dei nodi generati dall’algoritmo specificato nella sezione 3.1 di questa tesi fino a che la rete è in
grado di accettare peer. Tale procedura di inserimento della sequenza di nodi nella rete è ripetuta
per ogni valore che l’output banda del nodo sorgente può assumere nell’insieme {1,2,3,…,10}.
In questo modo, per ogni algoritmo si ottiene una tabella ed un corrispondente grafico nel quale
vi è come variabile indipendente l’ output band del nodo sorgente e come variabile dipendente il
numero massimo di nodi che possono essere inseriti nella rete. Un esempio di tabella contente i
valori di output band, con i relativi valori di “numero massimo di nodi inseribili nella rete” è la
seguente:
Output Band
nodo sorgente
1
2
3
4
5
6
7
8
9
10
N°Nodi 1° algoritmo
3
7
7
14
20
27
27
29
33
36
N°Nodi 2° algoritmo
3
7
9
22
22
26
31
33
36
40
67
N°Nodi 3° algoritmo
3
20
21
24
29
32
34
39
43
47
N°Nodi 4° algoritmo
3
20
23
28
31
33
36
41
46
49
Il grafico associato a tale tabella è il seguente:
Numero Nodi
60
50
Numero Nodi
40
Algoritmo1
30
Algoritmo2
Algoritmo3
20
Algoritmo4
10
0
1
2
3
4
5
6
7
8
9
Banda Nodo Sorgente
10
Figura 26
Le output band della sequenza di nodi che vogliono accedere nella rete, in questo esempio,
sono state generata a mano e non dall’algoritmo di generazione della sequenza di nodi descritto
nella sezione 3.1 .
Occorre notare che la rete non è più grado di accettare ulteriori nodi, specificati nella sequenza
di peer che vogliono accedere alla rete, quando per i suoi vincoli di banda non è possibile inserire
un nuovo nodo in essa.
Inoltre in questa sezione si presentano una serie di esempi relativi al numero massimo di nodi
inseribili nella rete al variare della output band fornita dal nodo sorgente:
68
primo esempio, con output band dei nodi che accedono alla rete da me definiti:
Numero Nodi
60
50
Numero Nodi
40
Algoritmo1
30
Algoritmo2
Algoritmo3
20
Algoritmo4
10
0
1
2
3
4
5
6
7
8
9
10
Banda Nodo Sorgente
Figura 27
secondo esempio, con Pc1=75% Pc2=12% Pc3=13%:
Numero Nodi
140
120
Numero Nodi
100
80
Algoritmo1
Algoritmo2
60
Algoritmo3
Algoritmo4
40
20
0
1
2
3
4
5
6
Banda Nodo Sorgente
69
7
8
9
10
Figura 28
terzo esempio, con Pc1=80% Pc2=12% Pc3=8%:
Numero Nodi
90
80
70
Numero Nodi
60
50
Algoritmo1
Algoritmo2
40
Algoritmo3
30
Algoritmo4
20
10
0
1
2
3
4
5
6
7
8
9
10
Banda Nodo Sorgente
Figura 29
quarto esempio, con Pc1=76% Pc2=14% Pc3=10%:
Numero Nodi
120
100
Numero Nodi
80
Algoritmo1
60
Algoritmo2
Algoritmo3
40
Algoritmo4
20
0
1
2
3
4
5
6
7
Banda Nodo Sorgente
70
8
9
10
Figura 30
quinto esempio, con Pc1=70% Pc2=25% Pc3=5%:
Numero Nodi
60
50
Numero Nodi
40
Algoritmo1
30
Algoritmo2
Algoritmo3
20
Algoritmo4
10
0
1
2
3
4
5
6
7
8
9
10
Banda Nodo Sorgente
Figura 31
sesto esempio, con Pc1=75% Pc2=20% Pc3=5%:
Numero Nodi
140
120
Numero Nodi
100
80
Algoritmo1
Algoritmo2
60
Algoritmo3
Algoritmo4
40
20
0
1
2
3
4
5
6
Banda Nodo Sorgente
71
7
8
9
10
Figura 32
settimo algoritmo, con Pc1=85% Pc2=10% Pc3=5%:
Numero Nodi
30
25
Numero Nodi
20
Algoritmo1
15
Algoritmo2
Algoritmo3
10
Algoritmo4
5
0
1
2
3
4
5
6
7
8
9
10
Banda Nodo Sorgente
Figura 33
ottavo esempio, con Pc1=78% Pc2=14% Pc3=8%:
Numero Nodi
250
Numero Nodi
200
150
Algoritmo1
Algoritmo2
100
Algoritmo3
Algoritmo4
50
0
1
2
3
4
5
6
Banda Nodo Sorgente
72
7
8
9
10
Figura 34
nono esempio, con Pc1=81% Pc2=10% Pc3=9%:
Numero Nodi
50
45
40
Numero Nodi
35
30
Algoritmo1
25
Algoritmo2
20
Algoritmo3
15
Algoritmo4
10
5
0
1
2
3
4
5
6
7
8
9
10
Banda Nodo Sorgente
Figura 35
decimo esempio, con Pc1=81% Pc2=10% Pc3=9%:
Numero Nodi
120
100
Numero Nodi
80
Algoritmo1
60
Algoritmo2
Algoritmo3
40
Algoritmo4
20
0
1
2
3
4
5
6
Banda Nodo Sorgente
73
7
8
9
10
Figura 36
undicesimo esempio, con Pc1=79% Pc2=20% Pc3=1%:
Numero Nodi
30
25
Numero Nodi
20
Algoritmo1
Algoritmo2
Algoritmo3
Algoritmo4
15
10
5
0
1
2
3
4
5
6
7
Banda Nodo Sorgente
8
9
10
Figura 37
dodicesimo esempio, con Pc1=79% Pc2=20% Pc3=1%:
Numero Nodi
70
60
Numero Nodi
50
40
Algoritmo1
Algoritmo2
30
Algoritmo3
Algoritmo4
20
10
0
1
2
3
4
5
6
Banda Nodo Sorgente
74
7
8
9
10
Figura 38
In quest’ultimo esempio si nota che: per il valore di output band, del nodo sorgente, pari a 3 il
numero massimo di nodi inseribili nell’algoritmo 3 è inferiore al numero massimo di nodi inseribili,
nella rete, nell’algoritmo 2; si verifica ciò poiché il secondo algoritmo presenta un inserimento dei
nodi nella rete con una eventuale ristrutturazione locale della rete stessa e quindi ciò fa sì che: con
opportune sequenze di nodi che accedono alla rete si verifica la possibilità di inserire un maggior
numero di nodi applicando l’algoritmo 2, rispetto al numero di nodi inseribili applicando
l’algoritmo 3. Per tale motivo è stato implementato l’algoritmo 4, che è realizzato aggiungendo
all’algoritmo 3 la gestione dell’inserimento di un nodo con eventuale ristrutturazione locale della
rete. Per maggiori dettagli sull’algoritmo 4 si veda la sezione 3.5 .
Un ulteriore considerazione che si può estrarre da questo esempio è la seguente: nell’esempio
si può notare che gli algoritmi 1 e 3 si comportano, quasi, nello stesso modo per quanto riguarda il
numero massimo di nodi inseribili nella rete, quando la banda fornita dal nodo sorgente è pari a 3;
quindi gli algoritmi 1 e 3, che effettuano l’inserimento dei nodi nella rete senza una eventuale
ristrutturazione locale della stessa, hanno lo svantaggio che il numero massimo di nodi inseribili
nella rete dipende dall’ordine con cui i nodi accedono alla rete stessa poiché non riorganizzano
opportunamente la rete quando viene inserito un nuovo nodo. Invece gli algoritmi 2 e 4 sono meno
sensibili a questo problema poiché, potenzialmente, ogni nodo che viene inserito nella rete può
determinare una ristrutturazione locale della stessa; di conseguenza, per tali algoritmi, il numero
massimo di nodi inseribili nella rete è meno sensibile all’ordine con cui i nodi accedono alla rete.
Infatti considerando, la sequenza di nodi dell’esempio 13, con un altro ordine di accesso dei nodi
stessi, si evidenzia che solamente con un opportuno ordine di accesso dei nodi, l’algoritmo 3 ha:
un comportamento simile all’algoritmo 4, rispetto al numero massimo di nodi inseribili nella
rete;
ed un comportamento migliore rispetto all’algoritmo 2, in base al numero di nodi inseribili nella
rete in funzione all’output band del nodo sorgente, cioè:
75
Numero Nodi
70
60
Numero Nodi
50
40
Algoritmo1
Algoritmo2
30
Algoritmo3
20
Algoritmo4
10
0
1
2
3
4
5
6
7
8
9
10
Banda Nodo Sorgente
Figura 39
Inoltre, per poter osservare che gli algoritmi dipendono dall’ordine con cui i nodi accedono alla
rete, possiamo confrontare ogni algoritmo con se stesso, applicandolo a due sequenze che
contengono gli stessi nodi e differiscono solamente per l’ordine con cui i nodi vogliono accedere
alla rete, cioè:
1. primo algoritmo con le due differenti sequenze di nodi:
Numero Nodi Algoritmo 1
60
50
Numero Nodi
40
30
Algoritmo1, Seq. 2
Algoritmo1, Seq. 1
20
10
0
1
2
3
4
5
6
7
Banda Nodo Sorgente
76
8
9
10
Figura 40
2. secondo algoritmo con le due differenti sequenze di nodi:
Numero Nodi Algoritmo 2
60
50
Numero Nodi
40
30
Algoritmo2, Seq. 2
Algoritmo2, Seq. 1
20
10
0
1
2
3
4
5
6
7
8
9
10
Banda Nodo Sorgente
Figura 41
3. terzo algoritmo con le due differenti sequenze di nodi:
Numero Nodi Algoritmo 3
70
60
Numero Nodi
50
40
Algoritmo3, Seq. 2
30
Algoritmo3, Seq. 1
20
10
0
1
2
3
4
5
6
7
Banda Nodo Sorgente
77
8
9
10
Figura 42
4. quarto algoritmo con le due differenti sequenze di nodi:
Numero Nodi Algoritmo 4
70
60
Numero Nodi
50
40
Algoritmo4, Seq. 2
30
Algoritmo4, Seq. 1
20
10
0
1
2
3
4
5
6
7
8
Banda Nodo Sorgente
9
10
Figura 43
Confrontando i vari algoritmi in base al numero massimo di nodi inseribili nella rete si nota
che: l’algoritmo che massimizza il numero di nodi inseribili nella rete è il quarto algoritmo.
4.1.3 BANDA TOTALE RESIDUA DELLA RETE IN FUNZIONE DELLA OUTPUT
BAND FORNITA DAL NODO SORGENTE
Per gli algoritmi 1,2,3 e 4 si analizza, come secondo parametro prestazionale, la banda totale
residua della rete (che si ha quando questa non è più in grado di accettare nuovi nodi) in funzione
della output band del nodo sorgente: per fare questo il componente software (realizzato in Java), che
implementa ciascun algoritmo, effettua l’inserimento dei nodi generati dall’algoritmo specificato
nella sezione 3.1 di questa tesi, fino a che la rete è in grado di accettare peer. Tale procedura di
inserimento della sequenza di nodi nella rete è ripetuta per ogni valore che l’output banda del nodo
sorgente può assumere nell’insieme {1,2,3,…,10}.
La banda totale residua della rete si determina quando la rete non è più in grado di accettare
nuovi nodi e viene calcolata come la somma delle output band residue di tutti i nodi contenuti nella
rete. L’output band residua di un nodo è pari alla differenza tra l’output band totale che il nodo ha a
78
disposizione quando non alimenta alcun nodo, e l’output band che tale nodo sta attualmente
utilizzando per alimentare ulteriori peer.
In questo modo, per ogni algoritmo si ottiene una tabella ed un corrispondente grafico nel quale
vi è come variabile indipendente l’ output band del nodo sorgente e come variabile dipendente la
banda totale residua della rete. Un esempio di tabella contente i valori di output band, con i relativi
valori di banda totale residua è la seguente:
Output Band fornita dal nodo
sorgente
1
2
3
4
5
6
7
8
9
10
BandaDisponibile BandaDisponibile
Algoritmo 1
Algoritmo 2
0,9921875
0,9921875
1,9375
1,9375
2,9375
2,90625
3,78125
1,9609375
3,640625
2,9609375
2,125
2,1328125
3,125
2,25
3,53125
2,1015625
3,1015625
2,078125
3,078125
2,2734375
BandaDisp.
Algoritmo 3
0,9921875
0,640625
0,9921875
0,921875
0,53125
0,8359375
0,921875
0,828125
0,734375
0,7734375
BandaDisp.
Algoritmo 4
0,9921875
0,640625
0,140625
0,21875
0,25
0,1015625
0,078125
0,2734375
0,5234375
0,71875
Il grafico associato a tale tabella è il seguente:
Banda Disponibile
Banda Disponibile
4
3,5
3
2,5
2
1,5
1
0,5
0
Algoritmo1
Algoritmo2
Algoritmo3
Algoritmo4
1
2
3
4
5
6
7
Banda Sorgente
8
9
10
Figura 44
Le output band della sequenza di nodi che vogliono accedere nella rete, in questo esempio,
sono state generata a mano e non dall’algoritmo di generazione della sequenza di nodi descritto
nella sezione 3.1 .
Inoltre in questa sezione si presentano una serie di esempi relativi alla banda totale residua
della rete al variare della output band fornita dal nodo sorgente:
79
primo esempio, con output band dei nodi che accedono alla rete da me definiti:
Banda Disponibile
Banda Disponibile
5
4,5
4
3,5
3
2,5
2
1,5
1
0,5
0
Algoritmo1
Algoritmo2
Algoritmo3
Algoritmo4
1
2
3
4
5
6
7
8
9
10
Banda Sorgente
Figura 45
secondo esempio, con Pc1=75% Pc2=12% Pc3=13%:
Banda Disponibile
7
Banda Disponibile
6
5
4
Algoritmo1
3
Algoritmo2
2
Algoritmo3
1
Algoritmo4
0
1
2
3
4
5
6
Banda Sorgente
80
7
8
9
10
Figura 46
terzo esempio, con Pc1=80% Pc2=12% Pc3=8%:
Banda Disponibile
Banda Disponibile
4,5
4
3,5
3
2,5
2
1,5
1
0,5
0
Algoritmo1
Algoritmo2
Algoritmo3
Algoritmo4
1
2
3
4
5
6
7
8
9
10
Banda Sorgente
Figura 47
quarto esempio, con Pc1=76% Pc2=14% Pc3=10%:
Banda Disponibile
Banda Disponibile
4,5
4
3,5
3
2,5
2
1,5
1
0,5
0
Algoritmo1
Algoritmo2
Algoritmo3
Algoritmo4
1
2
3
4
5
6
Banda Sorgente
81
7
8
9
10
Figura 48
quinto esempio, con Pc1=70% Pc2=25% Pc3=5%:
Banda Disponibile
6
Banda Disponibile
5
4
Algoritmo1
3
Algoritmo2
2
Algoritmo3
1
Algoritmo4
0
1
2
3
4
5
6
7
8
9
10
Banda Sorgente
Figura 49
sesto esempio, con Pc1=75% Pc2=20% Pc3=5%:
Banda Disponibile
8
Banda Disponibile
7
6
5
Algoritmo1
4
3
Algoritmo2
2
Algoritmo3
1
Algoritmo4
0
1
2
3
4
5
6
Banda Sorgente
82
7
8
9
10
Figura 50
settimo algoritmo, con Pc1=85% Pc2=10% Pc3=5%:
Banda Disponibile
3
Banda Disponibile
2,5
2
Algoritmo1
1,5
Algoritmo2
1
Algoritmo3
0,5
Algoritmo4
0
1
2
3
4
5
6
7
8
9
10
Banda Sorgente
Figura 51
ottavo esempio, con Pc1=78% Pc2=14% Pc3=8%:
Banda Disponibile
12
Banda Disponibile
10
8
Algoritmo1
6
Algoritmo2
4
Algoritmo3
2
Algoritmo4
0
1
2
3
4
5
6
Banda Sorgente
83
7
8
9
10
Figura 52
nono esempio, con Pc1=81% Pc2=10% Pc3=9%:
Banda Disponibile
4
Banda Disponibile
3,5
3
2,5
Algoritmo1
2
1,5
Algoritmo2
1
Algoritmo3
0,5
Algoritmo4
0
1
2
3
4
5
6
7
8
9
10
Banda Sorgente
Figura 53
decimo esempio, con Pc1=81% Pc2=10% Pc3=9%:
Banda Disponibile
7
Banda Disponibile
6
5
4
Algoritmo1
3
Algoritmo2
2
Algoritmo3
1
Algoritmo4
0
1
2
3
4
5
6
Banda Sorgente
84
7
8
9
10
Figura 54
undicesimo esempio, con Pc1=79% Pc2=20% Pc3=1%:
Banda Disponibile
Banda Disponibile
3
2
Algoritmo1
Algoritmo2
Algoritmo3
1
Algoritmo4
0
1
2
3
4
5 Sorgente
6
Banda
7
8
9
10
Figura 55
dodicesimo esempio, con Pc1=79% Pc2=20% Pc3=1%:
Banda Disponibile
Banda Disponibile
5
4,5
4
3,5
3
2,5
2
1,5
1
0,5
0
Algoritmo1
Algoritmo2
Algoritmo3
Algoritmo4
1
2
3
4
5
6
Banda Sorgente
7
8
9
10
Figura 56
Confrontando i vari algoritmi in base alla banda totale residua della rete si nota che:
l’algoritmo che minimizza tale banda è il quarto algoritmo.
85
4.1.4 STIMA DEL COSTO DELLE RISTRUTTURAZIONI IN FUNZIONE DELLA
OUTPUT BAND FORNITA DAL NODO SORGENTE
Per gli algoritmi 1,2,3 e 4 si analizza, come terzo parametro prestazionale, la stima del costo
delle ristrutturazioni della rete (che si verificano a causa dell’inserimento di nuovi nodi nella rete
stessa) in funzione della output band del nodo sorgente: per fare questo il componente software
(realizzato in Java), che implementa ciascun algoritmo, effettua l’inserimento dei nodi generati
dall’algoritmo specificato nella sezione 3.1 di questa tesi, fino a che la rete è in grado di accettare
peer. Tale procedura di inserimento della sequenza di nodi nella rete è ripetuta per ogni valore che
l’output banda del nodo sorgente può assumere nell’insieme {1,2,3,…,10}.
La stima del costo delle ristrutturazioni della rete si considera come parametro da analizzare,
quando la rete non è più in grado di accettare nuovi nodi e tale stima viene calcolata come la somma
dei costi di ristrutturazione che vi sono, per ogni nodo che accede alla rete. Il costo della
ristrutturazione della rete causato dall’inserimento di un nuovo nodo è definito nella sezione 3.3.
In questo modo, per ogni algoritmo si ottiene una tabella ed un corrispondente grafico nel quale
vi è come variabile indipendente l’ output band del nodo sorgente e come variabile dipendente la
stima del costo delle ristrutturazioni della rete, che è nello stato in cui non è in grado di accettare
ulteriori nodi. Un esempio di tabella contente i valori di output band, con i relativi valori di stima
del costo delle ristrutturazioni della rete è la seguente:
Output band fornita dal
nodo sorgente
1
2
3
4
5
6
7
8
9
10
Costo della
ristrutturazione Algoritmo
1
0
0
0
0
0
0
0
0
0
0
86
Costo della
ristrutturazione
Algoritmo 2
0
5
5
35
31
32
60
43
57
66
Costo della
ristrutturazione
Algoritmo 3
0
0
0
0
0
0
0
0
0
0
Costo della
ristrutturazione
Algoritmo 4
0
0
4
10
6
5
5
6
8
2
Il grafico associato a tale tabella è il seguente:
Costo delle ristrutturazioni locali
70
60
Costo
50
40
Algoritmo1
30
Algoritmo2
20
Algoritmo3
10
Algoritmo4
0
1
2
3
4
5
6
7
8
9
10
Banda Sorgente
Figura 57
Le output band della sequenza di nodi che vogliono accedere nella rete, in questo esempio,
sono state generata a mano e non dall’algoritmo di generazione della sequenza di nodi descritto
nella sezione 3.1 .
Inoltre in questa sezione si presentano una serie di esempi relativi stima del costo delle
ristrutturazioni della rete al variare della output band fornita dal nodo sorgente:
primo esempio, con output band dei nodi che accedono alla rete da me definiti:
Costo
Costo delle ristrutturazioni locali
100
90
80
70
60
50
40
30
20
10
0
Algoritmo1
Algoritmo2
Algoritmo3
Algoritmo4
1
2
3
4
5
6
Banda Sorgente
87
7
8
9
10
Figura 58
secondo esempio, con Pc1=75% Pc2=12% Pc3=13%:
Costo
Costo delle ristrutturazioni locali
200
180
160
140
120
100
80
60
40
20
0
Algoritmo1
Algoritmo2
Algoritmo3
Algoritmo4
1
2
3
4
5
6
7
8
9
10
Banda Sorgente
Figura 59
terzo esempio, con Pc1=80% Pc2=12% Pc3=8%:
Costo delle ristrutturazioni locali
160
140
120
Costo
100
Algoritmo1
80
60
Algoritmo2
40
Algoritmo3
20
Algoritmo4
0
1
2
3
4
5
6
Banda Sorgente
88
7
8
9
10
Figura 60
quarto esempio, con Pc1=76% Pc2=14% Pc3=10%:
Costo delle ristrutturazioni locali
250
Costo
200
150
Algoritmo1
Algoritmo2
100
Algoritmo3
50
Algoritmo4
0
1
2
3
4
5
6
7
8
9
10
Banda Sorgente
Figura 61
quinto esempio, con Pc1=70% Pc2=25% Pc3=5%:
Costo
Costo delle ristrutturazioni locali
90
80
70
60
50
40
30
20
10
0
Algoritmo1
Algoritmo2
Algoritmo3
Algoritmo4
1
2
3
4
5
6
Banda Sorgente
89
7
8
9
10
Figura 62
sesto esempio, con Pc1=75% Pc2=20% Pc3=5%:
Costo delle ristrutturazioni locali
300
250
Costo
200
Algoritmo1
150
Algoritmo2
100
Algoritmo3
50
Algoritmo4
0
1
2
3
4
5
6
7
8
9
10
Banda Sorgente
Figura 63
settimo algoritmo, con Pc1=85% Pc2=10% Pc3=5%:
Costo delle ristrutturazioni locali
35
30
Costo
25
20
Algoritmo1
15
Algoritmo2
10
Algoritmo3
5
Algoritmo4
0
1
2
3
4
5
6
Banda Sorgente
90
7
8
9
10
Figura 64
ottavo esempio, con Pc1=78% Pc2=14% Pc3=8%:
Costo delle ristrutturazioni locali
700
600
Costo
500
400
Algoritmo1
300
Algoritmo2
200
Algoritmo3
100
Algoritmo4
0
1
2
3
4
5
6
7
8
9
10
Banda Sorgente
Figura 65
nono esempio, con Pc1=81% Pc2=10% Pc3=9%:
Costo delle ristrutturazioni locali
90
80
70
Costo
60
50
Algoritmo1
40
Algoritmo2
30
Algoritmo3
20
Algoritmo4
10
0
1
2
3
4
5
6
Banda Sorgente
91
7
8
9
10
Figura 66
decimo esempio, con Pc1=81% Pc2=10% Pc3=9%:
Costo delle ristrutturazioni locali
250
Costo
200
150
Algoritmo1
Algoritmo2
100
Algoritmo3
50
Algoritmo4
0
1
2
3
4
5
6
7
8
9
10
Banda Sorgente
Figura 67
undicesimo esempio, con Pc1=79% Pc2=20% Pc3=1%:
Costo delle ristrutturazioni locali
12
10
Costo
8
Algori
tmo1
Algori
tmo2
6
4
2
0
1
2
3
4
5
6
Banda Sorgente
92
7
8
9
10
Figura 68
dodicesimo esempio, con Pc1=79% Pc2=20% Pc3=1%:
Costo delle ristrutturazioni locali
120
100
Costo
80
Algoritmo1
60
Algoritmo2
40
Algoritmo3
20
Algoritmo4
0
1
2
3
4
5
6
7
Banda Sorgente
8
9
10
Figura 69
Confrontando i vari algoritmi in base alla stima del costo delle ristrutturazioni della rete, si
nota che: gli algoritmi che minimizzano tale costo sono quelli che effettuano l’inserimento di un
nuovo nodo nella rete senza un’eventuale ristrutturazione della rete stessa; quindi gli algoritmi che
presentano un costo delle ristrutturazioni sempre nullo sono gli algoritmi 1 e 3; tra questi due
algoritmi, quello che massimizza il numero di nodi inseribili e minimizza la banda totale residua
della rete è l’algoritmo 3. Inoltre occorre notare che: di solito tra i due algoritmi (2 e 4), che
effettuano l’inserimento dei nodi nella rete con una eventuale ristrutturazione della rete stessa,
quello che ha un di costo di ristrutturazione minore è l’algoritmo 4.
4.2 ALGORITMI 5 E 6
Gli algoritmi 5 e 6 sono stati realizzati nell’ambiente di programmazione Java, come i
precedenti algoritmi visti.
L’algoritmo 5 è completamente uguale all’algoritmo 2, con la sola differenza che è stata
utilizzata una LinkedList; tale LinkedList contiene la lista dei nodi che sono in attesa di essere
inseriti: quando un nuovo nodo non può essere inserito nella rete, a causa del fatto che l’algoritmo
di inserimento fallisce, esso viene inserito nella lista dei nodi in attesa; solamente quando il nuovo
nodo che vuole accedere alla rete viene inserito nella rete stessa con successo, si verifica che:
l’algoritmo 5 scandisce la lista dei nodi in attesa e prova ad inserire ogni peer presente in tale lista,
togliendolo da questa se l’inserimento va a buon fine.
93
In maniera del tutto analoga l’algoritmo 6 è completamente uguale all’algoritmo 4, con la sola
differenza che è stata utilizzata una ulteriore LinkedList; tale LinkedList contiene la lista dei nodi
che sono in attesa di essere inseriti: quando un nuovo nodo non può essere inserito nella rete, a
causa del fatto che l’algoritmo di inserimento fallisce, esso viene inserito nella lista dei nodi in
attesa; solamente quando il nuovo nodo che vuole accedere alla rete viene inserito nella rete stessa
con successo, si verifica che: l’algoritmo 5 scandisce la lista dei nodi in attesa e prova ad inserire
ogni peer presente in tale lista, togliendolo da questa se l’inserimento va a buon fine.
Confrontando il comportamento di questi due algoritmi, attraverso il numero massimo di
inseribili nella rete, si nota che tale parametro varia relativamente poco in funzione della banda
erogata dal nodo sorgente cioè:
Numero nodi inseribili
650
Numero Nodi
600
550
ALGORITMO 5
500
ALGORITMO 6
450
400
1
2
3
4
5
6
Pc1
7
8
9
10
Figura 70
Quindi si è pensato di considerare i parametri di confronto degli algoritmi in funzione al
parametro Pc1 (che rappresenta la percentuale di nodi, presenti nella sequenza dei peer che
vogliono accedere alla rete, che hanno output band inferiore all’unità), con il valore della banda
fornita dal nodo sorgente costante. Quindi per confrontare i due algoritmi si utilizzano le sequenze
94
di nodi generate dal componente software “NodeSeqGen1_1”, descritto nella sezione 3.1; in questo
modo la sequenza di file, generati da tale componente software, è utilizzata per analizzare gli
algoritmi 5 e 6, in modo tale da poterli confrontare analizzando il loro comportamento in termini di:
numero di nodi inseribili, stima del costo delle ristrutturazioni, banda totale residua e numero di
nodi in attesa al variare del parametro Pc1.
4.2.1 UTILIZZO DEL SOFTWARE IMPLEMENTATO
Sia X una variabile intera che indica il numero dell’algoritmo che si vuole eseguire. Se ad
esempio si vuole eseguire il quinto algoritmo, X varrà 5 mentre, se si vuole eseguire il sesto
algoritmo X varrà 6.
Tutti gli algoritmi di costruzione delle reti peer to peer adottati per la diffusione di contenuti
sono stati realizzati in ambiente Java. Il file sorgente che contiene l’implementazione dell’algoritmo
X è denominato “AlgoritmoX.java”; la sua compilazione avviene nel seguente modo:
Figura 71
E:\Tesi_src\AlgoritmoX>javac AlgoritmoX.java
Per poter eseguire il file .class, generato dalla compilazione del file sorgente
“AlgoritmoX.java”, è necessario che nella directory che contiene il file .class vi siano anche i file di
testo contenti le varie sequenze di nodi che vogliono accedere alla rete. Tale sequenza di file può
essere generata eseguendo il componente software NodeSeqGen1_1 (secondo quanto visto nella
sezione 3.1) nel seguente modo:
E:\Tesi_src>java NodeSeqGen1_1
Figura 72
…
Attraverso tale esecuzione si ottengono un insieme di file di testo denominati:
“NodeSequencePc1=<valore di Pc1>Pc2=<valore di Pc2>.txt”, dove l’insieme di valori che la
coppia
(<valore
di
Pc1>,
<valore
di
Pc2>)
può
assumere
è
rappresentato
da:
{( Pc1iniziale , Pc 2 iniziale ), ( Pc1iniziale + 1, Pc 2 iniziale − 1),..., (99,1)} . Per poter eseguire l’implementazione
del secondo algoritmo è sufficiente posizionare tutti questi file nella directory dell’algoritmo X ed
eseguire il seguente comando da console:
E:\Tesi_src\AlgoritmoX>java AlgoritmoX
Figura 73
…
Eseguendo tale comando, viene mandato in esecuzione il componente software, (relativo
all’algoritmo X), il quale richiede dallo standard input:
95
il valore iniziale di Pc1 e quello iniziale di Pc2 di modo da poter applicare il sesto algoritmo ad
ogni file generato dal software NodeSeqGen1_1;
e il fattore moltiplicativo (intero) k attraverso il quale si fissa l’output band fornita dal nodo
sorgente. Attraverso il parametro k si stabilisce l’output band fornita dal nodo sorgente nel
seguente modo:
[Output Band del nodo sorgente ] = k ⋅ Bc , dove Bc è la banda non
normalizzata richiesta dal contenuto.
Al termine dell’esecuzione dell’algoritmo si ottiene, sulla console, la tabella dei risultati ed in
particolare si può notare che in tale tabella sono indicati: il numero di nodi inseribili nella rete, il
costo delle eventuali ristrutturazioni locali necessarie per effettuare l’inserimento dei nuovi nodi e la
banda totale residua dell’intera rete peer to peer creata, dove tutti questi parametri sono
rappresentati in funzione del parametro Pc1, il quale varia tra il suo valore iniziale ed il 99%.
Nelle sezioni successive di questo capitolo, si spiegano su che basi e su quali parametri
vengono effettuati i confronti tra i vari algoritmi implementati.
4.2.2 NUMERO DI NODI INSERIBILI IN FUNZIONE DELLA PERCENTUALE DI
NODI CHE HANNO OUTPUT BAND < 1 NELLA SEQUENZA DI
INGRESSO
Per gli algoritmi 5 e 6 si analizza, come primo parametro prestazionale, il numero massimo di
nodi inseribili nella rete in funzione del parametro Pc1 (che rappresenta la percentuale di nodi, della
sequenza di peer che accedono alla rete, aventi output band < 1): per fare questo il componente
software (realizzato in Java), che implementa ciascun algoritmo, effettua l’inserimento dei nodi
generati dall’algoritmo specificato nella sezione 3.1 di questa tesi fino a che la rete è in grado di
accettare peer. Tale procedura di inserimento della sequenza di nodi nella rete è ripetuta per ogni
sequenza di nodi, dove tali sequenze sono caratterizzate da un valore del parametro Pc1 che varia
tra il suo valore iniziale e il 99%. In questo modo per ogni valore di Pc1 (e quindi per ogni sequenza
di nodi) viene generata una rete di diffusione del contenuto.
Quindi, per ogni algoritmo si ottiene una tabella ed un corrispondente grafico nel quale vi è
come variabile indipendente il parametro Pc1 e come variabile dipendente il numero massimo di
nodi che possono essere inseriti nella rete. Un esempio di tabella contente i valori del parametro
Pc1, con i relativi valori di “numero massimo di nodi inseribili nella rete” è la seguente:
96
Pc1 N°Nodi Algoritmo 5
75
954
76
906
77
911
78
837
79
856
80
847
81
809
82
856
83
789
84
793
85
721
86
729
87
663
88
626
89
685
90
599
91
607
92
603
93
531
94
461
95
449
96
465
97
391
98
391
99
316
Pc1 N°Nodi Algoritmo 6
75
959
76
912
77
917
78
853
79
861
80
854
81
816
82
862
83
794
84
801
85
731
86
742
87
672
88
640
89
695
90
613
91
614
92
610
93
538
94
468
95
468
96
474
97
409
98
408
99
322
Il grafico associato a tale tabella è il seguente:
Numero nodi inseribili
1200
Numero Nodi
1000
800
600
Algoritmo5
400
Algoritmo6
200
0
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
Pc1
97
Figura 74
Grafico che rappresenta la differenza tra il numero massimo di nodi inseribili nella rete,
applicando il sesto algoritmo, ed il numero massimo di nodi inseribili nella rete, applicando quinto
algoritmo:
Differenza Numero Nodi dei 2 alg.
20
18
16
Differenza numero Nodi
14
12
10
Diff.
8
6
4
2
0
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
Pc1
Figura 75
Le output band della sequenza di nodi che vogliono accedere alla rete, in questo esempio, sono
state generata dall’algoritmo di generazione della sequenza di nodi descritto nella sezione 3.1 .
Occorre notare che la rete non è più grado di accettare ulteriori nodi, specificati nella sequenza
di peer che vogliono accedere alla rete stessa, quando per i suoi vincoli di banda non è possibile
inserire un nuovo nodo in essa, e quindi tale nodo verrà messo nella lista dei nodi in attesa.
Inoltre in questa sezione si presentano una serie di esempi relativi al numero massimo di nodi
inseribili nella rete al variare del parametro Pc1. Nel primo esempio il parametro Pc1 è stato scelto
≥ 75% di modo che la rete tenda alla condizione nella quale non è più in grado di accettare nuovi
nodi, e di modo che l’eventuale inserimento di un nuovo nodo avvenga con la ristrutturazione locale
della rete stessa. Se, invece, la percentuale Pc1 è inferiore al 75% allora può capitare che la rete
accetti tutti i nodi che vogliono accedere alla rete.
98
Primo esempio, avente Pc1 che varia tra 75 e 99 e Pc2 che vari tra 25 e 1. Quindi le reti sono
state ottenute considerando 25 sequenze di nodi, dove in ogni sequenza si hanno 1000 nodi. Pc1
è stato scelto ≥ 75 di modo che la rete sia in condizione di non accettare ulteriori nodi di modo
che l’eventuale inserimento di un nuovo nodo avvenga, solo, con ristrutturazione locale della
rete. Inoltre in questo esempio l’output band fornita dal nodo sorgente è costante e pari a 4:
Numero nodi inseribili
1200
1000
Numero Nodi
800
600
Algoritmo5
Algoritmo6
400
200
0
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
Pc1
99
Figura 76
Differenza numero Nodi
Differenza Numero Nodi dei 2 alg.
20
18
16
14
12
10
8
6
4
2
0
Diff.
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
Pc1
Figura 77
Secondo esempio, avente Pc1 che varia tra 65 e 99 e Pc2 che vari tra 35 e 1. Quindi le reti sono
state ottenute considerando 35 sequenze di nodi, dove in ogni sequenza si hanno 1000 nodi.
Essendo Pc1 ≥ 65%, allora per i valori di Pc1 inferiori al 75%, circa, può accadere che la rete
accetti tutti i nodi della sequenza caratterizzata da tale valore di Pc1. Inoltre in questo esempio
l’output band fornita dal nodo sorgente è costante e pari a 4:
Numero nodi inseribili
1200
1000
Numero Nodi
800
600
Algoritmo5
Algoritmo6
400
200
0
65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99
Pc1
Figura 78
100
Differenza Numero Nodi Inseribili dei 2 alg.
40
Differenza numero Nodi
35
30
25
20
Diff.
15
10
5
0
65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99
Pc1
Figura 79
In questo esempio si può notare che per Pc1= 65% e Pc1= 67% la rete accetta tutti i nodi che
vogliono accedervi.
Terzo esempio, avente Pc1 che varia tra 50 e 99 e Pc2 che vari tra 50 e 1. Quindi le reti sono
state ottenute considerando 50 sequenze di nodi, dove in ogni sequenza si hanno 1000 nodi.
Anche in questo caso, essendo Pc1 ≥ 50%, allora per i valori di Pc1 inferiori al 75%, circa, può
accadere che la rete accetti tutti i nodi della sequenza caratterizzata da tale valore di Pc1. Inoltre
in questo esempio l’output band fornita dal nodo sorgente è costante e pari a 4:
Numero nodi inseribili
1200
Numero Nodi
1000
800
600
Algoritmo5
400
Algoritmo6
200
0
50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98
Pc1
Figura 80
101
Differenza Numero Nodi dei 2 alg.
25
Differenza numero Nodi
20
15
10
Diff.
5
0
50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98
Pc1
Figura 81
In questo esempio si può notare che per valori di Pc1 ≤ 63% , circa, la rete accetta tutti i nodi
che vogliono accedervi.
Confrontando i due algoritmi in base al numero massimo di nodi inseribili nella rete, in
funzione del parametro Pc1, si nota che: l’algoritmo che massimizza il numero di nodi inseribili
nella rete è il sesto.
4.2.3 STIMA DEL COSTO DELLE RISTRUTTURAZIONI LOCALI IN FUNZIONE
DELLA PERCENTUALE DI NODI CHE HANNO OUTPUT BAND < 1
NELLA SEQUENZA DI INGRESSO
Per gli algoritmi 5 e 6 si analizza, come secondo parametro prestazionale, la stima del costo
delle ristrutturazioni locali dovute all’inserimento della sequenza dei nodi d’ingresso, in funzione
del parametro Pc1 (che rappresenta la percentuale di nodi, della sequenza di peer che accedono alla
rete, aventi output band < 1): per fare questo il componente software (realizzato in Java), che
implementa ciascun algoritmo, effettua l’inserimento dei nodi generati dall’algoritmo specificato
nella sezione 3.1 di questa tesi fino a che la rete è in grado di accettare peer. Tale procedura di
inserimento della sequenza di nodi nella rete è ripetuta per ogni sequenza di nodi, dove tali
sequenze sono caratterizzate da un valore del parametro Pc1 che varia tra il suo valore iniziale e il
99%. In questo modo per ogni valore di Pc1 (e quindi per ogni sequenza di nodi) viene generata una
rete di diffusione del contenuto.
102
Quindi, per ogni algoritmo si ottiene una tabella ed un corrispondente grafico, nel quale vi è
come variabile indipendente il parametro Pc1 e come variabile dipendente la stima del costo delle
ristrutturazioni locali dovute all’inserimento dei nodi delle varie sequenze. Un esempio di tabella
contente i valori del parametro Pc1, con i relativi valori di “stima del costo delle ristrutturazioni
locali” è la seguente:
Costo delle ristrutturazioni locali dell’algoritmo 5 Costo delle ristrutturazioni locali dell’algoritmo 6
3142
294
2408
631
2418
796
1898
845
2004
706
1941
963
1467
996
1636
1012
1576
984
1679
802
1286
787
…
…
931
605
564
554
558
602
608
555
518
448
623
448
487
210
Il grafico associato a tale tabella è il seguente:
Costo Ristrutturazioni Locali
3500
3000
2500
Costo
Pc1
75
76
77
78
79
80
81
82
83
84
85
…
93
94
95
96
97
98
99
2000
Algoritmo5
1500
Algoritmo6
1000
500
0
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
Pc1
103
Figura 82
Le output band della sequenza di nodi che vogliono accedere alla rete, in questo esempio, sono
state generata dall’algoritmo di generazione della sequenza di nodi descritto nella sezione 3.1 .
Occorre notare che la rete non è più grado di accettare ulteriori nodi, specificati nella sequenza
di peer che vogliono accedere alla rete stessa, quando per i suoi vincoli di banda non è possibile
inserire un nuovo nodo in essa, e quindi tale nodo verrà messo nella lista dei nodi in attesa.
Inoltre in questa sezione si presentano una serie di esempi relativi ai costi di ristrutturazione
locale delle reti al variare del parametro Pc1. Nel primo esempio il parametro Pc1 è stato scelto ≥
75% di modo che la rete tenda alla condizione nella quale non è più in grado di accettare nuovi
nodi, e di modo che l’eventuale inserimento di un nuovo nodo avvenga con la ristrutturazione locale
della rete stessa. Se, invece, la percentuale Pc1 è inferiore al 75% allora può capitare che la rete
accetti tutti i nodi che vogliono accedere alla rete, e quindi per valori di Pc1 inferiori al 75% si
potrebbe verificare che il costo totale di ristrutturazione sia molto basso o tendente a 0.
Primo esempio, avente Pc1 che varia tra 75 e 99 e Pc2 che vari tra 25 e 1. Quindi le reti sono
state ottenute considerando 25 sequenze di nodi, dove in ogni sequenza si hanno 1000 nodi. Pc1
è stato scelto ≥ 75 di modo che la rete sia in condizione di non accettare ulteriori nodi e di modo
che l’eventuale inserimento di un nuovo nodo avvenga, solo, con ristrutturazione locale della
rete. Quindi, sicuramente, in questo caso i costi di ristrutturazione locale delle varie reti generate
sarà superiore a 0. Inoltre in questo esempio l’output band fornita dal nodo sorgente è costante e
pari a 4:
Costo Ristrutturazioni Locali
3500
3000
Costo
2500
2000
Algoritmo5
1500
Algoritmo6
1000
500
0
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
Pc1
104
Figura 83
Secondo esempio, avente Pc1 che varia tra 65 e 99 e Pc2 che vari tra 35 e 1. Quindi le reti sono
state ottenute considerando 35 sequenze di nodi, dove in ogni sequenza si hanno 1000 nodi.
Essendo Pc1 ≥ 65%, allora per i valori di Pc1 inferiori al 75%, circa, può accadere che la rete
accetti tutti i nodi della sequenza caratterizzata da tale valore di Pc1; quindi per valori di Pc1
inferiori al 75% può accadere che i valori dei costi di ristrutturazione siano molto bassi o
tendenti a 0. Inoltre in questo esempio l’output band fornita dal nodo sorgente è costante e pari a
4:
Costo Ristrutturazioni Locali
4000
3500
3000
Costo
2500
2000
Algoritmo5
1500
Algoritmo6
1000
500
0
65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99
Pc1
Figura 84
In questo esempio si può notare che per Pc1= 65% e Pc1= 67% la rete, generata dall’algoritmo
6, accetta tutti i nodi che vogliono accedervi senza effettuare ristrutturazioni locali della rete
stessa. Quindi per questi due punti i costi di ristrutturazione della rete locale sono nulli.
Terzo esempio, avente Pc1 che varia tra 50 e 99 e Pc2 che vari tra 50 e 1. Quindi le reti sono
state ottenute considerando 50 sequenze di nodi, dove in ogni sequenza si hanno 1000 nodi.
Anche in questo caso, essendo Pc1 ≥ 50%, allora per i valori di Pc1 inferiori al 75%, circa, può
accadere che la rete accetti tutti i nodi della sequenza caratterizzata da tale valore di Pc1; quindi
per valori di Pc1 inferiori al 75% può accadere che i valori dei costi di ristrutturazione siano
105
molto bassi o tendenti a 0. Inoltre in questo esempio l’output band fornita dal nodo sorgente è
costante e pari a 4:
Costo Ristrutturazioni Locali
3500
3000
Costo
2500
2000
Algoritmo5
1500
Algoritmo6
1000
500
0
50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98
Pc1
Figura 85
In questo esempio si può notare che per valori di Pc1 ≤ 63% , circa, la rete, generata
dall’applicazione dell’algoritmo 6, accetta tutti i nodi che vogliono accedervi senza effettuare
ristrutturazioni locali della rete stessa. Quindi per questi punti i costi di ristrutturazione della
rete locale sono nulli.
Confrontando questi due algoritmi in base alla stima del costo della ristrutturazione locale della
rete, in funzione del parametro Pc1, si nota che: in genere, il sesto algoritmo è quello che rende
minimo il costo di ristrutturazione locale della rete. Occorre però notare che per valori di Pc1
elevati (ossia superiori al 80%) il quinto ed il sesto algoritmo si equivalgono o addirittura il
quinto algoritmo ha un costo di ristrutturazione leggermente inferiore del sesto.
106
4.2.4 BANDA DISPONIBILE O RESIDUA IN FUNZIONE DELLA PERCENTUALE
DI NODI CHE HANNO OUTPUT BAND < 1 NELLA SEQUENZA DI
INGRESSO
Per gli algoritmi 5 e 6 si analizza, come terzo parametro prestazionale, la banda totale
disponibile della rete (data dalla somma delle output band residue, ossia inutilizzate, di tutti i nodi
della rete), in funzione del parametro Pc1 (che rappresenta la percentuale di nodi, della sequenza di
peer che accedono alla rete, aventi output band < 1): per fare questo il componente software
(realizzato in Java), che implementa ciascun algoritmo, effettua l’inserimento dei nodi generati
dall’algoritmo specificato nella sezione 3.1 di questa tesi, fino a che la rete è in grado di accettare
peer. Tale procedura di inserimento della sequenza di nodi nella rete è ripetuta per ogni sequenza di
nodi, dove tali sequenze sono caratterizzate da un valore del parametro Pc1 che varia tra il suo
valore iniziale e il 99%. In questo modo per ogni valore di Pc1 (e quindi per ogni sequenza di nodi)
viene generata una rete di diffusione del contenuto.
Quindi, per ogni algoritmo si ottiene una tabella ed un corrispondente grafico, nel quale vi è
come variabile indipendente il parametro Pc1 e come variabile dipendente banda totale residua della
rete. Un esempio di tabella contente i valori del parametro Pc1, con i relativi valori di “banda totale
residua della rete” è la seguente:
Pc1 Banda totale residua algoritmo 5
75
4,0625
76
4,27083333
77
4,16666667
78
5
79
3,97916667
80
3,97916667
81
4,25
82
4,10416667
83
3,125
84
4,10416667
85
4,27083333
86
5,875
87
4,72916667
88
4,04166667
89
3,54166667
90
3,91666667
91
3,75
…
…
96
3,41666667
97
4,4375
98
4,4375
99
2,39583333
Banda totale residua algoritmo 6
0,375
0,4375
0,270833333
0,25
0,604166667
0,395833333
0,270833333
0,416666667
0,291666667
0,458333333
0,25
0,458333333
0,3125
0,25
0,416666667
0,270833333
0,25
…
0,25
0,25
0,3125
0,25
107
Il grafico associato a tale tabella è il seguente:
Banda Residua
7
6
Banda Disponibile
5
4
Algoritmo5
3
Algoritmo6
2
1
0
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
Pc1
Figura 86
Le output band della sequenza di nodi che vogliono accedere alla rete, in questo esempio, sono
state generata dall’algoritmo di generazione della sequenza di nodi descritto nella sezione 3.1 .
Occorre notare che la rete non è più grado di accettare ulteriori nodi, specificati nella sequenza
di peer che vogliono accedere alla rete stessa, quando per i suoi vincoli di banda non è possibile
inserire un nuovo nodo in essa, e quindi tale nodo verrà messo nella lista dei nodi in attesa.
Inoltre in questa sezione si presentano una serie di esempi relativi alla banda totale residua
della rete al variare del parametro Pc1. Nel primo esempio il parametro Pc1 è stato scelto ≥ 75% di
modo che la rete tenda alla condizione nella quale non è più in grado di accettare nuovi nodi, e di
modo che l’eventuale inserimento di un nuovo nodo avvenga con la ristrutturazione locale della rete
stessa. Se, invece, la percentuale Pc1 è inferiore al 75% allora può capitare che la rete accetti tutti i
nodi che vogliono accedere alla rete, e quindi per valori di Pc1 inferiori al 75% si potrebbe
108
verificare che la banda totale residua della rete sia superiore all’unità ossia con tale banda si
riuscirebbe ad alimentare uno o più ulteriori nodi.
Primo esempio, avente Pc1 che varia tra 75 e 99 e Pc2 che vari tra 25 e 1. Quindi le reti sono
state ottenute considerando 25 sequenze di nodi, dove in ogni sequenza si hanno 1000 nodi. Pc1
è stato scelto ≥ 75 di modo che la rete sia in condizione di non accettare ulteriori nodi e di modo
che l’eventuale inserimento di un nuovo nodo avvenga, solo, con ristrutturazione locale della
rete. Quindi, sicuramente, in questo caso la banda totale residua delle reti generate
dall’algoritmo 6 sarà sempre inferiore a 1, al variare di Pc1, poiché tale algoritmo è derivato
dall’algoritmo 4 il quale garantisce una banda totale residua della rete < di 1. Inoltre in questo
esempio l’output band fornita dal nodo sorgente è costante e pari a 4:
Banda Residua
7
6
Banda Disponibile
5
4
Algoritmo5
3
Algoritmo6
2
1
0
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
Pc1
Figura 87
In questo esempio si può notare che la banda totale residua, delle reti generate dall’algoritmo 6,
è sempre inferiore all’unità; quindi le reti generate da tale algoritmo, al variare di Pc1, sono tali
109
per cui non sono in grado di alimentare un ulteriore nodo e sono in grado di alimentarlo
solamente se, questo è in grado di incrementare sufficientemente la banda totale residua.
Inoltre si può notare che il quinto algoritmo genera reti, al variare di Pc1, con output band
residue superiori a quelle fornite dalle reti generate dal sesto algoritmo.
Secondo esempio, avente Pc1 che varia tra 65 e 99 e Pc2 che vari tra 35 e 1. Quindi le reti sono
state ottenute considerando 35 sequenze di nodi, dove in ogni sequenza si hanno 1000 nodi.
Essendo Pc1 ≥ 65%, allora per i valori di Pc1 inferiori al 75%, circa, può accadere che la rete
accetti tutti i nodi della sequenza caratterizzata da tale valore di Pc1; quindi per valori di Pc1
inferiori al 75% può accadere che i valori delle bande totali residue, delle reti generate
dall’algoritmo 6, siano superiori all’unità poiché tali reti sarebbero in grado di alimentare
ulteriori nodi, oltre a quelli delle sequenze che sono stati inseriti nelle reti stesse. Inoltre in
questo esempio l’output band fornita dal nodo sorgente è costante e pari a 4:
Banda Residua
5
4,5
4
Banda Disponibile
3,5
3
2,5
Algoritmo5
Algoritmo6
2
1,5
1
0,5
0
65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99
Pc1
110
Figura 88
In questo esempio si può notare che per Pc1= 65% e Pc1= 67% le reti, generate dal quinto e dal
sesto algoritmo, accettano tutti i nodi che vogliono accedervi e quindi hanno una banda totale
residua superiore all’unità poiché sarebbero in grado di alimentare ulteriori nodi. In ogni modo,
anche in questo esempio si nota che il sesto algoritmo ha un migliore comportamento del quinto
algoritmo, per quanto riguarda l’andamento della banda totale residua in funzione del parametro
Pc1.
Terzo esempio, avente Pc1 che varia tra 50 e 99 e Pc2 che vari tra 50 e 1. Quindi le reti sono
state ottenute considerando 50 sequenze di nodi, dove in ogni sequenza si hanno 1000 nodi.
Anche in questo caso, essendo Pc1 ≥ 50%, allora per i valori di Pc1 inferiori al 75%, circa, può
accadere che la rete accetti tutti i nodi della sequenza caratterizzata da tale valore di Pc1; quindi
per valori di Pc1 inferiori al 75% può accadere che i valori delle bande totali residue, delle reti
generate dall’algoritmo 6, siano superiori all’unità poiché tali reti sarebbero in grado di
alimentare ulteriori nodi, oltre a quelli delle sequenze che sono stati inseriti nelle reti stesse.
Inoltre in questo esempio l’output band fornita dal nodo sorgente è costante e pari a 4:
Banda Residua
140
120
Banda Disponibile
100
80
Algoritmo5
60
Algoritmo6
40
20
0
50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98
Pc1
111
Figura 89
In questo esempio si può notare che per valori di Pc1 ≤ 63% le reti, generate dal quinto e dal
sesto algoritmo, accettano tutti i nodi che vogliono accedervi e quindi hanno una banda totale
residua superiore all’unità poiché sarebbero in grado di alimentare ulteriori nodi. In ogni modo,
anche in questo esempio si nota che il sesto algoritmo ha un migliore comportamento del quinto
algoritmo, per quanto riguarda l’andamento della banda totale residua in funzione del parametro
Pc1.
Quindi confrontando tra loro il quinto ed il sesto algoritmo rispetto alla banda totale residua, in
funzione del parametro Pc1 si nota che: l’algoritmo che minimizza la banda totale residua è il sesto.
4.2.5 NUMERO NODI IN ATTESA IN FUNZIONE DELLA PERCENTUALE DI
NODI CHE HANNO OUTPUT BAND < 1 NELLA SEQUENZA DI
INGRESSO
Per gli algoritmi 5 e 6 si analizza, come quarto parametro prestazionale, il numero dei nodi in
attesa (si vedano le sezioni 3.6 e 3.7 per avere maggiori dettagli sulla lista dei nodi in attesa), in
funzione del parametro Pc1 (che rappresenta la percentuale di nodi, della sequenza di peer che
accedono alla rete, aventi output band < 1): per fare questo il componente software (realizzato in
Java), che implementa ciascun algoritmo, effettua l’inserimento dei nodi generati dall’algoritmo
specificato nella sezione 3.1 di questa tesi, fino a che la rete è in grado di accettare peer. Tale
procedura di inserimento della sequenza di nodi nella rete è ripetuta per ogni sequenza di nodi, dove
tali sequenze sono caratterizzate da un valore del parametro Pc1 che varia tra il suo valore iniziale e
il 99%. In questo modo per ogni valore di Pc1 (e quindi per ogni sequenza di nodi) viene generata
una rete di diffusione del contenuto.
Quindi, per ogni algoritmo si ottiene una tabella ed un corrispondente grafico, nel quale vi è
come variabile indipendente il parametro Pc1 e come variabile dipendente il numero di nodi che
sono in attesa di accedere alla rete. Un esempio di tabella contente i valori del parametro Pc1, con i
relativi valori di “numero di nodi in attesa” è la seguente:
112
Pc1
75
76
77
78
79
80
81
82
83
84
…
90
91
92
93
94
95
96
97
98
99
N°Nodi In Attesa
nell’algoritmo 5
46
94
89
163
144
153
191
144
211
207
…
401
393
397
469
539
551
535
609
609
684
N°Nodi In Attesa
nell’algoritmo 5
41
88
83
147
139
146
184
138
206
199
…
387
386
390
462
532
532
526
591
592
678
Differenza del numero dei nodi
in attesa dei due algoritmi
5
6
6
16
5
7
7
6
5
8
…
14
7
7
7
7
19
9
18
17
6
Il grafico associato a tale tabella, per quanto riguarda il numero dei nodi in attesa, è il seguente:
Numero Nodi in Attesa
800
700
Numero Nodi in attesa
600
500
400
Algoritmo5
300
Algoritmo6
200
100
0
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
Pc1
113
Figura 90
Il grafico associato a tale tabella, per quanto riguarda la differenza tra il numero di nodi in
attesa dell’algoritmo 5 ed il numero dei nodi in attesa dell’algoritmo 6, è il seguente:
Numero nodi in attesa
(differenza tra l'algoritmo 5 e 6)
20
18
16
Numero Nodi
14
12
10
NodiInAttesaDiff
8
6
4
2
0
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
Pc1
Figura 91
Le output band della sequenza di nodi che vogliono accedere alla rete, in questo esempio, sono
state generata dall’algoritmo di generazione della sequenza di nodi descritto nella sezione 3.1 .
Occorre notare che la rete non è più grado di accettare ulteriori nodi, specificati nella sequenza
di peer che vogliono accedere alla rete stessa, quando per i suoi vincoli di banda non è possibile
inserire un nuovo nodo in essa, e quindi tale nodo verrà messo nella lista dei nodi in attesa.
Inoltre in questa sezione si presentano una serie di esempi relativi al numero dei nodi in attesa
al variare del parametro Pc1. Nel primo esempio il parametro Pc1 è stato scelto ≥ 75% di modo che
la rete tenda alla condizione nella quale non è più in grado di accettare nuovi nodi, e di modo che
l’eventuale inserimento di un nuovo nodo avvenga con la ristrutturazione locale della rete stessa.
Se, invece, la percentuale Pc1 è inferiore al 75% allora può capitare che la rete accetti tutti i nodi
che vogliono accedere alla rete stessa e conseguentemente non si avranno peer in attesa.
114
Primo esempio, avente Pc1 che varia tra 75 e 99 e Pc2 che vari tra 25 e 1. Quindi le reti sono
state ottenute considerando 25 sequenze di nodi, dove in ogni sequenza si hanno 1000 nodi. Pc1
è stato scelto ≥ 75 di modo che la rete sia in condizione di non accettare ulteriori nodi di modo
che l’eventuale inserimento di un nuovo nodo avvenga, solo, con ristrutturazione locale della
rete stessa. Inoltre in questo esempio l’output band fornita dal nodo sorgente è costante e pari a
4:
Numero Nodi in Attesa
800
Numero Nodi in attesa
700
600
500
400
Algoritmo5
300
Algoritmo6
200
100
0
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
Pc1
Figura 92
Numero nodi in attesa
(differenza tra l'algoritmo 5 e 6)
20
18
Numero Nodi
16
14
12
10
8
NodiInAttesaDiff
6
4
2
0
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
Pc1
Figura 93
115
Secondo esempio, avente Pc1 che varia tra 65 e 99 e Pc2 che vari tra 35 e 1. Quindi le reti sono
state ottenute considerando 35 sequenze di nodi, dove in ogni sequenza si hanno 1000 nodi.
Essendo Pc1 ≥ 65%, allora per i valori di Pc1 inferiori al 75%, circa, può accadere che la rete
accetti tutti i nodi della sequenza caratterizzata da tale valore di Pc1. Inoltre in questo esempio
l’output band fornita dal nodo sorgente è costante e pari a 4:
Numero Nodi in Attesa
800
Numero Nodi in attesa
700
600
500
400
Algoritmo5
300
Algoritmo6
200
100
0
65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99
Pc1
Figura 94
Numero nodi in attesa
(differenza tra l'algoritmo 5 e 6)
40
35
Numero Nodi
30
25
20
NodiInAttesaDiff
15
10
5
0
65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99
Pc1
Figura 95
116
In questo esempio si può notare che per Pc1= 65% e Pc1= 67% la rete accetta tutti i nodi che
vogliono accedervi e quindi non vi sono nodi in attesa.
Terzo esempio, avente Pc1 che varia tra 50 e 99 e Pc2 che vari tra 50 e 1. Quindi le reti sono
state ottenute considerando 50 sequenze di nodi, dove in ogni sequenza si hanno 1000 nodi.
Anche in questo caso, essendo Pc1 ≥ 50%, allora per i valori di Pc1 inferiori al 75%, circa, può
accadere che la rete accetti tutti i nodi della sequenza caratterizzata da tale valore di Pc1. Inoltre
in questo esempio l’output band fornita dal nodo sorgente è costante e pari a 4:
Numero Nodi in Attesa
900
Numero Nodi in attesa
800
700
600
500
400
Algoritmo5
300
Algoritmo6
200
100
0
50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98
Pc1
Figura 96
Numero nodi in attesa
(differenza tra l'algoritmo 5 e 6)
25
Numero Nodi
20
15
10
NodiInAttesaDiff
5
0
50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98
Pc1
Figura 97
117
In questo esempio si può notare che per valori di Pc1 ≤ 63% , circa, la rete accetta tutti i nodi
che vogliono accedervi, e quindi il numero dei nodi che risultano essere in attesa di essere
inseriti è nullo.
Quindi confrontando i due algoritmi in base al numero dei nodi in attesa, in funzione del
parametro Pc1, si nota che: l’algoritmo che minimizza il numero di nodi in attesa è il sesto.
118
5 CONCLUSIONI
L’obiettivo di questa tesi è rappresentato dalla creazione e realizzazione di nuovi algoritmi per
la costruzione di reti peer to peer adottate per la diffusione di contenuti; questi algoritmi sono stati
ideati basandosi su un algoritmo di peer to peer, per la diffusione di contenuti su canale
asimmetrico, sviluppato dal prof. Ing. Gianluca Mazzini e Riccardo Rovatti. Nei nuovi algoritmi
non è prevista l’ipotesi per la quale tutti i peer che vogliono accedere alla rete hanno la medesima
output band, mentre nell’algoritmo di base tale ipotesi era prevista. Inoltre nei nuovi algoritmi si ha,
come ipotesi aggiuntiva, il fatto che i peer possono avere un output band maggiore di 1 (ossia della
output band richiesta dal contenuto normalizzata all’unità).
Questi algoritmi sono applicati ad un scenario nel quale il nodo sorgente emette il contenuto
mentre i nodi utente, o anche detti peer, sono in grado di accettare stream parziali (o contenuti
parziali) provenienti da più di un nodo attraverso il loro collegamento d'ingresso e di ridistribuire
tale contenuto ad uno o più ulteriori peer attraverso il loro link di uscita. Questo crea una rete di
distribuzione del contenuto modellata attraverso un grafo diretto orientato dalla sorgente. Tale grafo
deve essere creato ed aggiornato dinamicamente quando un nuovo peer entra nella rete.
Sono stati realizzati sei algoritmi differenti per la creazione di reti adottate per la diffusione di
contenuti erogati da un unico nodo sorgente.
Negli algoritmi 1,2 e 5 la rete, che viene generata, è strutturata in tier o file dove ogni tier
alimenta quello successivo; ciò si verifica per tutti i tier tranne il primo, il quale è alimentato
solamente dal nodo sorgente. Gli algoritmi 1,2 e 5 si differenziano in base alle modalità di
inserimento di nuovi nodi nella rete.
Negli algoritmi 3,4 e 6 la rete, che viene generata, è rappresentata attraverso una lista che
contiene tutti i peer presenti nella rete stessa; inizialmente tale lista contiene solo il nodo sorgente;
inoltre, ogni nodo, presente nella rete, contiene al suo interno la lista dei suoi peer figli. Quindi in
questo caso, il nuovo nodo che vuole accedere alla rete deve racimolare un quantitativo di banda
pari a quella richiesta dal contenuto stesso richiedendola ai vari peer della rete; se il nuovo peer è in
grado di racimolare la banda richiesta allora tale nodo viene inserito nella rete.
Gli algoritmi 1,2,3 e 4 presentano un blocco all’ingresso ossia nel caso in cui la rete generata
non è più in grado di accettare un nuovo nodo, l’algoritmo non permetterà l’inserimento dei peer
successivi, anche se attraverso un’opportuna ristrutturazione locale (che si potrebbe applicare agli
algoritmi 2 e 4 essendo questi caratterizzati da un inserimento con eventuale ristrutturazione) della
rete stessa, potrebbero essere inseriti. Basandosi su questa considerazione sono nati gli algoritmi 5 e
6 nei quali si accettano nella rete solamente i nodi inseribili anche eventualmente con
119
ristrutturazione locale, mettendo in attesa quei peer che risultano essere non inseribili nella rete;
questi peer sospesi sono in attesa che venga inserito nella rete un nuovo nodo avente una output
band talmente elevata da garantire l’inserimento di uno o più peer presenti nella lista di attesa.
Il primo algoritmo per il peer to peer prova ad aggiungere il nuovo peer nel tier caratterizzato
dal ritardo minimo, ossia nel tier più vicino possibile al nodo sorgente, in modo tale da soddisfare i
vincoli sull'ampiezza di banda e quindi tale algoritmo viene terminato con insuccesso (fallisce) se
non si possono alimentare ulteriori peer da parte dei peer che vi sono nei vari tiers della rete di
diffusione del contenuto.
Questo algoritmo è sub-ottimo nel numero di peer serviti. Infatti, si potrebbe racimolare
l'output band non utilizzata dai differenti tier per alimentare un nuovo nodo o in alternativa si
potrebbe fare la seguente considerazione: data una sequenza di nodi con output band diverse, questi
nodi accedono successivamente alla rete e questa accetta nodi finché l’ultimo tier che ha banda a
disposizione è in grado di alimentare un nuovo nodo; quindi la rete non è più in grado di accettare
nodi quando l’ultimo tier disponibile non ha una banda sufficiente (ossia ≥ 1) in grado di alimentare
un nuovo nodo.
Quindi in questo caso si può nota che:
1.
Data una sequenza di nodi con le seguenti output band: B1, B2, … , Bn con
B1<B2<…<Bn≤Bc=1
allora si suppone che il numero massimo di nodi che la rete è in grado di accettare sia
pari a K;
2.
Se invece si considerano gli stessi nodi con le stesse output band ma con una sequenza
di accesso dei nodi alla rete tale per cui vengono inseriti prima i nodi con output band
maggiore, ossia se i nodi con bande di output maggiori vanno a finire nei tiers più
vicini al nodo sorgente, allora si verifica che il numero massimo di nodi che la rete
Peer to Peer è in grado di accettare risulterà essere > K o al più uguale a K.
In questo modo la situazione ideale sarebbe quella di avere un algoritmo che inserisca, di volta
in volta, il nuovo nodo nella rete determinando in che tier inserirlo in base alla sua output band. Per
tale motivo è stato ideato il secondo algoritmo.
Il secondo algoritmo ha il seguente comportamento: dato un nodo con output band pari a Bj
allora tale nodo viene inserito:
nel primo tier se Bj è superiore al output band del peer avente banda minima per tale
tier;
120
altrimenti il nodo viene inserito nel tier avente output band minima < Bj ed avente
output band minima del tier precedente ≥ Bj.
Per notazione il tier dove viene inserito il nodo considerato viene indicato come tier i-esimo.
Quindi in questa situazione se, per i requisiti di banda del i-esimo tier il nodo da inserire può essere
direttamente inserito nell’i-esimo tier stesso allora lo si inserisce senza effettuare ristrutturazioni
della rete.
Se invece nel tier i-esimo non possono essere inseriti ulteriori nodi per i requisiti di banda
(poiché la banda disponibile nel tier i-esimo è inferiore all’unità) allora si determina il nodo Nm
avente banda in output minima presente nel tier i-esimo, lo si estrae dal tier e lo si sostituisce con il
nuovo nodo.
In questo modo il nodo Nm estratto viene inserito nel tier successivo, inserendolo direttamente
pi −1
nel tier se vi è posto (ossia se ∑ Ω k ≥ ( pi +1 + 1) ), altrimenti si determina il nodo avente output band
k =0
minore, in tale tier, e questo viene sostituito con il nodo Nm. Tale procedura ricorsiva si termina se:
1.
il nodo che deve essere inserito nel tier a cui si è giunti può essere inserito
direttamente (senza ristrutturazione locale) poiché i requisiti di banda lo consentono;
2.
oppure se si giunge all’ultimo tier e si riesce ad inserire il nodo prelevato dal tier
precedente poiché per l’ultimo tier sono garantiti i requisiti di banda richiesti dal
contenuto multimediale (ossia banda totale in upload dell’ultimo tier ≥ 1);
3.
oppure se la rete non è in grado di accettare più nodi; ciò si verifica se, con la
procedura ricorsiva, si giunge all’ultimo tier e se per questo non sono garantiti i
requisiti di banda richiesti dal contenuto multimediale (ossia output band totale
dell’ultimo tier < 1). Quindi a causa di tale evento prima di effettuare l’inserimento si
controllano tutte le condizioni sui requisiti di banda che vengono considerate a causa
dell’inserimento ricorsivo dei nodi.
Questo algoritmo presenta, rispetto al primo algoritmo, un possibile aumento del numero di
nodi inseribili nella rete a scapito di un onere rappresentato dal costo delle varie ristrutturazioni
locali della rete che potenzialmente si possono verificare ad ogni inserimento.
Nelle reti generate, sia dal primo che dal secondo algoritmo, si potrebbe racimolare l'output
band non utilizzata dai differenti tier per alimentare un nuovo nodo. In base a questa considerazione
è stato introdotto e realizzato il terzo algoritmo. Un ulteriore svantaggio del secondo algoritmo è
rappresentato dal costo delle ristrutturazioni locali generate a seguito dell’inserimento dei nuovi
nodi.
121
Nell’algoritmo 3 si ha il seguente comportamento: ogni nodo che vuole accedere alla rete,
interpella i vari nodi presenti nella rete stessa al fine di racimolare un quantitativo di banda pari alla
banda necessaria per acquisire il contenuto considerato. Se il nuovo peer è in grado di ottenere, dai
nodi già presenti nella rete, l’ampiezza di banda richiesta dal contenuto allora il nuovo nodo viene
inserito nella rete stessa ed inizia ad acquisire il contenuto considerato. Se invece il nuovo peer non
è in grado di racimolare un quantitativo di banda sufficiente ad acquisire il contenuto allora la rete
non è più in grado di accettare ulteriori nodi, oltre a quelli già presenti.
Lo svantaggio che si ha nel terzo algoritmo è dovuto al fatto che: modificando,
opportunamente,
l’algoritmo 3 di modo che l’inserimento dei nodi venga effettuato con una
eventuale ristrutturazione locale della rete, si ottiene un nuovo algoritmo che consente di aumentare
il numero massimo di nodi inseribili nella rete, a scapito di un costo dovuto alle ristrutturazioni
stesse. Da questa considerazione si ottiene l’algoritmo 4.
Il quarto algoritmo è del tutto analogo a quello precedente con l’aggiunta della ristrutturazione
locale della rete nel caso in cui l’inserimento di un nuovo nodo può essere effettuato solo
sostituendo il nodo avente output band minima con il nuovo nodo e reinserendo il nodo avente
banda minima. In questo caso si ferma l’inserimento di nuovi nodi, se il nuovo nodo entrante risulta
essere non inseribile nella rete anche con la sostituzione di questo con il nodo a banda di upload
minima. Quando si verifica tale evento il sistema rifiuta l’inserimento di nuovi nodi nella rete anche
se questi potrebbero essere inseriti con ristrutturazione locale. Lo svantaggio presente nel quarto
algoritmo è rappresentato dal costo delle ristrutturazioni locali generate a seguito dell’inserimento
dei nuovi nodi.
Occorre notare che negli algoritmi 2 e 4, che presentano ristrutturazioni locali, si potrebbe
pensare che:
se la rete non accetta più nodi poiché ha una banda totale disponibile < 1 allora si può
pensare di mettere in attesa tutti i nodi successivi che tentano di accedere alla rete
aspettando che arrivi un nuovo nodo che sia in grado di aumentare la banda totale
disponibile della rete;
quando si verifica tale condizione si inserisce nella rete il nodo a banda elevata con
ristrutturazione locale e successivamente si provano ad inserire i nodi in attesa, che erano
stati sospesi poiché la banda totale disponibile della rete prima dell’ultimo inserimento
era < 1.
In base a questa considerazione sono nati gli algoritmi 5 e 6.
122
Il quinto algoritmo è derivato dal secondo algoritmo presentato, con l’ipotesi aggiuntiva di non
avere il blocco all’ingresso della rete, ossia si inseriscono tutti i nodi inseribili nella sequenza di
nodi di ingresso scartando quelli non inseribili. Per fare questo si modifica il comportamento del
secondo algoritmo, per quanto riguarda la situazione nella quale il nuovo nodo non è inseribile nella
rete, cioè:
se la rete non accetta più nodi poiché ha una banda totale disponibile < 1, in tutti i suoi
tier, allora si mettono in attesa tutti i nodi successivi che tentano di accedere alla rete,
aspettando che arrivi un nodo che sia in grado di aumentare la banda totale disponibile in
almeno un tier della rete;
quando si verifica tale condizione si inserisce nella rete il nodo a banda elevata con
ristrutturazione locale e successivamente si provano ad inserire i nodi in attesa che erano
stati sospesi.
Il sesto algoritmo è derivato dal quarto algoritmo presentato con l’ipotesi aggiuntiva di non
avere il blocco all’ingresso della rete, ossia si inseriscono tutti i nodi inseribili nella sequenza di
nodi di ingresso scartando quelli non inseribili.
Per fare questo si modifica il comportamento del quarto algoritmo, per quanto riguarda la
situazione nella quale il nuovo nodo non è inseribile nella rete, cioè:
si consideri la seguente condizione:
BtotDisp – [La banda del nodo a banda minima della rete] + Bi ≥ 1
(1)
se la rete non accetta più nodi poiché ha una banda totale disponibile < 1 allora si
mettono in attesa tutti i nodi successivi che tentano di accedere alla rete aspettando che
arrivi un nodo che garantisca il verificarsi della condizione (1), ossia di un nodo che sia
in grado di aumentare la banda totale disponibile della rete;
quando si verifica tale condizione si inserisce nella rete il nodo a banda elevata (che
verifica la condizione (1)) con ristrutturazione locale e successivamente si provano ad
inserire i nodi in attesa, che erano stati sospesi poiché la banda totale disponibile della
rete prima dell’ultimo inserimento era < 1.
Quindi sia nel quinto che nel sesto algoritmo non si giunge mai in una situazione nella quale la
rete non è in grado di accettare nuovi nodi poiché prima o poi giungerà un nodo con output band
sufficientemente elevata da consentire l’inserimento dei nodi sospesi.
Dagli esempi e dai risultati mostrati nel capitolo 5 si può concludere che gli algoritmi, descritti
in questa tesi, garantiscono un miglioramento in termini di numero massimo di nodi inseribili nella
123
rete ed in termini di banda totale residua dell’intera rete, rispetto all’algoritmo Mazzini/Rovatti
[9]
adattato alle nuove condizioni di rete:
in particolare per quanto riguarda gli algoritmi con blocco all’ingresso (rappresentati
dai primi quattro algoritmi) quello che garantisce un maggior numero di nodi inseribili
e la minimizzazione della banda totale residua della rete è il quarto; se però per la
tipologia di contenuto da diffondere la ristrutturazione locale della rete, che
potenzialmente si può verificare all’inserimento di ogni nuovo nodo, è indesiderata per
la corretta distribuzione del contenuto stesso, allora l’algoritmo che garantisce un
maggior numero di nodi inseribili, con costo di ristrutturazione locale sempre nullo, è
rappresentato dal terzo algoritmo;
mentre per quanto riguarda gli algoritmi senza blocco all’ingresso (ossia gli algoritmi 5
e 6) quello che, in genere, garantisce la massimizzazione del numero di nodi inseribili
nella rete, la minimizzazione della banda totale residua della rete, la minimizzazione
del numero dei nodi in attesa ed un minor costo di ristrutturazione locale è il sesto
algoritmo.
124
6 BIBLIOGRAFIA
[1] Appunti del corso di “Reti di Calcolatori”, docente: prof. Cesare Stefanelli, anno accademico
2004/2005
[2] Wikipedia, storia di Napster: “http://en.wikipedia.org/wiki/Napster”
[3] Wikipedia, storia di Gnutella: “http://en.wikipedia.org/wiki/Gnutella”
[4] Wikipedia, storia di KaZaA: “http://en.wikipedia.org/wiki/Kazaa”
[5] Wikipedia, storia di BitTorrent: “http://en.wikipedia.org/wiki/BitTorrent_client”
[6] Slide: Peer-to-Peer Applications Reading: 9.4, COS 461: Computer Networks, Spring 2007
MW 1:30-2:50 in Friend 004), Jennifer Rexford Teaching Assistant: Ioannis Avramopoulos
[7] Reti di Telecomunicazioni, Gianluca Mazzini, Pitagora editrice Bologna; il multicast, da pagina
252 a pagina 265
[8] Peer to Peer File Download and Streaming, Gang Wu and Tzi-cker Chiueh, Department of
Computer Science, Stony Brook University, pagine 1 e 2
[9] Peer-to-Peer Distribution on Asymmetric Channels, Gianluca Mazzini, Riccardo Rovatti
125
126
7 RINGRAZIAMENTI
La vita riserva tante sorprese, tante emozioni che certe volte risultano essere inaspettate e tanto
desiderate.. Quando mi sono iscritto
iscritto all’università non pensavo, ma ci speravo, di potermi laureare
con una carriera così impressionate.
impressionate. Per questo motivo devo ringraziare tutti i docenti della
specialistica che mi hanno permesso, attraverso le loro capacità oratorie e la loro disponibilità,
disponibilità di
superare tutti gli esami con ottimi voti.
voti In particolare devo ringraziare il professore Gianluca
Gianluc
Mazzini per avermi dato la possibilità di fare la tesi con lui, per tutta la sua disponibilità e pazienza.
Devo ringraziare anche una persona, mia nonna Triestina, che mi pensava e amava tanto e non è
riuscita a vedermi laureato nella specialistica perché, purtroppo,, è venuta a mancare nel
ne mese di
settembre di quest’anno.
Inoltre devo ringraziare i miei genitori che mi hanno sostenuto sia moralmente che
economicamente durante tutto il percorso universitario.
Infine, ma non per ultima, devo ringraziare con
con tutto il cuore il mio amore, la gioia dei miei
occhi che mi ha dato la forza di poter superare gli ultimi due esami in un brevissimo periodo e con
voti veramente ottimi. Cara Barbara sei solamente tu,
tu che vedendoti e stando insieme a te, mi dai la
forza di vivere e superare tutte le avversità della mia esistenza,
esistenza, senza di te non saprei come fare,
grazie. Non so come ringraziarti per tutte le serate che abbiamo passato assieme e che passiamo
insieme perché, forse tu non te ne rendi conto completamente, ma il tuo amore mi fa sentire una
persona migliore e mi permette di fare qualunque cosa per il nostro bene, grazie.
grazie Per questo motivo
dedico questa tesi a te amore mio.
Danilo Merlanti
127
