---

yaml
---
r: 152459
b: refs/heads/try2
c: a0eca23
h: refs/heads/master
i:
  152457: 6f401aa
  152455: 1ca2d0b
v: v3

Author: mcreinhard

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: f03863ae7d372e2024bf87f0b9f7058237a918a2
+refs/heads/try2: a0eca2378640c7f5761e6e56438801ad61f5dfc8
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/crates.mk

@@ -61,16 +61,16 @@ DEPS_rlibc :=
 DEPS_alloc := core libc native:jemalloc
 DEPS_debug := std
 DEPS_rustrt := alloc core libc collections native:rustrt_native
-DEPS_std := core libc rand alloc collections rustrt sync \
+DEPS_std := core libc rand alloc collections rustrt \
 	native:rust_builtin native:backtrace
 DEPS_graphviz := std
 DEPS_green := std native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
 DEPS_syntax := std term serialize log fmt_macros debug
-DEPS_rustc := syntax native:rustllvm flate arena serialize getopts \
+DEPS_rustc := syntax native:rustllvm flate arena serialize sync getopts \
               time log graphviz debug
-DEPS_rustdoc := rustc native:hoedown serialize getopts \
+DEPS_rustdoc := rustc native:hoedown serialize sync getopts \
                 test time debug
 DEPS_flate := std native:miniz
 DEPS_arena := std
@@ -80,17 +80,17 @@ DEPS_serialize := std log
 DEPS_term := std log
 DEPS_semver := std
 DEPS_uuid := std serialize
-DEPS_sync := core alloc rustrt collections
+DEPS_sync := std alloc
 DEPS_getopts := std
 DEPS_collections := core alloc
 DEPS_fourcc := rustc syntax std
 DEPS_hexfloat := rustc syntax std
 DEPS_num := std
 DEPS_test := std getopts serialize term time regex native:rust_test_helpers
-DEPS_time := std serialize
+DEPS_time := std serialize sync
 DEPS_rand := core
 DEPS_url := std
-DEPS_log := std
+DEPS_log := std sync
 DEPS_regex := std
 DEPS_regex_macros = rustc syntax std regex
 DEPS_fmt_macros = std

branches/try2/mk/docs.mk

@@ -273,18 +273,14 @@ LIB_DOC_DEP_$(1) = \
 	$$(RSINPUTS_$(1)) \
 	$$(RUSTDOC_EXE) \
 	$$(foreach dep,$$(RUST_DEPS_$(1)), \
-		$$(TLIB2_T_$(CFG_BUILD)_H_$(CFG_BUILD))/stamp.$$(dep) \
-		doc/$$(dep)/)
+		$$(TLIB2_T_$(CFG_BUILD)_H_$(CFG_BUILD))/stamp.$$(dep))
 else
 LIB_DOC_DEP_$(1) = $$(CRATEFILE_$(1)) $$(RSINPUTS_$(1))
 endif
 
-doc/$(1)/:
-	$$(Q)mkdir -p $$@
-
 $(2) += doc/$(1)/index.html
 doc/$(1)/index.html: CFG_COMPILER_HOST_TRIPLE = $(CFG_TARGET)
-doc/$(1)/index.html: $$(LIB_DOC_DEP_$(1)) doc/$(1)/
+doc/$(1)/index.html: $$(LIB_DOC_DEP_$(1))
 	@$$(call E, rustdoc $$@)
 	$$(Q)$$(RUSTDOC) --cfg dox --cfg stage2 $$<
 endef

branches/try2/src/doc/guide-tasks.md

@@ -269,7 +269,7 @@ later.
 The basic example below illustrates this.
 
 ~~~
-use std::sync::Future;
+extern crate sync;
 
 # fn main() {
 # fn make_a_sandwich() {};
@@ -278,7 +278,7 @@ fn fib(n: u64) -> u64 {
     12586269025
 }
 
-let mut delayed_fib = Future::spawn(proc() fib(50));
+let mut delayed_fib = sync::Future::spawn(proc() fib(50));
 make_a_sandwich();
 println!("fib(50) = {}", delayed_fib.get())
 # }
@@ -294,7 +294,7 @@ Here is another example showing how futures allow you to background computations
 be distributed on the available cores.
 
 ~~~
