---

yaml
---
r: 315
b: refs/heads/master
c: 00d1465
h: refs/heads/master
i:
  313: 6ac35a5
  311: c92a2b7
v: v3

Author: mbebenita

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 1f0656d9084970fcc02ba9c27277265b8b3b7217
+refs/heads/master: 00d1465d13980fc3acf650f182ee0723fbda0e06

trunk/src/Makefile

@@ -244,7 +244,10 @@ BOOT_CMXS := $(BOOT_MLS:.ml=.cmx)
 BOOT_OBJS := $(BOOT_MLS:.ml=.o)
 BOOT_CMIS := $(BOOT_MLS:.ml=.cmi)
 
-RUNTIME_CS := rt/rust.cpp \
+RUNTIME_CS := rt/sync/spin_lock.cpp \
+			  rt/sync/lock_free_queue.cpp \
+			  rt/sync/condition_variable.cpp \
+              rt/rust.cpp \
               rt/rust_builtin.cpp \
               rt/rust_crate.cpp \
               rt/rust_crate_cache.cpp \
@@ -256,12 +259,19 @@ RUNTIME_CS := rt/rust.cpp \
               rt/rust_upcall.cpp \
               rt/rust_log.cpp \
               rt/rust_timer.cpp \
+              rt/circular_buffer.cpp \
               rt/isaac/randport.cpp
 
-RUNTIME_HDR := rt/rust.h \
+RUNTIME_HDR := rt/globals.h \
+			   rt/rust.h \
                rt/rust_dwarf.h \
                rt/rust_internal.h \
-               rt/rust_util.h
+               rt/rust_util.h \
+               rt/rust_chan.h \
+               rt/rust_dom.h \
+               rt/rust_task.h \
+               rt/rust_proxy.h \
+               rt/circular_buffer.h
 
 RUNTIME_INCS := -Irt/isaac -Irt/uthash
 RUNTIME_OBJS := $(RUNTIME_CS:.cpp=$(CFG_OBJ_SUFFIX))
@@ -363,6 +373,8 @@ TEST_XFAILS_X86 :=  $(MUT_BOX_XFAILS) \
                     test/run-pass/task-comm.rs \
                     test/run-pass/vec-alloc-append.rs \
                     test/run-pass/vec-slice.rs \
+					test/run-pass/task-comm-3.rs \
+					test/run-pass/task-comm-4.rs \
                     test/compile-fail/bad-recv.rs \
                     test/compile-fail/bad-send.rs \
                     test/compile-fail/infinite-tag-type-recursion.rs \
