---

yaml
---
r: 7093
b: refs/heads/master
c: 98f5109
h: refs/heads/master
i:
  7091: 755c54d
v: v3

Author: nikomatsakis

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: e88905cd2882919f95084f41539ca9601ebf5cfc
+refs/heads/master: 98f5109cde838e66d629bf05c804ad1ca9b06c42

trunk/src/comp/middle/trans_closure.rs

@@ -33,7 +33,7 @@ import trans::{
 // struct closure_box {
 //    unsigned ref_count; // only used for sharid environments
 //    struct closure {
-//      type_desc *tydesc;         // descriptor for the env type
+//      type_desc *tydesc;         // descriptor for the "struct closure" type
 //      type_desc *bound_tdescs[]; // bound descriptors
 //      struct {
 //          upvar1_t upvar1;

trunk/src/libcore/task.rs

@@ -31,6 +31,7 @@ import comm;
 import option::{some, none};
 import option = option::t;
 import ptr;
+import c = ctypes;
 
 export task;
 export joinable_task;
@@ -46,7 +47,6 @@ export tr_success;
 export tr_failure;
 export get_task;
 export spawn;
-export spawn_notify;
 export spawn_joinable;
 
 #[abi = "rust-intrinsic"]
@@ -55,6 +55,10 @@ native mod rusti {
     fn task_sleep(task: *rust_task, time_in_us: uint, &killed: bool);
 }
 
+type rust_closure = {
+    fnptr: c::intptr_t, envptr: c::intptr_t
+};
+
 #[link_name = "rustrt"]
 #[abi = "cdecl"]
 native mod rustrt {
@@ -70,8 +74,7 @@ native mod rustrt {
 
     fn migrate_alloc(alloc: *u8, target: task_id);
 
-    fn start_task(id: task, closure: *u8);
-
+    fn start_task(id: task, closure: *rust_closure);
 }
 
 /* Section: Types */
@@ -93,13 +96,60 @@ A handle to a task
 */
 type task = task_id;
 
+/*
+Function: spawn
+
+Creates and executes a new child task
+
+Sets up a new task with its own call stack and schedules it to be
+executed.  Upon execution, the closure `f()` will be invoked.
+
+Parameters:
+
+f - A function to execute in the new task
+
+Returns:
+
+A handle to the new task
+*/
+fn spawn(-f: sendfn()) -> task unsafe {
+    let closure: *rust_closure = unsafe::reinterpret_cast(ptr::addr_of(f));
+    #debug("spawn: closure={%x,%x}", (*closure).fnptr, (*closure).envptr);
+    let id = rustrt::new_task();
+    rustrt::start_task(id, closure);
+    unsafe::leak(f);
+    ret id;
+}
+
 /*
 Type: joinable_task
 
 A task that sends notification upon termination
 */
 type joinable_task = (task, comm::port<task_notification>);
 
+fn spawn_joinable(-f: sendfn()) -> joinable_task {
+    resource notify_rsrc(data: (comm::chan<task_notification>,
+                                task,
+                                @mutable task_result)) {
+        let (chan, task, tr) = data;
+        let msg = exit(task, *tr);
+        comm::send(chan, msg);
+    }
+
+    let notify_port = comm::port();
+    let notify_chan = comm::chan(notify_port);
+    let g = sendfn[copy notify_chan; move f]() {
+        let this_task = rustrt::get_task_id();
+        let result = @mutable tr_failure;
+        let _rsrc = notify_rsrc((notify_chan, this_task, result));
+        f();
+        *result = tr_success; // rsrc will fire msg when fn returns
+    };
+    let task = spawn(g);
+    ret (task, notify_port);
+}
+
 /*
 Tag: task_result
 
@@ -213,130 +263,6 @@ Unpin the current task and future child tasks
 */
 fn unpin() { rustrt::unpin_task(); }
 
-/*
-Function: spawn
-
-Creates and executes a new child task
-
-Sets up a new task with its own call stack and schedules it to be executed.
-Upon execution the new task will call function `f` with the provided
-argument `data`.
-
-Function `f` is a bare function, meaning it may not close over any data, as do
-shared functions (fn@) and lambda blocks. `data` must be a uniquely owned
-type; it is moved into the new task and thus can no longer be accessed
-locally.
-
-Parameters:
-
-data - A unique-type value to pass to the new task
-f - A function to execute in the new task
-
-Returns:
-
-A handle to the new task
-*/
-fn spawn<T: send>(-data: T, f: fn(T)) -> task {
-    spawn_inner(data, f, none)
-}
-
-/*
-Function: spawn_notify
-
-Create and execute a new child task, requesting notification upon its
-termination
-
-Immediately before termination, either on success or failure, the spawned
-task will send a <task_notification> message on the provided channel.
-*/
-fn spawn_notify<T: send>(-data: T, f: fn(T),
-                         notify: comm::chan<task_notification>) -> task {
-    spawn_inner(data, f, some(notify))
-}
-
-/*
-Function: spawn_joinable
-
-Create and execute a task which can later be joined with the <join> function
-
-This is a convenience wrapper around spawn_notify which, when paired
-with <join> can be easily used to spawn a task then wait for it to
-complete.
-*/
-fn spawn_joinable<T: send>(-data: T, f: fn(T)) -> joinable_task {
-    let p = comm::port::<task_notification>();
-    let id = spawn_notify(data, f, comm::chan::<task_notification>(p));
-    ret (id, p);
-}
-
-// FIXME: To transition from the unsafe spawn that spawns a shared closure to
-// the safe spawn that spawns a bare function we're going to write
-// barefunc-spawn on top of unsafe-spawn.  Sadly, bind does not work reliably
-// enough to suite our needs (#1034, probably others yet to be discovered), so
-// we're going to copy the bootstrap data into a unique pointer, cast it to an
-// unsafe pointer then wrap up the bare function and the unsafe pointer in a
-// shared closure to spawn.
-//
-// After the transition this should all be rewritten.
-
-fn spawn_inner<T: send>(-data: T, f: fn(T),
-                          notify: option<comm::chan<task_notification>>)
-    -> task unsafe {
-
-    fn wrapper<T: send>(data: *u8, f: fn(T)) unsafe {
-        let data: ~T = unsafe::reinterpret_cast(data);
-        f(*data);
-    }
-
-    let data = ~data;
-    let dataptr: *u8 = unsafe::reinterpret_cast(data);
-    unsafe::leak(data);
-    let wrapped = bind wrapper(dataptr, f);
-    ret unsafe_spawn_inner(wrapped, notify);
-}
-
-// FIXME: This is the old spawn function that spawns a shared closure.
-// It is a hack and needs to be rewritten.
-fn unsafe_spawn_inner(-thunk: fn@(),
-                      notify: option<comm::chan<task_notification>>) ->
-   task unsafe {
-    let id = rustrt::new_task();
-
-    let raw_thunk: {code: uint, env: uint} = cast(thunk);
-
-    // set up the task pointer
-    let task_ptr <- rust_task_ptr(rustrt::get_task_pointer(id));
-
-    assert (ptr::null() != (**task_ptr).stack_ptr);
-
-    // copy the thunk from our stack to the new stack
-    let sp: uint = cast((**task_ptr).stack_ptr);
-    let ptrsize = sys::size_of::<*u8>();
-    let thunkfn: *mutable uint = cast(sp - ptrsize * 2u);
-    let thunkenv: *mutable uint = cast(sp - ptrsize);
-    *thunkfn = cast(raw_thunk.code);;
-    *thunkenv = cast(raw_thunk.env);;
-    // Advance the stack pointer. No need to align because
-    // the native code will do that for us
-    (**task_ptr).stack_ptr = cast(sp - ptrsize * 2u);
-
-    // set up notifications if they are enabled.
-    alt notify {
-      some(c) {
-        (**task_ptr).notify_enabled = 1;
-        (**task_ptr).notify_chan = c;
-      }
-      none { }
-    }
-
-    // give the thunk environment's allocation to the new task
-    rustrt::migrate_alloc(cast(raw_thunk.env), id);
-    rustrt::start_task(id, cast(thunkfn));
-    // don't cleanup the thunk in this task
-    unsafe::leak(thunk);
-    ret id;
-}
-
 // Local Variables:
 // mode: rust;
 // fill-column: 78;

trunk/src/libstd/test.rs

@@ -49,7 +49,7 @@ type test_name = str;
 // to support isolation of tests into tasks.
 type test_fn<T> = T;
 
-type default_test_fn = test_fn<fn()>;
+type default_test_fn = test_fn<sendfn()>;
 
 // The definition of a single test. A test runner will run a list of
 // these.
@@ -336,11 +336,10 @@ fn run_test<T: copy>(test: test_desc<T>,
 // We need to run our tests in another task in order to trap test failures.
 // This function only works with functions that don't contain closures.
 fn default_test_to_task(&&f: default_test_fn) -> joinable {
-    fn run_task(f: default_test_fn) {
+    ret task::spawn_joinable(sendfn[copy f]() {
         configure_test_task();
         f();
-    }
-    ret task::spawn_joinable(copy f, run_task);
+    });
 }
 
 // Call from within a test task to make sure it's set up correctly

trunk/src/rt/rust.cpp

@@ -98,7 +98,7 @@ rust_start(uintptr_t main_fn, int argc, char **argv, void* crate_map) {
         DLOG(sched, dom, "startup: arg[%d] = '%s'", i, args->argv[i]);
     }
 
-    root_task->start(main_fn, (uintptr_t)args->args);
+    root_task->start((spawn_fn)main_fn, (uintptr_t)args->args);
     root_task->deref();
     root_task = NULL;
 
@@ -119,6 +119,5 @@ rust_start(uintptr_t main_fn, int argc, char **argv, void* crate_map) {
 // indent-tabs-mode: nil
 // c-basic-offset: 4
 // buffer-file-coding-system: utf-8-unix
-// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
 // End:
 //

trunk/src/rt/rust_builtin.cpp

@@ -2,6 +2,7 @@
 
 #include "rust_internal.h"
 #include "rust_scheduler.h"
+#include "rust_task.h"
 
 #if !defined(__WIN32__)
 #include <sys/time.h>
@@ -424,18 +425,11 @@ struct fn_env_pair {
     intptr_t env;
 };
 
-// FIXME This is probably not needed at all anymore. Have to rearrange some
-// argument passing to remove it.
-void rust_spawn_wrapper(void* retptr, void* envptr,
-                        void(*func)(void*, void*)) {
-    func(retptr, envptr);
-}
-
 extern "C" CDECL void
 start_task(rust_task_id id, fn_env_pair *f) {
     rust_task *task = rust_scheduler::get_task();
     rust_task *target = task->kernel->get_task_by_id(id);
-    target->start((uintptr_t)rust_spawn_wrapper, f->f, f->env);
+    target->start((spawn_fn)f->f, f->env);
     target->deref();
 }
 
@@ -578,6 +572,5 @@ port_recv(uintptr_t *dptr, rust_port *port,
 // indent-tabs-mode: nil
 // c-basic-offset: 4
 // buffer-file-coding-system: utf-8-unix
-// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
 // End:
 //