---

yaml
---
r: 147839
b: refs/heads/try2
c: e34b1ea
h: refs/heads/master
i:
  147837: 1320087
  147835: f9e15ca
  147831: ca78889
  147823: 5b7e7f4
  147807: 5f093a2
  147775: a5a6c9b
  147711: 28d05ce
v: v3

Author: bors

[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: 14a01b149a5a273abca9c32588935cb9acf207f9
+refs/heads/try2: e34b1eaccec107a76513d227fe4d6f15a6281d29
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -3806,25 +3806,6 @@ As a convenience, the logging spec can also be set to a special pseudo-crate,
 `::help`. In this case, when the application starts, the runtime will
 simply output a list of loaded modules containing log expressions, then exit.
 
-The Rust runtime itself generates logging information. The runtime's logs are
-generated for a number of artificial modules in the `::rt` pseudo-crate,
-and can be enabled just like the logs for any standard module. The full list
-of runtime logging modules follows.
-
-* `::rt::mem` Memory management
-* `::rt::comm` Messaging and task communication
-* `::rt::task` Task management
-* `::rt::dom` Task scheduling
-* `::rt::trace` Unused
-* `::rt::cache` Type descriptor cache
-* `::rt::upcall` Compiler-generated runtime calls
-* `::rt::timer` The scheduler timer
-* `::rt::gc` Garbage collection
-* `::rt::stdlib` Functions used directly by the standard library
-* `::rt::kern` The runtime kernel
-* `::rt::backtrace` Log a backtrace on task failure
-* `::rt::callback` Unused
-
 #### Logging Expressions
 
 Rust provides several macros to log information. Here's a simple Rust program

branches/try2/src/driver/driver.rs

@@ -19,7 +19,4 @@ extern mod this = "rustdoc";
 #[cfg(rustc)]
 extern mod this = "rustc";
 
-#[cfg(rustdoc_ng)]
-extern mod this = "rustdoc_ng";
-
 fn main() { this::main() }

branches/try2/src/etc/emacs/rust-mode.el

@@ -54,7 +54,9 @@
     ;; We don't want to indent out to the open bracket if the
     ;; open bracket ends the line
     (when (not (looking-at "[[:blank:]]*\\(?://.*\\)?$"))
-      (when (looking-at "[[:space:]]") (forward-to-word 1))
+      (when (looking-at "[[:space:]]")
+	(forward-word 1)
+	(backward-word 1))
       (current-column))))
 
 (defun rust-mode-indent-line ()

branches/try2/src/libextra/getopts.rs

@@ -31,7 +31,7 @@
 //!
 //! ~~~{.rust}
 //! extern mod extra;
-//! use extra::getopts::*;
+//! use extra::getopts::{optopt,optflag,getopts,Opt};
 //! use std::os;
 //!
 //! fn do_work(inp: &str, out: Option<~str>) {

branches/try2/src/libextra/time.rs

@@ -12,17 +12,16 @@
 
 use std::io::Reader;
 use std::io::mem::BufReader;
+use std::libc;
 use std::num;
 use std::str;
 
 static NSEC_PER_SEC: i32 = 1_000_000_000_i32;
 
-pub mod rustrt {
+mod rustrt {
     use super::Tm;
 
     extern {
-        pub fn rust_get_time(sec: &mut i64, nsec: &mut i32);
-        pub fn rust_precise_time_ns(ns: &mut u64);
         pub fn rust_tzset();
         pub fn rust_gmtime(sec: i64, nsec: i32, result: &mut Tm);
         pub fn rust_localtime(sec: i64, nsec: i32, result: &mut Tm);
@@ -31,6 +30,31 @@ pub mod rustrt {
     }
 }
 
+#[cfg(unix, not(target_os = "macos"))]
+mod imp {
+    use std::libc::{c_int, timespec};
+
+    // Apparently android provides this in some other library?
+    #[cfg(not(target_os = "android"))]
+    #[link(name = "rt")]
+    extern {}
+
+    extern {
+        pub fn clock_gettime(clk_id: c_int, tp: *mut timespec) -> c_int;
+    }
+
+}
+#[cfg(target_os = "macos")]
+mod imp {
+    use std::libc::{timeval, timezone, c_int, mach_timebase_info};
+
+    extern {
+        pub fn gettimeofday(tp: *mut timeval, tzp: *mut timezone) -> c_int;
+        pub fn mach_absolute_time() -> u64;
+        pub fn mach_timebase_info(info: *mut mach_timebase_info) -> c_int;
+    }
+}
+
 /// A record specifying a time value in seconds and nanoseconds.
 
 
@@ -64,11 +88,45 @@ impl Ord for Timespec {
  */
 pub fn get_time() -> Timespec {
     unsafe {
-        let mut sec = 0i64;
-        let mut nsec = 0i32;
-        rustrt::rust_get_time(&mut sec, &mut nsec);
+        let (sec, nsec) = os_get_time();
         return Timespec::new(sec, nsec);
     }
+
+    #[cfg(windows)]
+    unsafe fn os_get_time() -> (i64, i32) {
+        static NANOSECONDS_FROM_1601_TO_1970: u64 = 11644473600000000;
+
+        let mut time = libc::FILETIME {
+            dwLowDateTime: 0,
+            dwHighDateTime: 0,
+        };
+        libc::GetSystemTimeAsFileTime(&mut time);
+
+        // A FILETIME contains a 64-bit value representing the number of
+        // hectonanosecond (100-nanosecond) intervals since 1601-01-01T00:00:00Z.
+        // http://support.microsoft.com/kb/167296/en-us
+        let ns_since_1601 = ((time.dwHighDateTime as u64 << 32) |
+                             (time.dwLowDateTime  as u64 <<  0)) / 10;
+        let ns_since_1970 = ns_since_1601 - NANOSECONDS_FROM_1601_TO_1970;
+
+        ((ns_since_1970 / 1000000) as i64,
+         ((ns_since_1970 % 1000000) * 1000) as i32)
+    }
+
+    #[cfg(target_os = "macos")]
+    unsafe fn os_get_time() -> (i64, i32) {
+        use std::ptr;
+        let mut tv = libc::timeval { tv_sec: 0, tv_usec: 0 };
+        imp::gettimeofday(&mut tv, ptr::mut_null());
+        (tv.tv_sec as i64, tv.tv_usec * 1000)
+    }
+
+    #[cfg(not(target_os = "macos"), not(windows))]
+    unsafe fn os_get_time() -> (i64, i32) {
+        let mut tv = libc::timespec { tv_sec: 0, tv_nsec: 0 };
+        imp::clock_gettime(libc::CLOCK_REALTIME, &mut tv);
+        (tv.tv_sec as i64, tv.tv_nsec as i32)
+    }
 }
 
 
@@ -77,10 +135,38 @@ pub fn get_time() -> Timespec {
  * in nanoseconds since an unspecified epoch.
  */
 pub fn precise_time_ns() -> u64 {
-    unsafe {
-        let mut ns = 0u64;
-        rustrt::rust_precise_time_ns(&mut ns);
-        ns
+    return os_precise_time_ns();
+
+    #[cfg(windows)]
+    fn os_precise_time_ns() -> u64 {
+        let mut ticks_per_s = 0;
+        assert_eq!(unsafe {
+            libc::QueryPerformanceFrequency(&mut ticks_per_s)
+        }, 1);
+        let ticks_per_s = if ticks_per_s == 0 {1} else {ticks_per_s};
+        let mut ticks = 0;
+        assert_eq!(unsafe {
+            libc::QueryPerformanceCounter(&mut ticks)
+        }, 1);
+
+        return (ticks as u64 * 1000000000) / (ticks_per_s as u64);
+    }
+
+    #[cfg(target_os = "macos")]
+    fn os_precise_time_ns() -> u64 {
+        let time = unsafe { imp::mach_absolute_time() };
+        let mut info = libc::mach_timebase_info { numer: 0, denom: 0 };
+        unsafe { imp::mach_timebase_info(&mut info); }
+        return time * ((info.numer / info.denom) as u64);
+    }
+
+    #[cfg(not(windows), not(target_os = "macos"))]
+    fn os_precise_time_ns() -> u64 {
+        let mut ts = libc::timespec { tv_sec: 0, tv_nsec: 0 };
+        unsafe {
+            imp::clock_gettime(libc::CLOCK_MONOTONIC, &mut ts);
+        }
+        return (ts.tv_sec as u64) * 1000000000 + (ts.tv_nsec as u64)
     }
 }
 

branches/try2/src/libgreen/lib.rs

@@ -25,18 +25,20 @@
 // NB this does *not* include globs, please keep it that way.
 #[feature(macro_rules)];
 
+// Allow check-stage0-green for now
+#[cfg(test, stage0)] extern mod green;
+
 use std::os;
 use std::rt::crate_map;
-use std::rt::local::Local;
 use std::rt::rtio;
-use std::rt::task::Task;
 use std::rt::thread::Thread;
 use std::rt;
 use std::sync::atomics::{SeqCst, AtomicUint, INIT_ATOMIC_UINT};
 use std::sync::deque;
 use std::task::TaskOpts;
 use std::util;
 use std::vec;
+use std::sync::arc::UnsafeArc;
 
 use sched::{Shutdown, Scheduler, SchedHandle, TaskFromFriend, NewNeighbor};
 use sleeper_list::SleeperList;
@@ -118,14 +120,6 @@ pub fn run(main: proc()) -> int {
         os::set_exit_status(rt::DEFAULT_ERROR_CODE);
     }
 
-    // Once the main task has exited and we've set our exit code, wait for all
-    // spawned sub-tasks to finish running. This is done to allow all schedulers
-    // to remain active while there are still tasks possibly running.
-    unsafe {
-        let mut task = Local::borrow(None::<Task>);
-        task.get().wait_for_other_tasks();
-    }
-
     // Now that we're sure all tasks are dead, shut down the pool of schedulers,
     // waiting for them all to return.
     pool.shutdown();
@@ -164,6 +158,17 @@ pub struct SchedPool {
     priv deque_pool: deque::BufferPool<~task::GreenTask>,
     priv sleepers: SleeperList,
     priv factory: fn() -> ~rtio::EventLoop,
+    priv task_state: TaskState,
+    priv tasks_done: Port<()>,
+}
+
+/// This is an internal state shared among a pool of schedulers. This is used to
+/// keep track of how many tasks are currently running in the pool and then
+/// sending on a channel once the entire pool has been drained of all tasks.
+#[deriving(Clone)]
+struct TaskState {
+    cnt: UnsafeArc<AtomicUint>,
+    done: SharedChan<()>,
 }
 
 impl SchedPool {
@@ -182,6 +187,7 @@ impl SchedPool {
         assert!(nscheds > 0);
 
         // The pool of schedulers that will be returned from this function
+        let (p, state) = TaskState::new();
         let mut pool = SchedPool {
             threads: ~[],
             handles: ~[],
@@ -192,6 +198,8 @@ impl SchedPool {
             deque_pool: deque::BufferPool::new(),
             next_friend: 0,
             factory: factory,
+            task_state: state,
+            tasks_done: p,
         };
 
         // Create a work queue for each scheduler, ntimes. Create an extra
@@ -210,21 +218,30 @@ impl SchedPool {
                                             (pool.factory)(),
                                             worker,
                                             pool.stealers.clone(),
-                                            pool.sleepers.clone());
+                                            pool.sleepers.clone(),
+                                            pool.task_state.clone());
             pool.handles.push(sched.make_handle());
             let sched = sched;
-            pool.threads.push(do Thread::start {
-                sched.bootstrap();
-            });
+            pool.threads.push(do Thread::start { sched.bootstrap(); });
         }
 
         return pool;
     }
 
+    /// Creates a new task configured to run inside of this pool of schedulers.
+    /// This is useful to create a task which can then be sent to a specific
+    /// scheduler created by `spawn_sched` (and possibly pin it to that
+    /// scheduler).
     pub fn task(&mut self, opts: TaskOpts, f: proc()) -> ~GreenTask {
         GreenTask::configure(&mut self.stack_pool, opts, f)
     }
 
+    /// Spawns a new task into this pool of schedulers, using the specified
+    /// options to configure the new task which is spawned.
+    ///
+    /// New tasks are spawned in a round-robin fashion to the schedulers in this
+    /// pool, but tasks can certainly migrate among schedulers once they're in
+    /// the pool.
     pub fn spawn(&mut self, opts: TaskOpts, f: proc()) {
         let task = self.task(opts, f);
 
@@ -262,7 +279,8 @@ impl SchedPool {
                                         (self.factory)(),
                                         worker,
                                         self.stealers.clone(),
-                                        self.sleepers.clone());
+                                        self.sleepers.clone(),
+                                        self.task_state.clone());
         let ret = sched.make_handle();
         self.handles.push(sched.make_handle());
         let sched = sched;
@@ -271,9 +289,28 @@ impl SchedPool {
         return ret;
     }
 
+    /// Consumes the pool of schedulers, waiting for all tasks to exit and all
+    /// schedulers to shut down.
+    ///
+    /// This function is required to be called in order to drop a pool of
+    /// schedulers, it is considered an error to drop a pool without calling
+    /// this method.
+    ///
+    /// This only waits for all tasks in *this pool* of schedulers to exit, any
+    /// native tasks or extern pools will not be waited on
     pub fn shutdown(mut self) {
         self.stealers = ~[];
 
+        // Wait for everyone to exit. We may have reached a 0-task count
+        // multiple times in the past, meaning there could be several buffered
+        // messages on the `tasks_done` port. We're guaranteed that after *some*
+        // message the current task count will be 0, so we just receive in a
+        // loop until everything is totally dead.
+        while self.task_state.active() {
+            self.tasks_done.recv();
+        }
+
+        // Now that everyone's gone, tell everything to shut down.
         for mut handle in util::replace(&mut self.handles, ~[]).move_iter() {
             handle.send(Shutdown);
         }
@@ -283,6 +320,31 @@ impl SchedPool {
     }
 }
 
+impl TaskState {
+    fn new() -> (Port<()>, TaskState) {
+        let (p, c) = SharedChan::new();
+        (p, TaskState {
+            cnt: UnsafeArc::new(AtomicUint::new(0)),
+            done: c,
+        })
+    }
+
+    fn increment(&mut self) {
+        unsafe { (*self.cnt.get()).fetch_add(1, SeqCst); }
+    }
+
+    fn active(&self) -> bool {
+        unsafe { (*self.cnt.get()).load(SeqCst) != 0 }
+    }
+
+    fn decrement(&mut self) {
+        let prev = unsafe { (*self.cnt.get()).fetch_sub(1, SeqCst) };
+        if prev == 1 {
+            self.done.send(());
+        }
+    }
+}
+
 impl Drop for SchedPool {
     fn drop(&mut self) {
         if self.threads.len() > 0 {