-# use std::sync::Future;
+# extern crate sync;
 fn partial_sum(start: uint) -> f64 {
     let mut local_sum = 0f64;
     for num in range(start*100000, (start+1)*100000) {
@@ -304,7 +304,7 @@ fn partial_sum(start: uint) -> f64 {
 }
 
 fn main() {
-    let mut futures = Vec::from_fn(1000, |ind| Future::spawn( proc() { partial_sum(ind) }));
+    let mut futures = Vec::from_fn(1000, |ind| sync::Future::spawn( proc() { partial_sum(ind) }));
 
     let mut final_res = 0f64;
     for ft in futures.mut_iter()  {
@@ -329,8 +329,10 @@ Here is a small example showing how to use Arcs. We wish to run concurrently sev
 a single large vector of floats. Each task needs the full vector to perform its duty.
 
 ~~~
+extern crate sync;
+
+use sync::Arc;
 use std::rand;
-use std::sync::Arc;
 
 fn pnorm(nums: &[f64], p: uint) -> f64 {
     nums.iter().fold(0.0, |a, b| a + b.powf(p as f64)).powf(1.0 / (p as f64))
@@ -355,8 +357,9 @@ at the power given as argument and takes the inverse power of this value). The A
 created by the line
 
 ~~~
+# extern crate sync;
 # use std::rand;
-# use std::sync::Arc;
+# use sync::Arc;
 # fn main() {
 # let numbers = Vec::from_fn(1000000, |_| rand::random::<f64>());
 let numbers_arc=Arc::new(numbers);
@@ -368,8 +371,9 @@ it's contents. Within the task's procedure, the captured Arc reference can be us
 reference to the underlying vector as if it were local.
 
 ~~~
+# extern crate sync;
 # use std::rand;
-# use std::sync::Arc;
+# use sync::Arc;
 # fn pnorm(nums: &[f64], p: uint) -> f64 { 4.0 }
 # fn main() {
 # let numbers=Vec::from_fn(1000000, |_| rand::random::<f64>());
@@ -457,9 +461,9 @@ the string in response.  The child terminates when it receives `0`.
 Here is the function that implements the child task:
 
 ~~~
-use std::comm::DuplexStream;
+extern crate sync;
 # fn main() {
-fn stringifier(channel: &DuplexStream<String, uint>) {
+fn stringifier(channel: &sync::DuplexStream<String, uint>) {
     let mut value: uint;
     loop {
         value = channel.recv();
@@ -481,10 +485,10 @@ response itself is simply the stringified version of the received value,
 Here is the code for the parent task:
 
 ~~~
-use std::comm::duplex;
+extern crate sync;
 # use std::task::spawn;
-# use std::comm::DuplexStream;
-# fn stringifier(channel: &DuplexStream<String, uint>) {
+# use sync::DuplexStream;
+# fn stringifier(channel: &sync::DuplexStream<String, uint>) {
 #     let mut value: uint;
 #     loop {
 #         value = channel.recv();
@@ -494,7 +498,7 @@ use std::comm::duplex;
 # }
 # fn main() {
 
-let (from_child, to_child) = duplex();
+let (from_child, to_child) = sync::duplex();
 
 spawn(proc() {
     stringifier(&to_child);

branches/try2/src/doc/intro.md

@@ -297,7 +297,8 @@ an atomically reference counted box ("A.R.C." == "atomically reference counted")
 Here's some code:
 
 ```
-use std::sync::Arc;
+extern crate sync;
+use sync::Arc;
 
 fn main() {
     let numbers = vec![1,2,3];
@@ -343,7 +344,8 @@ Let's take the same example yet again,
 and modify it to mutate the shared state:
 
 ```
-use std::sync::{Arc, Mutex};
+extern crate sync;
+use sync::{Arc, Mutex};
 
 fn main() {
     let numbers = vec![1,2,3];

branches/try2/src/doc/tutorial.md

@@ -1710,14 +1710,14 @@ having ownership of the box. It allows the creation of cycles, and the individua
 not have a destructor.
 
 ~~~
-use std::gc::GC;
+use std::gc::Gc;
 
 // A fixed-size array allocated in a garbage-collected box
-let x = box(GC) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let x = Gc::new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 let y = x; // does not perform a move, unlike with `Rc`
 let z = x;
 
-assert!(*z == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+assert!(*z.borrow() == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 ~~~
 
 With shared ownership, mutability cannot be inherited so the boxes are always immutable. However,
@@ -2459,7 +2459,7 @@ fn draw_all(shapes: &[Box<Drawable>]) {
 }
 ~~~~
 
-In this example, there is no type parameter. Instead, the `~Drawable`
+In this example, there is no type parameter. Instead, the `Box<Drawable>`
 type denotes any owned box value that implements the `Drawable` trait.
 To construct such a value, you use the `as` operator to cast a value
 to an object:

branches/try2/src/etc/licenseck.py

@@ -38,9 +38,9 @@
     "rt/isaac/randport.cpp", # public domain
     "rt/isaac/rand.h", # public domain
     "rt/isaac/standard.h", # public domain
-    "libsync/mpsc_queue.rs", # BSD
-    "libsync/spsc_queue.rs", # BSD
-    "libsync/mpmc_bounded_queue.rs", # BSD
+    "libstd/sync/mpsc_queue.rs", # BSD
+    "libstd/sync/spsc_queue.rs", # BSD
+    "libstd/sync/mpmc_bounded_queue.rs", # BSD
     "libsync/mpsc_intrusive.rs", # BSD
     "test/bench/shootout-fannkuch-redux.rs", # BSD
     "test/bench/shootout-meteor.rs", # BSD

branches/try2/src/liballoc/arc.rs

@@ -33,7 +33,9 @@ use heap::deallocate;
 /// task.
 ///
 /// ```rust
-/// use std::sync::Arc;
+/// extern crate sync;
+///
+/// use sync::Arc;
 ///
 /// fn main() {
 ///     let numbers = Vec::from_fn(100, |i| i as f32);
@@ -182,7 +184,7 @@ impl<T: Share + Send> Drop for Arc<T> {
 
         // 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`
+        // decreasing of the reference count sychronizes with this `Acquire`
         // fence. This means that use of the data happens before decreasing
         // the refernce count, which happens before this fence, which
         // happens before the deletion of the data.
@@ -274,7 +276,7 @@ mod tests {
     use std::task;
     use std::vec::Vec;
     use super::{Arc, Weak};
-    use std::sync::Mutex;
+    use sync::Mutex;
 
     struct Canary(*mut atomics::AtomicUint);
 

branches/try2/src/liballoc/heap.rs

@@ -155,6 +155,24 @@ unsafe fn closure_exchange_malloc(drop_glue: fn(*mut u8), size: uint, align: uin
     alloc as *mut u8
 }
 
+// hack for libcore
+#[no_mangle]
+#[doc(hidden)]
+#[deprecated]
+#[cfg(not(test))]
+pub unsafe extern "C" fn rust_allocate(size: uint, align: uint) -> *mut u8 {
+    allocate(size, align)
+}
+
+// hack for libcore
+#[no_mangle]
+#[doc(hidden)]
+#[deprecated]
+#[cfg(not(test))]
+pub unsafe extern "C" fn rust_deallocate(ptr: *mut u8, size: uint, align: uint) {
+    deallocate(ptr, size, align)
+}
+
 #[cfg(test)]
 mod bench {
     extern crate test;
@@ -166,4 +184,11 @@ mod bench {
             box 10
         })
     }
+
+    #[bench]
+    fn alloc_owned_big(b: &mut Bencher) {
+        b.iter(|| {
+            box [10, ..1000]
+        })
+    }
 }

branches/try2/src/liballoc/lib.rs

@@ -84,6 +84,7 @@ extern crate libc;
 // Allow testing this library
 
 #[cfg(test)] extern crate debug;
+#[cfg(test)] extern crate sync;
 #[cfg(test)] extern crate native;
 #[cfg(test, stage0)] #[phase(syntax, link)] extern crate std;
 #[cfg(test, stage0)] #[phase(syntax, link)] extern crate log;

branches/try2/src/liballoc/rc.rs

@@ -320,8 +320,8 @@ mod tests {
     #[test]
     fn gc_inside() {
         // see issue #11532
-        use std::gc::GC;
-        let a = Rc::new(RefCell::new(box(GC) 1));
+        use std::gc::Gc;
+        let a = Rc::new(RefCell::new(Gc::new(1)));
         assert!(a.try_borrow_mut().is_some());
     }