2019-05-07 10:18:18 +08:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2019 Intel Corporation. All rights reserved.
|
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
2019-05-23 18:03:31 +08:00
|
|
|
#include "bh_config.h"
|
2019-05-07 10:18:18 +08:00
|
|
|
#include "bh_memory.h"
|
|
|
|
#include "mem_alloc.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
2019-05-23 18:03:31 +08:00
|
|
|
#if BEIHAI_ENABLE_MEMORY_PROFILING != 0
|
|
|
|
#include "bh_thread.h"
|
|
|
|
|
|
|
|
/* 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
|
|
|
|
|
2019-05-07 10:18:18 +08:00
|
|
|
#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 (*free_func)(void *ptr) = NULL;
|
|
|
|
|
|
|
|
int bh_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;
|
2019-05-23 18:03:31 +08:00
|
|
|
#if BEIHAI_ENABLE_MEMORY_PROFILING != 0
|
|
|
|
vm_mutex_init(&profile_lock);
|
|
|
|
#endif
|
2019-05-07 10:18:18 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
printf("Init memory with pool (%p, %u) failed.\n", mem, bytes);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int bh_memory_init_with_allocator(void *_malloc_func, void *_free_func)
|
|
|
|
{
|
|
|
|
if (_malloc_func && _free_func && _malloc_func != _free_func) {
|
|
|
|
memory_mode = MEMORY_MODE_ALLOCATOR;
|
|
|
|
malloc_func = _malloc_func;
|
|
|
|
free_func = _free_func;
|
2019-05-23 18:03:31 +08:00
|
|
|
#if BEIHAI_ENABLE_MEMORY_PROFILING != 0
|
|
|
|
vm_mutex_init(&profile_lock);
|
|
|
|
#endif
|
2019-05-07 10:18:18 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
printf("Init memory with allocator (%p, %p) failed.\n", _malloc_func,
|
|
|
|
_free_func);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void bh_memory_destroy()
|
|
|
|
{
|
2019-05-23 18:03:31 +08:00
|
|
|
#if BEIHAI_ENABLE_MEMORY_PROFILING != 0
|
|
|
|
vm_mutex_destroy(&profile_lock);
|
|
|
|
#endif
|
2019-05-07 10:18:18 +08:00
|
|
|
if (memory_mode == MEMORY_MODE_POOL)
|
|
|
|
mem_allocator_destroy(pool_allocator);
|
|
|
|
memory_mode = MEMORY_MODE_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
2019-05-23 18:03:31 +08:00
|
|
|
void* bh_malloc_internal(unsigned int size)
|
2019-05-07 10:18:18 +08:00
|
|
|
{
|
|
|
|
if (memory_mode == MEMORY_MODE_UNKNOWN) {
|
|
|
|
printf("bh_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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-23 18:03:31 +08:00
|
|
|
void bh_free_internal(void *ptr)
|
2019-05-07 10:18:18 +08:00
|
|
|
{
|
|
|
|
if (memory_mode == MEMORY_MODE_UNKNOWN) {
|
|
|
|
printf("bh_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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-23 18:03:31 +08:00
|
|
|
#if BEIHAI_ENABLE_MEMORY_PROFILING != 0
|
|
|
|
void* bh_malloc_profile(const char *file,
|
|
|
|
int line,
|
|
|
|
const char *func,
|
|
|
|
unsigned int size)
|
|
|
|
{
|
|
|
|
void *p = bh_malloc_internal(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 = bh_malloc_internal(sizeof(memory_profile_t));
|
|
|
|
if (!profile) {
|
|
|
|
vm_mutex_unlock(&profile_lock);
|
|
|
|
memcpy(p, &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);
|
|
|
|
|
|
|
|
memcpy(p, &size, sizeof(size));
|
|
|
|
memory_in_use += size;
|
|
|
|
|
|
|
|
memory_profile_print(file, line, func, size);
|
|
|
|
|
|
|
|
return (char *)p + 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void bh_free_profile(const char *file, int line, const char *func, void *ptr)
|
|
|
|
{
|
|
|
|
unsigned int size = *(unsigned int *)((char *)ptr - 8);
|
|
|
|
memory_profile_t *profile;
|
|
|
|
|
|
|
|
bh_free_internal((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 = bh_malloc_internal(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) {
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
printf("location:%s@%d:used:%d:contribution:%d\n",
|
|
|
|
func, line, memory_in_use, alloc);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
void* bh_malloc(unsigned int size)
|
|
|
|
{
|
|
|
|
return bh_malloc_internal(size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void bh_free(void *ptr)
|
|
|
|
{
|
|
|
|
bh_free_internal(ptr);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-05-07 10:18:18 +08:00
|
|
|
#else /* else of MALLOC_MEMORY_FROM_SYSTEM */
|
|
|
|
|
2019-05-23 18:03:31 +08:00
|
|
|
#if BEIHAI_ENABLE_MEMORY_PROFILING == 0
|
|
|
|
|
2019-05-07 10:18:18 +08:00
|
|
|
void* bh_malloc(unsigned int size)
|
|
|
|
{
|
|
|
|
return malloc(size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void bh_free(void *ptr)
|
|
|
|
{
|
|
|
|
if (ptr)
|
2019-05-23 18:03:31 +08:00
|
|
|
free(ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* else of BEIHAI_ENABLE_MEMORY_PROFILING */
|
|
|
|
|
|
|
|
void* bh_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);
|
2019-05-07 10:18:18 +08:00
|
|
|
}
|
|
|
|
|
2019-05-23 18:03:31 +08:00
|
|
|
void bh_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 */
|
2019-05-07 10:18:18 +08:00
|
|
|
#endif /* end of MALLOC_MEMORY_FROM_SYSTEM*/
|
|
|
|
|