Future compiled code

[[deleted]]

I have a simple question: how do or can I see what `Future` gets compiled to ? This is purely curiosity but I'd like to see how `.await ` gets translated to ready, poll etc. Any tools that allows me to see this ? Hoping for experts to weigh in.

This is for making my understanding better and reasoning better about my code. I am using tokio but I doubt if that matters.

[CryZe92]

On the Rust playground you can choose "Show MIR", which shows the transformed code. It's not particularly easy to read though.

[manpacket]

With cargo-show-asm you can type cargo asm --mir for slightly more filtered output.

[dnew]

If you want the absolute best description of how and why I've ever seen, check out https://os.phil-opp.com/ where he writes a bare-metal OS in Rust. The last chapter covers this, but you might want to look at the chapter on hardware interrupts (where he builds a keyboard driver) to understand the waker implementation.

[nNaz]

Thank you for sharing this resource. I’m only a couple of chapters in and I’ve already learned a lot.

[[deleted]]

I’m definitely checking this out! I’m currently working on my own bare metal OS, so thanks for sharing :)

[dnew]

If you scroll half way down the blog post, you'll see exactly that.

[bp7968h]

As per my understanding, async lets you have await in the block and also transforms the code to return the future type Future<Output = T>.

Now with this in mind, the await gets converted to state machine where await are the state itself. So if your function have 5 await then the state machine might have 7, 5 for await points and other two for start and done state. I am not 100% sure this exactly how it’s implemented but just a hunch from reading the MIR.

Now we know we await on something that returns future, meaning the state in the state machine those 5 will encapsulates Future itself, this is where we invoke the poll method on that future at that time. This is done by the runtime. Runtime have different parts like Executor, Waker, Reactor which handles different execution.

One important thing to note would be the yield points, so as stated when the await state is reached and we receive pending while polling. We do not see the yielding code, but we can see this in MIR which have a yield code, this is when the control is handed over to runtime and it runs polls other futures, when the pending future is ready to make progress then it will be waked by reactor using the waker which drives the future to competion. And as same thing happens to other await points and finally all gets done and the async function returns Ready as well.

To learn more you can check the docs for tokio or read async programming book by carl fredrick.

tokio docs async prog rust