Passa al contenuto principale

3. RTTM -- Misurazione del tempo di andata e ritorno

3.1 Introduzione​

Stime RTT accurate e aggiornate sono necessarie per adattarsi alle condizioni di traffico mutevoli e per evitare un'instabilità nota come "collasso da congestione (congestion collapse)" [Nagle84] in una rete affollata. Tuttavia, la misurazione accurata dell'RTT può essere difficile sia in teoria che nell'implementazione.

Molte implementazioni TCP basano le loro misurazioni RTT su un campione di un solo pacchetto per finestra. Sebbene ciò produca un'approssimazione adeguata all'RTT per finestre piccole, risulta in una stima RTT inaccettabilmente scarsa per un LFN. Se consideriamo la stima dell'RTT come un problema di elaborazione del segnale (che è), un segnale dati a una certa frequenza, il tasso di pacchetti, viene campionato a una frequenza inferiore, il tasso di finestra. Questa frequenza di campionamento inferiore viola i criteri di Nyquist e può quindi introdurre artefatti di "aliasing" nell'RTT stimato [Hamming77].

Un buon stimatore RTT con un calcolo conservativo del timeout di ritrasmissione può tollerare l'aliasing quando la frequenza di campionamento è "vicina" alla frequenza dei dati. Ad esempio, con una finestra di 8 pacchetti, il tasso di campionamento è 1/8 della frequenza dei dati -- meno di un ordine di grandezza diverso. Tuttavia, quando la finestra è di decine o centinaia di pacchetti, lo stimatore RTT può essere gravemente in errore, risultando in ritrasmissioni spurie.

Se ci sono pacchetti persi, il problema peggiora. Zhang [Zhang86], Jain [Jain86] e Karn [Karn87] hanno dimostrato che non è possibile accumulare stime RTT affidabili se i segmenti ritrasmessi sono inclusi nella stima. Poiché una finestra completa di dati sarà stata trasmessa prima di una ritrasmissione, tutti i segmenti in quella finestra dovranno essere confermati prima che possa essere preso il prossimo campione RTT. Ciò significa almeno un tempo aggiuntivo equivalente a una finestra tra le misurazioni RTT e, man mano che il tasso di errore si avvicina a uno per finestra di dati (ad es., 10**-6 errori per bit per la rete satellitare a banda larga), diventa effettivamente impossibile ottenere una misurazione RTT valida.

Una soluzione a questi problemi, che in realtà semplifica sostanzialmente il mittente, è la seguente: utilizzando le opzioni TCP, il mittente inserisce un timestamp in ogni segmento di dati, e il ricevitore riflette questi timestamp nei segmenti ACK. Quindi una singola sottrazione fornisce al mittente una misurazione RTT accurata per ogni segmento ACK (che corrisponderà a ogni altro segmento di dati, con un ricevitore sensato). Chiamiamo questo meccanismo RTTM (Round-Trip Time Measurement, misurazione del tempo di andata e ritorno).

È estremamente importante utilizzare il meccanismo RTTM con finestre grandi; altrimenti, si apre la porta a alcune instabilità pericolose dovute all'aliasing. Inoltre, l'opzione è probabilmente utile per tutti i TCP, poiché semplifica il mittente.

3.2 Opzione TCP Timestamps​

TCP è un protocollo simmetrico, che consente l'invio di dati in qualsiasi momento in entrambe le direzioni, e quindi l'eco del timestamp può verificarsi in entrambe le direzioni. Per semplicità e simmetria, specifichiamo che i timestamp siano sempre inviati e riflessi in entrambe le direzioni. Per efficienza, combiniamo i campi timestamp e risposta timestamp in un'unica opzione TCP Timestamps.

Opzione TCP Timestamps (TSopt):​

Kind: 8

Length: 10 bytes

+-------+-------+---------------------+---------------------+
|Kind=8 | 10 | TS Value (TSval) |TS Echo Reply (TSecr)|
+-------+-------+---------------------+---------------------+
1 1 4 4

