Esercizio - TCP, slow start e messaggio da 18 kB su un collegamento da 8 Mbps

Testo. $A$ deve trasferire a $B$ con TCP un messaggio applicativo di $18$ kbyte. Un solo collegamento con $C=8$ Mbit/s e $\tau=10$ ms. $\text{MSS}=1000$ byte, intestazioni trascurabili, connessione aperta da $A$ con segmenti di apertura di lunghezza trascurabile, ACK trascurabili, $\text{ssthresh}=4$ MSS. Calcolare il tempo totale di trasferimento.

Teoria usata: TCP - controllo di congestioneLa congestione nasce quando collegamenti veloci alimentano un collegamento lento: le code dei router si riempiono, i pacchetti si perdono o ritardano e, nel caso peggiore, la rete collassa (quasi solo ritrasmissioni). TCP controlla la propria finestra di congestione cwnd con il feedback delle perdite (timeout o tre ACK duplicati): slow start (cwnd raddoppia a ogni RTT) fino alla soglia ssthresh, poi congestion avoidance (+1 MSS per RTT); a ogni perdita ssthresh = W/2. Le varianti si distinguono per come reagiscono ai tre dupACK: Tahoe riparte da cwnd = 1 dopo la ritrasmissione rapida; Reno usa il fast recovery (ssthresh = cwnd/2, cwnd = ssthresh + 3, +1 per ogni altro dupACK); NewReno gestisce gli ACK parziali e recupera più perdite nella stessa finestra; SACK riscontra i blocchi ricevuti e ritrasmette solo quello che manca.TCP - controllo di congestione →, TCP - connessione, affidabilità e controllo di flussoTCP (Transmission Control Protocol) è il protocollo di trasporto con connessione e affidabile: trasforma il servizio senza connessione e inaffidabile di IP in un flusso di byte ordinato, senza errori né duplicati. La connessione si apre con l'handshake a tre vie (SYN, SYN+ACK, ACK) e si chiude con tre o quattro segmenti (FIN). I byte sono numerati: il numero di sequenza è quello del primo byte del segmento, il numero di ACK (cumulativo) è il prossimo byte atteso. Il mittente può inviare $\min(\text{rwnd},\text{cwnd})$ byte non ancora confermati; rwnd (finestra del ricevitore, in un campo di 16 bit) è il controllo di flusso. L'errore si gestisce con checksum, ACK, timeout di ritrasmissione (RTO) e ritrasmissione rapida dopo tre ACK duplicati. Per usare tutto il canale la finestra deve valere almeno il prodotto banda-ritardo (BDP); il throughput massimo è $\text{MSS}\cdot W_{\max}/\text{RTT}$.TCP - connessione, affidabilità e controllo di flusso →.

Come si calcola il tempo: la convenzione del corso

Tutti gli esercizi di trasferimento TCP del corso si risolvono con lo stesso schema, che conviene capire una volta bene.

