---

yaml
---
r: 64880
b: refs/heads/snap-stage3
c: 5ec1d5b
h: refs/heads/master
v: v3

Author: omasanori

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 81dda9d9cb5a8e472509c6f335acc81083d74b91
+refs/heads/snap-stage3: 5ec1d5b69d8eb81b9b9f4381e9e4b8bbea6e6a5e
 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::SingleThreaded) {
+        do task::spawn_sched(task::ManualThreads(1)) {
             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 = 1u8;
+    pub static FALSE : u8 = 0u8;
 
     pub static UCHAR_ALPHABETIC : UProperty = 0;
     pub static UCHAR_BINARY_START : UProperty = 0; // = UCHAR_ALPHABETIC

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

@@ -674,11 +674,10 @@ 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();
             }
         }
     }
@@ -690,15 +689,13 @@ 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();
             }
         }
     }
@@ -710,21 +707,19 @@ 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();
             }
         }
     }
@@ -736,14 +731,12 @@ 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,9 +343,7 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
     }
 
     // Wait for schedulers
-    for threads.consume_iter().advance() |thread| {
-        thread.join();
-    }
+    { let _threads = threads; }
 
     // Return the exit code
     unsafe {

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

@@ -901,8 +901,10 @@ mod test {
                 sched.run();
             };
 
-            normal_thread.join();
-            special_thread.join();
+            // wait for the end
+            let _thread1 = normal_thread;
+            let _thread2 = special_thread;
+
         }
     }
 
@@ -1072,19 +1074,16 @@ 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 = 2000000; // XXX: Too much stack
+        static MIN_STACK_SIZE: uint = 100000; // 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,9 +125,7 @@ pub fn run_in_mt_newsched_task(f: ~fn()) {
         }
 
         // Wait for schedulers
-        for threads.consume_iter().advance() |thread| {
-            thread.join();
-        }
+        let _threads = threads;
     }
 
 }

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

@@ -16,8 +16,7 @@ type raw_thread = libc::c_void;
 
 pub struct Thread {
     main: ~fn(),
-    raw_thread: *raw_thread,
-    joined: bool
+    raw_thread: *raw_thread
 }
 
 impl Thread {
@@ -28,28 +27,18 @@ impl Thread {
         let raw = substart(&main);
         Thread {
             main: main,
-            raw_thread: raw,
-            joined: false
+            raw_thread: raw
         }
     }
-
-    pub fn join(self) {
-        assert!(!self.joined);
-        let mut this = self;
-        unsafe { rust_raw_thread_join(this.raw_thread); }
-        this.joined = true;
-    }
 }
 
 impl Drop for Thread {
     fn drop(&self) {
-        assert!(self.joined);
-        unsafe { rust_raw_thread_delete(self.raw_thread) }
+        unsafe { rust_raw_thread_join_delete(self.raw_thread) }
     }
 }
 
 extern {
     pub unsafe fn rust_raw_thread_start(f: &(~fn())) -> *raw_thread;
-    pub unsafe fn rust_raw_thread_join(thread: *raw_thread);
-    pub unsafe fn rust_raw_thread_delete(thread: *raw_thread);
+    pub unsafe fn rust_raw_thread_join_delete(thread: *raw_thread);
 }

branches/snap-stage3/src/libstd/rt/uv/async.rs

@@ -94,13 +94,12 @@ mod test {
             let mut loop_ = Loop::new();
             let watcher = AsyncWatcher::new(&mut loop_, |w, _| w.close(||()) );
             let watcher_cell = Cell::new(watcher);
-            let thread = do Thread::start {
+            let _thread = do Thread::start {
                 let mut watcher = watcher_cell.take();
                 watcher.send();
             };
             loop_.run();
             loop_.close();
-            thread.join();
         }
     }
 }

branches/snap-stage3/src/libstd/rt/uv/net.rs

@@ -715,7 +715,7 @@ mod test {
                 }
             }
 
-            let client_thread = do Thread::start {
+            let _client_thread = do Thread::start {
                 rtdebug!("starting client thread");
                 let mut loop_ = Loop::new();
                 let mut tcp_watcher = { TcpWatcher::new(&mut loop_) };
@@ -739,7 +739,6 @@ mod test {
             let mut loop_ = loop_;
             loop_.run();
             loop_.close();
-            client_thread.join();
         }
     }
 
@@ -791,7 +790,7 @@ mod test {
                 }
             }
 
-            let client_thread = do Thread::start {
+            let _client_thread = do Thread::start {
                 rtdebug!("starting client thread");
                 let mut loop_ = Loop::new();
                 let mut tcp_watcher = { TcpWatcher::new(&mut loop_) };
@@ -815,7 +814,6 @@ mod test {
             let mut loop_ = loop_;
             loop_.run();
             loop_.close();
-            client_thread.join();
         }
     }
 
@@ -857,7 +855,7 @@ mod test {
                 server.close(||{});
             }
 
-            let thread = do Thread::start {
+            do Thread::start {
                 let mut loop_ = Loop::new();
                 let mut client = UdpWatcher::new(&loop_);
                 assert!(client.bind(client_addr).is_ok());
@@ -875,7 +873,6 @@ mod test {
 
             loop_.run();
             loop_.close();
-            thread.join();
         }
     }
 
@@ -917,7 +914,7 @@ mod test {
                 server.close(||{});
             }
 
-            let thread = do Thread::start {
+            do Thread::start {
                 let mut loop_ = Loop::new();
                 let mut client = UdpWatcher::new(&loop_);
                 assert!(client.bind(client_addr).is_ok());
@@ -935,7 +932,6 @@ mod test {
 
             loop_.run();
             loop_.close();
-            thread.join();
         }
     }
 }

branches/snap-stage3/src/libstd/rt/uv/uvio.rs

@@ -222,12 +222,11 @@ mod test_remote {
                 };
                 remote_cell.put_back(remote);
             }
-            let thread = do Thread::start {
+            let _thread = do Thread::start {
                 remote_cell.take().fire();
             };
 
             assert!(tube.recv() == 1);
-            thread.join();
         }
     }
 }