diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 8c3c21a89023..ff942444a617 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -77,11 +77,12 @@ use core::atomic; use core::atomic::Ordering::{Relaxed, Release, Acquire, SeqCst}; use core::fmt; use core::cmp::Ordering; -use core::mem::{min_align_of, size_of}; +use core::mem::{min_align_of_val, size_of_val}; +use core::intrinsics::drop_in_place; use core::mem; use core::nonzero::NonZero; -use core::ops::Deref; -use core::ptr; +use core::ops::{Deref, CoerceUnsized}; +use core::marker::Unsize; use core::hash::{Hash, Hasher}; use heap::deallocate; @@ -118,15 +119,16 @@ use heap::deallocate; /// ``` #[unsafe_no_drop_flag] #[stable(feature = "rust1", since = "1.0.0")] -pub struct Arc { +pub struct Arc { // FIXME #12808: strange name to try to avoid interfering with // field accesses of the contained type via Deref _ptr: NonZero<*mut ArcInner>, } -unsafe impl Send for Arc { } -unsafe impl Sync for Arc { } +unsafe impl Send for Arc { } +unsafe impl Sync for Arc { } +impl, U: ?Sized> CoerceUnsized> for Arc {} /// A weak pointer to an `Arc`. /// @@ -135,30 +137,30 @@ unsafe impl Sync for Arc { } #[unsafe_no_drop_flag] #[unstable(feature = "alloc", reason = "Weak pointers may not belong in this module.")] -pub struct Weak { +pub struct Weak { // FIXME #12808: strange name to try to avoid interfering with // field accesses of the contained type via Deref _ptr: NonZero<*mut ArcInner>, } -unsafe impl Send for Weak { } -unsafe impl Sync for Weak { } +unsafe impl Send for Weak { } +unsafe impl Sync for Weak { } #[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for Weak { +impl fmt::Debug for Weak { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "(Weak)") } } -struct ArcInner { +struct ArcInner { strong: atomic::AtomicUsize, weak: atomic::AtomicUsize, data: T, } -unsafe impl Send for ArcInner {} -unsafe impl Sync for ArcInner {} +unsafe impl Send for ArcInner {} +unsafe impl Sync for ArcInner {} impl Arc { /// Constructs a new `Arc`. @@ -182,7 +184,9 @@ impl Arc { }; Arc { _ptr: unsafe { NonZero::new(mem::transmute(x)) } } } +} +impl Arc { /// Downgrades the `Arc` to a `Weak` reference. /// /// # Examples @@ -204,7 +208,7 @@ impl Arc { } } -impl Arc { +impl Arc { #[inline] fn inner(&self) -> &ArcInner { // This unsafety is ok because while this arc is alive we're guaranteed @@ -222,11 +226,11 @@ impl Arc { // Destroy the data at this time, even though we may not free the box // allocation itself (there may still be weak pointers lying around). - drop(ptr::read(&self.inner().data)); + drop_in_place(&mut (*ptr).data); if self.inner().weak.fetch_sub(1, Release) == 1 { atomic::fence(Acquire); - deallocate(ptr as *mut u8, size_of::>(), min_align_of::>()) + deallocate(ptr as *mut u8, size_of_val(&*ptr), min_align_of_val(&*ptr)) } } } @@ -234,12 +238,12 @@ impl Arc { /// Get the number of weak references to this value. #[inline] #[unstable(feature = "alloc")] -pub fn weak_count(this: &Arc) -> usize { this.inner().weak.load(SeqCst) - 1 } +pub fn weak_count(this: &Arc) -> usize { this.inner().weak.load(SeqCst) - 1 } /// Get the number of strong references to this value. #[inline] #[unstable(feature = "alloc")] -pub fn strong_count(this: &Arc) -> usize { this.inner().strong.load(SeqCst) } +pub fn strong_count(this: &Arc) -> usize { this.inner().strong.load(SeqCst) } /// Returns a mutable reference to the contained value if the `Arc` is unique. @@ -264,7 +268,7 @@ pub fn strong_count(this: &Arc) -> usize { this.inner().strong.load(SeqCst /// ``` #[inline] #[unstable(feature = "alloc")] -pub fn get_mut(this: &mut Arc) -> Option<&mut T> { +pub fn get_mut(this: &mut Arc) -> Option<&mut T> { if strong_count(this) == 1 && weak_count(this) == 0 { // This unsafety is ok because we're guaranteed that the pointer // returned is the *only* pointer that will ever be returned to T. Our @@ -279,7 +283,7 @@ pub fn get_mut(this: &mut Arc) -> Option<&mut T> { } #[stable(feature = "rust1", since = "1.0.0")] -impl Clone for Arc { +impl Clone for Arc { /// Makes a clone of the `Arc`. /// /// This increases the strong reference count. @@ -313,7 +317,7 @@ impl Clone for Arc { } #[stable(feature = "rust1", since = "1.0.0")] -impl Deref for Arc { +impl Deref for Arc { type Target = T; #[inline] @@ -356,7 +360,7 @@ impl Arc { } #[stable(feature = "rust1", since = "1.0.0")] -impl Drop for Arc { +impl Drop for Arc { /// Drops the `Arc`. /// /// This will decrement the strong reference count. If the strong reference @@ -390,7 +394,7 @@ impl Drop for Arc { // it's run more than once) let ptr = *self._ptr; // if ptr.is_null() { return } - if ptr.is_null() || ptr as usize == mem::POST_DROP_USIZE { return } + if ptr as usize == 0 || ptr as usize == mem::POST_DROP_USIZE { return } // Because `fetch_sub` is already atomic, we do not need to synchronize // with other threads unless we are going to delete the object. This @@ -424,7 +428,7 @@ impl Drop for Arc { #[unstable(feature = "alloc", reason = "Weak pointers may not belong in this module.")] -impl Weak { +impl Weak { /// Upgrades a weak reference to a strong reference. /// /// Upgrades the `Weak` reference to an `Arc`, if possible. @@ -465,7 +469,7 @@ impl Weak { #[unstable(feature = "alloc", reason = "Weak pointers may not belong in this module.")] -impl Clone for Weak { +impl Clone for Weak { /// Makes a clone of the `Weak`. /// /// This increases the weak reference count. @@ -489,7 +493,7 @@ impl Clone for Weak { } #[stable(feature = "rust1", since = "1.0.0")] -impl Drop for Weak { +impl Drop for Weak { /// Drops the `Weak`. /// /// This will decrement the weak reference count. @@ -520,21 +524,22 @@ impl Drop for Weak { let ptr = *self._ptr; // see comments above for why this check is here - if ptr.is_null() || ptr as usize == mem::POST_DROP_USIZE { return } + if ptr as usize == 0 || ptr as usize == mem::POST_DROP_USIZE { return } // If we find out that we were the last weak pointer, then its time to // deallocate the data entirely. See the discussion in Arc::drop() about // the memory orderings if self.inner().weak.fetch_sub(1, Release) == 1 { atomic::fence(Acquire); - unsafe { deallocate(ptr as *mut u8, size_of::>(), - min_align_of::>()) } + unsafe { deallocate(ptr as *mut u8, + size_of_val(&*ptr), + min_align_of_val(&*ptr)) } } } } #[stable(feature = "rust1", since = "1.0.0")] -impl PartialEq for Arc { +impl PartialEq for Arc { /// Equality for two `Arc`s. /// /// Two `Arc`s are equal if their inner value are equal. @@ -566,7 +571,7 @@ impl PartialEq for Arc { fn ne(&self, other: &Arc) -> bool { *(*self) != *(*other) } } #[stable(feature = "rust1", since = "1.0.0")] -impl PartialOrd for Arc { +impl PartialOrd for Arc { /// Partial comparison for two `Arc`s. /// /// The two are compared by calling `partial_cmp()` on their inner values. @@ -645,21 +650,21 @@ impl PartialOrd for Arc { fn ge(&self, other: &Arc) -> bool { *(*self) >= *(*other) } } #[stable(feature = "rust1", since = "1.0.0")] -impl Ord for Arc { +impl Ord for Arc { fn cmp(&self, other: &Arc) -> Ordering { (**self).cmp(&**other) } } #[stable(feature = "rust1", since = "1.0.0")] -impl Eq for Arc {} +impl Eq for Arc {} #[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Display for Arc { +impl fmt::Display for Arc { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&**self, f) } } #[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for Arc { +impl fmt::Debug for Arc { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Debug::fmt(&**self, f) } @@ -679,7 +684,7 @@ impl Default for Arc { } #[stable(feature = "rust1", since = "1.0.0")] -impl Hash for Arc { +impl Hash for Arc { fn hash(&self, state: &mut H) { (**self).hash(state) } @@ -906,4 +911,13 @@ mod tests { // Make sure deriving works with Arc #[derive(Eq, Ord, PartialEq, PartialOrd, Clone, Debug, Default)] struct Foo { inner: Arc } + + #[test] + fn test_unsized() { + let x: Arc<[i32]> = Arc::new([1, 2, 3]); + assert_eq!(format!("{:?}", x), "[1, 2, 3]"); + let y = x.clone().downgrade(); + drop(x); + assert!(y.upgrade().is_none()); + } } diff --git a/src/liballoc/arc_stage0.rs b/src/liballoc/arc_stage0.rs new file mode 100644 index 000000000000..290b0566fd1b --- /dev/null +++ b/src/liballoc/arc_stage0.rs @@ -0,0 +1,686 @@ +// Copyright 2012-2014 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 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![stable(feature = "rust1", since = "1.0.0")] + +//! Threadsafe reference-counted boxes (the `Arc` type). +//! +//! The `Arc` type provides shared ownership of an immutable value. +//! Destruction is deterministic, and will occur as soon as the last owner is +//! gone. It is marked as `Send` because it uses atomic reference counting. +//! +//! If you do not need thread-safety, and just need shared ownership, consider +//! the [`Rc` type](../rc/struct.Rc.html). It is the same as `Arc`, but +//! does not use atomics, making it both thread-unsafe as well as significantly +//! faster when updating the reference count. +//! +//! The `downgrade` method can be used to create a non-owning `Weak` pointer +//! to the box. A `Weak` pointer can be upgraded to an `Arc` pointer, but +//! will return `None` if the value has already been dropped. +//! +//! For example, a tree with parent pointers can be represented by putting the +//! nodes behind strong `Arc` pointers, and then storing the parent pointers +//! as `Weak` pointers. +//! +//! # Examples +//! +//! Sharing some immutable data between threads: +//! +//! ```no_run +//! use std::sync::Arc; +//! use std::thread; +//! +//! let five = Arc::new(5); +//! +//! for _ in 0..10 { +//! let five = five.clone(); +//! +//! thread::spawn(move || { +//! println!("{:?}", five); +//! }); +//! } +//! ``` +//! +//! Sharing mutable data safely between threads with a `Mutex`: +//! +//! ```no_run +//! use std::sync::{Arc, Mutex}; +//! use std::thread; +//! +//! let five = Arc::new(Mutex::new(5)); +//! +//! for _ in 0..10 { +//! let five = five.clone(); +//! +//! thread::spawn(move || { +//! let mut number = five.lock().unwrap(); +//! +//! *number += 1; +//! +//! println!("{}", *number); // prints 6 +//! }); +//! } +//! ``` + +use boxed::Box; + +use core::prelude::*; + +use core::atomic; +use core::atomic::Ordering::{Relaxed, Release, Acquire, SeqCst}; +use core::fmt; +use core::cmp::Ordering; +use core::mem::{min_align_of, size_of}; +use core::mem; +use core::nonzero::NonZero; +use core::ops::Deref; +use core::ptr; +use core::hash::{Hash, Hasher}; +use heap::deallocate; + +/// An atomically reference counted wrapper for shared state. +/// +/// # Examples +/// +/// In this example, a large vector of floats is shared between several threads. +/// With simple pipes, without `Arc`, a copy would have to be made for each +/// thread. +/// +/// When you clone an `Arc`, it will create another pointer to the data and +/// increase the reference counter. +/// +/// ``` +/// # #![feature(alloc, core)] +/// use std::sync::Arc; +/// use std::thread; +/// +/// fn main() { +/// let numbers: Vec<_> = (0..100u32).collect(); +/// let shared_numbers = Arc::new(numbers); +/// +/// for _ in 0..10 { +/// let child_numbers = shared_numbers.clone(); +/// +/// thread::spawn(move || { +/// let local_numbers = &child_numbers[..]; +/// +/// // Work with the local numbers +/// }); +/// } +/// } +/// ``` +#[unsafe_no_drop_flag] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Arc { + // FIXME #12808: strange name to try to avoid interfering with + // field accesses of the contained type via Deref + _ptr: NonZero<*mut ArcInner>, +} + +unsafe impl Send for Arc { } +unsafe impl Sync for Arc { } + + +/// A weak pointer to an `Arc`. +/// +/// Weak pointers will not keep the data inside of the `Arc` alive, and can be +/// used to break cycles between `Arc` pointers. +#[unsafe_no_drop_flag] +#[unstable(feature = "alloc", + reason = "Weak pointers may not belong in this module.")] +pub struct Weak { + // FIXME #12808: strange name to try to avoid interfering with + // field accesses of the contained type via Deref + _ptr: NonZero<*mut ArcInner>, +} + +unsafe impl Send for Weak { } +unsafe impl Sync for Weak { } + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for Weak { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "(Weak)") + } +} + +struct ArcInner { + strong: atomic::AtomicUsize, + weak: atomic::AtomicUsize, + data: T, +} + +unsafe impl Send for ArcInner {} +unsafe impl Sync for ArcInner {} + +impl Arc { + /// Constructs a new `Arc`. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn new(data: T) -> Arc { + // Start the weak pointer count as 1 which is the weak pointer that's + // held by all the strong pointers (kinda), see std/rc.rs for more info + let x: Box<_> = box ArcInner { + strong: atomic::AtomicUsize::new(1), + weak: atomic::AtomicUsize::new(1), + data: data, + }; + Arc { _ptr: unsafe { NonZero::new(mem::transmute(x)) } } + } + + /// Downgrades the `Arc` to a `Weak` reference. + /// + /// # Examples + /// + /// ``` + /// # #![feature(alloc)] + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// let weak_five = five.downgrade(); + /// ``` + #[unstable(feature = "alloc", + reason = "Weak pointers may not belong in this module.")] + pub fn downgrade(&self) -> Weak { + // See the clone() impl for why this is relaxed + self.inner().weak.fetch_add(1, Relaxed); + Weak { _ptr: self._ptr } + } +} + +impl Arc { + #[inline] + fn inner(&self) -> &ArcInner { + // This unsafety is ok because while this arc is alive we're guaranteed + // that the inner pointer is valid. Furthermore, we know that the + // `ArcInner` structure itself is `Sync` because the inner data is + // `Sync` as well, so we're ok loaning out an immutable pointer to these + // contents. + unsafe { &**self._ptr } + } + + // Non-inlined part of `drop`. + #[inline(never)] + unsafe fn drop_slow(&mut self) { + let ptr = *self._ptr; + + // Destroy the data at this time, even though we may not free the box + // allocation itself (there may still be weak pointers lying around). + drop(ptr::read(&self.inner().data)); + + if self.inner().weak.fetch_sub(1, Release) == 1 { + atomic::fence(Acquire); + deallocate(ptr as *mut u8, size_of::>(), min_align_of::>()) + } + } +} + +/// Get the number of weak references to this value. +#[inline] +#[unstable(feature = "alloc")] +pub fn weak_count(this: &Arc) -> usize { this.inner().weak.load(SeqCst) - 1 } + +/// Get the number of strong references to this value. +#[inline] +#[unstable(feature = "alloc")] +pub fn strong_count(this: &Arc) -> usize { this.inner().strong.load(SeqCst) } + + +/// Returns a mutable reference to the contained value if the `Arc` is unique. +/// +/// Returns `None` if the `Arc` is not unique. +/// +/// # Examples +/// +/// ``` +/// # #![feature(alloc)] +/// extern crate alloc; +/// # fn main() { +/// use alloc::arc::{Arc, get_mut}; +/// +/// let mut x = Arc::new(3); +/// *get_mut(&mut x).unwrap() = 4; +/// assert_eq!(*x, 4); +/// +/// let _y = x.clone(); +/// assert!(get_mut(&mut x).is_none()); +/// # } +/// ``` +#[inline] +#[unstable(feature = "alloc")] +pub fn get_mut(this: &mut Arc) -> Option<&mut T> { + if strong_count(this) == 1 && weak_count(this) == 0 { + // This unsafety is ok because we're guaranteed that the pointer + // returned is the *only* pointer that will ever be returned to T. Our + // reference count is guaranteed to be 1 at this point, and we required + // the Arc itself to be `mut`, so we're returning the only possible + // reference to the inner data. + let inner = unsafe { &mut **this._ptr }; + Some(&mut inner.data) + } else { + None + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Arc { + /// Makes a clone of the `Arc`. + /// + /// This increases the strong reference count. + /// + /// # Examples + /// + /// ``` + /// # #![feature(alloc)] + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// five.clone(); + /// ``` + #[inline] + fn clone(&self) -> Arc { + // Using a relaxed ordering is alright here, as knowledge of the + // original reference prevents other threads from erroneously deleting + // the object. + // + // As explained in the [Boost documentation][1], Increasing the + // reference counter can always be done with memory_order_relaxed: New + // references to an object can only be formed from an existing + // reference, and passing an existing reference from one thread to + // another must already provide any required synchronization. + // + // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html) + self.inner().strong.fetch_add(1, Relaxed); + Arc { _ptr: self._ptr } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Deref for Arc { + type Target = T; + + #[inline] + fn deref(&self) -> &T { + &self.inner().data + } +} + +impl Arc { + /// Make a mutable reference from the given `Arc`. + /// + /// This is also referred to as a copy-on-write operation because the inner + /// data is cloned if the reference count is greater than one. + /// + /// # Examples + /// + /// ``` + /// # #![feature(alloc)] + /// use std::sync::Arc; + /// + /// let mut five = Arc::new(5); + /// + /// let mut_five = five.make_unique(); + /// ``` + #[inline] + #[unstable(feature = "alloc")] + pub fn make_unique(&mut self) -> &mut T { + // Note that we hold a strong reference, which also counts as a weak + // reference, so we only clone if there is an additional reference of + // either kind. + if self.inner().strong.load(SeqCst) != 1 || + self.inner().weak.load(SeqCst) != 1 { + *self = Arc::new((**self).clone()) + } + // As with `get_mut()`, the unsafety is ok because our reference was + // either unique to begin with, or became one upon cloning the contents. + let inner = unsafe { &mut **self._ptr }; + &mut inner.data + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Drop for Arc { + /// Drops the `Arc`. + /// + /// This will decrement the strong reference count. If the strong reference + /// count becomes zero and the only other references are `Weak` ones, + /// `drop`s the inner value. + /// + /// # Examples + /// + /// ``` + /// # #![feature(alloc)] + /// use std::sync::Arc; + /// + /// { + /// let five = Arc::new(5); + /// + /// // stuff + /// + /// drop(five); // explicit drop + /// } + /// { + /// let five = Arc::new(5); + /// + /// // stuff + /// + /// } // implicit drop + /// ``` + #[inline] + fn drop(&mut self) { + // This structure has #[unsafe_no_drop_flag], so this drop glue may run + // more than once (but it is guaranteed to be zeroed after the first if + // it's run more than once) + let ptr = *self._ptr; + // if ptr.is_null() { return } + if ptr.is_null() || ptr as usize == mem::POST_DROP_USIZE { return } + + // Because `fetch_sub` is already atomic, we do not need to synchronize + // with other threads unless we are going to delete the object. This + // same logic applies to the below `fetch_sub` to the `weak` count. + if self.inner().strong.fetch_sub(1, Release) != 1 { return } + + // This fence is needed to prevent reordering of use of the data and + // deletion of the data. Because it is marked `Release`, the decreasing + // of the reference count synchronizes with this `Acquire` fence. This + // means that use of the data happens before decreasing the reference + // count, which happens before this fence, which happens before the + // deletion of the data. + // + // As explained in the [Boost documentation][1], + // + // > It is important to enforce any possible access to the object in one + // > thread (through an existing reference) to *happen before* deleting + // > the object in a different thread. This is achieved by a "release" + // > operation after dropping a reference (any access to the object + // > through this reference must obviously happened before), and an + // > "acquire" operation before deleting the object. + // + // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html) + atomic::fence(Acquire); + + unsafe { + self.drop_slow() + } + } +} + +#[unstable(feature = "alloc", + reason = "Weak pointers may not belong in this module.")] +impl Weak { + /// Upgrades a weak reference to a strong reference. + /// + /// Upgrades the `Weak` reference to an `Arc`, if possible. + /// + /// Returns `None` if there were no strong references and the data was + /// destroyed. + /// + /// # Examples + /// + /// ``` + /// # #![feature(alloc)] + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// let weak_five = five.downgrade(); + /// + /// let strong_five: Option> = weak_five.upgrade(); + /// ``` + pub fn upgrade(&self) -> Option> { + // We use a CAS loop to increment the strong count instead of a + // fetch_add because once the count hits 0 it must never be above 0. + let inner = self.inner(); + loop { + let n = inner.strong.load(SeqCst); + if n == 0 { return None } + let old = inner.strong.compare_and_swap(n, n + 1, SeqCst); + if old == n { return Some(Arc { _ptr: self._ptr }) } + } + } + + #[inline] + fn inner(&self) -> &ArcInner { + // See comments above for why this is "safe" + unsafe { &**self._ptr } + } +} + +#[unstable(feature = "alloc", + reason = "Weak pointers may not belong in this module.")] +impl Clone for Weak { + /// Makes a clone of the `Weak`. + /// + /// This increases the weak reference count. + /// + /// # Examples + /// + /// ``` + /// # #![feature(alloc)] + /// use std::sync::Arc; + /// + /// let weak_five = Arc::new(5).downgrade(); + /// + /// weak_five.clone(); + /// ``` + #[inline] + fn clone(&self) -> Weak { + // See comments in Arc::clone() for why this is relaxed + self.inner().weak.fetch_add(1, Relaxed); + Weak { _ptr: self._ptr } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Drop for Weak { + /// Drops the `Weak`. + /// + /// This will decrement the weak reference count. + /// + /// # Examples + /// + /// ``` + /// # #![feature(alloc)] + /// use std::sync::Arc; + /// + /// { + /// let five = Arc::new(5); + /// let weak_five = five.downgrade(); + /// + /// // stuff + /// + /// drop(weak_five); // explicit drop + /// } + /// { + /// let five = Arc::new(5); + /// let weak_five = five.downgrade(); + /// + /// // stuff + /// + /// } // implicit drop + /// ``` + fn drop(&mut self) { + let ptr = *self._ptr; + + // see comments above for why this check is here + if ptr.is_null() || ptr as usize == mem::POST_DROP_USIZE { return } + + // If we find out that we were the last weak pointer, then its time to + // deallocate the data entirely. See the discussion in Arc::drop() about + // the memory orderings + if self.inner().weak.fetch_sub(1, Release) == 1 { + atomic::fence(Acquire); + unsafe { deallocate(ptr as *mut u8, size_of::>(), + min_align_of::>()) } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for Arc { + /// Equality for two `Arc`s. + /// + /// Two `Arc`s are equal if their inner value are equal. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// five == Arc::new(5); + /// ``` + fn eq(&self, other: &Arc) -> bool { *(*self) == *(*other) } + + /// Inequality for two `Arc`s. + /// + /// Two `Arc`s are unequal if their inner value are unequal. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// five != Arc::new(5); + /// ``` + fn ne(&self, other: &Arc) -> bool { *(*self) != *(*other) } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for Arc { + /// Partial comparison for two `Arc`s. + /// + /// The two are compared by calling `partial_cmp()` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// five.partial_cmp(&Arc::new(5)); + /// ``` + fn partial_cmp(&self, other: &Arc) -> Option { + (**self).partial_cmp(&**other) + } + + /// Less-than comparison for two `Arc`s. + /// + /// The two are compared by calling `<` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// five < Arc::new(5); + /// ``` + fn lt(&self, other: &Arc) -> bool { *(*self) < *(*other) } + + /// 'Less-than or equal to' comparison for two `Arc`s. + /// + /// The two are compared by calling `<=` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// five <= Arc::new(5); + /// ``` + fn le(&self, other: &Arc) -> bool { *(*self) <= *(*other) } + + /// Greater-than comparison for two `Arc`s. + /// + /// The two are compared by calling `>` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// five > Arc::new(5); + /// ``` + fn gt(&self, other: &Arc) -> bool { *(*self) > *(*other) } + + /// 'Greater-than or equal to' comparison for two `Arc`s. + /// + /// The two are compared by calling `>=` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// five >= Arc::new(5); + /// ``` + fn ge(&self, other: &Arc) -> bool { *(*self) >= *(*other) } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for Arc { + fn cmp(&self, other: &Arc) -> Ordering { (**self).cmp(&**other) } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for Arc {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for Arc { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Display::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for Arc { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Pointer for Arc { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Pointer::fmt(&*self._ptr, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for Arc { + #[stable(feature = "rust1", since = "1.0.0")] + fn default() -> Arc { Arc::new(Default::default()) } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for Arc { + fn hash(&self, state: &mut H) { + (**self).hash(state) + } +} diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index ac5a5d60cbd4..45dcea909f44 100644 --- a/src/liballoc/lib.rs +++ b/src/liballoc/lib.rs @@ -112,7 +112,14 @@ pub mod boxed; mod boxed { pub use std::boxed::{Box, HEAP}; } #[cfg(test)] mod boxed_test; +#[cfg(not(stage0))] pub mod arc; +#[cfg(stage0)] +mod arc_stage0; +#[cfg(stage0)] +pub mod arc { + pub use arc_stage0::*; +} pub mod rc; /// Common out-of-memory routine