稲田 直哉 (INADA Naoki)

• KLab Inc.
• @methane
• msgpack-python

• source

  http://github.com/methane/pyconjp2012-gevent-slide/

• slide

  http://methane.github.com/pyconjp2012-gevent-slide/en.html

• Target of Gevent
• What makes Gevent unique
• How Gevent works
• Start using Gevent

Easy and efficient IO multiplexing

Working on conccurrnt IO.

• Web Application
• Chatting system
• tailing multi files.
• downloading many porn images from web.

blocking IO

blocks entire thread when can't process IO immediate.

Make threads to multiplex blocking IO.

nonblocking IO

returns error without blocking when can't process IO immediate.

1. Wait multiple IOs with single blocking call. (select, epoll, kqeuue, ...)
2. Process returned IO with event driven programming.

Only works with single client

import socket

def echo(sock):
    try:
        while True:
            data = sock.recv(1024) # blocks until recieve data.
            if not data:
                break
            sock.sendall(data) # block until send buffer is not full.
    finally:
        sock.close()

def serve(addr):
    sock = socket.socket()
    sock.bind(addr); sock.listen(50)
    while True:
        conn, _ = sock.accept() # block untile client comes.
        echo(conn) # doesn't return until client disconnect.

serve(('0.0.0.0', 4000))

Wrap with thread. Very easy.

import socket, threading

def echo(sock):
    try:
        while True:
            data = sock.recv(1024)
            if not data:
                break
            sock.sendall(data)
    finally:
        sock.close()

def serve(addr):
    sock = socket.socket()
    sock.bind(addr); sock.listen(50)
    while True:
        conn, _ = sock.accept()
        threading.Thread(target=echo, args=(conn,)).start()

serve(('0.0.0.0', 4000))

Using select manually is very hard

echo_select.py

    #...
    def on_readable(self):
        while True:
            conn, _ = self.sock.accept()
            EchoHandler(conn)
    #...
    def on_readable(self):
        try:
            data = self.sock.recv(4096)
            if not data:
                self.close()
                return
            self.buf.append(data)
        finally:
            self._update()
    #...

It makes event driven programming easy

from tornado import ioloop, iostream
from tornado.netutil import TCPServer

class EchoServer(TCPServer):
    def handle_stream(self, stream, addr):
        stream.read_until_close(
                lambda _: stream.close(), # when closed connection.
                stream.write, # when recieved data.
                )

def serve(addr):
    server = EchoServer()
    server.listen(addr[1], addr[0])
    ioloop.IOLoop.instance().start()

serve(('', 4000))

• echo server with Gevent

• Gevent vs Threading

  • Performance

• Gevent vs Tornado

  • Programming.

from gevent.server import StreamServer

def handler(sock, addr):
    try:
        while 1:
            buf = sock.recv(4096)
            if not buf:
                return
            sock.sendall(buf)
    finally:
        sock.close()

def serve(addr):
    server = StreamServer(addr, handler, backlog=1024)
    server.serve_forever()

serve(('', 4000))

import gevent.monkey; gevent.monkey.patch_all()
import socket, threading

def echo(sock):
    try:
        while True:
            data = sock.recv(1024)
            if not data:
                break
            sock.sendall(data)
    finally:
        sock.close()

def serve(addr):
    sock = socket.socket()
    sock.bind(addr); sock.listen(50)
    while True:
        conn, _ = sock.accept()
        threading.Thread(target=echo, args=(conn,)).start()

serve(('0.0.0.0', 4000))

1000 clients sends 1000 messages to echo server.

(Total 1M messages)

threading: 34MB

gevent: 26MB

tornado: 12MB

select: 6.1MB

threading: 3.9GB

gevent: 41MB

tornado: 27MB

select: 21MB

Threaded code doesn't run in 32bit environment.

threading: 43sec

gevent: 53sec

tornado: 43sec

select: 25sec

2000 clients send 50 messages. (Total: 0.1M)

Add busy loop before send.

def stress(): # 18.6 ms
    def rec(n):
        if n:
            return rec(n-1)
    for i in xrange(100):
        rec(100)

Threading have significant overhead.

• Threading is enough on many circumstance

  It's ok to use Gevent for fun :-)

• multicore, multithread, heavy load

  When threading overhead is problem, Gevent helps us.

Gevent

Many libraries works on Gevent with monkey patching.

It's easy to support gevent.

Tornado

Requires full scratch.

Example: PyMongo

Works on Gevent with monkey patch.

It doesn't return to Tornado IO loops. So Motor (gevent like system) is developed.

Torando, Twisted, node.js are good event driven programming framework.

Gevent allows standard programming style
and using existing libraries.

1. Greenlet
2. gevent.core
3. gevent.hub

• low memory consuption.
• smaller overhead when switching. (especially, with Old GIL)

• cooperative (easy to write threadsafe code)

• doesn't run blocking system call concurrently

• gevent.thread -- gevent version of standard thread
• gevent.socket -- standard socket
• gevent.select -- standard select
• gevent.queue -- standard Queue
• gevent.lock -- locks in threading
• gevent.pywsgi -- wsgi server
• gevent.monkey -- monkey patch
• etc...

• event loop (core)
• connector for event loop and greenlet (hub)
• modules highly compatible to standard library.
• monkey patch replacing standard libraries with gevent version.
• tcpserver, wsgiserver, name resolution, etc...
• pool, Event, AsyncResult, etc...

• supporting WebSocket
• supporting Comet (long polling)
• supporting Streaming API
• anytime needs massive concurrent connection.
• When threading is not efficient.

• Python 3
• PyPy

tutorial

http://sdiehl.github.com/gevent-tutorial

in japanese

http://methane.github.com/gevent-tutorial-ja

Github

https://github.com/SiteSupport/gevent

website

http://gevent.org/