套接字性能激增

Question

我们在使用 IPC 套接字的高吞吐量事务处理系统中面临着随机峰值。

以下是用于运行的设置：

1. 客户端为每个事务打开和关闭新连接，并且服务器和客户端之间有 4 次交换。
2. 我们通过 getsockopt 设置套接字延迟 (SO_LINGER) 选项来禁用 TIME_WAIT，因为我们认为峰值是由于套接字在 TIME_WAIT< 中等待而引起的/代码>。
3. 没有对交易进行任何处理。仅传递消息。
4. 操作系统使用 Centos 5.4

平均往返时间约为 3 毫秒，但有时往返时间范围从 100 毫秒到几秒。

用于执行、测量和输出的步骤

1. 启动服务器

   $ python sockServerLinger.py > /dev/null &

2. 启动客户端向服务器发送 100 万笔交易。并在 client.log 文件中记录事务的时间。

   $ python sockClient.py 1000000 > client.log

3. 执行完成后，以下命令将以 : 格式显示大于 100 毫秒的执行时间。

   $ grep -n "0.[1-9]" client.log |

   $ grep -n "0.[1-9]" client.log | less

下面是服务器和客户端的示例代码。

服务器

# File: sockServerLinger.py
import socket, traceback,time
import struct
host = ''
port = 9999

l_onoff = 1
l_linger = 0
lingeropt = struct.pack('ii', l_onoff, l_linger)

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, lingeropt)
s.bind((host, port))
s.listen(1)

while 1:
    try:
        clientsock, clientaddr = s.accept()
        print "Got connection from", clientsock.getpeername()
        data = clientsock.recv(1024*1024*10)
        #print "asdasd",data
        numsent=clientsock.send(data)
        data1 = clientsock.recv(1024*1024*10)
        numsent=clientsock.send(data)
        ret = 1
        while(ret>0):
            data1 = clientsock.recv(1024*1024*10)
            ret = len(data)
        clientsock.close()
    except KeyboardInterrupt:
        raise
    except:
        print traceback.print_exc()
        continue

客户端

# File: sockClient.py

import socket, traceback,sys
import time
i = 0
while 1:
    try:
        st = time.time()
        s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        while (s.connect_ex(('127.0.0.1',9999)) != 0):
            continue
        numsent=s.send("asd"*1000)
        response = s.recv(6000)
        numsent=s.send("asd"*1000)
        response = s.recv(6000)
        i+=1
        if i == int(sys.argv[1]):
            break
    except KeyboardInterrupt:
        raise
    except:
        print "in exec:::::::::::::",traceback.print_exc()
        continue
    print time.time() -st

Answer 1

我想到了一种可能性：

1）因为您使用的是 SOCK_STREAM，所以您正在使用 TCP 协议
2）作为一个可靠的协议，TCP会重新发送超时的数据包，以确保一切最终到达。
3) TCP 使用动态超时值，该值是根据当前往返时间 (RTT) 的估计值计算得出的
4）当TCP连接第一次启动时，它不知道RTT是多少，因此它使用非常大的初始超时值，有时约为秒。

所以...如果早期的 TCP 握手数据包之一被丢弃，您的套接字可能会等待很长时间，然后才确定该数据包没有到达那里并重新发送它。这种情况会随机发生，相对较少，但在一百万个连接中肯定会发生很多次。

尝试使用具有相对较短值的socket.settimeout()，如果连接超时，请立即重试。通过这种方式，您可以假装拥有较短的初始 RTT 估计值。