import option::{some, none};
import option = option::t;
import ptr;
+import c = ctypes;
export task;
export joinable_task;
export tr_failure;
export get_task;
export spawn;
-export spawn_notify;
export spawn_joinable;
#[abi = "rust-intrinsic"]
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 {
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 */
*/
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
*/
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
*/
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;
struct spawn_args {
rust_task *task;
- uintptr_t a3;
- uintptr_t a4;
- void (*CDECL f)(int *, uintptr_t, uintptr_t);
+ uintptr_t envptr;
+ spawn_fn f;
};
-struct rust_closure_env {
+struct rust_closure {
+ const type_desc *td;
+ // ... see trans_closure.rs for full description ...
+};
+
+struct rust_boxed_closure {
intptr_t ref_count;
- type_desc *td;
+ rust_closure closure;
};
struct cleanup_args {
cc::do_cc(task);
- rust_closure_env* env = (rust_closure_env*)a->a3;
- if(env) {
+ rust_boxed_closure* boxed_env = (rust_boxed_closure*)a->envptr;
+ if(boxed_env) {
// free the environment.
- I(task->sched, 1 == env->ref_count); // the ref count better be 1
- //env->td->drop_glue(NULL, task, NULL, env->td->first_param, env);
- //env->td->free_glue(NULL, task, NULL, env->td->first_param, env);
- task->free(env);
+ rust_closure *env = &boxed_env->closure;
+ env->td->drop_glue(NULL, NULL, &env->td, env);
+ env->td->free_glue(NULL, NULL, &env->td, env);
}
task->die();
void task_start_wrapper(spawn_args *a)
{
rust_task *task = a->task;
- int rval = 42;
bool failed = false;
try {
- a->f(&rval, a->a3, a->a4);
+ // The first argument is the return pointer; as the task fn
+ // must have void return type, we can safely pass 0.
+ a->f(0, a->envptr);
} catch (rust_task *ex) {
A(task->sched, ex == task,
"Expected this task to be thrown for unwinding");
}
void
-rust_task::start(uintptr_t spawnee_fn,
- uintptr_t args,
+rust_task::start(spawn_fn spawnee_fn,
uintptr_t env)
{
LOG(this, task, "starting task from fn 0x%" PRIxPTR
- " with args 0x%" PRIxPTR, spawnee_fn, args);
+ " with env 0x%" PRIxPTR, spawnee_fn, env);
I(sched, stk->data != NULL);
spawn_args *a = (spawn_args *)sp;
a->task = this;
- a->a3 = env;
- a->a4 = args;
- void **f = (void **)&a->f;
- *f = (void *)spawnee_fn;
+ a->envptr = env;
+ a->f = spawnee_fn;
ctx.call((void *)task_start_wrapper, a, sp);
this->start();
}
-void
-rust_task::start(uintptr_t spawnee_fn,
- uintptr_t args)
-{
- start(spawnee_fn, args, 0);
-}
-
void rust_task::start()
{
yield_timer.reset_us(0);
projects / rust.git / commitdiff