Merge pull request #229 from nature-lang/feature/union_variable_size

feat: type_union value variable size

Author: weiwenhao

runtime/allocator.c

@@ -5,7 +5,7 @@
 static uint8_t calc_sizeclass(uint64_t size) {
     // 快速路径：精确判断常见大小
     if (size == 1) return 1; // class 1: 8 bytes
-    if (size == 2) return 2; // class 2: 16 bytes, n_union_t,n_interface_t
+    if (size == 2) return 2; // class 2: 16 bytes, small structs (e.g. n_interface_t)
     if (size == 40) return 5; // class 5: 48 bytes, n_string_t/n_vec_t
     if (size == 56) return 6; // class 6: 64 bytes, n_map_t
     if (size == 128) return 10; // class 10: 128 bytes, map default space

runtime/builtin.c

@@ -11,7 +11,7 @@ static char *space = " ";
 
 // type_any_t 是 nature 中的类型，在 c 中是认不出来的
 // 这里按理来说应该填写 void*, 写 type_any_t 就是为了语义明确
-static void print_arg(n_union_t *arg) {
+static void print_arg(n_any_t *arg) {
     char sprint_buf[1024];
 
     assert(arg && "[runtime.print_arg] arg is null");
@@ -20,9 +20,11 @@ static void print_arg(n_union_t *arg) {
     DEBUGF("[runtime.print_arg] arg->rtype=%p, kind=%s, arg->value=%lu", arg->rtype, type_kind_str[arg->rtype->kind],
            arg->value.i64_value);
 
+    void *value_ptr = arg->value.ptr_value;
+
     if (arg->rtype->kind == TYPE_STRING) {
         // n_string_t 在内存视角，应该是由 2 块内存组成，一个是字符个数，一个是指向的数据结构(同样是内存视角)
-        n_string_t *s = arg->value.ptr_value;// 字符串的内存视角
+        n_string_t *s = value_ptr;// 字符串的内存视角
         assert(s && "[runtime.print_arg] string is null");
 
         DEBUGF("[runtime.print_arg] string=%p, length=%lu, data=%p, len=%lu, cap=%lu, hash=%ld, element_size=%ld",
@@ -115,7 +117,7 @@ static void print_arg(n_union_t *arg) {
     }
 
     // 其他所有类型都打印 ptr 地址
-    int n = sprintf(sprint_buf, "%p", arg->value.ptr_value);
+    int n = sprintf(sprint_buf, "%p", value_ptr);
     VOID write(STDOUT_FILENO, sprint_buf, n);
 }
 
@@ -133,12 +135,12 @@ void print(n_vec_t args) {
         addr_t p = base + (i * element_size);
 
         // 将 p 中存储的地址赋值给 a, 此时 a 中存储的是一个堆中的地址，其结构是 memory_any_t
-        // void* p 只是转换为指针类型，而不会读取其中的值，所以这里 n_union_t* 是目标值, *value 才是读取 p 中的地址
-        n_union_t *union_arg = (n_union_t *) p;
+        // void* p 只是转换为指针类型，而不会读取其中的值，所以这里 n_any_t* 是目标值, *value 才是读取 p 中的地址
+        n_any_t *any_arg = (n_any_t *) p;
 
-        DEBUGF("[runtime.print] union arg i=%d, addr=%p, union_arg_value=%p ", i, (void *) p, union_arg);
+        DEBUGF("[runtime.print] any arg i=%d, addr=%p, any_arg_value=%p ", i, (void *) p, any_arg);
 
-        print_arg(union_arg);
+        print_arg(any_arg);
     }
 }
 
@@ -155,12 +157,12 @@ void println(n_vec_t args) {
         addr_t p = base + (i * element_size);
 
         // 将 p 中存储的地址赋值给 a, 此时 a 中存储的是一个堆中的地址，其结构是 memory_any_t
-        // void* p 只是转换为指针类型，而不会读取其中的值，所以这里 n_union_t* 是目标值, *value 才是读取 p 中的地址
-        n_union_t *union_arg = (n_union_t *) p;
+        // void* p 只是转换为指针类型，而不会读取其中的值，所以这里 n_any_t* 是目标值, *value 才是读取 p 中的地址
+        n_any_t *any_arg = (n_any_t *) p;
 
-        DEBUGF("[runtime.println] union arg i=%d, addr=%p, union_arg_value=%p ", i, (void *) p, union_arg);
+        DEBUGF("[runtime.println] any arg i=%d, addr=%p, any_arg_value=%p ", i, (void *) p, any_arg);
 
-        print_arg(union_arg);
+        print_arg(any_arg);
 
         if (i < (args.length - 1)) {
             VOID write(STDOUT_FILENO, space, 1);

runtime/nutils/map.c

@@ -117,6 +117,12 @@ n_map_t *rt_map_alloc(uint64_t rtype_hash, uint64_t key_rhash, uint64_t value_rh
     return map_heap;
 }
 
+void rt_map_new_out(n_map_t *out, uint64_t rtype_hash, uint64_t key_rhash, uint64_t value_rhash) {
+    n_map_t map_data = rt_map_new(rtype_hash, key_rhash, value_rhash);
+    *out = map_data;
+    DEBUGF("[rt_map_new_out] success, out=%p, len=%lu, cap=%lu", out, out->length, out->capacity);
+}
+
 /**
  * m["key"] = v
  * @param m

runtime/nutils/map.h

@@ -9,6 +9,8 @@ n_map_t rt_map_new(uint64_t rtype_hash, uint64_t key_rhash, uint64_t value_rhash
 
 n_map_t *rt_map_alloc(uint64_t rtype_hash, uint64_t key_rhash, uint64_t value_rhash);
 
+void rt_map_new_out(n_map_t *out, uint64_t rtype_hash, uint64_t key_rhash, uint64_t value_rhash);
+
 uint64_t rt_map_length(n_map_t *l);
 
 void map_grow(n_map_t *m);

runtime/nutils/nutils.c

@@ -81,20 +81,46 @@ void union_assert(n_union_t *mu, int64_t target_rtype_hash, void *value_ref) {
 
     rtype_t *rtype = rt_find_rtype(target_rtype_hash);
     if (rtype->storage_kind == STORAGE_KIND_IND) {
-        memmove(value_ref, mu->value.ptr_value, rtype->storage_size);
+        memmove(value_ref, &mu->value.struct_, rtype->storage_size);
     } else {
         memmove(value_ref, &mu->value, rtype->storage_size);
     }
     DEBUGF(
             "[union_assert] success, union_base: %p, union_rtype_kind: %s, heap_out_size: %lu, union_i64_value: %ld, "
             "values_ref: %p",
-            mu, type_kind_str[mu->rtype->kind], size, mu->value.i64_value, value_ref);
+            mu, type_kind_str[mu->rtype->kind], rtype->storage_size, mu->value.i64_value, value_ref);
+}
+
+void any_assert(n_any_t *mu, int64_t target_rtype_hash, void *value_ref) {
+    if (mu->rtype->hash != target_rtype_hash) {
+        DEBUGF("[any_assert] type assert failed, mu->rtype->kind: %s, target_rtype_hash: %ld",
+               type_kind_str[mu->rtype->kind],
+               target_rtype_hash);
+
+        rti_throw("type assert failed", true);
+        return;
+    }
+
+    rtype_t *rtype = rt_find_rtype(target_rtype_hash);
+    if (rtype->storage_kind == STORAGE_KIND_IND) {
+        memmove(value_ref, mu->value.ptr_value, rtype->storage_size);
+    } else {
+        memmove(value_ref, &mu->value, rtype->storage_size);
+    }
+    DEBUGF(
+            "[any_assert] success, any_base: %p, any_rtype_kind: %s, heap_out_size: %lu, any_i64_value: %ld, "
+            "values_ref: %p",
+            mu, type_kind_str[mu->rtype->kind], rtype->storage_size, mu->value.i64_value, value_ref);
 }
 
 bool union_is(n_union_t *mu, int64_t target_rtype_hash) {
     return mu->rtype->hash == target_rtype_hash;
 }
 
+bool any_is(n_any_t *mu, int64_t target_rtype_hash) {
+    return mu->rtype->hash == target_rtype_hash;
+}
+
 bool interface_is(n_interface_t *mu, int64_t target_rtype_hash) {
     return mu->rtype->hash == target_rtype_hash;
 }
@@ -163,7 +189,8 @@ n_interface_t *interface_casting(uint64_t input_rtype_hash, void *value_ref, int
  * @param value
  * @return
  */
-n_union_t union_casting(int64_t input_rtype_hash, void *value_ref) {
+void union_casting(n_union_t *out, int64_t input_rtype_hash, void *value_ref) {
+    assert(out && "union_casting out is null");
     // - 根据 input_rtype_hash 找到对应的
     rtype_t *rtype = rt_find_rtype(input_rtype_hash);
     assert(rtype && "cannot find rtype by hash");
@@ -172,41 +199,92 @@ n_union_t union_casting(int64_t input_rtype_hash, void *value_ref) {
 
     TRACEF("[union_casting] input_kind=%s", type_kind_str[rtype->kind]);
 
+    DEBUGF("[union_casting] union_base: %p, memmove value_ref(%p) -> any->value(%p), size=%lu, fetch_value_8byte=%p",
+           out, value_ref,
+           &out->value, rtype->storage_size, (void *) fetch_addr_value((addr_t) value_ref));
+    out->rtype = rtype;
+
+    uint64_t storage_size = rtype->storage_size;
+    out->value.i64_value = 0;
+
+    if (rtype->storage_kind == STORAGE_KIND_IND) {
+        memmove(&out->value.struct_, value_ref, storage_size);
+    } else {
+        memmove(&out->value, value_ref, storage_size);
+    }
 
-    n_union_t mu = {0};
 
-    DEBUGF("[union_casting] union_base: %p, memmove value_ref(%p) -> any->value(%p), size=%lu, fetch_value_8byte=%p",
-           &mu, value_ref,
-           &mu.value, rtype->storage_size, (void *) fetch_addr_value((addr_t) value_ref));
-    mu.rtype = rtype;
+    DEBUGF("[union_casting] success, union_base: %p, union_rtype: %p, union_i64_value: %ld", out, out->rtype,
+           out->value.i64_value);
+}
+
+/**
+ * any 参考旧版 union 处理 storage_ind 类型
+ * @param input_rtype_hash
+ * @param value_ref
+ * @return
+ */
+void any_casting(n_any_t *out, int64_t input_rtype_hash, void *value_ref) {
+    assert(out && "any_casting out is null");
+    // - 根据 input_rtype_hash 找到对应的
+    rtype_t *rtype = rt_find_rtype(input_rtype_hash);
+    assert(rtype && "cannot find rtype by hash");
+
+    ASSERT_ADDR(value_ref);
+
+    TRACEF("[any_casting] input_kind=%s", type_kind_str[rtype->kind]);
+
+    DEBUGF("[any_casting] any_base: %p, memmove value_ref(%p) -> any->value(%p), size=%lu, fetch_value_8byte=%p",
+            out, value_ref,
+            &out->value, rtype->storage_size, (void *) fetch_addr_value((addr_t) value_ref));
+    out->rtype = rtype;
 
     uint64_t storage_size = rtype->storage_size;
+    out->value.i64_value = 0;
 
-    // TODO union 产生了 GC? 这个问题稍后再解决。甚至现在总是会产生 GC。
-    // 甚至 return union 类型变得寸步难行。
     if (rtype->storage_kind == STORAGE_KIND_IND) {
-        // union 进行了数据的额外缓存，并进行值 copy，不需要担心 arr/struct 这样的大数据的丢失问题
         void *new_value = rti_gc_malloc(rtype->gc_heap_size, rtype);
         memmove(new_value, value_ref, storage_size);
-        mu.value.ptr_value = new_value;
+        out->value.ptr_value = new_value;
     } else {
-        memmove(&mu.value, value_ref, storage_size);
+        memmove(&out->value, value_ref, storage_size);
     }
 
+    DEBUGF("[any_casting] success, any_base: %p, any_rtype: %p, any_i64_value: %ld", out, out->rtype,
+           out->value.i64_value);
+}
 
-    DEBUGF("[union_casting] success, union_base: %p, union_rtype: %p, union_i64_value: %ld", &mu, mu.rtype,
-           mu.value.i64_value);
+/**
+ * union -> any: 提取 union 的 rtype 和 value 传递给 any_casting
+ */
+void union_to_any(n_any_t *out, n_union_t *input) {
+    assert(out && "union_to_any out is null");
+    assert(input && "union_to_any input is null");
+    assert(input->rtype && "union_to_any input rtype is null");
 
-    return mu;
+    rtype_t *rtype = input->rtype;
+
+    DEBUGF("[union_to_any] input rtype kind=%s, hash=%ld", type_kind_str[rtype->kind], rtype->hash);
+
+    // union value 根据 storage_kind 确定 value_ref
+    void *value_ref;
+    if (rtype->storage_kind == STORAGE_KIND_IND) {
+        value_ref = &input->value.struct_;
+    } else {
+        value_ref = &input->value;
+    }
+
+    any_casting(out, rtype->hash, value_ref);
 }
 
-n_tagged_union_t tagged_union_casting(int64_t tag_hash, int64_t value_rtype_hash, void *value_ref) {
+void tagged_union_casting(n_tagged_union_t *out, int64_t tag_hash, int64_t value_rtype_hash, void *value_ref) {
+    assert(out && "tagged_union_casting out is null");
     DEBUGF("[tagged_union_casting] tag_hash=%ld, value_hash=%ld", tag_hash, value_rtype_hash);
 
-    n_tagged_union_t mu = {0};
-    mu.tag_hash = tag_hash;
+    out->tag_hash = tag_hash;
+    out->value.i64_value = 0;
     if (value_rtype_hash == 0) {
-        return mu;
+        return;
     }
 
     // - 根据 input_rtype_hash 找到对应的
@@ -217,24 +295,18 @@ n_tagged_union_t tagged_union_casting(int64_t tag_hash, int64_t value_rtype_hash
 
     DEBUGF(
             "[tagged_union_casting] union_base: %p, memmove value_ref(%p) -> any->value(%p), kind=%s, size=%lu, fetch_value_8byte=%p",
-            &mu, value_ref,
-            &mu.value, type_kind_str[rtype->kind], rtype->storage_size, (void *) fetch_addr_value((addr_t) value_ref));
+            out, value_ref,
+            &out->value, type_kind_str[rtype->kind], rtype->storage_size, (void *) fetch_addr_value((addr_t) value_ref));
 
     uint64_t storage_size = rtype->storage_size;
     if (rtype->storage_kind == STORAGE_KIND_IND) {
-        // union 进行了数据的额外缓存，并进行值 copy，不需要担心 arr/struct 这样的大数据的丢失问题
-        void *new_value = rti_gc_malloc(rtype->gc_heap_size, rtype);
-        memmove(new_value, value_ref, storage_size);
-
-        mu.value.ptr_value = new_value;
+        memmove(&out->value.struct_, value_ref, storage_size);
     } else {
-        memmove(&mu.value, value_ref, storage_size);
+        memmove(&out->value, value_ref, storage_size);
     }
 
-    DEBUGF("[tagged_union_casting] success, base: %p, id: %ld, union_i64_value: %ld", &mu, mu.tag_hash,
-           mu.value.i64_value);
-
-    return mu;
+    DEBUGF("[tagged_union_casting] success, base: %p, id: %ld, union_i64_value: %ld", out, out->tag_hash,
+           out->value.i64_value);
 }
 
 
@@ -400,9 +472,9 @@ void co_throw_error(n_interface_t *error, char *path, char *fn_name, n_int_t lin
 
     n_string_t err_msg = rti_error_msg(error);
     DEBUGF("[runtime.co_throw_error] co=%p, error=%p, path=%s, fn_name=%s, line=%ld, column=%ld, msg=%s", co,
-            (void *) error, path, fn_name,
-            line,
-            column, (char *) rt_string_ref(&err_msg));
+           (void *) error, path, fn_name,
+           line,
+           column, (char *) rt_string_ref(&err_msg));
 
     assert(co->traces.data == NULL);
     n_vec_t traces = rti_vec_new(&errort_trace_rtype, 0, 0);

runtime/nutils/nutils.h

@@ -15,21 +15,29 @@ extern char **command_argv;
 
 void union_assert(n_union_t *mu, int64_t target_rtype_hash, void *value_ref);
 
+void any_assert(n_any_t *mu, int64_t target_rtype_hash, void *value_ref);
+
 void interface_assert(n_interface_t *mu, int64_t target_rtype_hash, void *value_ref);
 
 bool union_is(n_union_t *mu, int64_t target_rtype_hash);
 
+bool any_is(n_any_t *mu, int64_t target_rtype_hash);
+
 bool interface_is(n_interface_t *mu, int64_t target_rtype_hash);
 
 /**
  * input rtype index 是 value 具体的类型
+ * @param out
  * @param input_rtype_hash
  * @param value_ref
- * @return
  */
-n_union_t union_casting(int64_t input_rtype_hash, void *value_ref);
+void union_casting(n_union_t *out, int64_t input_rtype_hash, void *value_ref);
+
+void any_casting(n_any_t *out, int64_t input_rtype_hash, void *value_ref);
+
+void union_to_any(n_any_t *out, n_union_t *input);
 
-n_tagged_union_t tagged_union_casting(int64_t id, int64_t value_rtype_hash, void *value_ref);
+void tagged_union_casting(n_tagged_union_t *out, int64_t id, int64_t value_rtype_hash, void *value_ref);
 
 n_interface_t *interface_casting(uint64_t input_rtype_hash, void *value_ref, int64_t method_count, int64_t *methods);
 

runtime/nutils/set.c

@@ -118,6 +118,12 @@ n_set_t rt_set_new(uint64_t rtype_hash, uint64_t key_hash) {
     return set_data;
 }
 
+void rt_set_new_out(n_set_t *out, uint64_t rtype_hash, uint64_t key_hash) {
+    n_set_t set_data = rt_set_new(rtype_hash, key_hash);
+    *out = set_data;
+    DEBUGF("[rt_set_new_out] success, out=%p, len=%lu, cap=%lu", out, out->length, out->capacity);
+}
+
 /**
  * 如果值已经存在则返回 false
  * @param m

runtime/nutils/set.h

@@ -11,6 +11,8 @@
 
 n_set_t rt_set_new(uint64_t rtype_hash, uint64_t key_hash);
 
+void rt_set_new_out(n_set_t *out, uint64_t rtype_hash, uint64_t key_hash);
+
 bool rt_set_add(n_set_t *m, void *key_ref);
 
 bool rt_set_contains(n_set_t *m, void *key_ref);

runtime/nutils/vec.c

@@ -164,6 +164,13 @@ n_vec_t *rt_vec_alloc(int64_t hash, int64_t element_hash, int64_t capacity) {
     return vec_heap;
 }
 
+void rt_vec_new_out(n_vec_t *out, int64_t hash, int64_t element_hash, int64_t capacity) {
+    n_vec_t vec = rt_vec_cap(hash, element_hash, capacity);
+    *out = vec;
+    DEBUGF("[rt_vec_new_out] success, out=%p, data=%p, element_size=%lu, cap=%d", out, out->data,
+           out->element_size, capacity);
+}
+
 /**
  * @param l
  * @param index

runtime/nutils/vec.h

@@ -27,6 +27,8 @@ n_vec_t rt_vec_cap(int64_t hash, int64_t element_hash, int64_t capacity);
 
 n_vec_t *rt_vec_alloc(int64_t hash, int64_t element_hash, int64_t capacity);
 
+void rt_vec_new_out(n_vec_t *out, int64_t hash, int64_t element_hash, int64_t capacity);
+
 n_anyptr_t rt_vec_element_addr(n_vec_t *l, uint64_t index);
 
 /**