问题:为什么TCP socket在多个系统调用中会变慢?

为什么下面的代码很慢?我所说的慢是指慢 100 倍到 1000 倍。它只是直接在 TCP 套接字上重复执行读/写。奇怪的是,只有当我使用两个函数调用来读取和写入时,它仍然很慢,如下所示。如果我更改服务器或客户端代码以使用单个函数调用(如注释中所示),它会变得超级快。

代码片段:

int main(...) {
  int sock = ...; // open TCP socket
  int i;
  char buf[100000];
  for(i=0;i<2000;++i)
  { if(amServer)
    { write(sock,buf,10);
      // read(sock,buf,20);
      read(sock,buf,10);
      read(sock,buf,10);
    }else
    { read(sock,buf,10);
      // write(sock,buf,20);
      write(sock,buf,10);
      write(sock,buf,10);
    }
  }
  close(sock);
}

我们在一个更大的程序中偶然发现了这一点,它实际上使用了 stdio 缓冲。当有效载荷大小略微超过缓冲区大小时,它神秘地变得迟缓。然后我用strace做了一些挖掘,最后把问题归结为这个。我可以通过玩弄缓冲策略来解决这个问题,但我真的很想知道这里到底发生了什么。在我的机器上,当我将两个读取调用更改为一个调用时,它在我的机器上从 0.030 秒到超过一分钟(在本地和远程机器上测试)。

这些测试是在各种 Linux 发行版和各种内核版本上完成的。结果相同。

具有网络样板的完全可运行代码:

#include <netdb.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/ip.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>

static int getsockaddr(const char* name,const char* port, struct sockaddr* res)
{
    struct addrinfo* list;
    if(getaddrinfo(name,port,NULL,&list) < 0) return -1;
    for(;list!=NULL && list->ai_family!=AF_INET;list=list->ai_next);
    if(!list) return -1;
    memcpy(res,list->ai_addr,list->ai_addrlen);
    freeaddrinfo(list);
    return 0;
}
// used as sock=tcpConnect(...); ...; close(sock);
static int tcpConnect(struct sockaddr_in* sa)
{
    int outsock;
    if((outsock=socket(AF_INET,SOCK_STREAM,0))<0) return -1;
    if(connect(outsock,(struct sockaddr*)sa,sizeof(*sa))<0) return -1;
    return outsock;
}
int tcpConnectTo(const char* server, const char* port)
{
    struct sockaddr_in sa;
    if(getsockaddr(server,port,(struct sockaddr*)&sa)<0) return -1;
    int sock=tcpConnect(&sa); if(sock<0) return -1;
    return sock;
}

int tcpListenAny(const char* portn)
{
    in_port_t port;
    int outsock;
    if(sscanf(portn,"%hu",&port)<1) return -1;
    if((outsock=socket(AF_INET,SOCK_STREAM,0))<0) return -1;
    int reuse = 1;
    if(setsockopt(outsock,SOL_SOCKET,SO_REUSEADDR,
              (const char*)&reuse,sizeof(reuse))<0) return fprintf(stderr,"setsockopt() failed\n"),-1;
    struct sockaddr_in sa = { .sin_family=AF_INET, .sin_port=htons(port)
                  , .sin_addr={INADDR_ANY} };
    if(bind(outsock,(struct sockaddr*)&sa,sizeof(sa))<0) return fprintf(stderr,"Bind failed\n"),-1;
    if(listen(outsock,SOMAXCONN)<0) return fprintf(stderr,"Listen failed\n"),-1;
    return outsock;
}

int tcpAccept(const char* port)
{
    int listenSock, sock;
    listenSock = tcpListenAny(port);
    if((sock=accept(listenSock,0,0))<0) return fprintf(stderr,"Accept failed\n"),-1;
    close(listenSock);
    return sock;
}

void writeLoop(int fd,const char* buf,size_t n)
{
    // Don't even bother incrementing buffer pointer
    while(n) n-=write(fd,buf,n);
}
void readLoop(int fd,char* buf,size_t n)
{
    while(n) n-=read(fd,buf,n);
}
int main(int argc,char* argv[])
{
    if(argc<3)
    { fprintf(stderr,"Usage: round {server_addr|--} port\n");
        return -1;
    }
    bool amServer = (strcmp("--",argv[1])==0);
    int sock;
    if(amServer) sock=tcpAccept(argv[2]);
    else sock=tcpConnectTo(argv[1],argv[2]);
    if(sock<0) { fprintf(stderr,"Connection failed\n"); return -1; }

    int i;
    char buf[100000] = { 0 };
    for(i=0;i<4000;++i)
    {
        if(amServer)
        { writeLoop(sock,buf,10);
            readLoop(sock,buf,20);
            //readLoop(sock,buf,10);
            //readLoop(sock,buf,10);
        }else
        { readLoop(sock,buf,10);
            writeLoop(sock,buf,20);
            //writeLoop(sock,buf,10);
            //writeLoop(sock,buf,10);
        }
    }

    close(sock);
    return 0;
}

