remove rust_srv

Author: jamorton

Diff for: mk/rt.mk

@@ -64,7 +64,6 @@ RUNTIME_CS_$(1) := \
               rt/rust_port_selector.cpp \
               rt/circular_buffer.cpp \
               rt/isaac/randport.cpp \
-              rt/rust_srv.cpp \
               rt/rust_kernel.cpp \
               rt/rust_shape.cpp \
               rt/rust_abi.cpp \

Diff for: src/rt/circular_buffer.cpp

@@ -24,8 +24,12 @@ circular_buffer::circular_buffer(rust_kernel *kernel, size_t unit_sz) :
 circular_buffer::~circular_buffer() {
     KLOG(kernel, mem, "~circular_buffer 0x%" PRIxPTR, this);
     assert(_buffer);
-    W(kernel, _unread == 0,
-      "freeing circular_buffer with %d unread bytes", _unread);
+    if (_unread != 0) {
+        fprintf(stderr, "warning: freeing circular_buffer with"
+                " %lu unread bytes", _unread);
+        fflush(stderr);
+    }
+
     kernel->free(_buffer);
 }
 

Diff for: src/rt/memory_region.cpp

@@ -23,14 +23,14 @@ void *memory_region::get_data(alloc_header *ptr) {
     return (void*)((char *)ptr + HEADER_SIZE);
 }
 
-memory_region::memory_region(rust_srv *srv, bool synchronized) :
-    _srv(srv), _parent(NULL), _live_allocations(0),
-    _detailed_leaks(srv->env->detailed_leaks),
+memory_region::memory_region(rust_env *env, bool synchronized) :
+    _env(env), _parent(NULL), _live_allocations(0),
+    _detailed_leaks(env->detailed_leaks),
     _synchronized(synchronized) {
 }
 
 memory_region::memory_region(memory_region *parent) :
-    _srv(parent->_srv), _parent(parent), _live_allocations(0),
+    _env(parent->_env), _parent(parent), _live_allocations(0),
     _detailed_leaks(parent->_detailed_leaks),
     _synchronized(parent->_synchronized) {
 }
@@ -59,7 +59,7 @@ void memory_region::free(void *mem) {
     }
     release_alloc(mem);
     maybe_poison(mem);
-    _srv->free(alloc);
+    ::free(alloc);
 }
 
 void *
