Renamed what's left of rust_dom to rust_scheduler

src/rt/rust_util.h

@@ -25,24 +25,24 @@ ptr_vec<T>::ptr_vec(rust_task *task) :
     fill(0),
     data(new (task) T*[alloc])
 {
-    I(task->dom, data);
-    DLOG(task->dom, mem, "new ptr_vec(data=0x%" PRIxPTR ") -> 0x%" PRIxPTR,
+    I(task->sched, data);
+    DLOG(task->sched, mem, "new ptr_vec(data=0x%" PRIxPTR ") -> 0x%" PRIxPTR,
          (uintptr_t)data, (uintptr_t)this);
 }
 
 template <typename T>
 ptr_vec<T>::~ptr_vec()
 {
-    I(task->dom, data);
-    DLOG(task->dom, mem, "~ptr_vec 0x%" PRIxPTR ", data=0x%" PRIxPTR,
+    I(task->sched, data);
+    DLOG(task->sched, mem, "~ptr_vec 0x%" PRIxPTR ", data=0x%" PRIxPTR,
          (uintptr_t)this, (uintptr_t)data);
-    I(task->dom, fill == 0);
+    I(task->sched, fill == 0);
     task->free(data);
 }
 
 template <typename T> T *&
 ptr_vec<T>::operator[](size_t offset) {
-    I(task->dom, data[offset]->idx == offset);
+    I(task->sched, data[offset]->idx == offset);
     return data[offset];
 }
 
@@ -50,14 +50,14 @@ template <typename T>
 void
 ptr_vec<T>::push(T *p)
 {
-    I(task->dom, data);
-    I(task->dom, fill <= alloc);
+    I(task->sched, data);
+    I(task->sched, fill <= alloc);
     if (fill == alloc) {
         alloc *= 2;
         data = (T **)task->realloc(data, alloc * sizeof(T*));
-        I(task->dom, data);
+        I(task->sched, data);
     }
-    I(task->dom, fill < alloc);
+    I(task->sched, fill < alloc);
     p->idx = fill;
     data[fill++] = p;
 }
@@ -80,13 +80,13 @@ template <typename T>
 void
 ptr_vec<T>::trim(size_t sz)
 {
-    I(task->dom, data);
+    I(task->sched, data);
     if (sz <= (alloc / 4) &&
         (alloc / 2) >= INIT_SIZE) {
         alloc /= 2;
-        I(task->dom, alloc >= fill);
+        I(task->sched, alloc >= fill);
         data = (T **)task->realloc(data, alloc * sizeof(T*));
-        I(task->dom, data);
+        I(task->sched, data);
     }
 }
 
@@ -95,9 +95,9 @@ void
 ptr_vec<T>::swap_delete(T *item)
 {
     /* Swap the endpoint into i and decr fill. */
-    I(task->dom, data);
-    I(task->dom, fill > 0);
-    I(task->dom, item->idx < fill);
+    I(task->sched, data);
+    I(task->sched, fill > 0);
+    I(task->sched, item->idx < fill);
     fill--;
     if (fill > 0) {
         T *subst = data[fill];
@@ -127,22 +127,22 @@ next_power_of_two(size_t s)
 // Initialization helper for ISAAC RNG
 
 static inline void
-isaac_init(rust_dom *dom, randctx *rctx)
+isaac_init(rust_scheduler *sched, randctx *rctx)
 {
         memset(rctx, 0, sizeof(randctx));
 
 #ifdef __WIN32__
         {
             HCRYPTPROV hProv;
-            dom->kernel->win32_require
+            sched->kernel->win32_require
                 (_T("CryptAcquireContext"),
                  CryptAcquireContext(&hProv, NULL, NULL, PROV_RSA_FULL,
                                      CRYPT_VERIFYCONTEXT|CRYPT_SILENT));
-            dom->kernel->win32_require
+            sched->kernel->win32_require
                 (_T("CryptGenRandom"),
                  CryptGenRandom(hProv, sizeof(rctx->randrsl),
                                 (BYTE*)(&rctx->randrsl)));
-            dom->kernel->win32_require
+            sched->kernel->win32_require
                 (_T("CryptReleaseContext"),
                  CryptReleaseContext(hProv, 0));
         }
@@ -156,11 +156,11 @@ isaac_init(rust_dom *dom, randctx *rctx)
             }
         } else {
             int fd = open("/dev/urandom", O_RDONLY);
-            I(dom, fd > 0);
-            I(dom, 
+            I(sched, fd > 0);
+            I(sched, 
               read(fd, (void*) &rctx->randrsl, sizeof(rctx->randrsl))
               == sizeof(rctx->randrsl));
-            I(dom, close(fd) == 0);
+            I(sched, close(fd) == 0);
         }
 #endif
         randinit(rctx, 1);
@@ -175,9 +175,10 @@ rust_vec : public rc_base<rust_vec>
     size_t fill;
     size_t pad; // Pad to align data[0] to 16 bytes.
     uint8_t data[];
-    rust_vec(rust_dom *dom, size_t alloc, size_t fill, uint8_t const *d) :
-        alloc(alloc),
-        fill(fill)
+    rust_vec(rust_scheduler *sched, size_t alloc, size_t fill, 
+             uint8_t const *d) 
+        : alloc(alloc),
+          fill(fill)
     {
         if (d)
             memcpy(&data[0], d, fill);