【转】网络编程中Nagle算法和Delayed ACK的测试

老盖 发布于 2011/06/30 18:51
阅读 465
收藏 0
  Nagle算法的立意是良好的,避免网络中充塞小封包,提高网络的利用率。但是当Nagle算法遇到 delayed ACK悲剧就发生了。Delayed ACK的本意也是为了提高TCP性能,跟应答数据捎带上ACK,同时避免 糊涂窗口综合症,也可以一个ack确认多个段来节省开销。
    悲剧发生在这种情况,假设一端发送数据并等待另一端应答,协议上分为头部和数据,发送的时候不幸地选择了write-write,然后再read,也就是先发送头部,再发送数据,最后等待应答。发送端的伪代码是这样
write(head);
write(body);
read(response);

接收端的处理代码类似这样:
read(request);
process(request);
write(response);

   这里假设head和body都比较小,当默认启用nagle算法,并且是第一次发送的时候,根据nagle算法,第一个段head可以立即发送,因为没有等待确认的段;接收端收到head,但是包不完整,继续等待body达到并延迟ACK;发送端继续写入body,这时候nagle算法起作用了,因为head还没有被ACK,所以body要延迟发送。这就造成了发送端和接收端都在等待对方发送数据的现象,发送端等待接收端ACK head以便继续发送body,而接收端在等待发送方发送body并延迟ACK,悲剧的无以言语。这种时候只有等待一端超时并发送数据才能继续往下走。

   正因为nagle算法和delayed ack的影响,再加上这种write-write-read的编程方式造成了很多网贴在讨论为什么自己写的网络程序性能那么差。然后很多人会在帖子里建议禁用Nagle算法吧,设置TCP_NODELAY为true即可禁用nagle算法。但是这真的是解决问题的唯一办法和最好办法吗?

   其实问题不是出在nagle算法身上的,问题是出在write-write-read这种应用编程上。禁用nagle算法可以暂时解决问题,但是禁用nagle算法也带来很大坏处,网络中充塞着小封包,网络的利用率上不去,在极端情况下,大量小封包导致网络拥塞甚至崩溃。因此,能不禁止还是不禁止的好,后面我们会说下什么情况下才需要禁用nagle算法。对大多数应用来说,一般都是连续的请求——应答模型,有请求同时有应答,那么请求包的ACK其实可以延迟到跟响应一起发送,在这种情况下,其实你只要避免write-write-read形式的调用就可以避免延迟现象,利用writev做聚集写或者将head和body一起写,然后再read,变成write-read-write-read的形式来调用,就无需禁用nagle算法也可以做到不延迟。

   writev是系统调用,在Java里是用到 GatheringByteChannel.write(ByteBuffer[] srcs, int offset, int length)方法来做聚集写。这里可能还有一点值的提下,很多同学看java nio框架几乎都不用这个writev调用,这是有原因的。主要是因为Java的write本身对ByteBuffer有做临时缓存,而writev没有做缓存,导致测试来看write反而比writev更高效,因此通常会更推荐用户将head和body放到同一个Buffer里来避免调用writev。

   下面我们将做个实际的代码测试来结束讨论。这个例子很简单,客户端发送一行数据到服务器,服务器简单地将这行数据返回。客户端发送的时候可以选择分两次发,还是一次发送。分两次发就是write-write-read,一次发就是write-read-write-read,可以看看两种形式下延迟的差异。 注意,在windows上测试下面的代码,客户端和服务器必须分在两台机器上,似乎winsock对loopback连接的处理不一样。

    服务器源码:
package  net.fnil.nagle;

import  java.io.BufferedReader;
import  java.io.InputStream;
import  java.io.InputStreamReader;
import  java.io.OutputStream;
import  java.net.InetSocketAddress;
import  java.net.ServerSocket;
import  java.net.Socket;


public   class  Server {
    
public   static   void  main(String[] args)  throws  Exception {
        ServerSocket serverSocket 
=   new  ServerSocket();
        serverSocket.bind(
new  InetSocketAddress( 8000 ));
        System.out.println(
" Server startup at 8000 " );
        
for  (;;) {
            Socket socket 
=  serverSocket.accept();
            InputStream in 
=  socket.getInputStream();
            OutputStream out 
=  socket.getOutputStream();

            
while  ( true ) {
                
try  {
                    BufferedReader reader 
=   new  BufferedReader( new  InputStreamReader(in));
                    String line 
=  reader.readLine();
                    out.write((line 
+   " \r\n " ).getBytes());
                }
                
catch  (Exception e) {
                    
break ;
                }
            }
        }
    }
}

服务端绑定到本地8000端口,并监听连接,连上来的时候就阻塞读取一行数据,并将数据返回给客户端。

客户端代码:
package  net.fnil.nagle;

import  java.io.BufferedReader;
import  java.io.InputStream;
import  java.io.InputStreamReader;
import  java.io.OutputStream;
import  java.net.InetSocketAddress;
import  java.net.Socket;