@@ -74,7 +74,7 @@ memory_region::realloc(void *mem, size_t orig_size) {
 #   endif
 
     size_t size = orig_size + HEADER_SIZE;
-    alloc_header *newMem = (alloc_header *)_srv->realloc(alloc, size);
+    alloc_header *newMem = (alloc_header *)::realloc(alloc, size);
 
 #   if RUSTRT_TRACK_ALLOCATIONS >= 1
     assert(newMem->magic == MAGIC);
@@ -105,7 +105,7 @@ void *
 memory_region::malloc(size_t size, const char *tag, bool zero) {
     size_t old_size = size;
     size += HEADER_SIZE;
-    alloc_header *mem = (alloc_header *)_srv->malloc(size);
+    alloc_header *mem = (alloc_header *)::malloc(size);
 
 #   if RUSTRT_TRACK_ALLOCATIONS >= 1
     mem->magic = MAGIC;
@@ -222,7 +222,7 @@ memory_region::claim_alloc(void *mem) {
 void
 memory_region::maybe_poison(void *mem) {
 
-    if (!_srv->env->poison_on_free)
+    if (!_env->poison_on_free)
         return;
 
 #   if RUSTRT_TRACK_ALLOCATIONS >= 1

Diff for: src/rt/memory_region.h

@@ -22,7 +22,7 @@
 // hugely expensive and should only be used as a last resort.
 #define RUSTRT_TRACK_ALLOCATIONS 0
 
-class rust_srv;
+class rust_env;
 
 class memory_region {
 private:
@@ -42,7 +42,7 @@ class memory_region {
     inline alloc_header *get_header(void *mem);
     inline void *get_data(alloc_header *);
 
-    rust_srv *_srv;
+    rust_env *_env;
     memory_region *_parent;
     int _live_allocations;
     array_list<alloc_header *> _allocation_list;
@@ -58,7 +58,7 @@ class memory_region {
     void claim_alloc(void *mem);
 
 public:
-    memory_region(rust_srv *srv, bool synchronized);
+    memory_region(rust_env *env, bool synchronized);
     memory_region(memory_region *parent);
     void *malloc(size_t size, const char *tag, bool zero = true);
     void *calloc(size_t size, const char *tag);

Diff for: src/rt/rust.cpp

@@ -75,8 +75,7 @@ rust_start(uintptr_t main_fn, int argc, char **argv, void* crate_map) {
     update_log_settings(crate_map, env->logspec);
     check_claims = env->check_claims;
 
-    rust_srv *srv = new rust_srv(env);
-    rust_kernel *kernel = new rust_kernel(srv);
+    rust_kernel *kernel = new rust_kernel(env);
     rust_sched_id sched_id = kernel->create_scheduler(env->num_sched_threads);
     rust_scheduler *sched = kernel->get_scheduler_by_id(sched_id);
     rust_task *root_task = sched->create_task(NULL, "main");
@@ -96,7 +95,6 @@ rust_start(uintptr_t main_fn, int argc, char **argv, void* crate_map) {
     int ret = kernel->wait_for_exit();
     delete args;
     delete kernel;
-    delete srv;
 
     free_env(env);
 

Diff for: src/rt/rust_internal.h

@@ -95,7 +95,6 @@ template <typename T> struct region_owned {
 struct rust_cond { };
 
 #include "memory_region.h"
-#include "rust_srv.h"
 #include "rust_log.h"
 #include "rust_kernel.h"
 #include "rust_sched_loop.h"

Diff for: src/rt/rust_kernel.cpp

@@ -9,16 +9,15 @@
 #define KLOG_ERR_(field, ...)                   \
     KLOG_LVL(this, field, log_err, __VA_ARGS__)
 
-rust_kernel::rust_kernel(rust_srv *srv) :
-    _region(srv, true),
-    _log(srv, NULL),
-    srv(srv),
+rust_kernel::rust_kernel(rust_env *env) :
+    _region(env, true),
+    _log(env, NULL),
     max_task_id(0),
     max_port_id(0),
     rval(0),
     max_sched_id(0),
     sched_reaper(this),
-    env(srv->env)
+    env(env)
 {
 }
 
@@ -69,7 +68,7 @@ rust_kernel::create_scheduler(size_t num_threads) {
         id = max_sched_id++;
         assert(id != INTPTR_MAX && "Hit the maximum scheduler id");
         sched = new (this, "rust_scheduler")
-            rust_scheduler(this, srv, num_threads, id);
+            rust_scheduler(this, num_threads, id);
         bool is_new = sched_table
             .insert(std::pair<rust_sched_id,
                               rust_scheduler*>(id, sched)).second;

Diff for: src/rt/rust_kernel.h

@@ -22,9 +22,6 @@ class rust_kernel {
     memory_region _region;
     rust_log _log;
 
-public:
-    rust_srv *srv;
-private:
     // The next task id
     rust_task_id max_task_id;
 
@@ -50,10 +47,9 @@ class rust_kernel {
     rust_sched_reaper sched_reaper;
 
 public:
-
     struct rust_env *env;
 
-    rust_kernel(rust_srv *srv);
+    rust_kernel(rust_env *env);
 
     void log(uint32_t level, char const *fmt, ...);
     void fatal(char const *fmt, ...);

Diff for: src/rt/rust_log.cpp

@@ -40,8 +40,8 @@ log_console_off(rust_env *env) {
     }
 }
 
-rust_log::rust_log(rust_srv *srv, rust_sched_loop *sched_loop) :
-    _srv(srv),
+rust_log::rust_log(rust_env *env, rust_sched_loop *sched_loop) :
+    _env(env),
     _sched_loop(sched_loop) {
 }
 
@@ -98,7 +98,8 @@ rust_log::trace_ln(char *prefix, char *message) {
     append_string(buffer, "%s", prefix);
     append_string(buffer, "%s", message);
     if (_log_to_console) {
-        _srv->log(buffer);
+        fprintf(stderr, "rust: %s\n", buffer);
+        fflush(stderr);
     }
     _log_lock.unlock();
 }

Diff for: src/rt/rust_log.h

@@ -40,15 +40,15 @@ struct rust_task;
 class rust_log {
 
 public:
-    rust_log(rust_srv *srv, rust_sched_loop *sched_loop);
+    rust_log(rust_env *env, rust_sched_loop *sched_loop);
     virtual ~rust_log();
 
     void trace_ln(rust_task *task, uint32_t level, char *message);
     void trace_ln(char *prefix, char *message);
     bool is_tracing(uint32_t type_bits);
 
 private:
-    rust_srv *_srv;
+    rust_env *_env;
     rust_sched_loop *_sched_loop;
     bool _use_labels;
     void trace_ln(rust_task *task, char *message);

Diff for: src/rt/rust_sched_launcher.cpp

@@ -3,16 +3,15 @@
 
 const size_t SCHED_STACK_SIZE = 1024*100;
 
-rust_sched_launcher::rust_sched_launcher(rust_scheduler *sched,
-                                         rust_srv *srv, int id)
+rust_sched_launcher::rust_sched_launcher(rust_scheduler *sched, int id)
     : kernel(sched->kernel),
-      sched_loop(sched, srv, id),
+      sched_loop(sched, id),
       driver(&sched_loop) {
 }
 
 rust_thread_sched_launcher::rust_thread_sched_launcher(rust_scheduler *sched,
-                                                       rust_srv *srv, int id)
-    : rust_sched_launcher(sched, srv, id),
+                                                       int id)
+    : rust_sched_launcher(sched, id),
       rust_thread(SCHED_STACK_SIZE) {
 }
 

Diff for: src/rt/rust_sched_launcher.h

@@ -16,7 +16,7 @@ class rust_sched_launcher : public kernel_owned<rust_sched_launcher> {
     rust_sched_driver driver;
 
 public:
-    rust_sched_launcher(rust_scheduler *sched, rust_srv *srv, int id);
+    rust_sched_launcher(rust_scheduler *sched, int id);
     virtual ~rust_sched_launcher() { }
 
     virtual void start() = 0;
@@ -28,7 +28,7 @@ class rust_thread_sched_launcher
   :public rust_sched_launcher,
    private rust_thread {
 public:
-    rust_thread_sched_launcher(rust_scheduler *sched, rust_srv *srv, int id);
+    rust_thread_sched_launcher(rust_scheduler *sched, int id);
     virtual void start() { rust_thread::start(); }
     virtual void run() { driver.start_main_loop(); }
     virtual void join() { rust_thread::join(); }

Diff for: src/rt/rust_sched_loop.cpp

@@ -17,21 +17,19 @@ const size_t C_STACK_SIZE = 1024*1024;
 
 bool rust_sched_loop::tls_initialized = false;
 
-rust_sched_loop::rust_sched_loop(rust_scheduler *sched,
-                                   rust_srv *srv,
-                                   int id) :
-    _log(srv, this),
+rust_sched_loop::rust_sched_loop(rust_scheduler *sched,int id) :
+    _log(env, this),
     id(id),
     should_exit(false),
     cached_c_stack(NULL),
     dead_task(NULL),
     pump_signal(NULL),
     kernel(sched->kernel),
     sched(sched),
-    srv(srv),
     log_lvl(log_debug),
     min_stack_size(kernel->env->min_stack_size),
     env(kernel->env),
+    local_region(env, false),
     // TODO: calculate a per scheduler name.
     name("main")
 {

Diff for: src/rt/rust_sched_loop.h

@@ -69,7 +69,6 @@ struct rust_sched_loop
 public:
     rust_kernel *kernel;
     rust_scheduler *sched;
-    rust_srv *srv;
 
     // NB: this is used to filter *runtime-originating* debug
     // logging, on a per-scheduler basis. It's not likely what
@@ -81,6 +80,7 @@ struct rust_sched_loop
 
     size_t min_stack_size;
     rust_env *env;
+    memory_region local_region;
 
     randctx rctx;
 
@@ -90,7 +90,7 @@ struct rust_sched_loop
 
     // Only a pointer to 'name' is kept, so it must live as long as this
     // domain.
-    rust_sched_loop(rust_scheduler *sched, rust_srv *srv, int id);
+    rust_sched_loop(rust_scheduler *sched, int id);
     void activate(rust_task *task);
     void log(rust_task *task, uint32_t level, char const *fmt, ...);
     rust_log & get_log();

Diff for: src/rt/rust_scheduler.cpp

@@ -3,12 +3,9 @@
 #include "rust_sched_launcher.h"
 
 rust_scheduler::rust_scheduler(rust_kernel *kernel,
-                               rust_srv *srv,
                                size_t num_threads,
                                rust_sched_id id) :
     kernel(kernel),
-    srv(srv),
-    env(srv->env),
     live_threads(num_threads),
     live_tasks(0),
     num_threads(num_threads),
@@ -24,10 +21,9 @@ rust_scheduler::~rust_scheduler() {
 
 rust_sched_launcher *
 rust_scheduler::create_task_thread(int id) {
-    rust_srv *srv = this->srv->clone();
     rust_sched_launcher *thread =
         new (kernel, "rust_thread_sched_launcher")
-        rust_thread_sched_launcher(this, srv, id);
+        rust_thread_sched_launcher(this, id);
     KLOG(kernel, kern, "created task thread: " PTR ", id: %d",
           thread, id);
     return thread;
@@ -36,9 +32,7 @@ rust_scheduler::create_task_thread(int id) {
 void
 rust_scheduler::destroy_task_thread(rust_sched_launcher *thread) {
     KLOG(kernel, kern, "deleting task thread: " PTR, thread);
-    rust_srv *srv = thread->get_loop()->srv;
     delete thread;
-    delete srv;
 }
 
 void

Diff for: src/rt/rust_scheduler.h

@@ -9,8 +9,6 @@ class rust_scheduler : public kernel_owned<rust_scheduler> {
     // FIXME: Make these private
 public:
     rust_kernel *kernel;
-    rust_srv *srv;
-    rust_env *env;
 private:
     // Protects live_threads and cur_thread increments
     lock_and_signal lock;
@@ -34,7 +32,7 @@ class rust_scheduler : public kernel_owned<rust_scheduler> {
     void exit();
 
 public:
-    rust_scheduler(rust_kernel *kernel, rust_srv *srv, size_t num_threads,
+    rust_scheduler(rust_kernel *kernel, size_t num_threads,
                    rust_sched_id id);
     ~rust_scheduler();