python - real - Punto de referencia de la latencia del socket TCP vs. UDP

socket python 3 example

Question

Implementé un pequeño punto de referencia para la comunicación de socket a través de TCP y UDP en Python. Sorprendentemente, TCP es casi exactamente el doble de rápido que UDP.

Para evitar los efectos de enrutamiento, el servidor y el cliente se ejecutan en la misma máquina Unix, pero en diferentes subprocesos.

Tal vez el código es útil. Aquí está el código del servidor:

import socket
import sys
host = ''localhost''
port = 8888
buffersize = 8
server_address = (host, port)
def start_UDP_server():
socket_UDP = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
socket_UDP.bind(server_address)
print("UDP server is running...")
while True:
data, from_address = socket_UDP.recvfrom(buffersize)
if not data: break
socket_UDP.sendto(data, from_address)
socket_UDP.close()
def start_TCP_server():
socket_TCP = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket_TCP.bind(server_address)
socket_TCP.listen(1)
print("TCP server is running...")
while True:
client, client_address = socket_TCP.accept()
while True:
data = client.recv(buffersize)
if not data: break
client.sendall(data)
client.close()

Entonces puede ejecutar start_TCP_server() o start_UDP_server() .

En el lado del cliente, el código es:

import socket
import sys
import time
host = ''localhost''
port = 8888
buffersize = 8
server_address = (host, port)
client_address = (host, port+1)
N = 1000000
def benchmark_UDP():
socket_UDP = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
socket_UDP.bind(client_address)
print("Benchmark UDP...")
duration = 0.0
for i in range(0, N):
b = bytes("a"*buffersize, "utf-8")
start = time.time()
socket_UDP.sendto(b, server_address)
data, from_address = socket_UDP.recvfrom(buffersize)
duration += time.time() - start
if data != b:
print("Error: Sent and received data are bot the same")
print(duration*pow(10, 6)/N, "µs for UDP")
def benchmark_TCP():
socket_TCP = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket_TCP.connect(server_address)
print("Benchmark TCP...")
duration = 0.0
for i in range(0, N):
b = bytes("a"*buffersize, "utf-8")
start = time.time()
socket_TCP.sendall(b)
data = socket_TCP.recv(buffersize)
duration += time.time() - start
if data != b:
print("Error: Sent and received data are bot the same")
print(duration*pow(10, 6)/N, "µs for TCP")
socket_TCP.close()

Al igual que para el servidor, puede iniciar el benchmark mediante benchmark_TCP() o benchmark_UDP() .

Los resultados son alrededor de 25 μs para TCP , y alrededor de 54 μs para UDP en Unix e incluso peor para Windows (alrededor de 30 μs para TCP y más de 200 μs para UDP). ¿Por qué? Esperaría una ventaja mínima para UDP.

Answer 1

Su socket TCP está conectado pero su socket UDP no. Esto significa procesamiento adicional para cada envío / recepción en el socket UDP. Llamada de connect en cada lado para el socket UDP, al igual que llame a connect / accept en el socket TCP.

Programas como iperf hacen esto para medir con precisión.