pure sdk for main
This commit is contained in:
divadiow
@@ -0,0 +1,234 @@
|
||||
|
||||
#include "sys_config.h"
|
||||
#include "typesdef.h"
|
||||
#include "osal/string.h"
|
||||
#include "lib/heap/sysheap.h"
|
||||
#include "lib/heap/sysheap_psram.h"
|
||||
#include "lib/heap/mtrace.h"
|
||||
|
||||
#if MPOOL_ALLOC
|
||||
|
||||
__bobj struct sys_heap sram_heap;
|
||||
|
||||
|
||||
void *_os_malloc(int size)
|
||||
{
|
||||
return sysheap_alloc(&sram_heap, size, RETURN_ADDR(), 0);
|
||||
}
|
||||
|
||||
void _os_free(void *ptr)
|
||||
{
|
||||
if (ptr) {
|
||||
sysheap_free(&sram_heap, ptr);
|
||||
}
|
||||
}
|
||||
|
||||
void *_os_zalloc(int size)
|
||||
{
|
||||
void *ptr = sysheap_alloc(&sram_heap, size, RETURN_ADDR(), 0);
|
||||
if (ptr) {
|
||||
os_memset(ptr, 0, size);
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void *_os_calloc(size_t nmemb, size_t size)
|
||||
{
|
||||
void *ptr = sysheap_alloc(&sram_heap, nmemb * size, RETURN_ADDR(), 0);
|
||||
if (ptr) {
|
||||
os_memset(ptr, 0, nmemb * size);
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void *_os_realloc(void *ptr, int size)
|
||||
{
|
||||
void *nptr = sysheap_alloc(&sram_heap, size, RETURN_ADDR(), 0);
|
||||
if (nptr) {
|
||||
os_memcpy(nptr, ptr, size);
|
||||
}
|
||||
if(ptr){
|
||||
_os_free(ptr);
|
||||
}
|
||||
return nptr;
|
||||
}
|
||||
|
||||
void *_os_malloc_t(int size, const char *func, int line)
|
||||
{
|
||||
return sysheap_alloc(&sram_heap, size, func, line);
|
||||
}
|
||||
|
||||
void _os_free_t(void *ptr)
|
||||
{
|
||||
if (ptr) {
|
||||
sysheap_free(&sram_heap, ptr);
|
||||
}
|
||||
}
|
||||
|
||||
void *_os_zalloc_t(int size, const char *func, int line)
|
||||
{
|
||||
void *ptr = _os_malloc_t(size, func, line);
|
||||
if (ptr) {
|
||||
os_memset(ptr, 0, size);
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void *_os_calloc_t(size_t nmemb, size_t size, const char *func, int line)
|
||||
{
|
||||
return _os_zalloc_t(nmemb * size, func, line);
|
||||
}
|
||||
|
||||
void *_os_realloc_t(void *ptr, int size, const char *func, int line)
|
||||
{
|
||||
void *nptr = _os_malloc_t(size, func, line);
|
||||
if (nptr && ptr) {
|
||||
os_memcpy(nptr, ptr, size);
|
||||
}
|
||||
if(ptr){
|
||||
_os_free_t(ptr);
|
||||
}
|
||||
return nptr;
|
||||
}
|
||||
|
||||
#ifdef MALLOC_IN_PSRAM
|
||||
void *malloc(uint32 size) __alias(_os_malloc_psram);
|
||||
void free(void *ptr) __alias(_os_free_psram);
|
||||
void *zalloc(size_t size) __alias(_os_zalloc_psram);
|
||||
void *calloc(size_t nmemb, size_t size) __alias(_os_calloc_psram);
|
||||
void *realloc(void *ptr, size_t size) __alias(_os_realloc_psram);
|
||||
#else
|
||||
void *malloc(uint32 size) __alias(_os_malloc);
|
||||
void free(void *ptr) __alias(_os_free);
|
||||
void *zalloc(size_t size) __alias(_os_zalloc);
|
||||
void *calloc(size_t nmemb, size_t size) __alias(_os_calloc);
|
||||
void *realloc(void *ptr, size_t size) __alias(_os_realloc);
|
||||
#endif
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
#ifdef PSRAM_HEAP
|
||||
__bobj struct sys_heap psram_heap;
|
||||
|
||||
void *_os_malloc_psram(int size)
|
||||
{
|
||||
void *ret = sysheap_alloc(&psram_heap, size, RETURN_ADDR(), 0);
|
||||
if(ret)
|
||||
{
|
||||
sys_dcache_clean_invalid_range(ret,size);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void _os_free_psram(void *ptr)
|
||||
{
|
||||
if (ptr) {
|
||||
sysheap_free(&psram_heap, ptr);
|
||||
}
|
||||
}
|
||||
|
||||
void *_os_zalloc_psram(size_t size)
|
||||
{
|
||||
void *ptr = sysheap_alloc(&psram_heap, size, RETURN_ADDR(), 0);
|
||||
if(ptr)
|
||||
{
|
||||
sys_dcache_clean_invalid_range(ptr,size);
|
||||
}
|
||||
if (ptr) {
|
||||
os_memset(ptr, 0, size);
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void *_os_calloc_psram(size_t nmemb, size_t size)
|
||||
{
|
||||
void *ptr = sysheap_alloc(&psram_heap, nmemb * size, RETURN_ADDR(), 0);
|
||||
if(ptr)
|
||||
{
|
||||
sys_dcache_clean_invalid_range(ptr,nmemb * size);
|
||||
}
|
||||
if (ptr) {
|
||||
os_memset(ptr, 0, nmemb * size);
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void *_os_realloc_psram(void *ptr, int size)
|
||||
{
|
||||
void *nptr = sysheap_alloc(&psram_heap, size, RETURN_ADDR(), 0);
|
||||
if(nptr){
|
||||
sys_dcache_clean_invalid_range(nptr,size);
|
||||
if (ptr) {
|
||||
os_memcpy(nptr, ptr, size);
|
||||
}
|
||||
}
|
||||
if(ptr){
|
||||
_os_free_psram(ptr);
|
||||
}
|
||||
return nptr;
|
||||
}
|
||||
|
||||
void *_os_malloc_psram_t(int size, const char *func, int line)
|
||||
{
|
||||
void *ret = sysheap_alloc(&psram_heap, size, func, line);
|
||||
if(ret)
|
||||
{
|
||||
sys_dcache_clean_invalid_range(ret,size);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void _os_free_psram_t(void *ptr)
|
||||
{
|
||||
if (ptr) {
|
||||
sysheap_free(&psram_heap, ptr);
|
||||
}
|
||||
}
|
||||
|
||||
void *_os_zalloc_psram_t(int size, const char *func, int line)
|
||||
{
|
||||
void *ptr = _os_malloc_psram_t(size, func, line);
|
||||
if(ptr)
|
||||
{
|
||||
sys_dcache_clean_invalid_range(ptr,size);
|
||||
}
|
||||
if (ptr) {
|
||||
os_memset(ptr, 0, size);
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void *_os_calloc_psram_t(size_t nmemb, size_t size, const char *func, int line)
|
||||
{
|
||||
return _os_zalloc_psram_t(nmemb * size, func, line);
|
||||
}
|
||||
|
||||
void *_os_realloc_psram_t(void *ptr, int size, const char *func, int line)
|
||||
{
|
||||
void *nptr = _os_malloc_psram_t(size, func, line);
|
||||
if (nptr && ptr) {
|
||||
os_memcpy(nptr, ptr, size);
|
||||
}
|
||||
if(ptr){
|
||||
_os_free_psram_t(ptr);
|
||||
}
|
||||
return nptr;
|
||||
}
|
||||
|
||||
void *malloc_psram(uint32 size) __alias(_os_malloc_psram);
|
||||
void free_psram(void *ptr) __alias(_os_free_psram);
|
||||
void *zalloc_psram(size_t size) __alias(_os_zalloc_psram);
|
||||
void *calloc_psram(size_t nmemb, size_t size) __alias(_os_calloc_psram);
|
||||
void *realloc_psram(void *ptr, size_t size) __alias(_os_realloc_psram);
|
||||
|
||||
#else
|
||||
void *_os_malloc_psram(int size) __alias(_os_malloc);
|
||||
void _os_free_psram(void *ptr) __alias(_os_free);
|
||||
void *_os_zalloc_psram(size_t size) __alias(_os_zalloc);
|
||||
void *_os_calloc_psram(size_t nmemb, size_t size) __alias(_os_calloc);
|
||||
void *_os_realloc_psram(void *ptr, int size) __alias(_os_realloc);
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,554 @@
|
||||
/*
|
||||
User defined heap pool
|
||||
*/
|
||||
|
||||
#include "typesdef.h"
|
||||
#include "osal/string.h"
|
||||
#include "lib/heap/mpool.h"
|
||||
#include "lib/heap/mmpool.h"
|
||||
#include "k_api.h"
|
||||
|
||||
enum SYSHEAP_FLAGS {
|
||||
SYSHEAP_FLAGS_MEM_LEAK_TRACE = (1u << 0),
|
||||
SYSHEAP_FLAGS_MEM_OVERFLOW_CHECK = (1u << 1),
|
||||
SYSHEAP_FLAGS_MEM_ALIGN_16 = (1u << 2),
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////
|
||||
/* 选择使用 哪个分配算法模块 */
|
||||
#define MMPOOL3 //使用 mmpool3
|
||||
//#define MMPOOL2 //使用 mmpool2
|
||||
//默认就是使用 mmpool1
|
||||
/////////////////////////////////////////////////////
|
||||
|
||||
#ifdef MMPOOL3
|
||||
#define MMPOOL mmpool3
|
||||
#define MPOOL_INIT(p,b,a,s) mmpool3_init(p,a,s,b)
|
||||
#define MPOOL_MALLOC(p,s,f,l) mmpool3_alloc(p,s,f,l)
|
||||
#define MPOOL_FREE(mp, p) mmpool3_free(mp, p)
|
||||
#define MPOOL_ADD(mp,a,s,b) mmpool3_add_region(mp,a,s,b)
|
||||
#define MPOOL_FREE_STATE(mp,b,s,t) mmpool3_free_state(mp,b,s,t)
|
||||
#define MPOOL_USED_STATE(mp,b,s,t,ms) mmpool3_used_state(mp,b,s,t,ms)
|
||||
#define MPOOL_FREE_SIZE(mp,s) mmpool3_free_size(mp, s)
|
||||
#define MPOOL_OF_CHECK(mp,a,s) mmpool3_of_check(mp,a,s)
|
||||
#define MPOOL_TOTAL_SIZE(mp) (mp)->size
|
||||
#define MPOOL_VALID_ADDR(mp, addr) mmpool3_valid_addr(mp, addr)
|
||||
#define MPOOL_ALLOC_PERF(mp, values, count) mmpool3_perfermance(mp, 1, values, count)
|
||||
#define MPOOL_FREE_PERF(mp, values, count) mmpool3_perfermance(mp, 0, values, count)
|
||||
#define MPOOL_TIME(mp, tot_alloc, tot_free) mmpool3_time(mp, tot_alloc, tot_free)
|
||||
|
||||
#elif defined(MMPOOL2)
|
||||
#define MMPOOL mmpool2
|
||||
#define MPOOL_INIT(p,b,a,s) mmpool2_init(p,a,s)
|
||||
#define MPOOL_MALLOC(p,s,f,l) mmpool2_alloc(p,s,f,l)
|
||||
#define MPOOL_FREE(mp, p) mmpool2_free(mp, p)
|
||||
#define MPOOL_ADD(mp,a,s,b) mmpool2_add_region(mp,a,s)
|
||||
#define MPOOL_FREE_STATE(mp,b,s,t) mmpool2_free_state(mp,b,s,t)
|
||||
#define MPOOL_USED_STATE(mp,b,s,t,ms) mmpool2_used_state(mp,b,s,t,ms)
|
||||
#define MPOOL_FREE_SIZE(mp,s) mmpool2_free_size(mp, s)
|
||||
#define MPOOL_OF_CHECK(mp,a,s) mmpool2_of_check(mp,a,s)
|
||||
#define MPOOL_TOTAL_SIZE(mp) (mp)->size
|
||||
#define MPOOL_VALID_ADDR(mp, addr) mmpool2_valid_addr(mp, addr)
|
||||
#define MPOOL_ALLOC_PERF(mp, values, count) mmpool2_perfermance(mp, 1, values, count)
|
||||
#define MPOOL_FREE_PERF(mp, values, count) mmpool2_perfermance(mp, 0, values, count)
|
||||
#define MPOOL_TIME(mp, tot_alloc, tot_free) mmpool2_time(mp, tot_alloc, tot_free)
|
||||
|
||||
#else
|
||||
#define MMPOOL mmpool
|
||||
#define MPOOL_INIT(p,b,a,s) mmpool_init(p,a,s)
|
||||
#define MPOOL_MALLOC(p,s,f,l) mmpool_alloc(p,s,f,l)
|
||||
#define MPOOL_FREE(mp, p) mmpool_free(mp, p)
|
||||
#define MPOOL_ADD(mp,a,s,b) mmpool_add_region(mp, a, s)
|
||||
#define MPOOL_FREE_STATE(mp, b, s, t) mmpool_free_state(mp, b, s, t)
|
||||
#define MPOOL_USED_STATE(mp, b, s, t, ms) mmpool_used_state(mp, b, s, t, ms)
|
||||
#define MPOOL_FREE_SIZE(mp, s) mmpool_free_size(mp, s)
|
||||
#define MPOOL_OF_CHECK(mp,a,s) mmpool_of_check(mp,a,s)
|
||||
#define MPOOL_TOTAL_SIZE(mp) (mp)->size
|
||||
#define MPOOL_VALID_ADDR(mp, addr) mmpool_valid_addr(mp, (uint32)addr)
|
||||
#define MPOOL_ALLOC_PERF(mp, values, count) mmpool_perfermance(mp, 1, values, count)
|
||||
#define MPOOL_FREE_PERF(mp, values, count) mmpool_perfermance(mp, 0, values, count)
|
||||
#define MPOOL_TIME(mp, tot_alloc, tot_free) mmpool_time(mp, tot_alloc, tot_free)
|
||||
#endif
|
||||
|
||||
struct MMPOOL user_pool;
|
||||
__init int32 uheap_init(void *heap_start, uint32 heap_size, uint32 flags)
|
||||
{
|
||||
memset(&user_pool, 0, sizeof(struct MMPOOL));
|
||||
user_pool.headsize = 4;
|
||||
|
||||
/* trace_off, ofchk_off 最大值为15，小心溢出*/
|
||||
if (flags & SYSHEAP_FLAGS_MEM_OVERFLOW_CHECK) {
|
||||
user_pool.ofchk_off = user_pool.headsize;
|
||||
user_pool.headsize += 4;
|
||||
user_pool.tailsize = 4;
|
||||
//os_printf("HEAP: OFCHK enabled\r\n");
|
||||
}
|
||||
|
||||
if (flags & SYSHEAP_FLAGS_MEM_LEAK_TRACE) {
|
||||
user_pool.trace_off = user_pool.headsize;
|
||||
user_pool.headsize += 20;
|
||||
//os_printf("HEAP: TRACE enabled\r\n");
|
||||
}
|
||||
|
||||
if (flags & SYSHEAP_FLAGS_MEM_ALIGN_16) {
|
||||
user_pool.align = 16;
|
||||
//os_printf("HEAP: ALIGN 16\r\n");
|
||||
}
|
||||
return MPOOL_INIT(&user_pool, 0, (uint32)heap_start, heap_size);
|
||||
}
|
||||
|
||||
uint32 uheap_time()
|
||||
{
|
||||
uint32 alloc = 0, free = 0;
|
||||
MPOOL_TIME(&user_pool, &alloc, &free);
|
||||
return (alloc + free) / 1000;
|
||||
}
|
||||
|
||||
void *uheap_alloc(int size, const char *func, int line)
|
||||
{
|
||||
void *ptr = MPOOL_MALLOC(&user_pool, size, func, line);
|
||||
if (ptr == NULL) {
|
||||
os_printf(KERN_ERR"User POOL alloc fail, size=%d, (lr:0x%x,%s:%d)\r\n", size, line?0:func, line?func:"", line);
|
||||
}else{
|
||||
ASSERT((uint32)ptr == ALIGN((uint32)ptr, user_pool.align));
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void uheap_free(void *ptr)
|
||||
{
|
||||
if (ptr) {
|
||||
ASSERT((uint32)ptr == ALIGN((uint32)ptr, user_pool.align));
|
||||
MPOOL_FREE(&user_pool, ptr);
|
||||
}
|
||||
}
|
||||
|
||||
int32 uheap_add(void *heap_start, uint32 heap_size)
|
||||
{
|
||||
return MPOOL_ADD(&user_pool, (uint32)heap_start, heap_size, 0);
|
||||
}
|
||||
|
||||
void uheap_collect_init(uint32 start, uint32 end)
|
||||
{
|
||||
uheap_add((void *)start, end - start);
|
||||
}
|
||||
|
||||
uint32 uheap_freesize()
|
||||
{
|
||||
return MPOOL_FREE_SIZE(&user_pool, 0);
|
||||
}
|
||||
|
||||
uint32 uheap_totalsize()
|
||||
{
|
||||
return MPOOL_TOTAL_SIZE(&user_pool);
|
||||
}
|
||||
|
||||
int32 uheap_of_check(void *ptr, uint32 size)
|
||||
{
|
||||
return MPOOL_OF_CHECK(&user_pool, (uint32)ptr, size);
|
||||
}
|
||||
|
||||
int32 uheap_valid_addr(void *ptr)
|
||||
{
|
||||
return MPOOL_VALID_ADDR(&user_pool, (uint32)ptr);
|
||||
}
|
||||
|
||||
void uheap_status(uint32 *status_buf, int32 buf_size, uint32 mini_size)
|
||||
{
|
||||
int32 i = 0 ;
|
||||
int32 count = 0;
|
||||
int32 log = 0;
|
||||
uint32 total_size = 0;
|
||||
uint32 tmps;
|
||||
|
||||
if(status_buf == NULL){
|
||||
os_printf("User POOL: total:%d free:%d\r\n", user_pool.size, MPOOL_FREE_SIZE(&user_pool, 0));
|
||||
return;
|
||||
}
|
||||
|
||||
os_printf("user_heap(%s): regions:%d, align:%d, headsize:%d, tailsize:%d, trace:%d, ofchk:%d\r\n",
|
||||
user_pool.name, user_pool.region_cnt, user_pool.align,
|
||||
user_pool.headsize, user_pool.tailsize, user_pool.trace_off, user_pool.ofchk_off);
|
||||
|
||||
count = MPOOL_FREE_STATE(&user_pool, status_buf, buf_size, &total_size);
|
||||
os_printf("-----------------------------------------------\r\n");
|
||||
os_printf("free regions: %d\r\n", count / 2);
|
||||
for (i = 0; i < count; i += 2) {
|
||||
tmps = status_buf[i + 1];
|
||||
log = 0;
|
||||
while ((tmps /= 2) != 0) log++;
|
||||
os_printf("%02d: 0x%x ~ 0x%x, size:%d \t[%d]\r\n", (i / 2) + 1, status_buf[i],
|
||||
status_buf[i] + status_buf[i + 1], status_buf[i + 1], log);
|
||||
}
|
||||
os_printf("total free size:%d\r\n", total_size);
|
||||
os_printf("-----------------------------------------------\r\n");
|
||||
|
||||
if (user_pool.trace_off) {
|
||||
total_size = 0;
|
||||
count = MPOOL_USED_STATE(&user_pool, status_buf, buf_size, &total_size, mini_size);
|
||||
os_printf("User POOL used regions: %d\r\n", count / 5);
|
||||
for (i = 0; i < count; i += 5) {
|
||||
if (status_buf[i + 1]) {
|
||||
os_printf("%s:%d, size:%d, tick:%d, addr:%x\r\n", (char *)status_buf[i], status_buf[i + 1], status_buf[i + 2], status_buf[i + 3], status_buf[i + 4]);
|
||||
} else {
|
||||
os_printf("lr:0x%x, size:%d, tick:%d, addr:%x\r\n", status_buf[i], status_buf[i + 2], status_buf[i + 3], status_buf[i + 4]);
|
||||
}
|
||||
}
|
||||
os_printf("total used size:%d\r\n", total_size);
|
||||
os_printf("-----------------------------------------------\r\n");
|
||||
}
|
||||
os_printf("total size:%d\r\n", user_pool.size);
|
||||
|
||||
count = MPOOL_ALLOC_PERF(&user_pool, status_buf, buf_size);
|
||||
if(count){
|
||||
os_printf("alloc perfermace:");
|
||||
for(i=0;i<count;i++) _os_printf(" %-03d", status_buf[i]);
|
||||
_os_printf("\r\n");
|
||||
}
|
||||
|
||||
count = MPOOL_FREE_PERF(&user_pool, status_buf, buf_size);
|
||||
if(count){
|
||||
os_printf("free perfermace:");
|
||||
for(i=0;i<count;i++) _os_printf(" %-03d", status_buf[i]);
|
||||
_os_printf("\r\n");
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef PSRAM_HEAP
|
||||
struct MMPOOL psram_pool;
|
||||
|
||||
void uheap_psram_status(uint32 *status_buf, int32 buf_size, uint32 mini_size)
|
||||
{
|
||||
int32 i = 0 ;
|
||||
int32 count = 0;
|
||||
int32 log = 0;
|
||||
uint32 total_size = 0;
|
||||
uint32 tmps;
|
||||
|
||||
if(status_buf == NULL){
|
||||
os_printf("User POOL: total:%d free:%d\r\n", psram_pool.size, MPOOL_FREE_SIZE(&psram_pool, 0));
|
||||
return;
|
||||
}
|
||||
|
||||
os_printf("user_heap(%s): regions:%d, align:%d, headsize:%d, tailsize:%d, trace:%d, ofchk:%d\r\n",
|
||||
psram_pool.name, psram_pool.region_cnt, psram_pool.align,
|
||||
psram_pool.headsize, psram_pool.tailsize, psram_pool.trace_off, psram_pool.ofchk_off);
|
||||
|
||||
count = MPOOL_FREE_STATE(&psram_pool, status_buf, buf_size, &total_size);
|
||||
os_printf("-----------------------------------------------\r\n");
|
||||
os_printf("free regions: %d\r\n", count / 2);
|
||||
for (i = 0; i < count; i += 2) {
|
||||
tmps = status_buf[i + 1];
|
||||
log = 0;
|
||||
while ((tmps /= 2) != 0) log++;
|
||||
os_printf("%02d: 0x%x ~ 0x%x, size:%d \t[%d]\r\n", (i / 2) + 1, status_buf[i],
|
||||
status_buf[i] + status_buf[i + 1], status_buf[i + 1], log);
|
||||
}
|
||||
os_printf("total free size:%d\r\n", total_size);
|
||||
os_printf("-----------------------------------------------\r\n");
|
||||
|
||||
if (psram_pool.trace_off) {
|
||||
total_size = 0;
|
||||
count = MPOOL_USED_STATE(&psram_pool, status_buf, buf_size, &total_size, mini_size);
|
||||
os_printf("User POOL used regions: %d\r\n", count / 5);
|
||||
for (i = 0; i < count; i += 5) {
|
||||
if (status_buf[i + 1]) {
|
||||
os_printf("%s:%d, size:%d, tick:%d, addr:%x\r\n", (char *)status_buf[i], status_buf[i + 1], status_buf[i + 2], status_buf[i + 3], status_buf[i + 4]);
|
||||
} else {
|
||||
os_printf("lr:0x%x, size:%d, tick:%d, addr:%x\r\n", status_buf[i], status_buf[i + 2], status_buf[i + 3], status_buf[i + 4]);
|
||||
}
|
||||
}
|
||||
os_printf("total used size:%d\r\n", total_size);
|
||||
os_printf("-----------------------------------------------\r\n");
|
||||
}
|
||||
os_printf("total size:%d\r\n", psram_pool.size);
|
||||
|
||||
count = MPOOL_ALLOC_PERF(&psram_pool, status_buf, buf_size);
|
||||
if(count){
|
||||
os_printf("alloc perfermace:");
|
||||
for(i=0;i<count;i++) _os_printf(" %-03d", status_buf[i]);
|
||||
_os_printf("\r\n");
|
||||
}
|
||||
|
||||
count = MPOOL_FREE_PERF(&psram_pool, status_buf, buf_size);
|
||||
if(count){
|
||||
os_printf("free perfermace:");
|
||||
for(i=0;i<count;i++) _os_printf(" %-03d", status_buf[i]);
|
||||
_os_printf("\r\n");
|
||||
}
|
||||
}
|
||||
|
||||
__init int32 psram_heap_init(void *heap_start, uint32 heap_size, uint32 flags) {
|
||||
memset(&psram_pool, 0, sizeof(struct MMPOOL));
|
||||
psram_pool.headsize = 4;
|
||||
|
||||
/* trace_off, ofchk_off 最大值为15，小心溢出*/
|
||||
if (flags & SYSHEAP_FLAGS_MEM_OVERFLOW_CHECK) {
|
||||
psram_pool.ofchk_off = psram_pool.headsize;
|
||||
psram_pool.headsize += 4;
|
||||
psram_pool.tailsize = 4;
|
||||
//os_printf("HEAP: OFCHK enabled\r\n");
|
||||
}
|
||||
|
||||
if (flags & SYSHEAP_FLAGS_MEM_LEAK_TRACE) {
|
||||
psram_pool.trace_off = psram_pool.headsize;
|
||||
psram_pool.headsize += 20;
|
||||
//os_printf("HEAP: TRACE enabled\r\n");
|
||||
}
|
||||
|
||||
if (flags & SYSHEAP_FLAGS_MEM_ALIGN_16) {
|
||||
psram_pool.align = 16;
|
||||
//os_printf("HEAP: ALIGN 16\r\n");
|
||||
}
|
||||
return MPOOL_INIT(&psram_pool, 0, (uint32)heap_start, heap_size);
|
||||
}
|
||||
|
||||
void *psram_heap_alloc(int size, const char *func, int line)
|
||||
{
|
||||
void *ptr = MPOOL_MALLOC(&psram_pool, size, func, line);
|
||||
if (ptr == NULL) {
|
||||
os_printf(KERN_ERR"User POOL alloc fail, size=%d, (lr:0x%x,%s:%d)\r\n", size, line?0:func, line?func:"", line);
|
||||
}
|
||||
sys_dcache_clean_invalid_range(ptr,size);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void psram_heap_free(void *ptr)
|
||||
{
|
||||
if (ptr) {
|
||||
MPOOL_FREE(&psram_pool, ptr);
|
||||
}
|
||||
}
|
||||
|
||||
uint32 psram_heap_freesize()
|
||||
{
|
||||
return MPOOL_FREE_SIZE(&psram_pool, 0);
|
||||
}
|
||||
|
||||
uint32 psram_heap_totalsize()
|
||||
{
|
||||
return MPOOL_TOTAL_SIZE(&psram_pool);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef LV_PSRAM_HEAP
|
||||
struct MMPOOL lvgl_pool;
|
||||
|
||||
__init int32 lvgl_heap_init(void *heap_start, uint32 heap_size, uint32 flags) {
|
||||
memset(&lvgl_pool, 0, sizeof(struct MMPOOL));
|
||||
lvgl_pool.headsize = 4;
|
||||
|
||||
/* trace_off, ofchk_off 最大值为15，小心溢出*/
|
||||
if (flags & SYSHEAP_FLAGS_MEM_OVERFLOW_CHECK) {
|
||||
lvgl_pool.ofchk_off = lvgl_pool.headsize;
|
||||
lvgl_pool.headsize += 4;
|
||||
lvgl_pool.tailsize = 4;
|
||||
//os_printf("HEAP: OFCHK enabled\r\n");
|
||||
}
|
||||
|
||||
if (flags & SYSHEAP_FLAGS_MEM_LEAK_TRACE) {
|
||||
lvgl_pool.trace_off = lvgl_pool.headsize;
|
||||
lvgl_pool.headsize += 20;
|
||||
//os_printf("HEAP: TRACE enabled\r\n");
|
||||
}
|
||||
|
||||
if (flags & SYSHEAP_FLAGS_MEM_ALIGN_16) {
|
||||
lvgl_pool.align = 16;
|
||||
//os_printf("HEAP: ALIGN 16\r\n");
|
||||
}
|
||||
return MPOOL_INIT(&lvgl_pool, 0, (uint32)heap_start, heap_size);
|
||||
}
|
||||
|
||||
void *lvgl_heap_alloc(int size, const char *func, int line)
|
||||
{
|
||||
void *ptr = MPOOL_MALLOC(&lvgl_pool, size, func, line);
|
||||
if (ptr == NULL) {
|
||||
os_printf(KERN_ERR"User POOL alloc fail, size=%d, (lr:0x%x,%s:%d)\r\n", size, line?0:func, line?func:"", line);
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void lvgl_heap_free(void *ptr)
|
||||
{
|
||||
if (ptr) {
|
||||
MPOOL_FREE(&lvgl_pool, ptr);
|
||||
}
|
||||
}
|
||||
|
||||
uint32 lvgl_heap_freesize()
|
||||
{
|
||||
return MPOOL_FREE_SIZE(&lvgl_pool, 0);
|
||||
}
|
||||
|
||||
uint32 lvgl_heap_totalsize()
|
||||
{
|
||||
return MPOOL_TOTAL_SIZE(&lvgl_pool);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef LWIP_PSRAM_HEAP
|
||||
struct MMPOOL lwip_pool;
|
||||
|
||||
__init int32 lwip_heap_init(void *heap_start, uint32 heap_size, uint32 flags) {
|
||||
memset(&lwip_pool, 0, sizeof(struct MMPOOL));
|
||||
lwip_pool.headsize = 4;
|
||||
|
||||
/* trace_off, ofchk_off 最大值为15，小心溢出*/
|
||||
if (flags & SYSHEAP_FLAGS_MEM_OVERFLOW_CHECK) {
|
||||
lwip_pool.ofchk_off = lwip_pool.headsize;
|
||||
lwip_pool.headsize += 4;
|
||||
lwip_pool.tailsize = 4;
|
||||
//os_printf("HEAP: OFCHK enabled\r\n");
|
||||
}
|
||||
|
||||
if (flags & SYSHEAP_FLAGS_MEM_LEAK_TRACE) {
|
||||
lwip_pool.trace_off = lwip_pool.headsize;
|
||||
lwip_pool.headsize += 20;
|
||||
//os_printf("HEAP: TRACE enabled\r\n");
|
||||
}
|
||||
|
||||
if (flags & SYSHEAP_FLAGS_MEM_ALIGN_16) {
|
||||
lwip_pool.align = 16;
|
||||
//os_printf("HEAP: ALIGN 16\r\n");
|
||||
}
|
||||
return MPOOL_INIT(&lwip_pool, 0, (uint32)heap_start, heap_size);
|
||||
}
|
||||
|
||||
void *lwip_heap_alloc(int size, const char *func, int line)
|
||||
{
|
||||
void *ptr = MPOOL_MALLOC(&lwip_pool, size, func, line);
|
||||
if (ptr == NULL) {
|
||||
os_printf(KERN_ERR"User POOL alloc fail, size=%d, (lr:0x%x,%s:%d)\r\n", size, line?0:func, line?func:"", line);
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void lwip_heap_free(void *ptr)
|
||||
{
|
||||
if (ptr) {
|
||||
MPOOL_FREE(&lwip_pool, ptr);
|
||||
}
|
||||
}
|
||||
|
||||
uint32 lwip_heap_freesize()
|
||||
{
|
||||
return MPOOL_FREE_SIZE(&lwip_pool, 0);
|
||||
}
|
||||
|
||||
uint32 lwip_heap_totalsize()
|
||||
{
|
||||
return MPOOL_TOTAL_SIZE(&lwip_pool);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef SYS_TASK_PSRAM_HEAP
|
||||
struct MMPOOL mlsys_pool;
|
||||
|
||||
__init int32 mlsys_heap_init(void *heap_start, uint32 heap_size, uint32 flags) {
|
||||
memset(&mlsys_pool, 0, sizeof(struct MMPOOL));
|
||||
mlsys_pool.headsize = 4;
|
||||
|
||||
/* trace_off, ofchk_off 最大值为15，小心溢出*/
|
||||
if (flags & SYSHEAP_FLAGS_MEM_OVERFLOW_CHECK) {
|
||||
mlsys_pool.ofchk_off = mlsys_pool.headsize;
|
||||
mlsys_pool.headsize += 4;
|
||||
mlsys_pool.tailsize = 4;
|
||||
//os_printf("HEAP: OFCHK enabled\r\n");
|
||||
}
|
||||
|
||||
if (flags & SYSHEAP_FLAGS_MEM_LEAK_TRACE) {
|
||||
mlsys_pool.trace_off = mlsys_pool.headsize;
|
||||
mlsys_pool.headsize += 20;
|
||||
//os_printf("HEAP: TRACE enabled\r\n");
|
||||
}
|
||||
|
||||
if (flags & SYSHEAP_FLAGS_MEM_ALIGN_16) {
|
||||
mlsys_pool.align = 16;
|
||||
//os_printf("HEAP: ALIGN 16\r\n");
|
||||
}
|
||||
return MPOOL_INIT(&mlsys_pool, 0, (uint32)heap_start, heap_size);
|
||||
}
|
||||
|
||||
void *mlsys_heap_alloc(int size, const char *func, int line)
|
||||
{
|
||||
void *ptr = MPOOL_MALLOC(&mlsys_pool, size, func, line);
|
||||
if (ptr == NULL) {
|
||||
os_printf(KERN_ERR"User POOL alloc fail, size=%d, (lr:0x%x,%s:%d)\r\n", size, line?0:func, line?func:"", line);
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void mlsys_heap_free(void *ptr)
|
||||
{
|
||||
if (ptr) {
|
||||
MPOOL_FREE(&mlsys_pool, ptr);
|
||||
}
|
||||
}
|
||||
|
||||
uint32 mlsys_heap_freesize()
|
||||
{
|
||||
return MPOOL_FREE_SIZE(&mlsys_pool, 0);
|
||||
}
|
||||
|
||||
uint32 mlsys_heap_totalsize()
|
||||
{
|
||||
return MPOOL_TOTAL_SIZE(&mlsys_pool);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FREE_TYPE_PSRAM_HEAP
|
||||
struct MMPOOL ft_pool;
|
||||
|
||||
__init int32 ft_heap_init(void *heap_start, uint32 heap_size, uint32 flags) {
|
||||
memset(&ft_pool, 0, sizeof(struct MMPOOL));
|
||||
ft_pool.headsize = 4;
|
||||
|
||||
/* trace_off, ofchk_off 最大值为15，小心溢出*/
|
||||
if (flags & SYSHEAP_FLAGS_MEM_OVERFLOW_CHECK) {
|
||||
ft_pool.ofchk_off = ft_pool.headsize;
|
||||
ft_pool.headsize += 4;
|
||||
ft_pool.tailsize = 4;
|
||||
//os_printf("HEAP: OFCHK enabled\r\n");
|
||||
}
|
||||
|
||||
if (flags & SYSHEAP_FLAGS_MEM_LEAK_TRACE) {
|
||||
ft_pool.trace_off = ft_pool.headsize;
|
||||
ft_pool.headsize += 20;
|
||||
//os_printf("HEAP: TRACE enabled\r\n");
|
||||
}
|
||||
|
||||
if (flags & SYSHEAP_FLAGS_MEM_ALIGN_16) {
|
||||
ft_pool.align = 16;
|
||||
//os_printf("HEAP: ALIGN 16\r\n");
|
||||
}
|
||||
return MPOOL_INIT(&ft_pool, 0, (uint32)heap_start, heap_size);
|
||||
}
|
||||
|
||||
void *ft_heap_alloc(int size, const char *func, int line)
|
||||
{
|
||||
void *ptr = MPOOL_MALLOC(&ft_pool, size, func, line);
|
||||
if (ptr == NULL) {
|
||||
os_printf(KERN_ERR"User POOL alloc fail, size=%d, (lr:0x%x,%s:%d)\r\n", size, line?0:func, line?func:"", line);
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void ft_heap_free(void *ptr)
|
||||
{
|
||||
if (ptr) {
|
||||
MPOOL_FREE(&ft_pool, ptr);
|
||||
}
|
||||
}
|
||||
|
||||
uint32 ft_heap_freesize()
|
||||
{
|
||||
return MPOOL_FREE_SIZE(&ft_pool, 0);
|
||||
}
|
||||
|
||||
uint32 ft_heap_totalsize()
|
||||
{
|
||||
return MPOOL_TOTAL_SIZE(&ft_pool);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
Reference in New Issue
Block a user