L'opzione Timestamps trasporta due campi timestamp di quattro byte. Il campo Timestamp Value (TSval) contiene il valore corrente del clock timestamp del TCP che invia l'opzione.

Il campo Timestamp Echo Reply (TSecr) è valido solo se il bit ACK è impostato nell'intestazione TCP; se è valido, riflette un valore timestamp che è stato inviato dal TCP remoto nel campo TSval di un'opzione Timestamps. Quando TSecr non è valido, il suo valore deve essere zero. Il valore TSecr sarà generalmente dall'opzione Timestamp più recente che è stata ricevuta; tuttavia, ci sono eccezioni che sono spiegate di seguito.

Un TCP può inviare l'opzione Timestamps (TSopt) in un segmento <SYN> iniziale (cioè, segmento contenente un bit SYN e nessun bit ACK), e può inviare una TSopt in altri segmenti solo se ha ricevuto una TSopt nel segmento <SYN> iniziale per la connessione.

3.3 Il meccanismo RTTM​

Il valore timestamp da inviare in TSval deve essere ottenuto da un clock (virtuale) che chiamiamo "clock timestamp". I suoi valori devono essere almeno approssimativamente proporzionali al tempo reale, per misurare l'RTT effettivo.

Il seguente esempio illustra un flusso di dati unidirezionale con segmenti che arrivano in sequenza senza perdite. Qui A, B, C... rappresentano blocchi di dati che occupano blocchi successivi di numeri di sequenza, e ACK(A),... rappresentano i corrispondenti acknowledgment cumulativi. I due campi timestamp dell'opzione Timestamps sono mostrati simbolicamente come <TSval= x,TSecr=y>. Ogni campo TSecr contiene il valore ricevuto più di recente in un campo TSval.

    TCP  A                                          TCP B

&lt;A,TSval=1,TSecr=120> ------>

&lt;---- &lt;ACK(A),TSval=127,TSecr=1>

&lt;B,TSval=5,TSecr=127> ------>

&lt;---- &lt;ACK(B),TSval=131,TSecr=5>

. . . . . . . . . . . . . . . . . . . . . .

&lt;C,TSval=65,TSecr=131> ------>

&lt;---- &lt;ACK(C),TSval=191,TSecr=65>

(etc)

La linea punteggiata segna una pausa (lunga 60 unità di tempo) in cui A non aveva nulla da inviare. Si noti che questa pausa gonfia l'RTT che B potrebbe dedurre dalla ricezione di TSecr=131 nel segmento di dati C. Pertanto, nei flussi di dati unidirezionali, RTTM nella direzione inversa misura un valore che è gonfiato da lacune nell'invio di dati. Tuttavia, la seguente regola impedisce un gonfiamento risultante dell'RTT misurato:

Un valore TSecr ricevuto in un segmento viene utilizzato per aggiornare la misurazione RTT mediata solo se il segmento conferma alcuni nuovi dati, cioè solo se avanza il bordo sinistro della finestra di invio.

Poiché TCP B non sta inviando dati, il segmento di dati C non conferma alcun nuovo dato quando arriva a B. Pertanto, la misurazione RTTM gonfiata non viene utilizzata per aggiornare la misurazione RTTM di B.

3.4 Quale timestamp rinviare​

Se viene ricevuta più di un'opzione Timestamps prima che venga inviato un segmento di risposta, il TCP deve scegliere solo uno dei TSvals da riflettere, ignorando gli altri. Per minimizzare lo stato mantenuto nel ricevitore (cioè, il numero di TSvals non elaborati), il ricevitore dovrebbe essere tenuto a mantenere al massimo un timestamp nel blocco di controllo della connessione.

Ci sono tre situazioni da considerare:

(A) ACK ritardati.​

Molti TCP confermano solo ogni K-esimo segmento di un gruppo di segmenti che arrivano entro un breve intervallo di tempo; questa politica è generalmente nota come "ACK ritardati (delayed ACKs)". Il TCP mittente di dati deve misurare l'RTT effettivo, incluso il tempo aggiuntivo dovuto agli ACK ritardati, altrimenti ritrasmett irà inutilmente. Pertanto, quando gli ACK ritardati sono in uso, il ricevitore dovrebbe rispondere con il campo TSval dal segmento non confermato più vecchio.

