Uvloop: Fast Python networking

http://magic.io/blog/uvloop-blazing-fast-python-networking/

by c17r • 10 years ago

456 127 10 years ago

magic.io

1st129• 10 years ago

I'm the dev behind uvloop. AMA.

plainOldText• 10 years ago

What are some of the non-obvious limitations/peculiarities one should be aware before using this?

1st129• 10 years ago

Wherever you use asyncio, it should be safe to just start using uvloop (once we graduate it from beta).

uvloop shouldn't behave any differently, I've paid special attention to make sure it works exactly the same way as asyncio (down to when its objects are garbage collected).

ruffrey• 10 years ago

at least 2x faster than nodejs, gevent, as well as any other Python asynchronous framework

I did not see any benchmarks in the repo to support this. How was this statistic determined?

kevinastone• 10 years ago

The benchmark (simple echo server) results were right there in the blog post:

http://magic.io/blog/uvloop-blazing-fast-python-networking/t...

1st129• 10 years ago

For benchmarks we have a separate project on the GH: [1] -- you can run the benchmarks on a Linux box pretty easily. Here's an example output: [2]

[1] https://github.com/MagicStack/vmbench [2] http://magic.io/blog/uvloop-blazing-fast-python-networking/t...

e12e• 10 years ago

Not sure what you mean, the benchmark section lists ~40k packets/s for nodejs and asyncio, ~100k for uvloop (for 1KiB packages, similar difference for 10 and 100 KiB) - and ~20k req/s for nodejs, and ~37k for uvloop w/httptools. Interestingly, uvloop pulls ahead for 100KiB request size for the http case.

danappelxx3• 10 years ago

Building on to this, how does it compare to raw libuv in c?Personally, I'm not surprised that python (especially cython) is faster than node in this case, but I still need to see how much less overhead there is to node.

breathesalt• 10 years ago

I'm working on a Python CLI that uses asyncio/aiohttp to make and process requests to a 3rd party API. Anyways, I ran into the 10,000 socket problem today and ended up using a semaphore, that actually boosted the overall performance. Why is that? Is it just because the CPU is overwhelmed otherwise?

1st129• 10 years ago

It depends. Maybe you aren't closing the sockets properly (shutdown + close). Or maybe, because of how TCP works, the sockets are stuck in timeouts and don't really close for a long period of time. If its something like that, then your old connections aren't really closing, and new ones can't be created.

Or maybe it's a simple problem of aiohttp performance -- as shown in the blog post, its HTTP parser is a bit slow.

In general, I'd recommend to use a fewer number of sockets and implement some pipelining of API requests.

takeda3• 10 years ago

Are you making all connections within a single session?

Not long ago I saw example here that someone was creating a new session for every single connection. This is not very optimal way of using it. If you use it within same session, aiohttp will make use of keep-alive, which in turn will reuse existing connections and reduce overhead. You also won't need to use a semaphore, since you can define limit in TCPConnector.

Why you had performance issues? As other said, you were making thousands of connections, each socket need to be in TIME_WAIT state for 2 minutes after closing (limitation of TCP, SCTP does not have this problem). So if you use all connections within short time, you'll essentially run out of them. Some people use tcp_tw_reuse/recycle, and that solves this issue, but that makes your connections no longer follow RFC and you might encounter strange issues later on. The advice above should resolve your problem without any hacks.

zoombini29• 10 years ago

do you have perf benchmarks under heavier concurrency? (e.g., how does it do with 100 concurrent clients? 1000?)

1st129• 10 years ago

The HTTP benchmarks were actually run under concurrency level of 300. I've just updated the post with extra details. See also the full report of HTTP benchmark [1]

[1] http://magic.io/blog/uvloop-blazing-fast-python-networking/h...

continuations2• 10 years ago

1) What makes uvloop which is based on libuv 2x faster than node.js which is also based on libuv?

2) Can uvloop be used with frameworks like flask or django?

3) gevent uses monkey patching to turn blocking libraries such as DB drivers non-blocking, does uvloop do anything similar? If not how does it work with blocking libraries?

1st129• 10 years ago

1) I don't know :( I've answered a similar question in this thread with a couple of guesses.

2) No, they have a different architecture. Although I heard that there is a project to integrate asyncio into django to get websockets and http/2.

