The Long Road To Asynchrony

LONG ROAD
ANDREW GODWIN // @andrewgodwin
ASYNCHRONY
TO
THE

View Slide

Andrew Godwin / @andrewgodwin
Hi, I’m
Andrew Godwin
• Django core developer
• Worked on Migrations, Channels & Async
• Once a Londoner, now from Denver, USA

View Slide


View Slide

"Asynchronous Programming"
What is it, really?

View Slide

Concurrent Programming
The more general term

View Slide

Input
Process
Output
Sequential execution

View Slide

Input
Process
Output
Process
Concurrent execution
Archive

View Slide

Shared use of a single resource
In this case, CPUs

View Slide

"Communicating Sequential Processes", C. A. R Hoare

View Slide

func main() {
messages := make(chan string)
go func() { messages <- "ping" }()
msg := <-messages
fmt.Println(msg)
}

View Slide

Multiple processes
multiprocessing
Threads
threading
Event loops
asyncio / twisted

View Slide

Multiple processes scale best
It's also diﬃcult and costs the most!

View Slide

Threads are unpredictable
Also, the GIL is our ever-present friend

View Slide

Event loops are a good compromise
They do require shared memory, though.

View Slide

Asynchronous ≈ Event loops
Most of the time!

View Slide

# Ready when a timer finishes
await asyncio.sleep(1)
# Ready when network packets return
await client.get("http://example.com")
# Ready when the coroutine exits
await my_function("hello", 64.2)

View Slide

Network/timer updates
An event loop's ﬂow
Select a ready task
Run task
Add new tasks to queue
await

View Slide

Coroutines
Time →

View Slide

How did we get here?

View Slide

1998 threading module, Stackless Python
2002 Twisted
2006 Greenlets (later gevent, eventlet)
2008 multiprocessing module
2012 Tulip, PEP 3156
2014 asyncio module
2005 Coroutine-friendly generators (PEP 342)

View Slide

2017 Django Channels 1.0
2018 Django Channels 2.0
2019 DEP 9 (Async support)
2020 Async views land in Django

View Slide

No solution is perfect
Everyone chooses different tradeoffs

View Slide

Asyncio is based on yield from
Because it was prototyped in Python 2

View Slide

Can't tell if a function returns a coroutine!
There are standard hints, but no actual guaranteed way

View Slide

async def calculate(x):
result = await coroutine(x)
return result
# These both return a coroutine
def calculate(x):
result = coroutine(x)
return result

View Slide

Can't have one function service both
How we got here makes sense, but it's still annoying sometimes.

View Slide

# Calls get.__call__
instance = MyModel.objects.get(id=3)
# Calls get.__call__
# and then awaits its result
instance = await MyModel.objects.get(id=3)

View Slide

You have to namespace async functions
I really, really wish we didn't have to

View Slide

instance = MyModel.objects.get(id=3)
instance = await MyModel.objects.async.get(id=3)

View Slide

Completely different libraries!
Even sleep() is different.

View Slide

time.sleep ➞ asyncio.sleep
requests ➞ httpx
psycopg2 ➞ aiopg
WSGI ➞ ASGI
Django ➞ Django?

View Slide

Django & Async

View Slide

Asyncio only benefits IO-bound code
Code that thrashes the CPU doesn't beneﬁt at all

View Slide

We're adding async to some parts
The bits where it makes sense!

View Slide

But, you can't mix sync and async
So we have to have two parallel request paths

View Slide

WSGIHandler
__call__
WSGI Server
WSGIRequest
BaseHandler
get_response
URLs Middleware
View
__call__
HTTP protocol
Socket handling
Transfer encodings
Headers-to-META
Upload file wrapping
GET/POST parsing
Exception catching
Atomic view wrapper
Django 3.0 Request Flow

View Slide

WSGIHandler
__call__
WSGI Server
WSGIRequest
BaseHandler
get_response
URLs Middleware
Async View
__call__
ASGIHandler
__call__
ASGI Server
ASGIRequest
Sync View
__call__
Asynchronous
request path
Proposed async request ﬂow

View Slide

WSGIHandler
__call__
WSGI Server
WSGIRequest URLs Middleware
View
__call__
ASGIHandler
__call__
ASGI Server
ASGIRequest
Asynchronous
request path
BaseHandler
get_response_async
BaseHandler
get_response
URLs Middleware
Async View
__call__
Implemented async request ﬂow

View Slide

We have to work with what we have
I'd rather let people ship code than argue about perfection.

View Slide

Django's main job is safety
It matters more than anything else

View Slide

Deadlocks
Livelocks
Starvation
Race conditions

View Slide

Coroutines & the GIL actually help!
You're saved from all the awful memory corruption bugs

View Slide

async def transfer_money(p1, p2):
await get_lock()
# Code between awaits is atomic!
subtract_money(p1)
add_money(p2)
await release_lock()

View Slide

You can still screw up a lot
Trust me, I have lived it while developing async

View Slide

async def log_message(m):
await client.post("log-server", m)
result = calculate_result()
log_message(m)

View Slide

async def log_message(m):
await client.post("log-server", m)
result = calculate_result()
await log_message(m)

View Slide

Async usability has a long way to go
But it is undoubtedly the future!

View Slide

Python is the language of pragmatism
If anyone can get it right, we can

View Slide

What does the future hold?
Hopefully, no GIL!

View Slide

Let's make async understandable
Almost every project could beneﬁt, if we made it worth their time.

View Slide

Thanks.
Andrew Godwin
@andrewgodwin // aeracode.org

View Slide

The Long Road To Asynchrony

The Long Road To Asynchrony

Andrew Godwin

More Decks by Andrew Godwin

Other Decks in Programming

Featured

Transcript