Memory ordering guarantees across .await points?

[ZhennanWu]

This issue is related to this StackOverflow question: https://stackoverflow.com/questions/70984928/rust-async-executor-memory-ordering-guarantees-when-moving-tasks-across-threads

In tokio, tasks can be moved across threads at .await point. However, C++ memory ordering only specifies memory ordering from a thread-based perspective. As a result, within an async function, there are no clear documentation clarifying memory ordering behavior across a .await point, since the thread could be different.

A more formal description of the StackOverflow question:

1. Suppose there are two consecutive full expressions A and B. According to definition, A is sequenced-before B.
2. Now within an async function, we insert an expression with a .await point, between A and B. Is the sequence-before relation still guaranteed?

I'm not familiar with tokio's internal scheduler. If anyone can describe what kind of synchronization operations they perform when they move/poll a task, that would help a lot.

C++ memory ordering spec: https://en.cppreference.com/w/cpp/atomic/memory_order

---

In fact, there is also another different but related question. What is the memory ordering at a .await point? Do all memory writes inside the awaited future become visible side-effects after the outside .await expression?

[Darksonn]

When the task is moved from one thread to another, there is a synchronizes-with relation between the things before and after the .await. Depending on the exact circumstances, the synchronization comes from a mutex or an atomic using acquire & release semantics.

The relation is not a sequenced-before relation because that relation only applies within a single thread.