3) asyncio/uvloop require you to use explicit async/await. So, unfortunately, the existing networking code that isn't built for asyncio can't be reused. On the bright side, there are so many asyncio DB drivers and other modules now!

qihqi• 10 years ago

The answer of 2) is likely to be "no" as wsgi is synchronous in nature. The only way to run it async is through gevent.

aidos• 10 years ago

You can use guv[0] if you're looking for a UV based version of gevent. I've used it before with good success.

[0] https://github.com/veegee/guv/blob/develop/README.rst

jamesmishra• 10 years ago

It looks like uvloop requires Python 3.5. How practical is it to create a fork for companies stuck on Python 2.7?

1st129• 10 years ago

Not really practical. uvloop is designed to work in tandem with asyncio, which is a Python 3-only module. asyncio, in turn, requires 'yield from' support, something that Python 2 doesn't have.

sharpshadow• 10 years ago

Today it should be good practice to use containers with Python 2.7 and 3.5 or any other versions you like. With that you can solve most szenarios.

masklinn3• 10 years ago

How practical is it to create a fork for companies stuck on Python 2.7?

Not very, it's an alternative event loop for asyncio[0] which was introduced in 3.4 and builds upon other Python 3 features (e.g. `yield from`)

[0] https://docs.python.org/3/library/asyncio.html

sametmax7• 10 years ago

Use either docker or/and crossbar.io to isolate the 2.7 code as a service if you don't want to port it, then add the rest of the code in 3.

viraptor• 10 years ago

No questions, just a thank you for including relevant information about the tests content, concurrency, adding percentile boxes to graphs, etc. (and the tested environment itself!) It's refreshing to see a benchmark taken seriously rather than "we tested some stuff, here are 3 numbers, victory!".

1st129• 10 years ago

Thanks!

felixweis2• 10 years ago

Pretty awesome stuff. Do you think aiohttp's http parsing would benefit much on a hypothetical pypy3 interpreter?

1st129• 10 years ago

Maybe. But I think its parser is better to be replaced with the httptools one.

rattray2• 10 years ago

This is awesome!

How does it compare to PyPy?

Once PyPy3 is available, will this work with it?

1st129• 10 years ago

Once PyPy3 is available, will this work with it?

We'll find a way!

patrickg_zill• 10 years ago

Are you using this code in production?

1st129• 10 years ago

I'd say it's not yet ready for production. The test coverage is fairly decent, though, so I hope we'll make a stable release soon.

That said, uvloop should be fully compatible with asyncio. All APIs should be ready, so you can start testing it in your projects.

cjbprime• 10 years ago

Wow. What's the intuition for why python on top of libuv is 2x faster than node on top of libuv?

1st129• 10 years ago

Two things I'd check first:

1. The benchmarks make servers generate a huge number of objects, so maybe, the GC is under too much pressure.

2. Another possibility is that the v8 JIT can't optimize some JS code in nodejs, or does a poor job.

That said, only careful profiling can answer your question :)

geekuillaume• 10 years ago

I would be interested in seeing the performance difference in NodeJS TCP echo benchmark by using piping instead of reading/writing manually:

  socket.pipe(socket);

fzaninotto• 10 years ago

