Question

我有一个客户端用 Python 写成服务器, 它通过局域网运行。算法中的一部分使用套接字快速读取, 其执行速度比 < a href=" http:// pastie. org/ 3962231, rel 几乎是 C++ 中写到的 " noreferrer" 。使 Python 套接字读得更快有什么解决办法?

我有一些简单的缓冲装置, 和我的班级工作插座是这样的:

import socket
import struct

class Sock():
    def __init__(self):
        self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.recv_buf = b  
        self.send_buf = b  

    def connect(self):
        self.s.connect(( 127.0.0.1 , 6666))

    def close(self):
        self.s.close()

    def recv(self, lngth):
        while len(self.recv_buf) < lngth:
                self.recv_buf += self.s.recv(lngth - len(self.recv_buf))

        res = self.recv_buf[-lngth:]
        self.recv_buf = self.recv_buf[:-lngth]
        return res

    def next_int(self):
        return struct.unpack("i", self.recv(4))[0]

    def next_float(self):
        return struct.unpack("f", self.recv(4))[0]

    def write_int(self, i):
        self.send_buf += struct.pack( i , i)

    def write_float(self, f):
        self.send_buf += struct.pack( f , f)

    def flush(self):
        self.s.sendall(self.send_buf)
        self.send_buf = b

P.S.:概况分析还表明,大部分时间用于阅读插座。

<强度> 编辑: 因为数据是用已知大小的区块接收的, 我可以立刻读取整个区块。所以我把我的代码改成了这个 :

class Sock():
    def __init__(self):
        self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.send_buf = b  

    def connect(self):
        self.s.connect(( 127.0.0.1 , 6666))

    def close(self):
        self.s.close()

    def recv_prepare(self, cnt):
        self.recv_buf = bytearray()
        while len(self.recv_buf) < cnt:
            self.recv_buf.extend(self.s.recv(cnt - len(self.recv_buf)))

        self.recv_buf_i = 0

    def skip_read(self, cnt):
        self.recv_buf_i += cnt

    def next_int(self):
        self.recv_buf_i += 4
        return struct.unpack("i", self.recv_buf[self.recv_buf_i - 4:self.recv_buf_i])[0]

    def next_float(self):
        self.recv_buf_i += 4
        return struct.unpack("f", self.recv_buf[self.recv_buf_i - 4:self.recv_buf_i])[0]

    def write_int(self, i):
        self.send_buf += struct.pack( i , i)

    def write_float(self, f):
        self.send_buf += struct.pack( f , f)

    def flush(self):
        self.s.sendall(self.send_buf)
        self.send_buf = b

recv 来源于 socket 的 < exter_int 似乎是最佳的。但是现在 next_int 和 and next_float 成为第二个瓶颈,他们每次打开解锁的电话大约需要1 msec (3,000 CPU 周期) 。是否有可能更快一些, 如 C++ 中的 C++?

Answer 1

您最近的瓶颈在 next_int 和 next_float 中,因为您从 byeararray 创建中间字符串,而且您每次只解开一个值。

struct 模块有一个 unpack_ from 的 unpack_ from 模块,该模块取用缓冲和偏移。这样做更有效率, 因为不需要从您的 bytearray 创建中间字符串 :

def next_int(self):
    self.recv_buf_i += 4
    return struct.unpack_from("i", self.recv_buf, self.recv_buf_i-4)[0]

此外, struct 模块可以一次解开多个值。目前, 您会为每个值从 Python 到 C (通过模块) 调用。您最好将其调用为更少的时间, 并让它对每次调用做更多的工作 :

def next_chunk(self, fmt): # fmt can be a group such as "iifff" 
    sz = struct.calcsize(fmt) 
    self.recv_buf_i += sz
    return struct.unpack_from(fmt, self.recv_buf, self.recv_buf_i-sz)

如果您知道 fmt 将始终是 4 位元整数和浮点, 您可以用 > 4 * len(fmt) 替换 struct. calcision(fmt) 。

最后,作为一个优先事项,我认为这段文字更清楚明了:

def next_chunk(self, fmt): 
    sz = struct.calcsize(fmt) 
    chunk = struct.unpack_from(fmt, self.recv_buf, self.recv_buf_i)
    self.recv_buf_i += sz
    return chunk

友情链接