@@ -452,6 +464,11 @@ TEST_XFAILS_LLVM := $(addprefix test/run-pass/, \
                       tail-cps.rs \
                       tail-direct.rs \
                       task-comm.rs \
+                      task-comm-0.rs \
+                      task-comm-1.rs \
+                      task-comm-2.rs \
+                      task-comm-3.rs \
+                      task-comm-4.rs \
                       threads.rs \
                       tup.rs \
                       type-sizes.rs \

trunk/src/boot/be/abi.ml

@@ -13,7 +13,7 @@
 let rc_base_field_refcnt = 0;;
 
 let task_field_refcnt = rc_base_field_refcnt;;
-let task_field_stk = task_field_refcnt + 1;;
+let task_field_stk = task_field_refcnt + 2;;
 let task_field_runtime_sp = task_field_stk + 1;;
 let task_field_rust_sp = task_field_runtime_sp + 1;;
 let task_field_gc_alloc_chain = task_field_rust_sp + 1;;

trunk/src/rt/circular_buffer.cpp

@@ -0,0 +1,118 @@
+/*
+ * A simple resizable circular buffer.
+ */
+
+#include "rust_internal.h"
+
+circular_buffer::circular_buffer(rust_dom *dom, size_t unit_sz) :
+    dom(dom),
+    _buffer_sz(INITIAL_CIRCULAR_BUFFFER_SIZE_IN_UNITS * unit_sz),
+    unit_sz(unit_sz),
+    _next(0),
+    _unread(0),
+    _buffer((uint8_t *)dom->calloc(_buffer_sz)) {
+
+    A(dom, unit_sz, "Unit size must be larger than zero.");
+
+    dom->log(rust_log::MEM | rust_log::COMM,
+             "new circular_buffer(buffer_sz=%d, unread=%d)"
+             "-> circular_buffer=0x%" PRIxPTR,
+             _buffer_sz, _unread, this);
+
+    A(dom, _buffer, "Failed to allocate buffer.");
+}
+
+circular_buffer::~circular_buffer() {
+    dom->log(rust_log::MEM | rust_log::COMM,
+             "~circular_buffer 0x%" PRIxPTR,
+             this);
+    I(dom, _buffer);
+    // I(dom, unread == 0);
+    dom->free(_buffer);
+}
+
+/**
+ * Copies the unread data from this buffer to the "dst" address.
+ */
+void
+circular_buffer::transfer(void *dst) {
+    I(dom, dst);
+    uint8_t *ptr = (uint8_t *) dst;
+    for (size_t i = 0; i < _unread; i += unit_sz) {
+        memcpy(&ptr[i], &_buffer[_next + i % _buffer_sz], unit_sz);
+    }
+}
+
+/**
+ * Copies the data at the "src" address into this buffer. The buffer is
+ * grown if it isn't large enough.
+ */
+void
+circular_buffer::enqueue(void *src) {
+    I(dom, src);
+    I(dom, _unread <= _buffer_sz);
+
+    // Grow if necessary.
+    if (_unread == _buffer_sz) {
+        I(dom, _buffer_sz <= MAX_CIRCULAR_BUFFFER_SIZE);
+        void *tmp = dom->malloc(_buffer_sz << 1);
+        transfer(tmp);
+        _buffer_sz <<= 1;
+        dom->free(_buffer);
+        _buffer = (uint8_t *)tmp;
+    }
+
+    dom->log(rust_log::MEM | rust_log::COMM,
+             "circular_buffer enqueue "
+             "unread: %d, buffer_sz: %d, unit_sz: %d",
+             _unread, _buffer_sz, unit_sz);
+
+    I(dom, _unread < _buffer_sz);
+    I(dom, _unread + unit_sz <= _buffer_sz);
+
+    // Copy data
+    size_t i = (_next + _unread) % _buffer_sz;
+    memcpy(&_buffer[i], src, unit_sz);
+    _unread += unit_sz;
+
+    dom->log(rust_log::MEM | rust_log::COMM,
+             "circular_buffer pushed data at index: %d", i);
+}
+
+/**
+ * Copies data from this buffer to the "dst" address. The buffer is
+ * shrunk if possible.
+ */
+void
+circular_buffer::dequeue(void *dst) {
+    I(dom, dst);
+    I(dom, unit_sz > 0);
+    I(dom, _unread >= unit_sz);
+    I(dom, _unread <= _buffer_sz);
+    I(dom, _buffer);
+    size_t i = _next;
+    memcpy(dst, &_buffer[i], unit_sz);
+    dom->log(rust_log::MEM | rust_log::COMM,
+             "shifted data from index %d", i);
+    _unread -= unit_sz;
+    _next += unit_sz;
+    I(dom, _next <= _buffer_sz);
+    if (_next == _buffer_sz) {
+        _next = 0;
+    }
+
+    // Shrink if possible.
+    if (_buffer_sz >= INITIAL_CIRCULAR_BUFFFER_SIZE_IN_UNITS * unit_sz &&
+        _unread <= _buffer_sz / 4) {
+        void *tmp = dom->malloc(_buffer_sz / 2);
+        transfer(tmp);
+        _buffer_sz >>= 1;
+        dom->free(_buffer);
+        _buffer = (uint8_t *)tmp;
+    }
+}
+
+bool
+circular_buffer::is_empty() {
+    return _unread == 0;
+}

trunk/src/rt/circular_buffer.h

@@ -0,0 +1,30 @@
+/*
+ *
+ */
+
+#ifndef CIRCULAR_BUFFER_H
+#define CIRCULAR_BUFFER_H
+
+class
+circular_buffer : public dom_owned<circular_buffer> {
+    static const size_t INITIAL_CIRCULAR_BUFFFER_SIZE_IN_UNITS = 8;
+    static const size_t MAX_CIRCULAR_BUFFFER_SIZE = 1 << 24;
+
+public:
+    rust_dom *dom;
+    circular_buffer(rust_dom *dom, size_t unit_sz);
+    ~circular_buffer();
+    void transfer(void *dst);
+    void enqueue(void *src);
+    void dequeue(void *dst);
+    bool is_empty();
+
+private:
+    size_t _buffer_sz;
+    size_t unit_sz;
+    size_t _next;
+    size_t _unread;
+    uint8_t *_buffer;
+};
+
+#endif /* CIRCULAR_BUFFER_H */

trunk/src/rt/globals.h

@@ -0,0 +1,33 @@
+#ifndef GLOBALS_H
+#define GLOBALS_H
+
+#define __STDC_LIMIT_MACROS 1
+#define __STDC_CONSTANT_MACROS 1
+#define __STDC_FORMAT_MACROS 1
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#if defined(__WIN32__)
+extern "C" {
+#include <windows.h>
+#include <tchar.h>
+#include <wincrypt.h>
+}
+#elif defined(__GNUC__)
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dlfcn.h>
+#include <pthread.h>
+#include <errno.h>
+#else
+#error "Platform not supported."
+#endif
+
+#endif /* GLOBALS_H */

trunk/src/rt/rust.cpp

@@ -1,7 +1,6 @@
 #include "rust_internal.h"
 #include "util/array_list.h"
 
-
 // #define TRACK_ALLOCATIONS
 // For debugging, keeps track of live allocations, so you can find out
 // exactly what leaked.
@@ -100,52 +99,6 @@ rust_srv::clone()
     return new rust_srv();
 }
 
