Re-org memory allocation interfaces, add --stack-size and --heap-size option (#193)

core/iwasm/common/wasm_memory.c

@@ -0,0 +1,372 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "wasm_runtime_common.h"
+#include "bh_platform.h"
+#include "mem_alloc.h"
+#include "bh_thread.h"
+
+#if BEIHAI_ENABLE_MEMORY_PROFILING != 0
+
+/* Memory profile data of a function */
+typedef struct memory_profile {
+    struct memory_profile *next;
+    const char *function_name;
+    const char *file_name;
+    int line_in_file;
+    int malloc_num;
+    int free_num;
+    int total_malloc;
+    int total_free;
+} memory_profile_t;
+
+/* Memory in use which grows when BH_MALLOC was called
+ * and decreases when bh_free was called */
+static unsigned int memory_in_use = 0;
+
+/* Memory profile data list */
+static memory_profile_t *memory_profiles_list = NULL;
+
+/* Lock of the memory profile list */
+static korp_mutex profile_lock;
+#endif /* end of BEIHAI_ENABLE_MEMORY_PROFILING */
+
+#ifndef MALLOC_MEMORY_FROM_SYSTEM
+
+typedef enum Memory_Mode {
+    MEMORY_MODE_UNKNOWN = 0,
+    MEMORY_MODE_POOL,
+    MEMORY_MODE_ALLOCATOR
+} Memory_Mode;
+
+static Memory_Mode memory_mode = MEMORY_MODE_UNKNOWN;
+
+static mem_allocator_t pool_allocator = NULL;
+
+static void *(*malloc_func)(unsigned int size) = NULL;
+static void *(*realloc_func)(void *ptr, unsigned int size) = NULL;
+static void (*free_func)(void *ptr) = NULL;
+
+static unsigned int global_pool_size;
+
+static bool
+wasm_memory_init_with_pool(void *mem, unsigned int bytes)
+{
+    mem_allocator_t _allocator = mem_allocator_create(mem, bytes);
+
+    if (_allocator) {
+        memory_mode = MEMORY_MODE_POOL;
+        pool_allocator = _allocator;
+#if BEIHAI_ENABLE_MEMORY_PROFILING != 0
+        vm_mutex_init(&profile_lock);
+#endif
+        global_pool_size = bytes;
+        return true;
+    }
+    bh_printf("Init memory with pool (%p, %u) failed.\n", mem, bytes);
+    return false;
+}
+
+static bool
+wasm_memory_init_with_allocator(void *_malloc_func,
+                                void *_realloc_func,
+                                void *_free_func)
+{
+    if (_malloc_func && _free_func && _malloc_func != _free_func) {
+        memory_mode = MEMORY_MODE_ALLOCATOR;
+        malloc_func = _malloc_func;
+        realloc_func = _realloc_func;
+        free_func = _free_func;
+#if BEIHAI_ENABLE_MEMORY_PROFILING != 0
+        vm_mutex_init(&profile_lock);
+#endif
+        return true;
+    }
+    bh_printf("Init memory with allocator (%p, %p, %p) failed.\n",
+              _malloc_func, _realloc_func, _free_func);
+    return false;
+}
+
+bool
+wasm_runtime_memory_init(mem_alloc_type_t mem_alloc_type,
+                         const MemAllocOption *alloc_option)
+{
+    if (mem_alloc_type == Alloc_With_Pool)
+        return wasm_memory_init_with_pool(alloc_option->pool.heap_buf,
+                                          alloc_option->pool.heap_size);
+    else if (mem_alloc_type == Alloc_With_Allocator)
+        return wasm_memory_init_with_allocator(alloc_option->allocator.malloc_func,
+                                               alloc_option->allocator.realloc_func,
+                                               alloc_option->allocator.free_func);
+    else if (mem_alloc_type == Alloc_With_System_Allocator)
+        return wasm_memory_init_with_allocator(os_malloc, os_realloc, os_free);
+    else
+        return false;
+}
+
+void
+wasm_runtime_memory_destroy()
+{
+#if BEIHAI_ENABLE_MEMORY_PROFILING != 0
+    vm_mutex_destroy(&profile_lock);
+#endif
+    if (memory_mode == MEMORY_MODE_POOL)
+        mem_allocator_destroy(pool_allocator);
+    memory_mode = MEMORY_MODE_UNKNOWN;
+}
+
+unsigned
+wasm_runtime_memory_pool_size()
+{
+    if (memory_mode == MEMORY_MODE_POOL)
+        return global_pool_size;
+    else
+        return 1 * BH_GB;
+}
+
+void *
+wasm_runtime_malloc(unsigned int size)
+{
+    if (memory_mode == MEMORY_MODE_UNKNOWN) {
+        bh_printf("wasm_runtime_malloc failed: memory hasn't been initialize.\n");
+        return NULL;
+    } else if (memory_mode == MEMORY_MODE_POOL) {
+        return mem_allocator_malloc(pool_allocator, size);
+    } else {
+        return malloc_func(size);
+    }
+}
+
+void *
+wasm_runtime_realloc(void *ptr, unsigned int size)
+{
+    if (memory_mode == MEMORY_MODE_UNKNOWN) {
+        bh_printf("wasm_runtime_realloc failed: memory hasn't been initialize.\n");
+        return NULL;
+    } else if (memory_mode == MEMORY_MODE_POOL) {
+        return mem_allocator_realloc(pool_allocator, ptr, size);
+    } else {
+        if (realloc_func)
+            return realloc_func(ptr, size);
+        else
+            return NULL;
+    }
+}
+
+void
+wasm_runtime_free(void *ptr)
+{
+    if (memory_mode == MEMORY_MODE_UNKNOWN) {
+        bh_printf("wasm_runtime_free failed: memory hasn't been initialize.\n");
+    } else if (memory_mode == MEMORY_MODE_POOL) {
+        mem_allocator_free(pool_allocator, ptr);
+    } else {
+        free_func(ptr);
+    }
+}
+
+#if BEIHAI_ENABLE_MEMORY_PROFILING != 0
+void *
+wasm_runtime_malloc_profile(const char *file, int line,
+                            const char *func, unsigned int size)
+{
+    void *p = wasm_rutime_malloc(size + 8);
+
+    if (p) {
+        memory_profile_t *profile;
+
+        vm_mutex_lock(&profile_lock);
+
+        profile = memory_profiles_list;
+        while (profile) {
+            if (strcmp(profile->function_name, func) == 0
+                && strcmp(profile->file_name, file) == 0) {
+                break;
+            }
+            profile = profile->next;
+        }
+
+        if (profile) {
+            profile->total_malloc += size;/* TODO: overflow check */
+            profile->malloc_num++;
+        } else {
+            profile = wasm_runtime_malloc(sizeof(memory_profile_t));
+            if (!profile) {
+              vm_mutex_unlock(&profile_lock);
+              bh_memcpy_s(p, size + 8, &size, sizeof(size));
+              return (char *)p + 8;
+            }
+
+            memset(profile, 0, sizeof(memory_profile_t));
+            profile->file_name = file;
+            profile->line_in_file = line;
+            profile->function_name = func;
+            profile->malloc_num = 1;
+            profile->total_malloc = size;
+            profile->next = memory_profiles_list;
+            memory_profiles_list = profile;
+        }
+
+        vm_mutex_unlock(&profile_lock);
+
+        bh_memcpy_s(p, size + 8, &size, sizeof(size));
+        memory_in_use += size;
+
+        memory_profile_print(file, line, func, size);
+
+        return (char *)p + 8;
+    }
+
+    return NULL;
+}
+
+void
+wasm_runtime_free_profile(const char *file, int line,
+                          const char *func, void *ptr)
+{
+    unsigned int size = *(unsigned int *)((char *)ptr - 8);
+    memory_profile_t *profile;
+
+    wasm_runtime_free((char *)ptr - 8);
+
+    if (memory_in_use >= size)
+        memory_in_use -= size;
+
+    vm_mutex_lock(&profile_lock);
+
+    profile = memory_profiles_list;
+    while (profile) {
+        if (strcmp(profile->function_name, func) == 0
+            && strcmp(profile->file_name, file) == 0) {
+            break;
+        }
+        profile = profile->next;
+    }
+
+    if (profile) {
+        profile->total_free += size;/* TODO: overflow check */
+        profile->free_num++;
+    } else {
+        profile = wasm_runtime_malloc(sizeof(memory_profile_t));
+        if (!profile) {
+            vm_mutex_unlock(&profile_lock);
+            return;
+        }
+
+        memset(profile, 0, sizeof(memory_profile_t));
+        profile->file_name = file;
+        profile->line_in_file = line;
+        profile->function_name = func;
+        profile->free_num = 1;
+        profile->total_free = size;
+        profile->next = memory_profiles_list;
+        memory_profiles_list = profile;
+    }
+
+    vm_mutex_unlock(&profile_lock);
+}
+
+/**
+ * Summarize memory usage and print it out
+ * Can use awk to analyze the output like below:
+ * awk -F: '{print $2,$4,$6,$8,$9}' OFS="\t" ./out.txt | sort -n -r -k 1
+ */
+void memory_usage_summarize()
+{
+    memory_profile_t *profile;
+
+    vm_mutex_lock(&profile_lock);
+
+    profile = memory_profiles_list;
+    while (profile) {
+        bh_printf("malloc:%d:malloc_num:%d:free:%d:free_num:%d:%s\n",
+                  profile->total_malloc,
+                  profile->malloc_num,
+                  profile->total_free,
+                  profile->free_num,
+                  profile->function_name);
+        profile = profile->next;
+    }
+
+    vm_mutex_unlock(&profile_lock);
+}
+
+void
+memory_profile_print(const char *file, int line,
+                     const char *func, int alloc)
+{
+    bh_printf("location:%s@%d:used:%d:contribution:%d\n",
+              func, line, memory_in_use, alloc);
+}
+
+#endif /* end of BEIHAI_ENABLE_MEMORY_PROFILING */
+
+#else /* else of MALLOC_MEMORY_FROM_SYSTEM */
+
+
+void *
+wasm_runtime_malloc(unsigned int size)
+{
+    return malloc(size);
+}
+
+void *
+wasm_runtime_realloc(void *ptr, unsigned int size)
+{
+    return realloc(ptr, size);
+}
+
+void
+wasm_runtime_free(void *ptr)
+{
+    if (ptr)
+        free(ptr);
+}
+
+#if BEIHAI_ENABLE_MEMORY_PROFILING != 0
+void *
+wasm_runtime_malloc_profile(const char *file, int line,
+                            const char *func, unsigned int size)
+{
+    (void)file;
+    (void)line;
+    (void)func;
+
+    (void)memory_profiles_list;
+    (void)profile_lock;
+    (void)memory_in_use;
+
+    return malloc(size);
+}
+
+void *
+wasm_runtime_realloc_profile(const char *file, int line,
+                             const char *func, void *ptr, unsigned int size)
+{
+    (void)file;
+    (void)line;
+    (void)func;
+
+    (void)memory_profiles_list;
+    (void)profile_lock;
+    (void)memory_in_use;
+
+    return realloc(ptr, size);
+}
+
+void
+wasm_runtime_free_profile(const char *file, int line,
+                          const char *func, void *ptr)
+{
+    (void)file;
+    (void)line;
+    (void)func;
+
+    if (ptr)
+        free(ptr);
+}
+#endif /* end of BEIHAI_ENABLE_MEMORY_PROFILING */
+#endif /* end of MALLOC_MEMORY_FROM_SYSTEM*/
+