PowLu/TencentOS-tiny
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add support for dynamic mmblk pool

Browse Source
This commit is contained in:
mculover666
2021-03-12 19:30:39 +08:00
parent 5703f01eb6
commit ef489bf51f
5 changed files with 160 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
kernel/core/include/tos_kerr.h
View File

@@ -50,6 +50,8 @@ typedef enum k_err_en {
K_ERR_MMBLK_POOL_EMPTY,
K_ERR_MMBLK_INVALID_BLK_SIZE,
K_ERR_MMBLK_INVALID_POOL_ADDR,
K_ERR_MMBLK_POOL_OUT_OF_MEMORY,
K_ERR_MMBLK_OUT_OF_MEMORY,
K_ERR_MMHEAP_INVALID_POOL_ADDR = 800u,
K_ERR_MMHEAP_INVALID_POOL_SIZE,

31
kernel/core/include/tos_mmblk.h
View File

@@ -67,6 +67,37 @@ __API__ k_err_t tos_mmblk_pool_create(k_mmblk_pool_t *mbp, void *pool_start, siz
*/
__API__ k_err_t tos_mmblk_pool_destroy(k_mmblk_pool_t *mbp);
/**
* @brief Create a dynamic memory manage block pool.
* Create a dynamic memory manage block pool.
*
* @attention None
*
* @param[in] mbp pointer to the pointer of memory block pool handler.
* @param[in] blk_num number of the blocks in the pool.
* @param[in] blk_size size of each block in the pool.
*
* @return errcode
* @retval #K_ERR_MMBLK_INVALID_POOL_ADDR start address of the pool is invalid.
* @retval #K_ERR_MMBLK_INVALID_BLK_SIZE size of the block is invalid.
* @retval #K_ERR_NONE return successfully.
*/
__API__ k_err_t tos_mmblk_pool_create_dyn(k_mmblk_pool_t **mbp, size_t blk_num, size_t blk_size);
/**
* @brief Destroy a dynamic memory manage block pool.
* Destroy a memory dynamic manage block pool.
*
* @attention None
*
* @param[in] mbp pointer to the memory block pool handler.
*
* @return errcode
* @retval #K_ERR_OBJ_INVALID mbp is not a valid memory block pool handler.
* @retval #K_ERR_NONE return successfully.
*/
__API__ k_err_t tos_mmblk_pool_destroy_dyn(k_mmblk_pool_t *mbp);
/**
* @brief Allocate a memory manage block.
* Allocate a memory manage block.

85
kernel/core/tos_mmblk.c
View File

@@ -51,6 +51,8 @@ __API__ k_err_t tos_mmblk_pool_create(k_mmblk_pool_t *mbp, void *pool_start, siz
TOS_OBJ_INIT(mbp, KNL_OBJ_TYPE_MMBLK_POOL);
knl_object_alloc_set_static(&mbp->knl_obj);
return K_ERR_NONE;
}
@@ -59,6 +61,12 @@ __API__ k_err_t tos_mmblk_pool_destroy(k_mmblk_pool_t *mbp)
TOS_PTR_SANITY_CHECK(mbp);
TOS_OBJ_VERIFY(mbp, KNL_OBJ_TYPE_MMBLK_POOL);
#if TOS_CFG_MMHEAP_EN > 0u
if (!knl_object_alloc_is_static(&mbp->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
#endif
mbp->pool_start = K_NULL;
mbp->free_list = K_NULL;
mbp->blk_free = 0;
@@ -70,6 +78,83 @@ __API__ k_err_t tos_mmblk_pool_destroy(k_mmblk_pool_t *mbp)
return K_ERR_NONE;
}
#if TOS_CFG_MMHEAP_EN > 0u
__API__ k_err_t tos_mmblk_pool_create_dyn(k_mmblk_pool_t **mbp, size_t blk_num, size_t blk_size)
{
uint32_t i;
void *pool_start;
k_mmblk_pool_t *the_mbp;
void *blk_curr, *blk_next;
TOS_IN_IRQ_CHECK();
TOS_PTR_SANITY_CHECK(mbp);
if ((blk_size & K_MMBLK_ALIGN_MASK) != 0u) {
return K_ERR_MMBLK_INVALID_BLK_SIZE;
}
the_mbp = tos_mmheap_calloc(1, sizeof(k_mmblk_pool_t));
if (!the_mbp) {
return K_ERR_MMBLK_OUT_OF_MEMORY;
}
pool_start = tos_mmheap_alloc(blk_num * blk_size);
if (!pool_start) {
return K_ERR_MMBLK_POOL_OUT_OF_MEMORY;
}
blk_curr = pool_start;
blk_next = K_MMBLK_NEXT_BLK(blk_curr, blk_size);
for (i = 0; i < blk_num - 1u; ++i) {
*(void **)blk_curr = blk_next;
blk_curr = blk_next;
blk_next = K_MMBLK_NEXT_BLK(blk_next, blk_size);
}
*(void **)blk_curr = K_NULL;
the_mbp->pool_start = pool_start;
the_mbp->free_list = pool_start;
the_mbp->blk_free = blk_num;
the_mbp->blk_max = blk_num;
the_mbp->blk_size = blk_size;
TOS_OBJ_INIT(the_mbp, KNL_OBJ_TYPE_MMBLK_POOL);
knl_object_alloc_set_dynamic(&the_mbp->knl_obj);
*mbp = the_mbp;
return K_ERR_NONE;
}
__API__ k_err_t tos_mmblk_pool_destroy_dyn(k_mmblk_pool_t *mbp)
{
TOS_PTR_SANITY_CHECK(mbp);
TOS_OBJ_VERIFY(mbp, KNL_OBJ_TYPE_MMBLK_POOL);
if (!knl_object_alloc_is_dynamic(&mbp->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
tos_mmheap_free(mbp->pool_start);
mbp->pool_start = K_NULL;
mbp->free_list = K_NULL;
mbp->blk_free = 0;
mbp->blk_max = 0;
mbp->blk_size = 0;
TOS_OBJ_DEINIT(mbp);
tos_mmheap_free(mbp);
return K_ERR_NONE;
}
#endif
__API__ k_err_t tos_mmblk_alloc(k_mmblk_pool_t *mbp, void **blk)
{
TOS_CPU_CPSR_ALLOC();

9
osal/cmsis_os/cmsis_os2.c
View File

@@ -728,8 +728,11 @@ osMemoryPoolId_t osMemoryPoolNew(uint32_t block_count,
if (attr->cb_mem) {
err = tos_mmblk_pool_create((k_mmblk_pool_t*)attr->cb_mem, attr->mp_mem,
block_count, block_size);
mpId = err == K_ERR_NONE ? attr->cb_mem : NULL;
mpId = (err == K_ERR_NONE) ? attr->cb_mem : NULL;
}
} else {
err = tos_mmblk_pool_create_dyn(&mpId, block_count, block_size);
mpId = (err == K_ERR_NONE) ? mpId : NULL;
}
return (osMemoryPoolId_t)mpId;
@@ -775,8 +778,12 @@ uint32_t osMemoryPoolGetSpace(osMemoryPoolId_t mp_id) {
osStatus_t osMemoryPoolDelete(osMemoryPoolId_t mp_id) {
k_mmblk_pool_t* mpId = (k_mmblk_pool_t*)mp_id;
if (knl_object_alloc_is_dynamic(&mpId->knl_obj)) {
return errno_knl2cmsis(tos_mmblk_pool_destroy_dyn(mpId));
} else {
return errno_knl2cmsis(tos_mmblk_pool_destroy(mpId));
}
}
/*---------------------------------------------------------------------------*/

32
test/suit_mmblk.c
View File

@@ -9,6 +9,9 @@ SUITE(suit_mmblk);
k_mmblk_pool_t test_mmblk_pool_00;
k_mmblk_pool_t test_mmblk_pool_01;
k_mmblk_pool_t test_mmblk_pool_02;
k_mmblk_pool_t *test_mmblk_pool_dyn_00;
k_mmblk_pool_t *test_mmblk_pool_dyn_01;
k_mmblk_pool_t *test_mmblk_pool_dyn_02;
uint8_t mmblk_pool_buffer_00[MMBLK_BLK_NUM * MMBLK_BLK_SIZE];
uint8_t mmblk_pool_buffer_01[MMBLK_BLK_NUM * MMBLK_BLK_SIZE];
@@ -69,6 +72,34 @@ TEST test_tos_mmblk_pool_destroy(void)
PASS();
}
TEST test_tos_mmblk_pool_create_dyn(void)
{
k_err_t err;
err = tos_mmblk_pool_create_dyn(&test_mmblk_pool_dyn_00, MMBLK_BLK_NUM, MMBLK_BLK_SIZE);
ASSERT_EQ(err, K_ERR_NONE);
err = tos_mmblk_pool_create_dyn(&test_mmblk_pool_dyn_01, MMBLK_BLK_NUM, MMBLK_BLK_SIZE);
ASSERT_EQ(err, K_ERR_NONE);
err = tos_mmblk_pool_create_dyn(&test_mmblk_pool_dyn_02, MMBLK_BLK_NUM, MMBLK_BLK_SIZE);
ASSERT_EQ(err, K_ERR_NONE);
err = tos_mmblk_pool_destroy_dyn(test_mmblk_pool_dyn_00);
ASSERT_EQ(err, K_ERR_NONE);
err = tos_mmblk_pool_destroy_dyn(test_mmblk_pool_dyn_01);
ASSERT_EQ(err, K_ERR_NONE);
err = tos_mmblk_pool_destroy_dyn(test_mmblk_pool_dyn_02);
ASSERT_EQ(err, K_ERR_NONE);
err = tos_mmblk_pool_create_dyn(&test_mmblk_pool_dyn_00, MMBLK_BLK_NUM, MMBLK_BLK_SIZE + 1);
ASSERT_EQ(err, K_ERR_MMBLK_INVALID_BLK_SIZE);
PASS();
}
TEST test_tos_mmblk_alloc(void)
{
int i = 0;
@@ -123,6 +154,7 @@ SUITE(suit_mmblk)
{
RUN_TEST(test_tos_mmblk_pool_create);
RUN_TEST(test_tos_mmblk_pool_destroy);
RUN_TEST(test_tos_mmblk_pool_create_dyn);
RUN_TEST(test_tos_mmblk_alloc);
RUN_TEST(test_tos_mmblk_free);
}