Kernel refactor (part 1 of ??)

mk/rt.mk

@@ -10,7 +10,7 @@ RUNTIME_CS := rt/sync/timer.cpp \
               rt/rust_run_program.cpp \
               rt/rust_crate_cache.cpp \
               rt/rust_comm.cpp \
-              rt/rust_dom.cpp \
+              rt/rust_scheduler.cpp \
               rt/rust_task.cpp \
               rt/rust_task_list.cpp \
               rt/rust_proxy.cpp \
@@ -40,7 +40,7 @@ RUNTIME_HDR := rt/globals.h \
                rt/rust_util.h \
                rt/rust_chan.h \
                rt/rust_port.h \
-               rt/rust_dom.h \
+               rt/rust_scheduler.h \
                rt/rust_task.h \
                rt/rust_task_list.h \
                rt/rust_proxy.h \

src/comp/back/upcall.rs

@@ -55,8 +55,6 @@ type upcalls =
         ValueRef get_type_desc,
         ValueRef new_task,
         ValueRef start_task,
-        ValueRef new_thread,
-        ValueRef start_thread,
         ValueRef ivec_resize,
         ValueRef ivec_spill);
 
@@ -102,7 +100,7 @@ fn declare_upcalls(type_names tn, ModuleRef llmod) -> @upcalls {
              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", [T_ptr(T_str())],
+             dup_str=d("dup_str", [T_taskptr(tn), T_ptr(T_str())],
                        T_ptr(T_str())),
              new_vec=d("new_vec", [T_size_t(), T_ptr(T_tydesc(tn))],
                        T_opaque_vec_ptr()),
@@ -118,10 +116,6 @@ fn declare_upcalls(type_names tn, ModuleRef llmod) -> @upcalls {
              start_task=d("start_task",
                           [T_taskptr(tn), T_int(), T_int(), T_size_t()],
                           T_taskptr(tn)),
-             new_thread=d("new_thread", [T_ptr(T_i8())], T_taskptr(tn)),
-             start_thread=d("start_thread",
-                            [T_taskptr(tn), T_int(), T_int(), T_int(),
-                             T_size_t()], T_taskptr(tn)),
              ivec_resize=d("ivec_resize", [T_ptr(T_opaque_ivec()), T_int()],
                            T_void()),
              ivec_spill=d("ivec_spill", [T_ptr(T_opaque_ivec()), T_int()],

src/comp/middle/trans.rs

@@ -6512,7 +6512,7 @@ fn deep_copy(&@block_ctxt bcx, ValueRef v, ty::t t, ValueRef target_task)
     else if(ty::type_is_str(tcx, t)) {
         ret rslt(bcx,
                 bcx.build.Call(bcx.fcx.lcx.ccx.upcalls.dup_str,
-                               [bcx.fcx.lltaskptr, v]));
+                               [bcx.fcx.lltaskptr, target_task, v]));
     }
     else if(ty::type_is_chan(tcx, t)) {
         // If this is a channel, we need to clone it.

src/rt/circular_buffer.cpp

@@ -4,34 +4,35 @@
 
 #include "rust_internal.h"
 
-circular_buffer::circular_buffer(rust_dom *dom, size_t unit_sz) :
-    dom(dom),
+circular_buffer::circular_buffer(rust_task *task, size_t unit_sz) :
+    sched(task->sched),
+    task(task),
     unit_sz(unit_sz),
     _buffer_sz(initial_size()),
     _next(0),
     _unread(0),
-    _buffer((uint8_t *)dom->malloc(_buffer_sz)) {
+    _buffer((uint8_t *)task->malloc(_buffer_sz)) {
 
-    A(dom, unit_sz, "Unit size must be larger than zero.");
+    A(sched, unit_sz, "Unit size must be larger than zero.");
 
-    DLOG(dom, mem, "new circular_buffer(buffer_sz=%d, unread=%d)"
+    DLOG(sched, mem, "new circular_buffer(buffer_sz=%d, unread=%d)"
          "-> circular_buffer=0x%" PRIxPTR,
          _buffer_sz, _unread, this);
 
-    A(dom, _buffer, "Failed to allocate buffer.");
+    A(sched, _buffer, "Failed to allocate buffer.");
 }
 
 circular_buffer::~circular_buffer() {
-    DLOG(dom, mem, "~circular_buffer 0x%" PRIxPTR, this);
-    I(dom, _buffer);
-    W(dom, _unread == 0,
+    DLOG(sched, mem, "~circular_buffer 0x%" PRIxPTR, this);
+    I(sched, _buffer);
+    W(sched, _unread == 0,
       "freeing circular_buffer with %d unread bytes", _unread);
-    dom->free(_buffer);
+    task->free(_buffer);
 }
 
 size_t
 circular_buffer::initial_size() {
-    I(dom, unit_sz > 0);
+    I(sched, unit_sz > 0);
     return INITIAL_CIRCULAR_BUFFER_SIZE_IN_UNITS * unit_sz;
 }
 
@@ -40,8 +41,8 @@ circular_buffer::initial_size() {
  */
 void
 circular_buffer::transfer(void *dst) {
-    I(dom, dst);
-    I(dom, _unread <= _buffer_sz);
+    I(sched, dst);
+    I(sched, _unread <= _buffer_sz);
 
     uint8_t *ptr = (uint8_t *) dst;
 
@@ -53,13 +54,13 @@ circular_buffer::transfer(void *dst) {
     } else {
         head_sz = _buffer_sz - _next;
     }
-    I(dom, _next + head_sz <= _buffer_sz);
+    I(sched, _next + head_sz <= _buffer_sz);
     memcpy(ptr, _buffer + _next, head_sz);
 
     // Then copy any other items from the beginning of the buffer
-    I(dom, _unread >= head_sz);
+    I(sched, _unread >= head_sz);
     size_t tail_sz = _unread - head_sz;
-    I(dom, head_sz + tail_sz <= _buffer_sz);
+    I(sched, head_sz + tail_sz <= _buffer_sz);
     memcpy(ptr + head_sz, _buffer, tail_sz);
 }
 
@@ -69,37 +70,37 @@ circular_buffer::transfer(void *dst) {
  */
 void
 circular_buffer::enqueue(void *src) {
-    I(dom, src);
-    I(dom, _unread <= _buffer_sz);
-    I(dom, _buffer);
+    I(sched, src);
+    I(sched, _unread <= _buffer_sz);
+    I(sched, _buffer);
 
     // Grow if necessary.
     if (_unread == _buffer_sz) {
         grow();
     }
 
-    DLOG(dom, mem, "circular_buffer enqueue "
+    DLOG(sched, mem, "circular_buffer enqueue "
          "unread: %d, next: %d, buffer_sz: %d, unit_sz: %d",
          _unread, _next, _buffer_sz, unit_sz);
 
-    I(dom, _unread < _buffer_sz);
-    I(dom, _unread + unit_sz <= _buffer_sz);
+    I(sched, _unread < _buffer_sz);
+    I(sched, _unread + unit_sz <= _buffer_sz);
 
     // Copy data
     size_t dst_idx = _next + _unread;
-    I(dom, dst_idx >= _buffer_sz || dst_idx + unit_sz <= _buffer_sz);
+    I(sched, dst_idx >= _buffer_sz || dst_idx + unit_sz <= _buffer_sz);
     if (dst_idx >= _buffer_sz) {
         dst_idx -= _buffer_sz;
 
-        I(dom, _next >= unit_sz);
-        I(dom, dst_idx <= _next - unit_sz);
+        I(sched, _next >= unit_sz);
+        I(sched, dst_idx <= _next - unit_sz);
     }
 
-    I(dom, dst_idx + unit_sz <= _buffer_sz);
+    I(sched, dst_idx + unit_sz <= _buffer_sz);
     memcpy(&_buffer[dst_idx], src, unit_sz);
     _unread += unit_sz;
 
-    DLOG(dom, mem, "circular_buffer pushed data at index: %d", dst_idx);
+    DLOG(sched, mem, "circular_buffer pushed data at index: %d", dst_idx);
 }
 
 /**
@@ -109,21 +110,21 @@ circular_buffer::enqueue(void *src) {
  */
 void
 circular_buffer::dequeue(void *dst) {
-    I(dom, unit_sz > 0);
-    I(dom, _unread >= unit_sz);
-    I(dom, _unread <= _buffer_sz);
-    I(dom, _buffer);
+    I(sched, unit_sz > 0);
+    I(sched, _unread >= unit_sz);
+    I(sched, _unread <= _buffer_sz);
+    I(sched, _buffer);
 
-    DLOG(dom, mem,
+    DLOG(sched, mem,
              "circular_buffer dequeue "
              "unread: %d, next: %d, buffer_sz: %d, unit_sz: %d",
              _unread, _next, _buffer_sz, unit_sz);
 
-    I(dom, _next + unit_sz <= _buffer_sz);
+    I(sched, _next + unit_sz <= _buffer_sz);
     if (dst != NULL) {
         memcpy(dst, &_buffer[_next], unit_sz);
     }
-    DLOG(dom, mem, "shifted data from index %d", _next);
+    DLOG(sched, mem, "shifted data from index %d", _next);
     _unread -= unit_sz;
     _next += unit_sz;
     if (_next == _buffer_sz) {
@@ -139,11 +140,11 @@ circular_buffer::dequeue(void *dst) {
 void
 circular_buffer::grow() {
     size_t new_buffer_sz = _buffer_sz * 2;
-    I(dom, new_buffer_sz <= MAX_CIRCULAR_BUFFER_SIZE);
-    DLOG(dom, mem, "circular_buffer is growing to %d bytes", new_buffer_sz);
-    void *new_buffer = dom->malloc(new_buffer_sz);
+    I(sched, new_buffer_sz <= MAX_CIRCULAR_BUFFER_SIZE);
+    DLOG(sched, mem, "circular_buffer is growing to %d bytes", new_buffer_sz);
+    void *new_buffer = task->malloc(new_buffer_sz);
     transfer(new_buffer);
-    dom->free(_buffer);
+    task->free(_buffer);
     _buffer = (uint8_t *)new_buffer;
     _next = 0;
     _buffer_sz = new_buffer_sz;
@@ -152,11 +153,11 @@ circular_buffer::grow() {
 void
 circular_buffer::shrink() {
     size_t new_buffer_sz = _buffer_sz / 2;
-    I(dom, initial_size() <= new_buffer_sz);
-    DLOG(dom, mem, "circular_buffer is shrinking to %d bytes", new_buffer_sz);
-    void *new_buffer = dom->malloc(new_buffer_sz);
+    I(sched, initial_size() <= new_buffer_sz);
+    DLOG(sched, mem, "circular_buffer is shrinking to %d bytes", new_buffer_sz);
+    void *new_buffer = task->malloc(new_buffer_sz);
     transfer(new_buffer);
-    dom->free(_buffer);
+    task->free(_buffer);
     _buffer = (uint8_t *)new_buffer;
     _next = 0;
     _buffer_sz = new_buffer_sz;

src/rt/circular_buffer.h

@@ -6,15 +6,17 @@
 #define CIRCULAR_BUFFER_H
 
 class
-circular_buffer : public dom_owned<circular_buffer> {
+circular_buffer : public task_owned<circular_buffer> {
     static const size_t INITIAL_CIRCULAR_BUFFER_SIZE_IN_UNITS = 8;
     static const size_t MAX_CIRCULAR_BUFFER_SIZE = 1 << 24;
 
+    rust_scheduler *sched;
+
 public:
-    rust_dom *dom;
+    rust_task *task;
     // Size of the data unit in bytes.
     const size_t unit_sz;
-    circular_buffer(rust_dom *dom, size_t unit_sz);
+    circular_buffer(rust_task *task, size_t unit_sz);
     ~circular_buffer();
     void transfer(void *dst);
     void enqueue(void *src);

src/rt/memory.h

@@ -1,54 +1,59 @@
+// -*- c++ -*-
 #ifndef MEMORY_H
 #define MEMORY_H
 
 inline void *operator new(size_t size, void *mem) {
     return mem;
 }
 
-inline void *operator new(size_t size, rust_dom *dom) {
-    return dom->malloc(size, memory_region::LOCAL);
+inline void *operator new(size_t size, rust_kernel *kernel) {
+    return kernel->malloc(size);
 }
 
-inline void *operator new[](size_t size, rust_dom *dom) {
-    return dom->malloc(size, memory_region::LOCAL);
+inline void *operator new(size_t size, rust_task *task) {
+    return task->malloc(size, memory_region::LOCAL);
 }
 
-inline void *operator new(size_t size, rust_dom &dom) {
-    return dom.malloc(size, memory_region::LOCAL);
+inline void *operator new[](size_t size, rust_task *task) {
+    return task->malloc(size, memory_region::LOCAL);
 }
 
-inline void *operator new[](size_t size, rust_dom &dom) {
-    return dom.malloc(size, memory_region::LOCAL);
+inline void *operator new(size_t size, rust_task &task) {
+    return task.malloc(size, memory_region::LOCAL);
 }
 
-inline void *operator new(size_t size, rust_dom *dom,
+inline void *operator new[](size_t size, rust_task &task) {
+    return task.malloc(size, memory_region::LOCAL);
+}
+
+inline void *operator new(size_t size, rust_task *task,
     memory_region::memory_region_type type) {
-    return dom->malloc(size, type);
+    return task->malloc(size, type);
 }
 
-inline void *operator new[](size_t size, rust_dom *dom,
+inline void *operator new[](size_t size, rust_task *task,
     memory_region::memory_region_type type) {
-    return dom->malloc(size, type);
+    return task->malloc(size, type);
 }
 
-inline void *operator new(size_t size, rust_dom &dom,
+inline void *operator new(size_t size, rust_task &task,
     memory_region::memory_region_type type) {
-    return dom.malloc(size, type);
+    return task.malloc(size, type);
 }
 
-inline void *operator new[](size_t size, rust_dom &dom,
+inline void *operator new[](size_t size, rust_task &task,
     memory_region::memory_region_type type) {
-    return dom.malloc(size, type);
+    return task.malloc(size, type);
 }
 
-inline void operator delete(void *mem, rust_dom *dom) {
-    dom->free(mem, memory_region::LOCAL);
+inline void operator delete(void *mem, rust_task *task) {
+    task->free(mem, memory_region::LOCAL);
     return;
 }
 
-inline void operator delete(void *mem, rust_dom *dom,
+inline void operator delete(void *mem, rust_task *task,
     memory_region::memory_region_type type) {
-    dom->free(mem, type);
+    task->free(mem, type);
     return;
 }