docs/pdds/pdd??_atomic.pod - Atomic operations
This document defines a portable interface for accessing atomic operations from parrot backend code.
$Revision: 14928 $
Most architectures support atomic updates (read-and-write) to a memory location which do not require the overhead of ordinary locking, even on SMP systems. This document describes an interface for performing a set of such operations on pointers and integers (of some unspecified width which is at least 16 bits). All accesses below are guaranteed to be atomic with respect to each other.
All of the below will be defined by parrot/atomic.h with implementations in parrot/atomic/TYPE.h and, should it be necessary to implement these outside of macros, atomic/TYPE.c.
parrot/atomic.h
parrot/atomic/TYPE.h
atomic/TYPE.c
Holds a void * value. Must be accessed through macros only.
Holds an integer which is at least 16 bits wide. Must be accessed through macros only.
Initialize a Parrot_atomic_pointer. Must be called before any other use and cannot be used again on the value until PARROT_ATOMIC_PTR_DESTROY() is called. Does not guarantee that PARROT_ATOMIC_PTR_GET(a_ptr) will return any particular value.
Destroy any resources associated with a Parrot_atomic_pointer.
Stores the pointer in a_ptr into result.
a_ptr
result
Sets the value store in a Parrot_atomic_pointer to new_value.
``Compare-and-swap''. If the value in a_ptr was old_value, set it to new_value and assign true to result; otherwise assign false to result. (The result is not the return value of this macro so that it can be easily implemented without requiring a function call.)
Initialize a Parrot_atomic_integer. Must be called before any other use and cannot be used again on the same value until PARROT_ATOMIC_INT_DESTROY() is called. Does not guarantee that PARROT_ATOMIC_INT_GET(a_int) will return any particular value.
Stores the integer in a_int into result.
a_int
Stores new_value.
``Compare-and-swap''. Same as PARROT_ATOMIC_PTR_CAS but with integers.
Increment the integer atomically. Return the new value in result.
Decrement the integer atomically. Return the new value in result.
Expands to a true value if this implementation has a native implementation of the atomic operations. Expands to false if the atomic operations are defined in terms of threading primitives. If false, the atomic operations should not be used if the implementors have written an alternative. This will always be 1 when parrot is compiled without threading support in which case the atomic operations will not actually be atomic.
Defined (to a true value) only if the operation by that name is implemented.
On most systems with native atomic operation support, Parrot_atomic_pointer and Parrot_atomic_integer will be a struct containing a single integer or pointer and ATOMIC_*_INIT will do nothing. For the fallback implementation the atomic types will be implemented in terms of a Parrot_mutex. Platform-specific implementations should not make Parrot_atomic_pointer or Parrot_atomic_integer a typedef for an integer or pointer type to prevent programmers from accidentally violating encapsulation. =cut
__END__ Local Variables: fill-column:78 End: vim: wrap textwidth=78
To install SmartLink, copy and paste the appropriate command in to your terminal.
cpanm
cpanm SmartLink
CPAN shell
perl -MCPAN -e shell install SmartLink
For more information on module installation, please visit the detailed CPAN module installation guide.