gnh1201/wasm-micro-runtime
1
0
Fork 0
mirror of https://github.com/bytecodealliance/wasm-micro-runtime.git synced 2025-05-07 04:06:16 +00:00
Code Issues Actions 9 Packages Projects Releases Wiki Activity
412631ac13
wasm-micro-runtime/core/shared/mem-alloc/ems/ems_alloc.c
Huang Qi 412631ac13
fix: correct typos and improve comments across multiple files by codespell (#4116) 
Signed-off-by: Huang Qi <huangqi3@xiaomi.com>
2025-03-07 08:21:54 +08:00

1170 lines
32 KiB
C
Raw Blame History

/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "ems_gc_internal.h"
#if WASM_ENABLE_GC != 0
#define LOCK_HEAP(heap) \
do { \
if (!heap->is_doing_reclaim) \
/* If the heap is doing reclaim, it must have been locked, \
we should not lock the heap again. */ \
os_mutex_lock(&heap->lock); \
} while (0)
#define UNLOCK_HEAP(heap) \
do { \
if (!heap->is_doing_reclaim) \
/* If the heap is doing reclaim, it must have been locked, \
and will be unlocked after reclaim, we should not \
unlock the heap again. */ \
os_mutex_unlock(&heap->lock); \
} while (0)
#else
#define LOCK_HEAP(heap) os_mutex_lock(&heap->lock)
#define UNLOCK_HEAP(heap) os_mutex_unlock(&heap->lock)
#endif
static inline bool
hmu_is_in_heap(void *hmu, gc_uint8 *heap_base_addr, gc_uint8 *heap_end_addr)
{
gc_uint8 *addr = (gc_uint8 *)hmu;
return (addr >= heap_base_addr && addr < heap_end_addr) ? true : false;
}
/**
* Remove a node from the tree it belongs to
*
* @param p the node to remove, can not be NULL, can not be the ROOT node
* the node will be removed from the tree, and the left, right and
* parent pointers of the node @p will be set to be NULL. Other fields
* won't be touched. The tree will be re-organized so that the order
* conditions are still satisfied.
*/
static bool
remove_tree_node(gc_heap_t *heap, hmu_tree_node_t *p)
{
hmu_tree_node_t *q = NULL, **slot = NULL;
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
hmu_tree_node_t *root = heap->kfc_tree_root, *parent;
gc_uint8 *base_addr = heap->base_addr;
gc_uint8 *end_addr = base_addr + heap->current_size;
#endif
bh_assert(p);
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
parent = p->parent;
if (!parent || p == root /* p can not be the ROOT node */
|| !hmu_is_in_heap(p, base_addr, end_addr)
|| (parent != root && !hmu_is_in_heap(parent, base_addr, end_addr))) {
goto fail;
}
#endif
/* get the slot which holds pointer to node p */
if (p == p->parent->right) {
/* Don't use `slot = &p->parent->right` to avoid compiler warning */
slot = (hmu_tree_node_t **)((uint8 *)p->parent
+ offsetof(hmu_tree_node_t, right));
}
else if (p == p->parent->left) {
/* p should be a child of its parent */
/* Don't use `slot = &p->parent->left` to avoid compiler warning */
slot = (hmu_tree_node_t **)((uint8 *)p->parent
+ offsetof(hmu_tree_node_t, left));
}
else {
goto fail;
}
/**
* algorithms used to remove node p
* case 1: if p has no left child, replace p with its right child
* case 2: if p has no right child, replace p with its left child
* case 3: otherwise, find p's predecessor, remove it from the tree
* and replace p with it.
* use predecessor can keep the left <= root < right condition.
*/
if (!p->left) {
/* move right child up*/
*slot = p->right;
if (p->right) {
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (!hmu_is_in_heap(p->right, base_addr, end_addr)) {
goto fail;
}
#endif
p->right->parent = p->parent;
}
p->left = p->right = p->parent = NULL;
return true;
}
if (!p->right) {
/* move left child up*/
*slot = p->left;
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (!hmu_is_in_heap(p->left, base_addr, end_addr)) {
goto fail;
}
#endif
/* p->left can never be NULL unless it is corrupted. */
p->left->parent = p->parent;
p->left = p->right = p->parent = NULL;
return true;
}
/* both left & right exist, find p's predecessor at first*/
q = p->left;
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (!hmu_is_in_heap(q, base_addr, end_addr)) {
goto fail;
}
#endif
while (q->right) {
q = q->right;
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (!hmu_is_in_heap(q, base_addr, end_addr)) {
goto fail;
}
#endif
}
/* remove from the tree*/
if (!remove_tree_node(heap, q))
return false;
*slot = q;
q->parent = p->parent;
q->left = p->left;
q->right = p->right;
if (q->left) {
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (!hmu_is_in_heap(q->left, base_addr, end_addr)) {
goto fail;
}
#endif
q->left->parent = q;
}
if (q->right) {
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (!hmu_is_in_heap(q->right, base_addr, end_addr)) {
goto fail;
}
#endif
q->right->parent = q;
}
p->left = p->right = p->parent = NULL;
return true;
fail:
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
heap->is_heap_corrupted = true;
#endif
return false;
}
static bool
unlink_hmu(gc_heap_t *heap, hmu_t *hmu)
{
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
gc_uint8 *base_addr, *end_addr;
#endif
gc_size_t size;
bh_assert(gci_is_heap_valid(heap));
bh_assert(hmu && (gc_uint8 *)hmu >= heap->base_addr
&& (gc_uint8 *)hmu < heap->base_addr + heap->current_size);
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (hmu_get_ut(hmu) != HMU_FC) {
heap->is_heap_corrupted = true;
return false;
}
#endif
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
base_addr = heap->base_addr;
end_addr = base_addr + heap->current_size;
#endif
size = hmu_get_size(hmu);
if (HMU_IS_FC_NORMAL(size)) {
uint32 node_idx = size >> 3;
hmu_normal_node_t *node_prev = NULL, *node_next;
hmu_normal_node_t *node = heap->kfc_normal_list[node_idx].next;
while (node) {
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (!hmu_is_in_heap(node, base_addr, end_addr)) {
heap->is_heap_corrupted = true;
return false;
}
#endif
node_next = get_hmu_normal_node_next(node);
if ((hmu_t *)node == hmu) {
if (!node_prev) /* list head */
heap->kfc_normal_list[node_idx].next = node_next;
else
set_hmu_normal_node_next(node_prev, node_next);
break;
}
node_prev = node;
node = node_next;
}
if (!node) {
LOG_ERROR("[GC_ERROR]couldn't find the node in the normal list\n");
}
}
else {
if (!remove_tree_node(heap, (hmu_tree_node_t *)hmu))
return false;
}
return true;
}
static void
hmu_set_free_size(hmu_t *hmu)
{
gc_size_t size;
bh_assert(hmu && hmu_get_ut(hmu) == HMU_FC);
size = hmu_get_size(hmu);
*((uint32 *)((char *)hmu + size) - 1) = size;
}
/**
* Add free chunk back to KFC
*
* @param heap should not be NULL and it should be a valid heap
* @param hmu should not be NULL and it should be a HMU of length @size inside
* @heap hmu should be 8-bytes aligned
* @param size should be positive and multiple of 8
* hmu with size @size will be added into KFC as a new FC.
*/
bool
gci_add_fc(gc_heap_t *heap, hmu_t *hmu, gc_size_t size)
{
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
gc_uint8 *base_addr, *end_addr;
#endif
hmu_normal_node_t *np = NULL;
hmu_tree_node_t *root = NULL, *tp = NULL, *node = NULL;
uint32 node_idx;
bh_assert(gci_is_heap_valid(heap));
bh_assert(hmu && (gc_uint8 *)hmu >= heap->base_addr
&& (gc_uint8 *)hmu < heap->base_addr + heap->current_size);
bh_assert(((gc_uint32)(uintptr_t)hmu_to_obj(hmu) & 7) == 0);
bh_assert(size > 0
&& ((gc_uint8 *)hmu) + size
<= heap->base_addr + heap->current_size);
bh_assert(!(size & 7));
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
base_addr = heap->base_addr;
end_addr = base_addr + heap->current_size;
#endif
hmu_set_ut(hmu, HMU_FC);
hmu_set_size(hmu, size);
hmu_set_free_size(hmu);
if (HMU_IS_FC_NORMAL(size)) {
np = (hmu_normal_node_t *)hmu;
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (!hmu_is_in_heap(np, base_addr, end_addr)) {
heap->is_heap_corrupted = true;
return false;
}
#endif
node_idx = size >> 3;
set_hmu_normal_node_next(np, heap->kfc_normal_list[node_idx].next);
heap->kfc_normal_list[node_idx].next = np;
return true;
}
/* big block */
node = (hmu_tree_node_t *)hmu;
node->size = size;
node->left = node->right = node->parent = NULL;
/* find proper node to link this new node to */
root = heap->kfc_tree_root;
tp = root;
bh_assert(tp->size < size);
while (1) {
if (tp->size < size) {
if (!tp->right) {
tp->right = node;
node->parent = tp;
break;
}
tp = tp->right;
}
else { /* tp->size >= size */
if (!tp->left) {
tp->left = node;
node->parent = tp;
break;
}
tp = tp->left;
}
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (!hmu_is_in_heap(tp, base_addr, end_addr)) {
heap->is_heap_corrupted = true;
return false;
}
#endif
}
return true;
}
/**
* Find a proper hmu for required memory size
*
* @param heap should not be NULL and should be a valid heap
* @param size should cover the header and should be 8 bytes aligned
* GC will not be performed here.
* Heap extension will not be performed here.
*
* @return hmu allocated if success, which will be aligned to 8 bytes,
* NULL otherwise
*/
static hmu_t *
alloc_hmu(gc_heap_t *heap, gc_size_t size)
{
gc_uint8 *base_addr, *end_addr;
hmu_normal_list_t *normal_head = NULL;
hmu_normal_node_t *p = NULL;
uint32 node_idx = 0, init_node_idx = 0;
hmu_tree_node_t *root = NULL, *tp = NULL, *last_tp = NULL;
hmu_t *next, *rest;
uintptr_t tp_ret;
bh_assert(gci_is_heap_valid(heap));
bh_assert(size > 0 && !(size & 7));
#if WASM_ENABLE_GC != 0
/* In doing reclaim, gc must not alloc memory again. */
bh_assert(!heap->is_doing_reclaim);
#endif
base_addr = heap->base_addr;
end_addr = base_addr + heap->current_size;
if (size < GC_SMALLEST_SIZE)
size = GC_SMALLEST_SIZE;
/* check normal list at first*/
if (HMU_IS_FC_NORMAL(size)) {
/* find a non-empty slot in normal_node_list with good size*/
init_node_idx = (size >> 3);
for (node_idx = init_node_idx; node_idx < HMU_NORMAL_NODE_CNT;
node_idx++) {
normal_head = heap->kfc_normal_list + node_idx;
if (normal_head->next)
break;
normal_head = NULL;
}
/* found in normal list*/
if (normal_head) {
bh_assert(node_idx >= init_node_idx);
p = normal_head->next;
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (!hmu_is_in_heap(p, base_addr, end_addr)) {
heap->is_heap_corrupted = true;
return NULL;
}
#endif
normal_head->next = get_hmu_normal_node_next(p);
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (((gc_int32)(uintptr_t)hmu_to_obj(p) & 7) != 0) {
heap->is_heap_corrupted = true;
return NULL;
}
#endif
if ((gc_size_t)node_idx != (uint32)init_node_idx
/* with bigger size*/
&& ((gc_size_t)node_idx << 3) >= size + GC_SMALLEST_SIZE) {
rest = (hmu_t *)(((char *)p) + size);
if (!gci_add_fc(heap, rest, (node_idx << 3) - size)) {
return NULL;
}
hmu_mark_pinuse(rest);
}
else {
size = node_idx << 3;
next = (hmu_t *)((char *)p + size);
if (hmu_is_in_heap(next, base_addr, end_addr))
hmu_mark_pinuse(next);
}
heap->total_free_size -= size;
if ((heap->current_size - heap->total_free_size)
> heap->highmark_size)
heap->highmark_size =
heap->current_size - heap->total_free_size;
hmu_set_size((hmu_t *)p, size);
return (hmu_t *)p;
}
}
/* need to find a node in tree*/
root = heap->kfc_tree_root;
/* find the best node*/
bh_assert(root);
tp = root->right;
while (tp) {
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (!hmu_is_in_heap(tp, base_addr, end_addr)) {
heap->is_heap_corrupted = true;
return NULL;
}
#endif
if (tp->size < size) {
tp = tp->right;
continue;
}
/* record the last node with size equal to or bigger than given size*/
last_tp = tp;
tp = tp->left;
}
if (last_tp) {
bh_assert(last_tp->size >= size);
/* alloc in last_p*/
/* remove node last_p from tree*/
if (!remove_tree_node(heap, last_tp))
return NULL;
if (last_tp->size >= size + GC_SMALLEST_SIZE) {
rest = (hmu_t *)((char *)last_tp + size);
if (!gci_add_fc(heap, rest, last_tp->size - size))
return NULL;
hmu_mark_pinuse(rest);
}
else {
size = last_tp->size;
next = (hmu_t *)((char *)last_tp + size);
if (hmu_is_in_heap(next, base_addr, end_addr))
hmu_mark_pinuse(next);
}
heap->total_free_size -= size;
if ((heap->current_size - heap->total_free_size) > heap->highmark_size)
heap->highmark_size = heap->current_size - heap->total_free_size;
hmu_set_size((hmu_t *)last_tp, size);
tp_ret = (uintptr_t)last_tp;
return (hmu_t *)tp_ret;
}
return NULL;
}
#if WASM_ENABLE_GC != 0
static int
do_gc_heap(gc_heap_t *heap)
{
int ret = GC_SUCCESS;
#if WASM_ENABLE_GC_PERF_PROFILING != 0
uint64 start = 0, end = 0, time = 0;
start = os_time_get_boot_microsecond();
#endif
if (heap->is_reclaim_enabled) {
UNLOCK_HEAP(heap);
ret = gci_gc_heap(heap);
LOCK_HEAP(heap);
}
#if WASM_ENABLE_GC_PERF_PROFILING != 0
end = os_time_get_boot_microsecond();
time = end - start;
heap->total_gc_time += time;
if (time > heap->max_gc_time) {
heap->max_gc_time = time;
}
heap->total_gc_count += 1;
#endif
return ret;
}
#endif
/**
* Find a proper HMU with given size
*
* @param heap should not be NULL and should be a valid heap
* @param size should cover the header and should be 8 bytes aligned
*
* Note: This function will try several ways to satisfy the allocation request:
* 1. Find a proper on available HMUs.
* 2. GC will be triggered if 1 failed.
* 3. Find a proper on available HMUS.
* 4. Return NULL if 3 failed
*
* @return hmu allocated if success, which will be aligned to 8 bytes,
* NULL otherwise
*/
static hmu_t *
alloc_hmu_ex(gc_heap_t *heap, gc_size_t size)
{
bh_assert(gci_is_heap_valid(heap));
bh_assert(size > 0 && !(size & 7));
#if WASM_ENABLE_GC != 0
#if GC_IN_EVERY_ALLOCATION != 0
if (GC_SUCCESS != do_gc_heap(heap))
return NULL;
#else
if (heap->total_free_size < heap->gc_threshold) {
if (GC_SUCCESS != do_gc_heap(heap))
return NULL;
}
else {
hmu_t *ret = NULL;
if ((ret = alloc_hmu(heap, size))) {
return ret;
}
if (GC_SUCCESS != do_gc_heap(heap))
return NULL;
}
#endif
#endif
return alloc_hmu(heap, size);
}
#if BH_ENABLE_GC_VERIFY == 0
gc_object_t
gc_alloc_vo(void *vheap, gc_size_t size)
#else
gc_object_t
gc_alloc_vo_internal(void *vheap, gc_size_t size, const char *file, int line)
#endif
{
gc_heap_t *heap = (gc_heap_t *)vheap;
hmu_t *hmu = NULL;
gc_object_t ret = (gc_object_t)NULL;
gc_size_t tot_size = 0, tot_size_unaligned;
/* hmu header + prefix + obj + suffix */
tot_size_unaligned = HMU_SIZE + OBJ_PREFIX_SIZE + size + OBJ_SUFFIX_SIZE;
/* aligned size*/
tot_size = GC_ALIGN_8(tot_size_unaligned);
if (tot_size < size)
/* integer overflow */
return NULL;
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (heap->is_heap_corrupted) {
LOG_ERROR("[GC_ERROR]Heap is corrupted, allocate memory failed.\n");
return NULL;
}
#endif
LOCK_HEAP(heap);
hmu = alloc_hmu_ex(heap, tot_size);
if (!hmu)
goto finish;
bh_assert(hmu_get_size(hmu) >= tot_size);
/* the total size allocated may be larger than
the required size, reset it here */
tot_size = hmu_get_size(hmu);
#if GC_STAT_DATA != 0
heap->total_size_allocated += tot_size;
#endif
hmu_set_ut(hmu, HMU_VO);
hmu_unfree_vo(hmu);
#if BH_ENABLE_GC_VERIFY != 0
hmu_init_prefix_and_suffix(hmu, tot_size, file, line);
#endif
ret = hmu_to_obj(hmu);
if (tot_size > tot_size_unaligned)
/* clear buffer appended by GC_ALIGN_8() */
memset((uint8 *)ret + size, 0, tot_size - tot_size_unaligned);
finish:
UNLOCK_HEAP(heap);
return ret;
}
#if BH_ENABLE_GC_VERIFY == 0
gc_object_t
gc_realloc_vo(void *vheap, void *ptr, gc_size_t size)
#else
gc_object_t
gc_realloc_vo_internal(void *vheap, void *ptr, gc_size_t size, const char *file,
int line)
#endif
{
gc_heap_t *heap = (gc_heap_t *)vheap;
hmu_t *hmu = NULL, *hmu_old = NULL, *hmu_next;
gc_object_t ret = (gc_object_t)NULL, obj_old = (gc_object_t)ptr;
gc_size_t tot_size, tot_size_unaligned, tot_size_old = 0, tot_size_next;
gc_size_t obj_size, obj_size_old;
gc_uint8 *base_addr, *end_addr;
hmu_type_t ut;
/* hmu header + prefix + obj + suffix */
tot_size_unaligned = HMU_SIZE + OBJ_PREFIX_SIZE + size + OBJ_SUFFIX_SIZE;
/* aligned size*/
tot_size = GC_ALIGN_8(tot_size_unaligned);
if (tot_size < size)
/* integer overflow */
return NULL;
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (heap->is_heap_corrupted) {
LOG_ERROR("[GC_ERROR]Heap is corrupted, allocate memory failed.\n");
return NULL;
}
#endif
if (obj_old) {
hmu_old = obj_to_hmu(obj_old);
tot_size_old = hmu_get_size(hmu_old);
if (tot_size <= tot_size_old)
/* current node already meets requirement */
return obj_old;
}
base_addr = heap->base_addr;
end_addr = base_addr + heap->current_size;
LOCK_HEAP(heap);
if (hmu_old) {
hmu_next = (hmu_t *)((char *)hmu_old + tot_size_old);
if (hmu_is_in_heap(hmu_next, base_addr, end_addr)) {
ut = hmu_get_ut(hmu_next);
tot_size_next = hmu_get_size(hmu_next);
if (ut == HMU_FC && tot_size <= tot_size_old + tot_size_next) {
/* current node and next node meets requirement */
if (!unlink_hmu(heap, hmu_next)) {
UNLOCK_HEAP(heap);
return NULL;
}
hmu_set_size(hmu_old, tot_size);
memset((char *)hmu_old + tot_size_old, 0,
tot_size - tot_size_old);
#if BH_ENABLE_GC_VERIFY != 0
hmu_init_prefix_and_suffix(hmu_old, tot_size, file, line);
#endif
if (tot_size < tot_size_old + tot_size_next) {
hmu_next = (hmu_t *)((char *)hmu_old + tot_size);
tot_size_next = tot_size_old + tot_size_next - tot_size;
if (!gci_add_fc(heap, hmu_next, tot_size_next)) {
UNLOCK_HEAP(heap);
return NULL;
}
hmu_mark_pinuse(hmu_next);
}
UNLOCK_HEAP(heap);
return obj_old;
}
}
}
hmu = alloc_hmu_ex(heap, tot_size);
if (!hmu)
goto finish;
bh_assert(hmu_get_size(hmu) >= tot_size);
/* the total size allocated may be larger than
the required size, reset it here */
tot_size = hmu_get_size(hmu);
#if GC_STAT_DATA != 0
heap->total_size_allocated += tot_size;
#endif
hmu_set_ut(hmu, HMU_VO);
hmu_unfree_vo(hmu);
#if BH_ENABLE_GC_VERIFY != 0
hmu_init_prefix_and_suffix(hmu, tot_size, file, line);
#endif
ret = hmu_to_obj(hmu);
finish:
if (ret) {
obj_size = tot_size - HMU_SIZE - OBJ_PREFIX_SIZE - OBJ_SUFFIX_SIZE;
memset(ret, 0, obj_size);
if (obj_old) {
obj_size_old =
tot_size_old - HMU_SIZE - OBJ_PREFIX_SIZE - OBJ_SUFFIX_SIZE;
bh_memcpy_s(ret, obj_size, obj_old, obj_size_old);
}
}
UNLOCK_HEAP(heap);
if (ret && obj_old)
gc_free_vo(vheap, obj_old);
return ret;
}
#if GC_MANUALLY != 0
void
gc_free_wo(void *vheap, void *ptr)
{
gc_heap_t *heap = (gc_heap_t *)vheap;
gc_object_t *obj = (gc_object_t *)ptr;
hmu_t *hmu = obj_to_hmu(obj);
bh_assert(gci_is_heap_valid(heap));
bh_assert(obj);
bh_assert((gc_uint8 *)hmu >= heap->base_addr
&& (gc_uint8 *)hmu < heap->base_addr + heap->current_size);
bh_assert(hmu_get_ut(hmu) == HMU_WO);
hmu_unmark_wo(hmu);
(void)heap;
}
#endif
/* see ems_gc.h for description*/
#if BH_ENABLE_GC_VERIFY == 0
gc_object_t
gc_alloc_wo(void *vheap, gc_size_t size)
#else
gc_object_t
gc_alloc_wo_internal(void *vheap, gc_size_t size, const char *file, int line)
#endif
{
gc_heap_t *heap = (gc_heap_t *)vheap;
hmu_t *hmu = NULL;
gc_object_t ret = (gc_object_t)NULL;
gc_size_t tot_size = 0, tot_size_unaligned;
/* hmu header + prefix + obj + suffix */
tot_size_unaligned = HMU_SIZE + OBJ_PREFIX_SIZE + size + OBJ_SUFFIX_SIZE;
/* aligned size*/
tot_size = GC_ALIGN_8(tot_size_unaligned);
if (tot_size < size)
/* integer overflow */
return NULL;
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (heap->is_heap_corrupted) {
os_printf("[GC_ERROR]Heap is corrupted, allocate memory failed.\n");
return NULL;
}
#endif
LOCK_HEAP(heap);
hmu = alloc_hmu_ex(heap, tot_size);
if (!hmu)
goto finish;
/* Don't memset the memory to improve performance, the caller should
decide whether to memset it or not */
bh_assert(hmu_get_size(hmu) >= tot_size);
/* the total size allocated may be larger than
the required size, reset it here */
tot_size = hmu_get_size(hmu);
#if GC_STAT_DATA != 0
heap->total_size_allocated += tot_size;
#endif
hmu_set_ut(hmu, HMU_WO);
#if GC_MANUALLY != 0
hmu_mark_wo(hmu);
#else
hmu_unmark_wo(hmu);
#endif
#if BH_ENABLE_GC_VERIFY != 0
hmu_init_prefix_and_suffix(hmu, tot_size, file, line);
#endif
ret = hmu_to_obj(hmu);
if (tot_size > tot_size_unaligned)
/* clear buffer appended by GC_ALIGN_8() */
memset((uint8 *)ret + size, 0, tot_size - tot_size_unaligned);
finish:
UNLOCK_HEAP(heap);
return ret;
}
/**
* Do some checking to see if given pointer is a possible valid heap
* @return GC_TRUE if all checking passed, GC_FALSE otherwise
*/
int
gci_is_heap_valid(gc_heap_t *heap)
{
if (!heap)
return GC_FALSE;
if (heap->heap_id != (gc_handle_t)heap)
return GC_FALSE;
return GC_TRUE;
}
#if BH_ENABLE_GC_VERIFY == 0
int
gc_free_vo(void *vheap, gc_object_t obj)
#else
int
gc_free_vo_internal(void *vheap, gc_object_t obj, const char *file, int line)
#endif
{
gc_heap_t *heap = (gc_heap_t *)vheap;
gc_uint8 *base_addr, *end_addr;
hmu_t *hmu = NULL;
hmu_t *prev = NULL;
hmu_t *next = NULL;
gc_size_t size = 0;
hmu_type_t ut;
int ret = GC_SUCCESS;
if (!obj) {
return GC_SUCCESS;
}
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (heap->is_heap_corrupted) {
LOG_ERROR("[GC_ERROR]Heap is corrupted, free memory failed.\n");
return GC_ERROR;
}
#endif
hmu = obj_to_hmu(obj);
base_addr = heap->base_addr;
end_addr = base_addr + heap->current_size;
LOCK_HEAP(heap);
if (hmu_is_in_heap(hmu, base_addr, end_addr)) {
#if BH_ENABLE_GC_VERIFY != 0
hmu_verify(heap, hmu);
#endif
ut = hmu_get_ut(hmu);
if (ut == HMU_VO) {
if (hmu_is_vo_freed(hmu)) {
bh_assert(0);
ret = GC_ERROR;
goto out;
}
size = hmu_get_size(hmu);
heap->total_free_size += size;
#if GC_STAT_DATA != 0
heap->total_size_freed += size;
#endif
if (!hmu_get_pinuse(hmu)) {
prev = (hmu_t *)((char *)hmu - *((int *)hmu - 1));
if (hmu_is_in_heap(prev, base_addr, end_addr)
&& hmu_get_ut(prev) == HMU_FC) {
size += hmu_get_size(prev);
hmu = prev;
if (!unlink_hmu(heap, prev)) {
ret = GC_ERROR;
goto out;
}
}
}
next = (hmu_t *)((char *)hmu + size);
if (hmu_is_in_heap(next, base_addr, end_addr)) {
if (hmu_get_ut(next) == HMU_FC) {
size += hmu_get_size(next);
if (!unlink_hmu(heap, next)) {
ret = GC_ERROR;
goto out;
}
next = (hmu_t *)((char *)hmu + size);
}
}
if (!gci_add_fc(heap, hmu, size)) {
ret = GC_ERROR;
goto out;
}
if (hmu_is_in_heap(next, base_addr, end_addr)) {
hmu_unmark_pinuse(next);
}
}
else {
ret = GC_ERROR;
goto out;
}
ret = GC_SUCCESS;
goto out;
}
out:
UNLOCK_HEAP(heap);
return ret;
}
void
gc_dump_heap_stats(gc_heap_t *heap)
{
os_printf("heap: %p, heap start: %p\n", heap, heap->base_addr);
os_printf("total free: %" PRIu32 ", current: %" PRIu32
", highmark: %" PRIu32 "\n",
heap->total_free_size, heap->current_size, heap->highmark_size);
#if GC_STAT_DATA != 0
os_printf("total size allocated: %" PRIu64 ", total size freed: %" PRIu64
", total occupied: %" PRIu64 "\n",
heap->total_size_allocated, heap->total_size_freed,
heap->total_size_allocated - heap->total_size_freed);
#endif
}
uint32
gc_get_heap_highmark_size(gc_heap_t *heap)
{
return heap->highmark_size;
}
void
gci_dump(gc_heap_t *heap)
{
hmu_t *cur = NULL, *end = NULL;
hmu_type_t ut;
gc_size_t size;
int i = 0, p, mark;
char inuse = 'U';
cur = (hmu_t *)heap->base_addr;
end = (hmu_t *)((char *)heap->base_addr + heap->current_size);
while (cur < end) {
ut = hmu_get_ut(cur);
size = hmu_get_size(cur);
p = hmu_get_pinuse(cur);
mark = hmu_is_wo_marked(cur);
if (ut == HMU_VO)
inuse = 'V';
else if (ut == HMU_WO)
inuse = hmu_is_wo_marked(cur) ? 'W' : 'w';
else if (ut == HMU_FC)
inuse = 'F';
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (size == 0 || size > (uint32)((uint8 *)end - (uint8 *)cur)) {
LOG_ERROR("[GC_ERROR]Heap is corrupted, heap dump failed.\n");
heap->is_heap_corrupted = true;
return;
}
#endif
os_printf("#%d %08" PRIx32 " %" PRIx32 " %d %d"
" %c %" PRId32 "\n",
i, (uint32)((char *)cur - (char *)heap->base_addr),
(uint32)ut, p, mark, inuse, (int32)hmu_obj_size(size));
#if BH_ENABLE_GC_VERIFY != 0
if (inuse == 'V') {
gc_object_prefix_t *prefix = (gc_object_prefix_t *)(cur + 1);
os_printf("#%s:%d\n", prefix->file_name, prefix->line_no);
}
#endif
cur = (hmu_t *)((char *)cur + size);
i++;
}
#if BH_ENABLE_GC_CORRUPTION_CHECK != 0
if (cur != end) {
LOG_ERROR("[GC_ERROR]Heap is corrupted, heap dump failed.\n");
heap->is_heap_corrupted = true;
}
#else
bh_assert(cur == end);
#endif
}
#if WASM_ENABLE_GC != 0
extra_info_node_t *
gc_search_extra_info_node(gc_handle_t handle, gc_object_t obj,
gc_size_t *p_index)
{
gc_heap_t *vheap = (gc_heap_t *)handle;
int32 low = 0, high = vheap->extra_info_node_cnt - 1;
int32 mid;
extra_info_node_t *node;
if (!vheap->extra_info_nodes)
return NULL;
while (low <= high) {
mid = (low + high) / 2;
node = vheap->extra_info_nodes[mid];
if (obj == node->obj) {
if (p_index) {
*p_index = mid;
}
return node;
}
else if (obj < node->obj) {
high = mid - 1;
}
else {
low = mid + 1;
}
}
if (p_index) {
*p_index = low;
}
return NULL;
}
static bool
insert_extra_info_node(gc_heap_t *vheap, extra_info_node_t *node)
{
gc_size_t index;
extra_info_node_t *orig_node;
if (!vheap->extra_info_nodes) {
vheap->extra_info_nodes = vheap->extra_info_normal_nodes;
vheap->extra_info_node_capacity = sizeof(vheap->extra_info_normal_nodes)
/ sizeof(extra_info_node_t *);
vheap->extra_info_nodes[0] = node;
vheap->extra_info_node_cnt = 1;
return true;
}
/* extend array */
if (vheap->extra_info_node_cnt == vheap->extra_info_node_capacity) {
extra_info_node_t **new_nodes = NULL;
gc_size_t new_capacity = vheap->extra_info_node_capacity * 3 / 2;
gc_size_t total_size = sizeof(extra_info_node_t *) * new_capacity;
new_nodes = (extra_info_node_t **)BH_MALLOC(total_size);
if (!new_nodes) {
LOG_ERROR("alloc extra info nodes failed");
return false;
}
bh_memcpy_s(new_nodes, total_size, vheap->extra_info_nodes,
sizeof(extra_info_node_t *) * vheap->extra_info_node_cnt);
if (vheap->extra_info_nodes != vheap->extra_info_normal_nodes) {
BH_FREE(vheap->extra_info_nodes);
}
vheap->extra_info_nodes = new_nodes;
vheap->extra_info_node_capacity = new_capacity;
}
orig_node = gc_search_extra_info_node(vheap, node->obj, &index);
if (orig_node) {
/* replace the old node */
vheap->extra_info_nodes[index] = node;
BH_FREE(orig_node);
}
else {
bh_memmove_s(vheap->extra_info_nodes + index + 1,
(vheap->extra_info_node_capacity - index - 1)
* sizeof(extra_info_node_t *),
vheap->extra_info_nodes + index,
(vheap->extra_info_node_cnt - index)
* sizeof(extra_info_node_t *));
vheap->extra_info_nodes[index] = node;
vheap->extra_info_node_cnt += 1;
}
return true;
}
bool
gc_set_finalizer(gc_handle_t handle, gc_object_t obj, gc_finalizer_t cb,
void *data)
{
extra_info_node_t *node = NULL;
gc_heap_t *vheap = (gc_heap_t *)handle;
node = (extra_info_node_t *)BH_MALLOC(sizeof(extra_info_node_t));
if (!node) {
LOG_ERROR("alloc a new extra info node failed");
return GC_FALSE;
}
memset(node, 0, sizeof(extra_info_node_t));
node->finalizer = cb;
node->obj = obj;
node->data = data;
LOCK_HEAP(vheap);
if (!insert_extra_info_node(vheap, node)) {
BH_FREE(node);
UNLOCK_HEAP(vheap);
return GC_FALSE;
}
UNLOCK_HEAP(vheap);
gct_vm_set_extra_info_flag(obj, true);
return GC_TRUE;
}
void
gc_unset_finalizer(gc_handle_t handle, gc_object_t obj)
{
gc_size_t index;
gc_heap_t *vheap = (gc_heap_t *)handle;
extra_info_node_t *node;
LOCK_HEAP(vheap);
node = gc_search_extra_info_node(vheap, obj, &index);
if (!node) {
UNLOCK_HEAP(vheap);
return;
}
BH_FREE(node);
bh_memmove_s(
vheap->extra_info_nodes + index,
(vheap->extra_info_node_capacity - index) * sizeof(extra_info_node_t *),
vheap->extra_info_nodes + index + 1,
(vheap->extra_info_node_cnt - index - 1) * sizeof(extra_info_node_t *));
vheap->extra_info_node_cnt -= 1;
UNLOCK_HEAP(vheap);
gct_vm_set_extra_info_flag(obj, false);
}
#endif
Reference in New Issue View Git Blame Copy Permalink