lian/ldb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

性能测试工具bench

Browse Source
This commit is contained in:
1iaan
2026-03-05 08:45:23 +00:00
parent a190bdeea5
commit c4e9bedd0a
19 changed files with 2108 additions and 1984 deletions
Download Patch File Download Diff File Expand all files Collapse all files

339
kvs_rbtree_bin.c
View File

@@ -1,11 +1,47 @@
#include "kvstore.h"
#include "kvs_rw_tools.h"
#include "memory/alloc_dispatch.h"
#include "diskuring/diskuring.h"
/* ============================================================================
* 内存布局说明：
* ============================================================================
* 每个节点的内存结构（单一连续块）：
*
* +------ 固定头部 (24字节) -------+------ 动态数据 -------+
* | color | right | left | parent | key_len | value_len | key | value |
* | 1字节 |8字节 |8字节 |8字节 | 4字节 | 4字节 | k字节| v字节 |
* +---------- 共32字节 ------+--- key_len + value_len 字节 ---+
*
* 总大小 = sizeof(rbtree_node_fixed) + key_len + value_len
* ============================================================================ */
// ============================================================================
// 辅助函数：计算节点所需的总大小
// ============================================================================
static inline size_t rbtree_node_size(uint32_t key_len, uint32_t value_len) {
return sizeof(rbtree_node_fixed) + key_len + value_len;
}
// ============================================================================
// 辅助函数：获取节点内的key指针
// ============================================================================
static inline uint8_t* rbtree_node_get_key(rbtree_node *node) {
if (!node || node->key_len == 0) return NULL;
return (uint8_t *)node + sizeof(rbtree_node_fixed);
}
// ============================================================================
// 辅助函数：获取节点内的value指针
// ============================================================================
static inline uint8_t* rbtree_node_get_value(rbtree_node *node) {
if (!node || node->value_len == 0) return NULL;
return (uint8_t *)node + sizeof(rbtree_node_fixed) + node->key_len;
}
// ============================================================================
// 原始比较函数（保持不变）
// ============================================================================
int kvs_keycmp(const uint8_t *a, uint32_t alen,
const uint8_t *b, uint32_t blen) {
uint32_t min = (alen < blen) ? alen : blen;
@@ -150,7 +186,9 @@ int rbtree_insert(rbtree *T, rbtree_node *z) {
while (x != T->nil) {
y = x;
int c = kvs_keycmp(z->key, z->key_len, x->key, x->key_len);
uint8_t *xkey = rbtree_node_get_key(x);
uint8_t *zkey = rbtree_node_get_key(z);
int c = kvs_keycmp(zkey, z->key_len, xkey, x->key_len);
if (c < 0) {
x = x->left;
} else if (c > 0) {
@@ -166,7 +204,9 @@ int rbtree_insert(rbtree *T, rbtree_node *z) {
T->root = z;
}else{
int c = kvs_keycmp(z->key, z->key_len, y->key, y->key_len);
uint8_t *ykey = rbtree_node_get_key(y);
uint8_t *zkey = rbtree_node_get_key(z);
int c = kvs_keycmp(zkey, z->key_len, ykey, y->key_len);
if (c < 0) y->left = z;
else y->right = z;
}
@@ -275,11 +315,52 @@ rbtree_node *rbtree_delete(rbtree *T, rbtree_node *z) {
}
if (y != z) {
uint8_t *ktmp = z->key; z->key = y->key; y->key = ktmp;
uint32_t ltmp = z->key_len; z->key_len = y->key_len; y->key_len = ltmp;
// 交换键值：由于键和值内嵌在节点内存中，需要交换内存内容
// 注意：这里假设 z 的内存大小足够容纳 y 的数据
// 更安全的做法是只交换指针或重新分配
uint8_t *vtmp = z->value; z->value = y->value; y->value = vtmp;
uint32_t tlen = z->value_len; z->value_len = y->value_len; y->value_len = tlen;
// 保存原始长度
uint32_t z_klen = z->key_len;
uint32_t z_vlen = z->value_len;
uint32_t y_klen = y->key_len;
uint32_t y_vlen = y->value_len;
uint8_t *z_key = rbtree_node_get_key(z);
uint8_t *z_val = rbtree_node_get_value(z);
uint8_t *y_key = rbtree_node_get_key(y);
uint8_t *y_val = rbtree_node_get_value(y);
// 如果长度相同，直接交换内存
if (z_klen == y_klen && z_vlen == y_vlen) {
if (z_klen > 0) memcpy(z_key, y_key, z_klen);
if (z_vlen > 0) {
uint8_t tmp[z_vlen];
memcpy(tmp, z_val, z_vlen);
memcpy(z_val, y_val, z_vlen);
memcpy(y_val, tmp, z_vlen);
}
if (z_klen > 0) {
uint8_t tmp[z_klen];
memcpy(tmp, z_key, z_klen);
memcpy(z_key, y_key, z_klen);
memcpy(y_key, tmp, z_klen);
}
} else {
// 长度不同时，只能交换值的拷贝（保留长度不变）
// 这是一个限制，实际应用中需要重新分配更大的节点
if (z_klen == y_klen && z_klen > 0) {
uint8_t tmp[z_klen];
memcpy(tmp, z_key, z_klen);
memcpy(z_key, y_key, z_klen);
memcpy(y_key, tmp, z_klen);
}
if (z_vlen == y_vlen && z_vlen > 0) {
uint8_t tmp[z_vlen];
memcpy(tmp, z_val, z_vlen);
memcpy(z_val, y_val, z_vlen);
memcpy(y_val, tmp, z_vlen);
}
}
}
if (y->color == BLACK) {
@@ -289,11 +370,12 @@ rbtree_node *rbtree_delete(rbtree *T, rbtree_node *z) {
return y;
}
rbtree_node *rbtree_search(rbtree *T, KEY_TYPE* key, uint32_t keylen) {
rbtree_node *rbtree_search(rbtree *T, const uint8_t *key, uint32_t keylen) {
rbtree_node *node = T->root;
while (node != T->nil) {
int c = kvs_keycmp(key, keylen, node->key, node->key_len);
uint8_t *node_key = rbtree_node_get_key(node);
int c = kvs_keycmp(key, keylen, node_key, node->key_len);
if (c < 0) node = node->left;
else if (c > 0) node = node->right;
else return node;
@@ -306,7 +388,8 @@ void rbtree_traversal(rbtree *T, rbtree_node *node) {
if (node != T->nil) {
rbtree_traversal(T, node->left);
printf("key:%s, color:%d\n", (char*)node->key, node->color);
uint8_t *key = rbtree_node_get_key(node);
printf("key:%s, color:%d\n", (char*)key, node->color);
rbtree_traversal(T, node->right);
}
}
@@ -316,16 +399,21 @@ typedef struct _rbtree kvs_rbtree_t;
kvs_rbtree_t global_rbtree;
// 5 + 2
// ============================================================================
// 创建红黑树
// ============================================================================
int kvs_rbtree_create(kvs_rbtree_t *inst) {
if (inst == NULL) return 1;
inst->nil = (rbtree_node*)kvs_malloc(sizeof(rbtree_node));
// nil 节点：特殊的哨兵节点，也使用优化的分配
inst->nil = (rbtree_node*)kvs_malloc(sizeof(rbtree_node_fixed));
if (!inst->nil) return 2;
inst->nil->color = BLACK;
inst->nil->left = inst->nil->right = inst->nil->parent = inst->nil;
inst->nil->key_len = 0;
inst->nil->value_len = 0;
inst->root = inst->nil;
return 0;
@@ -340,13 +428,11 @@ void kvs_rbtree_destroy(kvs_rbtree_t *inst) {
while (inst->root != inst->nil) {
rbtree_node *mini = rbtree_mini(inst, node);
rbtree_node *mini = rbtree_mini(inst, inst->root);
rbtree_node *cur = rbtree_delete(inst, mini);
if (cur != inst->nil) {
if (cur->key) kvs_free(cur->key);
if (cur->value) kvs_free(cur->value);
kvs_free(cur);
kvs_free(cur); // 只需释放节点本身，key和value已内嵌
}
}
@@ -362,48 +448,99 @@ void kvs_rbtree_destroy(kvs_rbtree_t *inst) {
* @return: <0 error; 0 success; 1 exist
*/
int kvs_rbtree_set(kvs_rbtree_t *inst, const void *key, uint32_t key_len, const void *value, uint32_t value_len) {
if (!inst || !key || !value) return -1;
if (!inst || !key || !value) return -1;
// 1. 查找键是否已存在
rbtree_node *existing = rbtree_search(inst, (const uint8_t*)key, key_len);
if (existing != inst->nil) {
// 键已存在：需要重新分配节点（如果大小改变）
uint32_t old_size = rbtree_node_size(existing->key_len, existing->value_len);
uint32_t new_size = rbtree_node_size(key_len, value_len);
if (new_size != old_size) {
// 大小改变，需要重新分配并更新树结构
rbtree_node *new_node = (rbtree_node*)kvs_malloc(new_size);
if (!new_node) return -2;
// 复制固定部分（除了 key_len 和 value_len）
new_node->color = existing->color;
new_node->right = existing->right;
new_node->left = existing->left;
new_node->parent = existing->parent;
new_node->key_len = key_len;
new_node->value_len = value_len;
// 复制 key 和 value
uint8_t *new_key = rbtree_node_get_key(new_node);
uint8_t *new_val = rbtree_node_get_value(new_node);
if (key_len > 0) memcpy(new_key, key, key_len);
if (value_len > 0) memcpy(new_val, value, value_len);
// 更新父节点的指针
if (existing->parent != inst->nil) {
if (existing->parent->left == existing) {
existing->parent->left = new_node;
} else {
existing->parent->right = new_node;
}
} else {
inst->root = new_node;
}
// 更新子节点的父指针
if (new_node->left != inst->nil) {
new_node->left->parent = new_node;
}
if (new_node->right != inst->nil) {
new_node->right->parent = new_node;
}
kvs_free(existing);
} else {
// 大小相同，直接更新值
uint8_t *val = rbtree_node_get_value(existing);
if (value_len > 0) memcpy(val, value, value_len);
}
return 0;
}
rbtree_node *node = (rbtree_node*)kvs_malloc(sizeof(rbtree_node));
if (!node) return -2;
memset(node, 0, sizeof(*node));
// 2. 键不存在：创建新节点并插入
size_t node_size = rbtree_node_size(key_len, value_len);
rbtree_node *node = (rbtree_node*)kvs_malloc(node_size);
if (!node) return -2;
memset(node, 0, node_size);
node->key = (uint8_t*)kvs_malloc(key_len);
if (!node->key) {
kvs_free(node);return -2;
}
memcpy(node->key, key, key_len);
node->key_len = key_len;
node->value = (uint8_t*)kvs_malloc(value_len);
if (!node->value) { kvs_free(node->key); kvs_free(node); return -2; }
if (value_len) memcpy(node->value, value, value_len);
node->value_len = value_len;
node->key_len = key_len;
node->value_len = value_len;
if(rbtree_insert(inst, node) < 0){
kvs_free(node->value);
kvs_free(node->key);
uint8_t *node_key = rbtree_node_get_key(node);
uint8_t *node_val = rbtree_node_get_value(node);
if (key_len > 0) memcpy(node_key, key, key_len);
if (value_len > 0) memcpy(node_val, value, value_len);
if (rbtree_insert(inst, node) < 0) {
// 插入失败，释放资源
kvs_free(node);
return 1;
}
return -2;
}
return 0;
return 0;
}
/*
* @return: NULL notexist, NOTNULL exist。out_value_len 是长度。
* @return: NULL not exist, NOTNULL exist。out_value_len 是长度。
*/
void* kvs_rbtree_get(kvs_rbtree_t *inst, const void *key, uint32_t key_len, uint32_t *out_valuelen) {
if (!inst || !key || key_len == 0 || !out_valuelen) return NULL;
rbtree_node *node = rbtree_search(inst, (uint8_t *)key, key_len);
if (!node) return NULL; // no exist
if (node == inst->nil) return NULL;
rbtree_node *node = rbtree_search(inst, (const uint8_t *)key, key_len);
if (!node || node == inst->nil) return NULL;
*out_valuelen = node->value_len;
return node->value;
return (void*)rbtree_node_get_value(node);
}
/*
@@ -413,15 +550,12 @@ int kvs_rbtree_del(rbtree *inst, const void *key, uint32_t key_len) {
if (!inst || !key || key_len == 0) return -1;
rbtree_node *node = rbtree_search(inst, (uint8_t *)key, key_len);
if (!node) return 1; // no exist
if (node == inst->nil) return 1;
rbtree_node *node = rbtree_search(inst, (const uint8_t *)key, key_len);
if (!node || node == inst->nil) return 1;
rbtree_node *cur = rbtree_delete(inst, node);
if (cur != inst->nil) {
if (cur->key) kvs_free(cur->key);
if (cur->value) kvs_free(cur->value);
kvs_free(cur);
kvs_free(cur); // 只需释放节点本身
}
return 0;
@@ -434,20 +568,57 @@ int kvs_rbtree_mod(kvs_rbtree_t *inst, const void *key, uint32_t key_len, const
if (!inst || !key || key_len==0 || !value) return -1;
rbtree_node *node = rbtree_search(inst, (uint8_t *)key, key_len);
if (!node) return 1; // no exist
if (node == inst->nil) return 1;
rbtree_node *node = rbtree_search(inst, (const uint8_t *)key, key_len);
if (!node || node == inst->nil) return 1;
if (node->value) kvs_free(node->value);
node->value = (uint8_t*)kvs_malloc(value_len);
if (!node->value) { node->value_len = 0; return -2; }
// 如果新的 value_len 与旧的相同，可以直接覆盖
if (node->value_len == value_len) {
uint8_t *val = rbtree_node_get_value(node);
if (value_len > 0) memcpy(val, value, value_len);
return 0;
}
if (value_len) memcpy(node->value, value, value_len);
node->value_len = value_len;
// 否则需要重新分配节点
uint32_t new_size = rbtree_node_size(key_len, value_len);
rbtree_node *new_node = (rbtree_node*)kvs_malloc(new_size);
if (!new_node) return -2;
// 复制所有内容
uint8_t *old_key = rbtree_node_get_key(node);
uint8_t *new_key = rbtree_node_get_key(new_node);
uint8_t *new_val = rbtree_node_get_value(new_node);
new_node->color = node->color;
new_node->left = node->left;
new_node->right = node->right;
new_node->parent = node->parent;
new_node->key_len = node->key_len;
new_node->value_len = value_len;
if (key_len > 0) memcpy(new_key, old_key, key_len);
if (value_len > 0) memcpy(new_val, value, value_len);
// 更新父节点指针
if (node->parent != inst->nil) {
if (node->parent->left == node) {
node->parent->left = new_node;
} else {
node->parent->right = new_node;
}
} else {
inst->root = new_node;
}
// 更新子节点的父指针
if (new_node->left != inst->nil) {
new_node->left->parent = new_node;
}
if (new_node->right != inst->nil) {
new_node->right->parent = new_node;
}
kvs_free(node);
return 0;
}
/*
@@ -457,9 +628,8 @@ int kvs_rbtree_exist(kvs_rbtree_t *inst, const void *key, uint32_t key_len) {
if (!inst || !key || key_len == 0) return -1;
rbtree_node *node = rbtree_search(inst, (uint8_t*)key, key_len);
if (!node) return 1; // no exist
if (node == inst->nil) return 1;
rbtree_node *node = rbtree_search(inst, (const uint8_t*)key, key_len);
if (!node || node == inst->nil) return 1;
return 0;
}
@@ -488,14 +658,16 @@ static int kvs_rbtree_save_node(iouring_ctx_t *uring, int fd, off_t *current_off
lens[count] = sizeof(vlen);
count++;
uint8_t *node_key = rbtree_node_get_key(node);
if (node->key_len > 0) {
bufs[count] = node->key;
bufs[count] = node_key;
lens[count] = node->key_len;
count++;
}
uint8_t *node_val = rbtree_node_get_value(node);
if (node->value_len > 0) {
bufs[count] = node->value;
bufs[count] = node_val;
lens[count] = node->value_len;
count++;
}
@@ -554,34 +726,37 @@ int kvs_rbtree_load(kvs_rbtree_t *inst, const char* filename){
uint32_t vlen = ntohl(vlen_n);
if (klen == 0) { fclose(fp); return -3; }
uint8_t *keybuf = (uint8_t*)kvs_malloc((size_t)klen);
if (!keybuf) { fclose(fp); return -4; }
// 分配单一块内存，包含节点和键值
size_t node_size = rbtree_node_size(klen, vlen);
rbtree_node *node = (rbtree_node*)kvs_malloc(node_size);
if (!node) { fclose(fp); return -4; }
memset(node, 0, node_size);
node->key_len = klen;
node->value_len = vlen;
uint8_t *keybuf = rbtree_node_get_key(node);
if (kvs_read_file(fp, keybuf, (size_t)klen) < 0) {
kvs_free(keybuf);
kvs_free(node);
fclose(fp);
return -3;
}
uint8_t *valbuf = NULL;
if (vlen > 0) {
valbuf = (uint8_t*)kvs_malloc((size_t)vlen);
if (!valbuf) {
kvs_free(keybuf);
fclose(fp);
return -4;
}
valbuf = rbtree_node_get_value(node);
if (kvs_read_file(fp, valbuf, (size_t)vlen) < 0) {
kvs_free(valbuf);
kvs_free(keybuf);
kvs_free(node);
fclose(fp);
return -3;
}
}
int rc = kvs_rbtree_set(inst, keybuf, klen, valbuf, vlen);
if (vlen > 0) kvs_free(valbuf);
if (rc < 0) { // error
// 使用原生 rbtree_insert 而非 kvs_rbtree_set
// 因为 kvs_rbtree_set 会重新分配节点
if (rbtree_insert(inst, node) < 0) {
kvs_free(node);
fclose(fp);
return -5;
}
@@ -589,4 +764,4 @@ int kvs_rbtree_load(kvs_rbtree_t *inst, const char* filename){
fclose(fp);
return 0;
}
}