280 lines
8.0 KiB
C
280 lines
8.0 KiB
C
#include "app_config.h"
|
|
#include "system/includes.h"
|
|
|
|
//lbuf 头文件
|
|
#include "lbuf.h"
|
|
|
|
#ifdef USE_LBUF_TEST_DEMO
|
|
//====================================================//
|
|
/* lbuf模块接口测试点:
|
|
1. 各个接口调用读写基本功能;
|
|
2. 碎片回收性能;
|
|
3. 多线程读写测试;
|
|
*/
|
|
//====================================================//
|
|
|
|
#define LBUF_WR_API_TEST_ENABLE 0
|
|
#define LBUF_MULT_TASK_WR_TEST_ENABLE 1
|
|
|
|
#define LBUF_TEST_SIZE 1024
|
|
#define LBUF_MAGIC_DATA 0x5a
|
|
|
|
struct lbuf_test_head {
|
|
u32 len;
|
|
u8 data[0];
|
|
};
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/**@brief lbuf初始化
|
|
@param buf_size: lbuf空间长度
|
|
@return void
|
|
@note
|
|
*/
|
|
/*----------------------------------------------------------------------------*/
|
|
static void *lbuf_ptr = NULL;
|
|
static struct lbuff_head *lib_system_lbuf_test_init(u32 buf_size)
|
|
{
|
|
struct lbuff_head *lbuf_handle = NULL;
|
|
lbuf_ptr = malloc(buf_size);
|
|
|
|
if (lbuf_ptr == NULL) {
|
|
printf("lbuf malloc buf err");
|
|
return NULL;
|
|
}
|
|
|
|
//lbuf初始化:
|
|
lbuf_handle = lbuf_init(lbuf_ptr, buf_size, 4, sizeof(struct lbuf_test_head));
|
|
|
|
return lbuf_handle;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/**@brief lbuf_test释放资源
|
|
@param void
|
|
@return void
|
|
@note
|
|
*/
|
|
/*----------------------------------------------------------------------------*/
|
|
static void lib_system_cbuf_test_close(void)
|
|
{
|
|
if (lbuf_ptr) {
|
|
free(lbuf_ptr);
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/**@brief 查询lbuf状态
|
|
@param lbuf_handle
|
|
@return void
|
|
@note
|
|
*/
|
|
/*----------------------------------------------------------------------------*/
|
|
static void lib_system_lbuf_state(struct lbuff_head *handle)
|
|
{
|
|
struct lbuff_state state;
|
|
if (handle) {
|
|
lbuf_state(handle, &state);
|
|
printf("%s: %x", __func__, (u32)handle);
|
|
printf("avaliable: %d", state.avaliable);
|
|
printf("fragment: %d", state.fragment);
|
|
printf("max_continue_len: %d", state.max_continue_len);
|
|
printf("num: %d", state.num);
|
|
}
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/**@brief lbuf基本读写接口测试
|
|
@param void
|
|
@return void
|
|
@note
|
|
*/
|
|
/*----------------------------------------------------------------------------*/
|
|
static void lib_system_lbuf_write_read_test(void)
|
|
{
|
|
struct lbuff_head *lbuf_handle = lib_system_lbuf_test_init(LBUF_TEST_SIZE);
|
|
const u32 alloc_size_table[] = {56, 65, 80, 100, 133};
|
|
u32 i = 0;
|
|
|
|
u32 buf_num;
|
|
|
|
struct lbuf_test_head *wbuf = NULL;
|
|
struct lbuf_test_head *rbuf = NULL;
|
|
u32 wcount = 0;
|
|
u32 rcount = 0;
|
|
u32 wlen = 0;
|
|
u32 rlen = 0;
|
|
|
|
if (lbuf_handle == NULL) {
|
|
return;
|
|
}
|
|
|
|
if (lbuf_empty(lbuf_handle)) {//查询LBUF内是否有数据帧
|
|
printf("lbuf is empty");
|
|
}
|
|
|
|
printf("lbuf init, total size: %d", lbuf_remain_space(lbuf_handle));
|
|
|
|
//lbuf写入:
|
|
while (1) {
|
|
wlen = alloc_size_table[i++];
|
|
if (lbuf_free_space(lbuf_handle) < wlen) {//查询LBUF空闲数据块是否有足够长度
|
|
break;
|
|
}
|
|
wbuf = (struct lbuf_test_head *)lbuf_alloc(lbuf_handle, wlen); //lbuf内申请一块空间
|
|
memset(&(wbuf->data[0]), LBUF_MAGIC_DATA, wlen);
|
|
wbuf->len = wlen;
|
|
lbuf_push(wbuf, BIT(0));//把数据块推送更新到lbuf的通道0
|
|
wcount += wlen;
|
|
i = i < ARRAY_SIZE(alloc_size_table) ? i : 0;
|
|
}
|
|
buf_num = lbuf_traversal(lbuf_handle);//查询LBUF内一共有多少个数据块还未读取
|
|
printf("total write: %d byte, buf_num = %d block, remain: %d byte", wcount, buf_num, lbuf_remain_space(lbuf_handle));//查询LBUF 总共写入多少字节, 多少块数据帧, 剩余多少字节可写
|
|
|
|
lib_system_lbuf_state(lbuf_handle);//查询LBUF状态信息
|
|
|
|
//lbuf读出和释放:
|
|
while (1) {
|
|
if (lbuf_empty(lbuf_handle)) {//查询LBUF内是否有数据帧
|
|
break;
|
|
}
|
|
rbuf = (struct lbuf_test_head *)lbuf_pop(lbuf_handle, BIT(0));//从lbuf的通道0读取数据块
|
|
rlen = rbuf->len;
|
|
for (i = 0; i < rlen; i++) {
|
|
if ((rbuf->data[i]) != LBUF_MAGIC_DATA) {
|
|
printf("lbuf read err: %d", rbuf->data[i]);
|
|
}
|
|
}
|
|
|
|
rcount += rlen;
|
|
|
|
if (lbuf_free(rbuf) == 0) { //释放lbuf通道0的数据块
|
|
printf("lbuf free fail!!!");
|
|
}
|
|
}
|
|
printf("total read: %d, remain: %d", rcount, lbuf_remain_space(lbuf_handle));
|
|
if (rcount == wcount) {
|
|
printf("lbuf wr pass");
|
|
} else {
|
|
printf("rw data count err!!!");
|
|
}
|
|
|
|
__test_end:
|
|
lib_system_cbuf_test_close();
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
/**@brief lbuf多线程读写测试
|
|
@param void
|
|
@return void
|
|
@note
|
|
*/
|
|
/*----------------------------------------------------------------------------*/
|
|
static OS_SEM sem1;
|
|
static OS_SEM sem2;
|
|
static struct lbuff_head *lbuf_handle_test = NULL;
|
|
static void lib_system_lbuf_task1(void *priv)
|
|
{
|
|
int ret = 0;
|
|
struct lbuf_test_head *wbuf = NULL;
|
|
u32 wlen = 0;
|
|
const u32 alloc_size_table[] = {56, 65, 80, 100, 133};
|
|
u32 i = 0;
|
|
|
|
while (1) {
|
|
putchar('1');
|
|
i = i < ARRAY_SIZE(alloc_size_table) ? i : 0;
|
|
wlen = alloc_size_table[i++];
|
|
wbuf = (struct lbuf_test_head *)lbuf_alloc(lbuf_handle_test, wlen);
|
|
if (wbuf != NULL) {
|
|
memset((u8 *)(&(wbuf->data[0])), LBUF_MAGIC_DATA, wlen);
|
|
wbuf->len = wlen;
|
|
lbuf_push(wbuf, (BIT(0) | BIT(1)));//把数据块推送更新到lbuf的通道0和通道1
|
|
os_sem_post(&sem1);
|
|
os_sem_post(&sem2);
|
|
} else {
|
|
printf("%s no buf", __func__);
|
|
}
|
|
os_time_dly(2);
|
|
}
|
|
}
|
|
|
|
static void lib_system_lbuf_task2(void *priv)
|
|
{
|
|
int ret = 0;
|
|
struct lbuf_test_head *rbuf = NULL;
|
|
|
|
while (1) {
|
|
os_sem_pend(&sem1, 0);
|
|
while (1) {
|
|
rbuf = (struct lbuf_test_head *)lbuf_pop(lbuf_handle_test, BIT(0));//从lbuf的通道0读取数据块
|
|
if (rbuf == NULL) {
|
|
break;
|
|
} else {
|
|
putchar('2');
|
|
for (u32 i = 0; i < rbuf->len; i++) {
|
|
if (rbuf->data[i] != LBUF_MAGIC_DATA) {
|
|
printf("%s read err: %d", __func__, rbuf->data[i]);
|
|
}
|
|
}
|
|
if (lbuf_free(rbuf)) {
|
|
putchar('f');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void lib_system_lbuf_task3(void *priv)
|
|
{
|
|
int ret = 0;
|
|
struct lbuf_test_head *rbuf = NULL;
|
|
|
|
while (1) {
|
|
os_sem_pend(&sem2, 0);
|
|
while (1) {
|
|
rbuf = (struct lbuf_test_head *)lbuf_pop(lbuf_handle_test, BIT(1));//从lbuf的通道1读取数据块
|
|
if (rbuf == NULL) {
|
|
break;
|
|
} else {
|
|
putchar('3');
|
|
for (u32 i = 0; i < rbuf->len; i++) {
|
|
if (rbuf->data[i] != LBUF_MAGIC_DATA) {
|
|
printf("%s read err: %d", __func__, rbuf->data[i]);
|
|
}
|
|
}
|
|
if (lbuf_free(rbuf)) {
|
|
putchar('f');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void lib_system_lbuf_mult_task_wr_api_test(void)
|
|
{
|
|
os_sem_create(&sem1, 0);
|
|
os_sem_create(&sem2, 0);
|
|
lbuf_handle_test = lib_system_lbuf_test_init(LBUF_TEST_SIZE);
|
|
os_task_create(lib_system_lbuf_task1, NULL, 1, 256, 0, "lbuf_1");
|
|
os_task_create(lib_system_lbuf_task2, NULL, 1, 256, 0, "lbuf_2");
|
|
os_task_create(lib_system_lbuf_task3, NULL, 1, 256, 0, "lbuf_3");
|
|
}
|
|
|
|
static int c_main(void)
|
|
{
|
|
#if LBUF_WR_API_TEST_ENABLE
|
|
lib_system_lbuf_write_read_test();
|
|
#endif /* #if LBUF_WR_API_TEST_ENABLE */
|
|
|
|
#if LBUF_MULT_TASK_WR_TEST_ENABLE
|
|
lib_system_lbuf_mult_task_wr_api_test();
|
|
#endif /* #if LBUF_MULT_TASK_WR_TEST_ENABLE */
|
|
|
|
return 0;
|
|
}
|
|
late_initcall(c_main);
|
|
#endif
|