---

yaml
---
r: 6897
b: refs/heads/master
c: 854daae
h: refs/heads/master
i:
  6895: 5a713b2
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: bbc534bcccfc1904104a1fa275a6a873a7675cd1
+refs/heads/master: 854daaec0c4cf0c236e46b45a1254c85a8b352db

trunk/src/cargo/cargo.rs

@@ -31,7 +31,6 @@ type package = {
     uuid: str,
     url: str,
     method: str,
-    ref: option::t<str>,
     tags: [str]
 };
 
@@ -243,11 +242,6 @@ fn load_one_source_package(&src: source, p: map::hashmap<str, json::json>) {
         }
     };
 
-    let ref = alt p.find("ref") {
-        some(json::string(_n)) { some(_n) }
-        _ { none }
-    };
-
     let tags = [];
     alt p.find("tags") {
         some(json::list(js)) {
@@ -266,7 +260,6 @@ fn load_one_source_package(&src: source, p: map::hashmap<str, json::json>) {
         uuid: uuid,
         url: url,
         method: method,
-        ref: ref,
         tags: tags
     });
     log "  Loaded package: " + src.name + "/" + name;
@@ -405,14 +398,8 @@ fn install_source(c: cargo, path: str) {
     }
 }
 
-fn install_git(c: cargo, wd: str, url: str, ref: option::t<str>) {
+fn install_git(c: cargo, wd: str, url: str) {
     run::run_program("git", ["clone", url, wd]);
-    if option::is_some::<str>(ref) {
-        let r = option::get::<str>(ref);
-        fs::change_dir(wd);
-        run::run_program("git", ["checkout", r]);
-    }
-
     install_source(c, wd);
 }
 
@@ -437,7 +424,7 @@ fn install_file(c: cargo, wd: str, path: str) {
 fn install_package(c: cargo, wd: str, pkg: package) {
     info("Installing with " + pkg.method + " from " + pkg.url + "...");
     if pkg.method == "git" {
-        install_git(c, wd, pkg.url, pkg.ref);
+        install_git(c, wd, pkg.url);
     } else if pkg.method == "http" {
         install_curl(c, wd, pkg.url);
     } else if pkg.method == "file" {

trunk/src/cargo/sources.json

@@ -3,7 +3,7 @@
 		"url": "https://raw.github.com/graydon/cargo-central/master/packages.json"
 	},
 	"elly": {
-		"url": "https://raw.github.com/elly/rust-packages/master/packages.json"
+		"url": "https://raw.github.com/elly/rust-packages/master/packages.json",
 		"sig": "https://raw.github.com/elly/rust-packages/master/packages.json.sig",
 		"key": "https://raw.github.com/elly/rust-packages/master/signing-key.gpg",
 		"keyfp": "4107 21C0 FF32 858F 61FF  33F6 E595 8E36 FDC8 EA00"

trunk/src/libcore/core.rs

@@ -6,6 +6,7 @@
 import option::{some,  none};
 import option = option::t;
 export option, some, none;
+export repeat;
 
 // Export the log levels as global constants. Higher levels mean
 // more-verbosity. Error is the bottom level, default logging level is
@@ -15,3 +16,16 @@ const error : int = 0;
 const warn : int = 1;
 const info : int = 2;
 const debug : int = 3;
+
+/*
+Function: repeat
+
+Execute a function for a set number of times
+*/
+fn repeat(times: uint, f: block()) {
+    let i = 0u;
+    while i < times {
+        f();
+        i += 1u;
+    }
+}

trunk/src/rt/circular_buffer.h

@@ -7,7 +7,7 @@
 
 class
 circular_buffer : public kernel_owned<circular_buffer> {
-    static const size_t INITIAL_CIRCULAR_BUFFER_SIZE_IN_UNITS = 8;
+    static const size_t INITIAL_CIRCULAR_BUFFER_SIZE_IN_UNITS = 1;
     static const size_t MAX_CIRCULAR_BUFFER_SIZE = 1 << 24;
 
 public:

trunk/src/rt/rust_kernel.cpp

@@ -150,13 +150,11 @@ rust_kernel::fail() {
 
 rust_task_id
 rust_kernel::create_task(rust_task *spawner, const char *name) {
+    scoped_lock with(_kernel_lock);
     rust_scheduler *thread = threads[isaac_rand(&rctx) % num_threads];
     rust_task *t = thread->create_task(spawner, name);
-    {
-        scoped_lock with(_kernel_lock);
-        t->user.id = max_id++;
-        task_table.put(t->user.id, t);
-    }
+    t->user.id = max_id++;
+    task_table.put(t->user.id, t);
     return t->user.id;
 }
 

trunk/src/rt/rust_task.cpp

@@ -397,23 +397,16 @@ void rust_task::start()
     sched->lock.signal();
 }
 
-void
-rust_task::grow(size_t n_frame_bytes)
-{
-    // FIXME (issue #151): Just fail rather than almost certainly crashing
-    // mysteriously later. The commented-out logic below won't work at all in
-    // the presence of non-word-aligned pointers.
-    abort();
-
-}
-
 // Only run this on the rust stack
 void
 rust_task::yield(size_t time_in_us, bool *killed) {
     if (this->killed) {
         *killed = true;
     }
 
+    // We're not going to need any extra stack for a while
+    clear_stack_cache();
+
     yield_timer.reset_us(time_in_us);
 
     // Return to the scheduler.
@@ -756,6 +749,15 @@ rust_task::del_stack() {
     record_stack_limit();
 }
 
+void
+rust_task::clear_stack_cache() {
+    A(sched, stk != NULL, "Expected to have a stack");
+    if (stk->prev != NULL) {
+        free_stk(this, stk->prev);
+        stk->prev = NULL;
+    }
+}
+
 void
 rust_task::record_stack_limit() {
     // The function prolog compares the amount of stack needed to the end of

trunk/src/rt/rust_task.h

@@ -138,7 +138,6 @@ rust_task : public kernel_owned<rust_task>, rust_cond
     void start(uintptr_t spawnee_fn,
                uintptr_t args);
     void start();
-    void grow(size_t n_frame_bytes);
     bool running();
     bool blocked();
     bool blocked_on(rust_cond *cond);
@@ -204,6 +203,7 @@ rust_task : public kernel_owned<rust_task>, rust_cond
     void reset_stack_limit();
     bool on_rust_stack();
     void check_stack_canary();
+    void clear_stack_cache();
 };
 
 //

trunk/src/test/bench/task-perf-one-million.rs

@@ -0,0 +1,60 @@
+// xfail-test FIXME: Can't run under valgrind - too much RAM
+// FIXME: This doesn't spawn close to a million tasks yet
+
+tag msg {
+    ready(comm::chan<msg>);
+    start;
+    done(int);
+}
+
+fn calc(&&args: (int, comm::chan<msg>)) {
+    let (depth, parent_ch) = args;
+    let port = comm::port();
+    let children = depth > 0 ? 20u : 0u;
+    let child_chs = [];
+    let sum = 0;
+
+    repeat (children) {||
+        task::spawn((depth - 1, comm::chan(port)), calc);
+    }
+
+    repeat (children) {||
+        alt comm::recv(port) {
+          ready(child_ch) {
+            child_chs += [child_ch];
+          }
+        }
+    }
+
+    comm::send(parent_ch, ready(comm::chan(port)));
+
+    alt comm::recv(port) {
+        start. {
+          vec::iter (child_chs) { |child_ch|
+              comm::send(child_ch, start);
+          }
+        }
+    }
+
+    repeat (children) {||
+        alt comm::recv(port) {
+          done(child_sum) { sum += child_sum; }
+        }
+    }
+
+    comm::send(parent_ch, done(sum + 1));
+}
+
+fn main() {
+    let port = comm::port();
+    task::spawn((3, comm::chan(port)), calc);
+    alt comm::recv(port) {
+      ready(chan) {
+        comm::send(chan, start);
+      }
+    }
+    let sum = alt comm::recv(port) {
+      done(sum) { sum }
+    };
+    log #fmt("How many tasks? That's right, %d tasks.", sum);
+}