1. Tempo di trasmissione di un segmento: $T=\text{MSS}/C$. Ritardo di andata e ritorno con ACK trascurabili: $\text{RTT}=T+2\tau$ (il segmento viene trasmesso e propagato, l'ACK torna solo con la propagazione; per più collegamenti si sommano trasmissioni e propagazioni).
2. Apertura (three-way handshake): $A$ manda SYN (arriva dopo $\tau$), $B$ risponde SYN+ACK (arriva dopo altri $\tau$), $A$ manda l'ACK e nello stesso segmento può portare i primi dati. I dati partono quindi a $t_0=2\tau$ (apertura $=2\tau$, perché i segmenti di apertura hanno lunghezza trascurabile).
3. Finestra a round (rounds). Si parte con $\text{cwnd}=1$ MSS. Il mittente trasmette una finestra di $w$ segmenti uno dietro l'altro (impiegando $wT$). L'ACK del primo segmento torna dopo un RTT dall'inizio della sua trasmissione e, siccome ogni ACK libera un posto in finestra, fa partire i segmenti successivi: la finestra seguente inizia quindi un RTT dopo l'inizio della precedente, purché $wT<\text{RTT}$ (la finestra è finita prima che torni il primo ACK).
4. Crescita della finestra: in slow start $\text{cwnd}$ raddoppia a ogni round ($1,2,4,8,\dots$) finché raggiunge $\text{ssthresh}$; poi, in congestion avoidance, cresce di $1$ MSS a round. Se vale il vincolo $\text{rwnd}$, $\text{swnd}=\min(\text{cwnd},\text{rwnd})$.
5. Flusso continuo: se $\text{swnd}\cdot T\ge\text{RTT}$ il primo ACK torna mentre il mittente sta ancora trasmettendo: da lì in poi il collegamento più lento non si ferma più e i segmenti rimasti si trasmettono uno ogni $T$ (del collo di bottiglia).
6. Fine: il tempo totale termina quando torna l'ACK dell'ultimo segmento, cioè un RTT dopo l'inizio della sua trasmissione.

Il tempo totale di un trasferimento senza perdite e senza flusso continuo è perciò $$T_{tot}=\underbrace{2\tau}_{\text{apertura}}+(R-1)\,\text{RTT}+(w_{ult}-1)\,T+\text{RTT},$$ dove $R$ è il numero di round e $w_{ult}$ la dimensione dell'ultima finestra.

Svolgimento

Dati in unità coerenti. $\text{MSS}=1000\cdot8=8000$ bit. $T=8000/(8\cdot10^6)=1$ ms. $\text{RTT}=T+2\tau=1+20=21$ ms. Segmenti: $18\,000/1000=18$. Apertura: $2\tau=20$ ms.

Finestre. $\text{ssthresh}=4$ MSS.

Perché $1,2,4,5,6$: due ACK arrivano nel secondo round e portano $\text{cwnd}$ da $2$ a $4=\text{ssthresh}$; da lì si va in congestion avoidance, $+1$ per round. Si sommano $1+2+4+5+6=18$: il messaggio finisce esattamente nel quinto round (le prime tre finestre sono una somma geometrica1 + 2 + 4 + ... + 2^k = 2^(k+1) − 1, perché ogni termine è il doppio del precedenteSerie notevoli - geometrica, telescopica, armonica →: $1+2+4=2^3-1=7$, poi $5+6=11$).

{"tipo":"geometria","uguale":false,"x":[0,5],"y":[0,8],"titolo":"Finestra di invio (segmenti) nei 5 round (1 round = 21 ms): slow start fino a ssthresh = 4, poi +1 per round; 1+2+4+5+6 = 18 segmenti","assi":{"x":"round (RTT)","y":"finestra (MSS)"},"elementi":[{"segmento":[[0,1],[1,1]],"colore":1,"etichetta":"cwnd"},{"segmento":[[1,1],[1,2]],"colore":1},{"segmento":[[1,2],[2,2]],"colore":1},{"segmento":[[2,2],[2,4]],"colore":1},{"segmento":[[2,4],[3,4]],"colore":1},{"segmento":[[3,4],[3,5]],"colore":1},{"segmento":[[3,5],[4,5]],"colore":1},{"segmento":[[4,5],[4,6]],"colore":1},{"segmento":[[4,6],[5,6]],"colore":1},{"segmento":[[0,4],[5,4]],"colore":3,"tratteggio":true,"etichetta":"ssthresh = 4"}]}
``` Nessun round è continuo: $\text{cwnd}\cdot T\le6$ ms $<21$ ms.

**Ultimo round.** Inizia a $104$ ms; i $6$ segmenti escono in $104,\dots,109$ ms (l'ultimo termina la trasmissione a $110$ ms, arriva a $B$ a $120$ ms); l'ACK dell'ultimo torna a $110+10+10=130$ ms.

$$T_{tot}=2\tau+(5-1)\,\text{RTT}+(6-1)T+\text{RTT}=20+4\cdot21+5+21=\boxed{130\ \text{ms}}.$$

(Verificato con Python con un simulatore a eventi: $130{,}0$ ms.)

## Confronto con la soluzione ufficiale

La slide riporta la formula $T_{tot}=T_{setup}+5\,\text{RTT}+(6-1)T$ con la scomposizione $1+2+4+5+6=18$ e il risultato $130$ ms: coincide (nella formula $T_{setup}=2\tau=20$ ms e i $5$ RTT comprendono quello dell'ultimo ACK: $20+5\cdot21+5=130$).

## Errori comuni

- Continuare lo slow start oltre $\text{ssthresh}$ (cioè $1,2,4,8$): a $\text{cwnd}=\text{ssthresh}=4$ si passa a crescita lineare.
- Contare l'apertura come $3\tau$ o come un RTT intero: i dati partono col terzo segmento, a $2\tau$.
- Dimenticare il termine $(w_{ult}-1)T$ della serializzazione dell'ultima finestra.
- Dimenticare che il tempo si ferma con l'ACK dell'ultimo segmento, non con la sua consegna.