Monday Jul 28, 2008

Atomic operations

Solaris 10 provides atomic operations in libc. Atomic operations are sequences of instructions that behave as if they are a single atomic instruction that no other thread can interrupt. The way that the operations are implemented uses the compare-and-swap instruction (cas). A rough outline is as follows:

do
{
  Load existing value
  New value = existing value + increment
  return value = compare and swap(existing value and new value)
}
while (return value != existing value)

The compare-and-swap instruction atomically swaps the value in a register with the value held in memory, but only if the value held in memory equals the value held in another register. The return value is the value held in memory. The pseudo-code uses this so that the value stored back to memory will only be the incremented value if the current value in memory is equal to the value before the increment. If the value held in memory is not the one that was expected, the code retries the operation until it does succeed.

Breaking the compare-and-swap instruction into pseudo code looks like:

  CAS (Value held in memory, Old value, New value)
  {
    Existing value = \*Value held in memory;
    if (Existing value == Old value)
    {
       \*Value held in memory = New value;
       return Old value;
    }
    else
    {
       return \*Value held in memory;
    }
  }

One of the questions from last week was how to use atomic operations in Solaris 9 if they are only available on Solaris 10. The answer is to write your own. The following code snippet demonstrates how to write an atomic increment operation:

.inline atomic_add,8
  ld [%o0],%o2         /\* Load existing value            \*/
1:
  add %o2, %o1, %o3    /\* Generate new value             \*/
  cas [%o0],%o2,%o3    /\* Swap memory contents           \*/
  cmp %o2, %o3         /\* Compare old value with return  \*/
  bne 1b               /\* Fail if the old value does not \*/
                       /\* equal the value returned from  \*/
                       /\* memory                         \*/
  mov %o3,%o2          /\* Retry using latest value from  \*/
                       /\* memory                         \*/
.end

It's probably a good idea to read this article on atomic operations on SPARC, and it may also be useful to read up on inline templates.

Thursday Jan 11, 2007

Atomic operations in Solaris 10

Atomic operations are available in Solaris 10 through the header file (and libc). A short example is as follows.

% more atom.c
#include 

volatile unsigned int test;

void main()
{
  test=0;
  for (int i=0; i<10000; i++){atomic_add_int(&test,i);}
}
% cc -O atom.c
% a.out

Here's the disassembly for atomic_add_int from lib:

atomic_add_int()
	2dc18:    ld        	[%o0], %o2
	2dc1c:    add       	%o2, %o1, %o3  <---|
	2dc20:    cas       	[%o0] , %o2, %o3   |
	2dc24:    cmp       	%o2, %o3           |
	2dc28:    bne,a,pn  	%icc, 0x2dc1c  ----|
	2dc2c:    mov       	%o3, %o2       ----| [delay slot]
	2dc30:    retl      	
	2dc34:    add       	%o2, %o1, %o0

The idea of atomic functions is that they complete without anything else being able to change the variable during the operation - as if the operation were a single step. They are exteremely useful when data is shared between threads

The basic idea, as can be seen in the add code, is that the variable is loaded, the add is performed, the value stored back (using the atomic instruction 'cas' - compare and swap). Then the result is checked to see whether it worked or not. If it didn't work the operation is repeated.

The cas instruction performs the test that if the value held at [%o0] is equal to the value %o2, then replace it with the value %o3. %o3 returns the value that was in [%o0] when the operation was tried.

The instruction in the delay slot of the branch gets executed together with the branch instruction.

About

Darryl Gove is a senior engineer in the Solaris Studio team, working on optimising applications and benchmarks for current and future processors. He is also the author of the books:
Multicore Application Programming
Solaris Application Programming
The Developer's Edge

Search

Categories
Archives
« April 2014
SunMonTueWedThuFriSat
  
1
2
5
6
8
9
10
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   
       
Today
Bookmarks
The Developer's Edge
Solaris Application Programming
Publications
Webcasts
Presentations
OpenSPARC Book
Multicore Application Programming
Docs