Background
I've been reading through various books and articles to learn about processor caches, cache consistency, and memory barriers in the context of concurrent execution. So far though, I have been unable to determine whether a common coding practice of mine is safe in the strictest sense.
Assumptions
The following pseudo-code is executed on a two-processor machine:
int sharedVar = 0;
myThread()
{
print(sharedVar);
}
main()
{
sharedVar = 1;
spawnThread(myThread);
sleep(-1);
}
main() executes on processor 1 (P1), while myThread() executes on P2.
Initially, sharedVar exists in the caches of both P1 and P2 with the initial value of 0 (due to some "warm-up code" that isn't shown above.)
Question
Strictly speaking – preferably without assuming any particular CPU – is myThread() guaranteed to print 1?
With my newfound knowledge of processor caches, it seems entirely possible that at the time of the print() statement, P2 may not have received the invalidation request for sharedVar caused by P1's assignment in main(). Therefore, it seems possible that myThread() could print 0.
References
These are the related articles and books I've been reading. (It wouldn't allow me to format these as links because I'm a new user - sorry.)
Shared Memory Consistency Models: A Tutorial
hpl.hp.com/techreports/Compaq-DEC/WRL-95-7.pdf
Memory Barriers: a Hardware View for Software Hackers
rdrop.com/users/paulmck/scalability/paper/whymb.2009.04.05a.pdf
Linux Kernel Memory Barriers
kernel.org/doc/Documentation/memory-barriers.txt
Computer Architecture: A Quantitative Approach
amazon.com/Computer-Architecture-Quantitative-Approach-4th/dp/0123704901/ref=dp_ob_title_bk
