Skip to content

Commit

Permalink
Make atomics interior Unsafe<T>
Browse files Browse the repository at this point in the history
  • Loading branch information
@flaper87
flaper87 committed Mar 20, 2014
1 parent 68a3ec0 commit 598fc75
Showing 1 changed file with 60 additions and 50 deletions.
110 changes: 60 additions & 50 deletions src/libstd/sync/atomics.rs
View file
Expand Up @@ -114,35 +114,36 @@ use cast;
use std::kinds::marker;
use option::{Option,Some,None};
use ops::Drop;
use ty::Unsafe;

/// An atomic boolean type.
pub struct AtomicBool {
priv v: uint,
priv v: Unsafe<uint>,
priv nopod: marker::NoPod
}

/// A signed atomic integer type, supporting basic atomic arithmetic operations
pub struct AtomicInt {
priv v: int,
priv v: Unsafe<int>,
priv nopod: marker::NoPod
}

/// An unsigned atomic integer type, supporting basic atomic arithmetic operations
pub struct AtomicUint {
priv v: uint,
priv v: Unsafe<uint>,
priv nopod: marker::NoPod
}

/// An unsigned atomic integer type that is forced to be 64-bits. This does not
/// support all operations.
pub struct AtomicU64 {
priv v: u64,
priv v: Unsafe<u64>,
priv nopod: marker::NoPod
}

/// An unsafe atomic pointer. Only supports basic atomic operations
pub struct AtomicPtr<T> {
priv p: uint,
priv p: Unsafe<uint>,
priv nopod: marker::NoPod
}

