Nagle's algorithm --TCP_NODELAY TCP_CORK

Nagle's algorithm

From Wikipedia, the free encyclopedia

Jump to: ,

Nagle's algorithm, named after John Nagle, is a means of improving the efficiency of networks by reducing the number of packets that need to be sent over the network.

Nagle's document, Congestion Control in IP/TCP Internetworks () describes what he called the 'small packet problem', where an application repeatedly emits data in small chunks, frequently only 1 in size. Since packets have a 40 byte header (20 bytes for TCP, 20 bytes for ), this results in a 41 byte packet for 1 byte of useful information, a huge overhead. This situation often occurs in sessions, where most keypresses generate a single byte of data which is transmitted immediately. Worse, over slow links, many such packets can be in transit at the same time, potentially leading to .

Nagle's algorithm works by a number of small outgoing messages, and sending them all at once. Specifically, as long as there is a sent packet for which the sender has received no acknowledgment, the sender should keep buffering its output until it has a full packet's worth of output, so that output can be sent all at once.

[] Algorithm

if there is new data to send
  if the window size >= MSS and available data is >= MSS
    send complete MSS segment now
  else
    if there is unconfirmed data still in the pipe
      enqueue data in the buffer until an acknowledge is received
    else
      send data immediately
    end if
  end if
end if

where MSS = .

This algorithm interacts badly with , a feature introduced into TCP at roughly the same time in the early 1980s, but by a different group. With both algorithms enabled, applications which do two successive writes to a TCP connection, followed by a read, experience a constant delay of up to 500 milliseconds, the " delay". For this reason, TCP implementations usually provide applications with an interface to disable the Nagle algorithm. This is typically called the TCP_NODELAY option. The first major application to run into this problem was the .

The tinygram problem and are sometimes confused. The tinygram problem occurs when the window is almost empty. Silly window syndrome occurs when the window is almost full.

    1. TCP_NODELAY: 使用 TCP_NODELAY这个tcp protocol 的option来制定传输数据时立即发送，而不是汇聚到一定大小后才发送，即平比nagle算法。缺点每个包的overhead和payload的比率较大，利用率低，优点：交 互快。如果应用程序需要快速的响应，那么建议用这个，如鼠标等。而对于需要大量数据传输的 场合，可能使用使用Nagle's algorithm就好一些。

If set, disable the Nagle algorithm. This means that segments are always sent as soon as possible, even if there is only a small amount of data. When not set, data is buffered until there is a sufficient amount to send out, thereby avoiding the frequent sending of small packets, which results in poor utilization of the network. This option is overridden by TCP_CORK; however, setting this option forces an explicit flush of pending output, even if TCP_CORK is currently set.

  

    2. TCP_CORK: （使数据缓冲后再发送）

If set, don't send out partial frames. All queued partial frames are sent when the option is cleared again. This is useful for prepending headers before calling (2), or for throughput optimization. As currently implemented, there is a 200 millisecond ceiling on the time for which output is corked by TCP_CORK. If this ceiling is reached, then queued data is automatically transmitted. This option can be combined with TCP_NODELAY only since Linux 2.5.71. This option should not be used in code intended to be portable.