---

yaml
---
r: 103950
b: refs/heads/try
c: ec2f047
h: refs/heads/master
v: v3

Author: adrientetar

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 62f1d68439dcfd509eaca29887afa97f22938373
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
-refs/heads/try: 1fd2d7786013f98c59f099a2a0413b61a6e82d9d
+refs/heads/try: ec2f047aa9a09926b9c4192c447f44dda484ee6d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/.gitignore

@@ -75,7 +75,6 @@ src/.DS_Store
 /nd/
 /llvm/
 version.md
-*.tex
 keywords.md
 x86_64-apple-darwin/
 x86_64-unknown-linux-gnu/

branches/try/mk/docs.mk

@@ -19,8 +19,10 @@ HTML_DEPS := doc/
 
 BASE_DOC_OPTS := --standalone --toc --number-sections
 HTML_OPTS = $(BASE_DOC_OPTS) --to=html5 --section-divs --css=rust.css \
-    --include-before-body=doc/version_info.html --include-in-header=doc/favicon.inc
-TEX_OPTS = $(BASE_DOC_OPTS) --include-before-body=doc/version.md --to=latex
+    --include-before-body=doc/version_info.html \
+    --include-in-header=doc/favicon.inc --include-after-body=doc/footer.inc
+TEX_OPTS = $(BASE_DOC_OPTS) --include-before-body=doc/version.md \
+    --from=markdown --include-before-body=doc/footer.tex --to=latex
 EPUB_OPTS = $(BASE_DOC_OPTS) --to=epub
 
 D := $(S)src/doc
@@ -55,12 +57,21 @@ doc/rust.css: $(D)/rust.css | doc/
 	@$(call E, cp: $@)
 	$(Q)cp -a $< $@ 2> /dev/null
 
+HTML_DEPS += doc/favicon.inc
+doc/favicon.inc: $(D)/favicon.inc | doc/
+	@$(call E, cp: $@)
+	$(Q)cp -a $< $@ 2> /dev/null
+
 doc/full-toc.inc: $(D)/full-toc.inc | doc/
 	@$(call E, cp: $@)
 	$(Q)cp -a $< $@ 2> /dev/null
 
-HTML_DEPS += doc/favicon.inc
-doc/favicon.inc: $(D)/favicon.inc | doc/
+HTML_DEPS += doc/footer.inc
+doc/footer.inc: $(D)/footer.inc | doc/
+	@$(call E, cp: $@)
+	$(Q)cp -a $< $@ 2> /dev/null
+
+doc/footer.tex: $(D)/footer.tex | doc/
 	@$(call E, cp: $@)
 	$(Q)cp -a $< $@ 2> /dev/null
 
@@ -83,7 +94,7 @@ doc/rust.html: $(D)/rust.md doc/full-toc.inc $(HTML_DEPS) | doc/
 	$(CFG_PANDOC) $(HTML_OPTS) --include-in-header=doc/full-toc.inc --output=$@
 
 DOCS += doc/rust.tex
-doc/rust.tex: $(D)/rust.md doc/version.md | doc/
+doc/rust.tex: $(D)/rust.md doc/footer.tex doc/version.md | doc/
 	@$(call E, pandoc: $@)
 	$(Q)$(CFG_NODE) $(D)/prep.js $< | \
 	$(CFG_PANDOC) $(TEX_OPTS) --output=$@
@@ -107,7 +118,7 @@ doc/tutorial.html: $(D)/tutorial.md $(HTML_DEPS)
 	$(CFG_PANDOC) $(HTML_OPTS) --output=$@
 
 DOCS += doc/tutorial.tex
-doc/tutorial.tex: $(D)/tutorial.md doc/version.md
+doc/tutorial.tex: $(D)/tutorial.md doc/footer.tex doc/version.md
 	@$(call E, pandoc: $@)
 	$(Q)$(CFG_NODE) $(D)/prep.js $< | \
 	$(CFG_PANDOC) $(TEX_OPTS) --output=$@

branches/try/mk/tests.mk

@@ -242,6 +242,7 @@ 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/try/src/doc/footer.inc

@@ -0,0 +1,7 @@
+<footer><p>
+Copyright &copy; 2011-2014 The Rust Project Developers. Licensed under the
+<a href="http://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0</a>
+or the <a href="http://opensource.org/licenses/MIT">MIT license</a>, at your option.
+</p><p>
+This file may not be copied, modified, or distributed except according to those terms.
+</p></footer>

branches/try/src/doc/footer.tex

@@ -0,0 +1,7 @@
+Copyright © 2011-2014 The Rust Project Developers. Licensed under the
+\href{http://www.apache.org/licenses/LICENSE-2.0}{Apache License,
+Version 2.0} or the \href{http://opensource.org/licenses/MIT}{MIT
+license}, at your option.
+
+This file may not be copied, modified, or distributed except according
+to those terms.

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

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

branches/try/src/doc/rust.css

@@ -15,7 +15,6 @@
 body {
     margin: 0 auto;
     padding: 0 15px;
-    margin-bottom: 4em;
     font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
     font-size: 14px;
     color: #333;
@@ -76,6 +75,15 @@ p {
     margin: 0 0 10px;
 }
 
+footer {
+    border-top: 1px solid #ddd;
+    font-size: 12px;
+    font-style: italic;
+    padding-top: 4px;
+    margin-top: 4em;
+    margin-bottom: 1em;
+}
+
 /* Links layout
    ========================================================================== */
 a {

branches/try/src/etc/tidy.py

@@ -14,9 +14,6 @@
 
 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" ],
@@ -49,22 +46,12 @@ 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:
@@ -85,16 +72,16 @@ def do_license_check(name, contents):
                 if "SNAP" in line:
                     report_warn("unmatched SNAP line: " + line)
 
-        if check_tab and (line.find('\t') != -1 and
+        if (line.find('\t') != -1 and
             fileinput.filename().find("Makefile") == -1):
             report_err("tab character")
-        if check_cr and not autocrlf and line.find('\r') != -1:
+        if 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 check_linelength and line_len > cols:
+        if line_len > cols:
             report_err("line longer than %d chars" % cols)
 
         if fileinput.isfirstline() and current_name != "":
@@ -103,9 +90,6 @@ 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/try/src/libgreen/lib.rs

@@ -12,156 +12,10 @@
 //!
 //! 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. This can be optionally linked in to rust
-//! programs in order to provide M:N functionality inside of 1:1 programs.
+//! stack-allocation strategy.
 //!
-//! # 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();
-//! ```
+//! This can be optionally linked in to rust programs in order to provide M:N
+//! functionality inside of 1:1 programs.
 
 #[crate_id = "green#0.10-pre"];
 #[license = "MIT/ASL2"];

branches/try/src/libnative/lib.rs

@@ -8,38 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! The native I/O and threading crate
+//! The native runtime 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"];