Added debug control over exceptions in greenpool, benchmarks directory.

1 files changed, 100 insertions, 0 deletions

diff --git a/benchmarks/localhost_socket.py b/benchmarks/localhost_socket.py
new file mode 100644
index 0000000..f249255
--- /dev/null
+++ b/benchmarks/localhost_socket.py
@@ -0,0 +1,100 @@
+"""Benchmark evaluating eventlet's performance at speaking to itself over a localhost socket."""
+
+import time
+import benchmarks
+
+BYTES=1000
+SIZE=1
+CONCURRENCY=50
+
+def reader(sock):
+    expect = BYTES
+    while expect > 0:
+        d = sock.recv(min(expect, SIZE))
+        expect -= len(d)
+            
+def writer(addr, socket_impl):
+    sock = socket_impl(socket.AF_INET, socket.SOCK_STREAM)
+    sock.connect(addr)
+    sent = 0
+    while sent < BYTES:
+        d = 'xy' * (max(min(SIZE/2, BYTES-sent), 1))
+        sock.sendall(d)
+        sent += len(d)
+        
+        
+def green_accepter(server_sock, pool):
+    for i in xrange(CONCURRENCY):
+        sock, addr = server_sock.accept()
+        pool.spawn_n(reader, sock)
+
+def heavy_accepter(server_sock, pool):
+    for i in xrange(CONCURRENCY):
+        sock, addr = server_sock.accept()
+        t = threading.Thread(None, reader, "reader thread", (sock,))
+        t.start()
+        pool.append(t)
+
+import eventlet.green.socket
+import eventlet
+
+from eventlet import debug
+debug.hub_exceptions(True)
+
+def launch_green_threads():
+    pool = eventlet.GreenPool(CONCURRENCY * 2 + 1)
+    server_sock = eventlet.green.socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    server_sock.bind(('localhost', 0))
+    server_sock.listen(50)
+    addr = ('localhost', server_sock.getsockname()[1])
+    pool.spawn_n(green_accepter, server_sock, pool)
+    for i in xrange(CONCURRENCY):
+        pool.spawn_n(writer, addr, eventlet.green.socket.socket)
+    pool.waitall()
+       
+import threading
+import socket       
+    
+def launch_heavy_threads():
+    threads = []
+    server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    server_sock.bind(('localhost', 0))
+    server_sock.listen(50)
+    addr = ('localhost', server_sock.getsockname()[1])
+    accepter_thread = threading.Thread(None, heavy_accepter, "accepter thread", (server_sock, threads))
+    accepter_thread.start()
+    threads.append(accepter_thread)
+    for i in xrange(CONCURRENCY):
+        client_thread = threading.Thread(None, writer, "writer thread", (addr, socket.socket))
+        client_thread.start()
+        threads.append(client_thread)
+    for t in threads:
+        t.join()
+
+
+if __name__ == "__main__":
+    import optparse
+    parser = optparse.OptionParser()
+    parser.add_option('--compare-threading', action='store_true', dest='threading', default=False)
+    parser.add_option('-b', '--bytes', type='int', dest='bytes', 
+                      default=BYTES)
+    parser.add_option('-s', '--size', type='int', dest='size', 
+                      default=SIZE)
+    parser.add_option('-c', '--concurrency', type='int', dest='concurrency', 
+                      default=CONCURRENCY)
+    
+    opts, args = parser.parse_args()
+    BYTES=opts.bytes
+    SIZE=opts.size
+    CONCURRENCY=opts.concurrency
+    
+    funcs = [launch_green_threads]
+    if opts.threading:
+        funcs = [launch_green_threads, launch_heavy_threads]
+    results = benchmarks.measure_best(3, 3,
+                                      lambda: None, lambda: None,
+                                      *funcs)
+    print "green:", results[launch_green_threads]
+    if opts.threading:
+        print "threads:", results[launch_heavy_threads]
+        print "%", (results[launch_green_threads]-results[launch_heavy_threads])/results[launch_heavy_threads] * 100
\ No newline at end of file