Hi all!
I was trying to reproduce some examples from the paper [1] (see Example 1 on page 2) and the paper [2] (example in section 2.2 on page 2). These examples try to justify races on non-atomic variables being UB.
In essence, both examples utilize potential ability of the compiler to remateralize load from shared variable. In the presence of the racy write, remateralized load can observe different value thus leading to unexpected program outcome.
I was trying to reproduce this behavior with the following example:
Simplifying it a bit, it looks as follows.
int a;
void* reader_thread(void* p) {
int t = a;
for (int i = 0; i < DUMP_N; ++i) {
// some code to induce pressure on register allocator
...
// can the compiler remateralize this load and read from a again?
dump[i] = t;
}
// print dump
...
return NULL;
}
void* writer_thread(void* p)
{
a = 42;
return NULL;
}
Based on the experiments with the compiler, I was able to reproduce one of the two scenarios.
(1) If there is not a lot of pressure on register allocator, then
the compiler loads from a to register and then promotes it on every use of t,
thus the stack slot for t is not allocated.
(2) If there is a lot of pressure on register allocator, then
stack slot for t is allocated, the load from a stores to this stack slot
and all subsequent uses of t load from this stack slot.
Both of these scenarios do not lead to interference with the racy write.
I.e. the reader thread either reads initial value 0, or the value 42 written by writer_thread.
My question is as follows: is the LLVM compiler even capable to remateralize loads from shared memory? On what conditions in general the compiler can spill and remateralize register without allocation of a stack slot?
Do you think the compiler should perform such an optimization (given how it can interfere with race writes, as the examples mentioned above demonstrate).
And, somewhat more general question, what other optimizations (besides register remateralization) you think can be problematic in the presence of races (and can actually be reproduced with the current compiler implementation)?
References:
[1] Dolan, S., Sivaramakrishnan, K. C., & Madhavapeddy, A. (2018). Bounding data races in space and time. ACM SIGPLAN Notices, 53(4), 242-255.
[2] Boehm, H. J. (2011, May). How to Miscompile Programs with Benign Data Races. In HotPar (pp. 3-3).
