Nicholas Piël

INPROC

import zmq
context = zmq.Context()
socket = context.socket(zmq.REP)
socket.bind("tcp://127.0.0.1:5000")

while True:
    msg = socket.recv()
    print "Got", msg
    socket.send(msg)

import zmq
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://127.0.0.1:5000")
socket.connect("tcp://127.0.0.1:6000")

for i in range(10):
    msg = "msg %s" % i
    socket.send(msg)
    print "Sending", msg
    msg_in = socket.recv()

import zmq
from random import choice
context = zmq.Context()
socket = context.socket(zmq.PUB)
socket.bind("tcp://127.0.0.1:5000")

countries = ['netherlands','brazil','germany','portugal']
events = ['yellow card', 'red card', 'goal', 'corner', 'foul']

while True:
    msg = choice( countries ) +" "+ choice( events )
    print "->",msg
    socket.send( msg )

import zmq

context = zmq.Context()
socket = context.socket(zmq.SUB)
socket.connect("tcp://127.0.0.1:5000")
socket.setsockopt(zmq.SUBSCRIBE, "netherlands")
socket.setsockopt(zmq.SUBSCRIBE, "germany")

while True:
    print  socket.recv()

import zmq
context = zmq.Context()
socket = context.socket(zmq.PAIR)
socket.bind("tcp://127.0.0.1:5555")

import zmq
context = zmq.Context()
socket = context.socket(zmq.PAIR)
socket.connect("tcp://127.0.0.1:5555")

def application(environ, start_response):
    status = '200 OK'
    output = 'Pong!'

    response_headers = [('Content-type', 'text/plain'),
                        ('Content-Length', str(len(output)))]
    start_response(status, response_headers)
    return [output]

from cherrypy import wsgiserver
from pong import application

# Here we set our application to the script_name '/'
wsgi_apps = [('/', application)]

server = wsgiserver.CherryPyWSGIServer(('0.0.0.0', 8070), wsgi_apps, request_queue_size=500,     server_name='localhost')

if __name__ == '__main__':
    try:
        server.start()
    except KeyboardInterrupt:
        server.stop()

from cogen.web import wsgi
from cogen.common import *
from pong import application

m = Scheduler(default_priority=priority.LAST, default_timeout=15)
server = wsgi.WSGIServer(
            ('0.0.0.0', 8070),
            application,
            m,
            server_name='pongserver')
m.add(server.serve)
try:
    m.run()
except (KeyboardInterrupt, SystemExit):
    pass

from concurrence import dispatch
from concurrence.http import WSGIServer
from pong import application
server = WSGIServer(application)
# Concurrence has a default backlog of 512
dispatch(server.serve(('0.0.0.0', 8080)))

import eventlet
from eventlet import wsgi
from pong import application
wsgi.server(eventlet.listen(('', 8090), backlog=500), application, max_size=8000)

import fapws._evwsgi as evwsgi
from fapws import base
from pong import application

def start():
    evwsgi.start("0.0.0.0", 8080)
    evwsgi.set_base_module(base)

    evwsgi.wsgi_cb(("/", application))

    evwsgi.set_debug(0)
    evwsgi.run()

if __name__=="__main__":
    start()

from gevent import wsgi
from pong import application
wsgi.WSGIServer(('', 8088), application, spawn=None).serve_forever()

#config.py
import magnum
import magnum.http
import magnum.http.wsgi
from pong import application

WORKER_PROCESSES = 1
WORKER_THREADS_PER_PROCESS = 1000
HOST = ('', 8050)
HANDLER_CLASS = magnum.http.wsgi.WSGIWrapper(application)
DEBUG = False
PID_FILE = '/tmp/magnum.pid'

<IfModule mpm_worker_module>
    ServerLimit         1
    ThreadLimit         1000
    StartServers          1
    MaxClients          1000
    MinSpareThreads     25
    MaxSpareThreads     75
    ThreadsPerChild     1000
    MaxRequestsPerChild   0
