rt: Remove the kernel task table

Author: brson

src/rt/rust_kernel.cpp

@@ -166,51 +166,11 @@ rust_kernel::fail() {
     }
 }
 
-void
-rust_kernel::register_task(rust_task *task) {
-    uintptr_t new_live_tasks;
-    {
-        scoped_lock with(task_lock);
-        task->id = max_task_id++;
-        task_table.put(task->id, task);
-        new_live_tasks = task_table.count();
-    }
-    K(srv, task->id != INTPTR_MAX, "Hit the maximum task id");
-    KLOG_("Registered task %" PRIdPTR, task->id);
-    KLOG_("Total outstanding tasks: %d", new_live_tasks);
-}
-
-void
-rust_kernel::release_task_id(rust_task_id id) {
-    KLOG_("Releasing task %" PRIdPTR, id);
-    uintptr_t new_live_tasks;
-    {
-        scoped_lock with(task_lock);
-        task_table.remove(id);
-        new_live_tasks = task_table.count();
-    }
-    KLOG_("Total outstanding tasks: %d", new_live_tasks);
-}
-
-rust_task *
-rust_kernel::get_task_by_id(rust_task_id id) {
-    scoped_lock with(task_lock);
-    rust_task *task = NULL;
-    // get leaves task unchanged if not found.
-    task_table.get(id, &task);
-    if(task) {
-        if(task->get_ref_count() == 0) {
-            // FIXME: I don't think this is possible.
-            // this means the destructor is running, since the destructor
-            // grabs the kernel lock to unregister the task. Pretend this
-            // doesn't actually exist.
-            return NULL;
-        }
-        else {
-            task->ref();
-        }
-    }
-    return task;
+rust_task_id
+rust_kernel::generate_task_id() {
+    rust_task_id id = sync::increment(max_task_id);
+    K(srv, id != INTPTR_MAX, "Hit the maximum task id");
+    return id;
 }
 
 rust_port_id

src/rt/rust_kernel.h

@@ -24,11 +24,8 @@ class rust_kernel {
 public:
     rust_srv *srv;
 private:
-    // Protects max_task_id and task_table
-    lock_and_signal task_lock;
     // The next task id
     rust_task_id max_task_id;
-    hash_map<rust_task_id, rust_task *> task_table;
 
     // Protects max_port_id and port_table
     lock_and_signal port_lock;
@@ -75,9 +72,7 @@ class rust_kernel {
     void win32_require(LPCTSTR fn, BOOL ok);
 #endif
 
-    void register_task(rust_task *task);
-    rust_task *get_task_by_id(rust_task_id id);
-    void release_task_id(rust_task_id tid);
+    rust_task_id generate_task_id();
 
     rust_port_id register_port(rust_port *port);
     rust_port *get_port_by_id(rust_port_id id);

src/rt/rust_task_thread.cpp

@@ -146,8 +146,6 @@ rust_task_thread::reap_dead_tasks() {
     // from the scheduler, which may end up trying to take this lock
     lock.unlock();
 
-    // Release the task from the kernel so nobody else can get at it
-    kernel->release_task_id(dead_task->id);
     dead_task->delete_all_stacks();
     // Deref the task, which may cause it to request us to release it
     dead_task->deref();
@@ -316,7 +314,7 @@ rust_task_thread::create_task(rust_task *spawner, const char *name,
         newborn_tasks.append(task);
     }
 
-    kernel->register_task(task);
+    task->id = kernel->generate_task_id();
     return task;
 }