---

yaml
---
r: 4724
b: refs/heads/master
c: 89df915
h: refs/heads/master
v: v3

Author: Eric Holk

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 862bc521a16ac764bee4446f60858459c6e04860
+refs/heads/master: 89df915a13454fbc9f51832394c7032716f70935

trunk/src/comp/back/upcall.rs

@@ -26,19 +26,8 @@ import lib::llvm::llvm::TypeRef;
 
 type upcalls =
     {grow_task: ValueRef,
-     new_port: ValueRef,
-     del_port: ValueRef,
-     new_chan: ValueRef,
-     flush_chan: ValueRef,
-     drop_chan: ValueRef,
-     take_chan: ValueRef,
-     del_chan: ValueRef,
-     clone_chan: ValueRef,
-     chan_target_task: ValueRef,
      _yield: ValueRef,
      sleep: ValueRef,
-     send: ValueRef,
-     recv: ValueRef,
      _fail: ValueRef,
      kill: ValueRef,
      exit: ValueRef,
@@ -48,14 +37,9 @@ type upcalls =
      shared_free: ValueRef,
      mark: ValueRef,
      new_str: ValueRef,
-     dup_str: ValueRef,
      new_vec: ValueRef,
      vec_append: ValueRef,
      get_type_desc: ValueRef,
-     new_task: ValueRef,
-     take_task: ValueRef,
-     drop_task: ValueRef,
-     start_task: ValueRef,
      ivec_resize: ValueRef,
      ivec_spill: ValueRef,
      ivec_resize_shared: ValueRef,
@@ -83,23 +67,8 @@ fn declare_upcalls(tn: type_names, tydesc_type: TypeRef,
 
     let empty_vec: [TypeRef] = ~[];
     ret @{grow_task: dv("grow_task", ~[T_size_t()]),
-          new_port: d("new_port", ~[T_size_t()], T_opaque_port_ptr()),
-          del_port: dv("del_port", ~[T_opaque_port_ptr()]),
-          new_chan:
-              d("new_chan", ~[T_opaque_port_ptr()], T_opaque_chan_ptr()),
-          flush_chan: dv("flush_chan", ~[T_opaque_chan_ptr()]),
-          drop_chan: dv("drop_chan", ~[T_opaque_chan_ptr()]),
-          take_chan: dv("take_chan", ~[T_opaque_chan_ptr()]),
-          del_chan: dv("del_chan", ~[T_opaque_chan_ptr()]),
-          clone_chan:
-              d("clone_chan", ~[taskptr_type, T_opaque_chan_ptr()],
-                T_opaque_chan_ptr()),
-          chan_target_task:
-              d("chan_target_task", ~[T_opaque_chan_ptr()], taskptr_type),
           _yield: dv("yield", empty_vec),
           sleep: dv("sleep", ~[T_size_t()]),
-          send: dv("send", ~[T_opaque_chan_ptr(), T_ptr(T_i8())]),
-          recv: dv("recv", ~[T_ptr(T_ptr(T_i8())), T_opaque_port_ptr()]),
           _fail: dv("fail", ~[T_ptr(T_i8()), T_ptr(T_i8()), T_size_t()]),
           kill: dv("kill", ~[taskptr_type]),
           exit: dv("exit", empty_vec),
@@ -112,8 +81,6 @@ fn declare_upcalls(tn: type_names, tydesc_type: TypeRef,
           shared_free: dv("shared_free", ~[T_ptr(T_i8())]),
           mark: d("mark", ~[T_ptr(T_i8())], T_int()),
           new_str: d("new_str", ~[T_ptr(T_i8()), T_size_t()], T_ptr(T_str())),
-          dup_str:
-              d("dup_str", ~[taskptr_type, T_ptr(T_str())], T_ptr(T_str())),
           new_vec:
               d("new_vec", ~[T_size_t(), T_ptr(tydesc_type)],
                 T_opaque_vec_ptr()),
@@ -126,12 +93,6 @@ fn declare_upcalls(tn: type_names, tydesc_type: TypeRef,
               d("get_type_desc",
                 ~[T_ptr(T_nil()), T_size_t(), T_size_t(), T_size_t(),
                   T_ptr(T_ptr(tydesc_type))], T_ptr(tydesc_type)),
-          new_task: d("new_task", ~[T_ptr(T_str())], taskptr_type),
-          take_task: dv("take_task", ~[taskptr_type]),
-          drop_task: dv("drop_task", ~[taskptr_type]),
-          start_task:
-              d("start_task", ~[taskptr_type, T_int(), T_int(), T_size_t()],
-                taskptr_type),
           ivec_resize:
               d("ivec_resize", ~[T_ptr(T_opaque_ivec()), T_int()], T_void()),
           ivec_spill:

trunk/src/rt/rust_upcall.cpp

@@ -70,80 +70,6 @@ upcall_log_istr(rust_task *task, uint32_t level, rust_ivec *str) {
     task->sched->log(task, level, "rust: %s", buf);
 }
 
-extern "C" CDECL rust_port*
-new_port(rust_task *task, size_t unit_sz);
-extern "C" CDECL rust_port*
-upcall_new_port(rust_task *task, size_t unit_sz) {
-    LOG_UPCALL_ENTRY(task);
-    LOG(task, comm, "upcall_new_port(task=0x%" PRIxPTR " (%s), unit_sz=%d)",
-        (uintptr_t) task, task->name, unit_sz);
-    return new_port(task, unit_sz);
-}
-
-extern "C" CDECL void
-del_port(rust_task *task, rust_port *port);
-extern "C" CDECL void
-upcall_del_port(rust_task *task, rust_port *port) {
-    LOG_UPCALL_ENTRY(task);
-    return del_port(task, port);
-}
-
-/**
- * Creates a new channel pointing to a given port.
- */
-extern "C" CDECL rust_chan*
-new_chan(rust_task *task, rust_port *port);
-extern "C" CDECL rust_chan*
-upcall_new_chan(rust_task *task, rust_port *port) {
-    LOG_UPCALL_ENTRY(task);
-    return new_chan(task, port);
-}
-
-/**
- * Called whenever this channel needs to be flushed. This can happen due to a
- * flush statement, or automatically whenever a channel's ref count is
- * about to drop to zero.
- */
-extern "C" CDECL void
-upcall_flush_chan(rust_task *task, rust_chan *chan) {
-    LOG_UPCALL_ENTRY(task);
-}
-
-/**
- * Called whenever the channel's ref count drops to zero.
- *
- * Cannot Yield: If the task were to unwind, the dropped ref would still
- * appear to be live, causing modify-after-free errors.
- */
-extern "C" CDECL
-void del_chan(rust_task *task, rust_chan *chan);
-extern "C" CDECL
-void upcall_del_chan(rust_task *task, rust_chan *chan) {
-    LOG_UPCALL_ENTRY(task);
-    del_chan(task, chan);
-}
-
-/**
- * Clones a channel and stores it in the spawnee's domain. Each spawned task
- * has its own copy of the channel.
- */
-extern "C" CDECL rust_chan *
-upcall_clone_chan(rust_task *task, rust_task_id tid,
-                  rust_chan *chan) {
-    // FIXME: This should be removed.
-    LOG_UPCALL_ENTRY(task);
-    rust_task *target = task->kernel->get_task_by_id(tid);
-    rust_chan *c = chan->clone(target);
-    target->deref();
-    return c;
-}
-
-extern "C" CDECL rust_task *
-upcall_chan_target_task(rust_task *task, rust_chan *chan) {
-    LOG_UPCALL_ENTRY(task);
-    return chan->port->task;
-}
-
 extern "C" CDECL void
 upcall_yield(rust_task *task) {
     LOG_UPCALL_ENTRY(task);
@@ -160,24 +86,6 @@ upcall_sleep(rust_task *task, size_t time_in_us) {
     task->yield(time_in_us);
 }
 
-/**
- * Buffers a chunk of data in the specified channel.
- *
- * sptr: pointer to a chunk of data to buffer
- */
-extern "C" CDECL void
-upcall_send(rust_task *task, rust_chan *chan, void *sptr) {
-    LOG_UPCALL_ENTRY(task);
-    chan->send(sptr);
-    LOG(task, comm, "=== sent data ===>");
-}
-
-extern "C" CDECL void
-upcall_recv(rust_task *task, uintptr_t *dptr, rust_port *port) {
-    LOG_UPCALL_ENTRY(task);
-    port_recv(task, dptr, port);
-}
-
 extern "C" CDECL void
 upcall_fail(rust_task *task,
             char const *expr,
@@ -314,15 +222,6 @@ upcall_new_str(rust_task *task, char const *s, size_t fill) {
     return make_str(task, s, fill);
 }
 
-extern "C" CDECL rust_str *
-upcall_dup_str(rust_task *task, rust_task_id tid, rust_str *str) {
-    LOG_UPCALL_ENTRY(task);
-    rust_task *target = task->kernel->get_task_by_id(tid);
-    rust_str *s = make_str(target, (char const *)str->data, str->fill);
-    target->deref();
-    return s;
-}
-
 extern "C" CDECL rust_vec *
 upcall_new_vec(rust_task *task, size_t fill, type_desc *td) {
     LOG_UPCALL_ENTRY(task);
@@ -477,80 +376,6 @@ upcall_get_type_desc(rust_task *task,
     return td;
 }
 
-extern "C" CDECL rust_task_id
-upcall_new_task(rust_task *spawner, rust_vec *name) {
-    // name is a rust string structure.
-    LOG_UPCALL_ENTRY(spawner);
-    rust_task_id tid =
-        spawner->kernel->create_task(spawner, (const char *)name->data);
-    // let the kernel bump the ref count.
-    spawner->kernel->get_task_by_id(tid);
-    // no deref because we're letting the caller take ownership.
-    return tid;
-}
-
-extern "C" CDECL void
-upcall_take_task(rust_task *task, rust_task_id tid) {
-    LOG_UPCALL_ENTRY(task);
-    // get_task_by_id increments the refcount.
-    task->kernel->get_task_by_id(tid);
-}
-
-extern "C" CDECL void
-drop_task(rust_task *task, rust_task_id tid);
-extern "C" CDECL void
-upcall_drop_task(rust_task *task, rust_task_id tid) {
-    LOG_UPCALL_ENTRY(task);
-    drop_task(task, tid);
-}
-
-extern "C" CDECL void
-upcall_take_chan(rust_task *task, rust_chan *target) {
-    LOG_UPCALL_ENTRY(task);
-    if(target) {
-        target->ref();
-    }
-}
-
-extern "C" CDECL void
-upcall_drop_chan(rust_task *task, rust_chan *target) {
-    LOG_UPCALL_ENTRY(task);
-    if(target) {
-        target->deref();
-    }
-}
-
-extern "C" CDECL rust_task *
-upcall_start_task(rust_task *spawner,
-                  rust_task_id tid,
-                  uintptr_t spawnee_fn,
-                  uintptr_t args,
-                  size_t args_sz) {
-    LOG_UPCALL_ENTRY(spawner);
-
-    rust_scheduler *sched = spawner->sched;
-    rust_task *task = spawner->kernel->get_task_by_id(tid);
-    DLOG(sched, task,
-         "upcall start_task(task %s @0x%" PRIxPTR
-         ", spawnee 0x%" PRIxPTR ")",
-         task->name, task,
-         spawnee_fn);
-
-    // we used to be generating this tuple in rustc, but it's easier to do it
-    // here.
-    //
-    // The args tuple is stack-allocated. We need to move it over to the new
-    // stack.
-    task->rust_sp -= args_sz;
-    uintptr_t child_arg = (uintptr_t)task->rust_sp;
-
-    memcpy((void*)task->rust_sp, (void*)args, args_sz);
-
-    task->start(spawnee_fn, child_arg);
-    task->deref();
-    return task;
-}
-
 /**
  * Resizes an interior vector that has been spilled to the heap.
  */

trunk/src/rt/rustrt.def.in

@@ -82,17 +82,9 @@ task_sleep
 task_yield
 task_join
 unsupervise
-upcall_chan_target_task
-upcall_clone_chan
 upcall_cmp_type
-upcall_del_chan
-upcall_del_port
-upcall_drop_chan
-upcall_drop_task
-upcall_dup_str
 upcall_exit
 upcall_fail
-upcall_flush_chan
 upcall_free
 upcall_get_type_desc
 upcall_grow_task
@@ -107,19 +99,10 @@ upcall_log_str
 upcall_log_type
 upcall_malloc
 upcall_mark
-upcall_new_chan
-upcall_new_port
 upcall_new_str
-upcall_new_task
 upcall_new_vec
-upcall_recv
-upcall_send
 upcall_shared_malloc
 upcall_shared_free
 upcall_sleep
-upcall_start_task
-upcall_take_task
-upcall_take_chan
 upcall_vec_append
 upcall_yield
-