---

yaml
---
r: 12275
b: refs/heads/master
c: e185888
h: refs/heads/master
i:
  12273: a5332c6
  12271: f607373
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 987bc2362926d0672a01e8d5964940743df48cb6
+refs/heads/master: e1858882a49bf0666d4ffb3f45989ac9dbe9c843
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/doc/tutorial.md

@@ -919,7 +919,7 @@ for the parameter list, as in `{|| ...}`.
 Partial application is done using the `bind` keyword in Rust.
 
 ~~~~
-let daynum = bind vec::position_elem(["mo", "tu", "we", "th",
+let daynum = bind vec::position_elem(["mo", "tu", "we", "do",
                                       "fr", "sa", "su"], _);
 ~~~~
 

trunk/mk/rt.mk

@@ -64,6 +64,7 @@ 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 \

trunk/src/rt/circular_buffer.cpp

@@ -12,26 +12,26 @@ circular_buffer::circular_buffer(rust_kernel *kernel, size_t unit_sz) :
     _unread(0),
     _buffer((uint8_t *)kernel->malloc(_buffer_sz, "circular_buffer")) {
 
-    assert(unit_sz && "Unit size must be larger than zero.");
+    A(kernel, unit_sz, "Unit size must be larger than zero.");
 
     KLOG(kernel, mem, "new circular_buffer(buffer_sz=%d, unread=%d)"
          "-> circular_buffer=0x%" PRIxPTR,
          _buffer_sz, _unread, this);
 
-    assert(_buffer && "Failed to allocate buffer.");
+    A(kernel, _buffer, "Failed to allocate buffer.");
 }
 
 circular_buffer::~circular_buffer() {
     KLOG(kernel, mem, "~circular_buffer 0x%" PRIxPTR, this);
-    assert(_buffer);
-    assert(_unread == 0 && "didn't expect bytes in the circular buffer");
-
+    I(kernel, _buffer);
+    W(kernel, _unread == 0,
+      "freeing circular_buffer with %d unread bytes", _unread);
     kernel->free(_buffer);
 }
 
 size_t
 circular_buffer::initial_size() {
-    assert(unit_sz > 0);
+    I(kernel, unit_sz > 0);
     return INITIAL_CIRCULAR_BUFFER_SIZE_IN_UNITS * unit_sz;
 }
 
@@ -40,8 +40,8 @@ circular_buffer::initial_size() {
  */
 void
 circular_buffer::transfer(void *dst) {
-    assert(dst);
-    assert(_unread <= _buffer_sz);
+    I(kernel, dst);
+    I(kernel, _unread <= _buffer_sz);
 
     uint8_t *ptr = (uint8_t *) dst;
 
@@ -53,13 +53,13 @@ circular_buffer::transfer(void *dst) {
     } else {
         head_sz = _buffer_sz - _next;
     }
-    assert(_next + head_sz <= _buffer_sz);
+    I(kernel, _next + head_sz <= _buffer_sz);
     memcpy(ptr, _buffer + _next, head_sz);
 
     // Then copy any other items from the beginning of the buffer
-    assert(_unread >= head_sz);
+    I(kernel, _unread >= head_sz);
     size_t tail_sz = _unread - head_sz;
-    assert(head_sz + tail_sz <= _buffer_sz);
+    I(kernel, head_sz + tail_sz <= _buffer_sz);
     memcpy(ptr + head_sz, _buffer, tail_sz);
 }
 
@@ -69,9 +69,9 @@ circular_buffer::transfer(void *dst) {
  */
 void
 circular_buffer::enqueue(void *src) {
-    assert(src);
-    assert(_unread <= _buffer_sz);
-    assert(_buffer);
+    I(kernel, src);
+    I(kernel, _unread <= _buffer_sz);
+    I(kernel, _buffer);
 
     // Grow if necessary.
     if (_unread == _buffer_sz) {
@@ -82,20 +82,20 @@ circular_buffer::enqueue(void *src) {
          "unread: %d, next: %d, buffer_sz: %d, unit_sz: %d",
          _unread, _next, _buffer_sz, unit_sz);
 
-    assert(_unread < _buffer_sz);
-    assert(_unread + unit_sz <= _buffer_sz);
+    I(kernel, _unread < _buffer_sz);
+    I(kernel, _unread + unit_sz <= _buffer_sz);
 
     // Copy data
     size_t dst_idx = _next + _unread;
-    assert(dst_idx >= _buffer_sz || dst_idx + unit_sz <= _buffer_sz);
+    I(kernel, dst_idx >= _buffer_sz || dst_idx + unit_sz <= _buffer_sz);
     if (dst_idx >= _buffer_sz) {
         dst_idx -= _buffer_sz;
 
-        assert(_next >= unit_sz);
-        assert(dst_idx <= _next - unit_sz);
+        I(kernel, _next >= unit_sz);
+        I(kernel, dst_idx <= _next - unit_sz);
     }
 
-    assert(dst_idx + unit_sz <= _buffer_sz);
+    I(kernel, dst_idx + unit_sz <= _buffer_sz);
     memcpy(&_buffer[dst_idx], src, unit_sz);
     _unread += unit_sz;
 
@@ -109,17 +109,17 @@ circular_buffer::enqueue(void *src) {
  */
 void
 circular_buffer::dequeue(void *dst) {
-    assert(unit_sz > 0);
-    assert(_unread >= unit_sz);
-    assert(_unread <= _buffer_sz);
-    assert(_buffer);
+    I(kernel, unit_sz > 0);
+    I(kernel, _unread >= unit_sz);
+    I(kernel, _unread <= _buffer_sz);
+    I(kernel, _buffer);
 
     KLOG(kernel, mem,
              "circular_buffer dequeue "
              "unread: %d, next: %d, buffer_sz: %d, unit_sz: %d",
              _unread, _next, _buffer_sz, unit_sz);
 
-    assert(_next + unit_sz <= _buffer_sz);
+    I(kernel, _next + unit_sz <= _buffer_sz);
     if (dst != NULL) {
         memcpy(dst, &_buffer[_next], unit_sz);
     }
@@ -153,7 +153,7 @@ circular_buffer::grow() {
 void
 circular_buffer::shrink() {
     size_t new_buffer_sz = _buffer_sz / 2;
-    assert(initial_size() <= new_buffer_sz);
+    I(kernel, initial_size() <= new_buffer_sz);
     KLOG(kernel, mem, "circular_buffer is shrinking to %d bytes",
          new_buffer_sz);
     void *new_buffer = kernel->malloc(new_buffer_sz,

trunk/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_env *env, bool synchronized) :
-    _env(env), _parent(NULL), _live_allocations(0),
-    _detailed_leaks(env->detailed_leaks),
+memory_region::memory_region(rust_srv *srv, bool synchronized) :
+    _srv(srv), _parent(NULL), _live_allocations(0),
+    _detailed_leaks(srv->env->detailed_leaks),
     _synchronized(synchronized) {
 }
 
 memory_region::memory_region(memory_region *parent) :
-    _env(parent->_env), _parent(parent), _live_allocations(0),
+    _srv(parent->_srv), _parent(parent), _live_allocations(0),
     _detailed_leaks(parent->_detailed_leaks),
     _synchronized(parent->_synchronized) {
 }
@@ -55,11 +55,11 @@ void memory_region::free(void *mem) {
 #   endif
 
     if (_live_allocations < 1) {
-        assert(false && "live_allocs < 1");
+        _srv->fatal("live_allocs < 1", __FILE__, __LINE__, "");
     }
     release_alloc(mem);
     maybe_poison(mem);
-    ::free(alloc);
+    _srv->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 *)::realloc(alloc, size);
+    alloc_header *newMem = (alloc_header *)_srv->realloc(alloc, size);
 
 #   if RUSTRT_TRACK_ALLOCATIONS >= 1
     assert(newMem->magic == MAGIC);
@@ -88,7 +88,7 @@ memory_region::realloc(void *mem, size_t orig_size) {
                alloc->index, _allocation_list[alloc->index], alloc);
         printf("realloc: ptr 0x%" PRIxPTR " (%s) is not in allocation_list\n",
                (uintptr_t) get_data(alloc), alloc->tag);
-        assert(false && "not in allocation_list");
+        _srv->fatal("not in allocation_list", __FILE__, __LINE__, "");
     }
     else {
         _allocation_list[newMem->index] = newMem;
@@ -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 *)::malloc(size);
+    alloc_header *mem = (alloc_header *)_srv->malloc(size);
 
 #   if RUSTRT_TRACK_ALLOCATIONS >= 1
     mem->magic = MAGIC;
@@ -166,8 +166,8 @@ memory_region::~memory_region() {
 #   endif
 
     if (_live_allocations > 0) {
-        fprintf(stderr, "%s\n", msg);
-        assert(false);
+        _srv->fatal(msg, __FILE__, __LINE__,
+                    "%d objects", _live_allocations);
     }
     if (_synchronized) { _lock.unlock(); }
 }
@@ -184,7 +184,7 @@ memory_region::release_alloc(void *mem) {
     if (_allocation_list[alloc->index] != alloc) {
         printf("free: ptr 0x%" PRIxPTR " (%s) is not in allocation_list\n",
                (uintptr_t) get_data(alloc), alloc->tag);
-        assert(false && "not in allocation_list");
+        _srv->fatal("not in allocation_list", __FILE__, __LINE__, "");
     }
     else {
         // printf("freed index %d\n", index);
@@ -222,7 +222,7 @@ memory_region::claim_alloc(void *mem) {
 void
 memory_region::maybe_poison(void *mem) {
 
-    if (!_env->poison_on_free)
+    if (!_srv->env->poison_on_free)
         return;
 
 #   if RUSTRT_TRACK_ALLOCATIONS >= 1

trunk/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
 
-struct rust_env;
+class rust_srv;
 
 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_env *_env;
+    rust_srv *_srv;
     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_env *env, bool synchronized);
+    memory_region(rust_srv *srv, 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);

trunk/src/rt/rust.cpp

@@ -75,7 +75,8 @@ 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_kernel *kernel = new rust_kernel(env);
+    rust_srv *srv = new rust_srv(env);
+    rust_kernel *kernel = new rust_kernel(srv);
     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");
@@ -92,9 +93,10 @@ rust_start(uintptr_t main_fn, int argc, char **argv, void* crate_map) {
     root_task->start((spawn_fn)main_fn, NULL, args->args);
     root_task = NULL;
 
-    int ret = kernel->wait_for_exit();
+    int ret = kernel->run();
     delete args;
     delete kernel;
+    delete srv;
 
     free_env(env);