feat(core): add a mem module for memory management

Rename `Box` to `Boxedptr` and add more useful functions to it, in addition to renaming some existing functions.
rivet-lang · Jan 1, 2024 · aea8a35 · aea8a35
1 parent ddf92b9
commit aea8a35
Show file tree

Hide file tree

Showing 27 changed files with 331 additions and 253 deletions.
diff --git a/lib/core/src/Box.ri b/lib/core/src/Box.ri
diff --git a/lib/core/src/DynArray.ri b/lib/core/src/DynArray.ri
@@ -2,6 +2,8 @@
 // source code is governed by an MIT license that can be found in the LICENSE
 // file.
 
+import ./mem;
+
 #[boxed]
 struct DynArray {
     mut ptr: rawptr;
@@ -11,19 +13,19 @@ struct DynArray {
 
     #[unsafe; inline]
     func new(elem_size: uint, cap: uint) -> Self {
-        return Self(mem_zeroed(cap * elem_size), elem_size, 0, cap);
+        return Self(mem.raw_zeroed(cap * elem_size), elem_size, 0, cap);
     }
 
     #[unsafe; inline]
     func new_with_len(elem_size: uint, len: uint, cap: uint) -> Self {
         cap_ := if cap < len { len } else { cap };
-        return Self(mem_zeroed(cap_ * elem_size), elem_size, len, cap);
+        return Self(mem.raw_zeroed(cap_ * elem_size), elem_size, len, cap);
     }
 
     #[unsafe; inline]
     func new_with_init(init: rawptr, elem_size: uint, len: uint, cap: uint) -> Self {
         cap_ := if cap < len { len } else { cap };
-        dyn_array := Self(mem_alloc(cap_ * elem_size), elem_size, len, cap);
+        dyn_array := Self(mem.raw_alloc(cap_ * elem_size), elem_size, len, cap);
         mut i: uint := 0;
         while i < len : i += 1 {
             unsafe {
@@ -35,8 +37,8 @@ struct DynArray {
 
     #[unsafe]
     func from_array(arr: rawptr, elem_size: uint, len: uint) -> Self {
-        dyn_array := Self(mem_alloc(len * elem_size), elem_size, len, len);
-        mem_copy(dyn_array.ptr, arr, len * elem_size);
+        dyn_array := Self(mem.raw_alloc(len * elem_size), elem_size, len, len);
+        mem.copy(dyn_array.ptr, arr, len * elem_size);
         return dyn_array;
     }
 
@@ -60,7 +62,7 @@ struct DynArray {
     #[unsafe; inline]
     func raw_set(self, idx: uint, val: rawptr) {
         unsafe {
-            mem_copy(
+            mem.copy(
                 @ptr_add(@as([&]mut uint8, self.ptr), self.elem_size * idx),
                 val, self.elem_size
             );
@@ -72,7 +74,7 @@ struct DynArray {
             runtime_error("dynamic array index out of range (index: {}, len: {})", idx, self.len);
         }
         unsafe {
-            mem_copy(
+            mem.copy(
                 @ptr_add(@as([&]mut uint8, self.ptr), self.elem_size * idx),
                 val, self.elem_size
             );
@@ -84,7 +86,7 @@ struct DynArray {
             self.reserve(self.len + 1);
         }
         unsafe {
-            mem_copy(@ptr_add(self.ptr, self.elem_size * self.len), val, self.elem_size);
+            mem.copy(@ptr_add(self.ptr, self.elem_size * self.len), val, self.elem_size);
         }
         self.len += 1;
     }
@@ -117,16 +119,16 @@ struct DynArray {
         old_ptr := self.ptr;
         new_size := self.len - size;
         new_cap: uint := if new_size == 0 { 1 } else { new_size };
-        self.ptr = mem_zeroed(new_cap * self.elem_size);
-        mem_copy(self.ptr, old_ptr, i * self.elem_size);
+        self.ptr = mem.raw_zeroed(new_cap * self.elem_size);
+        mem.copy(self.ptr, old_ptr, i * self.elem_size);
         unsafe {
-            mem_copy(
+            mem.copy(
                 @ptr_add(self.ptr, i * self.elem_size),
                 @ptr_add(old_ptr, (i + size) * self.elem_size),
                 (self.len - i - size) * self.elem_size
             );
             if no_slices {
-                mem_dealloc(old_ptr);
+                mem.raw_dealloc(old_ptr);
             }
         }
         self.len = new_size;
@@ -154,7 +156,7 @@ struct DynArray {
         if self.len != rhs.len {
             return false;
         }
-        return mem_cmp(self.ptr, rhs.ptr, self.len) == 0;
+        return mem.cmp(self.ptr, rhs.ptr, self.len) == 0;
     }
 
     #[inline]
@@ -171,8 +173,8 @@ struct DynArray {
             cap *= 2;
         }
         new_size := cap * self.elem_size;
-        new_ptr := mem_alloc(new_size);
-        mem_copy(new_ptr, self.ptr, self.len * self.elem_size);
+        new_ptr := mem.raw_alloc(new_size);
+        mem.copy(new_ptr, self.ptr, self.len * self.elem_size);
         self.ptr = new_ptr;
         self.cap = cap;
     }
@@ -204,14 +206,14 @@ struct DynArray {
         if size == 0 {
             size = 1;
         }
-        dyn_array := Self(mem_zeroed(size), self.elem_size, self.len, self.cap);
-        mem_copy(dyn_array.ptr, self.ptr, size);
+        dyn_array := Self(mem.raw_zeroed(size), self.elem_size, self.len, self.cap);
+        mem.copy(dyn_array.ptr, self.ptr, size);
         return dyn_array;
     }
 
     func __destroy__(self) {
         unsafe {
-            mem_dealloc(self.ptr);
+            mem.raw_dealloc(self.ptr);
         }
     }
 }
diff --git a/lib/core/src/Slice.ri b/lib/core/src/Slice.ri
@@ -2,6 +2,8 @@
 // source code is governed by an MIT license that can be found in the LICENSE
 // file.
 
+import ./mem;
+
 struct Slice {
     ptr: rawptr;
     elem_size: uint;
@@ -29,7 +31,7 @@ struct Slice {
             runtime_error("slice index out of range (index: {}, len: {})", idx, self.len);
         }
         unsafe {
-            mem_copy(
+            mem.copy(
                 @ptr_add(@as([&]mut uint8, self.ptr), self.elem_size * idx),
                 val, self.elem_size
             );
@@ -71,7 +73,7 @@ struct Slice {
         if self.len != rhs.len {
             return false;
         }
-        return mem_cmp(self.ptr, rhs.ptr, self.len) == 0;
+        return mem.cmp(self.ptr, rhs.ptr, self.len) == 0;
     }
 
     #[inline]

diff --git a/lib/core/src/StringBuilder.c.ri b/lib/core/src/StringBuilder.c.ri
@@ -3,6 +3,7 @@
 // file.
 
 import c/libc;
+import ./mem;
 
 #[boxed]
 pub struct StringBuilder < Stringable {
@@ -42,7 +43,7 @@ pub struct StringBuilder < Stringable {
     #[unsafe]
     pub func write_raw_with_len(mut self, s: [&]uint8, len: uint) {
         self.inner.reserve(self.inner.len + len);
-        mem_copy(
+        mem.copy(
             unsafe { @ptr_add(self.inner.ptr, self.inner.elem_size * self.inner.len) },
             s, len
         );

diff --git a/lib/core/src/array.c.ri b/lib/core/src/array.c.ri
@@ -3,12 +3,13 @@
 // file.
 
 import c/libc;
+import ./mem;
 
 func array_init_set(arr: rawptr, elem_size: uint, len: uint, value: rawptr) {
     mut i: uint := 0;
     while i < len : i += 1 {
         unsafe {
-            mem_copy(@ptr_add(@as([&]mut uint8, arr), elem_size * i), value, elem_size);
+            mem.copy(@ptr_add(@as([&]mut uint8, arr), elem_size * i), value, elem_size);
         }
     }
 }

diff --git a/lib/core/src/backtrace.c.ri b/lib/core/src/backtrace.c.ri
@@ -6,6 +6,7 @@ $if !_RELEASE_ { // skip backtrace in release mode
     #![compile_c_source("../thirdparty/libbacktrace/backtrace.c")]
 
     import c;
+    import ./mem;
 
     struct BacktraceState;
 
@@ -40,7 +41,7 @@ $if !_RELEASE_ { // skip backtrace in release mode
     ) -> int32 {
         unsafe {
             if safe_fn_ptr := fn_ptr {
-                if mem_cmp(safe_fn_ptr, c"_R4core4mainF", 13) == 0 {
+                if mem.cmp(safe_fn_ptr, c"_R4core4mainF", 13) == 0 {
                     return -1; // stop backtracing
                 }
             }

diff --git a/lib/core/src/int.ri b/lib/core/src/int.ri
@@ -2,6 +2,8 @@
 // source code is governed by an MIT license that can be found in the LICENSE
 // file.
 
+import ./mem;
+
 var digit_pairs := "0010203040506070809001112131415161718191021222324252627"
     "28292031323334353637383930414243444546474849405152535455565758595061626364656667"
     "68696071727374757677787970818283848586878889809192939495969798999";
@@ -54,7 +56,7 @@ extend int32 < Stringable {
         }
         unsafe {
             mut index := @as(uint, max);
-            buf := @as([&]mut uint8, mem_alloc(index + 1));
+            buf := @as([&]mut uint8, mem.raw_alloc(index + 1));
             buf[index] = 0;
             index -= 1;
 
@@ -82,7 +84,7 @@ extend int32 < Stringable {
             }
 
             diff := @as(uint, max) - index;
-            mem_move(buf, @ptr_add(buf, index), diff + 1);
+            mem.move(buf, @ptr_add(buf, index), diff + 1);
             return string.from_raw_with_len(buf, diff);
         }
     }
@@ -114,7 +116,7 @@ extend int64 < Stringable {
         unsafe {
             max := 20;
             mut index := @as(uint, max);
-            buf := @as([&]mut uint8, mem_alloc(index + 1));
+            buf := @as([&]mut uint8, mem.raw_alloc(index + 1));
             buf[index] = 0;
             index -= 1;
 
@@ -142,7 +144,7 @@ extend int64 < Stringable {
             }
 
             diff := @as(uint, max) - index;
-            mem_move(buf, @ptr_add(buf, index), diff + 1);
+            mem.move(buf, @ptr_add(buf, index), diff + 1);
             return string.from_raw_with_len(buf, diff);
         }
     }