Reti di telecomunicazioni LS Guida agli esercizi TCP con...
20
Reti di telecomunicazioni LS Guida agli esercizi TCP con NSCRIPT ESERCIZIO 1 - Monitoraggio del Rate Prima di eseguire l’esercizio si deve introdurre il concetto di Prodotto Banda per Ritardo: esso rappresenta la quantità di informazione che occupa al 100% la tratta tra trasmettitore e ricevitore. L’esercizio seguente verrà proposto con finestra di trasmissione 6 segmenti (collegamento sotto- utilizzato) e 26 segmenti (collegamento ottimo). La rete da simulare è quella riportata nella seguente Fig.1 Fig. 1 Rete da simulare La topologia della rete è la seguente: a) Link bidirezionale con: - capacità 10 Mb/s - ritardo 10 ms - politica di gestione della coda DropTail; b) Due nodi: sorgente e destinazione; c) Protocollo di trasporto: TCP RFC793; d) Finestra di trasmissione: 6 e 26 segmenti; e) Sorgente: CBR (Costant Bit Rate) 10 Mb/s e l’inizio della trasmissione dei dati avviene a 0.0 secondi; f) Tempo di simulazione: 5 secondi. Ora si utilizza NSCRIPT per assemblare la rete richiesta. Vengono disposti sulla finestra di lavoro i nodi, i link, gli agent Transport, l’applicazione e le varie utilities necessarie per il monitoraggio del Rate, selezionandoli dagli opportuni menù come descritto. Sliding window: 6 La rete che si ottiene è quella rappresentata in Fig. 2.
Transcript of Reti di telecomunicazioni LS Guida agli esercizi TCP con...
Reti di telecomunicazioni LS
Guida agli esercizi TCP con NSCRIPT
ESERCIZIO 1 - Monitoraggio del Rate Prima di eseguire l’esercizio si deve introdurre il concetto di Prodotto Banda per Ritardo: esso rappresenta la quantità di informazione che occupa al 100% la tratta tra trasmettitore e ricevitore. L’esercizio seguente verrà proposto con finestra di trasmissione 6 segmenti (collegamento sotto-utilizzato) e 26 segmenti (collegamento ottimo). La rete da simulare è quella riportata nella seguente Fig.1
Fig. 1 Rete da simulare
La topologia della rete è la seguente:
a) Link bidirezionale con: - capacità 10 Mb/s - ritardo 10 ms - politica di gestione della coda DropTail;
b) Due nodi: sorgente e destinazione; c) Protocollo di trasporto: TCP � RFC793; d) Finestra di trasmissione: 6 e 26 segmenti; e) Sorgente: CBR (Costant Bit Rate) 10 Mb/s e l’inizio della trasmissione dei dati avviene a 0.0 secondi; f) Tempo di simulazione: 5 secondi.
Ora si utilizza NSCRIPT per assemblare la rete richiesta. Vengono disposti sulla finestra di lavoro i nodi, i link, gli agent Transport, l’applicazione e le varie utilities necessarie per il monitoraggio del Rate, selezionandoli dagli opportuni menù come descritto. Sliding window: 6 La rete che si ottiene è quella rappresentata in Fig. 2.
Fig. 2 Rete
Dopo aver selezionato il link, vengono scritti i parametri del collegamento nelle opportune celle come riportato nella seguente Fig. 3.
Fig. 3 Parametri del Link
Si analizza la finestra del TCP selezionando l’icona e scrivendo 6 in Max Window Size come indicato in Fig. 4.
Fig. 4 Paramentri TCP
Viene analizzata l’applicazione CBR selezionando l’icona e scrivendo 10000Kb in Rate come riportato nella seguente Fig. 5.
Fig. 5 Parametri CBR
Per assegnare un colore, si clicca su , si apre una finestra (Fig. 6) dove a ogni numero viene assegnato un colore. Successivamente si clicca sull’agent Transport, nella cella Flow ID (Fig.4), specificare il numero a cui è stato attribuito un determinato colore nell’oggetto Colors0.
Fig. 6 Colors0
Per eseguire il monitoraggio del rate si utilizzano due Utilities: e . Il MonitorRate0 traduce graficamente la seguente riga di comando scritta in linguaggio OTcl:
set MonitorRate0[$ns monitor-queue $Node0 $Node1 [$ns get-ns-traceall]] Il MonitorRate0 deve essere posizionato sul link, quindi bisogna selezionarlo poi specificare i nodi che si trovano alle estremità del collegamento come rappresentato in Fig. 7.
Fig. 7 Parametri MonitorRate0
Il RATE0 traduce graficamente le seguenti righe di comando scritte in linguaggio OTcl: $ns at 0.0 "RATE0_trace"; set RATE0 [open RATE0.trc w]; close $RATE0; set NumBytePrec1 0; set TimePrec1 0; proc RATE0_trace {} {; global ns MonitorRate0; set RATE0 [open RATE0.trc a]; global NumBytePrec1 TimePrec1; set now [$ns now]; set Bytes [$MonitorRate0 set barrivals_]; set DeltaByte [expr $Bytes-$NumBytePrec1]; set DeltaTime [expr $now-$TimePrec1]; if { $DeltaTime == 0 } then { $ns after .1 "RATE0_trace"; return;
}; } puts $RATE0 "$now [expr $DeltaByte/$DeltaTime*8]"; set NumBytePrec1 $Bytes; set TimePrec1 $now; close $RATE0; $ns after .1 "RATE0_trace"; }; Il RATE0 utilizza il MonitorRate0 per creare un file trace per monitorare il rate sul link, quindi si
seleziona l’icona e scrivendo MonitorRate0 in Object come indicato in Fig. 8.
Fig. 8 RATE0
Nella precedente figura (Fig. 8) si osserva che può indicare l’istante di tempo in cui iniziare il monitoraggio del rate (start) e l’intervallo con cui vengono presi i campioni (dt). I risultati ottenuti sono riportati nelle seguenti Fig. 9.
Fig. 9 Rate con cwnd= 6
Sliding window: 26 La rete che si ottiene è quella mostrata nella Fig. 2. Rispetto a quella con finestra 6 va cambiato il parametro Max Window Size del TCP come mostrato nella seguente Fig. 10.
Fig. 10 Parametri TCP
I risultati ottenuti sono riportati nelle seguenti Fig. 11.
Fig.11 Rate con cwnd= 26
ESERCIZIO 2 - Studio del TCP La rete da realizzare è quella riportata nella seguente Fig. 12.
Fig. 12 Rete da simulare
La topologia della rete è la seguente:
a) Link bidirezionale con: - capacità 10 Mb/s - ritardo 100 ms - politica di gestione della coda DropTail;
b) Link bidirezionale con: - capacità 256 Kb/s - ritardo 100 ms
- politica di gestione della coda DropTail - coda 18 (ss, noss, ca) 8 (ssca);
c) Tre nodi: sorgente, router e destinazione; d) Protocollo di trasporto: TCP con i vari algoritmi; e) Finestra di trasmissione: 20 segmenti; f) Sorgente: FTP con l’inizio della trasmissione dei dati a 0.1 secondi; g) Tempo di simulazione: 12 secondi.
In questo esercizio si studiano i vari algoritmi del TCP. Algoritmo di Slow Start (SS) La rete che si ottiene con NSCRIPT è quella rappresentata in Fig. 13.
Fig. 13 Rete
Per impostare la coda sul link che connette Node1 con Node2 lo si seleziona e viene scritto il valore 18 nell’opportuna cella come mostrato in Fig. 14.
Fig. 14 Parametri del Link
Per vedere il funzionamento di questo algoritmo si utilizza l’icona TCPeduSS0 che traduce graficamente le seguenti righe di comando scritte in linguaggio OTcl: set TCPeduSS0 [new Agent/TCP/RFC793edu]; $TCPeduSS0 set add793slowstart_ false; $TCPeduSS0 set add793exponinc_ true; $TCPeduSS0 set add793additiveinc_ false; $ns at 0.01 "$TCPeduSS0 set ssthresh_ 1"; $TCPeduSS0 set fid_ 1;
In questo esercizio si vogliono monitorare la finestra di trasmissione, il numero di sequenza e le
perdite, quindi rispettivamente si utilizzano , , , (per le perdite bisogna usare contemporaneamente MonitoCoda0 e Loss0). Il CWND0 traduce graficamente le seguenti righe di comando scritte in linguaggio OTcl: $ns at 0.0 "CWND0_trace"; set CWND0 [open CWND0.trc w]; close $CWND0; proc CWND0_trace {} {; global ns TCPeduSS0; set CWND0 [open CWND0.trc a]; set now [$ns now]; set curr_cwnd [$TCPeduSS0 set cwnd_]; set curr_wnd [$TCPeduSS0 set window_]; if { $curr_wnd < $curr_cwnd } {; set swnd $curr_wnd; } else {; set swnd $curr_cwnd; }; puts $CWND0 "$now $swnd"; close $CWND0; $ns after .1 "CWND0_trace"; }; Il CWND0 crea un file trace per monitorare la finestra di trasmissione dell’agent Transport, quindi
si seleziona l’icona e scrivendo TCPeduSS0 in Object come indicato in Fig. 15.
Fig. 15 CWND0
Il SeqN0 traduce graficamente le seguenti righe di comando scritte in linguaggio OTcl: $ns at 0.0 "SeqN0_trace"; set SeqN0 [open SeqN0.trc w]; close $SeqN0; proc SeqN0_trace {} {; global ns TCPeduSS0; set SeqN0 [open SeqN0.trc a]; set now [$ns now]; set seqno [$TCPeduSS0 set t_seqno_ ]; set sst [$TCPeduSS0 set ssthresh_ ]; puts $SeqN0 "$now $seqno $sst"; close $SeqN0; $ns after .1 "SeqN0_trace"; };
Il SeqN0 crea un file trace per monitorare il numero di sequenza dei pacchetti trasmessi dell’agent
Transport, quindi si seleziona l’icona e scrivendo TCPeduSS0 in Object come indicato in Fig. 16.
Fig. 16 SeqN0
Il MonitorCoda0 traduce graficamente le seguenti righe di comando scritte in linguaggio OTcl: set MonitorCoda0 [$ns monitor-queue $Node1 $Node2 1 2] Il MonitorCoda0 deve essere posizionato sul link, quindi bisogna selezionarlo poi specificare i nodi che si trovano alle estremità del collegamento come rappresentato in Fig. 17.
Fig. 17 MonitorCoda0
Il LOSS0 traduce graficamente le seguenti righe di comando scritte in linguaggio OTcl: $ns at 0.0 "LOSS0_trace"; set LOSS0 [open LOSS0.trc w]; close $LOSS0; proc LOSS0_trace {} {; global ns MonitorCoda0; set LOSS0 [open LOSS0.trc a]; set now [$ns now]; set curr_loss [$MonitorCoda0 set pdrops_ ]; puts $LOSS0 "$now $curr_loss"; close $LOSS0; $ns after .1 "LOSS0_trace"; }; Il LOSS0 utilizza il MonitorCoda0 per creare un file trace per monitorare la perdita dei pacchetti sul
link, quindi si seleziona l’icona e scrivendo MonitorCoda0 in Object come indicato in Fig. 18.
Fig. 18 LOSS0
I risultati ottenuti sono riportati nelle seguenti Fig. 18 e Fig. 19.
Fig. 18 Finestra di trasmissione con algoritmo di Slow Start
Fig. 19 Numero di sequenza con algoritmo di Slow Start
Assenza dell’ algoritmo di Slow Start (NOSS) La rete che si ottiene con NSCRIPT è quella rappresentata in Fig. 20.
Fig. 20 Rete
Il TCPeduNOSS0 traduce graficamente le seguenti righe di comando scritte in linguaggio OTcl: set TCPeduNOSS0 [new Agent/TCP/RFC793edu]; $TCPeduNOSS0 set add793slowstart_ false; $TCPeduNOSS0 set add793exponinc_ false; $TCPeduNOSS0 set add793additiveinc_ false; $ns at 0.01 "$TCPeduNOSS0 set ssthresh_ 1"; $TCPeduNOSS0 set fid_ 1; Dopo aver creato lo script, lo simuliamo con NS2 e i risultati ottenuti sono riportati nelle seguenti Fig. 21, Fig. 22 e Fig. 23.
Fig. 21 Finestra di trasmissione senza algoritmo di Slow Start
Fig. 22 Numero di sequenza senza algoritmo di Slow Start
Fig. 23 Perdite senza algoritmo di Slow Start
Algoritmo di Congestion Avoidance (CA) La rete che si ottiene con NSCRIPT è quella rappresentata in Fig. 24.
Fig. 24 Rete
Il TCPeduCA0 traduce graficamente le seguenti righe di comando scritte in linguaggio OTcl: set TCPeduCA0 [new Agent/TCP/RFC793edu]; $TCPeduCA0 set add793slowstart_ false; $TCPeduCA0 set add793exponinc_ false; $TCPeduCA0 set add793additiveinc_ true; $ns at 0.01 "$TCPeduCA0 set ssthresh_ 1"; $TCPeduCA0 set fid_ 1; I risultati della simulazione sono riportati nelle seguenti Fig. 25 e Fig. 26.
Fig. 25 Finestra di trasmissione con algoritmo di Congestion Avoidance
Fig. 26 Numero di sequenza con algoritmo di Congestion Avoidance
Algoritmo di Slow Start e Congestion Avoidance (SSCA) La rete che si ottiene con NSCRIPT è quella rappresentata in Fig. 27.
Fig. 28Rete
Il TCPeduSSCA0 traduce graficamente le seguenti righe di comando scritte in linguaggio OTcl: set TCPeduSSCA0 [new Agent/TCP/RFC793edu]; $TCPeduSSCA0 set add793slowstart_ true; $TCPeduSSCA0 set add793exponinc_ false; $TCPeduSSCA0 set add793additiveinc_ false; $ns at 0.01 "$TCPeduSSCA0 set ssthresh_ 100"; $TCPeduSSCA0 set fid_ 1; In questa simulazione poniamo una coda sul link tra Node1 e Node2 pari a 8; per inserire questo dato basta cliccare sul link e digitare 8 nella cella Queue Capacity come riportato nella seguente Fig. 29.
Fig. 29 Parametri del Link
I risultati della simulazione sono riportati nelle seguenti Fig. 30, Fig. 31 e Fig. 32.
Fig. 30 Finestra di trasmissione con Slow Start e Congestion Avoidance
Fig. 31 Numero di sequenza con Slow Start e Congestion Avoidance
Fig. 32 Perdite con Slow Start e Congestion Avoidance
Algoritmo di Fast Retransmit (FRET) La rete da realizzare è quella riportata nella seguente Fig. 33.
0 1 29
Sink
0 1 29
Sink
Fig. 33 Rete da simulare
La topologia della rete è la seguente:
a) Link bidirezionale con: - capacità 1 Mb/s - ritardo 10 ms - politica di gestione della coda DropTail;
b) Link bidirezionale con: - capacità 50 Kb/s - ritardo 10 ms - politica di gestione della coda DropTail - coda 19;
c) Tre nodi: sorgente, router e destinazione; d) Protocollo di trasporto: TCP con algoritmo Fast Retransmit; e) Finestra di trasmissione: 20 segmenti; f) Sorgente: FTP con l’inizio della trasmissione dei dati a 0.1 secondi; g) Tempo di simulazione: 30 secondi.
La rete che si ottiene con NSCRIPT è quella rappresentata in Fig. 34.
Fig. 34 Rete
Il TCPeduFRET0 traduce graficamente le seguenti righe di comando scritte in linguaggio OTcl: set TCPeduFRET0 [new Agent/TCP/RFC793edu]; $TCPeduFRET0 set window_ 20; $TCPeduFRET0 set add793slowstart_ true; $TCPeduFRET0 set add793fastrtx_ true; $TCPeduFRET0 set add793jacobsonrtt_ true; $TCPeduFRET0 set add793karnrtt_ true; $TCPeduFRET0 set add793expbackoff_ true; $TCPeduFRET0 set add793slowstart_ true; $TCPeduFRET0 set fid_ 1; I risultati della simulazione sono riportati nelle seguenti Fig. 35 e Fig. 36.
Fig. 35 Finestra di trasmissione con algoritmo di Fast Retransmit
Fig. 36 Numero di sequenza con algoritmo di Fast Retransmit
Assenza dell’algoritmo di Fast Retransmit (NOFRET) La rete che si ottiene con NSCRIPT è quella rappresentata in Fig. 37.
Fig. 37 Rete
Il TCPeduNOFRET0 traduce graficamente le seguenti righe di comando scritte in linguaggio OTcl: set TCPeduNOFRET0 [new Agent/TCP/RFC793edu]; $TCPeduNOFRET0 set window_ 20; $TCPeduNOFRET0 set add793slowstart_ true; $TCPeduNOFRET0 set add793fastrtx_ false; $TCPeduNOFRET0 set add793jacobsonrtt_ true; $TCPeduNOFRET0 set add793karnrtt_ true; $TCPeduNOFRET0 set add793expbackoff_ true; $TCPeduNOFRET0 set add793slowstart_ true; $TCPeduNOFRET0 set fid_ 1; I risultati della simulazione sono riportati nelle seguenti Fig. 38 e Fig. 39.
Fig. 38 Finestra di trasmissione senza algoritmo di Fast Retransmit
Fig. 39 Numero di sequenza senza algoritmo di Fast Retransmit
Algoritmo di Fast Recovery (FREC) La topologia della rete da simulare è quella dell’algoritmo Fast Retransmit di Fig. 33. La rete che si ottiene con NSCRIPT è quella rappresentata in Fig. 40.
Fig. 40 Rete
Per vedere il funzionamento di questo algoritmo vengono utilizzate le icone FullTcp0 e SinkFullTcp0. Il FullTcp0 traduce graficamente le seguenti righe di comando scritte in linguaggio OTcl: set FullTcp0 [new Agent/TCP/FullTcp]; $FullTcp0 set fid_ 1; Il SinkFullTcp0 traduce graficamente le seguenti righe di comando scritte in linguaggio OTcl: set SinkFullTcp0 [newAgent/TCP/FullTcp] $SinkFullTcp0 listen; Utilizzando questi due dispositivi, si riesce a simulare il comportamento del Fast Recovery. I risultati della simulazione sono riportati nelle seguenti Fig. 41 e Fig. 42.
Fig. 41 Finestra di trasmissione con algoritmo di Fast Recovery
Fig. 42 Numero di sequenza con algoritmo di Fast Recovery
Appendice su gnuplot
• Prima colonna interpretata come i dati rappresentati sull’asse x • Seconda colonna e successive interpretati come i dati rappresentativi dell’asse y • Senza nessuna indicazione gnuplot assume come dati da plottare sull’asse x e
sull’asse y i dati elencati nella prima e nella seconda colonna rispettivamente Comandi più importanti: � set data style lines
� Grafica i dati come linee � Altre opzioni: dots, points, pointslines, boxes…
� set xrange[0:10] � Imposta l’intervallo dell’asse x (tra 0 e 10 in questo caso). Analogamente per l’assey
� set xlabel “tempo di simulazione” � Imposta l’etichetta dell’asse x. analogamente per l’asse y
� plot “nome_file.trc” � Visualizza il grafico prendendo i dati dal file nome_file.trc
� save “nome.plt” � Salva l’ultimo grafico visualizzato, con tutte le impostazioni in un file .ptl
� load “nome.plt” � Rivisualizza il file precedentemente impostato e memorizzato (senza bisogno di
ripetere il settaggio)
