---

yaml
---
r: 148973
b: refs/heads/try2
c: 29e500d
h: refs/heads/master
i:
  148971: 49ece01
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: ec2f047aa9a09926b9c4192c447f44dda484ee6d
+refs/heads/try2: 29e500db8a98a86b3de56688cd9fa6571a840470
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/tests.mk

@@ -242,7 +242,6 @@ ALL_HS := $(filter-out $(S)src/rt/vg/valgrind.h \
 tidy:
 		@$(call E, check: formatting)
 		$(Q)find $(S)src -name '*.r[sc]' \
-		| grep '^$(S)src/test' -v \
 		| grep '^$(S)src/libuv' -v \
 		| grep '^$(S)src/llvm' -v \
 		| grep '^$(S)src/gyp' -v \

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

@@ -236,9 +236,7 @@ extern mod green;
 
 #[start]
 fn start(argc: int, argv: **u8) -> int {
-    green::start(argc, argv, proc() {
-        main();
-    })
+    green::start(argc, argv, main)
 }
 
 fn main() {}

branches/try2/src/etc/tidy.py

@@ -14,6 +14,9 @@
 
 err=0
 cols=100
+cr_flag="xfail-tidy-cr"
+tab_flag="xfail-tidy-tab"
+linelength_flag="xfail-tidy-linelength"
 
 # Be careful to support Python 2.4, 2.6, and 3.x here!
 config_proc=subprocess.Popen([ "git", "config", "core.autocrlf" ],
@@ -46,12 +49,22 @@ def do_license_check(name, contents):
 
 current_name = ""
 current_contents = ""
+check_tab = True
+check_cr = True
+check_linelength = True
+
 
 try:
     for line in fileinput.input(file_names,
                                 openhook=fileinput.hook_encoded("utf-8")):
 
         if fileinput.filename().find("tidy.py") == -1:
+            if line.find(cr_flag) != -1:
+                check_cr = False
+            if line.find(tab_flag) != -1:
+                check_tab = False
+            if line.find(linelength_flag) != -1:
+                check_linelength = False
             if line.find("// XXX") != -1:
                 report_err("XXX is no longer necessary, use FIXME")
             if line.find("TODO") != -1:
@@ -72,16 +85,16 @@ def do_license_check(name, contents):
                 if "SNAP" in line:
                     report_warn("unmatched SNAP line: " + line)
 
-        if (line.find('\t') != -1 and
+        if check_tab and (line.find('\t') != -1 and
             fileinput.filename().find("Makefile") == -1):
             report_err("tab character")
-        if not autocrlf and line.find('\r') != -1:
+        if check_cr and not autocrlf and line.find('\r') != -1:
             report_err("CR character")
         if line.endswith(" \n") or line.endswith("\t\n"):
             report_err("trailing whitespace")
         line_len = len(line)-2 if autocrlf else len(line)-1
 
-        if line_len > cols:
+        if check_linelength and line_len > cols:
             report_err("line longer than %d chars" % cols)
 
         if fileinput.isfirstline() and current_name != "":
@@ -90,6 +103,9 @@ def do_license_check(name, contents):
         if fileinput.isfirstline():
             current_name = fileinput.filename()
             current_contents = ""
+            check_cr = True
+            check_tab = True
+            check_linelength = True
 
         current_contents += line
 

branches/try2/src/libgreen/lib.rs

@@ -12,10 +12,156 @@
 //!
 //! This library provides M:N threading for rust programs. Internally this has
 //! the implementation of a green scheduler along with context switching and a
-//! stack-allocation strategy.
+//! stack-allocation strategy. This can be optionally linked in to rust
+//! programs in order to provide M:N functionality inside of 1:1 programs.
 //!
-//! This can be optionally linked in to rust programs in order to provide M:N
-//! functionality inside of 1:1 programs.
+//! # Architecture
+//!
+//! An M:N scheduling library implies that there are N OS thread upon which M
+//! "green threads" are multiplexed. In other words, a set of green threads are
+//! all run inside a pool of OS threads.
+//!
+//! With this design, you can achieve _concurrency_ by spawning many green
+//! threads, and you can achieve _parallelism_ by running the green threads
+//! simultaneously on multiple OS threads. Each OS thread is a candidate for
+//! being scheduled on a different core (the source of parallelism), and then
+//! all of the green threads cooperatively schedule amongst one another (the
+//! source of concurrency).
+//!
+//! ## Schedulers
+//!
+//! In order to coordinate among green threads, each OS thread is primarily
+//! running something which we call a Scheduler. Whenever a reference to a
+//! Scheduler is made, it is synonymous to referencing one OS thread. Each
+//! scheduler is bound to one and exactly one OS thread, and the thread that it
+//! is bound to never changes.
+//!
+//! Each scheduler is connected to a pool of other schedulers (a `SchedPool`)
+//! which is the thread pool term from above. A pool of schedulers all share the
+//! work that they create. Furthermore, whenever a green thread is created (also
+//! synonymously referred to as a green task), it is associated with a
+//! `SchedPool` forevermore. A green thread cannot leave its scheduler pool.
+//!
+//! Schedulers can have at most one green thread running on them at a time. When
+//! a scheduler is asleep on its event loop, there are no green tasks running on
+//! the OS thread or the scheduler. The term "context switch" is used for when
+//! the running green thread is swapped out, but this simply changes the one
+//! green thread which is running on the scheduler.
+//!
+//! ## Green Threads
+//!
+//! A green thread can largely be summarized by a stack and a register context.
+//! Whenever a green thread is spawned, it allocates a stack, and then prepares
+//! a register context for execution. The green task may be executed across
+//! multiple OS threads, but it will always use the same stack and it will carry
+//! its register context across OS threads.
+//!
+//! Each green thread is cooperatively scheduled with other green threads.
+//! Primarily, this means that there is no pre-emption of a green thread. The
+//! major consequence of this design is that a green thread stuck in an infinite
+//! loop will prevent all other green threads from running on that particular
+//! scheduler.
+//!
+//! Scheduling events for green threads occur on communication and I/O
+//! boundaries. For example, if a green task blocks waiting for a message on a
+//! channel some other green thread can now run on the scheduler. This also has
+//! the consequence that until a green thread performs any form of scheduling
+//! event, it will be running on the same OS thread (unconditionally).
+//!
+//! ## Work Stealing
+//!
+//! With a pool of schedulers, a new green task has a number of options when
+//! deciding where to run initially. The current implementation uses a concept
+//! called work stealing in order to spread out work among schedulers.
+//!
+//! In a work-stealing model, each scheduler maintains a local queue of tasks to
+//! run, and this queue is stolen from by other schedulers. Implementation-wise,
+//! work stealing has some hairy parts, but from a user-perspective, work
+//! stealing simply implies what with M green threads and N schedulers where
+//! M > N it is very likely that all schedulers will be busy executing work.
+//!
+//! # Considerations when using libgreen
+//!
+//! An M:N runtime has both pros and cons, and there is no one answer as to
+//! whether M:N or 1:1 is appropriate to use. As always, there are many
+//! advantages and disadvantages between the two. Regardless of the workload,
+//! however, there are some aspects of using green thread which you should be
+//! aware of:
+//!
+//! * The largest concern when using libgreen is interoperating with native
+//!   code. Care should be taken when calling native code that will block the OS
+//!   thread as it will prevent further green tasks from being scheduled on the
+//!   OS thread.
+//!
+//! * Native code using thread-local-storage should be approached
+//!   with care. Green threads may migrate among OS threads at any time, so
+//!   native libraries using thread-local state may not always work.
+//!
+//! * Native synchronization primitives (e.g. pthread mutexes) will also not
+//!   work for green threads. The reason for this is because native primitives
+//!   often operate on a _os thread_ granularity whereas green threads are
+//!   operating on a more granular unit of work.
+//!
+//! * A green threading runtime is not fork-safe. If the process forks(), it
+//!   cannot expect to make reasonable progress by continuing to use green
+//!   threads.
+//!
+//! Note that these concerns do not mean that operating with native code is a
+//! lost cause. These are simply just concerns which should be considered when
+//! invoking native code.
+//!
+//! # Starting with libgreen
+//!
+//! ```rust
+//! extern mod green;
+//!
+//! #[start]
+//! fn start(argc: int, argv: **u8) -> int { green::start(argc, argv, main) }
+//!
+//! fn main() {
+//!     // this code is running in a pool of schedulers
+//! }
+//! ```
+//!
+//! # Using a scheduler pool
+//!
+//! ```rust
+//! use std::task::TaskOpts;
+//! use green::{SchedPool, PoolConfig};
+//! use green::sched::{PinnedTask, TaskFromFriend};
+//!
+//! let config = PoolConfig::new();
+//! let mut pool = SchedPool::new(config);
+//!
+//! // Spawn tasks into the pool of schedulers
+//! pool.spawn(TaskOpts::new(), proc() {
+//!     // this code is running inside the pool of schedulers
+//!
+//!     spawn(proc() {
+//!         // this code is also running inside the same scheduler pool
+//!     });
+//! });
+//!
+//! // Dynamically add a new scheduler to the scheduler pool. This adds another
+//! // OS thread that green threads can be multiplexed on to.
+//! let mut handle = pool.spawn_sched();
+//!
+//! // Pin a task to the spawned scheduler
+//! let task = pool.task(TaskOpts::new(), proc() { /* ... */ });
+//! handle.send(PinnedTask(task));
+//!
+//! // Schedule a task on this new scheduler
+//! let task = pool.task(TaskOpts::new(), proc() { /* ... */ });
+//! handle.send(TaskFromFriend(task));
+//!
+//! // Handles keep schedulers alive, so be sure to drop all handles before
+//! // destroying the sched pool
+//! drop(handle);
+//!
+//! // Required to shut down this scheduler pool.
+//! // The task will fail if `shutdown` is not called.
+//! pool.shutdown();
+//! ```
 
 #[crate_id = "green#0.10-pre"];
 #[license = "MIT/ASL2"];

branches/try2/src/libnative/lib.rs

@@ -8,11 +8,38 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! The native runtime crate
+//! The native I/O and threading crate
 //!
 //! This crate contains an implementation of 1:1 scheduling for a "native"
 //! runtime. In addition, all I/O provided by this crate is the thread blocking
 //! version of I/O.
+//!
+//! # Starting with libnative
+//!
+//! ```rust
+//! extern mod native;
+//!
+//! #[start]
+//! fn start(argc: int, argv: **u8) -> int { native::start(argc, argv, main) }
+//!
+//! fn main() {
+//!     // this code is running on the main OS thread
+//! }
+//! ```
+//!
+//! # Force spawning a native task
+//!
+//! ```rust
+//! extern mod native;
+//!
+//! fn main() {
+//!     // We're not sure whether this main function is run in 1:1 or M:N mode.
+//!
+//!     native::task::spawn(proc() {
+//!         // this code is guaranteed to be run on a native thread
+//!     });
+//! }
+//! ```
 
 #[crate_id = "native#0.10-pre"];
 #[license = "MIT/ASL2"];

branches/try2/src/libstd/ascii.rs

@@ -10,7 +10,7 @@
 
 //! Operations on ASCII strings and characters
 
-use to_str::{ToStr,IntoStr};
+use to_str::{ToStr, IntoStr};
 use str;
 use str::Str;
 use str::StrSlice;

branches/try2/src/libstd/cell.rs

@@ -10,7 +10,10 @@
 
 //! Types dealing with dynamic mutability
 
-use prelude::*;
+use clone::{Clone, DeepClone};
+use cmp::Eq;
+use ops::Drop;
+use option::{None, Option, Some};
 use cast;
 use kinds::{marker, Pod};
 

branches/try2/src/libstd/local_data.rs

@@ -41,7 +41,9 @@ local_data::get(key_vector, |opt| assert_eq!(*opt.unwrap(), ~[4]));
 // magic.
 
 use cast;
-use prelude::*;
+use option::{None, Option, Some};
+use vec::{ImmutableVector, MutableVector, OwnedVector};
+use iter::{Iterator};
 use rt::task::{Task, LocalStorage};
 use util::replace;
 

branches/try2/src/libstd/os.rs

@@ -28,20 +28,31 @@
 
 #[allow(missing_doc)];
 
-use clone::Clone;
-use container::Container;
 #[cfg(target_os = "macos")]
+#[cfg(windows)]
 use iter::range;
+
+use clone::Clone;
+use container::Container;
 use libc;
 use libc::{c_char, c_void, c_int};
-use option::{Some, None};
+use option::{Some, None, Option};
 use os;
-use prelude::*;
+use ops::Drop;
+use result::{Err, Ok, Result};
 use ptr;
 use str;
+use str::{Str, StrSlice};
 use fmt;
 use unstable::finally::Finally;
 use sync::atomics::{AtomicInt, INIT_ATOMIC_INT, SeqCst};
+use path::{Path, GenericPath};
+use iter::Iterator;
+use vec::{Vector, CloneableVector, ImmutableVector, MutableVector, OwnedVector};
+use ptr::RawPtr;
+
+#[cfg(unix)]
+use c_str::ToCStr;
 
 /// Delegates to the libc close() function, returning the same return value.
 pub fn close(fd: int) -> int {
@@ -396,6 +407,8 @@ pub fn self_exe_name() -> Option<Path> {
 
     #[cfg(windows)]
     fn load_self() -> Option<~[u8]> {
+        use str::OwnedStr;
+
         unsafe {
             use os::win32::fill_utf16_buf_and_decode;
             fill_utf16_buf_and_decode(|buf, sz| {
@@ -967,6 +980,7 @@ impl MemoryMap {
     /// `ErrZeroLength`.
     pub fn new(min_len: uint, options: &[MapOption]) -> Result<MemoryMap, MapError> {
         use libc::off_t;
+        use cmp::Equiv;
 
         if min_len == 0 {
             return Err(ErrZeroLength)

branches/try2/src/libstd/reference.rs

@@ -11,7 +11,7 @@
 //! Utilities for references
 
 #[cfg(not(test))]
-use prelude::*;
+use cmp::{Eq, Ord, Ordering, TotalEq, TotalOrd};
 
 // Equality for region pointers
 #[cfg(not(test))]

branches/try2/src/libstd/run.rs

@@ -20,7 +20,13 @@ use io::process;
 use io;
 use libc::{pid_t, c_int};
 use libc;
-use prelude::*;
+use option::{None, Option, Some};
+use task::spawn;
+use path::{Path, GenericPath};
+use result::Ok;
+use str::Str;
+use vec::Vector;
+use clone::Clone;
 
 /**
  * A value representing a child process.