Szybsze gniazda w Pythonie
Mam klienta napisanego w Pythonie dla serwera, który działa za pośrednictwem sieci LAN. Jakaś część algorytmu używa intensywnego czytania z gniazda i wykonuje się około 3-6 razy wolniej niżprawie ten sam napisany w C ++. Jakie są rozwiązania umożliwiające szybsze czytanie gniazda Python?
Mam zaimplementowane proste buforowanie, a moja klasa do pracy z gniazdami wygląda tak:
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 .: profilowanie pokazuje również, że większość czasu spędza na czytaniu gniazd.
Edytować: Ponieważ dane są odbierane w blokach o znanym rozmiarze, mogę odczytać cały blok na raz. Zmieniłem więc kod:
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
z gniazda wygląda optymalnie w tym kodzie. Ale teraznext_int
inext_float
stały się drugim wąskim gardłem, zajmują około 1 ms (3000 cykli procesora) na wywołanie, aby się rozpakować. Czy można je przyspieszyć, tak jak w C ++?