They are the building blocks for lock free algorithms. Modern CPUs supports them. They are slower than the non-atomic ones, but much faster than using locks.
Let's use compare-and-swap as an example. It compares a variable with another, if they are equal, then swaps them. It's like the following function:
In our example, the cmpxchg instruction compares %3 with eax, if they are equal, it will set %3 to %1. Then what is %3? It is the 3rd (zero based) line after the assembler template (i.e. the double-quoted string), i.e. "r"(newvar). "r" means any register, and(newvar) means set it to newvar. In other words, the whole %3 means "grab any register and set it to newvar before doing the cmpxchg". Note that the you can put valid C expressions inside the bracket, such as (newval + 1).
Similarly, %1 is referring to "+m"(*ptr), which is a memory location pointed by *ptr. Good. We want cmpxchg to modify it directly. The"+a"(oldvar) line specifies oldvar to be loaded to the eax register, which also takes parts in the cmpxchg instruction.
Finally, cmpxchg will set the Z flag if the comparison is equal. We want to use it as our return value. In order to know the value of the Z flag, we use the sete instruction, which will set the value of its operant to zero if the Z flag is clear, and 1 if the Z flag is set. In our example, the operant of sete is %b0. Without the b letter, it is just %0, i.e. "=r"(result) or "grab any register and set its value to result afterwards". Therefore, the C variable result will be 1 if the *ptr equals to newval and 0 otherwise. But what about the b between %0? It tells the assembler to grab a register of 1 byte long. Use %w0 if you want a word size register instead.
Let's use compare-and-swap as an example. It compares a variable with another, if they are equal, then swaps them. It's like the following function:
int CompareAndSwap( int *ptr, int old, int new )
{
int r = *ptr ;
if ( *ptr == old )
*ptr = new ;
return r ;
}
The x86 archecture provides the cmpxchg instruction to perform this operation. The following assembly code provides an example on how to use it:unsigned char CompareAndSwap( int *ptr, int oldvar, int newvar )
{
unsigned char result;
__asm__ __volatile__ (
"lock; cmpxchg %3, %1\n"
"sete %b0\n"
: "=r"(result),
"+m"(*ptr),
"+a"(oldvar)
: "r"(newvar)
: "memory", "cc"
);
return result;
}
Well, these AT&T style assembly codes are hard to understand. Let's decrypt it. First, let's look at the cmpxchg instruction. It compares its
second operant against the eax register, if they are equal, set the second operant to the value of the first operant.In our example, the cmpxchg instruction compares %3 with eax, if they are equal, it will set %3 to %1. Then what is %3? It is the 3rd (zero based) line after the assembler template (i.e. the double-quoted string), i.e. "r"(newvar). "r" means any register, and(newvar) means set it to newvar. In other words, the whole %3 means "grab any register and set it to newvar before doing the cmpxchg". Note that the you can put valid C expressions inside the bracket, such as (newval + 1).
Similarly, %1 is referring to "+m"(*ptr), which is a memory location pointed by *ptr. Good. We want cmpxchg to modify it directly. The"+a"(oldvar) line specifies oldvar to be loaded to the eax register, which also takes parts in the cmpxchg instruction.
Finally, cmpxchg will set the Z flag if the comparison is equal. We want to use it as our return value. In order to know the value of the Z flag, we use the sete instruction, which will set the value of its operant to zero if the Z flag is clear, and 1 if the Z flag is set. In our example, the operant of sete is %b0. Without the b letter, it is just %0, i.e. "=r"(result) or "grab any register and set its value to result afterwards". Therefore, the C variable result will be 1 if the *ptr equals to newval and 0 otherwise. But what about the b between %0? It tells the assembler to grab a register of 1 byte long. Use %w0 if you want a word size register instead.