-
-int
-rust_main_loop(rust_dom *dom)
-{
-    // Make sure someone is watching, to pull us out of infinite loops.
-    rust_timer timer(*dom);
-
-    int rval;
-    rust_task *task;
-
-    dom->log(rust_log::DOM,
-            "running main-loop on domain 0x%" PRIxPTR, dom);
-    dom->logptr("exit-task glue",
-            dom->root_crate->get_exit_task_glue());
-
-    while ((task = dom->sched()) != NULL) {
-        I(dom, task->running());
-
-        dom->log(rust_log::TASK,
-                "activating task 0x%" PRIxPTR ", sp=0x%" PRIxPTR,
-                (uintptr_t)task, task->rust_sp);
-
-        dom->interrupt_flag = 0;
-
-        dom->activate(task);
-
-        dom->log(rust_log::TASK,
-                 "returned from task 0x%" PRIxPTR
-                 " in state '%s', sp=0x%" PRIxPTR,
-                 (uintptr_t)task,
-                 dom->state_vec_name(task->state),
-                 task->rust_sp);
-
-        I(dom, task->rust_sp >= (uintptr_t) &task->stk->data[0]);
-        I(dom, task->rust_sp < task->stk->limit);
-
-        dom->reap_dead_tasks();
-    }
-
-    dom->log(rust_log::DOM, "finished main-loop (dom.rval = %d)", dom->rval);
-    rval = dom->rval;
-
-    return rval;
-}
-
-
 struct
 command_line_args
 {
@@ -243,7 +196,7 @@ rust_start(uintptr_t main_fn, rust_crate const *crate, int argc, char **argv)
                              (uintptr_t)&main_args,
                              sizeof(main_args));
 
-        ret = rust_main_loop(&dom);
+        ret = dom.start_main_loop();
     }
 
 #if !defined(__WIN32__)

trunk/src/rt/rust_builtin.cpp

@@ -19,7 +19,7 @@ str_alloc(rust_task *task, size_t n_bytes)
 extern "C" CDECL rust_str*
 last_os_error(rust_task *task) {
     rust_dom *dom = task->dom;
-    dom->log(rust_log::TASK, "last_os_error()");
+    task->log(rust_log::TASK, "last_os_error()");
 
 #if defined(__WIN32__)
     LPTSTR buf;
@@ -95,7 +95,7 @@ extern "C" CDECL rust_vec*
 vec_alloc(rust_task *task, type_desc *t, size_t n_elts)
 {
     rust_dom *dom = task->dom;
-    dom->log(rust_log::MEM,
+    task->log(rust_log::MEM,
             "vec_alloc %" PRIdPTR " elements of size %" PRIdPTR,
              n_elts, t->size);
     size_t fill = n_elts * t->size;