(B) Un buco nello spazio di sequenza (segmenti sono stati persi).​

Il mittente continuerà a inviare fino a quando la finestra è piena, e il ricevitore potrebbe generare ACK quando questi segmenti fuori ordine arrivano (ad es., per aiutare la "ritrasmissione rapida (fast retransmit)").

Il segmento perso è probabilmente un segno di congestione, e in quella situazione il mittente dovrebbe essere conservativo riguardo alla ritrasmissione. Inoltre, è meglio sovrastimare che sottostimare l'RTT. Un ACK per un segmento fuori ordine dovrebbe quindi contenere il timestamp dal segmento più recente che ha fatto avanzare la finestra.

La stessa situazione si verifica se i segmenti vengono riordinati dalla rete.

(C) Un buco colmato nello spazio di sequenza.​

Il segmento che riempie il buco rappresenta la misurazione più recente delle caratteristiche della rete. D'altra parte, un RTT calcolato da un segmento precedente includerebbe probabilmente il timeout di ritrasmissione del mittente, distorcendo gravemente la stima RTT media del mittente. Pertanto, il timestamp dal segmento più recente (che ha riempito il buco) deve essere riflesso.

Un algoritmo che copre tutti e tre i casi è descritto nelle seguenti regole per l'elaborazione dell'opzione Timestamps su una connessione sincronizzata:

Lo stato della connessione è aumentato con due slot a 32 bit: TS.Recent contiene un timestamp da riflettere in TSecr ogni volta che viene inviato un segmento, e Last.ACK.sent contiene il campo ACK dall'ultimo segmento inviato. Last.ACK.sent sarà uguale a RCV.NXT tranne quando gli ACK sono stati ritardati.

Se Last.ACK.sent rientra nell'intervallo di numeri di sequenza di un segmento in arrivo:

SEG.SEQ &lt;= Last.ACK.sent &lt; SEG.SEQ + SEG.LEN

allora il TSval dal segmento viene copiato in TS.Recent; altrimenti, il TSval viene ignorato.

Quando viene inviata una TSopt, il suo campo TSecr viene impostato al valore TS.Recent corrente.

I seguenti esempi illustrano queste regole. Qui A, B, C... rappresentano segmenti di dati che occupano blocchi successivi di numeri di sequenza, e ACK(A),... rappresentano i segmenti di acknowledgment corrispondenti. Si noti che ACK(A) ha lo stesso numero di sequenza di B. Mostriamo solo una direzione di riflessione del timestamp, per chiarezza.

I pacchetti arrivano in sequenza, e alcuni degli ACK sono ritardati.

Secondo il caso (A), il timestamp dal segmento non confermato più vecchio viene riflesso.

                                              TS.Recent
&lt;A, TSval=1> ------------------->
1
&lt;B, TSval=2> ------------------->
1
&lt;C, TSval=3> ------------------->
1
&lt;---- &lt;ACK(C), TSecr=1>
(etc)

I pacchetti arrivano fuori ordine, e ogni pacchetto viene confermato.

Secondo il caso (B), il timestamp dall'ultimo segmento che ha fatto avanzare il bordo sinistro della finestra viene riflesso, fino all'arrivo del segmento mancante; viene riflesso secondo il caso (C). La stessa sequenza si verificherebbe se i segmenti B e D fossero persi e ritrasmessi.

                                              TS.Recent
&lt;A, TSval=1> ------------------->
1
&lt;---- &lt;ACK(A), TSecr=1>
1
&lt;C, TSval=3> ------------------->
1
&lt;---- &lt;ACK(A), TSecr=1>
1
&lt;B, TSval=2> ------------------->
2
&lt;---- &lt;ACK(C), TSecr=2>
2
&lt;E, TSval=5> ------------------->
2
&lt;---- &lt;ACK(C), TSecr=2>
2
&lt;D, TSval=4> ------------------->
4
&lt;---- &lt;ACK(E), TSecr=4>
(etc)