Mirrors/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2026-10-02 03:00:34 +03:00
Code Issues Packages Projects Releases Wiki Activity

change(bt): separated host mem apis from bt_osi_mem.c

Browse Source
This commit is contained in:
ShenWeilong
2026-05-13 14:59:28 +08:00
parent 0e313e0207
commit e59109e6a5
11 changed files with 502 additions and 463 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/bt/porting/mem/bt_osi_mem.c
+34 -330
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2015-2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -10,311 +10,17 @@
#include "esp_log.h"
#include <assert.h>
static uint8_t log_count;
#if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED
static size_t controller_mem_used_size = 0;
static size_t host_mem_used_size = 0;
#endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED
#if CONFIG_BT_LE_MEM_CHECK_ENABLED
static uint16_t mem_count_limit = 0;
static uint16_t curr_mem_count;
#endif // CONFIG_BT_LE_MEM_CHECK_ENABLED
#if CONFIG_BT_NIMBLE_MEM_DEBUG
#define NIMBLE_MEM_DBG_INFO_MAX 1024*3
typedef struct {
void *p;
int size;
const char *func;
int line;
} nimble_mem_dbg_info_t;
static uint32_t nimble_mem_dbg_count = 0;
static nimble_mem_dbg_info_t nimble_mem_dbg_info[NIMBLE_MEM_DBG_INFO_MAX];
static uint32_t nimble_mem_dbg_current_size = 0;
static uint32_t nimble_mem_dbg_max_size = 0;
#define NIMBLE_MEM_DBG_MAX_SECTION_NUM 5
typedef struct {
bool used;
uint32_t max_size;
} nimble_mem_dbg_max_size_section_t;
static nimble_mem_dbg_max_size_section_t nimble_mem_dbg_max_size_section[NIMBLE_MEM_DBG_MAX_SECTION_NUM];
void nimble_mem_dbg_init(void)
{
int i;
for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) {
nimble_mem_dbg_info[i].p = NULL;
nimble_mem_dbg_info[i].size = 0;
nimble_mem_dbg_info[i].func = NULL;
nimble_mem_dbg_info[i].line = 0;
}
nimble_mem_dbg_count = 0;
nimble_mem_dbg_current_size = 0;
nimble_mem_dbg_max_size = 0;
for (i = 0; i < NIMBLE_MEM_DBG_MAX_SECTION_NUM; i++){
nimble_mem_dbg_max_size_section[i].used = false;
nimble_mem_dbg_max_size_section[i].max_size = 0;
}
}
void nimble_mem_dbg_record(void *p, int size, const char *func, int line)
{
int i;
if (!p || size == 0) {
ESP_LOGE("BT_NIMBLE_MEM", "%s invalid !!\n", __func__);
return;
}
for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) {
if (nimble_mem_dbg_info[i].p == NULL) {
nimble_mem_dbg_info[i].p = p;
nimble_mem_dbg_info[i].size = size;
nimble_mem_dbg_info[i].func = func;
nimble_mem_dbg_info[i].line = line;
nimble_mem_dbg_count++;
break;
}
}
if (i >= NIMBLE_MEM_DBG_INFO_MAX) {
ESP_LOGE("BT_NIMBLE_MEM", "%s full %s %d !!\n", __func__, func, line);
}
nimble_mem_dbg_current_size += size;
if(nimble_mem_dbg_max_size < nimble_mem_dbg_current_size) {
nimble_mem_dbg_max_size = nimble_mem_dbg_current_size;
}
for (i = 0; i < NIMBLE_MEM_DBG_MAX_SECTION_NUM; i++){
if (nimble_mem_dbg_max_size_section[i].used) {
if(nimble_mem_dbg_max_size_section[i].max_size < nimble_mem_dbg_current_size) {
nimble_mem_dbg_max_size_section[i].max_size = nimble_mem_dbg_current_size;
}
}
}
}
void nimble_mem_dbg_clean(void *p, const char *func, int line)
{
int i;
if (!p) {
ESP_LOGE("BT_NIMBLE_MEM", "%s %d free->%p invalid\n", func, line, p);
return;
}
for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) {
if (nimble_mem_dbg_info[i].p == p) {
nimble_mem_dbg_current_size -= nimble_mem_dbg_info[i].size;
nimble_mem_dbg_info[i].p = NULL;
nimble_mem_dbg_info[i].size = 0;
nimble_mem_dbg_info[i].func = NULL;
nimble_mem_dbg_info[i].line = 0;
nimble_mem_dbg_count--;
break;
}
}
if (i >= NIMBLE_MEM_DBG_INFO_MAX) {
ESP_LOGE("BT_NIMBLE_MEM", "%s full %s %d !!\n", __func__, func, line);
}
}
void nimble_mem_dbg_show(void)
{
int i;
for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) {
if (nimble_mem_dbg_info[i].p || nimble_mem_dbg_info[i].size != 0 ) {
ESP_LOGE("BT_NIMBLE_MEM", "--> p %p, s %d, f %s, l %d\n",
nimble_mem_dbg_info[i].p, nimble_mem_dbg_info[i].size,
nimble_mem_dbg_info[i].func, nimble_mem_dbg_info[i].line);
}
}
ESP_LOGE("BT_NIMBLE_MEM", "--> count %ld\n", nimble_mem_dbg_count);
ESP_LOGE("BT_NIMBLE_MEM", "--> size %ldB\n--> max size %ldB\n",
nimble_mem_dbg_current_size, nimble_mem_dbg_max_size);
}
uint32_t nimble_mem_dbg_get_max_size(void)
{
return nimble_mem_dbg_max_size;
}
uint32_t nimble_mem_dbg_get_current_size(void)
{
return nimble_mem_dbg_current_size;
}
void nimble_mem_dbg_set_section_start(uint8_t index)
{
if (index >= NIMBLE_MEM_DBG_MAX_SECTION_NUM) {
ESP_LOGE("BT_NIMBLE_MEM", "Then range of index should be between 0 and %d, current index is %d.\n",
NIMBLE_MEM_DBG_MAX_SECTION_NUM - 1, index);
return;
}
if (nimble_mem_dbg_max_size_section[index].used) {
ESP_LOGW("BT_NIMBLE_MEM", "This index(%d) has been started, restart it.\n", index);
}
nimble_mem_dbg_max_size_section[index].used = true;
nimble_mem_dbg_max_size_section[index].max_size = nimble_mem_dbg_current_size;
}
void nimble_mem_dbg_set_section_end(uint8_t index)
{
if (index >= NIMBLE_MEM_DBG_MAX_SECTION_NUM) {
ESP_LOGE("BT_NIMBLE_MEM", "Then range of index should be between 0 and %d, current index is %d.\n",
NIMBLE_MEM_DBG_MAX_SECTION_NUM - 1, index);
return;
}
if (!nimble_mem_dbg_max_size_section[index].used) {
ESP_LOGE("BT_NIMBLE_MEM", "This index(%d) has not been started.\n", index);
return;
}
nimble_mem_dbg_max_size_section[index].used = false;
}
uint32_t nimble_mem_dbg_get_max_size_section(uint8_t index)
{
if (index >= NIMBLE_MEM_DBG_MAX_SECTION_NUM){
ESP_LOGE("BT_NIMBLE_MEM", "Then range of index should be between 0 and %d, current index is %d.\n",
NIMBLE_MEM_DBG_MAX_SECTION_NUM - 1, index);
return 0;
}
return nimble_mem_dbg_max_size_section[index].max_size;
}
void *nimble_mem_dbg_realloc(void *ptr, size_t new_size, const char *func, int line)
{
size_t old_size = 0;
int i;
void *new_ptr = realloc(ptr, new_size);
if (new_ptr == NULL && new_size > 0) {
// realloc failed, keep old ptr record
return NULL;
}
// Find and clean old record if ptr is not NULL
if (ptr != NULL) {
for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) {
if (nimble_mem_dbg_info[i].p == ptr) {
old_size = nimble_mem_dbg_info[i].size;
nimble_mem_dbg_current_size -= old_size;
nimble_mem_dbg_info[i].p = NULL;
nimble_mem_dbg_info[i].size = 0;
nimble_mem_dbg_info[i].func = NULL;
nimble_mem_dbg_info[i].line = 0;
nimble_mem_dbg_count--;
break;
}
}
}
// Record the new allocation if new_size > 0
if (new_ptr != NULL && new_size > 0) {
for (i = 0; i < NIMBLE_MEM_DBG_INFO_MAX; i++) {
if (nimble_mem_dbg_info[i].p == NULL) {
nimble_mem_dbg_info[i].p = new_ptr;
nimble_mem_dbg_info[i].size = new_size;
nimble_mem_dbg_info[i].func = func;
nimble_mem_dbg_info[i].line = line;
nimble_mem_dbg_count++;
break;
}
}
if (i >= NIMBLE_MEM_DBG_INFO_MAX) {
ESP_LOGE("BT_NIMBLE_MEM", "%s full %s %d !!\n", __func__, func, line);
}
nimble_mem_dbg_current_size += new_size;
if (nimble_mem_dbg_max_size < nimble_mem_dbg_current_size) {
nimble_mem_dbg_max_size = nimble_mem_dbg_current_size;
}
for (i = 0; i < NIMBLE_MEM_DBG_MAX_SECTION_NUM; i++) {
if (nimble_mem_dbg_max_size_section[i].used &&
nimble_mem_dbg_max_size_section[i].max_size < nimble_mem_dbg_current_size) {
nimble_mem_dbg_max_size_section[i].max_size = nimble_mem_dbg_current_size;
}
}
}
return new_ptr;
}
#endif // CONFIG_BT_NIMBLE_MEM_DEBUG
#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE
IRAM_ATTR
#endif
void *bt_osi_mem_malloc(size_t size)
{
void *mem = NULL;
#ifdef CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_INTERNAL
mem = heap_caps_malloc(size, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
#elif CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_EXTERNAL
mem = heap_caps_malloc(size, MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT);
#elif CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_IRAM_8BIT
mem = heap_caps_malloc_prefer(size, 2, MALLOC_CAP_INTERNAL|MALLOC_CAP_IRAM_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
#else
mem = malloc(size);
#endif
if (!mem) {
log_count ++;
if ((log_count % 100) == 0) {
ESP_EARLY_LOGI("ESP_LOG_INFO","malloc failed (size %zu)",size);
log_count = 0;
}
assert(mem != NULL);
}
#if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED
if(mem) {
host_mem_used_size += heap_caps_get_allocated_size(mem);
}
#endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED
return mem;
}
#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE
IRAM_ATTR
#endif
void *bt_osi_mem_calloc(size_t n, size_t size)
{
void *mem = NULL;
#ifdef CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_INTERNAL
mem = heap_caps_calloc(n, size, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
#elif CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_EXTERNAL
mem = heap_caps_calloc(n, size, MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT);
#elif CONFIG_BT_NIMBLE_MEM_ALLOC_MODE_IRAM_8BIT
mem = heap_caps_calloc_prefer(n, size, 2, MALLOC_CAP_INTERNAL|MALLOC_CAP_IRAM_8BIT, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
#else
mem = calloc(n, size);
#endif
#if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED
if(mem) {
host_mem_used_size += heap_caps_get_allocated_size(mem);
}
#endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED
return mem;
}
#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE
IRAM_ATTR
#endif
void *bt_osi_mem_malloc_internal(size_t size)
void *
bt_osi_mem_malloc_internal(size_t size)
{
void *mem_ptr;
#if CONFIG_BT_LE_MEM_CHECK_ENABLED
@@ -334,10 +40,9 @@ void *bt_osi_mem_malloc_internal(size_t size)
return mem_ptr;
}
#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE
IRAM_ATTR
#endif
void *bt_osi_mem_calloc_internal(size_t n, size_t size)
void *
bt_osi_mem_calloc_internal(size_t n, size_t size)
{
void *mem_ptr;
#if CONFIG_BT_LE_MEM_CHECK_ENABLED
@@ -357,10 +62,8 @@ void *bt_osi_mem_calloc_internal(size_t n, size_t size)
return mem_ptr;
}
#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE
IRAM_ATTR
#endif
void bt_osi_mem_free_internal(void *ptr)
void
bt_osi_mem_free_internal(void *ptr)
{
#if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED
if (ptr) {
@@ -374,21 +77,35 @@ void bt_osi_mem_free_internal(void *ptr)
}
}
#if !CONFIG_BT_NIMBLE_LOW_SPEED_MODE
IRAM_ATTR
#endif
void bt_osi_mem_free(void *ptr)
void *
bt_osi_mem_malloc(size_t size)
{
void *mem_ptr;
#if CONFIG_BT_LE_MEM_CHECK_ENABLED
if (mem_count_limit) {
if (curr_mem_count > mem_count_limit) {
return NULL;
}
curr_mem_count ++;
}
#endif // CONFIG_BT_LE_MEM_CHECK_ENABLED
mem_ptr = heap_caps_malloc(size, MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
#if CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED
if (ptr) {
size_t alloc_size = heap_caps_get_allocated_size(ptr);
// assert(host_mem_used_size >= alloc_size);
host_mem_used_size -= alloc_size;
if (mem_ptr) {
controller_mem_used_size += heap_caps_get_allocated_size(mem_ptr);
}
#endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED
if (ptr) {
heap_caps_free(ptr);
}
return mem_ptr;
}
void
bt_osi_mem_free(void *ptr)
{
bt_osi_mem_free_internal(ptr);
}
#if CONFIG_BT_LE_MEM_CHECK_ENABLED
@@ -406,21 +123,8 @@ bt_osi_mem_internal_used_size_get(void)
return controller_mem_used_size;
}
size_t
bt_osi_mem_used_size_get(void)
{
return host_mem_used_size;
}
uint32_t esp_ble_controller_used_heap_size_get(void)
{
return bt_osi_mem_internal_used_size_get();
}
#if CONFIG_BT_NIMBLE_ENABLED
uint32_t esp_host_used_heap_size_get(void)
{
return bt_osi_mem_used_size_get();
}
#endif // CONFIG_BT_NIMBLE_ENABLED
#endif // CONFIG_BT_LE_USED_MEM_STATISTICS_ENABLED
components/bt/porting/mem/os_mempool.c
+2
View File
@@ -513,9 +513,11 @@ os_memblock_get(struct os_mempool *mp)
// Should not happen
OS_ENTER_CRITICAL(sr);
mp->mp_num_free++;
#if MYNEWT_VAL(MP_BLOCK_REUSED)
if (mp->mp_flags & OS_MEMPOOL_F_REUSED) {
mp->mp_alloc_blocks--;
}
#endif
OS_EXIT_CRITICAL(sr);
}
} else if (block) {
components/bt/porting/mem/os_msys_init.c
+17 -16
View File
@@ -12,7 +12,6 @@
#include "mem_api.h"
#include "bt_osi_mem.h"
#include "esp_err.h"
#include "esp_nimble_mem.h"
#if CONFIG_BT_NIMBLE_ENABLED
#include "syscfg/syscfg.h"
@@ -122,11 +121,13 @@ ble_os_msys_ensure_ctx(void)
return 0;
}
os_msys_ctx = nimble_platform_mem_calloc(1, sizeof(*os_msys_ctx));
os_msys_ctx = bt_osi_mem_malloc(sizeof(*os_msys_ctx));
if(!os_msys_ctx) {
return -1;
}
memset(os_msys_ctx, 0, sizeof(*os_msys_ctx));
return 0;
}
#endif // !CONFIG_BT_LE_MSYS_INIT_IN_CONTROLLER && CONFIG_BT_NIMBLE_STATIC_TO_DYNAMIC
@@ -230,9 +231,9 @@ os_msys_buf_alloc(void)
#if CONFIG_BT_NIMBLE_STATIC_TO_DYNAMIC
#if OS_MSYS_1_BLOCK_COUNT > 0
if (!os_msys_ctx->init_1_data) {
os_msys_ctx->init_1_data = nimble_platform_mem_calloc(1, (sizeof(os_membuf_t) * SYSINIT_MSYS_1_MEMPOOL_SIZE));
os_msys_ctx->init_1_data = bt_osi_mem_malloc((sizeof(os_membuf_t) * SYSINIT_MSYS_1_MEMPOOL_SIZE));
if(!os_msys_ctx->init_1_data){
nimble_platform_mem_free(os_msys_ctx);
bt_osi_mem_free(os_msys_ctx);
os_msys_ctx = NULL;
return ESP_FAIL;
}
@@ -241,13 +242,13 @@ os_msys_buf_alloc(void)
#if OS_MSYS_2_BLOCK_COUNT > 0
if (!os_msys_ctx->init_2_data) {
os_msys_ctx->init_2_data = nimble_platform_mem_calloc(1, (sizeof(os_membuf_t) * SYSINIT_MSYS_2_MEMPOOL_SIZE));
os_msys_ctx->init_2_data = bt_osi_mem_malloc((sizeof(os_membuf_t) * SYSINIT_MSYS_2_MEMPOOL_SIZE));
if(!os_msys_ctx->init_2_data) {
#if OS_MSYS_1_BLOCK_COUNT > 0
nimble_platform_mem_free(os_msys_ctx->init_1_data);
bt_osi_mem_free(os_msys_ctx->init_1_data);
os_msys_ctx->init_1_data = NULL;
#endif
nimble_platform_mem_free(os_msys_ctx);
bt_osi_mem_free(os_msys_ctx);
os_msys_ctx = NULL;
return ESP_FAIL;
}
@@ -256,17 +257,17 @@ os_msys_buf_alloc(void)
#endif
#else
#if OS_MSYS_1_BLOCK_COUNT > 0
os_msys_init_1_data = (os_membuf_t *)nimble_platform_mem_calloc(1, (sizeof(os_membuf_t) * SYSINIT_MSYS_1_MEMPOOL_SIZE));
os_msys_init_1_data = (os_membuf_t *)bt_osi_mem_malloc((sizeof(os_membuf_t) * SYSINIT_MSYS_1_MEMPOOL_SIZE));
if (!os_msys_init_1_data) {
return ESP_ERR_NO_MEM;
}
#endif
#if OS_MSYS_2_BLOCK_COUNT > 0
os_msys_init_2_data = (os_membuf_t *)nimble_platform_mem_calloc(1, (sizeof(os_membuf_t) * SYSINIT_MSYS_2_MEMPOOL_SIZE));
os_msys_init_2_data = (os_membuf_t *)bt_osi_mem_malloc((sizeof(os_membuf_t) * SYSINIT_MSYS_2_MEMPOOL_SIZE));
if (!os_msys_init_2_data) {
#if OS_MSYS_1_BLOCK_COUNT > 0
nimble_platform_mem_free(os_msys_init_1_data);
bt_osi_mem_free(os_msys_init_1_data);
os_msys_init_1_data = NULL;
#endif
return ESP_ERR_NO_MEM;
@@ -284,34 +285,34 @@ os_msys_buf_free(void)
if (os_msys_ctx) {
#if OS_MSYS_1_BLOCK_COUNT > 0
if (os_msys_ctx->init_1_data) {
nimble_platform_mem_free(os_msys_ctx->init_1_data);
bt_osi_mem_free(os_msys_ctx->init_1_data);
os_msys_ctx->init_1_data = NULL;
}
os_mempool_unregister(&os_msys_ctx->init_1_mempool);
#endif
#if OS_MSYS_2_BLOCK_COUNT > 0
if (os_msys_ctx->init_2_data) {
nimble_platform_mem_free(os_msys_ctx->init_2_data);
bt_osi_mem_free(os_msys_ctx->init_2_data);
os_msys_ctx->init_2_data = NULL;
}
os_mempool_unregister(&os_msys_ctx->init_2_mempool);
#endif
nimble_platform_mem_free(os_msys_ctx);
bt_osi_mem_free(os_msys_ctx);
os_msys_ctx = NULL;
}
#else
#if OS_MSYS_1_BLOCK_COUNT > 0
nimble_platform_mem_free(os_msys_init_1_data);
bt_osi_mem_free(os_msys_init_1_data);
os_msys_init_1_data = NULL;
os_mempool_unregister(&os_msys_init_1_mempool);
#endif
#if OS_MSYS_2_BLOCK_COUNT > 0
nimble_platform_mem_free(os_msys_init_2_data);
bt_osi_mem_free(os_msys_init_2_data);
os_msys_init_2_data = NULL;
os_mempool_unregister(&os_msys_init_1_mempool);
os_mempool_unregister(&os_msys_init_2_mempool);
#endif
#endif // CONFIG_BT_NIMBLE_STATIC_TO_DYNAMIC
}