Renamed what's left of rust_dom to rust_scheduler

Author: Eric Holk

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 \
@@ -37,7 +37,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/rt/circular_buffer.cpp

@@ -5,34 +5,34 @@
 #include "rust_internal.h"
 
 circular_buffer::circular_buffer(rust_task *task, size_t unit_sz) :
-    dom(task->dom),
+    sched(task->sched),
     task(task),
     unit_sz(unit_sz),
     _buffer_sz(initial_size()),
     _next(0),
     _unread(0),
     _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);
     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;
 }
 
@@ -41,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;
 
@@ -54,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);
 }
 
@@ -70,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);
 }
 
 /**
@@ -110,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) {
@@ -140,8 +140,8 @@ 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);
+    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);
     task->free(_buffer);
@@ -153,8 +153,8 @@ 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);
+    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);
     task->free(_buffer);

src/rt/circular_buffer.h

@@ -10,7 +10,7 @@ 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_dom *dom;
+    rust_scheduler *sched;
 
 public:
     rust_task *task;

src/rt/rust.cpp

@@ -39,13 +39,13 @@ command_line_args : public kernel_owned<command_line_args>
         size_t vec_fill = sizeof(rust_str *) * argc;
         size_t vec_alloc = next_power_of_two(sizeof(rust_vec) + vec_fill);
         void *mem = kernel->malloc(vec_alloc);
-        args = new (mem) rust_vec(task->dom, vec_alloc, 0, NULL);
+        args = new (mem) rust_vec(task->sched, vec_alloc, 0, NULL);
         rust_str **strs = (rust_str**) &args->data[0];
         for (int i = 0; i < argc; ++i) {
             size_t str_fill = strlen(argv[i]) + 1;
             size_t str_alloc = next_power_of_two(sizeof(rust_str) + str_fill);
             mem = kernel->malloc(str_alloc);
-            strs[i] = new (mem) rust_str(task->dom, str_alloc, str_fill,
+            strs[i] = new (mem) rust_str(task->sched, str_alloc, str_fill,
                                          (uint8_t const *)argv[i]);
         }
         args->fill = vec_fill;
@@ -98,21 +98,21 @@ rust_start(uintptr_t main_fn, int argc, char **argv, void* crate_map) {
     rust_srv *srv = new rust_srv();
     rust_kernel *kernel = new rust_kernel(srv);
     kernel->start();
-    rust_dom *dom = kernel->get_domain();
+    rust_scheduler *sched = kernel->get_scheduler();
     command_line_args *args 
-        = new (kernel) command_line_args(dom->root_task, argc, argv);
+        = new (kernel) command_line_args(sched->root_task, argc, argv);
 
-    DLOG(dom, dom, "startup: %d args in 0x%" PRIxPTR,
+    DLOG(sched, dom, "startup: %d args in 0x%" PRIxPTR,
              args->argc, (uintptr_t)args->args);
     for (int i = 0; i < args->argc; i++) {
-        DLOG(dom, dom, "startup: arg[%d] = '%s'", i, args->argv[i]);
+        DLOG(sched, dom, "startup: arg[%d] = '%s'", i, args->argv[i]);
     }
 
-    dom->root_task->start(main_fn, (uintptr_t)args->args);
+    sched->root_task->start(main_fn, (uintptr_t)args->args);
 
     int num_threads = get_num_threads();
 
-    DLOG(dom, dom, "Using %d worker threads.", num_threads);
+    DLOG(sched, dom, "Using %d worker threads.", num_threads);
 
     int ret = kernel->start_task_threads(num_threads);
     delete args;

src/rt/rust_builtin.cpp

@@ -9,7 +9,7 @@
 
 extern "C" CDECL rust_str*
 last_os_error(rust_task *task) {
-    rust_dom *dom = task->dom;
+    rust_scheduler *sched = task->sched;
     LOG(task, task, "last_os_error()");
 
 #if defined(__WIN32__)
@@ -47,7 +47,7 @@ last_os_error(rust_task *task) {
         task->fail(1);
         return NULL;
     }
-    rust_str *st = new (mem) rust_str(dom, alloc, fill, (const uint8_t *)buf);
+    rust_str *st = new (mem) rust_str(sched, alloc, fill, (const uint8_t *)buf);
 
 #ifdef __WIN32__
     LocalFree((HLOCAL)buf);
@@ -57,7 +57,7 @@ last_os_error(rust_task *task) {
 
 extern "C" CDECL rust_str *
 rust_getcwd(rust_task *task) {
-    rust_dom *dom = task->dom;
+    rust_scheduler *sched = task->sched;
     LOG(task, task, "rust_getcwd()");
 
     char cbuf[BUF_BYTES];
@@ -80,7 +80,7 @@ rust_getcwd(rust_task *task) {
     }
 
     rust_str *st;
-    st = new (mem) rust_str(dom, alloc, fill, (const uint8_t *)cbuf);
+    st = new (mem) rust_str(sched, alloc, fill, (const uint8_t *)cbuf);
 
     return st;    
 }
@@ -124,7 +124,7 @@ unsupervise(rust_task *task) {
 extern "C" CDECL rust_vec*
 vec_alloc(rust_task *task, type_desc *t, type_desc *elem_t, size_t n_elts)
 {
-    rust_dom *dom = task->dom;
+    rust_scheduler *sched = task->sched;
     LOG(task, mem, "vec_alloc %" PRIdPTR " elements of size %" PRIdPTR,
         n_elts, elem_t->size);
     size_t fill = n_elts * elem_t->size;
@@ -134,7 +134,7 @@ vec_alloc(rust_task *task, type_desc *t, type_desc *elem_t, size_t n_elts)
         task->fail(4);
         return NULL;
     }
-    rust_vec *vec = new (mem) rust_vec(dom, alloc, 0, NULL);
+    rust_vec *vec = new (mem) rust_vec(sched, alloc, 0, NULL);
     return vec;
 }
 
@@ -198,11 +198,11 @@ vec_alloc_with_data(rust_task *task,
                     size_t elt_size,
                     void *d)
 {
-    rust_dom *dom = task->dom;
+    rust_scheduler *sched = task->sched;
     size_t alloc = next_power_of_two(sizeof(rust_vec) + (n_elts * elt_size));
     void *mem = task->malloc(alloc, memory_region::LOCAL);
     if (!mem) return NULL;
-    return new (mem) rust_vec(dom, alloc, fill * elt_size, (uint8_t*)d);
+    return new (mem) rust_vec(sched, alloc, fill * elt_size, (uint8_t*)d);
 }
 
 extern "C" CDECL rust_vec*
@@ -355,13 +355,13 @@ str_from_buf(rust_task *task, char *buf, unsigned int len) {
 extern "C" CDECL void *
 rand_new(rust_task *task)
 {
-    rust_dom *dom = task->dom;
+    rust_scheduler *sched = task->sched;
     randctx *rctx = (randctx *) task->malloc(sizeof(randctx));
     if (!rctx) {
         task->fail(1);
         return NULL;
     }
-    isaac_init(dom, rctx);
+    isaac_init(sched, rctx);
     return rctx;
 }
 

src/rt/rust_chan.cpp

@@ -22,7 +22,7 @@ rust_chan::rust_chan(rust_task *task,
 rust_chan::~rust_chan() {
     LOG(task, comm, "del rust_chan(task=0x%" PRIxPTR ")", (uintptr_t) this);
 
-    A(task->dom, is_associated() == false,
+    A(task->sched, is_associated() == false,
       "Channel must be disassociated before being freed.");
     --task->ref_count;
 }
@@ -49,7 +49,7 @@ bool rust_chan::is_associated() {
  * Unlink this channel from its associated port.
  */
 void rust_chan::disassociate() {
-    A(task->dom, is_associated(), "Channel must be associated with a port.");
+    A(task->sched, is_associated(), "Channel must be associated with a port.");
 
     if (port->is_proxy() == false) {
         LOG(task, task,
@@ -69,14 +69,14 @@ void rust_chan::disassociate() {
 void rust_chan::send(void *sptr) {
     buffer.enqueue(sptr);
 
-    rust_dom *dom = task->dom;
+    rust_scheduler *sched = task->sched;
     if (!is_associated()) {
-        W(dom, is_associated(),
+        W(sched, is_associated(),
           "rust_chan::transmit with no associated port.");
         return;
     }
 
-    A(dom, !buffer.is_empty(),
+    A(sched, !buffer.is_empty(),
       "rust_chan::transmit with nothing to send.");
 
     if (port->is_proxy()) {
@@ -86,7 +86,7 @@ void rust_chan::send(void *sptr) {
     } else {
         rust_port *target_port = port->referent();
         if (target_port->task->blocked_on(target_port)) {
-            DLOG(dom, comm, "dequeued in rendezvous_ptr");
+            DLOG(sched, comm, "dequeued in rendezvous_ptr");
             buffer.dequeue(target_port->task->rendezvous_ptr);
             target_port->task->rendezvous_ptr = 0;
             target_port->task->wakeup(target_port);