PyconKR 2018 Deep dive into Coroutine

Deep Dive into
Coroutine
김대희

Environment
- OS : macOS High Sierra (10.13.6)
- Version : CPython 3.6.5

# coroutine.py
import asyncio
async def coroutine1():
print(“coro1 first entry point”)
await asyncio.sleep(1)
print(“coro1 second entry point”)
loop = asyncio.get_event_loop()
loop.create_task(coroutine1())
loop.run_forever()

# coroutine.py
import asyncio
loop.run_forever()
$ python coroutine.py
coro1 first entry point
coro1 second entry point
coro2 second entry point→ →
→ →
→ →
→ →

# coroutine.py
import asyncio
loop.run_forever()
$ python coroutine.py

# coroutine.py
import asyncio
loop.run_forever()
→ →
→ →
→ →
→ →
→ →
→ →
→ →
Resuming(Entry points)
- First lines of functions are
entry points.
- Lines after àwait` can be
resumed(entry points) if the
àwait` suspends.
→ →
Suspending
- àwait` means it may suspend
but not always.

In [1]:
In [2]:
In [3]:
...:
...:
...:
...:
...:
...:
In [4]:
In [5]:
import inspect
frame = None
def func():
global frame
x = 10
y = 20
print(x + y)
frame = inspect.currentframe()
func()
30
clear
Frame object
- Contains information for
executing a function.

In [6]: f_localsframe.
frame.f_locals frame.f_lasti
frame.f_back frame.f_code
frame.f_locals

f_locals
- Local variables are stored
In [6]: frame.f_locals
Out[6]: {‘x’: 10, ‘y’: 20}
In [7]:

Out[6]: {‘x’: 10, ‘y’: 20}
In [7]: f_backframe.
f_locals
frame.f_back frame.f_codeframe.f_back

f_locals
f_back
- Previous stack frame, this
frame’s caller
Out[6]: {‘x’: 10, ‘y’: 20}
In [7]: frame.f_back
Out[7]: <frame ...>
ThreadState
frame
Frame
f_back
Frame
f_back
Frame
f_back
→ Reference
→ Call

f_locals
f_back
frame’s caller
Out[6]: {‘x’: 10, ‘y’: 20}
Out[7]: <frame ...>
In [8]:
frame.f_back frame.f_code
frame.f_lasti
frame.f_lasti

f_locals
f_back
frame’s caller
Out[6]: {‘x’: 10, ‘y’: 20}
Out[7]: <frame ...>
In [8]: frame.f_lasti
Out[8]: 30
In [9]:

In [1]:
In [2]:
In [1]:
In [2]:
In [3]:
...:
...:
...:
...:
...:
...:
import inspect
frame = None
def func():
global frame
x = 10
y = 20
print(x + y)
frame = inspect.currentframe()
import dis
dis.dis(func)
2 0 LOAD_CONST 1 (10)
2 STORE_FAST 1 (x)
6 STORE_FAST 1 (y)
.
.
28 LOAD_CONST 0 (None)
30 RETURN_VALUE→ →

f_locals
f_back
frame’s caller
f_lasti
- Index of last attempted
instruction in bytecode.
Out[6]: {‘x’: 10, ‘y’: 20}
Out[7]: <frame ...>
Out[8]: 30
In [9]:

Out[6]: {‘x’: 10, ‘y’: 20}
Out[7]: <frame ...>
Out[8]: 30
In [9]:
frame.f_back frame.f_codeframe.f_code
f_locals
f_back
frame’s caller
f_lasti
instruction in bytecode.frame..f_code

Out[6]: {‘x’: 10, ‘y’: 20}
Out[7]: <frame ...>
Out[8]: 30
In [9]: frame.f_code
code.co_consts code.co_varnames
code.co_names code.co_code
f_locals
f_back
frame’s caller
f_lasti
instruction in bytecode.is func.__code__
Out[9]: True
In[10]: code = frame.f_code
In[11]: code.

In [1]: import dis
In [2]: from test import func
In [3]: dis.dis(func)
2 STORE_FAST 0 (x)
6 STORE_FAST 1 (y)
4 8 LOAD_GLOBAL 0 (print)
10 LOAD_FAST 0 (x)
12 LOAD_FAST 1 (y)
14 BINARY_ADD
16 CALL_FUNCION 1
18 POP_TOP
22 RETURN_VALUE
# test.py
def func():
x = 10
y = 20
print(x + y) Code Line Number
Bytecode index
Opcode
Operand
Operand value

In [1]: import dis
2 STORE_FAST 0 (x)
6 STORE_FAST 1 (y)
10 LOAD_FAST 0 (x)
12 LOAD_FAST 1 (y)
14 BINARY_ADD
16 CALL_FUNCION 1
18 POP_TOP
22 RETURN_VALUE
# test.py
def func():
x = 10
y = 20
print(x + y)
print(func.__code__.co_code)
>> b'dx01}x00dx02}x01tx00|x00|x01x17
x00x83x01x01x00dx00Sx00’
print(list(func.__code__.co_code))
>> [100, 1, 125, 0, 100, 2, 125, 1, 116, 0,
124, 0, 124, 1, 23, 0, 131, 1, 1, 0, 100, 0,
83, 0]
import opcode
print(opcode.opname[100])
>> ‘LOAD_CONST’

# test.py
def func():
x = 10
y = 20
print(x + y)
print(func.__code__.co_consts)
>> (None, 10, 20)
print(func.__code__.co_varnames)
>> ('x', 'y')
print(func.__code__.co_names)
>> ('print’,)
In [1]: import dis
2 STORE_FAST 0 (x)
6 STORE_FAST 1 (y)
10 LOAD_FAST 0 (x)
12 LOAD_FAST 1 (y)
14 BINARY_ADD
16 CALL_FUNCION 1
18 POP_TOP
22 RETURN_VALUE

# test.py
def func():
x = 10
y = 20
print(x + y)
Value stack
code.co_names
0 print
frame.f_local
code.co_consts
0 None
1 10
2 20
code.co_varnames
0 x
1 y
Mutable
Immutable
In [1]: import dis
2 STORE_FAST 0 (x)
6 STORE_FAST 1 (y)
10 LOAD_FAST 0 (x)
12 LOAD_FAST 1 (y)
14 BINARY_ADD
16 CALL_FUNCION 1
18 POP_TOP
22 RETURN_VALUE

# test.py
def func():
x = 10
y = 20
print(x + y)
Value stack
10
frame.f_local
Mutable
Immutable
code.co_names
0 print
code.co_consts
0 None
1 10
2 20
code.co_varnames
0 x
1 y
In [1]: import dis
2 STORE_FAST 0 (x)
6 STORE_FAST 1 (y)
10 LOAD_FAST 0 (x)
12 LOAD_FAST 1 (y)
14 BINARY_ADD
16 CALL_FUNCION 1
18 POP_TOP
22 RETURN_VALUE

# test.py
def func():
x = 10
y = 20
print(x + y)
Value stack frame.f_local
x 10
Mutable
Immutable
code.co_names
0 print
code.co_consts
0 None
1 10
2 20
code.co_varnames
0 x
1 y
In [1]: import dis
2 STORE_FAST 0 (x)
6 STORE_FAST 1 (y)
10 LOAD_FAST 0 (x)
12 LOAD_FAST 1 (y)
14 BINARY_ADD
16 CALL_FUNCION 1
18 POP_TOP
22 RETURN_VALUE

# test.py
def func():
x = 10
y = 20
print(x + y)
Value stack
20
frame.f_local
x 10
Mutable
Immutable
code.co_names
0 print
code.co_consts
0 None
1 10
2 20
code.co_varnames
0 x
1 y
In [1]: import dis
2 STORE_FAST 0 (x)
6 STORE_FAST 1 (y)
10 LOAD_FAST 0 (x)
12 LOAD_FAST 1 (y)
14 BINARY_ADD
16 CALL_FUNCION 1
18 POP_TOP
22 RETURN_VALUE

# test.py
def func():
x = 10
y = 20
print(x + y)
Value stack
code.co_names
0 print
frame.f_local
x 10
y 20
code.co_consts
0 None
1 10
2 20
code.co_varnames
0 x
1 y
Mutable
Immutable
In [1]: import dis
2 STORE_FAST 0 (x)
6 STORE_FAST 1 (y)
10 LOAD_FAST 0 (x)
12 LOAD_FAST 1 (y)
14 BINARY_ADD
16 CALL_FUNCION 1
18 POP_TOP
22 RETURN_VALUE

# test.py
def func():
x = 10
y = 20
print(x + y)
Value stack
print
code.co_names
0 print
frame.f_local
x 10
y 20
code.co_consts
0 None
1 10
2 20
code.co_varnames
0 x
1 y
Mutable
Immutable
In [1]: import dis
2 STORE_FAST 0 (x)
6 STORE_FAST 1 (y)
10 LOAD_FAST 0 (x)
12 LOAD_FAST 1 (y)
14 BINARY_ADD
16 CALL_FUNCION 1
18 POP_TOP
22 RETURN_VALUE

# test.py
def func():
x = 10
y = 20
print(x + y)
Value stack
print
10
20
code.co_names
0 print
frame.f_local
x 10
y 20
code.co_consts
0 None
1 10
2 20
code.co_varnames
0 x
1 y
Mutable
Immutable
In [1]: import dis
2 STORE_FAST 0 (x)
6 STORE_FAST 1 (y)
10 LOAD_FAST 0 (x)
12 LOAD_FAST 1 (y)
14 BINARY_ADD
16 CALL_FUNCION 1
18 POP_TOP
22 RETURN_VALUE

# test.py
def func():
x = 10
y = 20
print(x + y)
Value stack
print
30
code.co_names
0 print
frame.f_local
x 10
y 20
code.co_consts
0 None
1 10
2 20
code.co_varnames
0 x
1 y
Mutable
Immutable
In [1]: import dis
2 STORE_FAST 0 (x)
6 STORE_FAST 1 (y)
10 LOAD_FAST 0 (x)
12 LOAD_FAST 1 (y)
14 BINARY_ADD
16 CALL_FUNCION 1
18 POP_TOP
22 RETURN_VALUE

# test.py
def func():
x = 10
y = 20
print(x + y)
Value stack
None
code.co_names
0 print
frame.f_local
x 10
y 20
code.co_consts
0 None
1 10
2 20
code.co_varnames
0 x
1 y
Mutable
Immutable
In [1]: import dis
2 STORE_FAST 0 (x)
6 STORE_FAST 1 (y)
10 LOAD_FAST 0 (x)
12 LOAD_FAST 1 (y)
14 BINARY_ADD
16 CALL_FUNCION 1
18 POP_TOP
22 RETURN_VALUE

f_locals
f_back
frame’s caller
f_lasti
instruction in bytecode.
f_code
- co_consts
- Constant values
- co_names
- Global variable names
- co_varnames
- Local variable names
- co_code
- Complied bytecode
Out[6]: {‘x’: 10, ‘y’: 20}
Out[7]: <frame ...>
Out[8]: 30
In [9]: frame.f_code is func.__code__
Out[9]: True
In[10]: code = frame.f_code
In[11]: code.
code.co_consts code.co_varnames
code.co_names code.co_code

In [1]: import dis
In [2]: dis.dis(coroutine1)
...
3 8 LOAD_GLOBAL 1 (asyncio)
10 LOAD_ATTR 2 (sleep)
12 LOAD_CONST 2 (1)
14 CALL_FUNCTION 1
16 GET_AWAITABLE
20 YIELD_FROM
22 POP_TOP
...
import asyncio

import asyncio
@asyncio.coroutine
def coroutine3():
yield from asyncio.sleep(1)
In [1]: import dis
In [2]: dis.dis(coroutine1)
...
3 8 LOAD_GLOBAL 1 (asyncio)
10 LOAD_ATTR 2 (sleep)
12 LOAD_CONST 2 (1)
14 CALL_FUNCTION 1
16 GET_YIELD_FROM_ITER
20 YIELD_FROM
22 POP_TOP
...

YIELD_FROM
- Delegating to a subgenerator
- Both coroutines use ‘YIELD_FROM’.

def generator():
recv = yield 1
return recv
gen = generator()
gen.send(None)
1
gen.send(2)
2
In [1]:
In [2]:
Out[2]:
In [3]:
StopIteration:

def generator():
recv = yield 1
return recv
2 YIELD_VALUE
4 STORE_FAST 0 (recv)
3 6 LOAD_FAST 0 (recv)
8 RETURN_VALUE
In [1]: gen = generator()
In [2]: gen.send(None)
Out[2]: 1
lasti = gen.gi_frame.f_lasti
lasti
2
code = gen.gi_code
code is gen.gi_frame.f_code
True
op = code[lasti]
import opcode
opcode.opname[op]
‘YIELD_VALUE’
In [3]:
In [4]:
Out[4]:
In [5]:
In [6]:
Out[6]:
In [7]:
In [8]:
In [9]:
Out[9]:

async def coroutine():
pass
In [1]: coro = coroutine()
In [2]: coro.cr_frame
Out[2]: <frame at ...>
In [3]: coro.cr_code
Out[3]: <code object coroutine at ...>

In [1]: gen = generator()
In [2]: gen.send(None)
Out[2]: 1
In [3]: gen.send(2)
StopIteration: 2
static PyObject *gen_send_ex(PyGenObject *gen,
PyObject *arg, int exc, int closing)
{
PyThreadState *tstate =
PyThreadState_GET();
PyFrameObject *f = gen->gi_frame;
PyObject *result;
result = arg ? arg : Py_None;
Py_INCREF(result);
*(f->f_stacktop++) = result;
f->f_back = tstate->frame;
result = PyEval_EvalFrameEx(f, exc);
Py_CLEAR(f->f_back);
...

PyEval_EvalFrameEx
- The code object associated
with the execution frame is
executed, interpreting
bytecode and executing calls
as needed.
PyObject *PyEval_EvalFrameEx(PyFrameObject *f,
int throwflag){
PyThreadState *tstate =
PyThreadState_GET();
tstate->frame = f;
main_loop:
for (;;) {
f->f_lasti = INSTR_OFFSET();
switch (opcode) {
case: LOAD_FAST {
...
}
case: LOAD_CONST {
...
}
}
tstate->frame = f->f_back;
...

Frame object
- Used on executing a function
- Contains information for executing a function
- Call stack
- Value stack
- Local variables
- Last attempted bytecode instruction
Coroutine
- Based on generator
- Contains a frame object like thread state
- The frame memorizes which index of bytecode is executed.
- The frame stores local variables.

Frame f_back
f_locals
f_lasti
f_code co_consts
co_varnames
co_names
co_code
value stack

Frame f_back
f_locals
f_lasti
f_code co_consts
co_varnames
co_names
co_code
value stack
Frame f_bac
f_loc
f_las
f_cod
value

Frame f_back
f_locals
f_lasti
ThreadState
frame
Coroutine
gi_frame(cr_frame)

Event Loop for non-preemptive multitasking

Get an event loop from this
thread.
Schedule ‘coroutine1’ to the
event loop as a task.
Run the event loop executing
scheduled tasks.
# coroutine.py
import asyncio
loop.run_forever()
loop.run_forever()

# coroutine.py
import asyncio
loop.run_forever()
Get an event loop from this
thread.
Run the event loop executing
scheduled tasks.

async def sleep(delay, result=None, *, loop=None):
if delay <= 0:
await __sleep0()
return result
if loop is None:
loop = events.get_event_loop()
future = loop.create_future()
h = loop.call_later(delay,
future.set_result,
future, result)
return await future
@types.coroutine
def __sleep0():
yield
# the code has been modified for your better understanding

class Future:
def __await__(self):
if not self.done():
yield self # This tells Task to wait for completion.
if not self.done():
raise RuntimeError("await wasn't used with future")
return self.result()
__iter__ = __await__ # make compatible with 'yield from’.

class Task(Future):
def _step(self):
try:
result = self.coro.send(None)
except StopIteration as exc:
self.set_result(exc.value)
except Exception as exc:
self.set_exception(exc)
else:
if result is None:
self._loop.call_soon(self._step)
elif isinstance(result, Future):
result.add_done_callback(self._step)

class Task(Future):
def __init__(self, coro, *, loop=None):
super().__init__(loop=loop)
self._coro = coro
self._loop.call_soon(self._step)
...

class Future:
def add_done_callback(self, fn):
self._callbacks.append(fn)
def set_result(self, result):
self._result = result
self._state = _FINISHED
self._schedule_callbacks()
def _schedule_callbacks(self):
callbacks = self._callbacks[:]
if not callbacks:
return
self._callbacks[:] = []
for callback in callbacks:
self._loop.call_soon(callback, self)

Event Loop
Task._step
if result is None
Scheduled by call_soon
Task
result = coroutine.send(None)

Event Loop
Task._step
if result is None
Task

Event Loop
Task._step
if result is None
Task
if result is Future
Future
Future.callbacksAdded by add_done_callback
Future.set_result

class Handle:
def __init__(self, callback, args, loop):
self._callback = callback
self._args = args
self._loop = loop
def _run(self):
self._callback(*self._args)
class TimerHandle(Handle):
def __init__(self, when, callback, args, loop):
super().__init__(callback, args, loop)
self._when = when
def __gt__(self, other):
return self._when > other._when
...

class CustomEventLoop(AbstractEventLoop):
def create_future(self):
return Future(loop=self)
def create_task(self, coro):
return Task(coro, loop=self)
def time(self):
return time.monotonic()
def get_debug(self):
pass
def _timer_handle_cancelled(self, handle):
pass

def __init__(self):
self._scheduled = []
self._ready = deque()
def call_soon(self, callback, *args):
handle = Handle(callback, args, self)
self._ready.append(handle)
return handle
def call_later(self, delay, callback, *args):
timer = self.call_at(self.time() + delay, callback, *args)
return timer
def call_at(self, when, callback, *args):
timer = TimerHandle(when, callback, args, self)
heappush(self._scheduled, timer)
return timer

def run_forever(self):
while True:
self._run_once()

def _run_once(self):
while self._scheduled and self._scheduled[0]._when <= self.time():
timer = heappop(self._scheduled)
self._ready.append(timer)
len_ready = len(self._ready)
for _ in range(len_ready):
handle = self._ready.popleft()
handle._run()
timeout = 0
if self._scheduled and not self._ready:
timeout = max(0, self._scheduled[0]._when - self.time())
time.sleep(timeout)

timeout = 0
time.sleep(timeout)
Spinning if ‘timeout’ is zero
Freezing if ‘timeout’ is like infinity

Selector
 SelectSelector
 PollSelector
 EpollSelector
 KqueueSelector
 DevpollSelector
DefaultSelector
– An alias to the most efficient implementation available on the current platform

# main thread
import selectors
import socket
ssocket, csocket = socket.socketpair()
ssocket.setblocking(False)
csocket.setblocking(False)
selector = selectors.DefaultSelector()
selector.register(ssocket.fileno(), selectors.EVENT_READ)
selector.select(timeout=None) # waiting
ssocket.recv(1) # b’0’
# other threads
csocket.send(b’0’)

def __init__(self):
self._scheduled = []
self._ready = deque()
self._selector = selectors.DefaultSelector()
self._ssocket, self._csocket = socket.socketpair()
self._ssocket.setblocking(False)
self._csocket.setblocking(False)
self._selector.register(self._ssocket.fileno(), selectors.EVENT_READ)
def call_soon_threadsafe(self, callback, *args):
handle = self.call_soon(callback, *args)
self._csocket.send(b'0')
return handle

timeout = None
if self._ready:
timeout = 0
elif self._scheduled:
events = self._selector.select(timeout)
if events:
self._ssocket.recv(1)
timeout = 0
timeout = max(0, self.time() - self._scheduled[0]._when)
time.sleep(timeout)

PyconKR 2018 Deep dive into Coroutine

Recommended

Recommended

More Related Content

What's hot

What's hot (16)

Similar to PyconKR 2018 Deep dive into Coroutine

Similar to PyconKR 2018 Deep dive into Coroutine (20)

Recently uploaded

Recently uploaded (20)

PyconKR 2018 Deep dive into Coroutine