</IfModule>
CustomLog /dev/null combined
ErrorLog /dev/null

from pong import application
from paste import httpserver
httpserver.serve(application, '0.0.0.0', request_queue_size=500)

import os
import tornado.httpserver
import tornado.ioloop
import tornado.wsgi
import sys
from pong import application
sys.path.append('/home/nicholas/benchmark/wsgibench/')
def main():
    container = tornado.wsgi.WSGIContainer(application)
    http_server = tornado.httpserver.HTTPServer(container)
    http_server.listen(8000)
    tornado.ioloop.IOLoop.instance().start()
if __name__ == "__main__":
    main()

from twisted.web.server import Site
from twisted.web.wsgi import WSGIResource
from twisted.internet import reactor
from pong import application

resource = WSGIResource(reactor, reactor.getThreadPool(), application)
reactor.listenTCP(8000,Site(resource))
reactor.run()

worker_processes  1;

events {
    worker_connections  30000;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    keepalive_timeout  65;

    upstream pingpong {
        ip_hash;
        server unix:/var/nginx/uwsgi.sock;
    }

    server {
        listen       9090;
        server_name  localhost;

        location / {
            uwsgi_pass  pingpong;
            include     uwsgi_params;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

    }

}

from pong import application
from wsgiref import simple_server

class PimpedWSGIServer(simple_server.WSGIServer):
    # To increase the backlog
    request_queue_size = 500

class PimpedHandler(simple_server.WSGIRequestHandler):
    # to disable logging
    def log_message(self, *args):
        pass

httpd = PimpedWSGIServer(('',8000), PimpedHandler)
httpd.set_app(application)
httpd.serve_forever()

<?xml version="1.0"?>
<!DOCTYPE tsung SYSTEM "/usr/share/tsung/tsung-1.0.dtd" []>
<tsung loglevel="warning">

    <clients>
        <client host="tsung2" use_controller_vm="false" maxusers="800"/>
        <client host="tsung3" use_controller_vm="false" maxusers="800"/>
        <client host="bastet" use_controller_vm="false" maxusers="800"/>
    </clients>
    <servers>
        <server host="tsung1" port="8000" type="tcp"/>
    </servers>
    <monitoring>
        <monitor host="tsung1" type="erlang"/>
    </monitoring>

    <load>
        <arrivalphase phase="1" duration="5" unit="minute">
            <users interarrival="0.002" unit="second"/>
        </arrivalphase>
    </load>

    <sessions>
        <session name='wsgitest' probability='100'  type='ts_http'>
            <for from="0" to="12" incr="1" var="counter">
                <request>
                    <http url='http://tsung1:8000/' version='1.1' method='GET'/>
                </request>
                <thinktime random='false' value='5'/>
            </for>
        </session>
    </sessions>

</tsung>

from twisted.internet import epollreactor epollreactor.install()
from twisted.internet.protocol import Protocol, Factory
from twisted.internet import reactor

class Pong(Protocol):
 def connectionMade(self):
 self.transport.write("HTTP/1.0 200 OK\r\nContent-Length: 5\r\n\r\nPong!\r\n")
 self.transport.loseConnection()

# Start the reactor
factory = Factory()
factory.protocol = Pong
reactor.listenTCP(8000, factory)
reactor.run()


import errno
import functools
import socket
from tornado import ioloop, iostream

def connection_ready(sock, fd, events):
    while True:
        try:
            connection, address = sock.accept()
        except socket.error, e:
            if e[0] not in (errno.EWOULDBLOCK, errno.EAGAIN):
                raise
            return
        connection.setblocking(0)
        stream = iostream.IOStream(connection)
        stream.write("HTTP/1.0 200 OK\r\nContent-Length: 5\r\n\r\nPong!\r\n", stream.close)

if __name__ == '__main__':
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.setblocking(0)
    sock.bind(("", 8010))
    sock.listen(5000)

    io_loop = ioloop.IOLoop.instance()
    callback = functools.partial(connection_ready, sock)
    io_loop.add_handler(sock.fileno(), callback, io_loop.READ)
    try:
        io_loop.start()
    except KeyboardInterrupt:
        io_loop.stop()
        print "exited cleanly"

from diesel import Application, Service

def server_pong(addr):
    yield "HTTP/1.0 200 OK\r\nContent-Length: 5\r\n\r\nPong!\r\n"

app = Application()
app.add_service(Service(server_pong, 8020))
app.run()

from circuits.net.sockets import TCPServer

class PongServer(TCPServer):

    def connect(self, sock, host, port):
        self.write(sock, 'HTTP/1.0 200 OK\r\nContent-Length: 5\r\n\r\nPong!\r\n')
        self.close(sock)

PongServer(('localhost', 8050)).run()

from eventlet import api

def handle_socket(sock):
    sock.makefile('w').write("HTTP/1.0 200 OK\r\nContent-Length: 5\r\n\r\nPong!\r\n")
    sock.close()

server = api.tcp_listener(('localhost', 8030))
while True:
    try:
        new_sock, address = server.accept()
    except KeyboardInterrupt:
        break
    # handle every new connection with a new coroutine
    api.spawn(handle_socket, new_sock)

import gevent
from gevent import socket

def handle_socket(sock):
    sock.sendall("HTTP/1.0 200 OK\r\nContent-Length: 5\r\n\r\nPong!\r\n")
    sock.close()

server = socket.socket()
server.bind(('localhost', 8070))
server.listen(500)
while True:
    try:
        new_sock, address = server.accept()
    except KeyboardInterrupt:
        break
    # handle every new connection with a new coroutine
    gevent.spawn(handle_socket, new_sock)

from concurrence import dispatch, Tasklet
from concurrence.io import BufferedStream, Socket

def handler(client_socket):
    stream = BufferedStream(client_socket)
    writer = stream.writer
    writer.write_bytes("HTTP/1.0 200 OK\r\nContent-Length: 5\r\n\r\nPong!\r\n")
    writer.flush()
    stream.close()

def server():
    server_socket = Socket.new()
    server_socket.bind(('localhost', 8040))
    server_socket.listen()

    while True:
        client_socket = server_socket.accept()
        Tasklet.new(handler)(client_socket)

if __name__ == '__main__':
    dispatch(server)

import sys

from cogen.core import sockets
from cogen.core import schedulers
from cogen.core.coroutines import coroutine

@coroutine
def server():
    srv = sockets.Socket()
    adr = ('0.0.0.0', len(sys.argv)>1 and int(sys.argv[1]) or 1200)
    srv.bind(adr)
    srv.listen(500)
    while 1:
        conn, addr = yield srv.accept()
        fh = conn.makefile()
        yield fh.write("HTTP/1.0 200 OK\r\nContent-Length: 12\r\n\r\nHello World!\r\n")
        yield fh.flush()
        conn.close()

m = schedulers.Scheduler()
m.add(server)
m.run()

Name	Version	http 1.1	Flavour	Repo.	Blog	Community
Gunicorn	0.6.4	No	processor/thread	GIT	?	#gunicorn
uWSGI	Trunk (253)	Yes	processor/thread	repo	?	Mailing List
FAPWS3	0.3.1	No	processor/thread	GIT	William Os4y	Google Groups
Aspen	0.8	No	processor/thread	SVN	Chad Whitacre	Google Groups
Mod_WSGI	3.1	Yes	processor/thread	SVN	Graham Dumpleton	Google Groups
wsgiref	Py 2.6.4	No	processor/thread	SVN	None	Mailing List
CherryPy	3.1.2	Yes	processor/thread	SVN	Planet CherryPy	Planet, IRC
Magnum Py	0.2	No	processor/thread	SVN	Matt Gattis	Google Groups
Twisted	10.0.0	Yes	processor/thread	SVN	Planet Twisted	Community
Cogen	0.2.1	Yes	callback/generator	SVN	Maries Ionel	Google Groups
GEvent	0.12.2	Yes	lightweight threads	Mercurial	Denis Bilenko	Google Groups
Tornado	0.2	Yes	callback/generator	GIT	Facebook	Google Groups
Eventlet	0.9.6	Yes	lightweight threads	Mercurial	Eventlet	Mailinglist
Concurrence	tip	Yes	lightweight threads	GIT	None	Google Groups

Name	Lic.	Doc	Ex.	Prod.	Com.	Act.	Blog	Twt	Rep.	Pool	Wsgi	Scket	Cmet	Epoll	Test	Style
Twisted	MIT	Yes	Yes	Yes	Huge	Yes	Lots	No	Trac	Yes	Yes	Yes	No	Yes	Yes	Callback
Tornado	Apache	Yes	Yes	F.Feed	Yes	Yes	FB	Yes	GHub	No	Lim.	Yes	No	Yes	No	Async
Orbited	MIT	Yes	Yes	Yes	Yes	Yes	Yes	No	Trac	No	No	Yes	Yes	Yes	Yes	Callback
DieselWeb	BSD	Yes	Yes	STalk	Yes	Yes	Yes	Yes	BitB.	No	Lim.	Yes	Yes	Yes	No	Generator
MultiTask	MIT	Some	No	No	No	No	Yes	No	Bzr	No	No	No	No	No	No	Generator
Chiral	GPL2	API	No	No	IRC	No	No	No	Trac	No	Yes	Yes	Yes	Yes	Yes	Coroutine
Eventlet	MIT	Yes	Yes	S. Life	Yes	Yes	Yes	No	BitB.	Yes	Yes	Yes	No	Yes	Yes	Greenlet
FriendlyFlow	GPL2	Some	One	No	No	No	No	Yes	Ggle	No	No	Yes	No	No	Yes	Generator
Weightless	GPL2	Yes	No	Yes	No	No	No	Yes	SF	No	No	Yes	No	No	Yes	Generator
Fibra	MIT	No	No	No	No	No	Yes	No	Ggle	No	No	Yes	No	No	No	Generator
Concurrence	MIT	Yes	Yes	hyves	Yes	Yes	No	No	GHub	No	Yes	Yes	No	Yes	Yes	Tasklet
Circuits	MIT	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Trac	No	Yes	Yes	No	No	Yes	Async
Gevent	MIT	Yes	Yes	Yes	Yes	Yes	Yes	Yes	BitB.	No	Yes	Yes	No	Yes	Yes	Greenlet
Cogen	MIT	Yes	Yes	Yes	No	Yes	Yes	Yes	Ggle	No	Yes	Yes	No	Yes	Yes	Generator

Nicholas Piël

Posts

Float like a butterfly, sting like a bee

Performance

Simplicity

Scalability

Implementing a messaging layer with ZeroMQ

Choosing a transport

Setting up the infrastructure

Selecting a message pattern

Request Reply

Publish Subscribe

Pipelining

Paired sockets

ZeroMQ and the future

The benchmark

The Contestants

Implementation specifics for each WSGI server

Aspen

CherryPy

Cogen

Concurrence

Eventlet

FAPWS3

Gevent

Gunicorn

MagnumPy

Mod_WSGI

Paster

Tornado

Twisted

uWSGI

WsgiRef

Results

HTTP 1.0 Server results

HTTP 1.1 Server results

Memory Usage

Let’s Kick it up a notch

Tsung Benchmark Setup

Tsung Benchmark Results

Summary and Remarks

Asynchronous Server Specs

The Ping Pong Benchmark

Code

Twisted

Tornado

Dieselweb

Circuits

Eventlet

Gevent

Concurrence

Cogen

Results

Notes

References

Round 2: The need for data sharing

My efforts on data sharing

Posts