summaryrefslogtreecommitdiff
path: root/bbq/unittest
diff options
context:
space:
mode:
Diffstat (limited to 'bbq/unittest')
-rw-r--r--bbq/unittest/CMakeLists.txt25
-rw-r--r--bbq/unittest/ut_bbq.cc1189
-rw-r--r--bbq/unittest/ut_bbq_func.c615
-rw-r--r--bbq/unittest/ut_bbq_func.h302
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
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-30 13:48:33 +0000