---

yaml
---
r: 64886
b: refs/heads/snap-stage3
c: 8f835d4
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 6534b4d4ce87940954b017bd27dc4e5fa7e59703
+refs/heads/snap-stage3: 8f835d42d7f7090ab6408a9aa6316a0f8f21f3f3
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libextra/sync.rs

@@ -890,7 +890,7 @@ mod tests {
     fn test_sem_runtime_friendly_blocking() {
         // Force the runtime to schedule two threads on the same sched_loop.
         // When one blocks, it should schedule the other one.
-        do task::spawn_sched(task::ManualThreads(1)) {
+        do task::spawn_sched(task::SingleThreaded) {
             let s = ~Semaphore::new(1);
             let s2 = ~s.clone();
             let (p,c) = comm::stream();

branches/snap-stage3/src/libextra/unicode.rs

@@ -17,7 +17,7 @@ pub mod icu {
     pub type UChar32 = char;
 
     pub static TRUE : u8 = 1u8;
-    pub static FALSE : u8 = 0u8;
+    pub static FALSE : u8 = 1u8;
 
     pub static UCHAR_ALPHABETIC : UProperty = 0;
     pub static UCHAR_BINARY_START : UProperty = 0; // = UCHAR_ALPHABETIC

branches/snap-stage3/src/libstd/num/num.rs

@@ -8,10 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Numeric traits and functions for generic mathematics.
-//!
-//! These are implemented for the primitive numeric types in `std::{u8, u16,
-//! u32, u64, uint, i8, i16, i32, i64, int, f32, f64, float}`.
+//! An interface for numeric types
 
 #[allow(missing_doc)];
 
@@ -22,7 +19,9 @@ use option::Option;
 
 pub mod strconv;
 
+///
 /// The base trait for numeric types
+///
 pub trait Num: Eq + Zero + One
              + Neg<Self>
              + Add<Self,Self>
@@ -46,23 +45,18 @@ pub trait Orderable: Ord {
     fn clamp(&self, mn: &Self, mx: &Self) -> Self;
 }
 
-#[inline(always)] pub fn min<T: Orderable>(x: T, y: T) -> T { x.min(&y) }
-#[inline(always)] pub fn max<T: Orderable>(x: T, y: T) -> T { x.max(&y) }
-#[inline(always)] pub fn clamp<T: Orderable>(value: T, mn: T, mx: T) -> T { value.clamp(&mn, &mx) }
+#[inline(always)] pub fn min<T: Orderable>(a: T, b: T) -> T { a.min(&b) }
+#[inline(always)] pub fn max<T: Orderable>(a: T, b: T) -> T { a.max(&b) }
 
 pub trait Zero {
     fn zero() -> Self;      // FIXME (#5527): This should be an associated constant
     fn is_zero(&self) -> bool;
 }
 
-#[inline(always)] pub fn zero<T: Zero>() -> T { Zero::zero() }
-
 pub trait One {
     fn one() -> Self;       // FIXME (#5527): This should be an associated constant
 }
 
-#[inline(always)] pub fn one<T: One>() -> T { One::one() }
-
 pub trait Signed: Num
                 + Neg<Self> {
     fn abs(&self) -> Self;
@@ -74,7 +68,6 @@ pub trait Signed: Num
 }
 
 #[inline(always)] pub fn abs<T: Signed>(value: T) -> T { value.abs() }
-#[inline(always)] pub fn abs_sub<T: Signed>(x: T, y: T) -> T { x.abs_sub(&y) }
 #[inline(always)] pub fn signum<T: Signed>(value: T) -> T { value.signum() }
 
 pub trait Unsigned: Num {}
@@ -97,9 +90,6 @@ pub trait Integer: Num
     fn is_odd(&self) -> bool;
 }
 
-#[inline(always)] pub fn gcd<T: Integer>(x: T, y: T) -> T { x.gcd(&y) }
-#[inline(always)] pub fn lcm<T: Integer>(x: T, y: T) -> T { x.lcm(&y) }
-
 pub trait Round {
     fn floor(&self) -> Self;
     fn ceil(&self) -> Self;
@@ -123,21 +113,15 @@ pub trait Algebraic {
     fn hypot(&self, other: &Self) -> Self;
 }
 
-#[inline(always)] pub fn pow<T: Algebraic>(value: T, n: T) -> T { value.pow(&n) }
 #[inline(always)] pub fn sqrt<T: Algebraic>(value: T) -> T { value.sqrt() }
-#[inline(always)] pub fn rsqrt<T: Algebraic>(value: T) -> T { value.rsqrt() }
-#[inline(always)] pub fn cbrt<T: Algebraic>(value: T) -> T { value.cbrt() }
-#[inline(always)] pub fn hypot<T: Algebraic>(x: T, y: T) -> T { x.hypot(&y) }
 
 pub trait Trigonometric {
     fn sin(&self) -> Self;
     fn cos(&self) -> Self;
     fn tan(&self) -> Self;
-
     fn asin(&self) -> Self;
     fn acos(&self) -> Self;
     fn atan(&self) -> Self;
-
     fn atan2(&self, other: &Self) -> Self;
     fn sin_cos(&self) -> (Self, Self);
 }
@@ -151,12 +135,10 @@ pub trait Trigonometric {
 #[inline(always)] pub fn atan<T: Trigonometric>(value: T) -> T { value.atan() }
 
 #[inline(always)] pub fn atan2<T: Trigonometric>(x: T, y: T) -> T { x.atan2(&y) }
-#[inline(always)] pub fn sin_cos<T: Trigonometric>(value: T) -> (T, T) { value.sin_cos() }
 
 pub trait Exponential {
     fn exp(&self) -> Self;
     fn exp2(&self) -> Self;
-
     fn ln(&self) -> Self;
     fn log(&self, base: &Self) -> Self;
     fn log2(&self) -> Self;
@@ -175,7 +157,6 @@ pub trait Hyperbolic: Exponential {
     fn sinh(&self) -> Self;
     fn cosh(&self) -> Self;
     fn tanh(&self) -> Self;
-
     fn asinh(&self) -> Self;
     fn acosh(&self) -> Self;
     fn atanh(&self) -> Self;
@@ -189,7 +170,9 @@ pub trait Hyperbolic: Exponential {
 #[inline(always)] pub fn acosh<T: Hyperbolic>(value: T) -> T { value.acosh() }
 #[inline(always)] pub fn atanh<T: Hyperbolic>(value: T) -> T { value.atanh() }
 
+///
 /// Defines constants and methods common to real numbers
+///
 pub trait Real: Signed
               + Fractional
               + Algebraic
@@ -220,7 +203,9 @@ pub trait Real: Signed
     fn to_radians(&self) -> Self;
 }
 
+///
 /// Methods that are harder to implement and not commonly used.
+///
 pub trait RealExt: Real {
     // FIXME (#5527): usages of `int` should be replaced with an associated
     // integer type once these are implemented
@@ -238,7 +223,9 @@ pub trait RealExt: Real {
     fn yn(&self, n: int) -> Self;
 }
 
+///
 /// Collects the bitwise operators under one trait.
+///
 pub trait Bitwise: Not<Self>
                  + BitAnd<Self,Self>
                  + BitOr<Self,Self>
@@ -258,9 +245,11 @@ pub trait Bounded {
     fn max_value() -> Self;
 }
 
+///
 /// Specifies the available operations common to all of Rust's core numeric primitives.
 /// These may not always make sense from a purely mathematical point of view, but
 /// may be useful for systems programming.
+///
 pub trait Primitive: Num
                    + NumCast
                    + Bounded
@@ -275,13 +264,17 @@ pub trait Primitive: Num
     fn bytes() -> uint;
 }
 
+///
 /// A collection of traits relevant to primitive signed and unsigned integers
+///
 pub trait Int: Integer
              + Primitive
              + Bitwise
              + BitCount {}
 
+///
 /// Used for representing the classification of floating point numbers
+///
 #[deriving(Eq)]
 pub enum FPCategory {
     /// "Not a Number", often obtained by dividing by zero
@@ -296,7 +289,9 @@ pub enum FPCategory {
     FPNormal,
 }
 
+///
 /// Primitive floating point numbers
+///
 pub trait Float: Real
                + Signed
                + Primitive
@@ -330,10 +325,7 @@ pub trait Float: Real
     fn next_after(&self, other: Self) -> Self;
 }
 
-#[inline(always)] pub fn exp_m1<T: Float>(value: T) -> T { value.exp_m1() }
-#[inline(always)] pub fn ln_1p<T: Float>(value: T) -> T { value.ln_1p() }
-#[inline(always)] pub fn mul_add<T: Float>(a: T, b: T, c: T) -> T { a.mul_add(b, c) }
-
+///
 /// Cast from one machine scalar to another
 ///
 /// # Example
@@ -348,7 +340,9 @@ pub fn cast<T:NumCast,U:NumCast>(n: T) -> U {
     NumCast::from(n)
 }
 
+///
 /// An interface for casting between machine scalars
+///
 pub trait NumCast {
     fn from<T:NumCast>(n: T) -> Self;
 
@@ -420,6 +414,7 @@ pub trait FromStrRadix {
     pub fn from_str_radix(str: &str, radix: uint) -> Option<Self>;
 }
 
+///
 /// Calculates a power to a given radix, optimized for uint `pow` and `radix`.
 ///
 /// Returns `radix^pow` as `T`.

branches/snap-stage3/src/libstd/rt/comm.rs

@@ -674,10 +674,11 @@ mod test {
             do run_in_newsched_task {
                 let (port, chan) = oneshot::<int>();
                 let port_cell = Cell::new(port);
-                let _thread = do spawntask_thread {
+                let thread = do spawntask_thread {
                     let _p = port_cell.take();
                 };
                 let _chan = chan;
+                thread.join();
             }
         }
     }
@@ -689,13 +690,15 @@ mod test {
                 let (port, chan) = oneshot::<int>();
                 let chan_cell = Cell::new(chan);
                 let port_cell = Cell::new(port);
-                let _thread1 = do spawntask_thread {
+                let thread1 = do spawntask_thread {
                     let _p = port_cell.take();
                 };
-                let _thread2 = do spawntask_thread {
+                let thread2 = do spawntask_thread {
                     let c = chan_cell.take();
                     c.send(1);
                 };
+                thread1.join();
+                thread2.join();
             }
         }
     }
@@ -707,19 +710,21 @@ mod test {
                 let (port, chan) = oneshot::<int>();
                 let chan_cell = Cell::new(chan);
                 let port_cell = Cell::new(port);
-                let _thread1 = do spawntask_thread {
+                let thread1 = do spawntask_thread {
                     let port_cell = Cell::new(port_cell.take());
                     let res = do spawntask_try {
                         port_cell.take().recv();
                     };
                     assert!(res.is_err());
                 };
-                let _thread2 = do spawntask_thread {
+                let thread2 = do spawntask_thread {
                     let chan_cell = Cell::new(chan_cell.take());
                     do spawntask {
                         chan_cell.take();
                     }
                 };
+                thread1.join();
+                thread2.join();
             }
         }
     }
@@ -731,12 +736,14 @@ mod test {
                 let (port, chan) = oneshot::<~int>();
                 let chan_cell = Cell::new(chan);
                 let port_cell = Cell::new(port);
-                let _thread1 = do spawntask_thread {
+                let thread1 = do spawntask_thread {
                     chan_cell.take().send(~10);
                 };
-                let _thread2 = do spawntask_thread {
+                let thread2 = do spawntask_thread {
                     assert!(port_cell.take().recv() == ~10);
                 };
+                thread1.join();
+                thread2.join();
             }
         }
     }

branches/snap-stage3/src/libstd/rt/mod.rs

@@ -343,7 +343,9 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
     }
 
     // Wait for schedulers
-    { let _threads = threads; }
+    for threads.consume_iter().advance() |thread| {
+        thread.join();
+    }
 
     // Return the exit code
     unsafe {

branches/snap-stage3/src/libstd/rt/sched.rs

@@ -901,10 +901,8 @@ mod test {
                 sched.run();
             };
 
-            // wait for the end
-            let _thread1 = normal_thread;
-            let _thread2 = special_thread;
-
+            normal_thread.join();
+            special_thread.join();
         }
     }
 
@@ -1074,16 +1072,19 @@ mod test {
             sched2.enqueue_task(task2);
 
             let sched1_cell = Cell::new(sched1);
-            let _thread1 = do Thread::start {
+            let thread1 = do Thread::start {
                 let sched1 = sched1_cell.take();
                 sched1.run();
             };
 
             let sched2_cell = Cell::new(sched2);
-            let _thread2 = do Thread::start {
+            let thread2 = do Thread::start {
                 let sched2 = sched2_cell.take();
                 sched2.run();
             };
+
+            thread1.join();
+            thread2.join();
         }
     }
 

branches/snap-stage3/src/libstd/rt/task.rs

@@ -219,7 +219,7 @@ impl Drop for Task {
 impl Coroutine {
 
     pub fn new(stack_pool: &mut StackPool, start: ~fn()) -> Coroutine {
-        static MIN_STACK_SIZE: uint = 100000; // XXX: Too much stack
+        static MIN_STACK_SIZE: uint = 2000000; // XXX: Too much stack
 
         let start = Coroutine::build_start_wrapper(start);
         let mut stack = stack_pool.take_segment(MIN_STACK_SIZE);

branches/snap-stage3/src/libstd/rt/test.rs

@@ -125,7 +125,9 @@ pub fn run_in_mt_newsched_task(f: ~fn()) {
         }
 
         // Wait for schedulers
-        let _threads = threads;
+        for threads.consume_iter().advance() |thread| {
+            thread.join();
+        }
     }
 
 }