---

yaml
---
r: 92913
b: refs/heads/auto
c: ee634e3
h: refs/heads/master
i:
  92911: 5861059
v: v3

Author: bors

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 1c3c0103c4f0719479b4737c9216b5481561c69a
+refs/heads/auto: ee634e3ac455032227f44ee7577b3d65be4acb61
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/RELEASES.txt

@@ -1,10 +1,156 @@
-Version 0.9 (XXX 2013)
+Version 0.9 (January 2014)
 --------------------------
 
-   * ~XXX changes, numerous bugfixes
+   * ~1600 changes, numerous bugfixes
+
+   * Language
+      * The `float` type has been removed. Use `f32` or `f64` instead.
+      * A new facility for enabling experimental features (feature gating) has
+        been added, using the crate-level `#[feature(foo)]` attribute.
+      * Managed boxes (@) are now behind a feature gate
+        (`#[feature(managed_boxes)]`) in preperation for future removal. Use the
+        standard library's `Gc` or `Rc` types instead.
+      * `@mut` has been removed. Use `std::cell::{Cell, RefCell}` instead.
+      * Jumping back to the top of a loop is now done with `continue` instead of
+        `loop`.
+      * Strings can no longer be mutated through index assignment.
+      * Raw strings can be created via the basic `r"foo"` syntax or with matched
+        hash delimiters, as in `r###"foo"###`.
+      * `~fn` is now written `proc (args) -> retval { ... }` and may only be
+        called once.
+      * The `&fn` type is now written `|args| -> ret` to match the literal form.
+      * `@fn`s have been removed.
+      * `do` only works with procs in order to make it obvious what the cost
+        of `do` is.
+      * The `#[link(...)]` attribute has been replaced with
+        `#[crate_id = "name#vers"]`.
+      * Empty `impl`s must be terminated with empty braces and may not be
+        terminated with a semicolon.
+      * Keywords are no longer allowed as lifetime names; the `self` lifetime
+        no longer has any special meaning.
+      * The old `fmt!` string formatting macro has been removed.
+      * `printf!` and `printfln!` (old-style formatting) removed in favor of
+        `print!` and `println!`.
+      * `mut` works in patterns now, as in `let (mut x, y) = (1, 2);`.
+      * New reserved keywords: `alignof`, `offsetof`, `sizeof`.
+      * Macros can have attributes.
+      * Macros can expand to items with attributes.
+      * Macros can expand to multiple items.
+      * The `asm!` macro is feature-gated (`#[feature(asm)]`).
+      * Comments may be nested.
+      * Values automatically coerce to trait objects they implement, without
+        an explicit `as`.
+      * Enum discriminants are no longer an entire word but as small as needed to
+        contain all the variants. The `repr` attribute can be used to override
+        the discriminant size, as in `#[repr(int)]` for integer-sized, and
+        `#[repr(C)]` to match C enums.
+      * Non-string literals are not allowed in attributes (they never worked).
+      * The FFI now supports variadic functions.
+      * Octal numeric literals, as in `0o7777`.
+      * The `concat!` syntax extension performs compile-time string concatenation.
+      * The `#[fixed_stack_segment]` and `#[rust_stack]` attributes have been
+        removed as Rust no longer uses segmented stacks.
+      * Non-ascii identifiers are feature-gated (`#[feature(non_ascii_idents)]`).
+      * Ignoring all fields of an enum variant or tuple-struct is done with `..`,
+        not `*`; ignoring remaining fields of a struct is also done with `..`,
+        not `_`; ignoring a slice of a vector is done with `..`, not `.._`.
+      * `rustc` supports the "win64" calling convention via `extern "win64"`.
+      * `rustc` supports the "system" calling convention, which defaults to the
+        preferred convention for the target platform, "stdcall" on 32-bit Windows,
+        "C" elsewhere.
+      * The `type_overflow` lint (default: warn) checks literals for overflow.
+      * The `unsafe_block` lint (default: allow) checks for usage of `unsafe`.
+      * The `attribute_usage` lint (default: warn) warns about unknown
+        attributes.
+      * The `unknown_features` lint (default: warn) warns about unknown
+        feature gates.
+      * The `dead_code` lint (default: warn) checks for dead code.
+      * Rust libraries can be linked statically to one another
+      * `#[link_args]` is behind the `link_args` feature gate.
+      * Native libraries are now linked with `#[link(name = "foo")]`
+      * Native libraries can be statically linked to a rust crate
+        (`#[link(name = "foo", kind = "static")]`).
+      * Native OS X frameworks are now officially supported
+        (`#[link(name = "foo", kind = "framework")]`).
+      * The `#[thread_local]` attribute creates thread-local (not task-local)
+        variables. Currently behind the `thread_local` feature gate.
+      * The `return` keyword may be used in closures.
+      * Types that can be copied via a memcpy implement the `Pod` kind.
+
+   * Libraries
+      * std: The `option` and `result` API's have been overhauled to make them
+        simpler, more consistent, and more composable.
+      * std: The entire `std::io` module has been replaced with one that is
+        more comprehensive and that properly interfaces with the underlying
+        scheduler. File, TCP, UDP, Unix sockets, pipes, and timers are all
+        implemented.
+      * std: `io::util` contains a number of useful implementations of
+        `Reader` and `Writer`, including `NullReader`, `NullWriter`,
+        `ZeroReader`, `TeeReader`.
+      * std: The reference counted pointer type `extra::rc` moved into std.
+      * std: The `Gc` type in the `gc` module will replace `@` (it is currently
+        just a wrapper around it).
+      * std: `fmt::Default` can be implemented for any type to provide default
+        formatting to the `format!` macro, as in `format!("{}", myfoo)`.
+      * std: The `rand` API continues to be tweaked.
+      * std: Functions dealing with type size and alignment have moved from the
+        `sys` module to the `mem` module.
+      * std: The `path` module was written and API changed.
+      * std: `str::from_utf8` has been changed to cast instead of allocate.
+      * std: `starts_with` and `ends_with` methods added to vectors via the
+        `ImmutableEqVector` trait, which is in the prelude.
+      * std: Vectors can be indexed with the `get_opt` method, which returns `None`
+        if the index is out of bounds.
+      * std: Task failure no longer propagates between tasks, as the model was
+        complex, expensive, and incompatible with thread-based tasks.
+      * std: The `Any` type can be used for dynamic typing.
+      * std: `~Any` can be passed to the `fail!` macro and retrieved via
+        `task::try`.
+      * std: Methods that produce iterators generally do not have an `_iter`
+        suffix now.
+      * std: `cell::Cell` and `cell::RefCell` can be used to introduce mutability
+        roots (mutable fields, etc.). Use instead of e.g. `@mut`.
+      * std: `util::ignore` renamed to `prelude::drop`.
+      * std: Slices have `sort` and `sort_by` methods via the `MutableVector`
+        trait.
+      * std: `vec::raw` has seen a lot of cleanup and API changes.
+      * std: The standard library no longer includes any C++ code, and very
+        minimal C, eliminating the dependency on libstdc++.
+      * std: Runtime scheduling and I/O functionality has been factored out into
+        extensible interfaces and is now implemented by two different crates:
+        libnative, for native threading and I/O; and libgreen, for green threading
+        and I/O. This paves the way for using the standard library in more limited
+        embeded environments.
+      * std: The `comm` module has been rewritten to be much faster, have a
+        simpler, more consistent API, and to work for both native and green
+        threading.
+      * std: All libuv dependencies have been moved into the rustuv crate.
+      * native: New implementations of runtime scheduling on top of OS threads.
+      * native: New native implementations of TCP, UDP, file I/O, process spawning,
+        and other I/O.
+      * green: The green thread scheduler and message passing types are almost
+        entirely lock-free.
+      * extra: The `flatpipes` module had bitrotted and was removed.
+      * extra: All crypto functions have been removed and Rust now has a policy of
+        not reimplementing crypto in the standard library. In the future crypto
+        will be provided by external crates with bindings to established libraries.
+      * extra: `c_vec` has been modernized.
+      * extra: The `sort` module has been removed. Use the `sort` method on
+        mutable slices.
 
    * Tooling
-      * The `rust` and `rusti` commands have been removed, due to lack of maintenance.
+      * The `rust` and `rusti` commands have been removed, due to lack of
+        maintenance.
+      * `rustdoc` was completely rewritten.
+      * `rustdoc` can test code examples in documentation.
+      * `rustpkg` can test packages with the argument, 'test'.
+      * `rustpkg` supports arbitrary dependencies, including C libraries.
+      * `rustc`'s support for generating debug info is improved again.
+      * `rustc` has better error reporting for unbalanced delimiters.
+      * `rustc`'s JIT support was removed due to bitrot.
+      * Executables and static libraries can be built with LTO (-Z lto)
+      * `rustc` adds a `--dep-info` flag for communicating dependencies to
+        build tools.
 
 Version 0.8 (September 2013)
 --------------------------

branches/auto/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/auto/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 {