rust/src/libstd/unstable/atomics.rs

394 lines
9.7 KiB
Rust
Raw Normal View History

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));
}
}