Description
The Rustonomicon defines a data race like so:
- two or more threads concurrently accessing a location of memory
- one of them is a write
- one of them is unsynchronized
AIUI, all data races are automatically UB.
However, there is useful behaviour whose obvious implementation is forbidden in Rust with this definition. One example of this is with an atomic write, but an unsynchronised read:
- thread 1: atomic write
- thread 2: non-atomic read
(assuming thread 2 doesn't care whether it observes the changes from thread 1, or even if it observes partial changes)
For most cases, you can work around this by just doing a relaxed atomic read instead. The data race goes away and you just have to worry about normal race conditions. As a bonus, you avoid seeing partial results.
However, if you want to do a SIMD or other "wide" read then it becomes impossible in Rust. You would have to use assembly to avoid introducing UB.
My question is: if one wanted to want to support this in Rust, what would be a valid way to do it? Is this even OK to do at the assembly level? We can't introduce atomic versions of SIMD types, because SIMD is inherently not atomic. Would there need to be "volatile" versions of all SIMD operations whose only difference is that they don't introduce UB?