Expand All @@ -152,7 +153,7 @@ pub struct AtomicPtr<T> {
/// owned heap objects across tasks.
#[unsafe_no_drop_flag]
pub struct AtomicOption<T> {
priv p: uint,
priv p: Unsafe<uint>,
}

/// Atomic memory orderings
Expand Down Expand Up @@ -186,13 +187,21 @@ pub enum Ordering {
}

/// An `AtomicBool` initialized to `false`
pub static INIT_ATOMIC_BOOL : AtomicBool = AtomicBool { v: 0, nopod: marker::NoPod };
pub static INIT_ATOMIC_BOOL : AtomicBool = AtomicBool { v: Unsafe{value: 0,
marker1: marker::InvariantType},
nopod: marker::NoPod };
/// An `AtomicInt` initialized to `0`
pub static INIT_ATOMIC_INT : AtomicInt = AtomicInt { v: 0, nopod: marker::NoPod };
pub static INIT_ATOMIC_INT : AtomicInt = AtomicInt { v: Unsafe{value: 0,
marker1: marker::InvariantType},
nopod: marker::NoPod };
/// An `AtomicUint` initialized to `0`
pub static INIT_ATOMIC_UINT : AtomicUint = AtomicUint { v: 0, nopod: marker::NoPod };
pub static INIT_ATOMIC_UINT : AtomicUint = AtomicUint { v: Unsafe{value: 0,
marker1: marker::InvariantType},
nopod: marker::NoPod };
/// An `AtomicU64` initialized to `0`
pub static INIT_ATOMIC_U64 : AtomicU64 = AtomicU64 { v: 0, nopod: marker::NoPod };
pub static INIT_ATOMIC_U64 : AtomicU64 = AtomicU64 { v: Unsafe{value: 0,
marker1: marker::InvariantType},
nopod: marker::NoPod };


// NB: Needs to be -1 (0b11111111...) to make fetch_nand work correctly
Expand All @@ -201,29 +210,30 @@ static UINT_TRUE: uint = -1;
impl AtomicBool {
/// Create a new `AtomicBool`
pub fn new(v: bool) -> AtomicBool {
AtomicBool { v: if v { UINT_TRUE } else { 0 }, nopod: marker::NoPod }
let val = if v { UINT_TRUE } else { 0 };
AtomicBool { v: Unsafe::new(val), nopod: marker::NoPod }
}

/// Load the value
#[inline]
pub fn load(&self, order: Ordering) -> bool {
unsafe { atomic_load(&self.v, order) > 0 }
unsafe { atomic_load(&*self.v.get(), order) > 0 }
}

/// Store the value
#[inline]
pub fn store(&mut self, val: bool, order: Ordering) {
let val = if val { UINT_TRUE } else { 0 };

unsafe { atomic_store(&mut self.v, val, order); }
unsafe { atomic_store(&mut *self.v.get(), val, order); }
}

/// Store a value, returning the old value
#[inline]
pub fn swap(&mut self, val: bool, order: Ordering) -> bool {
let val = if val { UINT_TRUE } else { 0 };

unsafe { atomic_swap(&mut self.v, val, order) > 0 }
unsafe { atomic_swap(&mut *self.v.get(), val, order) > 0 }
}

/// If the current value is the same as expected, store a new value
Expand Down Expand Up @@ -276,7 +286,7 @@ impl AtomicBool {
let old = if old { UINT_TRUE } else { 0 };
let new = if new { UINT_TRUE } else { 0 };

unsafe { atomic_compare_and_swap(&mut self.v, old, new, order) > 0 }
unsafe { atomic_compare_and_swap(&mut *self.v.get(), old, new, order) > 0 }
}

/// A logical "and" operation
Expand Down Expand Up @@ -306,7 +316,7 @@ impl AtomicBool {
pub fn fetch_and(&mut self, val: bool, order: Ordering) -> bool {
let val = if val { UINT_TRUE } else { 0 };

unsafe { atomic_and(&mut self.v, val, order) > 0 }
unsafe { atomic_and(&mut *self.v.get(), val, order) > 0 }
}

/// A logical "nand" operation
Expand Down Expand Up @@ -337,7 +347,7 @@ impl AtomicBool {
pub fn fetch_nand(&mut self, val: bool, order: Ordering) -> bool {
let val = if val { UINT_TRUE } else { 0 };

unsafe { atomic_nand(&mut self.v, val, order) > 0 }
unsafe { atomic_nand(&mut *self.v.get(), val, order) > 0 }
}

/// A logical "or" operation
Expand Down Expand Up @@ -367,7 +377,7 @@ impl AtomicBool {
pub fn fetch_or(&mut self, val: bool, order: Ordering) -> bool {
let val = if val { UINT_TRUE } else { 0 };

unsafe { atomic_or(&mut self.v, val, order) > 0 }
unsafe { atomic_or(&mut *self.v.get(), val, order) > 0 }
}

/// A logical "xor" operation
Expand Down Expand Up @@ -397,32 +407,32 @@ impl AtomicBool {
pub fn fetch_xor(&mut self, val: bool, order: Ordering) -> bool {
let val = if val { UINT_TRUE } else { 0 };

unsafe { atomic_xor(&mut self.v, val, order) > 0 }
unsafe { atomic_xor(&mut *self.v.get(), val, order) > 0 }
}
}

impl AtomicInt {
/// Create a new `AtomicInt`
pub fn new(v: int) -> AtomicInt {
AtomicInt { v:v, nopod: marker::NoPod}
AtomicInt {v: Unsafe::new(v), nopod: marker::NoPod}
}

/// Load the value
#[inline]
pub fn load(&self, order: Ordering) -> int {
unsafe { atomic_load(&self.v, order) }
unsafe { atomic_load(&*self.v.get(), order) }
}

/// Store the value
#[inline]
pub fn store(&mut self, val: int, order: Ordering) {
unsafe { atomic_store(&mut self.v, val, order); }
unsafe { atomic_store(&mut *self.v.get(), val, order); }
}

/// Store a value, returning the old value
#[inline]
pub fn swap(&mut self, val: int, order: Ordering) -> int {
unsafe { atomic_swap(&mut self.v, val, order) }
unsafe { atomic_swap(&mut *self.v.get(), val, order) }
}

/// If the current value is the same as expected, store a new value
Expand All @@ -432,7 +442,7 @@ impl AtomicInt {
/// If the return value is equal to `old` then the value was updated.
#[inline]
pub fn compare_and_swap(&mut self, old: int, new: int, order: Ordering) -> int {
unsafe { atomic_compare_and_swap(&mut self.v, old, new, order) }
unsafe { atomic_compare_and_swap(&mut *self.v.get(), old, new, order) }
}

/// Add to the current value, returning the previous
Expand All @@ -448,7 +458,7 @@ impl AtomicInt {
/// ```
#[inline]
pub fn fetch_add(&mut self, val: int, order: Ordering) -> int {
unsafe { atomic_add(&mut self.v, val, order) }
unsafe { atomic_add(&mut *self.v.get(), val, order) }
}

/// Subtract from the current value, returning the previous
Expand All @@ -464,7 +474,7 @@ impl AtomicInt {
/// ```
#[inline]
pub fn fetch_sub(&mut self, val: int, order: Ordering) -> int {
unsafe { atomic_sub(&mut self.v, val, order) }
unsafe { atomic_sub(&mut *self.v.get(), val, order) }
}
}

Expand All @@ -474,62 +484,62 @@ impl AtomicInt {
#[cfg(not(target_arch = "mips"))]
impl AtomicU64 {
pub fn new(v: u64) -> AtomicU64 {
AtomicU64 { v:v, nopod: marker::NoPod }
AtomicU64 { v: Unsafe::new(v), nopod: marker::NoPod }
}

#[inline]
pub fn load(&self, order: Ordering) -> u64 {
unsafe { atomic_load(&self.v, order) }
unsafe { atomic_load(&*self.v.get(), order) }
}

#[inline]
pub fn store(&mut self, val: u64, order: Ordering) {
unsafe { atomic_store(&mut self.v, val, order); }
unsafe { atomic_store(&mut *self.v.get(), val, order); }
}

#[inline]
pub fn swap(&mut self, val: u64, order: Ordering) -> u64 {
unsafe { atomic_swap(&mut self.v, val, order) }
unsafe { atomic_swap(&mut *self.v.get(), val, order) }
}

#[inline]
pub fn compare_and_swap(&mut self, old: u64, new: u64, order: Ordering) -> u64 {
unsafe { atomic_compare_and_swap(&mut self.v, old, new, order) }
unsafe { atomic_compare_and_swap(&mut *self.v.get(), old, new, order) }
}

#[inline]
pub fn fetch_add(&mut self, val: u64, order: Ordering) -> u64 {
unsafe { atomic_add(&mut self.v, val, order) }
unsafe { atomic_add(&mut *self.v.get(), val, order) }
}

#[inline]
pub fn fetch_sub(&mut self, val: u64, order: Ordering) -> u64 {
unsafe { atomic_sub(&mut self.v, val, order) }
unsafe { atomic_sub(&mut *self.v.get(), val, order) }
}
}

impl AtomicUint {
/// Create a new `AtomicUint`
pub fn new(v: uint) -> AtomicUint {
AtomicUint { v:v, nopod: marker::NoPod }
AtomicUint { v: Unsafe::new(v), nopod: marker::NoPod }
}

/// Load the value
#[inline]
pub fn load(&self, order: Ordering) -> uint {
unsafe { atomic_load(&self.v, order) }
unsafe { atomic_load(&*self.v.get(), order) }
}

/// Store the value
#[inline]
pub fn store(&mut self, val: uint, order: Ordering) {
unsafe { atomic_store(&mut self.v, val, order); }
unsafe { atomic_store(&mut *self.v.get(), val, order); }
}

/// Store a value, returning the old value
#[inline]
pub fn swap(&mut self, val: uint, order: Ordering) -> uint {
unsafe { atomic_swap(&mut self.v, val, order) }
unsafe { atomic_swap(&mut *self.v.get(), val, order) }
}

/// If the current value is the same as expected, store a new value
Expand All @@ -539,7 +549,7 @@ impl AtomicUint {
/// If the return value is equal to `old` then the value was updated.
#[inline]
pub fn compare_and_swap(&mut self, old: uint, new: uint, order: Ordering) -> uint {
unsafe { atomic_compare_and_swap(&mut self.v, old, new, order) }
unsafe { atomic_compare_and_swap(&mut *self.v.get(), old, new, order) }
}

/// Add to the current value, returning the previous
Expand All @@ -555,7 +565,7 @@ impl AtomicUint {
/// ```
#[inline]
pub fn fetch_add(&mut self, val: uint, order: Ordering) -> uint {
unsafe { atomic_add(&mut self.v, val, order) }
unsafe { atomic_add(&mut *self.v.get(), val, order) }
}

/// Subtract from the current value, returning the previous
Expand All @@ -571,34 +581,34 @@ impl AtomicUint {
/// ```
#[inline]
pub fn fetch_sub(&mut self, val: uint, order: Ordering) -> uint {
unsafe { atomic_sub(&mut self.v, val, order) }
unsafe { atomic_sub(&mut *self.v.get(), val, order) }
}
}

impl<T> AtomicPtr<T> {
/// Create a new `AtomicPtr`
pub fn new(p: *mut T) -> AtomicPtr<T> {
AtomicPtr { p: p as uint, nopod: marker::NoPod }
AtomicPtr { p: Unsafe::new(p as uint), nopod: marker::NoPod }
}

/// Load the value
#[inline]
pub fn load(&self, order: Ordering) -> *mut T {
unsafe {
atomic_load(&self.p, order) as *mut T
atomic_load(&*self.p.get(), order) as *mut T
}
}

/// Store the value
#[inline]
pub fn store(&mut self, ptr: *mut T, order: Ordering) {
unsafe { atomic_store(&mut self.p, ptr as uint, order); }
unsafe { atomic_store(&mut *self.p.get(), ptr as uint, order); }
}

/// Store a value, returning the old value
#[inline]
pub fn swap(&mut self, ptr: *mut T, order: Ordering) -> *mut T {
unsafe { atomic_swap(&mut self.p, ptr as uint, order) as *mut T }
unsafe { atomic_swap(&mut *self.p.get(), ptr as uint, order) as *mut T }
}

/// If the current value is the same as expected, store a new value
Expand All @@ -609,7 +619,7 @@ impl<T> AtomicPtr<T> {
#[inline]
pub 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 as uint,
atomic_compare_and_swap(&mut *self.p.get(), old as uint,
new as uint, order) as *mut T
}
}
Expand All @@ -618,19 +628,19 @@ impl<T> AtomicPtr<T> {
impl<T> AtomicOption<T> {
/// Create a new `AtomicOption`
pub fn new(p: ~T) -> AtomicOption<T> {
unsafe { AtomicOption { p: cast::transmute(p) } }
unsafe { AtomicOption { p: Unsafe::new(cast::transmute(p)) } }
}

/// Create a new `AtomicOption` that doesn't contain a value
pub fn empty() -> AtomicOption<T> { AtomicOption { p: 0 } }
pub fn empty() -> AtomicOption<T> { AtomicOption { p: Unsafe::new(0) } }

/// Store a value, returning the old value
#[inline]
pub 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 p = atomic_swap(&mut *self.p.get(), val, order);
if p as uint == 0 {
None
} else {
Expand All @@ -655,7 +665,7 @@ impl<T> AtomicOption<T> {
unsafe {
let val = cast::transmute(val);
let expected = cast::transmute(0);
let oldval = atomic_compare_and_swap(&mut self.p, expected, val, order);
let oldval = atomic_compare_and_swap(&mut *self.p.get(), expected, val, order);
if oldval == expected {
None
} else {
Expand All @@ -670,7 +680,7 @@ impl<T> AtomicOption<T> {
/// result does not get invalidated by another task after this returns.
#[inline]
pub fn is_empty(&mut self, order: Ordering) -> bool {
unsafe { atomic_load(&self.p, order) as uint == 0 }
unsafe { atomic_load(&*self.p.get(), order) as uint == 0 }
}
}

Expand Down

0 comments on commit 598fc75

Please sign in to comment.