public   class  Client {

    
public   static   void  main(String[] args)  throws  Exception {
        
//  是否分开写head和body
         boolean  writeSplit  =   false ;
        String host 
=   " localhost " ;
        
if  (args.length  >=   1 ) {
            host 
=  args[ ];
        }
        
if  (args.length  >=   2 ) {
            writeSplit 
=  Boolean.valueOf(args[ 1 ]);
        }

        System.out.println(
" WriteSplit: "   +  writeSplit);

        Socket socket 
=   new  Socket();

        socket.connect(
new  InetSocketAddress(host,  8000 ));
        InputStream in 
=  socket.getInputStream();
        OutputStream out 
=  socket.getOutputStream();

        BufferedReader reader 
=   new  BufferedReader( new  InputStreamReader(in));

        String head 
=   " hello  " ;
        String body 
=   " world\r\n " ;
        
for  ( int  i  =   ; i  <   10 ; i ++ ) {
            
long  label  =  System.currentTimeMillis();
            
if  (writeSplit) {
                out.write(head.getBytes());
                out.write(body.getBytes());
            }
            
else  {
                out.write((head 
+  body).getBytes());
            }
            String line 
=  reader.readLine();
            System.out.println(
" RTT: "   +  (System.currentTimeMillis()  -  label)  +   "  ,receive: "   +  line);
        }
        in.close();
        out.close();
        socket.close();
    }

}


   客户端通过一个writeSplit变量来控制是否分开写head和body,如果为true,则先写head再写body,否则将head加上body一次写入。客户端的逻辑也很简单,连上服务器,发送一行,等待应答并打印RTT,循环10次最后关闭连接。

   首先,我们将writeSplit设置为true,也就是分两次写入一行,在我本机测试的结果,我的机器是ubuntu 11.10:
WriteSplit: true
RTT:
8  ,receive:hello world
RTT:
40  ,receive:hello world
RTT:
40  ,receive:hello world
RTT:
40  ,receive:hello world
RTT:
39  ,receive:hello world
RTT:
40  ,receive:hello world
RTT:
40  ,receive:hello world
RTT:
40  ,receive:hello world
RTT:
40  ,receive:hello world
RTT:
40  ,receive:hello world

    可以看到,每次请求到应答的时间间隔都在40ms,除了第一次。linux的delayed ack是40ms,而不是原来以为的200ms。第一次立即ACK,似乎跟linux的quickack mode有关,这里我不是特别清楚,有比较清楚的同学请指教。

     接下来,我们还是将writeSplit设置为true,但是客户端禁用nagle算法,也就是客户端代码在connect之前加上一行:
        Socket socket  =   new  Socket();
        socket.setTcpNoDelay(
true );
        socket.connect(
new  InetSocketAddress(host,  8000 ));

    再跑下测试:
WriteSplit: true
RTT:
 ,receive:hello world
RTT:
 ,receive:hello world
RTT:
 ,receive:hello world
RTT:
 ,receive:hello world
RTT:
1  ,receive:hello world
RTT:
 ,receive:hello world
RTT:
 ,receive:hello world
RTT:
 ,receive:hello world
RTT:
 ,receive:hello world
RTT:
 ,receive:hello world

   这时候就正常多了,大部分RTT时间都在1毫秒以下。果然禁用Nagle算法可以解决延迟问题。
   如果我们不禁用nagle算法,而将writeSplit设置为false,也就是将head和body一次写入,再次运行测试(记的将setTcpNoDelay这行删除):
WriteSplit: false
RTT:
7  ,receive:hello world
RTT:
1  ,receive:hello world
RTT:
 ,receive:hello world
RTT:
 ,receive:hello world
RTT:
 ,receive:hello world
RTT:
 ,receive:hello world
RTT:
 ,receive:hello world
RTT:
 ,receive:hello world
RTT:
 ,receive:hello world
RTT:
 ,receive:hello world

   结果跟禁用nagle算法的效果类似。既然这样,我们还有什么理由一定要禁用nagle算法呢?通过我在 xmemcached的压测中的测试,启用nagle算法在小数据的存取上甚至有一定的效率优势,memcached协议本身就是个连续的请求应答的模型。上面的测试如果在windows上跑,会发现RTT最大会在200ms以上,可见winsock的delayed ack超时是200ms。

   最后一个问题,什么情况下才应该禁用nagle算法?当你的应用不是这种连续的请求——应答模型,而是需要实时地单向发送很多小数据的时候或者请求是有间隔的,则应该禁用nagle算法来提高响应性。一个最明显是例子是telnet应用,你总是希望敲入一行数据后能立即发送给服务器,然后马上看到应答,而不是说我要连续敲入很多命令或者等待200ms才能看到应答。

   上面是我对nagle算法和delayed ack的理解和测试,有错误的地方请不吝赐教。

   转载请注明出处: http://www.blogjava.net/killme2008/archive/2011/06/30/353441.html
加载中
0
Lunar_Lin
Lunar_Lin

      时间长了有点不熟悉了. 记得各个系统上的TCP/IP栈实现nagle算法都充分考虑了telnet这样程序的特性.记得TCP头里有个标记位是URGENT,表示立即发送和确认. 没精力验证文中的实例.纯仰望了.

      虽然最初设计时的环境很简朴, 但此后N年, 从低速到极其高速,从空闲网络到拥挤网络,从近距离到高延迟的跨洲全球internet, TCP/IP协议都经受住了考验,成为几乎唯一使用的网络传输协议, 很多算法和参数至今仍被专家们认为不必修改,还是很牛的.

返回顶部
顶部