Merge pull request #228 from nature-lang/feature/string_vec_map_set_to_value

feat: string/vec/map/set to value

Author: weiwenhao

runtime/allocator.c

@@ -1482,7 +1482,7 @@ void *gc_malloc(uint64_t rhash) {
            bitmap_to_str(RTDATA(rtype->malloc_gc_bits_offset),
                          calc_gc_bits_size(rtype->heap_size, POINTER_SIZE)));
 
-    void *result = rti_gc_malloc(rtype->heap_size, rtype);
+    void *result = rti_gc_malloc(rtype->gc_heap_size, rtype);
     DEBUGF("[gc_malloc] size %lu, value %p", rtype->heap_size, result);
     return result;
 }

runtime/builtin.c

@@ -120,16 +120,16 @@ static void print_arg(n_union_t *arg) {
 }
 
 
-void print(n_vec_t *args) {
+void print(n_vec_t args) {
     // any_trans 将 int 转换成了堆中的一段数据，并将堆里面的其实地址返回了回去
-    // 所以 args->data 是一个堆里面的地址，其指向的堆内存区域是 [any_start_ptr1, any_start_ptr2m, ...]
-    addr_t base = (addr_t) args->data;// 把 data 中存储的值赋值给 p
-    uint64_t element_size = args->element_size;
+    // 所以 args.data 是一个堆里面的地址，其指向的堆内存区域是 [any_start_ptr1, any_start_ptr2m, ...]
+    addr_t base = (addr_t) args.data;// 把 data 中存储的值赋值给 p
+    uint64_t element_size = args.element_size;
 
-    DEBUGF("[runtime.print] args vec=%p, len=%lu, data=%p, element_size=%lu", args, args->length, (void *) base,
+    DEBUGF("[runtime.print] args len=%lu, data=%p, element_size=%lu", args.length, (void *) base,
            element_size);
 
-    for (int i = 0; i < args->length; ++i) {
+    for (int i = 0; i < args.length; ++i) {
         addr_t p = base + (i * element_size);
 
         // 将 p 中存储的地址赋值给 a, 此时 a 中存储的是一个堆中的地址，其结构是 memory_any_t
@@ -142,16 +142,16 @@ void print(n_vec_t *args) {
     }
 }
 
-void println(n_vec_t *args) {
+void println(n_vec_t args) {
     // any_trans 将 int 转换成了堆中的一段数据，并将堆里面的其实地址返回了回去
-    // 所以 args->data 是一个堆里面的地址，其指向的堆内存区域是 [any_start_ptr1, any_start_ptr2m, ...]
-    addr_t base = (addr_t) args->data;// 把 data 中存储的值赋值给 p
-    uint64_t element_size = args->element_size;
+    // 所以 args.data 是一个堆里面的地址，其指向的堆内存区域是 [any_start_ptr1, any_start_ptr2m, ...]
+    addr_t base = (addr_t) args.data;// 把 data 中存储的值赋值给 p
+    uint64_t element_size = args.element_size;
 
-    DEBUGF("[runtime.println] args vec=%p, len=%lu, data=%p, element_size=%lu", args, args->length, (void *) base,
+    DEBUGF("[runtime.println] args len=%lu, data=%p, element_size=%lu", args.length, (void *) base,
            element_size);
 
-    for (int i = 0; i < args->length; ++i) {
+    for (int i = 0; i < args.length; ++i) {
         addr_t p = base + (i * element_size);
 
         // 将 p 中存储的地址赋值给 a, 此时 a 中存储的是一个堆中的地址，其结构是 memory_any_t
@@ -162,7 +162,7 @@ void println(n_vec_t *args) {
 
         print_arg(union_arg);
 
-        if (i < (args->length - 1)) {
+        if (i < (args.length - 1)) {
             VOID write(STDOUT_FILENO, space, 1);
         }
     }

runtime/builtin.h

@@ -3,8 +3,8 @@
 
 #include "utils/type.h"
 
-void print(n_vec_t *args);
+void print(n_vec_t args);
 
-void println(n_vec_t *args);
+void println(n_vec_t args);
 
 #endif //NATURE_SRC_LIR_NATIVE_BUILTIN_H_

runtime/collector.c

@@ -187,13 +187,15 @@ static bool sweep_span(mcentral_t *central, mspan_t *span) {
             allocated_bytes -= span->obj_size;
             has_freed = true;
 
-            DEBUGF("[sweep_span] will sweep, span_base=%p obj_addr=%p", span->base, (void *) (span->base + i * span->obj_size));
+            DEBUGF("[sweep_span] will sweep, span_base=%p obj_addr=%p", span->base,
+                   (void *) (span->base + i * span->obj_size));
             // memset((void *) (span->base + i * span->obj_size), 0, span->obj_size);
         } else {
-            DEBUGF("[sweep_span] will sweep, span_base=%p, obj_addr=%p, not calc allocated_bytes, alloc_bit=%d, gcmark_bit=%d",
-                   span->base,
-                   (void *) (span->base + i * span->obj_size), bitmap_test(span->alloc_bits, i),
-                   bitmap_test(span->gcmark_bits, i));
+            DEBUGF(
+                "[sweep_span] will sweep, span_base=%p, obj_addr=%p, not calc allocated_bytes, alloc_bit=%d, gcmark_bit=%d",
+                span->base,
+                (void *) (span->base + i * span->obj_size), bitmap_test(span->alloc_bits, i),
+                bitmap_test(span->gcmark_bits, i));
         }
     }
 
@@ -330,11 +332,11 @@ static void scan_stack(n_processor_t *p, coroutine_t *co) {
     addr_t sp_value = (addr_t) co->aco.reg[ACO_REG_IDX_SP];
 
     DEBUGF(
-            "[runtime_gc.scan_stack] start, p_index=%d(%lu), p_status=%d, co=%p, co_status=%d, co_stack_size=%zu, save_stack=%p(%zu), "
-            "bp_value=%p, sp_value=%p, share_stack.base=%p",
-            p->index, (uint64_t) p->thread_id, p->status, co, co->status, co->aco.save_stack.valid_sz,
-            co->aco.save_stack.ptr,
-            co->aco.save_stack.sz, bp_value, sp_value, co->aco.share_stack->align_retptr);
+        "[runtime_gc.scan_stack] start, p_index=%d(%lu), p_status=%d, co=%p, co_status=%d, co_stack_size=%zu, save_stack=%p(%zu), "
+        "bp_value=%p, sp_value=%p, share_stack.base=%p",
+        p->index, (uint64_t) p->thread_id, p->status, co, co->status, co->aco.save_stack.valid_sz,
+        co->aco.save_stack.ptr,
+        co->aco.save_stack.sz, bp_value, sp_value, co->aco.share_stack->align_retptr);
 
     // save_stack 也是通过 gc 申请，即使是 gc_work 也需要标记一下
     assert(p->gc_work_finished < memory->gc_count && "gc work finished, cannot insert to gc worklist");
@@ -352,8 +354,8 @@ static void scan_stack(n_processor_t *p, coroutine_t *co) {
         insert_gc_worklist(worklist, co->error);
     }
 
-    if (co->traces) {
-        insert_gc_worklist(worklist, co->traces);
+    if (co->traces.data && span_of((addr_t) co->traces.data)) {
+        insert_gc_worklist(worklist, co->traces.data);
     }
 
     if (co->flag & FLAG(CO_FLAG_RTFN)) {
@@ -408,7 +410,9 @@ static void scan_stack(n_processor_t *p, coroutine_t *co) {
 
         if (ret_addr == assist_preempt_yield_ret_addr) {
             found_assist = true;
-            DEBUGF("[runtime_gc.scan_stack] find assist_preempt_yield_ret_addr %p, conservative treatment will be carried out", (void *) assist_preempt_yield_ret_addr);
+            DEBUGF(
+                "[runtime_gc.scan_stack] find assist_preempt_yield_ret_addr %p, conservative treatment will be carried out",
+                (void *) assist_preempt_yield_ret_addr);
             break;
         }
         // check prev value is nature fn
@@ -489,8 +493,9 @@ static void scan_stack(n_processor_t *p, coroutine_t *co) {
 
         fndef_t *fn = find_fn(ret_addr, p);
         if (!fn) {
-            DEBUGF("[runtime_gc.scan_stack] fn not found by ret_addr, return_addr=%p, share_stack_frame_bp=%p, bp_offset = %ld",
-                   (void *) ret_addr, (void *) share_stack_frame_bp, share_stack_frame_bp - sp_value);
+            DEBUGF(
+                "[runtime_gc.scan_stack] fn not found by ret_addr, return_addr=%p, share_stack_frame_bp=%p, bp_offset = %ld",
+                (void *) ret_addr, (void *) share_stack_frame_bp, share_stack_frame_bp - sp_value);
 
             // next and continue
             addr_t bp_offset = share_stack_frame_bp - sp_value;
@@ -591,11 +596,12 @@ static void handle_gc_ptr(n_processor_t *p, addr_t addr) {
     }
 
     bitmap_set(span->gcmark_bits, obj_index);
-    DEBUGF("[runtime_gc.handle_gc_ptr] addr=%p, span=%p, span_base=%p, obj_index=%lu marked, test=%d, obj_size=%d, spanclass_has_ptr=%d",
-           (void *) addr,
-           span,
-           (void *) span->base,
-           obj_index, bitmap_test(span->gcmark_bits, obj_index), span->obj_size, spanclass_has_ptr(span->spanclass));
+    DEBUGF(
+        "[runtime_gc.handle_gc_ptr] addr=%p, span=%p, span_base=%p, obj_index=%lu marked, test=%d, obj_size=%d, spanclass_has_ptr=%d",
+        (void *) addr,
+        span,
+        (void *) span->base,
+        obj_index, bitmap_test(span->gcmark_bits, obj_index), span->obj_size, spanclass_has_ptr(span->spanclass));
 
     mutex_unlock(&span->gcmark_locker);
 
@@ -621,9 +627,9 @@ static void handle_gc_ptr(n_processor_t *p, addr_t addr) {
             addr_t value = fetch_addr_value(temp_addr);
 
             DEBUGF(
-                    "[handle_gc_ptr] addr is ptr,base=%p cursor=%p cursor_value=%p, obj_size=%ld, bit_index=%lu, in_heap=%d",
-                    (void *) addr,
-                    (void *) temp_addr, (void *) value, span->obj_size, bit_index, in_heap(value));
+                "[handle_gc_ptr] addr is ptr,base=%p cursor=%p cursor_value=%p, obj_size=%ld, bit_index=%lu, in_heap=%d",
+                (void *) addr,
+                (void *) temp_addr, (void *) value, span->obj_size, bit_index, in_heap(value));
 
             if (span_of(value)) {
                 // assert(span_of(heap_addr) && "heap_addr not belong active span");
@@ -640,9 +646,9 @@ static void handle_gc_ptr(n_processor_t *p, addr_t addr) {
             }
         } else {
             DEBUGF(
-                    "[handle_gc_ptr] addr not ptr,base=%p cursor=%p cursor_value(int)=%p, obj_size=%ld, bit_index=%lu",
-                    (void *) addr,
-                    (void *) temp_addr, fetch_int_value(temp_addr, POINTER_SIZE), span->obj_size, bit_index);
+                "[handle_gc_ptr] addr not ptr,base=%p cursor=%p cursor_value(int)=%p, obj_size=%ld, bit_index=%lu",
+                (void *) addr,
+                (void *) temp_addr, fetch_int_value(temp_addr, POINTER_SIZE), span->obj_size, bit_index);
         }
     }
 }
@@ -703,10 +709,10 @@ static void gc_work() {
         current = current->succ;
 
         DEBUGF(
-                "[runtime_gc.gc_work] will scan_stack p_index=%d, co=%p, status=%d, is_main=%d, gc_black=%lu/gc_count=%lu, aco=%p",
-                share_p->index,
-                wait_co, wait_co->status, wait_co->main, wait_co->gc_black, memory->gc_count,
-                &wait_co->aco);
+            "[runtime_gc.gc_work] will scan_stack p_index=%d, co=%p, status=%d, is_main=%d, gc_black=%lu/gc_count=%lu, aco=%p",
+            share_p->index,
+            wait_co, wait_co->status, wait_co->main, wait_co->gc_black, memory->gc_count,
+            &wait_co->aco);
 
         if (wait_co->status == CO_STATUS_DEAD) {
             DEBUGF("[runtime_gc.gc_work] co=%p, main=%d, status=dead, will remove",
@@ -820,7 +826,9 @@ static void scan_pool() {
     n_processor_t *p = processor_index[0];
     n_string_t *value;
     sc_map_foreach_value(&const_str_pool, value) {
-        rt_linked_fixalloc_push(&p->gc_worklist, value);
+        if (value && span_of((addr_t) value->data)) {
+            rt_linked_fixalloc_push(&p->gc_worklist, value->data);
+        }
     }
 }
 
@@ -859,7 +867,8 @@ static void scan_global() {
                     gc_bits = (uint8_t *) &rtype->gc_bits;
                 }
 
-                if (bitmap_test(gc_bits, index)) { // need gc
+                if (bitmap_test(gc_bits, index)) {
+                    // need gc
                     addr_t addr = fetch_addr_value(current);
                     if (span_of(addr)) {
                         DEBUGF("[runtime.scan_global] name=%s, kind=%s, base=%p(%p), index=%d, addr=%p need gc",
@@ -1010,8 +1019,10 @@ void runtime_gc() {
     next_gc_bytes = heap_live + (heap_live * GC_PERCENT / 100);
 
     gc_stage = GC_STAGE_OFF;
-    DEBUGF("[runtime_gc] gc stage: GC_OFF, gc_barrier_stop, before=%ldKB, current=%ldKB, cleanup=%ldKB, alloc_total=%ldKB, remove_to_sys=%ldKB, used=%ldKB, next_gc=%ldKB",
-           before / 1024,
-           allocated_bytes / 1024,
-           (before - allocated_bytes) / 1024, allocated_total_bytes / 1024, remove_total_bytes / 1024, (allocated_total_bytes - remove_total_bytes) / 1024, next_gc_bytes / 1024);
+    DEBUGF(
+        "[runtime_gc] gc stage: GC_OFF, gc_barrier_stop, before=%ldKB, current=%ldKB, cleanup=%ldKB, alloc_total=%ldKB, remove_to_sys=%ldKB, used=%ldKB, next_gc=%ldKB",
+        before / 1024,
+        allocated_bytes / 1024,
+        (before - allocated_bytes) / 1024, allocated_total_bytes / 1024, remove_total_bytes / 1024,
+        (allocated_total_bytes - remove_total_bytes) / 1024, next_gc_bytes / 1024);
 }

runtime/linkco.c

@@ -25,7 +25,7 @@ linkco_t *rti_acquire_linkco() {
 
         // 全局借取失败，需要自己 new 一个
         if (p->linkco_count == 0) {
-            linkco_t *linkco = rti_gc_malloc(linkco_rtype.heap_size, &linkco_rtype);
+            linkco_t *linkco = rti_gc_malloc(linkco_rtype.gc_heap_size, &linkco_rtype);
             DEBUGF("[rti_acquire_linkco] p: %d gc_malloc linkco %p", p->index, linkco);
             //            p->linkco_cache[p->linkco_count++] = linkco;
             rti_write_barrier_ptr(&p->linkco_cache[p->linkco_count++], linkco, false);

runtime/memory.c

@@ -101,8 +101,13 @@ void register_const_str_pool() {
             continue;
         }
 
-        n_string_t *str = rt_string_new(s.base);
-        sc_map_put_sv(&const_str_pool, (char *) s.base, str);
+        n_string_t str = rt_string_new(s.base);
+        n_string_t *pool_copy = malloc(sizeof(n_string_t));
+        if (pool_copy == NULL) {
+            continue;
+        }
+        *pool_copy = str;
+        sc_map_put_sv(&const_str_pool, (char *) s.base, pool_copy);
 //        TDEBUGF("[register_const_str_pool] str = %p, str %s", str, (char *) s.base);
     }
 };

runtime/nutils/array.h

@@ -8,7 +8,7 @@
 
 static inline n_array_t *rti_array_new(rtype_t *element_rtype, uint64_t length) {
     assert(element_rtype && "element_rtype is null");
-    assert(element_rtype->heap_size > 0 && "element_rtype size is zero");
+    assert(element_rtype->gc_heap_size > 0 && "element_rtype size is zero");
 
     DEBUGF("[rti_array_new] ele_sz=%lu(rtype_stack_size=%lu),ele_kind=%s(n_gc=%d),len=%lu", element_rtype->heap_size,
            element_rtype->storage_size, type_kind_str[element_rtype->kind],
@@ -18,7 +18,7 @@ static inline n_array_t *rti_array_new(rtype_t *element_rtype, uint64_t length)
     rtype_t rtype = rti_rtype_array(element_rtype, length);
 
     // - 基于 rtype 进行 malloc 的申请调用, 这里进行的是堆内存申请，所以需要的就是其在在堆内存中占用的空间大小
-    void *addr = rti_gc_malloc(rtype.heap_size, &rtype);
+    void *addr = rti_gc_malloc(rtype.gc_heap_size, &rtype);
     DEBUGF(
             "[rti_array_new] success, base=%p, element_rtype.size=%lu, element_rtype.kind=%s(last_ptr=%d), "
             "array_rtype_size=%lu(length=%lu),rtype_kind=%s, rtype_last_ptr=%d",

runtime/nutils/dns.h

@@ -3,6 +3,11 @@
 #include "runtime/processor.h"
 #include <uv.h>
 
+typedef struct {
+    n_string_t host;
+    n_vec_t ips;
+} dns_ctx_t;
+
 static inline void on_dns_resolved_cb(uv_getaddrinfo_t *req, int status, struct addrinfo *res) {
     coroutine_t *co = req->data;
     DEBUGF("[on_dns_resolved_cb] co: %p, status: %d", co, status);
@@ -14,7 +19,8 @@ static inline void on_dns_resolved_cb(uv_getaddrinfo_t *req, int status, struct
     }
 
     // co->data = res; // addr info need use uv_freeaddrinfo free
-    n_vec_t *ips = co->data;
+    dns_ctx_t *ctx = co->data;
+    n_vec_t *ips = &ctx->ips;
     struct addrinfo *current = res;
     while (current != NULL) {
         if (current->ai_family == AF_INET) {
@@ -23,15 +29,15 @@ static inline void on_dns_resolved_cb(uv_getaddrinfo_t *req, int status, struct
 
             uv_ip4_name(addr_in, addr, 16);
 
-            n_string_t *ip = rt_string_new((n_anyptr_t) addr);
+            n_string_t ip = rt_string_new((n_anyptr_t) addr);
             rt_vec_push(ips, string_rtype.hash, &ip);
         } else if (current->ai_family == AF_INET6) {
             char addr6[INET6_ADDRSTRLEN] = {'\0'};
 
             struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *) current->ai_addr;
             uv_ip6_name(addr_in6, addr6, sizeof(addr6));
 
-            n_string_t *ip = rt_string_new((n_anyptr_t) addr6);
+            n_string_t ip = rt_string_new((n_anyptr_t) addr6);
             rt_vec_push(ips, string_rtype.hash, &ip);
         }
         current = current->ai_next;
@@ -41,35 +47,42 @@ static inline void on_dns_resolved_cb(uv_getaddrinfo_t *req, int status, struct
     co_ready(co);
 }
 
-void uv_async_getaddrinfo_register(uv_getaddrinfo_t *req, n_string_t *host) {
-    DEBUGF("[uv_async_getaddrinfo_register] host is %s, co=%p", (char *) rt_string_ref(host), req->data);
+void uv_async_getaddrinfo_register(uv_getaddrinfo_t *req, dns_ctx_t *ctx) {
+    DEBUGF("[uv_async_getaddrinfo_register] host is %s, co=%p", (char *) rt_string_ref(&ctx->host), req->data);
     struct addrinfo hints;
     memset(&hints, 0, sizeof(hints));
     hints.ai_family = AF_UNSPEC; // IPv4 or IPv6
     hints.ai_socktype = SOCK_STREAM; // TCP
 
-    int result = uv_getaddrinfo(&global_loop, req, on_dns_resolved_cb, rt_string_ref(host), NULL, &hints);
+    int result = uv_getaddrinfo(&global_loop, req, on_dns_resolved_cb, rt_string_ref(&ctx->host), NULL, &hints);
     if (result) {
         DEBUGF("[uv_async_getaddrinfo_register] uv_getaddrinfo failed: %s, co=%p", uv_strerror(result), req->data);
-        rti_co_throw(req->data, tlsprintf("resolve %s failed: %s", rt_string_ref(host), uv_strerror(result)), false);
+        rti_co_throw(req->data, tlsprintf("resolve %s failed: %s", rt_string_ref(&ctx->host), uv_strerror(result)), false);
         co_ready(req->data);
         return;
     }
 }
 
-void rt_uv_dns_lookup(n_string_t *host, n_vec_t *ips) {
+n_vec_t rt_uv_dns_lookup(n_string_t host) {
     n_processor_t *p = processor_get();
     coroutine_t *co = coroutine_get();
 
-    DEBUGF("[rt_uv_dns_lookup] start, host is %s, co=%p", (char *) rt_string_ref(host), co);
+    DEBUGF("[rt_uv_dns_lookup] start, host is %s, co=%p", (char *) rt_string_ref(&host), co);
+
+    dns_ctx_t *ctx = malloc(sizeof(dns_ctx_t));
+    ctx->host = host;
+    ctx->ips = rt_vec_cap(vec_rtype.hash, string_rtype.hash, 0);
 
     uv_getaddrinfo_t *req = malloc(sizeof(uv_getaddrinfo_t));
     req->data = co;
-    co->data = ips;
-
-    global_waiting_send(uv_async_getaddrinfo_register, req, host, 0);
+    co->data = ctx;
 
+    global_waiting_send(uv_async_getaddrinfo_register, req, ctx, 0);
     free(req);
+
+    n_vec_t result = ctx->ips;
+    free(ctx);
+    return result;
 }
 
 #endif //NATURE_RUNTIME_NUTILS_DNS_H_