How about clustering the Node server? By default, node uses only one process. Making the server use all available processes requires a bit more work (see https://nodejs.org/docs/latest/api/cluster.html or https://github.com/Unitech/pm2) but will probably do more justice to Node.js vs Python.

1st129• 10 years ago

but will probably do more justice to Node.js vs Python.

How so? Clustering for node just makes it run in several OS processes. You can (and should) do the same for Python code, it's easy.

occasionalreedr• 10 years ago

C Python uses ref counting, whereas Node/V8 uses GC. Ref counting schemes generally use much less memory and GC scans can be expensive when there's a lot of new data, as is the case for a web server.

windlep3• 10 years ago

This is quite interesting, but I don't find req/sec very interesting at all. These should be about matters of concurrency, that is, how much is being done at once, not how many req/sec overall are done (which could almost be explained away purely by the gains in lower latency).

These benchmarks seem to only use 10 clients concurrently, max. That's ridiculously low.

A few questions I'd like to see answered.

How many clients can you connect to each server, and have each one ping once per 5 mins, before the CPU gets overloaded?

How much memory is used per connection?

How does PyPy+Twisted fair in this?

1st129• 10 years ago

These benchmarks seem to only use 10 clients concurrently, max. That's ridiculously low.

I've just update the post with more details on HTTP benchmarks and attached the correct full-results file [1]. The concurrency level for HTTP benchmarks is 300, not 10.

To answer other questions, I'll have to run some benchmarks tomorrow :)

[1] http://magic.io/blog/uvloop-blazing-fast-python-networking/h...

windlep3• 10 years ago

Cool! For the client test I'm referring to, these would be long-lived clients that stay around and just TCP ping for an echo server, rather than HTTP calls that connect/disconnect.

In my experience, PyPy+twisted is around 5-25x faster CPython/twisted, and smoked asyncio as well. Would be great to see how uvloop compares there, and of course, someday when PyPy supports Python 3.5, there's no reason it couldn't use uvloop via cffi I'd hope.

nitely• 10 years ago

Asyncio is pretty fast, but as soon as you write any Python logic, request per second will drop significantly.

I'm surprise uvloop is faster than node.js since libuv was developed for the latter. Kudos to the author.

1st129• 10 years ago

Asyncio is pretty fast, but as soon as you write any Python logic, request per second will drop significantly.

Sure, but it really depends on how complex your Python code is.

I'm surprise uvloop is faster than node.js since libuv was developed for the latter. Kudos to the author.

Thanks!

tanlermin• 10 years ago

Can't one write the logic in cython also?

SEJeff2• 10 years ago

Also note that David Beazley (google him if you're not aware) has a competitor to asyncio, which arguably is also a direct competitor to this called curio:

http://curio.readthedocs.io/en/latest/

The caveat is that it uses the new async/await coroutine bits that just landed in Python 3.5, so it only works with Python 3.5+. He also gave a talk on concurrency in python recently at last year's PyCon:

https://www.youtube.com/watch?v=MCs5OvhV9S4

1st129• 10 years ago

There are benchmarks of curio in the blog post, FWIW.

SEJeff2• 10 years ago

Good stuff. I saw him RT your announcement of this on twitter.

cderwin• 10 years ago

Unless I'm mistaken, the decorator @asyncio.coroutine() is equivalent to async def and yield from is functionally a drop-in for await, so you should be able to use it with at least 3.4, maybe 3.3. Not that that's much better though.

masklinn3• 10 years ago

That makes it functionally equivalent to uvloop (which from my understanding is a drop-in replacement for the built-in asyncio eventloop).

smegel2• 10 years ago

It is interesting that uvloop-streams is almost identical to gevent in performance. Gevent is based on libev, the project libuv was forked from.

What exactly is the -streams addition that makes uvloop-streams perform so much worse than plain uvloop?

1st129• 10 years ago

Streams implementation is a pretty big chunk of Python code, that manages flow control, buffering, and integration with coroutines. And you don't always need all that stuff when you're writing a protocol, since you can implement them more efficiently as part of protocol parser.

smegel2• 10 years ago

Is it possible to add a benchmark for gevent using raw sockets not StreamServer (assuming that adds similar overhead).

ascotan• 10 years ago

I think claims about being faster than X require showing the code used in the benchmarking.

1st129• 10 years ago

Everything is in the blog post: https://github.com/MagicStack/vmbench/tree/master/servers

haberman4• 10 years ago

However, the performance bottleneck in aiohttp turned out to be its HTTP parser, which is so slow, that it matters very little how fast the underlying I/O library is.

This is exactly the same observation that motivated the Mongrel web server for Ruby, 10 years ago this year.

"Mongrel is a small library that provides a very fast HTTP 1.1 server for Ruby web applications. [...] What makes Mongrel so fast is the careful use of an Ragel [C] extension to provide fast, accurate HTTP 1.1 protocol parsing. This makes the server scream without too many portability issues." -- https://github.com/mongrel/mongrel

And its successor Thin:

"Thin is a Ruby web server that glues together 3 of the best Ruby libraries in web history: (1) the Mongrel parser, the root of Mongrel speed and security" -- http://code.macournoyer.com/thin/

In case anyone is still wondering, parsing in Ruby/Python/Lua is pretty slow compared to C/C++. That's why I personally have been really interested for a long time in writing parsers in C that can be used from higher level languages. That way you can get the best of both worlds.

coderdude2• 10 years ago

It's the best of both worlds but doesn't shield you from the worst of one of the worlds. Untrusted input is still reaching code that has direct access to system memory. Hopefully not, anyway. But probably. Still, it's the way to go if performance is key.

haberman4• 10 years ago

Very true. Thankfully fuzzing tools are getting better all the time. LLVM's libfuzzer is great.

jgraham• 10 years ago

These days you would probably want to write the parser part in Rust, with a small amount of unsafe code to implement a C-compatible API that could then be called from Python, or wherever. I did this for some regexp-based log parsing code written in Python, and saw a considerable (2-3x) performance win. The main outstanding issue is that Rust isn't as easy to distribute as C to random end users (e.g. it likely requires the user to have rustc installed for |pip install| to work, which is unlikely and not always possible through standard package managers).

mangeletti• 10 years ago

This is also what inspired the uwsgi[1] protocol in the uWSGI project[2].

1. https://uwsgi-docs.readthedocs.io/en/latest/Protocol.html

2. https://uwsgi-docs.readthedocs.io/en/latest/

sigil• 10 years ago

Check out http-parser for Python: https://pypi.python.org/pypi/http-parser

This uses Dahl's original http_parser.c FSM. With a little work you can write a WSGI handler around it. Highly recommend.

cesarbs• 10 years ago

On a related note, we go through great lengths in the Kestrel HTTP server [0] (which also uses libuv) to have fast HTTP parsing. As an example, we attempt to read the method and the HTTP version as longs and compare them to pre-computed longs in order to have fast comparisons and reuse strings containing standard methods and versions (reducing memory allocation is the main driver of our optimizations) [1], so we don't have to allocate those strings on every request. We do a similar thing for headers [2]. We also manage a lot of our own memory, despite using a garbage collected language [3].

[0] https://github.com/aspnet/KestrelHttpServer

[1] https://github.com/aspnet/KestrelHttpServer/blob/3a424f6abac...

[2] https://github.com/aspnet/KestrelHttpServer/blob/dev/src/Mic...

[3] https://github.com/aspnet/KestrelHttpServer/blob/dev/src/Mic...

1st129• 10 years ago

Have you benchmarked it?

igravious2• 10 years ago

How much of a parsing stack can you build atop of Ragel? I gave Ragel a good look over recently when checking out parsers for Ruby because Ragel has a Ruby binding. I chose A Ruby PEG† library (Parslet) because I decided that there was too much of a gap between the low level finite automata machinery that Ragel provides and the parsing generation that I was looking for. Was I wrong to decide that, I wonder.

† On a related note, I'm finding it difficult finding (fast) GLR or GLL parser generators for Ruby

haberman4• 10 years ago

I think you're right: the gap between Ragel and what you want in higher-level languages is too wide to make a stack out of it IMO.

I'm working on what I consider a parsing stack. The key observation, in my opinion, is that you need a way of representing structured data in the high-level language that is both rich and efficient. I think Protocol Buffers can serve that role.

Once you have the structured data representation, you can write parsers to read/write it. But you want the parsers to be independent of how you represent the structured data in any one language.

MrBra• 10 years ago

Time to take a rest for JS? :)

pritambarhate• 10 years ago

It will be great to know how this compares to async frameworks in Java, Netty and Vert.x for example, in the benchmarks.

1st129• 10 years ago

Feel free to make a PR to https://github.com/MagicStack/vmbench!

distracteddev902• 10 years ago

The benchmarks for node.js are terribly misleading. The node.js implementations only ever spawn a single process, and thus node is only running on a single core and uses only a single thread.

Specifically, the http server example(1), doesn't even bother using the standard library provided Cluster module(2). Cluster is specifically designed for distributing server workloads across multiple cores.

All node.js services/applications I've worked on in the past 3 years (that are concerned with scale) utilize a multi-process node architecture.

The current benchmark can only claim that a single python process that spawns multiple threads is 2x faster than a single node.js process that spawns only one thread.

This fact may be interesting to some, but is irrelevant to real world performance.

[1] https://github.com/MagicStack/vmbench/blob/master/servers/no...

[2] https://nodejs.org/api/cluster.html

alexchamberlain3• 10 years ago

Do the other benchmarkside spawn multiple processes?

masklinn3• 10 years ago

No, even Go is explicitly configured to only use one scheduler:

We use Python 3.5, and all servers are single-threaded. Additionally, we use GOMAXPROCS=1 for Go code, nodejs does not use cluster, and all Python servers are single-process.

1st129• 10 years ago

There is nothing misleading about the benchmarks. It is explicitly said that ALL frameworks were benchmarked in single-process and single-thread modes.

Yes, in production you should run your nodejs app in cluster, your Python apps in a multiprocess configuration, and you should never use GOMAXPROCS=1 for your go apps in production!

Running all benchmarks in multiprocess configuration wouldn't add anything new to the results.

distracteddev902• 10 years ago

The main premise in my comment is that the benchmarks do not resemble real world performance, and are therefore misleading.

The comment above (https://news.ycombinator.com/item?id=11626762) further expands on why these kinds of benchmarks, although interesting, have no real value.

Each implementation does something wildly different and responds to different inputs with completely different outputs.

To put it metaphorically, if you put a car engine in two completely different chassis and then race them on a track, you aren't gaining any real insight into relative performance of the engine in the two vehicles.

Also, just to be clear, my qualms are with the benchmarks alone, I think the library is great! Thanks for all the hard work :)

mpeg• 10 years ago

It says that all the benchmarks are single-threaded and even mentions at the end that you could push performance further with multicore machines.

It doesn't matter anyway, with one thread per core it would be pretty straightforward to scale in beefier machines.

shuzchen2• 10 years ago

Since this is a benchmark of eventloop based frameworks, it makes sense to only spawn a single eventloop and test against that. I looked through the code for the python servers and they are all configured for a single event loop, making this a comparison on equal footing.

Yes it's true you normally run multiple node processes in production, but you likewise normally run multiple asyncio/tornado/twisted processes in production as well. I don't see it as a big deal, or misleading to compare them in this sense.

halayli2• 10 years ago

This isn't a fair comparison. the "HTTP server" presented isn't doing any checks / validation that a typical web server does.

Compare

https://github.com/MagicStack/vmbench/blob/master/servers/as...

https://github.com/nodejs/node/blob/master/lib/_http_outgoin...

https://github.com/nodejs/node/blob/master/lib/_http_server....

https://github.com/golang/go/blob/master/src/net/http/server...

The benchmark is almost equivalent to testing raw eventloop performance against a complete http server.

To make this test fair, you need to write the same code in asyncio_http_server.py in other languages.

felixweis2• 10 years ago

There is a TCP and a HTTP benchmark.

RedCrowbar• 10 years ago

This isn't a fair comparison. the "HTTP server" presented isn't doing any checks / validation that a typical web server does.

How so? It uses a binding to http-parser, just like nodejs.

halayli2• 10 years ago

Parsing is just a small part of an http server. You can check the links I posted to see how much work is involved in validating http headers (after parsing), and creating http responses.

1st129• 10 years ago

Keep in mind that the HTTP server in the benchmarks actually uses the httptools parser, which is a full-blown HTTP parser. A lot of heavy-lifting is done by the parser.

I plan to add a complete HTTP protocol implementation to httptools, but honestly, I don't expect it to be more than 20% slower.

messel• 10 years ago

Looks good. Wonder why these benchmarks never include an actual database. I'm using firebase with nodejs and no matter how many requests per second my server can respond with, it's ultimately constrained by data requests and memory (ie how many connections can I wait on).

When I see numbers like 50k requests per second it's meaningless, unless I have no database or some kind of in memory cache only db.

sametmax7• 10 years ago

It's not meaningless for new gen apps which trade a lot of db request for message passing. In micro-services app, when you update something, you propagate the change, and you have x client update for one db requests instead of having x + 1 db requests. In that context, broacasting quickly to a lot of clients is important.

noplay• 10 years ago

Does it mean that uvloop could allow the use of the same event loop implementation on the three major OS?

1st129• 10 years ago

asyncio already allows that.

uvloop, as of now, only runs on *nix; but I hope we'll have Windows supported soon too.

Uvloop: Fast Python networking

Related Stories