Hi,
This is a text excerpt from the article [1].
Below paragraph I didn't understand quite well.Mainly in bold letters.Could
anybody please explain how this will lead to an infinite loop.
Atomicity
All modern processors offer atomic instructions. These special instructions
are crucial for synchronizing two or more concurrent tasks. As the name
implies, atomic instructions must be *indivisible* -- that's why they're so
handy for synchronization: they can't be preempted.
It turns out that in order for atomic instructions to perform correctly, the
addresses you pass them must be at least four-byte aligned. This is because
of a subtle interaction between atomic instructions and virtual memory.
If an address is unaligned, it requires at least two memory accesses. But
what happens if the desired data spans two pages of virtual memory? This
could lead to a situation where the first page is resident while the last
page is not. Upon access, in the middle of the instruction, a page fault
would be generated, executing the virtual memory management swap-in code,
destroying the atomicity of the instruction. To keep things simple and
correct, both the 68K and PowerPC require that atomically manipulated
addresses always be at least four-byte aligned.
*Unfortunately, the PowerPC does not throw an exception when atomically
storing to an unaligned address. Instead, the store simply always fails.
This is bad because most atomic functions are written to retry upon a failed
store, under the assumption they were preempted. These two circumstances
combine to where your program will go into an infinite loop if you attempt
to atomically store to an unaligned address. Oops.*
[1] http://www.ibm.com/developerworks/library/pa-dalign/.
--
With Regards
Subin Gangadharan
Everything should be made as simple as possible,but not simpler.
___
Kernelnewbies mailing list
Kernelnewbies@kernelnewbies.org
http://lists.kernelnewbies.org/mailman/listinfo/kernelnewbies
