Quando dovrei usare TCP_NODELAY e quando TCP_CORK?

È un'ottimizzazione, quindi come qualsiasi ottimizzazione:

1. Non usarlo
2. Aspetta che le prestazioni diventino un problema, quindi dopo aver determinato che la latenza del socket ne è sicuramente la causa e i test dimostrano che questo risolverà definitivamente il problema, E questo è il modo più semplice per risolverlo, fallo.

Fondamentalmente lo scopo è quello di evitare di dover inviare diversi frame in cui può essere utilizzato un singolo frame, con sendfile() ei suoi amici.

Quindi, ad esempio, in un server Web, invii le intestazioni seguite dal contenuto del file, le intestazioni verranno assemblate in memoria, il file verrà quindi inviato direttamente dal kernel. TCP_CORK ti consente di inviare le intestazioni e l'inizio del file in un singolo frame, anche con TCP_NODELAY, che altrimenti causerebbe l'invio immediato del primo blocco.

TCP_NODELAY

Utilizzato per disabilitare l'algoritmo di Nagle per migliorare le reti TCP/IP e ridurre il numero di pacchetti attendendo fino a quando non viene ricevuto un riconoscimento dei dati inviati in precedenza per inviare i pacchetti accumulati.

//Dal manuale tcp(7):

TCP_CORK (o TCP_NOPUSH in FreeBSD)

Se impostato, non inviare frame parziali. Tutti i telegrammi parziali in coda vengono inviati quando l'opzione viene nuovamente deselezionata. Questo è utile per anteporre le intestazioni prima di chiamare sendfile(2) o per l'ottimizzazione della velocità effettiva. Come attualmente implementato, esiste un massimale di 200 millisecondi sull'ora per la quale l'output è bloccato da TCP_CORK . Se questo limite viene raggiunto, i dati in coda vengono trasmessi automaticamente . Questa opzione può essere combinata con TCP_NODELAY solo da Linux 2.5.71. Questa opzione non deve essere utilizzata nel codice destinato alla portabilità.

Prima di tutto non entrambi disabilitano l'algoritmo di Nagle.

L'algoritmo di Nagle serve a ridurre un numero maggiore di piccoli pacchetti di rete in cavo. L'algoritmo è:se i dati sono inferiori a un limite (solitamente MSS), attendere fino a quando non si riceve l'ACK per i pacchetti inviati in precedenza e nel frattempo accumulare i dati dall'utente. Quindi invia i dati accumulati.

if [ data > MSS ]
    send(data)
else
    wait until ACK for previously sent data and accumulate data in send buffer (data)
    And after receiving the ACK send(data)

Questo aiuterà in applicazioni come telnet. Tuttavia, l'attesa dell'ACK può aumentare la latenza durante l'invio di dati in streaming. Inoltre, se il ricevitore implementa la "politica di ACK ritardato", causerà una situazione di stallo temporaneo. In questi casi, disabilitare l'algoritmo di Nagle è un'opzione migliore.

Quindi TCP_NODELAY è usato per disabilitare l'algoritmo di Nagle.

TCP_CORK accumula dati in modo aggressivo. Se TCP_CORK è abilitato in un socket, non invierà dati finché il buffer non raggiunge un limite fisso. Simile all'algoritmo di Nagle, accumula anche dati dall'utente ma fino a quando il buffer non si riempie fino a un limite fisso non fino a quando non riceve ACK. Questo sarà utile durante l'invio di più blocchi di dati. Ma devi stare più attento quando usi TCP_CORK.

Fino al kernel 2.6, entrambe queste opzioni si escludono a vicenda. Ma nel kernel successivo, entrambi possono coesistere. In tal caso, verrà data maggiore preferenza a TCP_CORK.

Rif:

• http://baus.net/on-tcp_cork/
• http://ccr.sigcomm.org/archive/2001/jan01/ccr-200101-mogul.pdf