The first releaseHEADmaindev-utdev

4 files changed, 2131 insertions, 0 deletions

diff --git a/bbq/unittest/CMakeLists.txt b/bbq/unittest/CMakeLists.txt
new file mode 100644
index 0000000..fedd026
--- /dev/null
+++ b/bbq/unittest/CMakeLists.txt
@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.0)
+project(BBQ_TESTS)
+
+
+# 指定库路径
+link_directories(${LIB_PATH})
+# 指定头文件
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}/common/
+)
+
+# 链接静态库
+link_libraries(bbq)
+# 指定可执行文件输出路径
+set(EXECUTABLE_OUTPUT_PATH ${EXEC_PATH})
+
+# 搜索当前cmake文件所在目录下的c文件
+file(GLOB SRC_C_LIST "${CMAKE_CURRENT_SOURCE_DIR}/*.c")
+file(GLOB SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/*.cc")
+list(APPEND SRC_LIST ${SRC_C_LIST})
+
+add_executable(bbq_unittest ${SRC_LIST}) # 添加可执行程序
+target_link_libraries(bbq_unittest gtest gtest_main pthread) # 链接gtest库
+
+add_test(bbq_unittest ${EXEC_PATH}/bbq_unittest) # 添加测试，保证make test可以执行该测试用例
diff --git a/bbq/unittest/ut_bbq.cc b/bbq/unittest/ut_bbq.cc
new file mode 100644
index 0000000..d244894
--- /dev/null
+++ b/bbq/unittest/ut_bbq.cc
@@ -0,0 +1,1189 @@
+/*
+ * @Author: liuyu
+ * @LastEditTime: 2024-07-07 21:59:54
+ * @Email: [email protected]
+ * @Describe: 简单的测试用例，测试基本功能
+ */
+
+#include "gtest/gtest.h"
+extern "C" {
+#include "ut_bbq_func.h"
+#include <math.h>
+extern bool bbq_debug_check_array_bounds(struct bbq *q);
+extern void bbq_struct_print(struct bbq *q);
+extern uint32_t bbq_enqueue_burst_elem_2d_array(struct bbq *q, void *const *obj_table, uint32_t n, uint32_t *wait_consumed);
+extern bool bbq_check_power_of_two(int n);
+extern unsigned bbq_ceil_log2(uint64_t x);
+extern uint64_t bbq_fetch_max(union bbq_atomic64 *atomic, uint64_t upd, bool single);
+extern bool ut_malloc_free_equal();
+extern int bbq_bnbs_calc(uint32_t entries, uint32_t *bn, uint32_t *bs);
+extern void bbq_atomic64_store(union bbq_atomic64 *atomic, uint64_t value, bool single);
+extern uint64_t bbq_atomic64_load(union bbq_atomic64 *atomic, bool single);
+extern bool bbq_debug_check_array_bounds(struct bbq *q);
+extern struct bbq *bbq_create_elem_with_bnbs(const char *name, uint32_t bn, uint32_t bs,
+                                             size_t obj_size, int socket_id, uint32_t flags,
+                                             bbq_malloc_f malloc_f, bbq_free_f free_f);
+extern uint64_t bbq_atomic64_load(union bbq_atomic64 *atomic, bool single);
+}
+
+#define BUF_CNT 4096
+
+class ut_bbq : public testing::Test {
+  protected:
+    virtual void SetUp() override {
+        // 1.清空内存malloc/free统计
+        ut_memory_counter_clear();
+
+        // 2.入队空间初始化
+        UT_DOUBLE_PTR_DATA_INIT(enq_table1, uint16_t, BUF_CNT);
+        UT_PTR_ARRAY_DATA_INIT(enq_table2, uint16_t, BUF_CNT);
+        UT_ARRAY_DATA_INIT(enq_table3, BUF_CNT);
+    }
+
+    virtual void TearDown() override {
+        // 1.释放测试数据
+        UT_DOUBLE_PTR_DATA_DESTORY(enq_table1, BUF_CNT);
+        UT_PTR_ARRAY_DATA_DESTORY(enq_table2, BUF_CNT);
+
+        // 2.内存泄漏检测
+        EXPECT_TRUE(ut_malloc_free_equal());
+    }
+
+    // 入队数据
+    uint16_t **enq_table1;
+    uint16_t *enq_table2[BUF_CNT];
+    uint16_t enq_table3[BUF_CNT];
+};
+
+TEST_F(ut_bbq, single_retry_new_cp_ptr) {
+    int ret = 0;
+    uint64_t cnt = 0;
+    uint16_t *deq_data = NULL;
+
+    // 创建队列
+    struct bbq *q = bbq_create("ut_bbq", BUF_CNT, BBQ_SOCKET_ID_ANY,
+                               BBQ_F_RETRY_NEW, ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+
+    // 空队出队失败
+    EXPECT_EQ(bbq_dequeue(q, (void **)&deq_data), BBQ_ERR_EMPTY);
+
+    // 全部入队成功
+    for (uint32_t i = 0; i < 4000; i++) {
+        if (bbq_enqueue(q, (void **)&enq_table1[i]) == 0) {
+            cnt++;
+        }
+    }
+
+    // 部分入队成功
+    for (uint32_t i = 0; i < 4000; i++) {
+        if (bbq_enqueue(q, (void **)&enq_table2[i]) == 0) {
+            cnt++;
+        }
+    }
+
+    // 入队成功个数等于队列总数
+    EXPECT_EQ(cnt, BUF_CNT);
+
+    cnt = 0;
+    for (uint32_t i = 0; i < BUF_CNT; i++) {
+        ret = bbq_dequeue(q, (void **)&deq_data);
+        if (ret == 0) {
+            EXPECT_EQ(*deq_data, UT_DATA_MAGIC);
+            cnt++;
+        }
+    }
+    // 全部出队成功
+    EXPECT_EQ(cnt, BUF_CNT);
+
+    // 空队出队失败
+    EXPECT_EQ(bbq_dequeue(q, (void **)&deq_data), BBQ_ERR_EMPTY);
+    bbq_destory(q);
+}
+
+TEST_F(ut_bbq, single_retry_new_cp_value) {
+    int ret = 0;
+    uint64_t cnt = 0;
+    uint16_t deq_data;
+
+    // 创建队列
+    struct bbq *q = bbq_create_elem("ut_bbq", BUF_CNT, sizeof(uint16_t),
+                                    BBQ_SOCKET_ID_ANY, BBQ_F_RETRY_NEW,
+                                    ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+
+    // 空队出队失败
+    EXPECT_EQ(bbq_dequeue(q, (void **)&deq_data), BBQ_ERR_EMPTY);
+
+    // 全部入队成功
+    for (uint32_t i = 0; i < 4000; i++) {
+        if (bbq_enqueue(q, (void **)enq_table1[i]) == 0) {
+            cnt++;
+        }
+    }
+
+    // 部分入队成功
+    for (uint32_t i = 0; i < 4000; i++) {
+        if (bbq_enqueue_elem(q, enq_table2[i]) == 0) {
+            cnt++;
+        }
+    }
+
+    // 入队成功个数等于队列总数
+    EXPECT_EQ(cnt, BUF_CNT);
+
+    cnt = 0;
+    for (uint32_t i = 0; i < BUF_CNT; i++) {
+        ret = bbq_dequeue_elem(q, &deq_data);
+        if (ret == 0) {
+            EXPECT_EQ(deq_data, UT_DATA_MAGIC);
+            cnt++;
+        }
+    }
+    // 全部出队成功
+    EXPECT_EQ(cnt, BUF_CNT);
+
+    // 空队出队失败
+    EXPECT_EQ(bbq_dequeue_elem(q, &deq_data), BBQ_ERR_EMPTY);
+    bbq_destory(q);
+}
+
+TEST_F(ut_bbq, single_drop_old_cp_pointer) {
+    int ret = 0;
+    uint64_t cnt = 0;
+    uint16_t *deq_data = NULL;
+    uint64_t first_cnt = BUF_CNT;
+    uint64_t second_cnt = 1000;
+
+    // 创建队列
+    struct bbq *q = bbq_create("ut_bbq", BUF_CNT, BBQ_SOCKET_ID_ANY,
+                               BBQ_F_DROP_OLD, ut_malloc_def_callback,
+                               ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+    EXPECT_LT(second_cnt, q->bs * q->bn);
+
+    // 空队出队失败
+    EXPECT_EQ(bbq_dequeue(q, (void **)&deq_data), BBQ_ERR_EMPTY);
+
+    // 全部入队成功，入队个数是BUF_CNT的整数倍，因此到了一个边界，刚好与消费者位置一致（套了loop圈）
+    uint32_t loop = 3;
+    for (uint32_t n = 0; n < loop; n++) {
+        for (uint32_t i = 0; i < first_cnt; i++) {
+            ret = bbq_enqueue(q, (void **)&enq_table1[i]);
+            if (ret == 0) {
+                cnt++;
+            }
+        }
+    }
+    EXPECT_EQ(cnt, first_cnt * loop);
+
+    // 全部入队成功
+    cnt = 0;
+    for (uint32_t i = 0; i < second_cnt; i++) {
+        if (bbq_enqueue(q, (void **)&enq_table2[i]) == 0) {
+            cnt++;
+        }
+    }
+    EXPECT_EQ(cnt, second_cnt);
+
+    cnt = 0;
+    for (uint32_t i = 0; i < BUF_CNT; i++) {
+        ret = bbq_dequeue(q, (void **)&deq_data);
+        if (ret == 0) {
+            EXPECT_EQ(*deq_data, UT_DATA_MAGIC);
+            cnt++;
+        }
+    }
+
+    // 一旦生产者追上了消费者，之前未消费的，以及当前块的数据全都作废了。
+    EXPECT_EQ(cnt, second_cnt - q->bs);
+
+    // 空队出队失败
+    EXPECT_EQ(bbq_dequeue(q, (void **)&deq_data), BBQ_ERR_EMPTY);
+
+    bbq_destory(q);
+}
+
+TEST_F(ut_bbq, single_drop_old_cp_value) {
+    int ret = 0;
+    uint64_t cnt = 0;
+    uint16_t deq_data;
+    uint64_t first_cnt = BUF_CNT;
+    uint64_t second_cnt = 1000;
+
+    // 创建队列
+    struct bbq *q = bbq_create_elem("ut_bbq", BUF_CNT, sizeof(uint16_t),
+                                    BBQ_SOCKET_ID_ANY, BBQ_F_DROP_OLD,
+                                    ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+    EXPECT_LT(second_cnt, q->bs * q->bn);
+
+    // 空队出队失败
+    EXPECT_EQ(bbq_dequeue_elem(q, &deq_data), BBQ_ERR_EMPTY);
+
+    // 全部入队成功，入队个数是BUF_CNT的整数倍，因此到了一个边界，刚好与消费者位置一致（套了loop圈）
+    uint32_t loop = 3;
+    for (uint32_t n = 0; n < loop; n++) {
+        for (uint32_t i = 0; i < first_cnt; i++) {
+            ret = bbq_enqueue_elem(q, enq_table1[i]);
+            if (ret == 0) {
+                cnt++;
+            }
+        }
+    }
+    EXPECT_EQ(cnt, first_cnt * loop);
+
+    // 全部入队成功
+    cnt = 0;
+    for (uint32_t i = 0; i < second_cnt; i++) {
+        if (bbq_enqueue_elem(q, enq_table2[i]) == 0) {
+            cnt++;
+        }
+    }
+    EXPECT_EQ(cnt, second_cnt);
+
+    cnt = 0;
+    for (uint32_t i = 0; i < BUF_CNT; i++) {
+        ret = bbq_dequeue_elem(q, &deq_data);
+        if (ret == 0) {
+            EXPECT_EQ(deq_data, UT_DATA_MAGIC);
+            cnt++;
+        }
+    }
+
+    // 一旦生产者追上了消费者，之前未消费的，以及当前块的数据全都作废了。
+    EXPECT_EQ(cnt, second_cnt - q->bs);
+    // 空队出队失败
+    EXPECT_EQ(bbq_dequeue_elem(q, &deq_data), BBQ_ERR_EMPTY);
+
+    bbq_destory(q);
+}
+
+TEST_F(ut_bbq, burst_retry_new_cp_value) {
+    struct bbq *q;
+    uint32_t ret1 = 0;
+    uint32_t ret2 = 0;
+    uint64_t first_cnt = 4000;
+    uint64_t second_cnt = 1000;
+    uint16_t deq_table1[BUF_CNT] = {0};
+    uint16_t *deq_table2 = (uint16_t *)ut_malloc(UT_MODULE_DATA, sizeof(uint16_t) * BUF_CNT);
+    uint32_t wait_consumed = 0;
+
+    // 创建队列
+    q = bbq_create_elem("ut_bbq", BUF_CNT, sizeof(uint16_t),
+                        BBQ_SOCKET_ID_ANY, BBQ_F_RETRY_NEW | BBQ_F_ENABLE_STAT,
+                        ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+    EXPECT_LT(first_cnt, q->bn * q->bs);
+
+    // 批量入队(全部成功)
+    ret1 = bbq_enqueue_burst_elem(q, (void const *)enq_table3, first_cnt, &wait_consumed);
+    EXPECT_EQ(ret1, first_cnt);
+    EXPECT_EQ(wait_consumed, ret1);
+
+    // 批量入队(部分成功)
+    // 由于需要将最终的值入队列，二维数组里的值不连续，需要循环赋值。不推荐这个函数，但可用于特殊场景。
+    ret2 = bbq_enqueue_burst_elem_2d_array(q, (void *const *)enq_table2, second_cnt, &wait_consumed);
+    EXPECT_EQ(ret2, BUF_CNT - ret1);
+    EXPECT_EQ(wait_consumed, ret1 + ret2);
+
+    // 出队列（全部成功）
+    ret1 = bbq_dequeue_burst_elem(q, (void *)deq_table1, first_cnt, &wait_consumed);
+    EXPECT_EQ(ret1, first_cnt);
+    EXPECT_EQ(wait_consumed, ret2);
+
+    // 出队列（部分成功）
+    ret2 = bbq_dequeue_burst_elem(q, (void *)deq_table2, second_cnt, &wait_consumed);
+    EXPECT_EQ(ret2, BUF_CNT - ret1);
+    EXPECT_EQ(wait_consumed, 0);
+
+    // 验证数据
+    for (uint32_t i = 0; i < ret1; i++) {
+        EXPECT_EQ(deq_table1[i], UT_DATA_MAGIC) << "i :" << i;
+    }
+
+    for (uint32_t i = 0; i < ret2; i++) {
+        EXPECT_EQ(deq_table2[i], UT_DATA_MAGIC) << "i :" << i;
+    }
+
+    EXPECT_TRUE(bbq_debug_check_array_bounds(q));
+    ut_free(UT_MODULE_DATA, deq_table2);
+    bbq_destory(q);
+}
+
+TEST_F(ut_bbq, burst_retry_new_cp_pointer) {
+    struct bbq *q;
+    uint32_t ret1 = 0;
+    uint32_t ret2 = 0;
+    uint64_t first_cnt = 4000;
+    uint64_t second_cnt = 1000;
+    uint32_t wait_consumed = 0;
+    uint16_t *deq_table1[BUF_CNT] = {0};
+    uint16_t **deq_table2 = (uint16_t **)ut_malloc(UT_MODULE_DATA, sizeof(uint16_t *) * BUF_CNT);
+
+    // 创建队列
+    q = bbq_create("ut_bbq", BUF_CNT, BBQ_SOCKET_ID_ANY,
+                   BBQ_F_RETRY_NEW | BBQ_F_ENABLE_STAT,
+                   ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+    EXPECT_LT(first_cnt, q->bn * q->bs);
+
+    // 批量入队(全部成功)
+    ret1 = bbq_enqueue_burst(q, (void *const *)enq_table1, first_cnt, &wait_consumed);
+    EXPECT_EQ(ret1, first_cnt);
+    EXPECT_EQ(wait_consumed, ret1);
+
+    // 批量入队(部分成功)
+    ret2 = bbq_enqueue_burst(q, (void *const *)enq_table2, second_cnt, &wait_consumed);
+    EXPECT_EQ(ret2, BUF_CNT - ret1);
+    EXPECT_EQ(wait_consumed, ret1 + ret2);
+
+    // 出队列（全部成功）
+    ret1 = bbq_dequeue_burst(q, (void **)deq_table1, first_cnt, &wait_consumed);
+    EXPECT_EQ(ret1, first_cnt);
+    EXPECT_EQ(wait_consumed, ret2);
+
+    // 出队列（部分成功）
+    ret2 = bbq_dequeue_burst(q, (void **)deq_table2, second_cnt, &wait_consumed);
+    EXPECT_EQ(ret2, BUF_CNT - ret1);
+    EXPECT_EQ(wait_consumed, 0);
+
+    // 验证数据
+    for (uint32_t i = 0; i < ret1; i++) {
+        EXPECT_EQ(*deq_table1[i], UT_DATA_MAGIC) << "i :" << i;
+    }
+
+    for (uint32_t i = 0; i < ret2; i++) {
+        EXPECT_EQ(*deq_table2[i], UT_DATA_MAGIC) << "i :" << i;
+    }
+
+    EXPECT_TRUE(bbq_debug_check_array_bounds(q));
+    ut_free(UT_MODULE_DATA, deq_table2);
+    bbq_destory(q);
+}
+
+TEST_F(ut_bbq, burst_drop_old_cp_pointer) {
+    struct bbq *q;
+    uint32_t ret1 = 0;
+    uint32_t ret2 = 0;
+    uint64_t first_cnt = BUF_CNT;
+    uint64_t second_cnt = 1000;
+    uint32_t wait_consumed = 0;
+    uint16_t *deq_table1[BUF_CNT] = {0};
+    uint16_t **deq_table2 = (uint16_t **)ut_malloc(UT_MODULE_DATA, sizeof(uint16_t *) * BUF_CNT);
+
+    // 创建队列
+    q = bbq_create("ut_bbq", BUF_CNT, BBQ_SOCKET_ID_ANY, BBQ_F_DROP_OLD,
+                   ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+    EXPECT_GT(second_cnt, q->bs);
+    EXPECT_LT(second_cnt, q->bs * q->bn);
+
+    // 批量入队(全部成功，入队个数等于队列总容量，未发生覆盖)
+    ret1 = bbq_enqueue_burst(q, (void *const *)enq_table1, first_cnt, &wait_consumed);
+    EXPECT_EQ(ret1, first_cnt);
+    // EXPECT_EQ(wait_consumed, ret1);
+
+    // 批量入队(全部成功)，覆盖了旧数据
+    ret2 = bbq_enqueue_burst(q, (void *const *)enq_table2, second_cnt, &wait_consumed);
+    EXPECT_EQ(ret2, second_cnt);
+    // EXPECT_EQ(wait_consumed, second_cnt - q->bs);
+
+    // 出队列（部分成功）
+    // 一旦生产者追上了消费者，之前未消费的，以及当前块的数据全都作废了。本例中第一个完整块作废。
+    ret1 = bbq_dequeue_burst(q, (void **)deq_table1, BUF_CNT, &wait_consumed);
+    EXPECT_EQ(ret1, second_cnt - q->bs);
+    // EXPECT_EQ(wait_consumed, 0);
+
+    // 验证数据
+    for (uint32_t i = 0; i < ret1; i++) {
+        EXPECT_EQ(*deq_table1[i], UT_DATA_MAGIC) << "i :" << i;
+    }
+
+    // 此时生产者和消费者在同一块上，入队个数为队列容量的N倍，由于发生了覆盖，且依旧在同一块上，数据全作废
+    for (uint32_t loop = 0; loop < 3; loop++) {
+        ret1 = bbq_enqueue_burst(q, (void *const *)enq_table1, BUF_CNT, &wait_consumed);
+        EXPECT_EQ(ret1, BUF_CNT);
+        EXPECT_TRUE(bbq_empty(q));
+        EXPECT_EQ(wait_consumed, 0);
+    }
+
+    EXPECT_TRUE(bbq_debug_check_array_bounds(q));
+    ut_free(UT_MODULE_DATA, deq_table2);
+    bbq_destory(q);
+}
+
+TEST_F(ut_bbq, burst_drop_old_cp_value) {
+    struct bbq *q;
+    uint32_t ret1 = 0;
+    uint32_t ret2 = 0;
+    uint64_t first_cnt = BUF_CNT;
+    uint64_t second_cnt = 1000;
+    uint32_t wait_consumed = 0;
+    uint16_t deq_table1[BUF_CNT] = {0};
+
+    // 创建队列
+    q = bbq_create_elem("ut_bbq", BUF_CNT, sizeof(uint16_t),
+                        BBQ_SOCKET_ID_ANY, BBQ_F_DROP_OLD,
+                        ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+    EXPECT_GT(second_cnt, q->bs);
+    EXPECT_LT(second_cnt, q->bs * q->bn);
+
+    // 批量入队(全部成功)
+    ret1 = bbq_enqueue_burst_elem(q, (void const *)enq_table3, first_cnt, &wait_consumed);
+    EXPECT_EQ(ret1, first_cnt);
+    // EXPECT_EQ(wait_consumed, ret1);
+
+    // 批量入队(全部成功)，覆盖了旧数据
+    // 由于需要将最终的值入队列，二维数组里的值不连续，需要循环赋值。不推荐这个函数，但可用于特殊场景。
+    ret2 = bbq_enqueue_burst_elem_2d_array(q, (void *const *)enq_table1, second_cnt, &wait_consumed);
+    EXPECT_EQ(ret2, second_cnt);
+    // EXPECT_EQ(wait_consumed, second_cnt - q->bs);
+
+    // 出队列（部分成功）
+    // 一旦生产者追上了消费者，之前未消费的，以及当前块的数据全都作废了。
+    ret1 = bbq_dequeue_burst_elem(q, (void *)deq_table1, BUF_CNT, &wait_consumed);
+    EXPECT_EQ(ret1, second_cnt - q->bs);
+    EXPECT_EQ(wait_consumed, 0);
+
+    // 验证数据
+    for (uint32_t i = 0; i < ret1; i++) {
+        EXPECT_EQ(deq_table1[i], UT_DATA_MAGIC) << "i :" << i;
+    }
+
+    EXPECT_TRUE(bbq_debug_check_array_bounds(q));
+    bbq_destory(q);
+}
+
+typedef struct {
+    uint64_t thread_cnt;
+    bbq_atomic64 data;
+    aotmic_uint64 ready_thread_cnt;
+} ut_fetch_arg;
+
+void *fetch_max_thread_func(void *arg) {
+    ut_fetch_arg *fetch_arg = (ut_fetch_arg *)arg;
+    fetch_arg->ready_thread_cnt.fetch_add(1);
+
+    while (fetch_arg->ready_thread_cnt.load() != fetch_arg->thread_cnt) {
+    }
+
+    uint64_t *ret = (uint64_t *)ut_malloc(UT_MODULE_UTEST, sizeof(*ret));
+    // 不同线程写入不同的>3的数
+    *ret = bbq_fetch_max(&fetch_arg->data, pthread_self() + 3, false);
+    pthread_exit(ret);
+}
+
+TEST_F(ut_bbq, mpmc) {
+    struct ut_info_s info {
+        .cfg = {
+            .base = {
+                .name = {},
+                .introduce = {},
+                .core_begin = 0,
+                .core_end = 3,
+            },
+            .ring = {
+                .ring_type = UT_RING_TYPE_BBQ,
+                .producer_cnt = 4,
+                .consumer_cnt = 4,
+                .workload = UT_WORKLOAD_SIMPLE,
+                .entries_cnt = 4096,
+                .block_count = 0,
+                .burst_cnt = 4,
+            },
+            .run = {
+                .run_ok_times = 9000000,
+                .run_time = 0,
+            },
+        },
+        .ctl = {
+            .running = true,
+            .all_threads_start = {},
+            .producer_exit = {},
+        },
+    };
+
+    // 队列初始化
+    int ret = -1;
+    struct ut_queue q;
+    ret = ut_queue_init_bbq(&info.cfg, &q);
+    ASSERT_TRUE(ret == 0);
+
+    // 创建线程
+    pthread_t *threads = ut_threads_create(&info, &q);
+    ASSERT_TRUE(threads);
+
+    // 等待所有线程完成，回收数据
+    uint32_t thread_cnt = info.cfg.ring.producer_cnt + info.cfg.ring.consumer_cnt;
+    struct ut_exit_data **exit_data = (struct ut_exit_data **)ut_malloc(UT_MODULE_UTEST, sizeof(struct ut_exit_data **) * (thread_cnt));
+    ut_wait_all_threads_exit(&info, thread_cnt, threads, exit_data);
+
+    // 比较数据
+    struct ut_merge_s merge;
+    memset(&merge, 0, sizeof(merge));
+    ut_merge_all_data(exit_data, thread_cnt, &merge);
+    EXPECT_EQ(merge.consumer.data_error_cnt, 0);
+    EXPECT_EQ(merge.consumer.ok_cnt, merge.producer.ok_cnt);
+
+    // 释放数据
+    for (uint32_t i = 0; i < thread_cnt; i++) {
+        ut_exit_data_destory(exit_data[i]);
+    }
+    ut_free(UT_MODULE_UTEST, exit_data);
+    ut_threads_destory(&info, threads);
+    EXPECT_TRUE(bbq_debug_check_array_bounds((struct bbq *)q.ring));
+    ut_queue_destory(&q);
+}
+
+TEST_F(ut_bbq, bbq_fetch_max) {
+    uint64_t ret = 0;
+    ut_fetch_arg arg;
+
+    bool single = false;
+    arg.data.m.store(0);
+    arg.thread_cnt = 0;
+    arg.ready_thread_cnt.store(0);
+
+    bbq_atomic64_store(&arg.data, 1, single); // 初始化1
+    arg.thread_cnt = 50;
+
+    ret = bbq_fetch_max(&arg.data, 2, single); // max比较后设置为2
+    EXPECT_EQ(bbq_atomic64_load(&arg.data, single), 2);
+    EXPECT_EQ(ret, 1);
+
+    pthread_t *threads = (pthread_t *)ut_malloc(UT_MODULE_UTEST, sizeof(*threads) * arg.thread_cnt);
+    for (uint64_t i = 0; i < arg.thread_cnt; i++) {
+        // 多个线程同时fetch_max，输入 > 3的数据
+        pthread_create(&threads[i], NULL, fetch_max_thread_func, (void *)&arg);
+    }
+
+    int eq_cnt = 0;
+    for (uint64_t i = 0; i < arg.thread_cnt; i++) {
+        uint64_t *tret;
+        pthread_join(threads[i], (void **)&tret); // 等待每个线程结束
+        if (*tret == 2) {
+            eq_cnt++; // 统计返回2的个数
+        }
+        ut_free(UT_MODULE_UTEST, tret);
+    }
+
+    // EXPECT_EQ(eq_cnt, 1);
+    ut_free(UT_MODULE_UTEST, threads);
+}
+
+TEST_F(ut_bbq, power_of_two) {
+    uint32_t tmp = 0;
+    uint32_t max = pow(2, 32) - 1;
+
+    EXPECT_FALSE(bbq_check_power_of_two(0));
+
+    tmp = 3;
+    for (uint32_t val = 5; val < max; val *= tmp) {
+        EXPECT_FALSE(bbq_check_power_of_two(val));
+        if (val >= max / tmp) {
+            break; // 即将越界
+        }
+    }
+
+    tmp = 2;
+    for (uint32_t val = 1; val < max; val *= tmp) {
+        EXPECT_TRUE(bbq_check_power_of_two(val));
+        if (val >= max / tmp) {
+            break;
+        }
+    }
+}
+
+TEST_F(ut_bbq, bbq_block_number_calc) {
+    uint32_t tmp = 2;
+    uint32_t max = pow(2, 32) - 1;
+    uint32_t bn = 0, bs = 0;
+    int ret = 0;
+
+    ret = bbq_bnbs_calc(1, &bn, &bs);
+    EXPECT_EQ(ret, BBQ_ERR_OUT_OF_RANGE);
+
+    for (uint32_t val = 2; val < max; val *= tmp) {
+        ret = bbq_bnbs_calc(val, &bn, &bs);
+        EXPECT_EQ(ret, BBQ_OK);
+        if (val <= 128) {
+            EXPECT_EQ(bn, 2);
+        } else if (val <= 2048) {
+            EXPECT_EQ(bn, 4);
+        } else if (val <= 32768) {
+            EXPECT_EQ(bn, 8);
+        } else if (val <= 524288) {
+            EXPECT_EQ(bn, 16);
+        } else if (val <= 8388608) {
+            EXPECT_EQ(bn, 32);
+        } else if (val <= 134217728) {
+            EXPECT_EQ(bn, 64);
+        } else if (val <= 2147483648) {
+            EXPECT_EQ(bn, 128);
+        } else {
+            EXPECT_TRUE(0); // 异常
+        }
+
+        if (val >= max / tmp) {
+            break;
+        }
+    }
+}
+
+#define OFFSETOF(type, member) ((size_t) & ((type *)0)->member)
+#define PRINT_OFFSETOF(type, member) printf("Offset of '%s' in '%s' is %zu\n", #member, #type, OFFSETOF(type, member))
+#define PTR_ALIGNED_64(ptr) (((uintptr_t)ptr & (64 - 1)) == 0)
+#define SIZE_ALIGNED_64(v) (((sizeof(v)) & (64 - 1)) == 0)
+
+TEST_F(ut_bbq, bbq_cache_line) {
+
+    // 创建队列
+    struct bbq *q = bbq_create("ut_bbq", 4096, BBQ_SOCKET_ID_ANY, BBQ_F_RETRY_NEW,
+                               ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+
+    // 首地址64字节对齐
+    EXPECT_EQ(PTR_ALIGNED_64(q), true);
+
+    // 关键成员64字节对齐
+    EXPECT_EQ(PTR_ALIGNED_64(&q->name), true);
+    EXPECT_EQ(PTR_ALIGNED_64(&q->socket_id), true);
+    EXPECT_EQ(PTR_ALIGNED_64(&q->phead.value), true);
+    EXPECT_EQ(PTR_ALIGNED_64(&q->chead.value), true);
+    EXPECT_EQ(PTR_ALIGNED_64(&q->blocks), true);
+    EXPECT_EQ(PTR_ALIGNED_64(&q->blocks[0].committed), true);
+    EXPECT_EQ(PTR_ALIGNED_64(&q->blocks[0].entries), true);
+
+    EXPECT_EQ(SIZE_ALIGNED_64(struct bbq_head), true);
+    EXPECT_EQ(SIZE_ALIGNED_64(struct bbq_block), true);
+
+    // PRINT_OFFSETOF(struct bbq, name);
+    // PRINT_OFFSETOF(struct bbq, socket_id);
+    // PRINT_OFFSETOF(struct bbq, phead);
+    // PRINT_OFFSETOF(struct bbq, chead);
+    // PRINT_OFFSETOF(struct bbq, blocks);
+
+    bbq_destory(q);
+}
+
+void expect_phead(struct bbq *q, uint64_t idx, uint64_t vsn, int line) {
+    uint64_t ph = bbq_atomic64_load(&q->phead.value, q->prod_single);
+    EXPECT_EQ(bbq_head_idx(q, ph), idx) << "line: " << line;
+    EXPECT_EQ(bbq_head_vsn(q, ph), vsn) << "line: " << line;
+}
+
+void expect_chead(struct bbq *q, uint64_t idx, uint64_t vsn, int line) {
+    uint64_t ch = bbq_atomic64_load(&q->chead.value, q->cons_single);
+    EXPECT_EQ(bbq_head_idx(q, ch), idx) << "line: " << line;
+    EXPECT_EQ(bbq_head_vsn(q, ch), vsn) << "line: " << line;
+}
+
+void expect_eq_allocated(struct bbq *q, bbq_block *block, uint64_t off, uint64_t vsn, int line) {
+    uint64_t allocated = bbq_atomic64_load(&block->allocated, q->prod_single);
+    EXPECT_EQ(bbq_cur_off(q, allocated), off) << "line: " << line;
+    EXPECT_EQ(bbq_cur_vsn(q, allocated), vsn) << "line: " << line;
+}
+
+void expect_eq_committed(struct bbq *q, bbq_block *block, uint64_t off, uint64_t vsn, int line) {
+    uint64_t committed = bbq_atomic64_load(&block->committed, q->prod_single);
+    EXPECT_EQ(bbq_cur_off(q, committed), off) << "line: " << line;
+    EXPECT_EQ(bbq_cur_vsn(q, committed), vsn) << "line: " << line;
+}
+
+void expect_eq_consumed(struct bbq *q, bbq_block *block, uint64_t off, uint64_t vsn, int line) {
+    uint64_t consumed = bbq_atomic64_load(&block->consumed, q->cons_single);
+    EXPECT_EQ(bbq_cur_off(q, consumed), off) << "line: " << line;
+    EXPECT_EQ(bbq_cur_vsn(q, consumed), vsn) << "line: " << line;
+}
+
+void expect_eq_reserved(struct bbq *q, bbq_block *block, uint64_t off, uint64_t vsn, int line) {
+    uint64_t reserved = bbq_atomic64_load(&block->reserved, q->cons_single);
+    EXPECT_EQ(bbq_cur_off(q, reserved), off) << "line: " << line;
+    EXPECT_EQ(bbq_cur_vsn(q, reserved), vsn) << "line: " << line;
+}
+
+// 初始化状态
+TEST_F(ut_bbq, head_cursor_init) {
+    struct bbq *q;
+    uint32_t bn = 2;
+    uint32_t bs = 4;
+    q = bbq_create_elem_with_bnbs("ut_bbq", bn, bs, sizeof(int),
+                                  BBQ_SOCKET_ID_ANY, BBQ_F_RETRY_NEW,
+                                  ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+
+    // 1.初始化状态,除了第一个block外其他块的4个游标都指向最后一个条目
+
+    EXPECT_EQ(bbq_atomic64_load(&q->phead.value, q->prod_single), 0);
+    EXPECT_EQ(bbq_atomic64_load(&q->chead.value, q->cons_single), 0);
+
+    expect_eq_allocated(q, &q->blocks[0], 0, 0, __LINE__);
+    expect_eq_committed(q, &q->blocks[0], 0, 0, __LINE__);
+    expect_eq_reserved(q, &q->blocks[0], 0, 0, __LINE__);
+    expect_eq_consumed(q, &q->blocks[0], 0, 0, __LINE__);
+    for (uint32_t i = 1; i < bn; i++) {
+        expect_eq_allocated(q, &q->blocks[i], bs, 0, __LINE__);
+        expect_eq_committed(q, &q->blocks[i], bs, 0, __LINE__);
+        expect_eq_reserved(q, &q->blocks[i], bs, 0, __LINE__);
+        expect_eq_consumed(q, &q->blocks[i], bs, 0, __LINE__);
+    }
+    EXPECT_TRUE(bbq_debug_check_array_bounds(q));
+    bbq_destory(q);
+}
+
+void ut_produce_something(uint32_t produce_cnt) {
+    int ret = 0;
+    struct bbq *q;
+    uint32_t bn = 8;
+    uint32_t bs = 4096;
+    int enqueue_data = UT_DATA_MAGIC;
+    int dequeue_data = 0;
+
+    EXPECT_GT(produce_cnt, 0);
+    EXPECT_LE(produce_cnt, bs);
+
+    q = bbq_create_elem_with_bnbs("ut_bbq", bn, bs, sizeof(int),
+                                  BBQ_SOCKET_ID_ANY, BBQ_F_RETRY_NEW,
+                                  ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+
+    // 生产produce_cnt
+    for (uint32_t i = 0; i < produce_cnt; i++) {
+        ret = bbq_enqueue_elem(q, &enqueue_data);
+        EXPECT_TRUE(ret == BBQ_OK);
+    }
+
+    EXPECT_EQ(bbq_atomic64_load(&q->phead.value, q->prod_single), 0);
+    EXPECT_EQ(bbq_atomic64_load(&q->chead.value, q->cons_single), 0);
+    expect_eq_allocated(q, &q->blocks[0], produce_cnt, 0, __LINE__);
+    expect_eq_committed(q, &q->blocks[0], produce_cnt, 0, __LINE__);
+    expect_eq_reserved(q, &q->blocks[0], 0, 0, __LINE__);
+    expect_eq_consumed(q, &q->blocks[0], 0, 0, __LINE__);
+
+    // 消费完
+    for (uint32_t i = 0; i < produce_cnt; i++) {
+        ret = bbq_dequeue_elem(q, &dequeue_data);
+        EXPECT_TRUE(ret == BBQ_OK);
+        EXPECT_EQ(dequeue_data, UT_DATA_MAGIC);
+    }
+
+    EXPECT_EQ(bbq_atomic64_load(&q->phead.value, q->prod_single), 0);
+    EXPECT_EQ(bbq_atomic64_load(&q->chead.value, q->cons_single), 0);
+    expect_eq_allocated(q, &q->blocks[0], produce_cnt, 0, __LINE__);
+    expect_eq_committed(q, &q->blocks[0], produce_cnt, 0, __LINE__);
+    expect_eq_reserved(q, &q->blocks[0], produce_cnt, 0, __LINE__);
+    expect_eq_consumed(q, &q->blocks[0], produce_cnt, 0, __LINE__);
+
+    for (uint32_t i = 1; i < bn; i++) {
+        expect_eq_allocated(q, &q->blocks[i], bs, 0, __LINE__);
+        expect_eq_committed(q, &q->blocks[i], bs, 0, __LINE__);
+        expect_eq_reserved(q, &q->blocks[i], bs, 0, __LINE__);
+        expect_eq_consumed(q, &q->blocks[i], bs, 0, __LINE__);
+    }
+    EXPECT_TRUE(bbq_debug_check_array_bounds(q));
+    bbq_destory(q);
+}
+// 在第一块内生产，然后被消费完
+TEST_F(ut_bbq, head_cursor_produce_something) {
+    ut_produce_something(1);
+    ut_produce_something(567);
+    ut_produce_something(789);
+    ut_produce_something(4096);
+}
+
+void ut_produce_next_block(uint32_t over) {
+    int ret = 0;
+    struct bbq *q;
+    uint32_t bn = 8;
+    uint32_t bs = 4096;
+    uint32_t produce_cnt = bs + over;
+    int enqueue_data = UT_DATA_MAGIC;
+    int dequeue_data = 0;
+
+    EXPECT_GT(over, 0);
+    EXPECT_LT(over, bs);
+
+    q = bbq_create_elem_with_bnbs("ut_bbq", bn, bs, sizeof(int),
+                                  BBQ_SOCKET_ID_ANY, BBQ_F_RETRY_NEW,
+                                  ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+
+    // 生产至第二块的第一个entry
+    for (uint32_t i = 0; i < produce_cnt; i++) {
+        ret = bbq_enqueue_elem(q, &enqueue_data);
+        EXPECT_TRUE(ret == BBQ_OK);
+    }
+
+    EXPECT_EQ(bbq_atomic64_load(&q->chead.value, q->cons_single), 0);
+    expect_phead(q, 1, 0, __LINE__);
+    expect_eq_allocated(q, &q->blocks[0], bs, 0, __LINE__);
+    expect_eq_committed(q, &q->blocks[0], bs, 0, __LINE__);
+    expect_eq_reserved(q, &q->blocks[0], 0, 0, __LINE__);
+    expect_eq_consumed(q, &q->blocks[0], 0, 0, __LINE__);
+
+    expect_eq_allocated(q, &q->blocks[1], over, 1, __LINE__);
+    expect_eq_committed(q, &q->blocks[1], over, 1, __LINE__);
+    expect_eq_reserved(q, &q->blocks[1], bs, 0, __LINE__);
+    expect_eq_consumed(q, &q->blocks[1], bs, 0, __LINE__);
+
+    // 消费完
+    for (uint32_t i = 0; i < produce_cnt; i++) {
+        ret = bbq_dequeue_elem(q, &dequeue_data);
+        EXPECT_TRUE(ret == BBQ_OK);
+        EXPECT_EQ(dequeue_data, UT_DATA_MAGIC);
+    }
+
+    expect_phead(q, 1, 0, __LINE__);
+    expect_chead(q, 1, 0, __LINE__);
+    expect_eq_allocated(q, &q->blocks[0], bs, 0, __LINE__);
+    expect_eq_committed(q, &q->blocks[0], bs, 0, __LINE__);
+    expect_eq_reserved(q, &q->blocks[0], bs, 0, __LINE__);
+    expect_eq_consumed(q, &q->blocks[0], bs, 0, __LINE__);
+
+    expect_eq_allocated(q, &q->blocks[1], over, 1, __LINE__);
+    expect_eq_committed(q, &q->blocks[1], over, 1, __LINE__);
+    expect_eq_reserved(q, &q->blocks[1], over, 1, __LINE__);
+    expect_eq_consumed(q, &q->blocks[1], over, 1, __LINE__);
+
+    EXPECT_TRUE(bbq_debug_check_array_bounds(q));
+    bbq_destory(q);
+}
+
+// 第一块生产完毕，第二块生产了若干，然后被消费完
+TEST_F(ut_bbq, head_cursor_produce_next_block) {
+    ut_produce_next_block(1);
+    ut_produce_next_block(123);
+    ut_produce_next_block(456);
+    ut_produce_next_block(4095);
+}
+
+void ut_produce_all_loop(uint32_t loop) {
+    int ret = 0;
+    struct bbq *q;
+    uint32_t bn = 8;
+    uint32_t bs = 4096;
+    uint32_t produce_cnt = bn * bs;
+    int enqueue_data = UT_DATA_MAGIC;
+    int dequeue_data = 0;
+
+    q = bbq_create_elem_with_bnbs("ut_bbq", bn, bs, sizeof(int),
+                                  BBQ_SOCKET_ID_ANY, BBQ_F_RETRY_NEW,
+                                  ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+
+    for (uint32_t cnt = 0; cnt < loop; cnt++) {
+        // 所有entry生产完毕
+        for (uint32_t i = 0; i < produce_cnt; i++) {
+            ret = bbq_enqueue_elem(q, &enqueue_data);
+            EXPECT_TRUE(ret == BBQ_OK);
+        }
+
+        // 消费完
+        for (uint32_t i = 0; i < produce_cnt; i++) {
+            ret = bbq_dequeue_elem(q, &dequeue_data);
+            EXPECT_TRUE(ret == BBQ_OK);
+            EXPECT_EQ(dequeue_data, UT_DATA_MAGIC);
+        }
+    }
+
+    expect_phead(q, bn - 1, loop - 1, __LINE__);
+    expect_chead(q, bn - 1, loop - 1, __LINE__);
+
+    expect_eq_allocated(q, &q->blocks[0], bs, loop - 1, __LINE__);
+    expect_eq_committed(q, &q->blocks[0], bs, loop - 1, __LINE__);
+    expect_eq_reserved(q, &q->blocks[0], bs, loop - 1, __LINE__);
+    expect_eq_consumed(q, &q->blocks[0], bs, loop - 1, __LINE__);
+
+    for (uint32_t i = 1; i < bn; i++) {
+        expect_eq_allocated(q, &q->blocks[i], bs, loop, __LINE__);
+        expect_eq_committed(q, &q->blocks[i], bs, loop, __LINE__);
+        expect_eq_reserved(q, &q->blocks[i], bs, loop, __LINE__);
+        expect_eq_consumed(q, &q->blocks[i], bs, loop, __LINE__);
+    }
+
+    EXPECT_TRUE(bbq_debug_check_array_bounds(q));
+    bbq_destory(q);
+}
+
+// 完成多轮的满生产和满消费
+TEST_F(ut_bbq, head_cursor_produce_all_loop) {
+    ut_produce_all_loop(1);
+    ut_produce_all_loop(10);
+    ut_produce_all_loop(23);
+    ut_produce_all_loop(79);
+}
+
+TEST_F(ut_bbq, head_cursor_retry_new_full_empty) {
+    int ret = 0;
+    uint32_t entries_cnt = 4096;
+    uint32_t loop = 1000;
+    struct bbq *q;
+    uint64_t ph = 0;
+    uint64_t ch = 0;
+    int *data = (int *)ut_malloc(UT_MODULE_UTEST, sizeof(*data) * entries_cnt);
+    int tmp_data = 0;
+    EXPECT_TRUE(data);
+
+    q = bbq_create_elem("ut_bbq", entries_cnt, sizeof(int), BBQ_SOCKET_ID_ANY,
+                        BBQ_F_RETRY_NEW | BBQ_F_ENABLE_STAT,
+                        ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+    EXPECT_TRUE(bbq_empty(q));
+
+    for (uint32_t i = 0; i < loop; i++) {
+        // 入满队
+        for (uint32_t j = 0; j < entries_cnt; j++) {
+            data[j] = (i + 1) * j;
+            ret = bbq_enqueue_elem(q, &data[j]);
+            EXPECT_TRUE(ret == BBQ_OK) << "ret " << ret;
+            EXPECT_FALSE(bbq_empty(q));
+        }
+
+        // 满队再入队
+        for (uint32_t j = 0; j < entries_cnt / 3; j++) {
+            ret = bbq_enqueue_elem(q, &data[j]);
+            EXPECT_TRUE(ret == BBQ_ERR_FULL);
+        }
+
+        ph = bbq_atomic64_load(&q->phead.value, q->prod_single);
+        ch = bbq_atomic64_load(&q->chead.value, q->cons_single);
+        if (i == 0) {
+            EXPECT_EQ((ph + 1) & q->idx_mask, ch & q->idx_mask);
+        } else {
+            EXPECT_EQ((ph)&q->idx_mask, ch & q->idx_mask);
+        }
+
+        for (uint32_t i = 0; i < q->bn; i++) {
+            EXPECT_EQ(bbq_atomic64_load(&q->blocks[i].committed, q->prod_single) & q->off_mask, q->bs);
+            EXPECT_GE(bbq_atomic64_load(&q->blocks[i].allocated, q->prod_single) & q->off_mask, q->bs);
+        }
+
+        // 全出队
+        for (uint32_t j = 0; j < entries_cnt; j++) {
+            EXPECT_FALSE(bbq_empty(q));
+            ret = bbq_dequeue_elem(q, &tmp_data);
+            EXPECT_TRUE(ret == BBQ_OK);
+            EXPECT_EQ(tmp_data, data[j]);
+        }
+
+        EXPECT_TRUE(bbq_empty(q));
+        // 空出队再出队
+        for (uint32_t j = 0; j < entries_cnt / 2; j++) {
+            ret = bbq_dequeue_elem(q, &tmp_data);
+            EXPECT_TRUE(ret == BBQ_ERR_EMPTY);
+        }
+
+        ph = bbq_atomic64_load(&q->phead.value, q->prod_single);
+        ch = bbq_atomic64_load(&q->chead.value, q->cons_single);
+        EXPECT_EQ(ph & q->idx_mask, ch & q->idx_mask);
+        for (uint32_t i = 0; i < q->bn; i++) {
+            EXPECT_EQ(bbq_atomic64_load(&q->blocks[i].committed, q->prod_single) & q->off_mask, q->bs);
+            EXPECT_GE(bbq_atomic64_load(&q->blocks[i].allocated, q->prod_single) & q->off_mask, q->bs);
+            EXPECT_EQ(bbq_atomic64_load(&q->blocks[i].consumed, q->cons_single) & q->off_mask, q->bs);
+            EXPECT_GE(bbq_atomic64_load(&q->blocks[i].reserved, q->cons_single) & q->off_mask, q->bs);
+        }
+    }
+
+    ut_free(UT_MODULE_UTEST, data);
+    EXPECT_TRUE(bbq_debug_check_array_bounds(q));
+    bbq_destory(q);
+}
+
+TEST_F(ut_bbq, head_cursor_mpsc_faa) {
+    struct ut_info_s info = {
+        .cfg = {
+            .base = {
+                .name = {},
+                .introduce = {},
+                .core_begin = 0,
+                .core_end = 3,
+            },
+            .ring = {
+                .ring_type = UT_RING_TYPE_BBQ,
+                .producer_cnt = 10,
+                .consumer_cnt = 1,
+                .workload = UT_WORKLOAD_SIMPLE,
+                .entries_cnt = 4,
+                .block_count = 1,
+                .burst_cnt = 1,
+            },
+            .run = {
+                .run_ok_times = 9000000,
+                .run_time = 0,
+            },
+        },
+        .ctl = {
+            .running = true,
+            .all_threads_start = {},
+            .producer_exit = {},
+        },
+    };
+
+    // 队列初始化
+    int ret = -1;
+    struct ut_queue q;
+    ret = ut_queue_init_bbq(&info.cfg, &q);
+    ASSERT_TRUE(ret == 0);
+
+    // 创建线程
+    pthread_t *threads = ut_threads_create(&info, &q);
+    ASSERT_TRUE(threads);
+
+    // 等待所有线程完成，回收数据
+    uint32_t thread_cnt = info.cfg.ring.producer_cnt + info.cfg.ring.consumer_cnt;
+    struct ut_exit_data **exit_data = (struct ut_exit_data **)ut_malloc(UT_MODULE_UTEST, sizeof(struct ut_exit_data **) * (thread_cnt));
+    uint32_t i = 0;
+
+    ut_wait_all_threads_exit(&info, thread_cnt, threads, exit_data);
+
+    // 比较数据
+    struct ut_merge_s merge;
+    memset(&merge, 0, sizeof(merge));
+
+    ut_merge_all_data(exit_data, thread_cnt, &merge);
+    EXPECT_EQ(merge.consumer.data_error_cnt, 0);
+    EXPECT_EQ(merge.consumer.ok_cnt, merge.producer.ok_cnt);
+
+    // 释放数据
+    for (i = 0; i < thread_cnt; i++) {
+        ut_exit_data_destory(exit_data[i]);
+    }
+    ut_free(UT_MODULE_UTEST, exit_data);
+    ut_threads_destory(&info, threads);
+    EXPECT_TRUE(bbq_debug_check_array_bounds((struct bbq *)q.ring));
+    ut_queue_destory(&q);
+}
+
+TEST_F(ut_bbq, head_cursor_drop_old_full_empty) {
+    int ret = 0;
+    uint32_t bn = 2;
+    uint32_t bs = 4;
+    uint32_t loop = 1000;
+    struct bbq *q;
+
+    int tmp_data = 0;
+    q = bbq_create_elem_with_bnbs("ut_bbq", bn, bs, sizeof(int),
+                                  BBQ_SOCKET_ID_ANY, BBQ_F_DROP_OLD,
+                                  ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+    // EXPECT_TRUE(bbq_empty(q));
+
+    for (uint32_t j = 0; j < loop; j++) {
+        // 入满队列
+        for (uint32_t i = 0; i < bn * bs; i++) {
+            ret = bbq_enqueue_elem(q, &i);
+            EXPECT_TRUE(ret == BBQ_OK) << "ret " << ret;
+            // EXPECT_FALSE(bbq_empty(q));
+        }
+
+        // 全出队
+        for (uint32_t i = 0; i < bn * bs; i++) {
+            // EXPECT_FALSE(bbq_empty(q));
+            ret = bbq_dequeue_elem(q, &tmp_data);
+            EXPECT_TRUE(ret == BBQ_OK) << "ret " << ret;
+            EXPECT_EQ(tmp_data, i);
+        }
+
+        // EXPECT_TRUE(bbq_empty(q));
+        // 空队再出队，失败
+        for (uint32_t i = 0; i < bn * bs; i++) {
+            ret = bbq_dequeue_elem(q, &tmp_data);
+            EXPECT_TRUE(ret == BBQ_ERR_EMPTY) << "ret " << ret;
+        }
+
+        expect_phead(q, bn - 1, j, __LINE__);
+        expect_chead(q, bn - 1, j, __LINE__);
+        for (uint32_t i = 0; i < q->bn; i++) {
+            expect_eq_committed(q, &q->blocks[i], q->bs, i == 0 ? j : j + 1, __LINE__);
+            expect_eq_allocated(q, &q->blocks[i], q->bs, i == 0 ? j : j + 1, __LINE__);
+            expect_eq_reserved(q, &q->blocks[i], q->bs, i == 0 ? j : j + 1, __LINE__);
+            EXPECT_EQ(bbq_atomic64_load(&q->blocks[i].consumed, q->cons_single), 0);
+        }
+    }
+    EXPECT_TRUE(bbq_debug_check_array_bounds(q));
+    bbq_destory(q);
+}
+
+TEST_F(ut_bbq, head_cursor_drop_old_full_empty_cover) {
+    int ret = 0;
+    uint32_t bn = 2;
+    uint32_t bs = 4;
+    uint32_t loop = 1000;
+    uint32_t over_cnt = bs + 2;
+    struct bbq *q;
+
+    EXPECT_EQ(over_cnt / bs, 1);
+
+    int tmp_data = 0;
+    q = bbq_create_elem_with_bnbs("ut_bbq", bn, bs, sizeof(int),
+                                  BBQ_SOCKET_ID_ANY, BBQ_F_DROP_OLD,
+                                  ut_malloc_def_callback, ut_free_def_callback);
+    ASSERT_NE(q, nullptr);
+
+    // EXPECT_TRUE(bbq_empty(q));
+    // 入满队列，再入over_cnt
+    for (uint32_t i = 0; i < bn * bs * loop + over_cnt; i++) {
+        ret = bbq_enqueue_elem(q, &i);
+        EXPECT_TRUE(ret == BBQ_OK) << "ret " << ret;
+
+        // uint32_t tmpA = i / (bn * bs);
+        // uint32_t tmpB = i % (bn * bs);
+        // if (tmpA > 0 && (tmpB < bs)) {
+        //     // 覆盖第一个块时，整个块被作废，因此都是empty，从第二个块开始可读取
+        //     EXPECT_TRUE(bbq_empty(q)) << "i " << i << "tmpA " << tmpA << "tmpB " << tmpB;
+        // } else {
+        //     EXPECT_FALSE(bbq_empty(q));
+        // }
+    }
+
+    expect_phead(q, 1, loop, __LINE__);
+    expect_chead(q, 0, 0, __LINE__);
+    // 检查每一个block上游标的正确性
+    for (uint32_t i = 0; i < bn; i++) {
+        expect_eq_committed(q, &q->blocks[i],
+                            i == bn - 1 ? over_cnt - bs : bs,
+                            i == 0 ? loop : loop + 1,
+                            __LINE__);
+        expect_eq_allocated(q, &q->blocks[i],
+                            i == bn - 1 ? over_cnt - bs : bs,
+                            i == 0 ? loop : loop + 1,
+                            __LINE__);
+        expect_eq_reserved(q, &q->blocks[i],
+                           i == 0 ? 0 : bs, 0,
+                           __LINE__);
+        EXPECT_EQ(bbq_atomic64_load(&q->blocks[i].consumed, false), 0);
+    }
+
+    // 队列中的数据全出队
+    for (uint32_t i = 0; i < over_cnt - bs; i++) {
+        ret = bbq_dequeue_elem(q, &tmp_data);
+        EXPECT_TRUE(ret == BBQ_OK) << "ret " << ret;
+    }
+
+    for (uint32_t i = 0; i < bn * bs; i++) {
+        // EXPECT_TRUE(bbq_empty(q));
+        ret = bbq_dequeue_elem(q, &tmp_data);
+        EXPECT_TRUE(ret == BBQ_ERR_EMPTY) << "ret " << ret;
+    }
+
+    expect_chead(q, 1, 0, __LINE__);
+    for (uint32_t i = 0; i < bn; i++) {
+        expect_eq_committed(q, &q->blocks[i],
+                            i == bn - 1 ? over_cnt - bs : bs,
+                            i == 0 ? loop : loop + 1,
+                            __LINE__);
+        expect_eq_allocated(q, &q->blocks[i],
+                            i == bn - 1 ? over_cnt - bs : bs,
+                            i == 0 ? loop : loop + 1,
+                            __LINE__);
+        expect_eq_reserved(q, &q->blocks[i],
+                           i == bn - 1 ? over_cnt - bs : bs,
+                           i == 1 ? loop + 1 : 0, __LINE__);
+        EXPECT_EQ(bbq_atomic64_load(&q->blocks[i].consumed, false), 0);
+    }
+
+    EXPECT_TRUE(bbq_debug_check_array_bounds(q));
+    bbq_destory(q);
+}
\ No newline at end of file
diff --git a/bbq/unittest/ut_bbq_func.c b/bbq/unittest/ut_bbq_func.c
new file mode 100644
index 0000000..88910ca
--- /dev/null
+++ b/bbq/unittest/ut_bbq_func.c
@@ -0,0 +1,615 @@
+/*
+ * @Author: liuyu
+ * @LastEditTime: 2024-07-07 22:34:03
+ * @Email: [email protected]
+ * @Describe: TODO
+ */
+
+#include "ut_bbq_func.h"
+#include "bbq.h"
+#include <pthread.h>
+#include <string.h>
+#include <sys/prctl.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+struct ut_memory {
+    aotmic_uint64 malloc_cnt;
+    aotmic_uint64 free_cnt;
+};
+
+struct ut_memory ut_memory_g[UT_MODULE_MAX] = {0};
+
+char *ut_ring_type_map[UT_RING_TYPE_MAX] = {
+    [UT_RING_TYPE_BBQ] = UT_RING_TYPE_BBQ_STR,
+    [UT_RING_TYPE_DPDK] = UT_RING_TYPE_DPDK_STR,
+    [UT_RING_TYPE_RMIND] = UT_RING_TYPE_RMIND_STR,
+};
+
+void *ut_malloc(enum ut_module module, size_t size) {
+    void *ptr = malloc(size);
+    if (ptr != NULL) {
+        atomic_fetch_add(&ut_memory_g[module].malloc_cnt, 1);
+    }
+
+    return ptr;
+}
+
+void ut_free(enum ut_module module, void *ptr) {
+    if (ptr != NULL) {
+        atomic_fetch_add(&ut_memory_g[module].free_cnt, 1);
+    }
+    free(ptr);
+}
+
+bool ut_malloc_free_equal() {
+    bool ret = true;
+    for (int i = 0; i < UT_MODULE_MAX; i++) {
+        uint64_t malloc_cnt = atomic_load(&ut_memory_g[i].malloc_cnt);
+        uint64_t free_cnt = atomic_load(&ut_memory_g[i].free_cnt);
+        if (malloc_cnt != free_cnt) {
+            UT_ERR_LOG("[module:%d] malloc:%lu free:%lu, test malloc-free not equal\n", i, malloc_cnt, free_cnt);
+            ret = false;
+        }
+    }
+
+    return ret;
+}
+
+void ut_memory_counter_clear() {
+    memset(ut_memory_g, 0, sizeof(ut_memory_g));
+}
+
+void ut_memory_counter_print() {
+    for (int i = 0; i < UT_MODULE_MAX; i++) {
+        uint64_t malloc_cnt = atomic_load(&ut_memory_g[i].malloc_cnt);
+        uint64_t free_cnt = atomic_load(&ut_memory_g[i].free_cnt);
+        if (malloc_cnt == 0 && free_cnt == 0) {
+            continue;
+        }
+
+        UT_INFO_LOG("[%d]test malloc:%lu free:%lu", i,
+                    atomic_load(&ut_memory_g[i].malloc_cnt),
+                    atomic_load(&ut_memory_g[i].free_cnt));
+    }
+
+    if (ut_malloc_free_equal()) {
+        UT_INFO_LOG("all memory free");
+    } else {
+        UT_ERR_LOG("memory not all free");
+    }
+}
+
+struct ut_metric ut_clock_time_get() {
+    struct ut_metric metric = {0};
+    clock_gettime(CLOCK_REALTIME, &metric.timestamp); // 系统实时时间,随系统实时时间改变而改变
+    return metric;
+}
+
+uint64_t ut_clock_time_to_ns(struct ut_metric *metric) {
+    return metric->timestamp.tv_nsec + metric->timestamp.tv_sec * 1000 * 1000 * 1000;
+}
+
+double ut_clock_time_to_double(struct ut_metric *metric) {
+    return metric->timestamp.tv_sec +
+           metric->timestamp.tv_nsec * 1.0 / 1000 / 1000 / 1000;
+}
+
+bool ut_clock_time_is_zero(struct ut_metric *metric) {
+    return metric->timestamp.tv_sec == 0 && metric->timestamp.tv_nsec == 0;
+}
+
+bool ut_timespec_is_after(const struct timespec *a, const struct timespec *b) {
+    if (a->tv_sec > b->tv_sec) {
+        // a的秒数大于b的秒数，所以a在b之后
+        return true;
+    } else if (a->tv_sec == b->tv_sec && a->tv_nsec > b->tv_nsec) {
+        // a和b的秒数相同，但a的纳秒数大于b的纳秒数，所以a在b之后
+        return true;
+    }
+    // 否则，a不在b之后
+    return false;
+}
+
+struct ut_metric ut_clock_time_sub(struct ut_metric now, struct ut_metric last) {
+    struct ut_metric diff = {
+        .timestamp.tv_sec = now.timestamp.tv_sec - last.timestamp.tv_sec,
+        .timestamp.tv_nsec = now.timestamp.tv_nsec - last.timestamp.tv_nsec,
+    };
+
+    if (now.timestamp.tv_nsec > last.timestamp.tv_nsec) {
+        diff.timestamp.tv_nsec = now.timestamp.tv_nsec - last.timestamp.tv_nsec;
+    } else {
+        // 从秒借位
+        diff.timestamp.tv_sec--;
+        diff.timestamp.tv_nsec = 1000 * 1000 * 1000 + now.timestamp.tv_nsec - last.timestamp.tv_nsec;
+    }
+
+    return diff;
+}
+
+enum ut_workload ut_workload_str2enum(const char *workload) {
+    if (strcmp(workload, "simple") == 0) {
+        return UT_WORKLOAD_SIMPLE;
+    } else if (strcmp(workload, "complex") == 0) {
+        return UT_WORKLOAD_COMPLEX;
+    }
+
+    return UT_WORKLOAD_MAX;
+}
+
+enum ut_ring_type ut_ring_type_str2enum(const char *ring_type) {
+    if (strcmp(ring_type, UT_RING_TYPE_BBQ_STR) == 0) {
+        return UT_RING_TYPE_BBQ;
+    } else if (strcmp(ring_type, UT_RING_TYPE_DPDK_STR) == 0) {
+        return UT_RING_TYPE_DPDK;
+    } else if (strcmp(ring_type, UT_RING_TYPE_RMIND_STR) == 0) {
+        return UT_RING_TYPE_RMIND;
+    }
+
+    return UT_RING_TYPE_MAX;
+}
+
+char *ut_ring_type_enum2str(enum ut_ring_type ring_type) {
+    if (ring_type >= UT_RING_TYPE_MAX) {
+        return "unknown";
+    } else {
+        return ut_ring_type_map[ring_type];
+    }
+}
+
+int ut_setaffinity(int core_id) {
+    cpu_set_t mask;
+    CPU_ZERO(&mask);
+    CPU_SET(core_id, &mask);
+
+    if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) == -1) {
+        UT_ERR_LOG("pthread_setaffinity_np erro\n");
+        return BBQ_ERR;
+    }
+
+    return BBQ_OK;
+}
+
+void *ut_malloc_def_callback(int32_t socket_id __attribute__((unused)), size_t size) {
+    return malloc(size);
+    // return aligned_alloc(BBQ_CACHE_LINE, size);
+}
+
+void ut_free_def_callback(void *ptr,
+                          size_t size __attribute__((unused))) {
+    free(ptr);
+}
+
+uint32_t ut_bbq_enqueue_burst(void *ring, void **obj_table, uint32_t n, uint16_t thread_idx, uint32_t *wait_consumed) {
+    UT_AVOID_WARNING(thread_idx);
+    return bbq_enqueue_burst(ring, obj_table, n, wait_consumed);
+}
+
+int ut_queue_init_bbq(struct ut_cfg *cfg, struct ut_queue *q) {
+#if 0
+    // 开启了BBQ_F_ENABLE_STAT 会导致性能下降
+    unsigned int flags = BBQ_F_RETRY_NEW | BBQ_F_ENABLE_STAT;
+#else
+    unsigned int flags = BBQ_F_RETRY_NEW;
+#endif
+
+    if (cfg->ring.producer_cnt <= 1) {
+        flags |= BBQ_F_SP_ENQ;
+    }
+
+    if (cfg->ring.consumer_cnt <= 1) {
+        flags |= BBQ_F_SC_DEQ;
+    }
+
+    if (cfg->ring.block_count == 0) {
+        q->ring = bbq_create("ut_bbq", cfg->ring.entries_cnt, BBQ_SOCKET_ID_ANY, flags,
+                             ut_malloc_def_callback, ut_free_def_callback);
+    } else {
+        q->ring = bbq_create_with_bnbs("ut_bbq", cfg->ring.block_count,
+                                       cfg->ring.entries_cnt / cfg->ring.block_count,
+                                       BBQ_SOCKET_ID_ANY, flags, ut_malloc_def_callback, ut_free_def_callback);
+    }
+
+    if (q->ring == NULL) {
+        UT_ERR_LOG("bbq create queue failed");
+        return BBQ_ERR_INPUT_NULL;
+    }
+
+    q->ring_free_f = (ut_ring_free_f)bbq_destory;
+    q->enqueue_f = (ut_ring_enqueue_f)bbq_enqueue;
+    q->dequeue_f = (ut_ring_dequeue_f)bbq_dequeue;
+    q->enqueue_burst_f = (ut_enqueue_burst_f)ut_bbq_enqueue_burst;
+    q->dequeue_burst_f = (ut_dequeue_burst_f)bbq_dequeue_burst;
+    return 0;
+}
+
+void ut_queue_destory(struct ut_queue *q) {
+    if (q != NULL && q->ring_free_f != NULL) {
+        q->ring_free_f(q->ring);
+    }
+}
+
+bool ut_all_producer_exit(struct ut_info_s *ut_info) {
+    return atomic_load(&ut_info->ctl.producer_exit) == ut_info->cfg.ring.producer_cnt;
+}
+
+void ut_wait_all_threads_ready(struct ut_ctl *ctl) {
+    pthread_barrier_wait(&ctl->all_threads_start);
+    UT_DBG_LOG("thread init done!");
+}
+
+struct ut_exit_data *ut_exit_data_create(struct ut_thread_arg *t_arg) {
+    struct ut_exit_data *exit_data = (struct ut_exit_data *)ut_malloc(UT_MODULE_COMMON, sizeof(struct ut_exit_data));
+    if (exit_data == NULL) {
+        UT_ERR_LOG("malloc failed");
+        exit(-1);
+    }
+
+    size_t size = t_arg->info->cfg.ring.entries_cnt;
+    exit_data->simple_data_cnt = size;
+    exit_data->simple_data = ut_data_create(size, UT_DATA_MAGIC_TYPE);
+
+    if (exit_data->simple_data == NULL) {
+        UT_ERR_LOG("malloc failed");
+        exit(-1);
+    }
+    exit_data->arg = t_arg;
+    exit_data->thread_id = pthread_self();
+    exit_data->latency_ns = 0;
+    exit_data->data_error_cnt = 0;
+
+    return exit_data;
+}
+
+void ut_exit_data_destory(struct ut_exit_data *data) {
+    ut_data_destory(data->simple_data, data->simple_data_cnt);
+    ut_free(UT_MODULE_COMMON, data->arg);
+    ut_free(UT_MODULE_COMMON, data);
+}
+
+struct ut_data **ut_data_create(size_t cnt, enum ut_data_type data_type) {
+    struct ut_data **simple_data = ut_malloc(UT_MODULE_DATA, sizeof(*simple_data) * cnt);
+    struct ut_metric enqueue_time = ut_clock_time_get();
+    for (size_t i = 0; i < cnt; i++) {
+        simple_data[i] = ut_malloc(UT_MODULE_DATA, sizeof(*simple_data[i]));
+        if (data_type == UT_DATA_MAGIC_TYPE) {
+            simple_data[i]->data = UT_DATA_MAGIC;
+        } else {
+            simple_data[i]->data = (uintptr_t)(simple_data[i]);
+        }
+        simple_data[i]->enqueue_time = enqueue_time;
+    }
+
+    return simple_data;
+}
+
+void ut_data_destory(struct ut_data **data, size_t cnt) {
+    for (size_t i = 0; i < cnt; i++) {
+        ut_free(UT_MODULE_DATA, data[i]);
+    }
+    ut_free(UT_MODULE_DATA, data);
+}
+
+uint32_t ut_exec_enqueue(struct ut_queue *q, struct ut_data **data, size_t burst_cnt,
+                         struct ut_metric *op_use_diff, uint16_t thread_idx) {
+    uint32_t enqueue_cnt = 0;
+    struct ut_metric op_use_start = ut_clock_time_get();
+    uint32_t wait_consumed = 0;
+    enqueue_cnt = q->enqueue_burst_f(q->ring, (void **)data, burst_cnt, thread_idx, &wait_consumed);
+    *op_use_diff = ut_clock_time_sub(ut_clock_time_get(), op_use_start);
+
+    return enqueue_cnt;
+}
+
+uint32_t ut_exec_dequeue(struct ut_queue *q, struct ut_data **data, size_t burst_cnt, struct ut_metric *op_use_diff) {
+    uint32_t dequeue_cnt = 0;
+
+    struct ut_metric op_use_start = ut_clock_time_get();
+    dequeue_cnt = q->dequeue_burst_f(q->ring, (void **)data, burst_cnt, NULL);
+    *op_use_diff = ut_clock_time_sub(ut_clock_time_get(), op_use_start);
+
+    return dequeue_cnt;
+}
+
+void *ut_thread_producer_start(void *arg) {
+    uint32_t enqueue_cnt = 0;
+    uint64_t ok_cnt = 0;
+    uint64_t run_times = 0;
+    struct ut_thread_arg *t_arg = (struct ut_thread_arg *)arg;
+    struct ut_info_s *info = t_arg->info;
+    struct ut_cfg *cfg = &info->cfg;
+    struct ut_queue *q = t_arg->q;
+    struct ut_exit_data *exit_data = ut_exit_data_create(t_arg);
+
+    char thread_name[128] = {0};
+    uint64_t op_ok_latency_ns = 0;
+    uint64_t op_err_latency_ns = 0;
+    uint64_t run_ok_times = cfg->run.run_ok_times / cfg->ring.producer_cnt;
+    struct ut_metric op_latency = {0};
+    snprintf(thread_name, sizeof(thread_name), "producer:%lu", exit_data->thread_id);
+    prctl(PR_SET_NAME, thread_name);
+    if (ut_setaffinity(t_arg->core) != BBQ_OK) {
+        UT_ERR_LOG("ut_setaffinity error");
+        exit(-1);
+    }
+
+    ut_wait_all_threads_ready(&info->ctl);
+    UT_INFO_LOG("producer thread:%lx, core:%d", exit_data->thread_id, t_arg->core);
+
+    exit_data->metric_start = ut_clock_time_get();
+    while (true) {
+        if ((run_ok_times > 0 && ok_cnt >= run_ok_times) || (!info->ctl.running)) {
+            // 控制次数的循环或运行时间到了
+            break;
+        }
+
+        if (cfg->ring.workload == UT_WORKLOAD_SIMPLE) {
+            enqueue_cnt = ut_exec_enqueue(q, exit_data->simple_data, cfg->ring.burst_cnt, &op_latency, t_arg->thread_idx);
+        } else {
+            struct ut_data **data = ut_data_create(cfg->ring.burst_cnt, UT_DATA_UINTPTR_TYPE);
+            if (data == NULL) {
+                UT_ERR_LOG("malloc falied");
+                exit(-1);
+            }
+
+            enqueue_cnt = ut_exec_enqueue(q, data, cfg->ring.burst_cnt, &op_latency, t_arg->thread_idx);
+            // 释放未入队的内存
+            for (uint32_t i = enqueue_cnt; i < cfg->ring.burst_cnt; i++) {
+                ut_free(UT_MODULE_DATA, data[i]);
+            }
+
+            ut_free(UT_MODULE_DATA, data);
+        }
+
+        if (enqueue_cnt > 0) {
+            ok_cnt += enqueue_cnt;
+            op_ok_latency_ns += ut_clock_time_to_ns(&op_latency);
+        } else {
+            op_err_latency_ns += ut_clock_time_to_ns(&op_latency);
+        }
+
+        run_times++;
+    }
+
+    exit_data->metric_end = ut_clock_time_get();
+    exit_data->run_times = run_times;
+    exit_data->ok_cnt = ok_cnt;
+
+    exit_data->op_ok_latency_ns = op_ok_latency_ns;
+    exit_data->op_err_latency_ns = op_err_latency_ns;
+    atomic_fetch_add(&info->ctl.producer_exit, 1);
+
+    UT_DBG_LOG("producer-----> en_ok:%lu", ok_cnt);
+    pthread_exit(exit_data);
+}
+
+void *ut_thread_consumer_start(void *arg) {
+    uint32_t deq_cnt = -1;
+    uint64_t ok_cnt = 0;
+    uint64_t run_times = 0;
+    struct ut_thread_arg *t_arg = (struct ut_thread_arg *)arg;
+    struct ut_info_s *info = t_arg->info;
+    struct ut_cfg *cfg = &info->cfg;
+    struct ut_queue *q = t_arg->q;
+    struct ut_exit_data *exit_data = ut_exit_data_create(t_arg);
+    uint64_t latency_ns = 0;
+    struct ut_metric op_latency = {0};
+    uint64_t op_ok_latency_ns = 0;
+    uint64_t op_err_latency_ns = 0;
+    uint64_t data_error_cnt = 0;
+    char thread_name[128] = {0};
+    struct ut_data **deq_data = ut_malloc(UT_MODULE_DATA, sizeof(*deq_data) * cfg->ring.entries_cnt);
+
+    snprintf(thread_name, sizeof(thread_name), "consumer:%lu", exit_data->thread_id);
+    prctl(PR_SET_NAME, thread_name);
+    if (ut_setaffinity(t_arg->core) != BBQ_OK) {
+        UT_ERR_LOG("ut_setaffinity error");
+        exit(-1);
+    }
+
+    ut_wait_all_threads_ready(&info->ctl);
+    UT_INFO_LOG("consumer thread:%lx, core:%d", exit_data->thread_id, t_arg->core);
+
+    exit_data->metric_start = ut_clock_time_get();
+
+    while (true) {
+        if (ut_all_producer_exit(info) && deq_cnt == 0) {
+            // 运行时间到了或是所有生产者退出了,检查生产者是否全部退出，且队列被消费完了
+            break;
+        }
+
+        deq_cnt = ut_exec_dequeue(q, deq_data, cfg->ring.burst_cnt, &op_latency);
+        if (deq_cnt > 0) {
+            for (uint32_t i = 0; i < deq_cnt; i++) {
+                struct ut_data *data = deq_data[i];
+                if (cfg->ring.workload == UT_WORKLOAD_SIMPLE) {
+                    if (data->data != UT_DATA_MAGIC) {
+                        UT_ERR_LOG("the obtained data is not consistent with the expectation, expect:%u actual:%lu", UT_DATA_MAGIC, data->data);
+                        exit_data->data_error_cnt += 1;
+                    }
+                } else {
+                    struct ut_metric latency = ut_clock_time_sub(ut_clock_time_get(), data->enqueue_time);
+                    if (ut_clock_time_is_zero(&data->enqueue_time)) {
+                        UT_ERR_LOG("enqueue_time is 0");
+                        exit(-1);
+                    }
+
+                    if (data->data != (uintptr_t)data) {
+                        UT_ERR_LOG("the obtained data is not consistent with the expectation, expect:%lu actual:%lu", (uintptr_t)data, data->data);
+                        data_error_cnt += 1;
+                    }
+
+                    latency_ns += ut_clock_time_to_ns(&latency);
+                    ut_free(UT_MODULE_DATA, data);
+                }
+            }
+            ok_cnt += deq_cnt;
+            op_ok_latency_ns += ut_clock_time_to_ns(&op_latency);
+        } else {
+            op_err_latency_ns += ut_clock_time_to_ns(&op_latency);
+        }
+
+        run_times++;
+    }
+
+    exit_data->metric_end = ut_clock_time_get();
+    exit_data->run_times = run_times;
+    exit_data->ok_cnt = ok_cnt;
+    exit_data->latency_ns = latency_ns;
+    exit_data->op_ok_latency_ns = op_ok_latency_ns;
+    exit_data->op_err_latency_ns = op_err_latency_ns;
+    exit_data->data_error_cnt = data_error_cnt;
+
+    ut_free(UT_MODULE_DATA, deq_data);
+    UT_DBG_LOG("consumer-----> de_ok:%lu", ok_cnt);
+    pthread_exit(exit_data);
+}
+
+void ut_wait_all_threads_exit(struct ut_info_s *info, uint32_t thread_cnt, pthread_t *threads, struct ut_exit_data **exit_data) {
+    if (info->cfg.run.run_time > 0) {
+        UT_DBG_LOG("sleep %lus, and notify all threads to exit...", info->cfg.run.run_time);
+        sleep(info->cfg.run.run_time);
+        info->ctl.running = false;
+    }
+
+    for (uint32_t i = 0; i < thread_cnt; i++) {
+        pthread_join(threads[i], (void **)(&exit_data[i])); // 等待每个线程结束
+    }
+}
+void ut_one_thread_create(struct ut_info_s *info, struct ut_queue *q, enum ut_thread_type ttype, int core, uint16_t thread_id, pthread_t *thread) {
+    UT_DBG_LOG("thread type:%d core:%d", ttype, core);
+    struct ut_thread_arg *arg = (struct ut_thread_arg *)ut_malloc(UT_MODULE_COMMON, sizeof(struct ut_thread_arg)); // 线程回收时free
+    arg->info = info;
+    arg->q = q;
+    arg->ttype = ttype;
+    arg->core = core;
+    arg->thread_idx = thread_id;
+
+    if (ttype == UT_THREAD_PRODUCER) {
+        pthread_create(thread, NULL, ut_thread_producer_start, arg);
+    } else {
+        pthread_create(thread, NULL, ut_thread_consumer_start, arg);
+    }
+}
+
+#define CORE_ID_CHK_SET(core_id, max_id)                             \
+    do {                                                             \
+        core_id = (core_id + 1) <= max_id ? (core_id + 1) : core_id; \
+    } while (0)
+
+pthread_t *ut_threads_create(struct ut_info_s *info, struct ut_queue *q) {
+    // 创建生产者消费者线程
+    uint16_t thread_id = 0;
+    struct ut_cfg *cfg = &info->cfg;
+    int core_id = cfg->base.core_begin;
+    size_t thread_cnt = cfg->ring.producer_cnt + cfg->ring.consumer_cnt;
+    pthread_t *threads = (pthread_t *)ut_malloc(UT_MODULE_COMMON, sizeof(pthread_t) * thread_cnt); // 存储所有线程ID的数组
+
+    pthread_barrier_init(&info->ctl.all_threads_start, NULL, thread_cnt);
+    info->ctl.running = true;
+    info->ctl.producer_exit = ATOMIC_VAR_INIT(0);
+
+    // MPSC 或 SPMC 场景在第一个核心/超线程上分配单个生产者或消费者，然后将其他线程按顺序分配给核心/超线程。
+    // MPMC，我们将生产者和消费者一一交错分配
+    // 如果数量不同，则在最后分配剩余部分。
+    if (cfg->ring.producer_cnt == 1 && cfg->ring.consumer_cnt >= 1) {
+        // SPMC，第一个核心给生产者，其他分配给消费者
+        ut_one_thread_create(info, q, UT_THREAD_PRODUCER, core_id, thread_id, &(threads[thread_id]));
+        thread_id++;
+        for (uint32_t i = 0; i < cfg->ring.consumer_cnt; i++) {
+            CORE_ID_CHK_SET(core_id, cfg->base.core_end);
+            ut_one_thread_create(info, q, UT_THREAD_CONSUMER, core_id, thread_id, &(threads[thread_id]));
+            thread_id++;
+        }
+    } else if (cfg->ring.consumer_cnt == 1 && cfg->ring.producer_cnt >= 1) {
+        // MPSC，第一个核心给消费者，其他分配给生产者
+        ut_one_thread_create(info, q, UT_THREAD_CONSUMER, core_id, thread_id, &(threads[thread_id]));
+        thread_id++;
+        for (uint32_t i = 0; i < cfg->ring.producer_cnt; i++) {
+            CORE_ID_CHK_SET(core_id, cfg->base.core_end);
+            ut_one_thread_create(info, q, UT_THREAD_PRODUCER, core_id, thread_id, &(threads[thread_id]));
+            thread_id++;
+        }
+    } else {
+        // MPMC 或 只有生产者 或这有消费者，核心交错分配
+        uint32_t pcnt = cfg->ring.producer_cnt; // 生产者个数
+        uint32_t ccnt = cfg->ring.consumer_cnt; // 消费者个数
+        for (core_id = cfg->base.core_begin; core_id < cfg->base.core_end && pcnt > 0 && ccnt > 0;) {
+            if ((core_id & 1) == 0) {
+                // 偶数
+                ut_one_thread_create(info, q, UT_THREAD_PRODUCER, core_id, thread_id, &(threads[thread_id]));
+                thread_id++;
+                pcnt--;
+            } else {
+                ut_one_thread_create(info, q, UT_THREAD_CONSUMER, core_id, thread_id, &(threads[thread_id]));
+                thread_id++;
+                ccnt--;
+            }
+            CORE_ID_CHK_SET(core_id, cfg->base.core_end);
+        }
+
+        for (uint32_t i = 0; i < pcnt; i++) {
+            ut_one_thread_create(info, q, UT_THREAD_PRODUCER, core_id, thread_id, &(threads[thread_id]));
+            thread_id++;
+            CORE_ID_CHK_SET(core_id, cfg->base.core_end);
+        }
+
+        for (uint32_t i = 0; i < ccnt; i++) {
+            ut_one_thread_create(info, q, UT_THREAD_CONSUMER, core_id, thread_id, &(threads[thread_id]));
+            thread_id++;
+            CORE_ID_CHK_SET(core_id, cfg->base.core_end);
+        }
+    }
+
+    return threads;
+}
+
+void ut_threads_destory(struct ut_info_s *info, pthread_t *threads) {
+    pthread_barrier_destroy(&info->ctl.all_threads_start);
+    ut_free(UT_MODULE_COMMON, threads);
+}
+
+void ut_merge_data_detail(struct ut_merge_data *merge, struct ut_exit_data *exit_data) {
+    merge->run_times += exit_data->run_times;
+    merge->ok_cnt += exit_data->ok_cnt;
+    merge->latency_ns += exit_data->latency_ns;
+    merge->op_err_latency_ns = exit_data->op_err_latency_ns;
+    merge->op_ok_latency_ns += exit_data->op_ok_latency_ns;
+    merge->data_error_cnt += exit_data->data_error_cnt;
+}
+
+void ut_merge_all_data(struct ut_exit_data **exit_data, uint32_t thread_cnt, struct ut_merge_s *merge) {
+    struct ut_metric p_start = {0};
+    struct ut_metric p_end = {0};
+    struct ut_metric c_start = {0};
+    struct ut_metric c_end = {0};
+
+    for (uint32_t i = 0; i < thread_cnt; i++) {
+        // 根据生产者/消费者 线程最早开始和最晚结束，记录时间
+        if (exit_data[i]->arg->ttype == UT_THREAD_PRODUCER) {
+            if (ut_clock_time_is_zero(&p_start) || ut_timespec_is_after(&p_start.timestamp, &exit_data[i]->metric_start.timestamp)) {
+                p_start = exit_data[i]->metric_start;
+            }
+
+            if (ut_timespec_is_after(&exit_data[i]->metric_start.timestamp, &p_end.timestamp)) {
+                p_end = exit_data[i]->metric_end;
+            }
+
+            ut_merge_data_detail(&merge->producer, exit_data[i]);
+        } else {
+            if (ut_clock_time_is_zero(&c_start) || ut_timespec_is_after(&c_start.timestamp, &exit_data[i]->metric_start.timestamp)) {
+                c_start = exit_data[i]->metric_start;
+            }
+
+            if (ut_timespec_is_after(&exit_data[i]->metric_start.timestamp, &c_end.timestamp)) {
+                c_end = exit_data[i]->metric_end;
+            }
+
+            ut_merge_data_detail(&merge->consumer, exit_data[i]);
+        }
+    }
+
+    merge->producer.use_time = ut_clock_time_sub(p_end, p_start);
+    merge->consumer.use_time = ut_clock_time_sub(c_end, c_start);
+}
\ No newline at end of file
diff --git a/bbq/unittest/ut_bbq_func.h b/bbq/unittest/ut_bbq_func.h
new file mode 100644
index 0000000..322f2cf
--- /dev/null
+++ b/bbq/unittest/ut_bbq_func.h
@@ -0,0 +1,302 @@
+/*
+ * @Author: liuyu
+ * @LastEditTime: 2024-07-07 21:57:13
+ * @Email: [email protected]
+ * @Describe: TODO
+ */
+#pragma once
+
+#include "bbq.h"
+#include <pthread.h>
+
+#include <pthread.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <time.h>
+
+#ifndef __cplusplus
+// C
+#include <stdatomic.h>
+#endif
+
+enum ut_thread_type {
+    UT_THREAD_PRODUCER,
+    UT_THREAD_CONSUMER,
+    UT_THREAD_TYPE_MAX,
+};
+
+struct ut_metric {
+    struct timespec timestamp; // 系统时间戳
+    // uint64_t cycles;     // cpu运行的cycle
+};
+
+struct ut_report {
+    uint64_t throughput;       // 吞吐量：每秒消耗的条目总数。
+    double data_latency;       // 数据延迟：每个数据在队列中停留的平均时间。
+    double op_latency;         // 操作延迟：每个入队或出队操作的平均延迟。
+    double *fairness;          // 公平性：每个生产者/消费者的吞吐量（占总吞吐的百分比）
+    double full_empty;         // 队列满时入队的延迟/队列空时出队的延迟（仅用于简单工作负载）。
+    uint64_t oversubscription; // 比核心/超线程更多的生产者和消费者的吞吐量
+};
+
+enum ut_workload {
+    UT_WORKLOAD_SIMPLE,  // 简单负载，每个生产者或消费者都有自己的线程，它们在循环中不断执行入队或出队操作。每次出队后都会验证数据。
+    UT_WORKLOAD_COMPLEX, // 复杂负载，基于简单工作负载。生产者和消费者为数据分配空间，执行入队和出队，然后手动释放
+    UT_WORKLOAD_MAX,
+};
+
+#define UT_RING_TYPE_BBQ_STR "bbq"
+#define UT_RING_TYPE_DPDK_STR "dpdk"
+#define UT_RING_TYPE_RMIND_STR "rmind"
+enum ut_ring_type {
+    UT_RING_TYPE_BBQ,
+    UT_RING_TYPE_DPDK,
+    UT_RING_TYPE_RMIND,
+    UT_RING_TYPE_MAX,
+};
+
+struct ut_cfg_base {
+    char name[128];      // 配置文件名
+    char introduce[128]; // 测试配置说明
+    uint16_t core_begin; // 起始核心
+    uint16_t core_end;   // 终止核心
+};
+
+struct ut_cfg_ring {
+    enum ut_ring_type ring_type; // ring buffer类型
+    uint32_t producer_cnt;       // 生产者个数
+    uint32_t consumer_cnt;       // 消费者个数
+    enum ut_workload workload;   // 负载模式
+    uint64_t entries_cnt;        // ring初始化时分配entry的个数
+    uint32_t block_count;        // bbq block个数，为0时表示根据entries_cnt自动计算
+    uint32_t burst_cnt;          // 批量出入队个数
+};
+
+struct ut_cfg_run {
+    uint64_t run_ok_times; // 成功入队/入队次数
+    uint64_t run_time;     // 整体运行时间，单位秒
+};
+
+struct ut_cfg {
+    struct ut_cfg_base base;
+    struct ut_cfg_ring ring;
+    struct ut_cfg_run run;
+};
+
+struct ut_ctl {
+    volatile bool running; // 默认为true，当设置为false，即所有生产者消费者即将退出
+    pthread_barrier_t all_threads_start;
+#ifndef __cplusplus
+    // C
+    atomic_uint producer_exit;
+#else
+    // C++ 为了兼容gtest测试
+    std::atomic<uint32_t> producer_exit;
+#endif
+};
+
+struct ut_info_s {
+    struct ut_cfg cfg;
+    struct ut_ctl ctl;
+};
+
+enum ut_module {
+    UT_MODULE_UTEST,
+    UT_MODULE_COMMON,
+    UT_MODULE_DATA,
+    UT_MODULE_BCM,
+    UT_MODULE_TABLE,
+    UT_MODULE_RMIND,
+    UT_MODULE_MAX,
+};
+
+#ifdef UT_DEBUG
+#define UT_DBG_LOG(fmt, ...)                                                             \
+    do {                                                                                 \
+        printf("[DBG][%s:%d:%s]" fmt "\n", __func__, __LINE__, __FILE__, ##__VA_ARGS__); \
+    } while (0)
+
+#else
+#define UT_DBG_LOG(fmt, ...) \
+    do {                     \
+    } while (0)
+#endif
+
+#define UT_ERR_LOG(fmt, ...)                                                                             \
+    do {                                                                                                 \
+        printf("\x1b[31m [ERR][%s:%d:%s]" fmt "\x1b[0m\n", __func__, __LINE__, __FILE__, ##__VA_ARGS__); \
+    } while (0)
+
+#define UT_INFO_LOG(fmt, ...)                                                             \
+    do {                                                                                  \
+        printf("[INFO][%s:%d:%s]" fmt "\n", __func__, __LINE__, __FILE__, ##__VA_ARGS__); \
+    } while (0)
+
+#define UT_AVOID_WARNING(param) ((void)param)
+
+#define UT_PTR_ARRAY_DATA_INIT(table, t_type, t_count)                           \
+    do {                                                                         \
+        if (table != NULL) {                                                     \
+            memset(table, 0, sizeof(t_type *) * t_count);                        \
+            for (uint32_t i = 0; i < t_count; i++) {                             \
+                table[i] = (t_type *)ut_malloc(UT_MODULE_TABLE, sizeof(t_type)); \
+                if (table[i] == NULL) {                                          \
+                    for (uint32_t j = 0; j < i; j++) {                           \
+                        ut_free(UT_MODULE_TABLE, table[j]);                      \
+                        table[j] = NULL;                                         \
+                    }                                                            \
+                    ut_free(UT_MODULE_TABLE, table);                             \
+                    break;                                                       \
+                }                                                                \
+                *table[i] = (t_type)UT_DATA_MAGIC;                               \
+            }                                                                    \
+        }                                                                        \
+    } while (0)
+
+#define UT_PTR_ARRAY_DATA_DESTORY(table, t_count)    \
+    do {                                             \
+        if (table != NULL) {                         \
+            for (uint32_t i = 0; i < t_count; i++) { \
+                ut_free(UT_MODULE_TABLE, table[i]);  \
+                table[i] = NULL;                     \
+            }                                        \
+        }                                            \
+    } while (0)
+
+#define UT_DOUBLE_PTR_DATA_INIT(table, t_type, t_count)                            \
+    do {                                                                           \
+        table = (t_type **)ut_malloc(UT_MODULE_TABLE, sizeof(t_type *) * t_count); \
+        if (table != NULL) {                                                       \
+            UT_PTR_ARRAY_DATA_INIT(table, t_type, t_count);                        \
+        }                                                                          \
+    } while (0)
+
+#define UT_DOUBLE_PTR_DATA_DESTORY(table, t_count)     \
+    do {                                               \
+        if (table != NULL) {                           \
+            UT_PTR_ARRAY_DATA_DESTORY(table, t_count); \
+            ut_free(UT_MODULE_TABLE, table);           \
+            table = NULL;                              \
+        }                                              \
+    } while (0)
+
+#define UT_ARRAY_DATA_INIT(table, t_count)  \
+    do {                                    \
+        for (int i = 0; i < t_count; i++) { \
+            table[i] = UT_DATA_MAGIC;       \
+        }                                   \
+    } while (0)
+
+#define UT_DATA_MAGIC 0x1F // 为了兼容所有类型的数据，存储1字节大小的数据
+
+typedef void (*ut_ring_free_f)(void *ring);
+typedef int (*ut_ring_enqueue_f)(void *ring, void *obj);
+typedef int (*ut_ring_dequeue_f)(void *ring, void *obj);
+typedef uint32_t (*ut_enqueue_burst_f)(void *ring, void **obj_table, uint32_t n, uint16_t thread_idx, uint32_t *wait_consumed);
+typedef uint32_t (*ut_dequeue_burst_f)(void *ring, void **obj_table, uint32_t n, uint32_t *wait_consumed);
+typedef bool (*ut_ring_empty_f)(void *ring);
+
+struct ut_queue {
+    void *ring;
+    enum ut_ring_type ring_type;
+    ut_ring_free_f ring_free_f;
+    ut_ring_enqueue_f enqueue_f;
+    ut_ring_dequeue_f dequeue_f;
+    ut_enqueue_burst_f enqueue_burst_f;
+    ut_dequeue_burst_f dequeue_burst_f;
+};
+
+struct ut_thread_arg {
+    int core;
+    uint16_t thread_idx; // 线程索引，不是pthread_id
+    enum ut_thread_type ttype;
+    struct ut_info_s *info;
+    struct ut_queue *q;
+};
+
+struct ut_data {
+    uint64_t data;                 // 数据
+    struct ut_metric enqueue_time; // 入队时间
+};
+
+struct ut_exit_data {
+    pthread_t thread_id;
+    uint64_t run_times;
+    uint64_t ok_cnt;
+    uint64_t latency_ns;        // 仅消费者有效，数据停留的时延
+    uint64_t op_ok_latency_ns;  // 成功操作的时延
+    uint64_t op_err_latency_ns; // 操作失败的时延， 如满队入队，空队出队
+    uint64_t data_error_cnt;    // 发生过至少一次数据不一致的次数
+    size_t simple_data_cnt;
+    struct ut_thread_arg *arg;
+    struct ut_metric metric_start;
+    struct ut_metric metric_end;
+    struct ut_data **simple_data;
+};
+
+struct ut_merge_data {
+    uint64_t run_times;
+    uint64_t ok_cnt;
+    uint64_t latency_ns;        // 仅消费者有效，数据停留的时延
+    uint64_t op_ok_latency_ns;  // 成功操作的时延
+    uint64_t op_err_latency_ns; // 操作失败的时延， 如满队入队，空队出队
+    uint64_t data_error_cnt;    // 发生过至少一次数据不一致的次数
+    struct ut_metric use_time;
+};
+
+struct ut_merge_s {
+    struct ut_merge_data producer;
+    struct ut_merge_data consumer;
+};
+
+enum ut_data_type {
+    UT_DATA_MAGIC_TYPE,
+    UT_DATA_UINTPTR_TYPE,
+};
+extern struct ut_metric ut_clock_time_get();
+extern struct ut_metric ut_clock_time_sub(struct ut_metric now, struct ut_metric last);
+extern int ut_load_config(const char *config, const char *ring_type, uint32_t burst_cnt, struct ut_cfg *cfg);
+extern enum ut_workload ut_workload_str2enum(const char *workload);
+extern enum ut_ring_type ut_ring_type_str2enum(const char *ring_type);
+extern bool ut_clock_time_is_zero(struct ut_metric *metric);
+extern bool ut_timespec_is_after(const struct timespec *a, const struct timespec *b);
+extern char *ut_ring_type_enum2str(enum ut_ring_type ring_type);
+extern uint64_t ut_clock_time_to_ns(struct ut_metric *metric);
+extern double ut_clock_time_to_double(struct ut_metric *metric);
+extern void *ut_malloc(enum ut_module module, size_t size);
+extern void ut_free(enum ut_module module, void *ptr);
+extern void ut_memory_counter_print();
+extern void ut_memory_counter_clear();
+extern bool ut_malloc_free_equal();
+extern int ut_setaffinity(int core_id);
+extern void *ut_malloc_def_callback(int32_t socket_id __attribute__((unused)), size_t size);
+extern void ut_free_def_callback(void *ptr, size_t size __attribute__((unused)));
+extern void ut_threads_destory(struct ut_info_s *info, pthread_t *threads);
+extern pthread_t *ut_threads_create(struct ut_info_s *info, struct ut_queue *q);
+extern void ut_one_thread_create(struct ut_info_s *info, struct ut_queue *q, enum ut_thread_type ttype, int core, uint16_t thread_id, pthread_t *thread);
+extern void ut_wait_all_threads_exit(struct ut_info_s *info, uint32_t thread_cnt, pthread_t *threads, struct ut_exit_data **exit_data);
+extern void *ut_thread_consumer_start(void *arg);
+extern void *ut_thread_producer_start(void *arg);
+extern uint32_t ut_exec_dequeue(struct ut_queue *q, struct ut_data **data, size_t burst_cnt, struct ut_metric *op_use_diff);
+extern uint32_t ut_exec_enqueue(struct ut_queue *q, struct ut_data **data, size_t burst_cnt, struct ut_metric *op_use_diff, uint16_t thread_idx);
+extern void ut_exit_data_destory(struct ut_exit_data *data);
+extern struct ut_exit_data *ut_exit_data_create(struct ut_thread_arg *t_arg);
+extern void ut_wait_all_threads_ready(struct ut_ctl *ctl);
+extern void ut_queue_destory(struct ut_queue *q);
+extern int ut_queue_init_bbq(struct ut_cfg *cfg, struct ut_queue *q);
+extern void ut_merge_all_data(struct ut_exit_data **exit_data, uint32_t thread_cnt, struct ut_merge_s *merge);
+extern uint64_t bbq_head_idx(struct bbq *q, uint64_t x);
+extern uint64_t bbq_cur_off(struct bbq *q, uint64_t x);
+extern uint64_t bbq_head_vsn(struct bbq *q, uint64_t x);
+extern uint64_t bbq_cur_vsn(struct bbq *q, uint64_t x);
+extern struct ut_data **ut_data_create(size_t cnt, enum ut_data_type);
+extern void ut_data_destory(struct ut_data **data, size_t cnt);
+extern bool bbq_debug_check_array_bounds(struct bbq *q);
+extern struct bbq *bbq_create_elem_with_bnbs(const char *name, uint32_t bn,
+                                             uint32_t bs, size_t obj_size,
+                                             int socket_id, uint32_t flags,
+                                             bbq_malloc_f malloc_f, bbq_free_f free_f);
+extern struct bbq *bbq_create_with_bnbs(const char *name, uint32_t bn, uint32_t bs,
+                                        int socket_id, uint32_t flags,
+                                        bbq_malloc_f malloc_f, bbq_free_f free_f);
\ No newline at end of file