---

yaml
---
r: 3427
b: refs/heads/master
c: f6f945f
h: refs/heads/master
i:
  3425: eeada19
  3423: 8f5d9dc
v: v3

Author: Eric Holk

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: c6d83248301b4aed366b9bef682d200381324c01
+refs/heads/master: f6f945fed5c8d1061d80b444331910df29afa392

trunk/src/rt/rust.cpp

@@ -111,7 +111,7 @@ rust_start(uintptr_t main_fn, int argc, char **argv, void* crate_map) {
 
     DLOG(dom, dom, "Using %d worker threads.", num_threads);
 
-    int ret = dom->start_main_loops(num_threads);
+    int ret = kernel->start_task_threads(num_threads);
     delete args;
     delete kernel;
     delete srv;

trunk/src/rt/rust_builtin.cpp

@@ -391,16 +391,16 @@ task_yield(rust_task *task) {
 
 extern "C" CDECL void
 task_join(rust_task *task, rust_task *join_task) {
-    task->dom->scheduler_lock.lock();
+    task->kernel->scheduler_lock.lock();
     // If the other task is already dying, we don't have to wait for it.
     if (join_task->dead() == false) {
         join_task->tasks_waiting_to_join.push(task);
         task->block(join_task, "joining local task");
-        task->dom->scheduler_lock.unlock();
+        task->kernel->scheduler_lock.unlock();
         task->yield(2);
     }
     else {
-        task->dom->scheduler_lock.unlock();
+        task->kernel->scheduler_lock.unlock();
     }
 }
 

trunk/src/rt/rust_dom.cpp

@@ -51,9 +51,9 @@ rust_dom::activate(rust_task *task) {
 
     task->ctx.next = &ctx;
     DLOG(this, task, "descheduling...");
-    scheduler_lock.unlock();
+    kernel->scheduler_lock.unlock();
     task->ctx.swap(ctx);
-    scheduler_lock.lock();
+    kernel->scheduler_lock.lock();
     DLOG(this, task, "task has returned");
 }
 
@@ -167,7 +167,7 @@ rust_dom::number_of_live_tasks() {
  */
 void
 rust_dom::reap_dead_tasks() {
-    I(this, scheduler_lock.lock_held_by_current_thread());
+    I(this, kernel->scheduler_lock.lock_held_by_current_thread());
     for (size_t i = 0; i < dead_tasks.length(); ) {
         rust_task *task = dead_tasks[i];
         // Make sure this task isn't still running somewhere else...
@@ -266,7 +266,7 @@ rust_dom::log_state() {
  */
 int
 rust_dom::start_main_loop(int id) {
-    scheduler_lock.lock();
+    kernel->scheduler_lock.lock();
 
     // Make sure someone is watching, to pull us out of infinite loops.
     //
@@ -296,9 +296,9 @@ rust_dom::start_main_loop(int id) {
             DLOG(this, task,
                  "all tasks are blocked, scheduler id %d yielding ...",
                  id);
-            scheduler_lock.unlock();
+            kernel->scheduler_lock.unlock();
             sync::sleep(100);
-            scheduler_lock.lock();
+            kernel->scheduler_lock.lock();
             DLOG(this, task,
                 "scheduler resuming ...");
             continue;
@@ -349,9 +349,9 @@ rust_dom::start_main_loop(int id) {
                 "scheduler yielding ...",
                 dead_tasks.length());
             log_state();
-            scheduler_lock.unlock();
+            kernel->scheduler_lock.unlock();
             sync::yield();
-            scheduler_lock.lock();
+            kernel->scheduler_lock.lock();
         } else {
             drain_incoming_message_queue(true);
         }
@@ -360,28 +360,7 @@ rust_dom::start_main_loop(int id) {
 
     DLOG(this, dom, "finished main-loop %d (dom.rval = %d)", id, rval);
 
-    scheduler_lock.unlock();
-    return rval;
-}
-
-int rust_dom::start_main_loops(int num_threads)
-{
-    dom_worker *worker = NULL;
-
-    // -1, because this thread will also be a worker.
-    for(int i = 0; i < num_threads - 1; ++i) {
-        worker = new dom_worker(i + 1, this);
-        worker->start();
-        threads.push(worker);
-    }
-
-    start_main_loop(0);
-
-    while(threads.pop(&worker)) {
-        worker->join();
-        delete worker;
-    }
-
+    kernel->scheduler_lock.unlock();
     return rval;
 }
 
@@ -392,26 +371,14 @@ rust_dom::get_cache() {
 
 rust_task *
 rust_dom::create_task(rust_task *spawner, const char *name) {
-    //scheduler_lock.lock();
     rust_task *task =
         new (this) rust_task (this, &newborn_tasks, spawner, name);
     DLOG(this, task, "created task: " PTR ", spawner: %s, name: %s",
                         task, spawner ? spawner->name : "null", name);
     newborn_tasks.append(task);
-    //scheduler_lock.unlock();
     return task;
 }
 
-rust_dom::dom_worker::dom_worker(int id, rust_dom *owner)
-    : id(id), owner(owner)
-{
-}
-
-void rust_dom::dom_worker::run()
-{
-    owner->start_main_loop(id);
-}
-
 //
 // Local Variables:
 // mode: C++

trunk/src/rt/rust_dom.h

@@ -97,24 +97,10 @@ struct rust_dom : public kernel_owned<rust_dom>, rc_base<rust_dom>
     rust_task *schedule_task();
 
     int start_main_loop(int id);
-    int start_main_loops(int num_threads);
 
     void log_state();
 
     rust_task *create_task(rust_task *spawner, const char *name);
-
-    class dom_worker : public rust_thread {
-        int id;
-        rust_dom *owner;
-
-    public:
-        dom_worker(int id, rust_dom *owner);
-
-        virtual void run();
-    };
-
-    lock_and_signal scheduler_lock;
-    array_list<dom_worker *> threads;
 };
 
 inline rust_log &

trunk/src/rt/rust_kernel.cpp

@@ -224,6 +224,37 @@ rust_kernel::signal_kernel_lock() {
     _kernel_lock.unlock();
 }
 
+int rust_kernel::start_task_threads(int num_threads)
+{
+    rust_task_thread *thread = NULL;
+    
+    // -1, because this thread will also be a thread.
+    for(int i = 0; i < num_threads - 1; ++i) {
+        thread = new rust_task_thread(i + 1, this);
+        thread->start();
+        threads.push(thread);
+    }
+    
+    dom->start_main_loop(0);
+
+    while(threads.pop(&thread)) {
+        thread->join();
+        delete thread;
+    }
+
+    return dom->rval;
+}
+
+rust_task_thread::rust_task_thread(int id, rust_kernel *owner)
+    : id(id), owner(owner)
+{
+}
+
+void rust_task_thread::run()
+{
+    owner->dom->start_main_loop(id);
+}
+
 //
 // Local Variables:
 // mode: C++

trunk/src/rt/rust_kernel.h

@@ -34,6 +34,9 @@ rust_handle :
     }
 };
 
+class rust_task_thread;
+
+
 /**
  * A global object shared by all thread domains. Most of the data structures
  * in this class are synchronized since they are accessed from multiple
@@ -44,8 +47,6 @@ class rust_kernel : public rust_thread {
     rust_log _log;
     rust_srv *_srv;
 
-    rust_dom *dom;
-
     /**
      * Task proxy objects are kernel owned handles to Rust objects.
      */
@@ -69,7 +70,11 @@ class rust_kernel : public rust_thread {
     rust_dom *create_domain(const char *name);
     void destroy_domain();
 
+    array_list<rust_task_thread *> threads;
+
 public:
+    rust_dom *dom;
+    lock_and_signal scheduler_lock;
 
     /**
      * Message queues are kernel objects and are associated with domains.
@@ -105,7 +110,10 @@ class rust_kernel : public rust_thread {
     void *malloc(size_t size);
     void free(void *mem);
 
+    // TODO: this should go away
     inline rust_dom *get_domain() const { return dom; }
+
+    int start_task_threads(int num_threads);
 };
 
 inline void *operator new(size_t size, rust_kernel *kernel) {
@@ -116,4 +124,15 @@ inline void *operator new(size_t size, rust_kernel &kernel) {
     return kernel.malloc(size);
 }
 
+
+class rust_task_thread : public rust_thread {
+    int id;
+    rust_kernel *owner;
+    
+public:
+    rust_task_thread(int id, rust_kernel *owner);
+    
+    virtual void run();
+};
+
 #endif /* RUST_KERNEL_H */

trunk/src/rt/rust_task.cpp

@@ -61,6 +61,7 @@ rust_task::rust_task(rust_dom *dom, rust_task_list *state,
     gc_alloc_chain(0),
     dom(dom),
     cache(NULL),
+    kernel(dom->kernel),
     name(name),
     state(state),
     cond(NULL),
@@ -134,7 +135,7 @@ void task_start_wrapper(spawn_args *a)
     LOG(task, task, "task exited with value %d", rval);
 
     {
-        scoped_lock with(task->dom->scheduler_lock);
+        scoped_lock with(task->kernel->scheduler_lock);
 
         // FIXME: the old exit glue does some magical argument copying
         // stuff. This is probably still needed.
@@ -158,9 +159,9 @@ rust_task::start(uintptr_t spawnee_fn,
     LOGPTR(dom, "from spawnee", spawnee_fn);
 
     I(dom, stk->data != NULL);
-    I(dom, !dom->scheduler_lock.lock_held_by_current_thread());
-
-    scoped_lock with(dom->scheduler_lock);
+    I(dom, !kernel->scheduler_lock.lock_held_by_current_thread());
+    
+    scoped_lock with(kernel->scheduler_lock);
 
     char *sp = (char *)rust_sp;
 
@@ -412,7 +413,7 @@ rust_task::free(void *p, bool is_gc)
 
 void
 rust_task::transition(rust_task_list *src, rust_task_list *dst) {
-    I(dom, dom->scheduler_lock.lock_held_by_current_thread());
+    I(dom, kernel->scheduler_lock.lock_held_by_current_thread());
     DLOG(dom, task,
          "task %s " PTR " state change '%s' -> '%s' while in '%s'",
          name, (uintptr_t)this, src->name, dst->name, state->name);

trunk/src/rt/rust_task.h

@@ -22,6 +22,7 @@ rust_task : public maybe_proxy<rust_task>,
     rust_crate_cache *cache;
 
     // Fields known only to the runtime.
+    rust_kernel *kernel;
     const char *const name;
     rust_task_list *state;
     rust_cond *cond;