From cb0134a8526636d38042519d320f817295c44954 Mon Sep 17 00:00:00 2001 From: 1iaan Date: Tue, 6 Jan 2026 21:05:48 +0800 Subject: [PATCH] =?UTF-8?q?=E6=8F=90=E4=BE=9Barray=E5=92=8Chashtable?= =?UTF-8?q?=E7=9A=84=E5=AD=98=E5=82=A8=E5=BC=95=E6=93=8E=E5=B1=82=E7=9A=84?= =?UTF-8?q?=E4=BA=8C=E8=BF=9B=E5=88=B6=E5=AE=89=E5=85=A8=E6=94=AF=E6=8C=81?= =?UTF-8?q?=EF=BC=8C=E6=8A=8A=E5=85=A5=E5=8F=A3=E5=87=BD=E6=95=B0=E4=BF=AE?= =?UTF-8?q?=E6=94=B9=E4=B8=BA=E6=8E=A5=E6=94=B6=E5=8F=82=E6=95=B0=E9=95=BF?= =?UTF-8?q?=E5=BA=A6=EF=BC=8C=E5=B0=86strlen=E3=80=81strcmp=E3=80=81strcpy?= =?UTF-8?q?=E6=9B=BF=E6=8D=A2=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Makefile | 3 +- kvs_array.c | 149 +++++++++++++++++++++- kvs_hash.c | 4 +- kvs_hash.o | Bin 0 -> 13600 bytes kvs_hash_bin.c | 300 +++++++++++++++++++++++++++++++++++++++++++++ kvs_rbtree.c | 2 +- kvs_rw_tools.c | 187 ++++++++++++++++++++++++++++ kvs_rw_tools.h | 26 +++- kvstore.c | 196 ++--------------------------- kvstore.h | 80 ++++++++++-- test/test_client.h | 3 +- test/testcase.c | 40 +++--- 12 files changed, 767 insertions(+), 223 deletions(-) create mode 100644 kvs_hash.o create mode 100755 kvs_hash_bin.c diff --git a/Makefile b/Makefile index a9fe9fb..789e60b 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,8 @@ CC = gcc FLAGS = -I ./NtyCo/core/ -L ./NtyCo/ -lntyco -lpthread -luring -ldl -SRCS = kvstore.c ntyco.c proactor.c reactor.c kvs_array.c kvs_rbtree.c kvs_hash.c kvs_rw_tools.c +# SRCS = kvstore.c ntyco.c proactor.c reactor.c kvs_array.c kvs_rbtree.c kvs_hash.c kvs_rw_tools.c +SRCS = kvstore.c ntyco.c proactor.c reactor.c kvs_array.c kvs_rbtree.c kvs_hash_bin.c kvs_rw_tools.c TESTCASE_SRCS = testcase.c TARGET = kvstore SUBDIR = ./NtyCo/ diff --git a/kvs_array.c b/kvs_array.c index f8f9664..0c483ee 100644 --- a/kvs_array.c +++ b/kvs_array.c @@ -19,12 +19,13 @@ int kvs_array_create(kvs_array_t *inst) { return -1; } + memset(inst->table, 0, (size_t)KVS_ARRAY_SIZE * sizeof(kvs_array_item_t)); inst->total = 0; return 0; } -void kvs_array_destory(kvs_array_t *inst) { +void kvs_array_destroy(kvs_array_t *inst) { if (!inst) return ; @@ -35,6 +36,151 @@ void kvs_array_destory(kvs_array_t *inst) { } +#if BIN_SAFE +/** + * return: ==-2 not exist, == -1 error, >= 0 exist idx + */ +int kvs_array_find_index(kvs_array_t *inst, const void *key, size_t key_len) { + if (!inst || !inst->table || !key) return -1; + for (int i = 0; i < inst->total; i++) { + kvs_array_item_t *it = &inst->table[i]; + if (!it->key) continue; + if (it->key_len == key_len && memcmp(it->key, key, key_len) == 0) { + return i; + } + } + return -2; // not found +} + +/* + * return: <0 error; 0 success; 1 exist + */ +int kvs_array_set_bin(kvs_array_t *inst, + const void *key, size_t key_len, + const void *value, size_t value_len) { + if (!inst || !inst->table || !key || key_len == 0 || !value) return -1; + if (inst->total >= KVS_ARRAY_SIZE) return -1; + + int idx = kvs_array_find_index(inst, key, key_len); + // -2 not exist + if (idx >= 0) return 1; // exist + if (idx == -1) return -1; // error + + uint8_t *kcopy = (uint8_t *)kvs_malloc(key_len); + if (!kcopy) return -2; + memcpy(kcopy, key, key_len); + + uint8_t *vcopy = NULL; + if (value_len > 0) { + vcopy = (uint8_t *)kvs_malloc(value_len); + if (!vcopy) { + kvs_free(kcopy); + return -2; + } + memcpy(vcopy, value, value_len); + } else { + // 允许空 value（长度0），value 指针置 NULL + vcopy = NULL; + } + + int i = 0; + for (i = 0;i < inst->total;i ++) { + if (inst->table[i].key == NULL) { + + inst->table[i].key = kcopy; + inst->table[i].key_len = key_len; + inst->table[i].value = vcopy; + inst->table[i].value_len = value_len; + inst->total ++; + + return 0; + } + } + + if (i == inst->total && i < KVS_ARRAY_SIZE) { + + inst->table[i].key = kcopy; + inst->table[i].key_len = key_len; + inst->table[i].value = vcopy; + inst->table[i].value_len = value_len; + inst->total ++; + } + + return 0; +} + +void *kvs_array_get_bin(kvs_array_t *inst, + const void *key, size_t key_len, + size_t *out_value_len) { + if (out_value_len) *out_value_len = 0; + if (!inst || !inst->table || !key || key_len == 0) return NULL; + + int idx = kvs_array_find_index(inst, key, key_len); + if (idx < 0) return NULL; + + kvs_array_item_t *it = &inst->table[idx]; + if (out_value_len) *out_value_len = it->value_len; + return it->value; // 注意：由 store 持有 +} + +int kvs_array_del_bin(kvs_array_t *inst, const void *key, size_t key_len) { + if (!inst || !inst->table || !key || key_len == 0) return -1; + + int idx = kvs_array_find_index(inst, key, key_len); + if (idx == -2) return 1; // not exist + if (idx < 0) return -1; + + kvs_array_item_t *it = &inst->table[idx]; + if (it->key) kvs_free(it->key); + if (it->value) kvs_free(it->value); + + // 用末尾元素填洞，保证 total 连续，避免 “total 只增不减” 问题 + int last = inst->total - 1; + if (idx != last) { + inst->table[idx] = inst->table[last]; + } + + // 清理末尾（已被移动或删除） + memset(&inst->table[last], 0, sizeof(kvs_array_item_t)); + inst->total--; + + return 0; +} + +int kvs_array_mod_bin(kvs_array_t *inst, + const void *key, size_t key_len, + const void *value, size_t value_len) { + if (!inst || !inst->table || !key || key_len == 0 || !value) return -1; + + int idx = kvs_array_find_index(inst, key, key_len); + if (idx == -2) return 1; // not exist + if (idx < 0) return -1; + + kvs_array_item_t *it = &inst->table[idx]; + + uint8_t *vcopy = NULL; + if (value_len > 0) { + vcopy = (uint8_t *)kvs_malloc(value_len); + if (!vcopy) return -2; + memcpy(vcopy, value, value_len); + } else { + vcopy = NULL; + } + + if (it->value) kvs_free(it->value); + it->value = vcopy; + it->value_len = value_len; + + return 0; +} + +int kvs_array_exist_bin(kvs_array_t *inst, const void *key, size_t key_len) { + if (!inst || !inst->table || !key || key_len == 0) return -1; + int idx = kvs_array_find_index(inst, key, key_len); + return (idx >= 0) ? 0 : 1; +} + +#else /* * @return: <0, error; =0, success; >0, exist */ @@ -187,3 +333,4 @@ int kvs_array_exist(kvs_array_t *inst, char *key) { } +#endif \ No newline at end of file diff --git a/kvs_hash.c b/kvs_hash.c index ea31eba..2dc83cb 100755 --- a/kvs_hash.c +++ b/kvs_hash.c @@ -84,7 +84,7 @@ int kvs_hash_create(kvs_hash_t *hash) { } // -void kvs_hash_destory(kvs_hash_t *hash) { +void kvs_hash_destroy(kvs_hash_t *hash) { if (!hash) return; @@ -275,7 +275,7 @@ int main() { ret = kvs_hash_exist(&hash, "Teacher1"); printf("Exist Teacher1 ret : %d\n", ret); - kvs_hash_destory(&hash); + kvs_hash_destroy(&hash); return 0; } diff --git a/kvs_hash.o b/kvs_hash.o new file mode 100644 index 0000000000000000000000000000000000000000..1c85d5c303b860335c7b1332b03ff31c6730b383 GIT binary patch literal 13600 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 NN*q&ybk)+q{s+7WBs%~A literal 0 HcmV?d00001 diff --git a/kvs_hash_bin.c b/kvs_hash_bin.c new file mode 100755 index 0000000..979ad03 --- /dev/null +++ b/kvs_hash_bin.c @@ -0,0 +1,300 @@ + + + +#include +#include +#include +#include + + +#include "kvstore.h" + + +// Key, Value --> +// Modify + + + +kvs_hash_t global_hash; + + +//Connection +// 'C' + 'o' + 'n' +static int _hash(const void *key, size_t key_len, int size) { + if (!key || size <= 0) return -1; + + const uint8_t *p = (const uint8_t *)key; + uint32_t sum = 0; + for (size_t i = 0; i < key_len; i++) { + sum += p[i]; + } + return sum % size; +} + +static int _key_equal(const hashnode_t *node, const void *key, size_t key_len) { + if (!node || !key) return 0; + if (!node->key) return 0; + if (node->key_len != key_len) return 0; + return memcmp(node->key, key, key_len) == 0; +} + +static hashnode_t *_create_node(const void *key, size_t key_len, + const void *value, size_t value_len) { + hashnode_t *node = (hashnode_t*)kvs_malloc(sizeof(hashnode_t)); + if (!node) return NULL; + memset(node, 0, sizeof(*node)); + + if (key_len > 0) { + node->key = (uint8_t*)kvs_malloc(key_len); + if (!node->key) { kvs_free(node); return NULL; } + memcpy(node->key, key, key_len); + node->key_len = key_len; + } + + if (value_len > 0) { + node->value = (uint8_t*)kvs_malloc(value_len); + if (!node->value) { + kvs_free(node->key); + kvs_free(node); + return NULL; + } + memcpy(node->value, value, value_len); + node->value_len = value_len; + } else { + node->value = NULL; + node->value_len = 0; + } + + node->next = NULL; + return node; +} + + +// +int kvs_hash_create(kvs_hash_t *hash) { + if (!hash) return -1; + + hash->nodes = (hashnode_t**)kvs_malloc(sizeof(hashnode_t*) * MAX_TABLE_SIZE); + if (!hash->nodes) return -1; + + memset(hash->nodes, 0, sizeof(hashnode_t*) * MAX_TABLE_SIZE); + hash->max_slots = MAX_TABLE_SIZE; + hash->count = 0; + return 0; +} + +// +void kvs_hash_destroy(kvs_hash_t *hash) { + if (!hash || !hash->nodes) return; + + for (int i = 0; i < hash->max_slots; i++) { + hashnode_t *node = hash->nodes[i]; + while (node != NULL) { + hashnode_t *tmp = node; + node = node->next; + + if (tmp->key) kvs_free(tmp->key); + if (tmp->value) kvs_free(tmp->value); + kvs_free(tmp); + } + hash->nodes[i] = NULL; + } + + kvs_free(hash->nodes); + hash->nodes = NULL; + hash->max_slots = 0; + hash->count = 0; +} + + +// 5 + 2 + +// mp +/* + * @return: <0 error; =0 success; >0 exist + */ +int kvs_hash_set_bin(kvs_hash_t *hash, const void *key, size_t key_len, const void *value, size_t value_len) { + if (!hash || !hash->nodes || !key || key_len == 0 || !value) return -1; + + int idx = _hash(key, key_len, MAX_TABLE_SIZE); + if (idx < 0) return -1; + + hashnode_t *node = hash->nodes[idx]; + while (node != NULL) { + if (_key_equal(node, key, key_len)) { // exist + return 1; + } + node = node->next; + } + + hashnode_t *new_node = _create_node(key, key_len, value, value_len); + if (!new_node) return -2; + + new_node->next = hash->nodes[idx]; + hash->nodes[idx] = new_node; + hash->count ++; + + return 0; +} + +/* + * get 返回：value 指针（由 hash 持有），并通过 out_value_len 返回长度 + */ +void *kvs_hash_get_bin(kvs_hash_t *hash, const void *key, size_t key_len, size_t *out_value_len) { + if (!hash || !hash->nodes || !key || key_len == 0 || !out_value_len) return NULL; + *out_value_len = 0; + + int idx = _hash(key, key_len, MAX_TABLE_SIZE); + if (idx < 0) return NULL; + + hashnode_t *node = hash->nodes[idx]; + + while (node != NULL) { + + if (_key_equal(node, key, key_len)) { + *out_value_len = node->value_len; + return node->value; + } + + node = node->next; + } + + return NULL; + +} + +/* + * @return <0 error; =0 success; >0 no exist + */ +int kvs_hash_mod_bin(kvs_hash_t *hash, const void *key, size_t key_len, const void *value, size_t value_len) { + + if (!hash || !hash->nodes || !key || key_len == 0 || !value) return -1; + + int idx = _hash(key, key_len, MAX_TABLE_SIZE); + if (idx < 0) return -1; + + hashnode_t *node = hash->nodes[idx]; + + while (node != NULL) { + + if (_key_equal(node, key, key_len)) { + break; + } + + node = node->next; + } + + if (node == NULL) { + return 1; + } + + // node --> + if (node->value) kvs_free(node->value); + node->value = NULL; + node->value_len = 0; + + if (value_len > 0) { + uint8_t *vcopy = (uint8_t*)kvs_malloc(value_len); + if (!vcopy) return -2; + memcpy(vcopy, value, value_len); + node->value = vcopy; + node->value_len = value_len; + } + return 0; +} + +int kvs_hash_count(kvs_hash_t *hash) { + return hash->count; +} + +/* + * @return 0 success; <0 error/noexist + */ +int kvs_hash_del_bin(kvs_hash_t *hash, const void *key, size_t key_len) { + if (!hash || !key || key_len == 0) return -2; + + int idx = _hash(key, key_len, MAX_TABLE_SIZE); + if (idx < 0) return -2; + + hashnode_t *head = hash->nodes[idx]; + if (head == NULL) return -1; // noexist + + // head node + if (_key_equal(head, key, key_len)) { + hashnode_t *tmp = head->next; + hash->nodes[idx] = tmp; + + if (head->key) kvs_free(head->key); + if (head->value) kvs_free(head->value); + kvs_free(head); + hash->count --; + + return 0; + } + + hashnode_t *cur = head; + while (cur->next != NULL) { + if (_key_equal(cur->next, key, key_len)) break; // search node + + cur = cur->next; + } + + if (cur->next == NULL) { + + return -1; + } + + hashnode_t *tmp = cur->next; + cur->next = tmp->next; + if (tmp->key) kvs_free(tmp->key); + if (tmp->value) kvs_free(tmp->value); + kvs_free(tmp); + + hash->count --; + + return 0; +} + +/* + * @return 0 exist, 1 no exist + */ +int kvs_hash_exist_bin(kvs_hash_t *hash, const void *key, size_t key_len) { + size_t vlen = 0; + void *value = kvs_hash_get_bin(hash, key, key_len, &vlen); + return value ? 0 : 1; +} + +#if 0 +int main() { + + kvs_hash_create(&hash); + + kvs_hash_set(&hash, "Teacher1", "King"); + kvs_hash_set(&hash, "Teacher2", "Darren"); + kvs_hash_set(&hash, "Teacher3", "Mark"); + kvs_hash_set(&hash, "Teacher4", "Vico"); + kvs_hash_set(&hash, "Teacher5", "Nick"); + + char *value1 = kvs_hash_get(&hash, "Teacher1"); + printf("Teacher1 : %s\n", value1); + + int ret = kvs_hash_mod(&hash, "Teacher1", "King1"); + printf("mode Teacher1 ret : %d\n", ret); + + char *value2 = kvs_hash_get(&hash, "Teacher1"); + printf("Teacher2 : %s\n", value1); + + ret = kvs_hash_del(&hash, "Teacher1"); + printf("delete Teacher1 ret : %d\n", ret); + + ret = kvs_hash_exist(&hash, "Teacher1"); + printf("Exist Teacher1 ret : %d\n", ret); + + kvs_hash_destroy(&hash); + + return 0; +} + +#endif + + diff --git a/kvs_rbtree.c b/kvs_rbtree.c index 4746b70..ac47a7c 100755 --- a/kvs_rbtree.c +++ b/kvs_rbtree.c @@ -451,7 +451,7 @@ int kvs_rbtree_create(kvs_rbtree_t *inst) { } -void kvs_rbtree_destory(kvs_rbtree_t *inst) { +void kvs_rbtree_destroy(kvs_rbtree_t *inst) { if (inst == NULL) return ; diff --git a/kvs_rw_tools.c b/kvs_rw_tools.c index a324b0d..21f7a11 100644 --- a/kvs_rw_tools.c +++ b/kvs_rw_tools.c @@ -2,6 +2,18 @@ #include "kvs_rw_tools.h" #include +#if ENABLE_ARRAY +extern kvs_array_t global_array; +#endif + +#if ENABLE_RBTREE +extern kvs_rbtree_t global_rbtree; +#endif + +#if ENABLE_HASH +extern kvs_hash_t global_hash; +#endif + int kvs_need(const uint8_t *p, const uint8_t *end, size_t n) { return (p + n <= end) ? 0 : -1; } @@ -159,6 +171,181 @@ void kvs_free_request(kvs_req_t *req) { req->argc = 0; } +/** + * 输入：req + * 输出：rsp + */ + int kvs_execute_one_cmd(const kvs_req_t *req, kvs_rsp_t *rsp_out) { + if(!req || !rsp_out) return -1; + rsp_out->op = req->op; + rsp_out->status = KVS_STATUS_ERROR; + rsp_out->data = NULL; + rsp_out->dlen = 0; + + int argc = req->argc; + int op = req->op; + kvs_arg_t *argv = req->args; + + size_t key_len = 0; + const void *key = NULL; + size_t value_len = 0; + const void *val = NULL; + + if(argc == 1){ + key_len = argv[0].len; + key = argv[0].data; + }else if(argc == 2){ + key_len = argv[0].len; + key = argv[0].data; + value_len = argv[1].len; + val = argv[1].data; + } + + // 基本参数校验（按你原有命令语义） + switch (op) { + case KVS_CMD_SET: + case KVS_CMD_MOD: + case KVS_CMD_RSET: + case KVS_CMD_RMOD: + case KVS_CMD_HSET: + case KVS_CMD_HMOD: + if (argc != 2 || !key || !val) { rsp_out->status = KVS_STATUS_BADREQ; return -1; } + break; + case KVS_CMD_GET: + case KVS_CMD_DEL: + case KVS_CMD_EXIST: + case KVS_CMD_RGET: + case KVS_CMD_RDEL: + case KVS_CMD_REXIST: + case KVS_CMD_HGET: + case KVS_CMD_HDEL: + case KVS_CMD_HEXIST: + if (argc != 1 || !key) { rsp_out->status = KVS_STATUS_BADREQ; return -1; } + break; + default: + rsp_out->status = KVS_STATUS_BADREQ; + return -1; + } + + int ret = 0; + const char *result = NULL; + + switch (op) { +#if ENABLE_ARRAY + case KVS_CMD_SET: + ret = kvs_array_set_bin(&global_array, key, key_len, val, value_len); + if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; + else if (ret == 0) rsp_out->status = KVS_STATUS_OK; + else rsp_out->status = KVS_STATUS_EXIST; + return 0; + + case KVS_CMD_GET: + result = kvs_array_get_bin(&global_array, key, key_len, &value_len); + if (!result) { rsp_out->status = KVS_STATUS_NO_EXIST; return 0; } + rsp_out->status = KVS_STATUS_OK; + rsp_out->data = result; + rsp_out->dlen = (uint32_t)value_len; + return 0; + + case KVS_CMD_DEL: + ret = kvs_array_del_bin(&global_array, key, key_len); + if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; + else if (ret == 0) rsp_out->status = KVS_STATUS_OK; + else rsp_out->status = KVS_STATUS_NO_EXIST; + return 0; + + case KVS_CMD_MOD: + ret = kvs_array_mod_bin(&global_array, key, key_len, val, value_len); + if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; + else if (ret == 0) rsp_out->status = KVS_STATUS_OK; + else rsp_out->status = KVS_STATUS_NO_EXIST; + return 0; + + case KVS_CMD_EXIST: + ret = kvs_array_exist_bin(&global_array, key, key_len); + rsp_out->status = (ret == 0) ? KVS_STATUS_EXIST : KVS_STATUS_NO_EXIST; + return 0; +#endif + +#if ENABLE_RBTREE + case KVS_CMD_RSET: + ret = kvs_rbtree_set(&global_rbtree, (char*)key, (char*)val); + if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; + else if (ret == 0) rsp_out->status = KVS_STATUS_OK; + else rsp_out->status = KVS_STATUS_EXIST; + return 0; + + case KVS_CMD_RGET: + result = kvs_rbtree_get(&global_rbtree, (char*)key); + if (!result) { rsp_out->status = KVS_STATUS_NO_EXIST; return 0; } + rsp_out->status = KVS_STATUS_OK; + rsp_out->data = result; + rsp_out->dlen = (uint32_t)strlen(result); + return 0; + + case KVS_CMD_RDEL: + ret = kvs_rbtree_del(&global_rbtree, (char*)key); + if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; + else if (ret == 0) rsp_out->status = KVS_STATUS_OK; + else rsp_out->status = KVS_STATUS_NO_EXIST; + return 0; + + case KVS_CMD_RMOD: + ret = kvs_rbtree_mod(&global_rbtree, (char*)key, (char*)val); + if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; + else if (ret == 0) rsp_out->status = KVS_STATUS_OK; + else rsp_out->status = KVS_STATUS_NO_EXIST; + return 0; + + case KVS_CMD_REXIST: + ret = kvs_rbtree_exist(&global_rbtree, (char*)key); + rsp_out->status = (ret == 0) ? KVS_STATUS_EXIST : KVS_STATUS_NO_EXIST; + return 0; +#endif + +#if ENABLE_HASH + case KVS_CMD_HSET: + ret = kvs_hash_set_bin(&global_hash, key, key_len, val, value_len); + if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; + else if (ret == 0) rsp_out->status = KVS_STATUS_OK; + else rsp_out->status = KVS_STATUS_EXIST; + return 0; + + case KVS_CMD_HGET: + result = kvs_hash_get_bin(&global_hash, key, key_len, &value_len); + if (!result) { rsp_out->status = KVS_STATUS_NO_EXIST; return 0; } + rsp_out->status = KVS_STATUS_OK; + rsp_out->data = result; + rsp_out->dlen = (uint32_t)value_len; + return 0; + + case KVS_CMD_HDEL: + ret = kvs_hash_del_bin(&global_hash, key, key_len); + if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; + else if (ret == 0) rsp_out->status = KVS_STATUS_OK; + else rsp_out->status = KVS_STATUS_NO_EXIST; + return 0; + + case KVS_CMD_HMOD: + ret = kvs_hash_mod_bin(&global_hash, key, key_len, val, value_len); + if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; + else if (ret == 0) rsp_out->status = KVS_STATUS_OK; + else rsp_out->status = KVS_STATUS_NO_EXIST; + return 0; + + case KVS_CMD_HEXIST: + ret = kvs_hash_exist_bin(&global_hash, key, key_len); + rsp_out->status = (ret == 0) ? KVS_STATUS_EXIST : KVS_STATUS_NO_EXIST; + return 0; +#endif + default: + rsp_out->status = KVS_STATUS_BADREQ; + return -1; + } + + return -1; +} + int kvs_build_one_rsp(const kvs_rsp_t *results, uint8_t *response, size_t response_cap){ if (!results || !response) return -1; diff --git a/kvs_rw_tools.h b/kvs_rw_tools.h index ef895cd..81cd003 100644 --- a/kvs_rw_tools.h +++ b/kvs_rw_tools.h @@ -25,7 +25,7 @@ int kvs_write_u32(uint8_t **pp, const uint8_t *end, uint32_t v); #define KVS_MAX_CMDS_PER_CALL 64 // 1MB #define KVS_MAX_RESPONSE (1024u * 1024u) -#define KVS_MAX_ARGC 64 +#define KVS_MAX_ARGC 4 #define KVS_MAX_ARGLEN (1024u * 1024u) #define KVS_MAX_CMD_BYTES (4u * 1024u * 1024u) @@ -37,6 +37,30 @@ enum { KVS_STATUS_BADREQ = 4 }; +enum { + KVS_CMD_START = 0, + // array + KVS_CMD_SET = KVS_CMD_START, + KVS_CMD_GET, + KVS_CMD_DEL, + KVS_CMD_MOD, + KVS_CMD_EXIST, + // rbtree + KVS_CMD_RSET, + KVS_CMD_RGET, + KVS_CMD_RDEL, + KVS_CMD_RMOD, + KVS_CMD_REXIST, + // hash + KVS_CMD_HSET, + KVS_CMD_HGET, + KVS_CMD_HDEL, + KVS_CMD_HMOD, + KVS_CMD_HEXIST, + + KVS_CMD_COUNT, +}; + typedef enum { KVS_OK = 1, KVS_NEED_MORE = 0, diff --git a/kvstore.c b/kvstore.c index a887e42..8ecd5c1 100644 --- a/kvstore.c +++ b/kvstore.c @@ -32,32 +32,6 @@ const char *command[] = { "HSET", "HGET", "HDEL", "HMOD", "HEXIST" }; -enum { - KVS_CMD_START = 0, - // array - KVS_CMD_SET = KVS_CMD_START, - KVS_CMD_GET, - KVS_CMD_DEL, - KVS_CMD_MOD, - KVS_CMD_EXIST, - // rbtree - KVS_CMD_RSET, - KVS_CMD_RGET, - KVS_CMD_RDEL, - KVS_CMD_RMOD, - KVS_CMD_REXIST, - // hash - KVS_CMD_HSET, - KVS_CMD_HGET, - KVS_CMD_HDEL, - KVS_CMD_HMOD, - KVS_CMD_HEXIST, - - KVS_CMD_COUNT, -}; - - - const char *response[] = { }; @@ -86,6 +60,10 @@ int kvs_split_token(char *msg, char *tokens[]) { // tokens[1] : Key // tokens[2] : Value +#if BIN_SAFE + + +#else int kvs_filter_protocol(char **tokens, int count, char *response) { if (tokens[0] == NULL || count == 0 || response == NULL) return -1; @@ -262,168 +240,8 @@ int kvs_filter_protocol(char **tokens, int count, char *response) { return length; } -/** - * 输入：req - * 输出：rsp - */ - int kvs_execute_one_cmd(const kvs_req_t *req, kvs_rsp_t *rsp_out) { - if(!req || !rsp_out) return -1; - rsp_out->op = req->op; - rsp_out->status = KVS_STATUS_ERROR; - rsp_out->data = NULL; - rsp_out->dlen = 0; - - int argc = req->argc; - int op = req->op; - kvs_arg_t *argv = req->args; - - const char *key = (argc >= 1) ? argv[0].data : NULL; - const char *val = (argc >= 2) ? argv[1].data : NULL; - - // 基本参数校验（按你原有命令语义） - switch (op) { - case KVS_CMD_SET: - case KVS_CMD_MOD: - case KVS_CMD_RSET: - case KVS_CMD_RMOD: - case KVS_CMD_HSET: - case KVS_CMD_HMOD: - if (argc != 2 || !key || !val) { rsp_out->status = KVS_STATUS_BADREQ; return -1; } - break; - case KVS_CMD_GET: - case KVS_CMD_DEL: - case KVS_CMD_EXIST: - case KVS_CMD_RGET: - case KVS_CMD_RDEL: - case KVS_CMD_REXIST: - case KVS_CMD_HGET: - case KVS_CMD_HDEL: - case KVS_CMD_HEXIST: - if (argc != 1 || !key) { rsp_out->status = KVS_STATUS_BADREQ; return -1; } - break; - default: - rsp_out->status = KVS_STATUS_BADREQ; - return -1; - } - - int ret = 0; - const char *result = NULL; - - switch (op) { -#if ENABLE_ARRAY - case KVS_CMD_SET: - ret = kvs_array_set(&global_array, (char*)key, (char*)val); - if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; - else if (ret == 0) rsp_out->status = KVS_STATUS_OK; - else rsp_out->status = KVS_STATUS_EXIST; - return 0; - - case KVS_CMD_GET: - result = kvs_array_get(&global_array, (char*)key); - if (!result) { rsp_out->status = KVS_STATUS_NO_EXIST; return 0; } - rsp_out->status = KVS_STATUS_OK; - rsp_out->data = result; - rsp_out->dlen = (uint32_t)strlen(result); - return 0; - - case KVS_CMD_DEL: - ret = kvs_array_del(&global_array, (char*)key); - if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; - else if (ret == 0) rsp_out->status = KVS_STATUS_OK; - else rsp_out->status = KVS_STATUS_NO_EXIST; - return 0; - - case KVS_CMD_MOD: - ret = kvs_array_mod(&global_array, (char*)key, (char*)val); - if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; - else if (ret == 0) rsp_out->status = KVS_STATUS_OK; - else rsp_out->status = KVS_STATUS_NO_EXIST; - return 0; - - case KVS_CMD_EXIST: - ret = kvs_array_exist(&global_array, (char*)key); - rsp_out->status = (ret == 0) ? KVS_STATUS_EXIST : KVS_STATUS_NO_EXIST; - return 0; #endif -#if ENABLE_RBTREE - case KVS_CMD_RSET: - ret = kvs_rbtree_set(&global_rbtree, (char*)key, (char*)val); - if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; - else if (ret == 0) rsp_out->status = KVS_STATUS_OK; - else rsp_out->status = KVS_STATUS_EXIST; - return 0; - - case KVS_CMD_RGET: - result = kvs_rbtree_get(&global_rbtree, (char*)key); - if (!result) { rsp_out->status = KVS_STATUS_NO_EXIST; return 0; } - rsp_out->status = KVS_STATUS_OK; - rsp_out->data = result; - rsp_out->dlen = (uint32_t)strlen(result); - return 0; - - case KVS_CMD_RDEL: - ret = kvs_rbtree_del(&global_rbtree, (char*)key); - if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; - else if (ret == 0) rsp_out->status = KVS_STATUS_OK; - else rsp_out->status = KVS_STATUS_NO_EXIST; - return 0; - - case KVS_CMD_RMOD: - ret = kvs_rbtree_mod(&global_rbtree, (char*)key, (char*)val); - if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; - else if (ret == 0) rsp_out->status = KVS_STATUS_OK; - else rsp_out->status = KVS_STATUS_NO_EXIST; - return 0; - - case KVS_CMD_REXIST: - ret = kvs_rbtree_exist(&global_rbtree, (char*)key); - rsp_out->status = (ret == 0) ? KVS_STATUS_EXIST : KVS_STATUS_NO_EXIST; - return 0; -#endif - -#if ENABLE_HASH - case KVS_CMD_HSET: - ret = kvs_hash_set(&global_hash, (char*)key, (char*)val); - if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; - else if (ret == 0) rsp_out->status = KVS_STATUS_OK; - else rsp_out->status = KVS_STATUS_EXIST; - return 0; - - case KVS_CMD_HGET: - result = kvs_hash_get(&global_hash, (char*)key); - if (!result) { rsp_out->status = KVS_STATUS_NO_EXIST; return 0; } - rsp_out->status = KVS_STATUS_OK; - rsp_out->data = result; - rsp_out->dlen = (uint32_t)strlen(result); - return 0; - - case KVS_CMD_HDEL: - ret = kvs_hash_del(&global_hash, (char*)key); - if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; - else if (ret == 0) rsp_out->status = KVS_STATUS_OK; - else rsp_out->status = KVS_STATUS_NO_EXIST; - return 0; - - case KVS_CMD_HMOD: - ret = kvs_hash_mod(&global_hash, (char*)key, (char*)val); - if (ret < 0) rsp_out->status = KVS_STATUS_ERROR; - else if (ret == 0) rsp_out->status = KVS_STATUS_OK; - else rsp_out->status = KVS_STATUS_NO_EXIST; - return 0; - - case KVS_CMD_HEXIST: - ret = kvs_hash_exist(&global_hash, (char*)key); - rsp_out->status = (ret == 0) ? KVS_STATUS_EXIST : KVS_STATUS_NO_EXIST; - return 0; -#endif - default: - rsp_out->status = KVS_STATUS_BADREQ; - return -1; - } - - return -1; -} #if NEW_KVSTORE /** @@ -542,13 +360,13 @@ int init_kvengine(void) { void dest_kvengine(void) { #if ENABLE_ARRAY - kvs_array_destory(&global_array); + kvs_array_destroy(&global_array); #endif #if ENABLE_RBTREE - kvs_rbtree_destory(&global_rbtree); + kvs_rbtree_destroy(&global_rbtree); #endif #if ENABLE_HASH - kvs_hash_destory(&global_hash); + kvs_hash_destroy(&global_hash); #endif } diff --git a/kvstore.h b/kvstore.h index c894e64..eef0110 100644 --- a/kvstore.h +++ b/kvstore.h @@ -19,11 +19,6 @@ #define NETWORK_SELECT NETWORK_REACTOR -// 8MB -#define MAX_PAYLOAD_LEN 8388608 -#define MAX_OPCOUNT 1024 -// 4MB -#define MAX_ARG_LEN 4194304 #define KVS_MAX_TOKENS 128 @@ -33,6 +28,8 @@ #define NEW_KVSTORE 1 +#define BIN_SAFE 1 + // typedef int (*msg_handler)(char *msg, int length, char *response); typedef int (*msg_handler)(char *request, int request_length, int *consumed_out, char *response, int *response_length); @@ -45,6 +42,37 @@ extern int ntyco_start(unsigned short port, msg_handler handler); #if ENABLE_ARRAY +#if BIN_SAFE +#define KVS_ARRAY_SIZE 1024 + +typedef struct kvs_array_item_s { + uint8_t *key; + size_t key_len; + + uint8_t *value; + size_t value_len; +} kvs_array_item_t; + + +typedef struct kvs_array_s { + kvs_array_item_t *table; + int total; // 元素上界 +} kvs_array_t; + +int kvs_array_create(kvs_array_t *inst); +void kvs_array_destroy(kvs_array_t *inst); +int kvs_array_set_bin(kvs_array_t *inst, + const void *key, size_t key_len, + const void *value, size_t value_len); +void *kvs_array_get_bin(kvs_array_t *inst, + const void *key, size_t key_len, + size_t *out_value_len); +int kvs_array_del_bin(kvs_array_t *inst, const void *key, size_t key_len); +int kvs_array_mod_bin(kvs_array_t *inst, + const void *key, size_t key_len, + const void *value, size_t value_len); +int kvs_array_exist_bin(kvs_array_t *inst, const void *key, size_t key_len); +#else typedef struct kvs_array_item_s { char *key; char *value; @@ -59,14 +87,14 @@ typedef struct kvs_array_s { } kvs_array_t; int kvs_array_create(kvs_array_t *inst); -void kvs_array_destory(kvs_array_t *inst); +void kvs_array_destroy(kvs_array_t *inst); int kvs_array_set(kvs_array_t *inst, char *key, char *value); char* kvs_array_get(kvs_array_t *inst, char *key); int kvs_array_del(kvs_array_t *inst, char *key); int kvs_array_mod(kvs_array_t *inst, char *key, char *value); int kvs_array_exist(kvs_array_t *inst, char *key); - +#endif #endif @@ -102,7 +130,7 @@ typedef struct _rbtree { typedef struct _rbtree kvs_rbtree_t; int kvs_rbtree_create(kvs_rbtree_t *inst); -void kvs_rbtree_destory(kvs_rbtree_t *inst); +void kvs_rbtree_destroy(kvs_rbtree_t *inst); int kvs_rbtree_set(kvs_rbtree_t *inst, char *key, char *value); char* kvs_rbtree_get(kvs_rbtree_t *inst, char *key); int kvs_rbtree_del(kvs_rbtree_t *inst, char *key); @@ -120,6 +148,38 @@ int kvs_rbtree_exist(kvs_rbtree_t *inst, char *key); #define MAX_VALUE_LEN 512 #define MAX_TABLE_SIZE 1024 +#if BIN_SAFE +#define MAX_TABLE_SIZE 1024 +typedef struct hashnode_s { + uint8_t *key; + size_t key_len; + + uint8_t *value; + size_t value_len; + + struct hashnode_s *next; +} hashnode_t; + +typedef struct hashtable_s { + hashnode_t **nodes; + int max_slots; + int count; +} hashtable_t; + +typedef struct hashtable_s kvs_hash_t; + +int kvs_hash_create(kvs_hash_t *hash); +void kvs_hash_destroy(kvs_hash_t *hash); +int kvs_hash_set_bin(kvs_hash_t *h, const void *key, size_t key_len, const void *value, size_t value_len); +void *kvs_hash_get_bin(kvs_hash_t *h, const void *key, size_t key_len, size_t *out_value_len); +int kvs_hash_get_copy_bin(kvs_hash_t *h, const void *key, size_t key_len, void **out_buf, size_t *out_len); +int kvs_hash_mod_bin(kvs_hash_t *h, const void *key, size_t key_len, const void *value, size_t value_len); +int kvs_hash_del_bin(kvs_hash_t *h, const void *key, size_t key_len); +int kvs_hash_exist_bin(kvs_hash_t *h, const void *key, size_t key_len); +int kvs_hash_count(kvs_hash_t *h); + +#else + #define ENABLE_KEY_POINTER 1 @@ -149,14 +209,14 @@ typedef struct hashtable_s kvs_hash_t; int kvs_hash_create(kvs_hash_t *hash); -void kvs_hash_destory(kvs_hash_t *hash); +void kvs_hash_destroy(kvs_hash_t *hash); int kvs_hash_set(hashtable_t *hash, char *key, char *value); char * kvs_hash_get(kvs_hash_t *hash, char *key); int kvs_hash_mod(kvs_hash_t *hash, char *key, char *value); int kvs_hash_del(kvs_hash_t *hash, char *key); int kvs_hash_exist(kvs_hash_t *hash, char *key); - +#endif #endif diff --git a/test/test_client.h b/test/test_client.h index 6541dcc..74e9ca5 100644 --- a/test/test_client.h +++ b/test/test_client.h @@ -18,7 +18,8 @@ #define BATCH_SIZE (65536) #define TIME_SUB_MS(tv1, tv2) ((tv1.tv_sec - tv2.tv_sec) * 1000 + (tv1.tv_usec - tv2.tv_usec) / 1000) -#define PRESP print_response +// #define PRESP print_response +#define PRESP typedef enum { diff --git a/test/testcase.c b/test/testcase.c index 836514b..bf341a2 100644 --- a/test/testcase.c +++ b/test/testcase.c @@ -67,21 +67,21 @@ void testcase(int connfd, uint8_t op, const char* key, const char* value, rsp_re void array_testcase_1w(int connfd) { - int count = 1; + int count = 10000; int i = 0; struct timeval tv_begin; gettimeofday(&tv_begin, NULL); for (i = 0;i < count;i ++) { - testcase(connfd, KVS_CMD_SET, "nage", "lian", KVS_STATUS_OK, NULL, "SET NAME"); - testcase(connfd, KVS_CMD_GET, "nage", NULL, KVS_STATUS_OK, "lian", "GET NAME"); - testcase(connfd, KVS_CMD_MOD, "nage", "liu", KVS_STATUS_OK, NULL, "MOD NAME"); - testcase(connfd, KVS_CMD_GET, "nage", NULL, KVS_STATUS_OK, "liu", "GET NAME"); + testcase(connfd, KVS_CMD_HSET, "nage", "lian", KVS_STATUS_OK, NULL, "SET NAME"); + testcase(connfd, KVS_CMD_HGET, "nage", NULL, KVS_STATUS_OK, "lian", "GET NAME"); + testcase(connfd, KVS_CMD_HMOD, "nage", "liu", KVS_STATUS_OK, NULL, "MOD NAME"); + testcase(connfd, KVS_CMD_HGET, "nage", NULL, KVS_STATUS_OK, "liu", "GET NAME"); - testcase(connfd, KVS_CMD_EXIST, "nage", NULL, KVS_STATUS_EXIST, NULL, "EXIST NAME"); - testcase(connfd, KVS_CMD_DEL, "nage", NULL, KVS_STATUS_OK, NULL, "DEL NAME"); - testcase(connfd, KVS_CMD_EXIST, "nage", NULL, KVS_STATUS_NO_EXIST, NULL, "NOT EXIST NAME"); + testcase(connfd, KVS_CMD_HEXIST, "nage", NULL, KVS_STATUS_EXIST, NULL, "EXIST NAME"); + testcase(connfd, KVS_CMD_HDEL, "nage", NULL, KVS_STATUS_OK, NULL, "DEL NAME"); + testcase(connfd, KVS_CMD_HEXIST, "nage", NULL, KVS_STATUS_NO_EXIST, NULL, "NOT EXIST NAME"); } struct timeval tv_end; @@ -98,11 +98,14 @@ void do_batch_example(int fd) kvs_batch_t batch; kvs_batch_init(&batch); + char key[10]={0}, val[10]={0}; + // 组 batch（最多 64 条） - kvs_batch_add(&batch, KVS_CMD_SET, "k1", "v1"); - kvs_batch_add(&batch, KVS_CMD_SET, "k2", "v2"); - kvs_batch_add(&batch, KVS_CMD_GET, "k1", NULL); - kvs_batch_add(&batch, KVS_CMD_GET, "k2", NULL); + for(int i = 0;i < 24; ++ i){ + int len = sprintf(key, "k%d", i); + len = sprintf(val, "v%d", i); + kvs_batch_add(&batch, KVS_CMD_HSET, key, val); + } // 一次性发送 kvs_batch_send(fd, &batch); @@ -118,10 +121,13 @@ void do_batch_example(int fd) PRESP("BATCH", &rsps[i]); } - printf("%d\n", nrsp); - testcase(fd, KVS_CMD_GET, "k1", NULL, KVS_STATUS_OK, "v1", "GET k1"); - testcase(fd, KVS_CMD_GET, "k2", NULL, KVS_STATUS_OK, "v2", "GET k2"); + for(int i = 0;i < 24; ++ i){ + int len = sprintf(key, "k%d", i); + len = sprintf(val, "v%d", i); + testcase(fd, KVS_CMD_HGET, key, NULL, KVS_STATUS_OK, val, "GET K"); + } + } @@ -136,8 +142,8 @@ int main(int argc, char *argv[]) { int connfd = connect_tcpserver(ip, port); - // array_testcase_1w(connfd); - do_batch_example(connfd); + array_testcase_1w(connfd); + // do_batch_example(connfd); return 0; } \ No newline at end of file