编辑:此版本与其他代码片段略有不同,因为它在循环中读取/写入。所以在这个版本中,两次单独的写入会自动导致两次单独的read()调用,即使readLoop只被调用一次。但除此之外,问题仍然存在。

解答

有趣的。您正在成为Nagle 算法和TCP 延迟确认的受害者。

Nagle 算法是 TCP 中使用的一种机制,用于延迟小段的传输,直到积累了足够的数据,值得在网络上构建和发送一个段。来自维基百科文章:

Nagle 的算法通过组合一些小的传出消息并一次发送它们来工作。具体来说,只要有一个发送方没有收到确认的已发送数据包,发送方就应该继续缓冲其输出,直到它有一个完整数据包的输出,以便可以一次发送所有输出。

但是,TCP 通常采用称为 TCP 延迟确认 的技术,这是一种将一批 ACK 回复累积在一起的技术(因为 TCP 使用累积 ACKS)来减少网络流量。

那篇维基百科文章进一步提到了这一点:

在启用这两种算法的情况下,应用程序对 TCP 连接执行两次连续写入,然后读取在第二次写入的数据到达目的地之后才会完成,经历长达 500 毫秒的恒定延迟,“确认延迟”。

(强调我的)

在您的特定情况下,由于服务器在读取回复之前没有发送更多数据,因此客户端导致延迟:如果客户端写入 twice,第二次写入将被延迟。

如果发送方正在使用 Nagle 算法,数据将由发送方排队,直到收到 ACK。如果发送方没有发送足够的数据来填充最大段大小(例如,如果它执行两个小写入,然后是阻塞读取),则传输将暂停,直到 ACK 延迟超时。

因此,当客户端进行 2 次写入调用时,会发生以下情况:

  1. 客户端发出第一次写入。

  2. 服务器收到一些数据。它不承认它,希望有更多的数据到达(因此它可以在一个 ACK 中批量处理一堆 ACK)。

  3. 客户端发出第二次写入。先前的写入尚未得到确认,因此 Nagle 的算法延迟传输,直到有更多数据到达(直到收集到足够的数据来组成一个段)或先前的写入被 ACKed。

  4. 服务器厌倦了等待,并在 500 毫秒后确认该段。

  5. 客户端_finally_完成第二次写入。

使用 1 次写入,会发生以下情况:

  1. 客户端发出第一次写入。

  2. 服务器收到一些数据。它不承认它,希望有更多的数据到达(因此它可以在一个 ACK 中批量处理一堆 ACK)。

  3. 服务器写入套接字。ACK是 TCP 标头的一部分,因此如果您正在编写,您不妨免费确认前一个段。去做吧。

  4. 同时,客户端写了一次,所以它已经在等待下一次读取 - 没有第二次写入等待服务器的 ACK。

如果您想在客户端继续写入两次,则需要禁用 Nagle 算法。这是算法作者自己提出的解决方案:

用户级解决方案是避免套接字上的写-写-读序列。写-读-写-读很好。写写写很好。但是写-写-读是一个杀手。因此,如果可以的话,缓冲您对 TCP 的少量写入并一次性发送它们。使用标准 UNIX I/O 包并在每次读取之前刷新写入通常是可行的。

(参见维基百科上的引文)

正如 David Schwartz 在评论中提到的那样,由于各种原因,这可能不是最好的想法,但它说明了这一点并表明这确实导致了延迟。

要禁用它,您需要在带有setsockopt(2)的套接字上设置TCP_NODELAY选项。

这可以在tcpConnectTo()中为客户端完成:

int tcpConnectTo(const char* server, const char* port)
{
    struct sockaddr_in sa;
    if(getsockaddr(server,port,(struct sockaddr*)&sa)<0) return -1;
    int sock=tcpConnect(&sa); if(sock<0) return -1;

    int val = 1;
    if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val)) < 0)
        perror("setsockopt(2) error");

    return sock;
}

在tcpAccept()中为服务器:

int tcpAccept(const char* port)
{
    int listenSock, sock;
    listenSock = tcpListenAny(port);
    if((sock=accept(listenSock,0,0))<0) return fprintf(stderr,"Accept failed\n"),-1;
    close(listenSock);

    int val = 1;
    if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val)) < 0)
        perror("setsockopt(2) error");

    return sock;
}

看到这带来的巨大差异很有趣。

如果您不想弄乱套接字选项,那么确保客户端在下一次读取之前写入一次 - 并且只写入一次就足够了。您仍然可以让服务器读取两次:

for(i=0;i<4000;++i)
{
    if(amServer)
    { writeLoop(sock,buf,10);
        //readLoop(sock,buf,20);
        readLoop(sock,buf,10);
        readLoop(sock,buf,10);
    }else
    { readLoop(sock,buf,10);
        writeLoop(sock,buf,20);
        //writeLoop(sock,buf,10);
        //writeLoop(sock,buf,10);
    }
}
# webrtc # linux # tcpdump
Logo
Linux