Are coroutines supported?

[aleGpereira]

Can memray be used for applications that uses asyncio? does it trace async/await functions properly?

[godlygeek]

Coroutines are supported, but the way they are reported may be surprising. Internally, the way that coroutines work is by yielding control back to an event loop when control is yielded from one coroutine to another, so in the implementation, coroutines are directly called by the event loop. The stacks that Memray shows for coroutines reflect that reality. Our flame graphs may not show which coroutine awaited another coroutine, and can instead show which runner ran each coroutine. This accurately reflects the reality of how coroutines get run, but the lack of context about why the runner is running a particular coroutine can make it hard to reason about the reports.

For instance, this flame graph:

Is the result of running this Python program:

import asyncio

xs = []

async def foo():
    return await bar()

async def bar():
    return await baz()

async def baz():
    await asyncio.sleep(0.1)
    xs.append("x" * 1024 * 1024)

async def main():
    print(await asyncio.gather(foo(), bar(), baz()))

asyncio.run(main())

We do show 3 different call stacks that all lead to baz being called, and all 3 are reported reasonably in our flame graph. But, all 3 of those are being awaited by asyncio.gather, and the frame for asyncio.gather does not itself appear in the flame graph.

[papb]

Hi @godlygeek! I have a few follow-up questions about this:

1. Does with memray.Tracker("some_output_file.bin"): work when I have an await something() inside the with block)?
2. Are there any plans on improving the way coroutine calls are reported into a less surprising output (maybe under an option)?

Note: for 1, you can assume no other Trackers are ever active (I've read in the API docs that only one Tracker can be active at a time).

[godlygeek]

Hi @papb!

1. Yes, that will work fine - tracking will start when the with block is entered, and stop when the with block is exited, just as you'd expect.
2. There are no plans to change the way that stacks are reported, no. I'm not sure what we could do differently. We're reporting the actual stack. The stack that we report is the same one that would be shown in a traceback printed by the interpreter itself, and the same one as you'd see from other profilers like cProfile. There's no way for the foo coroutine in my example above to know that the thing waiting for it to finish is the asyncio.gather call inside the main coroutine.

[papb]

Nice, thank you!

[aleGpereira]

Thank you so much for the detailed response!

[close2code-palm]

Also there is an interesting case with async execution, such as with asyncio.create_task(I have a lot of this), which effect it will make?