---

yaml
---
r: 4307
b: refs/heads/master
c: 6a6d5c6
h: refs/heads/master
i:
  4305: 082fc39
  4303: ea9c271
v: v3

Author: Eric Holk

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: b3d9d9b73cb9cae6b76e0a040756784112ed88a9
+refs/heads/master: 6a6d5c669e363238abbed050f62658ee6e74cbbf

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")) {
 
-    // A(sched, unit_sz, "Unit size must be larger than zero.");
+    A(kernel, unit_sz, "Unit size must be larger than zero.");
 
-    // DLOG(sched, mem, "new circular_buffer(buffer_sz=%d, unread=%d)"
-    //      "-> circular_buffer=0x%" PRIxPTR,
-    //      _buffer_sz, _unread, this);
+    KLOG(kernel, mem, "new circular_buffer(buffer_sz=%d, unread=%d)"
+         "-> circular_buffer=0x%" PRIxPTR,
+         _buffer_sz, _unread, this);
 
-    // A(sched, _buffer, "Failed to allocate buffer.");
+    A(kernel, _buffer, "Failed to allocate buffer.");
 }
 
 circular_buffer::~circular_buffer() {
-    // DLOG(sched, mem, "~circular_buffer 0x%" PRIxPTR, this);
-    // I(sched, _buffer);
-    // W(sched, _unread == 0,
-    //   "freeing circular_buffer with %d unread bytes", _unread);
+    KLOG(kernel, mem, "~circular_buffer 0x%" PRIxPTR, this);
+    I(kernel, _buffer);
+    W(kernel, _unread == 0,
+      "freeing circular_buffer with %d unread bytes", _unread);
     kernel->free(_buffer);
 }
 
 size_t
 circular_buffer::initial_size() {
-    // I(sched, 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) {
-    // I(sched, dst);
-    // I(sched, _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;
     }
-    // I(sched, _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
-    // I(sched, _unread >= head_sz);
+    I(kernel, _unread >= head_sz);
     size_t tail_sz = _unread - head_sz;
-    // I(sched, head_sz + tail_sz <= _buffer_sz);
+    I(kernel, head_sz + tail_sz <= _buffer_sz);
     memcpy(ptr + head_sz, _buffer, tail_sz);
 }
 
@@ -69,37 +69,37 @@ circular_buffer::transfer(void *dst) {
  */
 void
 circular_buffer::enqueue(void *src) {
-    // I(sched, src);
-    // I(sched, _unread <= _buffer_sz);
-    // I(sched, _buffer);
+    I(kernel, src);
+    I(kernel, _unread <= _buffer_sz);
+    I(kernel, _buffer);
 
     // Grow if necessary.
     if (_unread == _buffer_sz) {
         grow();
     }
 
-    // DLOG(sched, mem, "circular_buffer enqueue "
-    //      "unread: %d, next: %d, buffer_sz: %d, unit_sz: %d",
-    //      _unread, _next, _buffer_sz, unit_sz);
+    KLOG(kernel, mem, "circular_buffer enqueue "
+         "unread: %d, next: %d, buffer_sz: %d, unit_sz: %d",
+         _unread, _next, _buffer_sz, unit_sz);
 
-    // I(sched, _unread < _buffer_sz);
-    // I(sched, _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;
-    I(sched, 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;
 
-        // I(sched, _next >= unit_sz);
-        // I(sched, dst_idx <= _next - unit_sz);
+        I(kernel, _next >= unit_sz);
+        I(kernel, dst_idx <= _next - unit_sz);
     }
 
-    // I(sched, dst_idx + unit_sz <= _buffer_sz);
+    I(kernel, dst_idx + unit_sz <= _buffer_sz);
     memcpy(&_buffer[dst_idx], src, unit_sz);
     _unread += unit_sz;
 
-    // DLOG(sched, mem, "circular_buffer pushed data at index: %d", dst_idx);
+    KLOG(kernel, mem, "circular_buffer pushed data at index: %d", dst_idx);
 }
 
 /**
@@ -109,21 +109,21 @@ circular_buffer::enqueue(void *src) {
  */
 void
 circular_buffer::dequeue(void *dst) {
-    // I(sched, unit_sz > 0);
-    // I(sched, _unread >= unit_sz);
-    // I(sched, _unread <= _buffer_sz);
-    // I(sched, _buffer);
+    I(kernel, unit_sz > 0);
+    I(kernel, _unread >= unit_sz);
+    I(kernel, _unread <= _buffer_sz);
+    I(kernel, _buffer);
 
-    // DLOG(sched, mem,
-    //          "circular_buffer dequeue "
-    //          "unread: %d, next: %d, buffer_sz: %d, unit_sz: %d",
-    //          _unread, _next, _buffer_sz, unit_sz);
+    KLOG(kernel, mem,
+             "circular_buffer dequeue "
+             "unread: %d, next: %d, buffer_sz: %d, unit_sz: %d",
+             _unread, _next, _buffer_sz, unit_sz);
 
-    // I(sched, _next + unit_sz <= _buffer_sz);
+    I(kernel, _next + unit_sz <= _buffer_sz);
     if (dst != NULL) {
         memcpy(dst, &_buffer[_next], unit_sz);
     }
-    //DLOG(sched, mem, "shifted data from index %d", _next);
+    KLOG(kernel, mem, "shifted data from index %d", _next);
     _unread -= unit_sz;
     _next += unit_sz;
     if (_next == _buffer_sz) {
@@ -139,9 +139,9 @@ circular_buffer::dequeue(void *dst) {
 void
 circular_buffer::grow() {
     size_t new_buffer_sz = _buffer_sz * 2;
-    // I(sched, new_buffer_sz <= MAX_CIRCULAR_BUFFER_SIZE);
-    // DLOG(sched, mem, "circular_buffer is growing to %d bytes",
-    //      new_buffer_sz);
+    I(kernel, new_buffer_sz <= MAX_CIRCULAR_BUFFER_SIZE);
+    KLOG(kernel, mem, "circular_buffer is growing to %d bytes",
+         new_buffer_sz);
     void *new_buffer = kernel->malloc(new_buffer_sz,
                                     "new circular_buffer (grow)");
     transfer(new_buffer);
@@ -154,9 +154,9 @@ circular_buffer::grow() {
 void
 circular_buffer::shrink() {
     size_t new_buffer_sz = _buffer_sz / 2;
-    // I(sched, initial_size() <= new_buffer_sz);
-    // DLOG(sched, mem, "circular_buffer is shrinking to %d bytes",
-    //      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,
                                     "new circular_buffer (shrink)");
     transfer(new_buffer);

trunk/src/rt/circular_buffer.h

@@ -10,8 +10,6 @@ circular_buffer : public kernel_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_kernel *kernel;
     // Size of the data unit in bytes.