2013-05-25 00:51:26 -05:00
|
|
|
// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* Atomic types
|
2013-05-25 19:54:30 -05:00
|
|
|
*
|
|
|
|
* Basic atomic types supporting atomic operations. Each method takes an `Ordering` which
|
|
|
|
* represents the strength of the memory barrier for that operation. These orderings are the same
|
|
|
|
* as C++11 atomic orderings [http://gcc.gnu.org/wiki/Atomic/GCCMM/AtomicSync]
|
|
|
|
*
|
|
|
|
* All atomic types are a single word in size.
|
2013-05-25 00:51:26 -05:00
|
|
|
*/
|
|
|
|
|
|
|
|
use unstable::intrinsics;
|
|
|
|
use cast;
|
|
|
|
use option::{Option,Some,None};
|
2013-05-25 19:39:53 -05:00
|
|
|
use libc::c_void;
|
|
|
|
use ops::Drop;
|
2013-05-25 00:51:26 -05:00
|
|
|
|
2013-05-25 19:54:30 -05:00
|
|
|
/**
|
|
|
|
* A simple atomic flag, that can be set and cleared. The most basic atomic type.
|
|
|
|
*/
|
2013-05-25 00:51:26 -05:00
|
|
|
pub struct AtomicFlag {
|
2013-05-25 18:44:31 -05:00
|
|
|
priv v: int
|
2013-05-25 00:51:26 -05:00
|
|
|
}
|
|
|
|
|
2013-05-25 19:54:30 -05:00
|
|
|
/**
|
|
|
|
* An atomic boolean type.
|
|
|
|
*/
|
2013-05-25 00:51:26 -05:00
|
|
|
pub struct AtomicBool {
|
2013-05-25 18:44:31 -05:00
|
|
|
priv v: uint
|
2013-05-25 00:51:26 -05:00
|
|
|
}
|
|
|
|
|
2013-05-25 19:54:30 -05:00
|
|
|
/**
|
|
|
|
* A signed atomic integer type, supporting basic atomic aritmetic operations
|
|
|
|
*/
|
2013-05-25 00:51:26 -05:00
|
|
|
pub struct AtomicInt {
|
2013-05-25 18:44:31 -05:00
|
|
|
priv v: int
|
2013-05-25 00:51:26 -05:00
|
|
|
}
|
|
|
|
|
2013-05-25 19:54:30 -05:00
|
|
|
/**
|
|
|
|
* An unsigned atomic integer type, supporting basic atomic aritmetic operations
|
|
|
|
*/
|
2013-05-25 00:51:26 -05:00
|
|
|
pub struct AtomicUint {
|
2013-05-25 18:44:31 -05:00
|
|
|
priv v: uint
|
2013-05-25 00:51:26 -05:00
|
|
|
}
|
|
|
|
|
2013-05-25 19:54:30 -05:00
|
|
|
/**
|
|
|
|
* An unsafe atomic pointer. Only supports basic atomic operations
|
|
|
|
*/
|
2013-05-25 00:51:26 -05:00
|
|
|
pub struct AtomicPtr<T> {
|
2013-05-25 18:44:31 -05:00
|
|
|
priv p: *mut T
|
2013-05-25 00:51:26 -05:00
|
|
|
}
|
|
|
|
|
2013-05-25 19:54:30 -05:00
|
|
|
/**
|
|
|
|
* An owned atomic pointer. Ensures that only a single reference to the data is held at any time.
|
|
|
|
*/
|
2013-05-25 19:39:53 -05:00
|
|
|
pub struct AtomicOption<T> {
|
|
|
|
priv p: *mut c_void
|
|
|
|
}
|
|
|
|
|
2013-05-25 00:51:26 -05:00
|
|
|
pub enum Ordering {
|
|
|
|
Release,
|
|
|
|
Acquire,
|
|
|
|
SeqCst
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
impl AtomicFlag {
|
|
|
|
|
|
|
|
fn new() -> AtomicFlag {
|
|
|
|
AtomicFlag { v: 0 }
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Clears the atomic flag
|
|
|
|
*/
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn clear(&mut self, order: Ordering) {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe {atomic_store(&mut self.v, 0, order)}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the flag if it was previously unset, returns the previous value of the
|
|
|
|
* flag.
|
|
|
|
*/
|
2013-05-25 19:54:30 -05:00
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn test_and_set(&mut self, order: Ordering) -> bool {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe {atomic_compare_and_swap(&mut self.v, 0, 1, order) > 0}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl AtomicBool {
|
2013-05-25 19:39:53 -05:00
|
|
|
fn new(v: bool) -> AtomicBool {
|
2013-05-25 00:51:26 -05:00
|
|
|
AtomicBool { v: if v { 1 } else { 0 } }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn load(&self, order: Ordering) -> bool {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe { atomic_load(&self.v, order) > 0 }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn store(&mut self, val: bool, order: Ordering) {
|
2013-05-25 00:51:26 -05:00
|
|
|
let val = if val { 1 } else { 0 };
|
|
|
|
|
|
|
|
unsafe { atomic_store(&mut self.v, val, order); }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn swap(&mut self, val: bool, order: Ordering) -> bool {
|
2013-05-25 00:51:26 -05:00
|
|
|
let val = if val { 1 } else { 0 };
|
|
|
|
|
|
|
|
unsafe { atomic_swap(&mut self.v, val, order) > 0}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn compare_and_swap(&mut self, old: bool, new: bool, order: Ordering) -> bool {
|
2013-05-25 00:51:26 -05:00
|
|
|
let old = if old { 1 } else { 0 };
|
|
|
|
let new = if new { 1 } else { 0 };
|
|
|
|
|
|
|
|
unsafe { atomic_compare_and_swap(&mut self.v, old, new, order) > 0 }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl AtomicInt {
|
2013-05-25 19:39:53 -05:00
|
|
|
fn new(v: int) -> AtomicInt {
|
2013-05-25 00:51:26 -05:00
|
|
|
AtomicInt { v:v }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn load(&self, order: Ordering) -> int {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe { atomic_load(&self.v, order) }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn store(&mut self, val: int, order: Ordering) {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe { atomic_store(&mut self.v, val, order); }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn swap(&mut self, val: int, order: Ordering) -> int {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe { atomic_swap(&mut self.v, val, order) }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn compare_and_swap(&mut self, old: int, new: int, order: Ordering) -> int {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe { atomic_compare_and_swap(&mut self.v, old, new, order) }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn fetch_add(&mut self, val: int, order: Ordering) -> int {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe { atomic_add(&mut self.v, val, order) }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn fetch_sub(&mut self, val: int, order: Ordering) -> int {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe { atomic_sub(&mut self.v, val, order) }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl AtomicUint {
|
2013-05-25 19:39:53 -05:00
|
|
|
fn new(v: uint) -> AtomicUint {
|
2013-05-25 00:51:26 -05:00
|
|
|
AtomicUint { v:v }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn load(&self, order: Ordering) -> uint {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe { atomic_load(&self.v, order) }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn store(&mut self, val: uint, order: Ordering) {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe { atomic_store(&mut self.v, val, order); }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn swap(&mut self, val: uint, order: Ordering) -> uint {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe { atomic_swap(&mut self.v, val, order) }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn compare_and_swap(&mut self, old: uint, new: uint, order: Ordering) -> uint {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe { atomic_compare_and_swap(&mut self.v, old, new, order) }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn fetch_add(&mut self, val: uint, order: Ordering) -> uint {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe { atomic_add(&mut self.v, val, order) }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn fetch_sub(&mut self, val: uint, order: Ordering) -> uint {
|
2013-05-25 00:51:26 -05:00
|
|
|
unsafe { atomic_sub(&mut self.v, val, order) }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T> AtomicPtr<T> {
|
2013-05-25 19:39:53 -05:00
|
|
|
fn new(p: *mut T) -> AtomicPtr<T> {
|
2013-05-25 00:51:26 -05:00
|
|
|
AtomicPtr { p:p }
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn load(&self, order: Ordering) -> *mut T {
|
2013-05-25 18:44:31 -05:00
|
|
|
unsafe { atomic_load(&self.p, order) }
|
2013-05-25 00:51:26 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn store(&mut self, ptr: *mut T, order: Ordering) {
|
2013-05-25 18:44:31 -05:00
|
|
|
unsafe { atomic_store(&mut self.p, ptr, order); }
|
2013-05-25 00:51:26 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn swap(&mut self, ptr: *mut T, order: Ordering) -> *mut T {
|
2013-05-25 18:44:31 -05:00
|
|
|
unsafe { atomic_swap(&mut self.p, ptr, order) }
|
2013-05-25 00:51:26 -05:00
|
|
|
}
|
|
|
|
|
2013-05-25 18:44:31 -05:00
|
|
|
#[inline(always)]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn compare_and_swap(&mut self, old: *mut T, new: *mut T, order: Ordering) -> *mut T {
|
|
|
|
unsafe { atomic_compare_and_swap(&mut self.p, old, new, order) }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T> AtomicOption<T> {
|
|
|
|
fn new(p: ~T) -> AtomicOption<T> {
|
|
|
|
unsafe {
|
|
|
|
AtomicOption {
|
|
|
|
p: cast::transmute(p)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn empty() -> AtomicOption<T> {
|
|
|
|
unsafe {
|
|
|
|
AtomicOption {
|
|
|
|
p: cast::transmute(0)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn swap(&mut self, val: ~T, order: Ordering) -> Option<~T> {
|
|
|
|
unsafe {
|
|
|
|
let val = cast::transmute(val);
|
|
|
|
|
|
|
|
let p = atomic_swap(&mut self.p, val, order);
|
|
|
|
let pv : &uint = cast::transmute(&p);
|
|
|
|
|
|
|
|
if *pv == 0 {
|
|
|
|
None
|
|
|
|
} else {
|
|
|
|
Some(cast::transmute(p))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
fn take(&mut self, order: Ordering) -> Option<~T> {
|
|
|
|
unsafe {
|
|
|
|
self.swap(cast::transmute(0), order)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[unsafe_destructor]
|
|
|
|
impl<T> Drop for AtomicOption<T> {
|
|
|
|
fn finalize(&self) {
|
|
|
|
// This will ensure that the contained data is
|
|
|
|
// destroyed, unless it's null.
|
|
|
|
unsafe {
|
|
|
|
let this : &mut AtomicOption<T> = cast::transmute(self);
|
|
|
|
let _ = this.take(SeqCst);
|
|
|
|
}
|
2013-05-25 00:51:26 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
pub unsafe fn atomic_store<T>(dst: &mut T, val: T, order:Ordering) {
|
|
|
|
let dst = cast::transmute(dst);
|
|
|
|
let val = cast::transmute(val);
|
|
|
|
|
|
|
|
match order {
|
|
|
|
Release => intrinsics::atomic_store_rel(dst, val),
|
|
|
|
_ => intrinsics::atomic_store(dst, val)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
pub unsafe fn atomic_load<T>(dst: &T, order:Ordering) -> T {
|
|
|
|
let dst = cast::transmute(dst);
|
|
|
|
|
|
|
|
cast::transmute(match order {
|
|
|
|
Acquire => intrinsics::atomic_load_acq(dst),
|
|
|
|
_ => intrinsics::atomic_load(dst)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
pub unsafe fn atomic_swap<T>(dst: &mut T, val: T, order: Ordering) -> T {
|
|
|
|
let dst = cast::transmute(dst);
|
|
|
|
let val = cast::transmute(val);
|
|
|
|
|
|
|
|
cast::transmute(match order {
|
|
|
|
Acquire => intrinsics::atomic_xchg_acq(dst, val),
|
|
|
|
Release => intrinsics::atomic_xchg_rel(dst, val),
|
|
|
|
_ => intrinsics::atomic_xchg(dst, val)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
pub unsafe fn atomic_add<T>(dst: &mut T, val: T, order: Ordering) -> T {
|
|
|
|
let dst = cast::transmute(dst);
|
|
|
|
let val = cast::transmute(val);
|
|
|
|
|
|
|
|
cast::transmute(match order {
|
|
|
|
Acquire => intrinsics::atomic_xadd_acq(dst, val),
|
|
|
|
Release => intrinsics::atomic_xadd_rel(dst, val),
|
|
|
|
_ => intrinsics::atomic_xadd(dst, val)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
pub unsafe fn atomic_sub<T>(dst: &mut T, val: T, order: Ordering) -> T {
|
|
|
|
let dst = cast::transmute(dst);
|
|
|
|
let val = cast::transmute(val);
|
|
|
|
|
|
|
|
cast::transmute(match order {
|
|
|
|
Acquire => intrinsics::atomic_xsub_acq(dst, val),
|
|
|
|
Release => intrinsics::atomic_xsub_rel(dst, val),
|
|
|
|
_ => intrinsics::atomic_xsub(dst, val)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
#[inline(always)]
|
|
|
|
pub unsafe fn atomic_compare_and_swap<T>(dst:&mut T, old:T, new:T, order: Ordering) -> T {
|
|
|
|
let dst = cast::transmute(dst);
|
|
|
|
let old = cast::transmute(old);
|
|
|
|
let new = cast::transmute(new);
|
|
|
|
|
|
|
|
cast::transmute(match order {
|
|
|
|
Acquire => intrinsics::atomic_cxchg_acq(dst, old, new),
|
|
|
|
Release => intrinsics::atomic_cxchg_rel(dst, old, new),
|
|
|
|
_ => intrinsics::atomic_cxchg(dst, old, new),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod test {
|
|
|
|
use option::*;
|
|
|
|
use super::*;
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn flag() {
|
|
|
|
let mut flg = AtomicFlag::new();
|
|
|
|
assert!(!flg.test_and_set(SeqCst));
|
|
|
|
assert!(flg.test_and_set(SeqCst));
|
|
|
|
|
|
|
|
flg.clear(SeqCst);
|
|
|
|
assert!(!flg.test_and_set(SeqCst));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn option_swap() {
|
|
|
|
let mut p = AtomicOption::new(~1);
|
2013-05-25 00:51:26 -05:00
|
|
|
let a = ~2;
|
|
|
|
|
|
|
|
let b = p.swap(a, SeqCst);
|
|
|
|
|
|
|
|
assert_eq!(b, Some(~1));
|
|
|
|
assert_eq!(p.take(SeqCst), Some(~2));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2013-05-25 19:39:53 -05:00
|
|
|
fn option_take() {
|
|
|
|
let mut p = AtomicOption::new(~1);
|
2013-05-25 00:51:26 -05:00
|
|
|
|
|
|
|
assert_eq!(p.take(SeqCst), Some(~1));
|
|
|
|
assert_eq!(p.take(SeqCst), None);
|
|
|
|
|
|
|
|
let p2 = ~2;
|
2013-05-25 19:39:53 -05:00
|
|
|
p.swap(p2, SeqCst);
|
2013-05-25 00:51:26 -05:00
|
|
|
|
|
|
|
assert_eq!(p.take(SeqCst), Some(~2));
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|