python-eventlet/benchmarks/localhost_socket.py

   1 """Benchmark evaluating eventlet's performance at speaking to itself over a localhost socket."""
   2 from __future__ import print_function
   3
   4 import time
   5
   6 import benchmarks
   7 from eventlet.support import six
   8
   9
  10 BYTES = 1000
  11 SIZE = 1
  12 CONCURRENCY = 50
  13 TRIES = 5
  14
  15
  16 def reader(sock):
  17     expect = BYTES
  18     while expect > 0:
  19         d = sock.recv(min(expect, SIZE))
  20         expect -= len(d)
  21
  22
  23 def writer(addr, socket_impl):
  24     sock = socket_impl(socket.AF_INET, socket.SOCK_STREAM)
  25     sock.connect(addr)
  26     sent = 0
  27     while sent < BYTES:
  28         d = 'xy' * (max(min(SIZE / 2, BYTES - sent), 1))
  29         sock.sendall(d)
  30         sent += len(d)
  31
  32
  33 def green_accepter(server_sock, pool):
  34     for i in six.moves.range(CONCURRENCY):
  35         sock, addr = server_sock.accept()
  36         pool.spawn_n(reader, sock)
  37
  38
  39 def heavy_accepter(server_sock, pool):
  40     for i in six.moves.range(CONCURRENCY):
  41         sock, addr = server_sock.accept()
  42         t = threading.Thread(None, reader, "reader thread", (sock,))
  43         t.start()
  44         pool.append(t)
  45
  46
  47 import eventlet.green.socket
  48 import eventlet
  49
  50 from eventlet import debug
  51 debug.hub_exceptions(True)
  52
  53
  54 def launch_green_threads():
  55     pool = eventlet.GreenPool(CONCURRENCY * 2 + 1)
  56     server_sock = eventlet.green.socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  57     server_sock.bind(('localhost', 0))
  58     server_sock.listen(50)
  59     addr = ('localhost', server_sock.getsockname()[1])
  60     pool.spawn_n(green_accepter, server_sock, pool)
  61     for i in six.moves.range(CONCURRENCY):
  62         pool.spawn_n(writer, addr, eventlet.green.socket.socket)
  63     pool.waitall()
  64
  65
  66 import threading
  67 import socket
  68
  69
  70 def launch_heavy_threads():
  71     threads = []
  72     server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  73     server_sock.bind(('localhost', 0))
  74     server_sock.listen(50)
  75     addr = ('localhost', server_sock.getsockname()[1])
  76     accepter_thread = threading.Thread(
  77         None, heavy_accepter, "accepter thread", (server_sock, threads))
  78     accepter_thread.start()
  79     threads.append(accepter_thread)
  80     for i in six.moves.range(CONCURRENCY):
  81         client_thread = threading.Thread(None, writer, "writer thread", (addr, socket.socket))
  82         client_thread.start()
  83         threads.append(client_thread)
  84     for t in threads:
  85         t.join()
  86
  87
  88 if __name__ == "__main__":
  89     import optparse
  90     parser = optparse.OptionParser()
  91     parser.add_option('--compare-threading', action='store_true', dest='threading', default=False)
  92     parser.add_option('-b', '--bytes', type='int', dest='bytes',
  93                       default=BYTES)
  94     parser.add_option('-s', '--size', type='int', dest='size',
  95                       default=SIZE)
  96     parser.add_option('-c', '--concurrency', type='int', dest='concurrency',
  97                       default=CONCURRENCY)
  98     parser.add_option('-t', '--tries', type='int', dest='tries',
  99                       default=TRIES)
 100
 101     opts, args = parser.parse_args()
 102     BYTES = opts.bytes
 103     SIZE = opts.size
 104     CONCURRENCY = opts.concurrency
 105     TRIES = opts.tries
 106
 107     funcs = [launch_green_threads]
 108     if opts.threading:
 109         funcs = [launch_green_threads, launch_heavy_threads]
 110     results = benchmarks.measure_best(TRIES, 3,
 111                                       lambda: None, lambda: None,
 112                                       *funcs)
 113     print("green:", results[launch_green_threads])
 114     if opts.threading:
 115         print("threads:", results[launch_heavy_threads])
 116         print("%", (results[launch_green_threads] - results[launch_heavy_threads]
 117                     ) / results[launch_heavy_threads] * 100)