---

yaml
---
r: 4285
b: refs/heads/master
c: d1dbb99
h: refs/heads/master
i:
  4283: 8d930e0
v: v3

Author: Eric Holk

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: bc4e9afe2547fa88b55ffc31fef041dffe864b2b
+refs/heads/master: d1dbb99984064eedb77c0f55300430bcb35ce109

trunk/mk/rt.mk

@@ -18,7 +18,6 @@ RUNTIME_CS := rt/sync/timer.cpp \
               rt/rust_port.cpp \
               rt/rust_upcall.cpp \
               rt/rust_log.cpp \
-              rt/rust_message.cpp \
               rt/rust_timer.cpp \
               rt/circular_buffer.cpp \
               rt/isaac/randport.cpp \
@@ -44,9 +43,7 @@ RUNTIME_HDR := rt/globals.h \
                rt/rust_scheduler.h \
                rt/rust_task.h \
                rt/rust_task_list.h \
-               rt/rust_proxy.h \
                rt/rust_log.h \
-               rt/rust_message.h \
                rt/circular_buffer.h \
                rt/util/array_list.h \
                rt/util/indexed_list.h \

trunk/src/rt/rust.cpp

@@ -93,7 +93,6 @@ rust_start(uintptr_t main_fn, int argc, char **argv, void* crate_map) {
 
     rust_srv *srv = new rust_srv(env);
     rust_kernel *kernel = new rust_kernel(srv, env->num_sched_threads);
-    kernel->start();
     rust_task *root_task = kernel->create_task(NULL, "main");
     rust_scheduler *sched = root_task->sched;
     command_line_args *args

trunk/src/rt/rust_chan.cpp

@@ -4,7 +4,7 @@
 /**
  * Create a new rust channel and associate it with the specified port.
  */
-rust_chan::rust_chan(rust_kernel *kernel, maybe_proxy<rust_port> *port,
+rust_chan::rust_chan(rust_kernel *kernel, rust_port *port,
                      size_t unit_sz)
     : ref_count(1),
       kernel(kernel),
@@ -29,18 +29,16 @@ rust_chan::~rust_chan() {
 /**
  * Link this channel with the specified port.
  */
-void rust_chan::associate(maybe_proxy<rust_port> *port) {
+void rust_chan::associate(rust_port *port) {
     this->port = port;
-    if (port->is_proxy() == false) {
-        scoped_lock with(port->referent()->lock);
-        KLOG(kernel, task,
-            "associating chan: 0x%" PRIxPTR " with port: 0x%" PRIxPTR,
-            this, port);
-        ++this->ref_count;
-        this->task = port->referent()->task;
-        this->task->ref();
-        this->port->referent()->chans.push(this);
-    }
+    scoped_lock with(port->lock);
+    KLOG(kernel, task,
+         "associating chan: 0x%" PRIxPTR " with port: 0x%" PRIxPTR,
+         this, port);
+    ++this->ref_count;
+    this->task = port->task;
+    this->task->ref();
+    this->port->chans.push(this);
 }
 
 bool rust_chan::is_associated() {
@@ -52,19 +50,17 @@ bool rust_chan::is_associated() {
  */
 void rust_chan::disassociate() {
     A(kernel,
-      port->referent()->lock.lock_held_by_current_thread(),
+      port->lock.lock_held_by_current_thread(),
       "Port referent lock must be held to call rust_chan::disassociate");
     A(kernel, is_associated(),
       "Channel must be associated with a port.");
-    if (port->is_proxy() == false) {
-        KLOG(kernel, task,
-             "disassociating chan: 0x%" PRIxPTR " from port: 0x%" PRIxPTR,
-             this, port->referent());
-        --this->ref_count;
-        task->deref();
-        this->task = NULL;
-        port->referent()->chans.swap_delete(this);
-    }
+    KLOG(kernel, task,
+         "disassociating chan: 0x%" PRIxPTR " from port: 0x%" PRIxPTR,
+         this, port);
+    --this->ref_count;
+    task->deref();
+    this->task = NULL;
+    port->chans.swap_delete(this);
 
     // Delete reference to the port.
     port = NULL;
@@ -74,12 +70,7 @@ void rust_chan::disassociate() {
  * Attempt to send data to the associated port.
  */
 void rust_chan::send(void *sptr) {
-    I(kernel, !port->is_proxy());
-
-    rust_port *target_port = port->referent();
-    // TODO: We can probably avoid this lock by using atomic operations in
-    // circular_buffer.
-    scoped_lock with(target_port->lock);
+    scoped_lock with(port->lock);
 
     buffer.enqueue(sptr);
 
@@ -92,28 +83,17 @@ void rust_chan::send(void *sptr) {
     A(kernel, !buffer.is_empty(),
       "rust_chan::transmit with nothing to send.");
 
-    if (port->is_proxy()) {
-        data_message::send(buffer.peek(), buffer.unit_sz, "send data",
-                           task->get_handle(), port->as_proxy()->handle());
-        buffer.dequeue(NULL);
-    } else {
-        if (target_port->task->blocked_on(target_port)) {
-            KLOG(kernel, comm, "dequeued in rendezvous_ptr");
-            buffer.dequeue(target_port->task->rendezvous_ptr);
-            target_port->task->rendezvous_ptr = 0;
-            target_port->task->wakeup(target_port);
-            return;
-        }
+    if (port->task->blocked_on(port)) {
+        KLOG(kernel, comm, "dequeued in rendezvous_ptr");
+        buffer.dequeue(port->task->rendezvous_ptr);
+        port->task->rendezvous_ptr = 0;
+        port->task->wakeup(port);
     }
-
-    return;
 }
 
 rust_chan *rust_chan::clone(rust_task *target) {
-    size_t unit_sz = buffer.unit_sz;
-    maybe_proxy<rust_port> *port = this->port;
     return new (target->kernel, "cloned chan")
-        rust_chan(kernel, port, unit_sz);
+        rust_chan(kernel, port, buffer.unit_sz);
 }
 
 /**
@@ -125,30 +105,21 @@ void rust_chan::destroy() {
       "Channel's ref count should be zero.");
 
     if (is_associated()) {
-        if (port->is_proxy()) {
-            // Here is a good place to delete the port proxy we allocated
-            // in upcall_clone_chan.
-            rust_proxy<rust_port> *proxy = port->as_proxy();
-            scoped_lock with(port->referent()->lock);
-            disassociate();
-            delete proxy;
-        } else {
-            // We're trying to delete a channel that another task may be
-            // reading from. We have two options:
-            //
-            // 1. We can flush the channel by blocking in upcall_flush_chan()
-            //    and resuming only when the channel is flushed. The problem
-            //    here is that we can get ourselves in a deadlock if the
-            //    parent task tries to join us.
-            //
-            // 2. We can leave the channel in a "dormnat" state by not freeing
-            //    it and letting the receiver task delete it for us instead.
-            if (buffer.is_empty() == false) {
-                return;
-            }
-            scoped_lock with(port->referent()->lock);
-            disassociate();
+        // We're trying to delete a channel that another task may be
+        // reading from. We have two options:
+        //
+        // 1. We can flush the channel by blocking in upcall_flush_chan()
+        //    and resuming only when the channel is flushed. The problem
+        //    here is that we can get ourselves in a deadlock if the
+        //    parent task tries to join us.
+        //
+        // 2. We can leave the channel in a "dormnat" state by not freeing
+        //    it and letting the receiver task delete it for us instead.
+        if (buffer.is_empty() == false) {
+            return;
         }
+        scoped_lock with(port->lock);
+        disassociate();
     }
     delete this;
 }

trunk/src/rt/rust_chan.h

@@ -5,18 +5,18 @@ class rust_chan : public kernel_owned<rust_chan>,
                   public rust_cond {
 public:
     RUST_REFCOUNTED_WITH_DTOR(rust_chan, destroy())
-    rust_chan(rust_kernel *kernel, maybe_proxy<rust_port> *port,
+    rust_chan(rust_kernel *kernel, rust_port *port,
               size_t unit_sz);
 
     ~rust_chan();
 
     rust_kernel *kernel;
     rust_task *task;
-    maybe_proxy<rust_port> *port;
+    rust_port *port;
     size_t idx;
     circular_buffer buffer;
 
-    void associate(maybe_proxy<rust_port> *port);
+    void associate(rust_port *port);
     void disassociate();
     bool is_associated();
 

trunk/src/rt/rust_internal.h

@@ -219,9 +219,7 @@ template <typename T> class ptr_vec : public task_owned<ptr_vec<T> > {
 #include "memory_region.h"
 #include "rust_srv.h"
 #include "rust_log.h"
-#include "rust_proxy.h"
 #include "rust_kernel.h"
-#include "rust_message.h"
 #include "rust_scheduler.h"
 
 struct rust_timer {