diff --git a/.gitignore b/.gitignore index 758b615..704ab53 100644 --- a/.gitignore +++ b/.gitignore @@ -5,7 +5,7 @@ *.a /ebpf/libbpf-bootstrap -/doc +/test-redis/results kvstore testcase diff --git a/chainbuffer.plan.md b/chainbuffer.plan.md deleted file mode 100644 index 92d7348..0000000 --- a/chainbuffer.plan.md +++ /dev/null @@ -1,189 +0,0 @@ -# ChainBuffer + 全量 WAL（单一方案，slot 驱动） - -## 1. 目标与约束 - -目标： - -- 所有命令都落盘（不再区分 update/get）。 -- 主线程 A 尽量不做内存分配，不构造 uring task。 -- 主线程 A 只做：收包、解析命令边界、摘取 payload、写入预分配 slot。 -- WAL 线程 B 负责：从 slot 取 payload、构造 task、提交 io_uring、归还内存块。 - -约束： - -- 只保留一个实现方案，不引入 v1/v2 双路径。 -- 正确性优先：半包、多包、pipeline、断连、慢盘都可控。 - ---- - -## 2. ChainBuffer 设计（重点） - -## 2.1 结构定义 - -采用“回环 chunk 链表”： - -```c -typedef struct cb_chunk { - struct cb_chunk *next; - uint32_t cap; // 固定大小，默认 4096 - uint32_t rpos; // 读指针 [0, cap) - uint32_t wpos; // 写指针 [0, cap) - uint32_t used; // 已用字节数 [0, cap] - uint32_t refcnt; // 被 WAL payload 持有的引用计数 - uint8_t data[]; -} cb_chunk_t; - -typedef struct chain_buffer { - cb_chunk_t *head; - cb_chunk_t *tail; - size_t total_len; - uint32_t chunk_size; - - // 节点池：避免频繁 malloc/free - cb_chunk_t *free_list; - uint32_t free_count; - uint32_t free_limit; -} chain_buffer_t; -``` - -说明： - -- chunk 内部可回环读写（避免 memmove）。 -- 多 chunk 串联用于扩容。 -- 空 chunk 不释放到系统，先回收到 `free_list`。 - -## 2.2 接收路径（readv 直写） - -主线程不再 `recv -> tmp -> memcpy`，改为： - -1. `chain_buffer_prepare_recv_iov(buf, iov, max_iov)` - - 收集可写空闲段（优先尾 chunk，不够就从 free_list 取或新建 chunk）。 -2. `readv(fd, iov, iovcnt)` -3. `chain_buffer_commit_recv(buf, nread)` - - 推进 `wpos/used/total_len`。 - -这样可去掉接收中转拷贝。 - -## 2.3 消费与摘取 - -提供三个核心能力： - -- `chain_buffer_iter_*`：按字节流遍历，供 RESP 解析命令边界。 -- `chain_buffer_detach_prefix(buf, len, cb_payload_t *out)`：把前缀字节摘成 payload（尽量零拷贝，边界切分允许一次小拷贝）。 -- `chain_buffer_release_payload(buf, payload)`：WAL 线程用完后归还 chunk（refcnt--，归零后回 free_list）。 - ---- - -## 3. slot 队列设计（主线程零分配） - -## 3.1 预分配 ring - -定义单生产者单消费者 ring（A->B）： - -```c -#define WAL_SLOT_CAP 65536 - -typedef struct wal_slot { - uint64_t seq; - uint32_t cmd_len; - cb_payload_t payload; // 命令字节 - uint8_t in_use; -} wal_slot_t; - -typedef struct wal_ring { - wal_slot_t slots[WAL_SLOT_CAP]; - _Atomic uint32_t head; // producer write - _Atomic uint32_t tail; // consumer read - _Atomic uint32_t size; -} wal_ring_t; -``` - -特点： - -- slot 全预分配。 -- 主线程写 slot 不 malloc。 -- WAL 线程消费后清空 slot 并前移 tail。 - -## 3.2 主线程流程（所有命令都落盘） - -对每条完整命令： - -1. 从 chainbuffer 解析得到 `cmd_len`。 -2. 申请一个空 slot（ring 未满）。 -3. `detach_prefix(cmd_len)` 得到 `payload`。 -4. 写入 slot：`seq/cmd_len/payload`。 -5. 发布 head。 - -注意： - -- 不做命令类型判断。 -- 不构造 uring task。 -- 不进行额外 payload malloc。 - -## 3.3 WAL 线程流程 - -循环： - -1. 从 ring 取 slot。 -2. 生成长度头（4B）+ payload iov。 -3. 调 `submit_write()`（当前打包拷贝发生在此线程）。 -4. `chain_buffer_release_payload()` 归还 chunk。 -5. 清 slot，推进 tail。 - ---- - -## 4. 一致性与回压 - -## 4.1 日志顺序 - -- `g_log_off` 只在 WAL 线程维护。 -- 单消费者天然保证写入顺序与入队顺序一致。 - -## 4.2 回压（必须） - -当 ring 达到高水位（例如 80%）： - -1. 暂停该连接读事件（优先）。 -2. 若持续超时（如 200ms）仍高水位，关闭连接保护系统。 - -本方案不再做“回退旧路径”。 - -## 4.3 异常处理 - -- `submit_write` 失败：记录错误并触发保护动作（可选停机/拒绝新连接）。 -- 连接断开：已入 slot 的 payload 继续由 WAL 线程完成归还。 -- 进程退出：先停读，再 drain wal_ring，再 shutdown uring。 - ---- - -## 5. 实施步骤（实际落地） - -1. 重构 `network/chainbuffer.*` - - 回环 chunk + free_list - - `prepare_recv_iov/commit_recv` - - `iter/detach_prefix/release_payload` -2. 修改 `reactor.c` - - `recv_cb` 使用 `readv` + commit -3. 修改 `kvstore.c` - - 按命令边界循环 - - 每条命令统一入 wal_slot（不分类） -4. 新增 `dump/wal_slot_queue.*`（或放 `dump/kvs_oplog.c`） - - SPSC ring + WAL worker -5. 调整 `dump/kvs_oplog.c` - - 改为 WAL 线程消费 slot 后调用 `submit_write` -6. 收敛退出与错误路径 - - close_conn / shutdown / submit 失败全覆盖 - ---- - -## 6. 验收标准 - -- 功能： - - 半包/多包/pipeline 正确； - - 重启回放后数据一致。 -- 性能： - - 主线程不再出现 oplog task 构造热点； - - 接收路径 memcpy 次数下降（去掉 tmp 中转）。 -- 稳定性： - - 慢盘压测下无泄漏、无 double free、无 UAF； - - 高水位触发时系统行为可预期。 diff --git a/config/config.xml b/config/config.xml index 4df1944..acdb818 100644 --- a/config/config.xml +++ b/config/config.xml @@ -1,11 +1,11 @@ - + - 192.168.220.134 + 127.0.0.1 8888 - master + master - + disable 192.168.220.134 @@ -14,12 +14,12 @@ - INFO + INFO - none - data + incremental + data/persist_mypool_20260305_072256 kvs_oplog.db kvs_array.db @@ -28,7 +28,7 @@ - mypool - disable + mypool + disable - + \ No newline at end of file diff --git a/doc/conclusion.md b/doc/conclusion.md new file mode 100644 index 0000000..5321866 --- /dev/null +++ b/doc/conclusion.md @@ -0,0 +1,50 @@ +# 性能定位结论（主线程） + +## 1) 主要瓶颈结论 + +基于当前主线程采样统计，结论是： + +- **主线程最大开销确实是内存申请/管理相关开销**（而不是纯 memcpy）。 +- 开销占比大致为： + - `submit_write` 打包阶段：约 **61.3%** + - 其中 alloc 约 **66.5% of pack**（折算到主线程总开销约 **40.8%**） + - copy 约 **14.2% of pack**（折算到主线程总开销约 **8.7%**） + - 入队/通知（SPSC push + notify）：约 **29.2%** + - 回收释放：约 **9.5%** + - backpressure 影响很小（loops≈0） + +所以“减少申请内存次数”这个判断是对的，而且是当前最有价值的优化方向。 + +--- + +## 2) 对方案 2 / 3 的评价（结合本系统） + +### 方案 2：A/B 双 flag 缓冲覆写保护 + +- **优点**：实现直观，容易快速落地验证正确性。 +- **缺点**： + - 本质仍是“执行路径与拷贝路径耦合”，请求推进会受慢侧牵制； + - 不能从根本上消除 alloc 热点，只是控制覆写时序； + - 在高并发下调试成本会上升（状态机与边界条件多）。 +- **结论**：适合快速试验，不是长期高性能形态。 + +### 方案 3：ChainBuffer 所有权移交（摘链/归还） + +- **优点**： + - 以“指针/节点移动”替代大量 alloc+copy，方向与当前瓶颈完全一致； + - 对大 value、高吞吐场景收益潜力更大。 +- **缺点**： + - 生命周期、并发归还、异常回收都要设计清楚； + - 实现复杂度明显高于方案 2。 +- **结论**：更符合长期性能目标，但需要更严格的工程设计。 + +--- + +## 3) 哪个在你当前系统里更容易实现？ + +如果只比较你给的这两个方案，在你现在的系统里： + +- **更简单的是方案 2（A/B 双 flag）**； +- **更值得长期投入的是方案 3（所有权移交）**。 + +建议：短期先用方案 2 验证行为边界，最终收敛到方案 3（或其等价的零拷贝所有权模型）。 diff --git a/doc/interview_answers_aggressive_50.md b/doc/interview_answers_aggressive_50.md new file mode 100644 index 0000000..e02ac77 --- /dev/null +++ b/doc/interview_answers_aggressive_50.md @@ -0,0 +1,300 @@ +# KVStore 激进版：50 题参考回答（含风险等级与避坑话术） + +> 对应文件：`doc/interview_questions_aggressive_50.md` +> 建议答题模板：**目标 -> 方案 -> 收益 -> 代价 -> 兜底** + +--- + +## 1) 架构与边界（1-5） + +### 1. 分层设计收益与复杂度 +- **风险等级**：低 +- **参考回答**：我把系统拆成网络层（收发）、协议层（RESP 解析）、执行层（命令分发）、持久化层（快照/oplog）和复制层（SSYNC+shm）。收益是可替换和可定位问题，比如网络和持久化互不耦合。代价是模块间接口变多，调试时需要跨层追踪。兜底是我保留了主调用链文档，排障按固定链路走。 +- **避坑话术**：别说“完全解耦”，改成“低耦合、边界清晰”。 + +### 2. Reactor vs Proactor/协程 +- **风险等级**：中 +- **参考回答**：当前选 Reactor 是因为代码路径短、可控性高，适合先把协议和持久化跑稳。Proactor/协程在高并发下有潜力，但会引入更复杂的调度和状态管理。我的 tradeoff 是先优化主路径和持久化，再评估网络模型切换。 +- **避坑话术**：不要说“Reactor 一定最快”，要说“在当前代码复杂度和目标下更合适”。 + +### 3. 三引擎选型边界 +- **风险等级**：低 +- **参考回答**：Array 实现简单但查找线性，适合小规模或验证场景；RBTree 有序且 O(logN)，适合有序访问；Hash 平均 O(1)，适合热点随机读写。收益是能覆盖不同 workload。代价是维护三套实现和一致性语义。 +- **避坑话术**：不要泛泛说“都很快”，要给出复杂度和场景。 + +### 4. 主路径轻量化 +- **风险等级**：中 +- **参考回答**：主线程主要做解析、执行、回包，持久化提交走 io_uring worker。收益是减少 I/O 阻塞对主循环影响。代价是异步链路更复杂，需要回收队列和背压。我通过 destroy queue + wakeup 回收来控风险。 +- **避坑话术**：别说“主线程无开销”，保留“主要开销下降”。 + +### 5. 多核扩展优先级 +- **风险等级**：中 +- **参考回答**：我会先做连接分片，再做数据分片。连接分片改动小、收益快；数据分片需要引擎和一致性改造，复杂度高。tradeoff 是短期吞吐提升 vs 长期架构演进，我会分两阶段做。 +- **避坑话术**：不要一次性承诺“全做完”，强调迭代路线。 + +--- + +## 2) 协议与解析（6-10） + +### 6. 半包/多包/粘包与错误恢复 +- **风险等级**：低 +- **参考回答**：我按“可消费字节”循环解析，len=0 视为半包等待下次，len<0 视为协议错误。收益是能稳定处理 pipeline。代价是错误策略偏严格，遇坏包直接断链。这是在安全性和可恢复性之间偏安全的选择。 +- **避坑话术**：别说“能恢复所有坏包”。 + +### 7. binary-safe 为何用 slice +- **风险等级**：低 +- **参考回答**：因为 key/value 可能包含 `\0` 和二进制字节，C 字符串 API 会截断。slice（ptr+len）能保留完整字节语义。收益是协议正确性和通用性更强，代价是代码里长度参数管理更繁琐。 +- **避坑话术**：强调“正确性优先”。 + +### 8. 恶意请求限制 +- **风险等级**：中 +- **参考回答**：我在协议层设置了 bulk 上限和参数上限，同时连接层有读写缓冲上限。收益是避免单连接吃光内存。代价是极端合法请求也可能被拒绝。我会通过可配置阈值平衡安全和业务需求。 +- **避坑话术**：不要说“完全防攻击”，说“降低风险面”。 + +### 9. inline 与 multibulk 共存 +- **风险等级**：低 +- **参考回答**：如果首字节不是 `*`，走 inline；是 `*` 就走 multibulk。收益是兼容 Redis 常见输入。代价是代码路径多一支，但复杂度可控。 +- **避坑话术**：不要说“全面兼容 Redis”，说“覆盖当前命令集下的 RESP2 常用场景”。 + +### 10. 新命令最小改动 +- **风险等级**：中 +- **参考回答**：当前是命令枚举 + dispatch switch，新增命令主要改解析映射和执行分支。收益是性能直观、可调试。代价是规模大时 switch 变长。我会在命令数继续增长时再抽象为表驱动。 +- **避坑话术**：别提前宣称“完全插件化”。 + +--- + +## 3) ChainBuffer 与“零拷贝”（11-15） + +### 11. 零拷贝边界 +- **风险等级**：高 +- **参考回答**：接收阶段是 readv 直写到链式缓冲，减少中转拷贝；发送阶段用 sendmsg 聚合。当前仍存在线性化/打包场景下的 memcpy，所以更准确是“低拷贝主路径 + 局部拷贝回退”。tradeoff 是实现复杂度可控，同时先拿到主要收益。 +- **避坑话术**：主动说“不是全链路绝对 0 拷贝”。 + +### 12. linearize 触发条件 +- **风险等级**：中 +- **参考回答**：当上层需要连续字节视图而数据跨 chunk 时触发 linearize。收益是简化了解析和执行接口。代价是触发时会有额外 memcpy，影响尾延迟。我会通过 chunk 策略和请求分布降低触发频率。 +- **避坑话术**：不要说“从不 linearize”。 + +### 13. free_list 选型 +- **风险等级**：低 +- **参考回答**：free_list 复用 chunk，减少频繁 malloc/free 抖动。收益是吞吐更稳、分配开销更低。代价是会保留一定空闲内存。通过 free_limit 做上限控制，平衡性能和内存占用。 +- **避坑话术**：别说“零内存浪费”。 + +### 14. 大小 Key 混跑碎片问题 +- **风险等级**：中 +- **参考回答**：我用固定 chunk + 链式扩展，先保证正确和稳定。大 Key 会占多 chunk，可能带来局部碎片；收益是实现简单、行为可预测。后续可按 key size 分层 chunk 策略优化。 +- **避坑话术**：承认“有优化空间”更可信。 + +### 15. 部分发送一致性 +- **风险等级**：低 +- **参考回答**：sendmsg 返回 n 后按字节 drain 缓冲，未发完保留在 wbuf，EPOLLOUT 下次继续。收益是协议字节流不会错位。代价是状态维护复杂一点，但这是非阻塞发送必须的成本。 +- **避坑话术**：别说“一次 send 一定发完”。 + +--- + +## 4) 所有权移交与并发安全（16-20） + +### 16. 所有权定义 +- **风险等级**：高 +- **参考回答**：我的定义是“谁持有谁负责释放”，通过 detach/release 把片段生命周期显式化。收益是未来可做执行-落盘低拷贝协作。代价是引用计数和回收时序更复杂。当前实现已提供接口，进一步全链路化是下一阶段。 +- **避坑话术**：明确“已实现接口与局部机制，非全链路完成”。 + +### 17. UAF / double free 防护 +- **风险等级**：中 +- **参考回答**：通过 refcnt + release 路径统一回收，避免多方直接 free。收益是降低并发回收风险。代价是需要严格约束调用顺序和异常路径。排查时我会优先核对 detach/release 对称性。 +- **避坑话术**：别说“绝对不会 UAF”，说“通过机制显著降低风险”。 + +### 18. 连接关闭后的回收 +- **风险等级**：中 +- **参考回答**：连接关闭只释放连接侧对象，已移交片段由持有方继续走 release。收益是不会因连接断开丢失回收路径。代价是关闭逻辑需要区分“本地拥有”和“已移交”。 +- **避坑话术**：避免一句话“直接全清掉”。 + +### 19. 谁申请谁释放 +- **风险等级**：低 +- **参考回答**：这是为了避免跨线程释放带来的生命周期混乱。收益是定位泄漏和崩溃更直观。代价是需要一个回收协作队列，代码量会增加。总体是工程上更稳的 tradeoff。 +- **避坑话术**：强调“可维护性收益”。 + +### 20. 真正 0 拷贝落盘约束 +- **风险等级**：高 +- **参考回答**：要做到真正 0 拷贝，需要落盘线程直接消费网络片段并延迟释放，约束包括引用计数、回收屏障和慢盘背压。收益是减少打包复制。代价是并发复杂度显著上升，错误成本更高。 +- **避坑话术**：别承诺“短期必做完”，给阶段目标。 + +--- + +## 5) io_uring 流水线（21-25） + +### 21. n*SPSC vs MPSC +- **风险等级**：中 +- **参考回答**：n*SPSC 的好处是队列局部性好、竞争少，延迟更稳；代价是负载均衡和线程参数调优复杂。MPSC 实现集中但热点明显。当前我更看重稳定性，所以先用 n*SPSC。 +- **避坑话术**：不要否定 MPSC，强调场景选择。 + +### 22. 80% 水位 +- **风险等级**：中 +- **参考回答**：80% 是保护阈值，目的是给 CQE 回收和突发流量留缓冲。收益是降低 overflow 风险。代价是峰值吞吐可能不是最大。这个值不是常量真理，我会按压测再调。 +- **避坑话术**：不要说“最优解”，说“保守工程值”。 + +### 23. 背压策略 +- **风险等级**：中 +- **参考回答**：队列满时会回收已完成任务并让出 CPU，必要时限流连接。收益是系统不崩。代价是尾延迟上升。tradeoff 是优先保活再保时延。 +- **避坑话术**：别说“无损无延迟”。 + +### 24. 批量回收 +- **风险等级**：低 +- **参考回答**：批量偷取 destroy queue 能减少锁/原子开销和碎片回收抖动。收益是主循环更平滑。代价是回收时点有批处理延迟。这个延迟通常可接受。 +- **避坑话术**：承认“不是实时逐条释放”。 + +### 25. 优雅停机 +- **风险等级**：中 +- **参考回答**：停机流程是 stop 标志 -> 唤醒 worker -> drain 队列 -> join 线程 -> 清理剩余任务。收益是尽量保证数据路径收敛完成。代价是停机时间变长。这里优先数据完整性。 +- **避坑话术**：别说“秒停”，说“可控停机”。 + +--- + +## 6) 快照 + 增量一致性（26-30） + +### 26. 一致性窗口 +- **风险等级**：高 +- **参考回答**：快照代表某个时间点状态，后续变更由 oplog 补齐。收益是写入不中断。代价是天然存在窗口，需要恢复阶段串联重放。这个设计是吞吐优先下的最终一致方案。 +- **避坑话术**：不要声称“强一致快照”。 + +### 27. 先快照后回放 +- **风险等级**：低 +- **参考回答**：快照是基线，oplog 是增量。先加载基线再套增量语义清晰。收益是恢复逻辑简单。代价是快照越旧回放越长。可通过更频繁快照平衡。 +- **避坑话术**：说明“恢复时间与快照频率 tradeoff”。 + +### 28. 命令字节流日志 +- **风险等级**：中 +- **参考回答**：命令字节流实现快、复用现有解析器，开发成本低。代价是回放时要重新解析执行，效率不如结构化 WAL。当前选择是快速迭代优先，后续可演进为结构化记录。 +- **避坑话术**：承认“不是最终形态”。 + +### 29. 坏日志策略 +- **风险等级**：高 +- **参考回答**：当前更偏“发现坏日志就失败退出”，先保证正确性边界。收益是避免静默数据错误。代价是可用性下降。生产化可加校验和分段容错，再做可恢复降级。 +- **避坑话术**：不要说“自动修复所有坏日志”。 + +### 30. 状态边界证明 +- **风险等级**：高 +- **参考回答**：我会把边界定义成“快照点 + 之后成功持久化的增量”。收益是定义清楚，便于测试。代价是需要故障注入验证不同崩溃点。我的做法是先给出可验证边界，而不是口头保证。 +- **避坑话术**：避免绝对词“完全一致”。 + +--- + +## 7) 主从与状态机（31-35） + +### 31. 状态机描述 +- **风险等级**：中 +- **参考回答**：slave 发 SSYNC 申请全量，master 异步产出并发送 snapshot，slave 落盘后回 SREADY，再进入增量流。收益是流程清晰且可扩展。代价是阶段切换复杂，需要严格顺序控制。 +- **避坑话术**：别忽略“阶段切换失败处理”。 + +### 32. 快照期间新写入 +- **风险等级**：高 +- **参考回答**：思路是用 seq 把快照基线和增量窗口连接起来。收益是减少丢数据窗口。代价是实现复杂，需要状态机和顺序保证。当前代码有通道和钩子，协同还在持续完善。 +- **避坑话术**：一定说“机制已搭，协同在完善中”。 + +### 33. wrap marker 可行性 +- **风险等级**：中 +- **参考回答**：尾部放不下时写 wrap marker 并回到 0，消费者识别后跳转。收益是实现简单。代价是需要严格保证读写顺序和越界检查。适合单写者模型。 +- **避坑话术**：别说“多写者也没问题”。 + +### 34. seq 断档处理 +- **风险等级**：高 +- **参考回答**：断档处理要看目标：一致性优先就阻塞/重建，可用性优先可短暂跳过并告警。我的偏好是关键链路一致性优先。代价是短期可用性受影响。 +- **避坑话术**：避免“所有场景一个策略”。 + +### 35. eBPF 控制面定位 +- **风险等级**：中 +- **参考回答**：我把 eBPF 钩子放控制面，用于状态切换和转发触发，不直接承载主数据处理。收益是降低主路径侵入。代价是又多一层调试复杂度。 +- **避坑话术**：别说“eBPF 加速了所有链路”。 + +--- + +## 8) 内存分配器与内存池（36-40） + +### 36. 分级依据 +- **风险等级**：低 +- **参考回答**：8-512B 覆盖高频小对象，按 8B 对齐分桶，页内 free-list 管理。收益是分配释放路径短。代价是可能有内部碎片。属于延迟优先的选择。 +- **避坑话术**：不要回避碎片问题。 + +### 37. 大对象回退 malloc +- **风险等级**：低 +- **参考回答**：大对象生命周期和尺寸离散，放进小块池会放大管理成本。回退系统分配更简单。收益是降低池复杂度。代价是大块分配性能受系统 allocator 影响。 +- **避坑话术**：别说“mempool 覆盖全部场景”。 + +### 38. 空闲页回收 +- **风险等级**：中 +- **参考回答**：我保留一定空闲页做缓存，超过阈值再释放，平衡复用和内存占用。收益是减少抖动。代价是峰值内存更高。阈值可按业务压测调。 +- **避坑话术**：强调“可调参数”。 + +### 39. 三 allocator 差异来源 +- **风险等级**：中 +- **参考回答**：差异主要来自小对象分配路径、锁竞争、缓存复用和写盘模式耦合。mypool 在当前 workload 下命中率高，所以吞吐更好。代价是通用性不一定优于成熟 allocator。 +- **避坑话术**：别说“mypool 永远最优”。 + +### 40. 内存异常排查优先级 +- **风险等级**：低 +- **参考回答**：先看 RSS、分配失败、队列积压、in-flight、回收延迟，再看对象分布。收益是先定位“增长来源”再定位“泄漏点”。代价是需要加一些可观测指标。 +- **避坑话术**：别一上来就说“就是泄漏”。 + +--- + +## 9) 压测方法学（41-45） + +### 41. 复现性保证 +- **风险等级**：低 +- **参考回答**：固定参数、固定轮次、分组合独立目录、每轮重启，保存原始日志与 CSV。收益是可回放可核对。代价是执行时间更长。 +- **避坑话术**：不要只报“最好一轮数据”。 + +### 42. bench vs testcase 取舍 +- **风险等级**：中 +- **参考回答**：bench 更灵活，但随机 key 与 RSET 插入语义会碰撞；testcase mode=4 更稳定，适合长期对比。tradeoff 是灵活性 vs 稳定性。 +- **避坑话术**：主动解释语义差异，避免被质疑口径不一致。 + +### 43. QPS 口径 +- **风险等级**：中 +- **参考回答**：我用“完成请求数/耗时”，并明确是否包含错误。收益是可比较。代价是不同工具默认口径不同，需要文档化。 +- **避坑话术**：别把不同口径结果直接横比。 + +### 44. 避免虚高 +- **风险等级**：低 +- **参考回答**：做预热、控制 keyspace、分离预填充和正式压测、多轮取均值并看波动。收益是结果更稳。代价是实验时间增加。 +- **避坑话术**：不要只强调峰值，不报波动。 + +### 45. 波动解释 +- **风险等级**：中 +- **参考回答**：波动来自调度、缓存、I/O 抖动和后台回收。我的做法是看均值+CV，不用单轮结论。tradeoff 是展示更真实但数字不一定最亮眼。 +- **避坑话术**：别把异常轮次“隐去不提”。 + +--- + +## 10) 真实性与演进（46-50） + +### 46. 零拷贝表述边界 +- **风险等级**：高 +- **参考回答**：我会说“接收/发送主路径低拷贝，局部场景有拷贝回退”，而不是“全链路绝对零拷贝”。收益是表达亮点同时不失真。代价是表述没那么激进。 +- **避坑话术**：先给边界，再讲优化方向。 + +### 47. 状态机协同实现到哪 +- **风险等级**：高 +- **参考回答**：SSYNC/SREADY、快照传输、增量通道与 seq 机制已打通；全量-增量无缝协同仍在完善。这样说能体现工程进度和规划。 +- **避坑话术**：别说“完全解决协同一致性”。 + +### 48. 两周落地计划 +- **风险等级**：中 +- **参考回答**：第 1 周先补一致性边界和故障注入测试；第 2 周做所有权移交闭环和指标监控。收益是先补正确性再补性能。代价是短期新功能延后。 +- **避坑话术**：给里程碑，不要空谈“能做完”。 + +### 49. 最大技术债 +- **风险等级**：中 +- **参考回答**：最大的债是“协同一致性语义和容错测试还不够系统化”。我优先做了主链路可运行和性能基线。tradeoff 是先可用再完善严谨性。 +- **避坑话术**：承认技术债并给修复计划，面试官反而更认可。 + +### 50. 三人小组下一版目标 +- **风险等级**：低 +- **参考回答**：目标按优先级：一致性文档+故障矩阵、可观测性、性能回归门禁。验收指标包括恢复正确率、复制延迟、QPS/CV 基线。tradeoff 是减少“新功能数量”，换“上线可信度”。 +- **避坑话术**：不要只提“再提 2 倍 QPS”。 + +--- + +## 快速复习（高风险题清单） +- **高风险题**：11, 16, 20, 26, 29, 30, 32, 34, 46, 47 +- **统一策略**：先讲“已实现边界”，再讲“预案与下一步”，避免绝对化承诺。 diff --git a/doc/interview_questions_aggressive_50.md b/doc/interview_questions_aggressive_50.md new file mode 100644 index 0000000..a611ae7 --- /dev/null +++ b/doc/interview_questions_aggressive_50.md @@ -0,0 +1,76 @@ +# KVStore 激进版本：面试高频追问 50 题（含 Tradeoff 视角） + +## 回答建议（统一框架） +- 建议每题按「目标 -> 方案 -> 收益 -> 代价 -> 兜底」回答。 +- 收益常见维度：吞吐、时延、稳定性、可维护性、可扩展性。 +- 代价常见维度：实现复杂度、内存开销、排障成本、一致性窗口、开发周期。 + +## 1) 架构与边界（1-5） +1. 你把系统拆成了哪些层（网络/协议/执行/持久化/复制）？这种分层带来的收益与额外复杂度分别是什么？ +2. 为什么默认选择 Reactor 而不是 Proactor/协程网络模型？三者在吞吐、延迟、开发复杂度上的 tradeoff 是什么？ +3. Array/RBTree/Hash 三种引擎的选型边界是什么？在不同数据分布下的性能收益与维护成本如何权衡？ +4. 你说“主路径轻量化”，具体删掉了哪些主线程工作？对 CPU 利用率与代码复杂度的 tradeoff 是什么？ +5. 如果要做多核扩展，你会优先做连接分片还是数据分片？两者在扩展性与一致性上的代价分别是什么？ + +## 2) 协议与解析（6-10） +6. RESP 解析如何处理半包/多包/粘包？选择“严格报错”还是“尽量恢复”的 tradeoff 是什么？ +7. binary-safe 为什么必须用 slice（ptr+len）而不是 C 字符串？这对性能和代码可读性有什么影响？ +8. 你如何限制恶意请求（超大 bulk、超多参数）？安全性提升与正常流量误伤之间如何平衡？ +9. inline 与 multibulk 共存时如何处理优先级？兼容性收益与实现复杂度代价分别是什么？ +10. 新增命令时如何保证最小改动？抽象过度与快速迭代之间的 tradeoff 怎么拿捏？ + +## 3) ChainBuffer 与“零拷贝”追问（11-15） +11. readv 直写后用户态还会发生哪些拷贝？你如何定义“零拷贝”和“低拷贝”的边界？ +12. chain_buffer_linearize 何时触发？减少复杂解析逻辑与引入额外 memcpy 的 tradeoff 是什么？ +13. 为什么要做 chunk free_list？复用内存带来的性能收益与内存峰值风险如何平衡？ +14. 大 Key（64KB）与小 Key 混跑时，chunk 策略如何避免碎片化？吞吐和内存效率谁优先？ +15. sendmsg 聚合发送遇到部分发送时如何保证一致性？更高吞吐与更复杂状态管理如何权衡？ + +## 4) 所有权移交与并发安全（16-20） +16. “执行-落盘共享缓冲片段”如何定义所有权？减少拷贝收益与生命周期复杂度代价怎么评估？ +17. detach/release 如何避免 UAF/double free？你牺牲了哪些性能换取内存安全？ +18. 连接提前关闭时已移交数据如何回收？优先保证数据安全还是优先快速释放资源？ +19. 为什么采用“谁申请谁释放”？跨线程释放带来的便利与隐患如何取舍？ +20. 若做真正 0 拷贝落盘，你会接受哪些新增约束（引用计数/锁/回收时序）？ + +## 5) io_uring 持久化流水线（21-25） +21. n*SPSC 相比单队列 MPSC 的收益和代价分别是什么？你为什么在当前阶段选 n*SPSC？ +22. in-flight 上限为何设为 CQ 的 80%？保守水位与峰值吞吐之间如何权衡？ +23. 队列满时背压策略是什么？“保护系统稳定”与“牺牲尾延迟”之间如何取舍？ +24. destroy_queue 用批量偷取+集中释放的动机是什么？释放抖动与主循环平滑性如何平衡？ +25. shutdown 阶段如何保证无悬挂任务？优雅退出时间与数据完整性哪个优先？ + +## 6) 快照 + 增量日志一致性（26-30） +26. SAVE 与 oplog append 并发时一致性窗口怎么定义？强一致与吞吐的 tradeoff 是什么？ +27. 为什么恢复顺序是“先快照后 oplog”？恢复速度与恢复正确性之间如何权衡？ +28. oplog 记录命令字节流而不是逻辑变更，优势和成本分别是什么？ +29. replay 遇到坏日志时你会“失败退出”还是“跳过继续”？可用性与正确性怎么选？ +30. 你如何说明恢复后状态边界？文档化成本与实现灵活性的 tradeoff 是什么？ + +## 7) 主从同步与状态机（31-35） +31. 请描述 SSYNC -> Snapshot -> SREADY -> Incremental 状态机，并说明每步的收益与风险。 +32. 快照传输期间新写入如何不丢？延迟增大与一致性增强之间怎么平衡？ +33. 共享内存 ring wrap marker 方案为什么可行？简单实现与健壮性之间的代价是什么？ +34. seq 不连续时你为何选择阻塞/跳过/重建？各策略的可用性与数据风险如何比较？ +35. eBPF uprobe 放在控制面而非数据面的考量是什么？观测能力与运行时开销如何权衡？ + +## 8) 内存分配器与内存池（36-40） +36. mempool 分级（8-512B）的依据是什么？固定桶命中率与碎片风险如何平衡？ +37. 大对象回退 malloc 的原因是什么？统一路径与分层路径在复杂度上怎么取舍？ +38. mempool 如何处理空闲页回收？低延迟复用与低内存占用的 tradeoff 怎么设定？ +39. malloc/jemalloc/mypool 在你的 workload 下差异来自哪里？泛化能力与场景优化如何平衡？ +40. 线上内存峰值异常时先看哪些指标？指标全面性与观测成本如何取舍？ + +## 9) 压测方法学与结果可信度（41-45） +41. 你如何保证 benchmark 可复现？“实验真实度”与“执行成本”之间怎么平衡？ +42. 为什么有些场景用 bench.c，有些改用 testcase mode=4？语义准确与工具统一如何取舍？ +43. QPS 统计口径怎么定义？是否包含失败请求？可比性与直观性之间如何平衡？ +44. 如何避免预热不足/缓存命中导致虚高？测试严谨性与测试周期如何平衡？ +45. 如何解释 round 间波动（CV）？追求峰值还是追求稳定性的 tradeoff 是什么？ + +## 10) 真实性、边界与演进（46-50） +46. 简历里“零拷贝”哪些已落地，哪些是低拷贝/预案？为什么这样表述？ +47. 简历里“协同状态机”当前实现到哪一步？工程现实与对外表达如何平衡？ +48. 若给你 2 周把预案落地，你的里程碑怎么排？短期收益与长期架构如何取舍？ +49. 当前最大技术债是什么？为什么没有先修？业务推进与技术治理如何平衡？ +50. 若带 3 人继续做，下版目标与验收指标是什么？功能扩展与稳定性建设如何排序？ diff --git a/doc/resume.tex b/doc/resume.tex new file mode 100644 index 0000000..d3fa2b0 --- /dev/null +++ b/doc/resume.tex @@ -0,0 +1,25 @@ +\section{项目经历} + +\ResumeItem[KVStore 高性能 KV 存储系统（RESP 兼容 + 异步持久化 + 主从同步）] +{\textbf{KVStore} 高性能 KV 存储系统（RESP 兼容 + 异步持久化 + 主从同步）} +[个人项目|独立开发] +[2025.03 --- 2026.03] +\begin{itemize} + \item 基于 \textbf{C + Linux} 从零实现单机 KV 服务：支持 \textbf{RESP2 协议解析}、pipeline 与 binary-safe（支持 \texttt{\textbackslash 0}），并统一接入 \textbf{Array / RBTree / Hash} 三类存储引擎。 + \item 实现链式网络缓冲 \textbf{ChainBuffer}：通过 \textbf{readv/sendmsg} 构建分段零拷贝收发路径，支持大 Key 与半包/多包场景；提供 \textbf{detach/release} 所有权接口，支持后续执行-落盘共享同一数据片段。 + \item 实现 \textbf{io\_uring + n*SPSC} 异步落盘模型：主线程执行后写入增量日志，worker 线程批量提交 \textbf{writev}；通过 in-flight 控制、队列背压、destroy-queue 回收，避免 CQ 溢出与内存失控。 + \item 设计并落地“\textbf{快照 + 增量日志}”恢复链路：支持启动加载快照并回放 oplog；支持 \textbf{SSYNC $\rightarrow$ 快照传输 $\rightarrow$ SREADY $\rightarrow$ 增量同步} 的主从接管流程，并预留 eBPF uprobe 协同点。 + \item 实现可插拔内存分配策略（\textbf{malloc/jemalloc/mypool}）：自研 mempool 采用 8--512B 分级桶 + 页级 free-list；在 allocator$\times$persistence 复测中，\textbf{mypool} 吞吐最佳（none: 924878 QPS，incremental: 747101 QPS）。 + \item 构建 hiredis 功能/压测工具链（\texttt{testcase + bench + 自动化脚本}），沉淀多轮可复现实验口径；将关键优化量化为可交付结果（如 ChainBuffer 改造后写路径 QPS 提升约 \textbf{27\%}）。 +\end{itemize} + +\ResumeItem[EncryptSql 基于 PostgreSQL 的透明加密查询与运算框架] +{\textbf{EncryptSQL} 基于 PostgreSQL 的透明加密查询与运算框架} +[学校横向|部分代码开发] +[2024.09 --- 2025.09] +\begin{itemize} + \item 在客户端侧对 \textbf{libpq} 进行改造，实现 \textbf{SQL 解析后重写}：将原生表达式/运算符节点替换为密态版本函数/算子调用，尽量保证业务侧无侵入接入。 + \item 基于 \textbf{PostgreSQL 扩展机制}（自定义函数/算子等）接入密态运算：支持常见算术计算（加/减/乘/除）与部分聚合能力，并与查询执行流程集成。 + \item 设计并实现基于工厂模式的 \textbf{KMS 接口层}：在 \texttt{encryptsql} 组件中统一密钥获取与管理流程，完成 \textbf{LocalKMS} 与 \textbf{Huawei KMS API} 适配，支持外部 KMS 平滑替换。 + \item 面向高安全计算场景，引入 \textbf{TEE} 承载关键运算链路，在安全性与性能开销之间做工程化平衡。 +\end{itemize} diff --git a/doc/resume_aggressive.tex b/doc/resume_aggressive.tex new file mode 100644 index 0000000..e542dc1 --- /dev/null +++ b/doc/resume_aggressive.tex @@ -0,0 +1,25 @@ +\section{项目经历} + +\ResumeItem[KVStore 高性能 KV 存储系统（激进表达版）] +{\textbf{KVStore} 高性能 KV 存储系统（零拷贝接收 + 异步持久化 + 主从协同状态机）} +[个人项目|独立开发] +[2025.03 --- 2026.03] +\begin{itemize} + \item 基于 \textbf{C + Linux} 实现 RESP 兼容 KV 存储内核，支持 \textbf{binary-safe}、pipeline 与多引擎统一分发（Array/RBTree/Hash），形成协议层到执行层的一体化数据通路。 + \item 围绕大 Key 场景实现 \textbf{ChainBuffer 分段零拷贝接收}：采用 \textbf{readv/sendmsg} 与链式 chunk 组织，支持超大请求分段处理；按线上保护阈值将单请求上限收敛至 \textbf{65535} 字节级别。 + \item 实现并演进 \textbf{所有权移交} 机制：主线程仅负责命令边界识别与执行，落盘线程复用网络缓冲片段进行持久化，减少主路径内存申请/对象拼装开销。 + \item 搭建 \textbf{io\_uring + n*SPSC} 持久化流水线：worker 批量提交 writev，主线程异步回收完成任务；结合 in-flight 背压与 destroy-queue，稳定处理慢盘与高并发写入抖动。 + \item 设计“\textbf{快照 + 增量日志 + 实时复制}”协同方案：通过 \textbf{SSYNC $\rightarrow$ Snapshot $\rightarrow$ SREADY $\rightarrow$ Incremental} 状态机衔接全量与增量，保障复制窗口内的可恢复性与顺序一致性。 + \item 构建多维压测体系（功能正确性/吞吐/波动）：在 allocator$\times$persistence 复测中，\textbf{mypool} 取得最佳吞吐（none: 924878 QPS，incremental: 747101 QPS），并将优化效果沉淀为工程基线。 +\end{itemize} + +\ResumeItem[EncryptSql 基于 PostgreSQL 的透明加密查询与运算框架] +{\textbf{EncryptSQL} 基于 PostgreSQL 的透明加密查询与运算框架} +[学校横向|部分代码开发] +[2024.09 --- 2025.09] +\begin{itemize} + \item 在客户端侧改造 \textbf{libpq} 并实现 \textbf{SQL AST 重写}：将明文表达式自动替换为密态函数/算子调用，降低业务系统改造成本。 + \item 基于 \textbf{PostgreSQL 扩展机制}接入密态算子，支持加/减/乘/除与部分聚合能力，形成可落地的“密文存储 + 密态计算”执行路径。 + \item 设计并实现 \textbf{KMS 工厂接口框架}，完成 \textbf{LocalKMS/Huawei KMS} 适配，支持多云与私有化 KMS 的低成本切换。 + \item 在高敏感计算场景引入 \textbf{TEE}，对关键流程进行可信执行与边界隔离，平衡安全目标与查询性能。 +\end{itemize} diff --git a/doc/resume_conservative.tex b/doc/resume_conservative.tex new file mode 100644 index 0000000..f64b809 --- /dev/null +++ b/doc/resume_conservative.tex @@ -0,0 +1,25 @@ +\section{项目经历} + +\ResumeItem[KVStore 高性能 KV 存储系统（保守版）] +{\textbf{KVStore} 高性能 KV 存储系统（RESP 兼容 + 异步持久化 + 主从同步）} +[个人项目|独立开发] +[2025.03 --- 2026.03] +\begin{itemize} + \item 基于 \textbf{C + Linux} 实现单机 KV 服务，支持 \textbf{RESP2} 解析、pipeline 与 binary-safe（支持 \texttt{\textbackslash 0}）键值处理。 + \item 统一命令分发层，接入 \textbf{Array / RBTree / Hash} 三种引擎，实现 SET/GET/DEL 及对应 R*/H* 命令族。 + \item 实现 \textbf{ChainBuffer} 分段网络缓冲：接收侧使用 \textbf{readv} 直写，发送侧使用 \textbf{sendmsg} 聚合发送，并通过 linearize 处理跨分段解析场景。 + \item 实现 \textbf{io\_uring + n*SPSC} 异步增量日志写入，包含 in-flight 限流、背压与完成队列回收，降低主线程阻塞。 + \item 实现“\textbf{快照 + 增量日志}”恢复路径：支持 SAVE 快照、oplog 回放；支持 \textbf{SSYNC/SREADY} 启动同步与共享内存增量通道。 + \item 构建 hiredis 功能/性能测试工具链；在 2026-03-04 的 allocator$\times$persistence 复测中，\textbf{mypool} 组合吞吐最佳（none: 924878 QPS，incremental: 747101 QPS）。 +\end{itemize} + +\ResumeItem[EncryptSql 基于 PostgreSQL 的透明加密查询与运算框架] +{\textbf{EncryptSQL} 基于 PostgreSQL 的透明加密查询与运算框架} +[学校横向|部分代码开发] +[2024.09 --- 2025.09] +\begin{itemize} + \item 在客户端侧对 \textbf{libpq} 进行改造，实现 \textbf{SQL 解析后重写}：将原生表达式/运算符节点替换为密态函数/算子调用，尽量保证业务侧无侵入接入。 + \item 基于 \textbf{PostgreSQL 扩展机制}（自定义函数/算子等）接入密态运算：支持常见算术计算（加/减/乘/除）与部分聚合能力，并与执行流程集成。 + \item 设计并实现基于工厂模式的 \textbf{KMS 接口层}：在 \texttt{encryptsql} 中统一密钥获取与管理流程，完成 \textbf{LocalKMS} 与 \textbf{Huawei KMS API} 适配。 + \item 面向高安全计算场景，引入 \textbf{TEE} 承载关键运算链路，在安全性与性能开销之间做工程化平衡。 +\end{itemize} diff --git a/hash.c b/hash.c deleted file mode 100755 index fb2c891..0000000 --- a/hash.c +++ /dev/null @@ -1,228 +0,0 @@ - - - -// #include -// #include -// #include -// #include - - - -// #define MAX_KEY_LEN 128 -// #define MAX_VALUE_LEN 512 -// #define MAX_TABLE_SIZE 1024 - - - -// typedef struct hashnode_s { - -// char key[MAX_KEY_LEN]; -// char value[MAX_VALUE_LEN]; - -// struct hashnode_s *next; - -// } hashnode_t; - - -// typedef struct hashtable_s { - -// hashnode_t **nodes; //* change **, - -// int max_slots; -// int count; - -// pthread_mutex_t lock; - -// } hashtable_t; - -// hashtable_t hash; - - -// //Connection -// // 'C' + 'o' + 'n' -// static int _hash(char *key, int size) { - -// if (!key) return -1; - -// int sum = 0; -// int i = 0; - -// while (key[i] != 0) { -// sum += key[i]; -// i ++; -// } - -// return sum % size; - -// } - -// hashnode_t *_create_node(char *key, char *value) { - -// hashnode_t *node = (hashnode_t*)malloc(sizeof(hashnode_t)); -// if (!node) return NULL; - -// strncpy(node->key, key, MAX_KEY_LEN); -// strncpy(node->value, value, MAX_VALUE_LEN); -// node->next = NULL; - -// return node; -// } - - -// // -// int init_hashtable(hashtable_t *hash) { - -// if (!hash) return -1; - -// hash->nodes = (hashnode_t**)malloc(sizeof(hashnode_t*) * MAX_TABLE_SIZE); -// if (!hash->nodes) return -1; - -// hash->max_slots = MAX_TABLE_SIZE; -// hash->count = 0; - -// pthread_mutex_init(&hash->lock, NULL); - -// return 0; -// } - -// // -// void dest_hashtable(hashtable_t *hash) { - -// if (!hash) return; - -// int i = 0; -// for (i = 0;i < hash->max_slots;i ++) { -// hashnode_t *node = hash->nodes[i]; - -// while (node != NULL) { // error - -// hashnode_t *tmp = node; -// node = node->next; -// hash->nodes[i] = node; - -// free(tmp); - -// } -// } - -// free(hash->nodes); - -// } - - - -// // mp -// int put_kv_hashtable(hashtable_t *hash, char *key, char *value) { - -// if (!hash || !key || !value) return -1; - -// int idx = _hash(key, MAX_TABLE_SIZE); - -// pthread_mutex_lock(&hash->lock); - -// hashnode_t *node = hash->nodes[idx]; -// #if 1 -// while (node != NULL) { -// if (strcmp(node->key, key) == 0) { // exist -// pthread_mutex_unlock(&hash->lock); -// return 1; -// } -// node = node->next; -// } -// #endif - -// hashnode_t *new_node = _create_node(key, value); -// new_node->next = hash->nodes[idx]; -// hash->nodes[idx] = new_node; - -// hash->count ++; - -// pthread_mutex_unlock(&hash->lock); - -// return 0; -// } - - -// char * get_kv_hashtable(hashtable_t *hash, char *key) { - -// if (!hash || !key) return NULL; - -// int idx = _hash(key, MAX_TABLE_SIZE); - -// pthread_mutex_lock(&hash->lock); -// hashnode_t *node = hash->nodes[idx]; - -// while (node != NULL) { - -// if (strcmp(node->key, key) == 0) { -// pthread_mutex_unlock(&hash->lock); -// return node->value; -// } - -// node = node->next; -// } - -// pthread_mutex_unlock(&hash->lock); - -// return NULL; - -// } - - -// int count_kv_hashtable(hashtable_t *hash) { -// return hash->count; -// } - -// int delete_kv_hashtable(hashtable_t *hash, char *key) { -// if (!hash || !key) return -2; - -// int idx = _hash(key, MAX_TABLE_SIZE); - -// pthread_mutex_lock(&hash->lock); -// hashnode_t *head = hash->nodes[idx]; -// if (head == NULL) return -1; // noexist -// // head node -// if (strcmp(head->key, key) == 0) { -// hashnode_t *tmp = head->next; -// hash->nodes[idx] = tmp; - -// free(head); -// hash->count --; -// pthread_mutex_unlock(&hash->lock); - -// return 0; -// } - -// hashnode_t *cur = head; -// while (cur->next != NULL) { -// if (strcmp(cur->next->key, key) == 0) break; // search node - -// cur = cur->next; -// } - -// if (cur->next == NULL) { - -// pthread_mutex_unlock(&hash->lock); -// return -1; -// } - -// hashnode_t *tmp = cur->next; -// cur->next = tmp->next; -// free(tmp); -// hash->count --; - -// pthread_mutex_unlock(&hash->lock); - -// return 0; -// } - - -// int exist_kv_hashtable(hashtable_t *hash, char *key) { - -// char *value = get_kv_hashtable(hash, key); -// if (value) return 1; -// else return 0; - -// } - - diff --git a/kvs_array.c b/kvs_array.c deleted file mode 100644 index a336a2f..0000000 --- a/kvs_array.c +++ /dev/null @@ -1,192 +0,0 @@ - - -#include "kvstore.h" -#include "kvs_rw_tools.h" -#include "memory/alloc_dispatch.h" -#include - - -// singleton - -kvs_array_t global_array = {0}; - -int kvs_array_create(kvs_array_t *inst) { - - if (!inst) return -1; - if (inst->table) { - printf("table has alloc\n"); - return -1; - } - inst->table = kvs_malloc(KVS_ARRAY_SIZE * sizeof(kvs_array_item_t)); - if (!inst->table) { - return -1; - } - - memset(inst->table, 0, (size_t)KVS_ARRAY_SIZE * sizeof(kvs_array_item_t)); - inst->total = 0; - - return 0; -} - -void kvs_array_destroy(kvs_array_t *inst) { - - if (!inst) return ; - - if (inst->table) { - kvs_free(inst->table); - } - -} - - - -/* - * @return: <0, error; =0, success; >0, exist - */ - -int kvs_array_set(kvs_array_t *inst, char *key, char *value) { - - if (inst == NULL || key == NULL || value == NULL) return -1; - if (inst->total == KVS_ARRAY_SIZE) return -1; - - char *str = kvs_array_get(inst, key); - if (str) { - return 1; // - } - - char *kcopy = kvs_malloc(strlen(key) + 1); - if (kcopy == NULL) return -2; - memset(kcopy, 0, strlen(key) + 1); - strncpy(kcopy, key, strlen(key)); - - char *kvalue = kvs_malloc(strlen(value) + 1); - if (kvalue == NULL) return -2; - memset(kvalue, 0, strlen(value) + 1); - strncpy(kvalue, value, strlen(value)); - - int i = 0; - for (i = 0;i < inst->total;i ++) { - if (inst->table[i].key == NULL) { - - inst->table[i].key = kcopy; - inst->table[i].value = kvalue; - inst->total ++; - - return 0; - } - } - - if (i == inst->total && i < KVS_ARRAY_SIZE) { - - inst->table[i].key = kcopy; - inst->table[i].value = kvalue; - inst->total ++; - } - - return 0; -} - -char* kvs_array_get(kvs_array_t *inst, char *key) { - - if (inst == NULL || key == NULL) return NULL; - - int i = 0; - for (i = 0;i < inst->total;i ++) { - if (inst->table[i].key == NULL) { - continue; - } - - if (strcmp(inst->table[i].key, key) == 0) { - return inst->table[i].value; - } - } - - return NULL; -} - - -/* - * @return < 0, error; =0, success; >0, no exist - */ - -int kvs_array_del(kvs_array_t *inst, char *key) { - - if (inst == NULL || key == NULL) return -1; - - int i = 0; - for (i = 0;i < inst->total;i ++) { - - if (strcmp(inst->table[i].key, key) == 0) { - - kvs_free(inst->table[i].key); - inst->table[i].key = NULL; - - kvs_free(inst->table[i].value); - inst->table[i].value = NULL; -// error: > 1024 - if (inst->total-1 == i) { - inst->total --; - } - - - return 0; - } - } - - return i; -} - - -/* - * @return : < 0, error; =0, success; >0, no exist - */ - -int kvs_array_mod(kvs_array_t *inst, char *key, char *value) { - - if (inst == NULL || key == NULL || value == NULL) return -1; -// error: > 1024 - if (inst->total == 0) { - return KVS_ARRAY_SIZE; - } - - - int i = 0; - for (i = 0;i < inst->total;i ++) { - - if (inst->table[i].key == NULL) { - continue; - } - - if (strcmp(inst->table[i].key, key) == 0) { - - kvs_free(inst->table[i].value); - - char *kvalue = kvs_malloc(strlen(value) + 1); - if (kvalue == NULL) return -2; - memset(kvalue, 0, strlen(value) + 1); - strncpy(kvalue, value, strlen(value)); - - inst->table[i].value = kvalue; - - return 0; - } - - } - - return i; -} - - -/* - * @return 0: exist, 1: no exist - */ -int kvs_array_exist(kvs_array_t *inst, char *key) { - - if (!inst || !key) return -1; - - char *str = kvs_array_get(inst, key); - if (!str) { - return 1; // - } - return 0; -} diff --git a/kvs_hash.c b/kvs_hash.c deleted file mode 100755 index 71a14ec..0000000 --- a/kvs_hash.c +++ /dev/null @@ -1,286 +0,0 @@ - - - -// #include -// #include -// #include -// #include - - -// #include "memory/alloc_dispatch.h" -// #include "kvstore.h" - - -// // Key, Value --> -// // Modify - - - -// kvs_hash_t global_hash; - - -// //Connection -// // 'C' + 'o' + 'n' -// static int _hash(char *key, int size) { - -// if (!key) return -1; - -// int sum = 0; -// int i = 0; - -// while (key[i] != 0) { -// sum += key[i]; -// i ++; -// } - -// return sum % size; - -// } - -// hashnode_t *_create_node(char *key, char *value) { - -// hashnode_t *node = (hashnode_t*)kvs_malloc(sizeof(hashnode_t)); -// if (!node) return NULL; - -// #if ENABLE_KEY_POINTER -// char *kcopy = kvs_malloc(strlen(key) + 1); -// if (kcopy == NULL) return NULL; -// memset(kcopy, 0, strlen(key) + 1); -// strncpy(kcopy, key, strlen(key)); - -// node->key = kcopy; - -// char *kvalue = kvs_malloc(strlen(value) + 1); -// if (kvalue == NULL) { -// kvs_free(kvalue); -// return NULL; -// } -// memset(kvalue, 0, strlen(value) + 1); -// strncpy(kvalue, value, strlen(value)); - -// node->value = kvalue; - -// #else -// strncpy(node->key, key, MAX_KEY_LEN); -// strncpy(node->value, value, MAX_VALUE_LEN); -// #endif -// 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; - -// hash->max_slots = MAX_TABLE_SIZE; -// hash->count = 0; - -// return 0; -// } - -// // -// void kvs_hash_destroy(kvs_hash_t *hash) { - -// if (!hash) return; - -// int i = 0; -// for (i = 0;i < hash->max_slots;i ++) { -// hashnode_t *node = hash->nodes[i]; - -// while (node != NULL) { // error - -// hashnode_t *tmp = node; -// node = node->next; -// hash->nodes[i] = node; - -// kvs_free(tmp); - -// } -// } - -// kvs_free(hash->nodes); - -// } - -// // 5 + 2 - -// // mp -// int kvs_hash_set(kvs_hash_t *hash, char *key, char *value) { - -// if (!hash || !key || !value) return -1; - -// int idx = _hash(key, MAX_TABLE_SIZE); - -// hashnode_t *node = hash->nodes[idx]; -// #if 1 -// while (node != NULL) { -// if (strcmp(node->key, key) == 0) { // exist -// return 1; -// } -// node = node->next; -// } -// #endif - -// hashnode_t *new_node = _create_node(key, value); -// new_node->next = hash->nodes[idx]; -// hash->nodes[idx] = new_node; - -// hash->count ++; - -// return 0; -// } - - -// char * kvs_hash_get(kvs_hash_t *hash, char *key) { - -// if (!hash || !key) return NULL; - -// int idx = _hash(key, MAX_TABLE_SIZE); - -// hashnode_t *node = hash->nodes[idx]; - -// while (node != NULL) { - -// if (strcmp(node->key, key) == 0) { -// return node->value; -// } - -// node = node->next; -// } - -// return NULL; - -// } - - -// int kvs_hash_mod(kvs_hash_t *hash, char *key, char *value) { - -// if (!hash || !key) return -1; - -// int idx = _hash(key, MAX_TABLE_SIZE); - -// hashnode_t *node = hash->nodes[idx]; - -// while (node != NULL) { - -// if (strcmp(node->key, key) == 0) { -// break; -// } - -// node = node->next; -// } - -// if (node == NULL) { -// return 1; -// } - -// // node --> -// kvs_free(node->value); - -// char *kvalue = kvs_malloc(strlen(value) + 1); -// if (kvalue == NULL) return -2; -// memset(kvalue, 0, strlen(value) + 1); -// strncpy(kvalue, value, strlen(value)); - -// node->value = kvalue; - -// return 0; -// } - -// int kvs_hash_count(kvs_hash_t *hash) { -// return hash->count; -// } - -// int kvs_hash_del(kvs_hash_t *hash, char *key) { -// if (!hash || !key) return -2; - -// int idx = _hash(key, MAX_TABLE_SIZE); - -// hashnode_t *head = hash->nodes[idx]; -// if (head == NULL) return -1; // noexist -// // head node -// if (strcmp(head->key, key) == 0) { -// hashnode_t *tmp = head->next; -// hash->nodes[idx] = tmp; - -// kvs_free(head); -// hash->count --; - -// return 0; -// } - -// hashnode_t *cur = head; -// while (cur->next != NULL) { -// if (strcmp(cur->next->key, key) == 0) break; // search node - -// cur = cur->next; -// } - -// if (cur->next == NULL) { - -// return -1; -// } - -// hashnode_t *tmp = cur->next; -// cur->next = tmp->next; -// #if ENABLE_KEY_POINTER -// kvs_free(tmp->key); -// kvs_free(tmp->value); -// #endif -// kvs_free(tmp); - -// hash->count --; - -// return 0; -// } - - -// int kvs_hash_exist(kvs_hash_t *hash, char *key) { - -// char *value = kvs_hash_get(hash, key); -// if (!value) return 1; - -// return 0; - -// } - -// #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_hash_bin.c b/kvs_hash_bin.c index 5537e69..58e18c5 100755 --- a/kvs_hash_bin.c +++ b/kvs_hash_bin.c @@ -1,384 +1,680 @@ - - - - - - -#include "kvstore.h" -#include "kvs_rw_tools.h" -#include "memory/alloc_dispatch.h" -#include "diskuring/diskuring.h" -// Key, Value --> -// Modify - - - -kvs_hash_t global_hash; - - -//Connection -// 'C' + 'o' + 'n' -static int _hash(const void *key, uint32_t key_len, int size) { - if (!key || size <= 0) return -1; - - const uint8_t *p = (const uint8_t *)key; - uint32_t sum = 0; - for (uint32_t i = 0; i < key_len; i++) { - sum += p[i]; - } - return sum % size; -} - -static int _key_equal(const hashnode_t *node, const void *key, uint32_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, uint32_t key_len, - const void *value, uint32_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; 1 exist - */ -int kvs_hash_set_bin(kvs_hash_t *hash, const void *key, uint32_t key_len, const void *value, uint32_t value_len) { - if (!hash || !hash->nodes || !key || key_len == 0) 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; -} - -/* - * @return: NULL notexist, NOTNULL exist。out_value_len 是长度。 - */ -void *kvs_hash_get_bin(kvs_hash_t *hash, const void *key, uint32_t key_len, uint32_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, uint32_t key_len, const void *value, uint32_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 error; =0 success; >0 no exist - */ -int kvs_hash_del_bin(kvs_hash_t *hash, const void *key, uint32_t key_len) { - if (!hash || !key || key_len == 0) return -1; - - int idx = _hash(key, key_len, MAX_TABLE_SIZE); - if (idx < 0) return -1; - - 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, uint32_t key_len) { - uint32_t vlen = 0; - void *value = kvs_hash_get_bin(hash, key, key_len, &vlen); - return value ? 0 : 1; -} - -// 0 suc, <0 error -int kvs_hash_save(iouring_ctx_t *uring, kvs_hash_t *inst, const char* filename){ - if(!inst || !filename) return -1; - int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644); - if(fd < 0) return -2; - - off_t current_off = 0; - - for(int i = 0;i < inst->max_slots; ++ i){ - for (hashnode_t *n = inst->nodes[i]; n != NULL; n = n->next) { - if (!n->key || n->key_len == 0) continue; - if (n->value_len > 0 && !n->value) { - goto clean; - } - - - uint32_t klen = htonl((uint32_t)n->key_len); - uint32_t vlen = htonl((uint32_t)n->value_len); - - void *bufs[4]; - size_t lens[4]; - int count = 0; - - bufs[count] = &klen; - lens[count] = sizeof(klen); - count++; - - bufs[count] = &vlen; - lens[count] = sizeof(vlen); - count++; - - if (n->key_len > 0){ - bufs[count] = n->key; - lens[count] = n->key_len; - count++; - } - - if (n->value_len > 0) { - bufs[count] = n->value; - lens[count] = n->value_len; - count++; - } - - size_t total = 0; - for (int i = 0; i < count; i++) total += lens[i]; - - - task_t *t = submit_write(uring, fd, bufs, lens, count, current_off); - if(!t) { - perror("task init failed"); - goto clean; - } - cleanup_finished_iouring_tasks(uring); - - current_off += (off_t) total; - } - } - -clean: - while (!uring_task_complete(uring)) { - usleep(1000); - cleanup_finished_iouring_tasks(uring); - } - close(fd); - return 0; -} - -int kvs_hash_load(kvs_hash_t *inst, const char* filename){ - if (!inst || !filename) return -1; - if (!inst->nodes || inst->max_slots <= 0) return -1; - - FILE *fp = fopen(filename, "rb"); - if (!fp) return -2; - - while(1){ - uint32_t klen_n = 0, vlen_n = 0; - - if (kvs_read_file(fp, &klen_n, 4) < 0) { fclose(fp); return -3; } - if (kvs_read_file(fp, &vlen_n, 4) < 0) { fclose(fp); return -3; } - - uint32_t klen = ntohl(klen_n); - 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; } - if (kvs_read_file(fp, keybuf, (size_t)klen) < 0) { - kvs_free(keybuf); - 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; - } - if (kvs_read_file(fp, valbuf, (size_t)vlen) < 0) { - kvs_free(valbuf); - kvs_free(keybuf); - fclose(fp); - return -3; - } - } - - int rc = kvs_hash_set_bin(inst, keybuf, klen, valbuf, vlen); - kvs_free(keybuf); - if (vlen > 0) kvs_free(valbuf); - - if (rc < 0) { // error - fclose(fp); - return -5; - } - } - fclose(fp); - return 0; +#include "kvstore.h" +#include "kvs_rw_tools.h" +#include "memory/alloc_dispatch.h" +#include "diskuring/diskuring.h" + +#include +#include +#include + +#define KVS_HASH_INITIAL_GLOBAL_DEPTH 1u +#define KVS_HASH_BUCKET_SPLIT_THRESHOLD 64u +#define KVS_HASH_MAX_GLOBAL_DEPTH 31u + +kvs_hash_t global_hash; + +static uint32_t _hash_u32(const void *key, uint32_t key_len) { + const uint8_t *p = (const uint8_t *)key; + uint32_t hash = 2166136261u; + + for (uint32_t i = 0; i < key_len; i++) { + hash ^= p[i]; + hash *= 16777619u; + } + + return hash; +} + +static inline uint32_t _dir_index(uint32_t hashv, uint32_t global_depth) { + if (global_depth == 0) { + return 0; + } + return hashv & ((1u << global_depth) - 1u); +} + +static hashbucket_t *_bucket_create(uint32_t local_depth) { + hashbucket_t *bucket = (hashbucket_t *)kvs_malloc(sizeof(hashbucket_t)); + if (!bucket) { + return NULL; + } + + bucket->head = NULL; + bucket->local_depth = local_depth; + bucket->item_count = 0; + bucket->next_all = NULL; + return bucket; +} + +static void _bucket_list_push(kvs_hash_t *hash, hashbucket_t *bucket) { + bucket->next_all = hash->bucket_list; + hash->bucket_list = bucket; +} + +static inline uint8_t *_get_node_key(const hashnode_t *node) { + return (uint8_t *)node + sizeof(hashnode_t); +} + +static inline uint8_t *_get_node_value(const hashnode_t *node) { + return (uint8_t *)node + sizeof(hashnode_t) + node->key_len; +} + +static int _key_equal(const hashnode_t *node, const void *key, uint32_t key_len) { + if (!node || !key) { + return 0; + } + if (node->key_len != key_len) { + return 0; + } + return memcmp(_get_node_key(node), key, key_len) == 0; +} + +static hashnode_t *_create_node(const void *key, uint32_t key_len, + const void *value, uint32_t value_len) { + size_t total_size = sizeof(hashnode_t) + key_len + value_len; + hashnode_t *node; + uint8_t *data_ptr; + + if (!key || key_len == 0) { + return NULL; + } + + node = (hashnode_t *)kvs_malloc(total_size); + if (!node) { + return NULL; + } + + memset(node, 0, sizeof(hashnode_t)); + node->key_len = key_len; + node->value_len = value_len; + node->next = NULL; + + data_ptr = (uint8_t *)node + sizeof(hashnode_t); + memcpy(data_ptr, key, key_len); + if (value_len > 0 && value) { + memcpy(data_ptr + key_len, value, value_len); + } + + return node; +} + +static hashnode_t *_find_node(hashbucket_t *bucket, + const void *key, uint32_t key_len, + hashnode_t ***out_indirect) { + hashnode_t **indirect; + + if (out_indirect) { + *out_indirect = NULL; + } + if (!bucket || !key || key_len == 0) { + return NULL; + } + + indirect = &bucket->head; + while (*indirect) { + if (_key_equal(*indirect, key, key_len)) { + if (out_indirect) { + *out_indirect = indirect; + } + return *indirect; + } + indirect = &(*indirect)->next; + } + + return NULL; +} + +static int _update_node_value(hashnode_t **node_ptr, const void *value, uint32_t value_len) { + hashnode_t *old_node; + hashnode_t *new_node; + + if (!node_ptr || !*node_ptr) { + return -1; + } + if (value_len > 0 && !value) { + return -1; + } + + old_node = *node_ptr; + + if (old_node->value_len == value_len) { + if (value_len > 0) { + memcpy(_get_node_value(old_node), value, value_len); + } + return 0; + } + + new_node = _create_node(_get_node_key(old_node), old_node->key_len, value, value_len); + if (!new_node) { + return -1; + } + + new_node->next = old_node->next; + *node_ptr = new_node; + kvs_free(old_node); + return 0; +} + +static int _double_directory(kvs_hash_t *hash) { + uint32_t old_size; + uint32_t new_size; + hashbucket_t **new_dir; + uint32_t i; + + if (!hash || !hash->directory) { + return -1; + } + if (hash->global_depth >= KVS_HASH_MAX_GLOBAL_DEPTH) { + return 1; + } + + old_size = hash->dir_size; + if (old_size == 0 || old_size > UINT32_MAX / 2u) { + return 1; + } + + new_size = old_size << 1; + new_dir = (hashbucket_t **)kvs_malloc(sizeof(hashbucket_t *) * new_size); + if (!new_dir) { + return 1; + } + + for (i = 0; i < old_size; i++) { + new_dir[i] = hash->directory[i]; + new_dir[i + old_size] = hash->directory[i]; + } + + kvs_free(hash->directory); + hash->directory = new_dir; + hash->dir_size = new_size; + hash->global_depth++; + return 0; +} + +static int _split_bucket(kvs_hash_t *hash, uint32_t dir_idx) { + hashbucket_t *old_bucket; + hashbucket_t *new_bucket; + hashnode_t *node; + uint32_t split_bit; + uint32_t i; + + if (!hash || !hash->directory || dir_idx >= hash->dir_size) { + return -1; + } + + old_bucket = hash->directory[dir_idx]; + if (!old_bucket) { + return -1; + } + + if (old_bucket->local_depth >= KVS_HASH_MAX_GLOBAL_DEPTH) { + return 1; + } + + if (old_bucket->local_depth == hash->global_depth) { + int rc = _double_directory(hash); + if (rc != 0) { + return rc; + } + } + + new_bucket = _bucket_create(old_bucket->local_depth + 1); + if (!new_bucket) { + return -1; + } + _bucket_list_push(hash, new_bucket); + + old_bucket->local_depth++; + split_bit = 1u << (old_bucket->local_depth - 1u); + + for (i = 0; i < hash->dir_size; i++) { + if (hash->directory[i] == old_bucket && (i & split_bit)) { + hash->directory[i] = new_bucket; + } + } + + node = old_bucket->head; + old_bucket->head = NULL; + old_bucket->item_count = 0; + + while (node) { + hashnode_t *next = node->next; + uint32_t idx = _dir_index(_hash_u32(_get_node_key(node), node->key_len), hash->global_depth); + hashbucket_t *target = hash->directory[idx]; + node->next = target->head; + target->head = node; + target->item_count++; + node = next; + } + + return 0; +} + +int kvs_hash_create(kvs_hash_t *hash) { + uint32_t init_depth; + uint32_t i; + hashbucket_t *initial_bucket; + + if (!hash) { + return -1; + } + + memset(hash, 0, sizeof(*hash)); + + init_depth = KVS_HASH_INITIAL_GLOBAL_DEPTH; + if (init_depth > KVS_HASH_MAX_GLOBAL_DEPTH) { + init_depth = KVS_HASH_MAX_GLOBAL_DEPTH; + } + hash->global_depth = init_depth; + hash->dir_size = 1u << init_depth; + if (hash->dir_size == 0) { + return -1; + } + + hash->directory = (hashbucket_t **)kvs_malloc(sizeof(hashbucket_t *) * hash->dir_size); + if (!hash->directory) { + return -1; + } + memset(hash->directory, 0, sizeof(hashbucket_t *) * hash->dir_size); + + initial_bucket = _bucket_create(0); + if (!initial_bucket) { + kvs_free(hash->directory); + hash->directory = NULL; + hash->dir_size = 0; + return -1; + } + + _bucket_list_push(hash, initial_bucket); + for (i = 0; i < hash->dir_size; i++) { + hash->directory[i] = initial_bucket; + } + + hash->count = 0; + return 0; +} + +void kvs_hash_destroy(kvs_hash_t *hash) { + hashbucket_t *bucket; + + if (!hash) { + return; + } + + bucket = hash->bucket_list; + while (bucket) { + hashbucket_t *next_bucket = bucket->next_all; + hashnode_t *node = bucket->head; + while (node) { + hashnode_t *next = node->next; + kvs_free(node); + node = next; + } + kvs_free(bucket); + bucket = next_bucket; + } + + kvs_free(hash->directory); + memset(hash, 0, sizeof(*hash)); +} + +int kvs_hash_set_bin(kvs_hash_t *hash, const void *key, uint32_t key_len, + const void *value, uint32_t value_len) { + uint32_t hashv; + uint32_t idx; + hashbucket_t *bucket; + hashnode_t **indirect = NULL; + hashnode_t *found; + hashnode_t *new_node; + + if (!hash || !hash->directory || !key || key_len == 0) { + return -1; + } + if (value_len > 0 && !value) { + return -1; + } + + hashv = _hash_u32(key, key_len); + idx = _dir_index(hashv, hash->global_depth); + bucket = hash->directory[idx]; + if (!bucket) { + return -1; + } + + found = _find_node(bucket, key, key_len, &indirect); + if (found) { + return (_update_node_value(indirect, value, value_len) == 0) ? 0 : -2; + } + + while (bucket->item_count >= KVS_HASH_BUCKET_SPLIT_THRESHOLD) { + int split_rc = _split_bucket(hash, idx); + if (split_rc < 0) { + return -2; + } + if (split_rc > 0) { + break; + } + idx = _dir_index(hashv, hash->global_depth); + bucket = hash->directory[idx]; + } + + new_node = _create_node(key, key_len, value, value_len); + if (!new_node) { + return -2; + } + + new_node->next = bucket->head; + bucket->head = new_node; + bucket->item_count++; + hash->count++; + return 0; +} + +void *kvs_hash_get_bin(kvs_hash_t *hash, const void *key, uint32_t key_len, + uint32_t *out_value_len) { + uint32_t idx; + hashbucket_t *bucket; + hashnode_t *node; + + if (!out_value_len) { + return NULL; + } + *out_value_len = 0; + + if (!hash || !hash->directory || !key || key_len == 0) { + return NULL; + } + + idx = _dir_index(_hash_u32(key, key_len), hash->global_depth); + bucket = hash->directory[idx]; + if (!bucket) { + return NULL; + } + + node = _find_node(bucket, key, key_len, NULL); + if (!node) { + return NULL; + } + + *out_value_len = node->value_len; + return (node->value_len > 0) ? _get_node_value(node) : NULL; +} + +int kvs_hash_get_copy_bin(kvs_hash_t *hash, const void *key, uint32_t key_len, + void **out_buf, uint32_t *out_len) { + uint32_t idx; + hashbucket_t *bucket; + hashnode_t *node; + void *copy; + + if (!out_buf || !out_len) { + return -1; + } + *out_buf = NULL; + *out_len = 0; + + if (!hash || !hash->directory || !key || key_len == 0) { + return -1; + } + + idx = _dir_index(_hash_u32(key, key_len), hash->global_depth); + bucket = hash->directory[idx]; + if (!bucket) { + return -1; + } + + node = _find_node(bucket, key, key_len, NULL); + if (!node) { + return 1; + } + + *out_len = node->value_len; + if (node->value_len == 0) { + return 0; + } + + copy = kvs_malloc(node->value_len); + if (!copy) { + *out_len = 0; + return -2; + } + + memcpy(copy, _get_node_value(node), node->value_len); + *out_buf = copy; + return 0; +} + +int kvs_hash_mod_bin(kvs_hash_t *hash, const void *key, uint32_t key_len, + const void *value, uint32_t value_len) { + uint32_t idx; + hashbucket_t *bucket; + hashnode_t **indirect = NULL; + hashnode_t *node; + + if (!hash || !hash->directory || !key || key_len == 0) { + return -1; + } + if (value_len > 0 && !value) { + return -1; + } + + idx = _dir_index(_hash_u32(key, key_len), hash->global_depth); + bucket = hash->directory[idx]; + if (!bucket) { + return -1; + } + + node = _find_node(bucket, key, key_len, &indirect); + if (!node) { + return 1; + } + + return (_update_node_value(indirect, value, value_len) == 0) ? 0 : -2; +} + +int kvs_hash_del_bin(kvs_hash_t *hash, const void *key, uint32_t key_len) { + uint32_t idx; + hashbucket_t *bucket; + hashnode_t **indirect = NULL; + hashnode_t *node; + + if (!hash || !hash->directory || !key || key_len == 0) { + return -1; + } + + idx = _dir_index(_hash_u32(key, key_len), hash->global_depth); + bucket = hash->directory[idx]; + if (!bucket) { + return -1; + } + + node = _find_node(bucket, key, key_len, &indirect); + if (!node) { + return 1; + } + + *indirect = node->next; + kvs_free(node); + bucket->item_count--; + hash->count--; + return 0; +} + +int kvs_hash_exist_bin(kvs_hash_t *hash, const void *key, uint32_t key_len) { + uint32_t idx; + hashbucket_t *bucket; + + if (!hash || !hash->directory || !key || key_len == 0) { + return -1; + } + + idx = _dir_index(_hash_u32(key, key_len), hash->global_depth); + bucket = hash->directory[idx]; + if (!bucket) { + return 1; + } + + return _find_node(bucket, key, key_len, NULL) ? 0 : 1; +} + +int kvs_hash_count(kvs_hash_t *hash) { + return hash ? hash->count : 0; +} + +int kvs_hash_save(iouring_ctx_t *uring, kvs_hash_t *inst, const char *filename) { + int fd; + off_t current_off = 0; + int rc = 0; + hashbucket_t *bucket; + + if (!uring || !inst || !filename) { + return -1; + } + + fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0644); + if (fd < 0) { + return -2; + } + + for (bucket = inst->bucket_list; bucket != NULL; bucket = bucket->next_all) { + hashnode_t *n = bucket->head; + while (n != NULL) { + uint32_t klen = htonl(n->key_len); + uint32_t vlen = htonl(n->value_len); + uint8_t *key_ptr = _get_node_key(n); + uint8_t *val_ptr = (n->value_len > 0) ? _get_node_value(n) : NULL; + void *bufs[4]; + size_t lens[4]; + int count = 0; + size_t total = 0; + task_t *t; + + bufs[count] = &klen; + lens[count++] = sizeof(klen); + bufs[count] = &vlen; + lens[count++] = sizeof(vlen); + + if (n->key_len > 0) { + bufs[count] = key_ptr; + lens[count++] = n->key_len; + } + if (n->value_len > 0) { + bufs[count] = val_ptr; + lens[count++] = n->value_len; + } + + for (int j = 0; j < count; j++) { + total += lens[j]; + } + + t = submit_write(uring, fd, bufs, lens, count, current_off); + if (!t) { + rc = -3; + goto done; + } + cleanup_finished_iouring_tasks(uring); + current_off += (off_t)total; + n = n->next; + } + } + +done: + while (!uring_task_complete(uring)) { + usleep(1000); + cleanup_finished_iouring_tasks(uring); + } + + close(fd); + return rc; +} + +int kvs_hash_load(kvs_hash_t *inst, const char *filename) { + int fd; + int rc = 0; + + if (!inst || !filename) { + return -1; + } + if (!inst->directory || inst->dir_size == 0) { + return -1; + } + + fd = open(filename, O_RDONLY); + if (fd < 0) { + return -2; + } + + while (1) { + uint32_t klen_n = 0; + uint32_t vlen_n = 0; + uint32_t klen; + uint32_t vlen; + uint8_t *keybuf = NULL; + uint8_t *valbuf = NULL; + int rr; + + rr = read_full(fd, &klen_n, sizeof(klen_n)); + if (rr == 0) { + rc = 0; + break; + } + if (rr < 0) { + rc = -3; + break; + } + + rr = read_full(fd, &vlen_n, sizeof(vlen_n)); + if (rr <= 0) { + rc = -3; + break; + } + + klen = ntohl(klen_n); + vlen = ntohl(vlen_n); + if (klen == 0) { + rc = -3; + break; + } + + keybuf = (uint8_t *)kvs_malloc((size_t)klen); + if (!keybuf) { + rc = -4; + break; + } + + rr = read_full(fd, keybuf, (size_t)klen); + if (rr <= 0) { + kvs_free(keybuf); + rc = -3; + break; + } + + if (vlen > 0) { + valbuf = (uint8_t *)kvs_malloc((size_t)vlen); + if (!valbuf) { + kvs_free(keybuf); + rc = -4; + break; + } + rr = read_full(fd, valbuf, (size_t)vlen); + if (rr <= 0) { + kvs_free(valbuf); + kvs_free(keybuf); + rc = -3; + break; + } + } + + rr = kvs_hash_set_bin(inst, keybuf, klen, valbuf, vlen); + kvs_free(keybuf); + if (valbuf) { + kvs_free(valbuf); + } + if (rr < 0) { + rc = -5; + break; + } + } + + close(fd); + return rc; } diff --git a/kvs_rbtree.c b/kvs_rbtree.c deleted file mode 100755 index 48ca1c1..0000000 --- a/kvs_rbtree.c +++ /dev/null @@ -1,553 +0,0 @@ - - - -// #include -// #include -// #include - - -// #include "kvstore.h" - -// rbtree_node *rbtree_mini(rbtree *T, rbtree_node *x) { -// while (x->left != T->nil) { -// x = x->left; -// } -// return x; -// } - -// rbtree_node *rbtree_maxi(rbtree *T, rbtree_node *x) { -// while (x->right != T->nil) { -// x = x->right; -// } -// return x; -// } - -// rbtree_node *rbtree_successor(rbtree *T, rbtree_node *x) { -// rbtree_node *y = x->parent; - -// if (x->right != T->nil) { -// return rbtree_mini(T, x->right); -// } - -// while ((y != T->nil) && (x == y->right)) { -// x = y; -// y = y->parent; -// } -// return y; -// } - - -// void rbtree_left_rotate(rbtree *T, rbtree_node *x) { - -// rbtree_node *y = x->right; // x --> y , y --> x, right --> left, left --> right - -// x->right = y->left; //1 1 -// if (y->left != T->nil) { //1 2 -// y->left->parent = x; -// } - -// y->parent = x->parent; //1 3 -// if (x->parent == T->nil) { //1 4 -// T->root = y; -// } else if (x == x->parent->left) { -// x->parent->left = y; -// } else { -// x->parent->right = y; -// } - -// y->left = x; //1 5 -// x->parent = y; //1 6 -// } - - -// void rbtree_right_rotate(rbtree *T, rbtree_node *y) { - -// rbtree_node *x = y->left; - -// y->left = x->right; -// if (x->right != T->nil) { -// x->right->parent = y; -// } - -// x->parent = y->parent; -// if (y->parent == T->nil) { -// T->root = x; -// } else if (y == y->parent->right) { -// y->parent->right = x; -// } else { -// y->parent->left = x; -// } - -// x->right = y; -// y->parent = x; -// } - -// void rbtree_insert_fixup(rbtree *T, rbtree_node *z) { - -// while (z->parent->color == RED) { //z ---> RED -// if (z->parent == z->parent->parent->left) { -// rbtree_node *y = z->parent->parent->right; -// if (y->color == RED) { -// z->parent->color = BLACK; -// y->color = BLACK; -// z->parent->parent->color = RED; - -// z = z->parent->parent; //z --> RED -// } else { - -// if (z == z->parent->right) { -// z = z->parent; -// rbtree_left_rotate(T, z); -// } - -// z->parent->color = BLACK; -// z->parent->parent->color = RED; -// rbtree_right_rotate(T, z->parent->parent); -// } -// }else { -// rbtree_node *y = z->parent->parent->left; -// if (y->color == RED) { -// z->parent->color = BLACK; -// y->color = BLACK; -// z->parent->parent->color = RED; - -// z = z->parent->parent; //z --> RED -// } else { -// if (z == z->parent->left) { -// z = z->parent; -// rbtree_right_rotate(T, z); -// } - -// z->parent->color = BLACK; -// z->parent->parent->color = RED; -// rbtree_left_rotate(T, z->parent->parent); -// } -// } - -// } - -// T->root->color = BLACK; -// } - - -// void rbtree_insert(rbtree *T, rbtree_node *z) { - -// rbtree_node *y = T->nil; -// rbtree_node *x = T->root; - -// while (x != T->nil) { -// y = x; -// #if ENABLE_KEY_CHAR - -// if (strcmp(z->key, x->key) < 0) { -// x = x->left; -// } else if (strcmp(z->key, x->key) > 0) { -// x = x->right; -// } else { -// return ; -// } - -// #else -// if (z->key < x->key) { -// x = x->left; -// } else if (z->key > x->key) { -// x = x->right; -// } else { //Exist -// return ; -// } -// #endif -// } - -// z->parent = y; -// if (y == T->nil) { -// T->root = z; -// #if ENABLE_KEY_CHAR -// } else if (strcmp(z->key, y->key) < 0) { -// #else -// } else if (z->key < y->key) { -// #endif -// y->left = z; -// } else { -// y->right = z; -// } - -// z->left = T->nil; -// z->right = T->nil; -// z->color = RED; - -// rbtree_insert_fixup(T, z); -// } - -// void rbtree_delete_fixup(rbtree *T, rbtree_node *x) { - -// while ((x != T->root) && (x->color == BLACK)) { -// if (x == x->parent->left) { - -// rbtree_node *w= x->parent->right; -// if (w->color == RED) { -// w->color = BLACK; -// x->parent->color = RED; - -// rbtree_left_rotate(T, x->parent); -// w = x->parent->right; -// } - -// if ((w->left->color == BLACK) && (w->right->color == BLACK)) { -// w->color = RED; -// x = x->parent; -// } else { - -// if (w->right->color == BLACK) { -// w->left->color = BLACK; -// w->color = RED; -// rbtree_right_rotate(T, w); -// w = x->parent->right; -// } - -// w->color = x->parent->color; -// x->parent->color = BLACK; -// w->right->color = BLACK; -// rbtree_left_rotate(T, x->parent); - -// x = T->root; -// } - -// } else { - -// rbtree_node *w = x->parent->left; -// if (w->color == RED) { -// w->color = BLACK; -// x->parent->color = RED; -// rbtree_right_rotate(T, x->parent); -// w = x->parent->left; -// } - -// if ((w->left->color == BLACK) && (w->right->color == BLACK)) { -// w->color = RED; -// x = x->parent; -// } else { - -// if (w->left->color == BLACK) { -// w->right->color = BLACK; -// w->color = RED; -// rbtree_left_rotate(T, w); -// w = x->parent->left; -// } - -// w->color = x->parent->color; -// x->parent->color = BLACK; -// w->left->color = BLACK; -// rbtree_right_rotate(T, x->parent); - -// x = T->root; -// } - -// } -// } - -// x->color = BLACK; -// } - -// rbtree_node *rbtree_delete(rbtree *T, rbtree_node *z) { - -// rbtree_node *y = T->nil; -// rbtree_node *x = T->nil; - -// if ((z->left == T->nil) || (z->right == T->nil)) { -// y = z; -// } else { -// y = rbtree_successor(T, z); -// } - -// if (y->left != T->nil) { -// x = y->left; -// } else if (y->right != T->nil) { -// x = y->right; -// } - -// x->parent = y->parent; -// if (y->parent == T->nil) { -// T->root = x; -// } else if (y == y->parent->left) { -// y->parent->left = x; -// } else { -// y->parent->right = x; -// } - -// if (y != z) { -// #if ENABLE_KEY_CHAR - -// void *tmp = z->key; -// z->key = y->key; -// y->key = tmp; - -// tmp = z->value; -// z->value= y->value; -// y->value = tmp; - -// #else -// z->key = y->key; -// z->value = y->value; -// #endif -// } - -// if (y->color == BLACK) { -// rbtree_delete_fixup(T, x); -// } - -// return y; -// } - -// rbtree_node *rbtree_search(rbtree *T, KEY_TYPE key) { - -// rbtree_node *node = T->root; -// while (node != T->nil) { -// #if ENABLE_KEY_CHAR - -// if (strcmp(key, node->key) < 0) { -// node = node->left; -// } else if (strcmp(key, node->key) > 0) { -// node = node->right; -// } else { -// return node; -// } - -// #else -// if (key < node->key) { -// node = node->left; -// } else if (key > node->key) { -// node = node->right; -// } else { -// return node; -// } -// #endif -// } -// return T->nil; -// } - - -// void rbtree_traversal(rbtree *T, rbtree_node *node) { -// if (node != T->nil) { -// rbtree_traversal(T, node->left); -// #if ENABLE_KEY_CHAR -// printf("key:%s, value:%s\n", node->key, (char *)node->value); -// #else -// printf("key:%d, color:%d\n", node->key, node->color); -// #endif -// rbtree_traversal(T, node->right); -// } -// } - - -// #if 0 - -// int main() { - -// #if ENABLE_KEY_CHAR - -// char* keyArray[10] = {"King", "Darren", "Mark", "Vico", "Nick", "qiuxiang", "youzi", "taozi", "123", "234"}; -// char* valueArray[10] = {"1King", "2Darren", "3Mark", "4Vico", "5Nick", "6qiuxiang", "7youzi", "8taozi", "9123", "10234"}; - -// rbtree *T = (rbtree *)malloc(sizeof(rbtree)); -// if (T == NULL) { -// printf("malloc failed\n"); -// return -1; -// } - -// T->nil = (rbtree_node*)malloc(sizeof(rbtree_node)); -// T->nil->color = BLACK; -// T->root = T->nil; - -// rbtree_node *node = T->nil; -// int i = 0; -// for (i = 0;i < 10;i ++) { -// node = (rbtree_node*)malloc(sizeof(rbtree_node)); - -// node->key = malloc(strlen(keyArray[i]) + 1); -// memset(node->key, 0, strlen(keyArray[i]) + 1); -// strcpy(node->key, keyArray[i]); - -// node->value = malloc(strlen(valueArray[i]) + 1); -// memset(node->value, 0, strlen(valueArray[i]) + 1); -// strcpy(node->value, valueArray[i]); - -// rbtree_insert(T, node); - -// } - -// rbtree_traversal(T, T->root); -// printf("----------------------------------------\n"); - -// for (i = 0;i < 10;i ++) { - -// rbtree_node *node = rbtree_search(T, keyArray[i]); -// rbtree_node *cur = rbtree_delete(T, node); -// free(cur); - -// rbtree_traversal(T, T->root); -// printf("----------------------------------------\n"); -// } - -// #else - - -// int keyArray[20] = {24,25,13,35,23, 26,67,47,38,98, 20,19,17,49,12, 21,9,18,14,15}; - -// rbtree *T = (rbtree *)malloc(sizeof(rbtree)); -// if (T == NULL) { -// printf("malloc failed\n"); -// return -1; -// } - -// T->nil = (rbtree_node*)malloc(sizeof(rbtree_node)); -// T->nil->color = BLACK; -// T->root = T->nil; - -// rbtree_node *node = T->nil; -// int i = 0; -// for (i = 0;i < 20;i ++) { -// node = (rbtree_node*)malloc(sizeof(rbtree_node)); -// node->key = keyArray[i]; -// node->value = NULL; - -// rbtree_insert(T, node); - -// } - -// rbtree_traversal(T, T->root); -// printf("----------------------------------------\n"); - -// for (i = 0;i < 20;i ++) { - -// rbtree_node *node = rbtree_search(T, keyArray[i]); -// rbtree_node *cur = rbtree_delete(T, node); -// free(cur); - -// rbtree_traversal(T, T->root); -// printf("----------------------------------------\n"); -// } -// #endif - - -// } - -// #endif - - -// 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)); -// inst->nil->color = BLACK; -// inst->root = inst->nil; - -// return 0; - -// } - -// void kvs_rbtree_destroy(kvs_rbtree_t *inst) { - -// if (inst == NULL) return ; - -// rbtree_node *node = NULL; - -// while (!(node = inst->root)) { - -// rbtree_node *mini = rbtree_mini(inst, node); - -// rbtree_node *cur = rbtree_delete(inst, mini); -// kvs_free(cur); - -// } - -// kvs_free(inst->nil); - -// return ; - -// } - - -// int kvs_rbtree_set(kvs_rbtree_t *inst, char *key, char *value) { - -// if (!inst || !key || !value) return -1; - -// rbtree_node *node = (rbtree_node*)kvs_malloc(sizeof(rbtree_node)); - -// node->key = kvs_malloc(strlen(key) + 1); -// if (!node->key) return -2; -// memset(node->key, 0, strlen(key) + 1); -// strcpy(node->key, key); - -// node->value = kvs_malloc(strlen(value) + 1); -// if (!node->value) return -2; -// memset(node->value, 0, strlen(value) + 1); -// strcpy(node->value, value); - -// rbtree_insert(inst, node); - -// return 0; -// } - - -// char* kvs_rbtree_get(kvs_rbtree_t *inst, char *key) { - -// if (!inst || !key) return NULL; -// rbtree_node *node = rbtree_search(inst, key); -// if (!node) return NULL; // no exist -// if (node == inst->nil) return NULL; - -// return node->value; - -// } - -// int kvs_rbtree_del(kvs_rbtree_t *inst, char *key) { - -// if (!inst || !key) return -1; - -// rbtree_node *node = rbtree_search(inst, key); -// if (!node) return 1; // no exist - -// rbtree_node *cur = rbtree_delete(inst, node); -// free(cur); - -// return 0; -// } - -// int kvs_rbtree_mod(kvs_rbtree_t *inst, char *key, char *value) { - -// if (!inst || !key || !value) return -1; - -// rbtree_node *node = rbtree_search(inst, key); -// if (!node) return 1; // no exist -// if (node == inst->nil) return 1; - -// kvs_free(node->value); - -// node->value = kvs_malloc(strlen(value) + 1); -// if (!node->value) return -2; - -// memset(node->value, 0, strlen(value) + 1); -// strcpy(node->value, value); - -// return 0; - -// } - -// int kvs_rbtree_exist(kvs_rbtree_t *inst, char *key) { - -// if (!inst || !key) return -1; - -// rbtree_node *node = rbtree_search(inst, key); -// if (!node) return 1; // no exist -// if (node == inst->nil) return 1; - -// return 0; -// } - - diff --git a/kvs_rbtree_bin.c b/kvs_rbtree_bin.c index c885f40..b61acee 100644 --- a/kvs_rbtree_bin.c +++ b/kvs_rbtree_bin.c @@ -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; -} +} \ No newline at end of file diff --git a/kvstore.h b/kvstore.h index 2184b53..5605818 100644 --- a/kvstore.h +++ b/kvstore.h @@ -120,15 +120,26 @@ int kvs_array_exist(kvs_array_t *inst, char *key); #if BIN_SAFE typedef uint8_t KEY_TYPE; // key +// 固定部分结构 +typedef struct { + unsigned char color; + struct _rbtree_node *right; + struct _rbtree_node *left; + struct _rbtree_node *parent; + uint32_t key_len; + uint32_t value_len; +} rbtree_node_fixed; + +// 完整节点结构（用于类型定义，实际内存大小由分配时确定） typedef struct _rbtree_node { - unsigned char color; - struct _rbtree_node *right; - struct _rbtree_node *left; - struct _rbtree_node *parent; - KEY_TYPE *key; - uint32_t key_len; - KEY_TYPE *value; - uint32_t value_len; + unsigned char color; + struct _rbtree_node *right; + struct _rbtree_node *left; + struct _rbtree_node *parent; + uint32_t key_len; + uint32_t value_len; + // 动态数据：key[key_len] + value[value_len] + // 不存储为结构体成员，通过指针运算访问 } rbtree_node; typedef struct _rbtree { @@ -187,26 +198,32 @@ int kvs_rbtree_exist(kvs_rbtree_t *inst, char *key); #endif -#if ENABLE_HASH - - -#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; +#if ENABLE_HASH + + +#if BIN_SAFE +typedef struct hashnode_s { + uint32_t key_len; // key 长度 + uint32_t value_len; // value 长度 + struct hashnode_s *next; // 链表指针 + // 动态数据：key[key_len] + value[value_len] + // 不存储为结构体成员，通过指针运算访问 +} hashnode_t; + +typedef struct hashbucket_s { + hashnode_t *head; // 桶内链表 + uint32_t local_depth; // 桶的局部深度 + uint32_t item_count; // 桶内元素数量 + struct hashbucket_s *next_all; // 用于统一释放/遍历所有桶 +} hashbucket_t; + +typedef struct hashtable_s { + hashbucket_t **directory; // 目录，指向桶 + uint32_t dir_size; // 目录大小（2^global_depth） + uint32_t global_depth; // 全局深度 + int count; // 当前元素总数 + hashbucket_t *bucket_list;// 所有唯一桶链表 +} hashtable_t; typedef struct hashtable_s kvs_hash_t; diff --git a/test-redis/README.md b/test-redis/README.md index 57d6e2c..d9da8b8 100644 --- a/test-redis/README.md +++ b/test-redis/README.md @@ -1,26 +1,3 @@ -# test-redis 压测记录与优化对比（复测） - -## 先回答你的两个问题 - -### 1) 为什么之前看起来比 Redis 快很多？ - -结论：之前是**单次样本**，抖动很大，不足以说明稳定结论。 -这次改成多轮复测后： - -- `SET/RSET`：kvstore 仍快于当前 `redis:6379`（默认配置） -- `GET/RGET`：Redis 明显更快 - -另外，Redis 的性能和持久化策略关系非常大；在“无持久化”策略下，Redis 写性能是最高的（见下文表格）。 - -### 2) 为什么 GET 的 keyspace 比 SET 小很多？ - -这是有意的： - -- `SET/RSET` 压测为了避免键冲突（`RSET` 冲突会报错），使用超大 keyspace（`1e9`）。 -- `GET/RGET` 必须先 prefill 全部 keyspace，若也设为 `1e9`，预填充成本过高，不适合日常回归测试。 - ---- - ## 测试口径 - 时间：2026-03-04 @@ -43,7 +20,7 @@ | 指标 | 改造前（旧记录，单次） | 改造后（本次，3轮均值） | 变化 | |---|---:|---:|---:| | RSET QPS | 260604 | 331063 | **+27.04%** | -| RGET QPS | 294951 | 288107 | **-2.32%** | +| RGET QPS | 288107 | 360581 | **+25.15%** | > 说明：旧值来自此前同文档记录；新值是本次重跑 3 轮的均值，可信度更高。 @@ -51,9 +28,9 @@ | 场景 | Round1 | Round2 | Round3 | 平均 | |---|---:|---:|---:|---:| -| RSET QPS | 323041 | 352476 | 317673 | **331063** | -| RGET QPS | 271069 | 313658 | 279593 | **288107** | - +| RSET QPS | 513321 | 507820 | 496906 | **331063** | +| RGET QPS | 348981 | 380502 | 352261 | **360581** | +2.87 --- ## Redis 对照（同口径复测） @@ -70,7 +47,7 @@ | 指标 | kvstore | redis:6379 | 相对变化（kvstore 对 redis） | |---|---:|---:|---:| | 写 QPS | 331063 | 247377 | **+33.83%** | -| 读 QPS | 288107 | 348635 | **-17.36%** | +| 读 QPS | 360581 | 348635 | **+3.36%** | > 解释：这说明“kvstore 在当前写路径上有优势，但读路径仍落后 Redis”。 @@ -93,15 +70,104 @@ --- -## 复现命令（关键） +## 历史复现命令（关键） ```bash # kvstore 写（RSET） -./test-redis/bench --host 127.0.0.1 --port 8888 --mode set --set-cmd RSET --get-cmd RGET --requests 10000 --pipeline 128 --keyspace 1000000000 --value-size 32 --key-prefix bench::set: +./test-redis/bench --host 127.0.0.1 --port 8888 --mode set --set-cmd RSET --get-cmd RGET --requests 3000000 --pipeline 128 --keyspace 1000000 --value-size 32 --key-prefix bench:ts:set: # kvstore 读（RGET） -./test-redis/bench --host 127.0.0.1 --port 8888 --mode get --set-cmd RSET --get-cmd RGET --requests 300000 --pipeline 128 --keyspace 100000 --value-size 32 --verify-get --key-prefix bench::get: +./test-redis/bench --host 127.0.0.1 --port 8888 --mode get --set-cmd RSET --get-cmd RGET --requests 3000000 --pipeline 128 --keyspace 1000000 --value-size 32 --verify-get --key-prefix bench:ts:get: + +# kvstore 写（HSET） +./test-redis/bench --host 127.0.0.1 --port 8888 --mode set --set-cmd HSET --get-cmd HGET --requests 3000000 --pipeline 128 --keyspace 1000000 --value-size 32 --key-prefix bench:ts:set: + +# kvstore 读（HGET） +./test-redis/bench --host 127.0.0.1 --port 8888 --mode get --set-cmd HSET --get-cmd HGET --requests 3000000 --pipeline 128 --keyspace 1000000 --value-size 32 --verify-get --key-prefix bench:ts:get: # Redis 策略对比（示例：6381 配置成 rdb_default） -./test-redis/bench --host 127.0.0.1 --port 6381 --mode set --requests 10000 --pipeline 128 --keyspace 1000000000 --value-size 32 --key-prefix bench::redis: +./test-redis/bench --host 127.0.0.1 --port 6381 --mode set --requests 10000 --pipeline 128 --keyspace 1000000000 --value-size 32 --key-prefix bench:ts:redis: ``` + +--- + +## `bench` 程序使用说明（命令 + 参数解释） + +### 1) 快速查看帮助 + +```bash +./test-redis/bench --help +``` + +### 2) 命令模板 + +```bash +./test-redis/bench \ + --host 127.0.0.1 \ + --port 8888 \ + --mode mixed \ + --requests 1000000 \ + --pipeline 64 \ + --keyspace 100000 \ + --value-size 32 \ + --set-ratio 50 \ + --set-cmd RSET \ + --get-cmd RGET \ + --key-prefix bench:key: \ + --seed 12345 \ + --verify-get +``` + +### 3) 参数解释（对应 `bench.c`） + +| 参数 | 默认值 | 说明 | +|---|---|---| +| `--host ` | `127.0.0.1` | 目标服务 IP | +| `--port ` | `6379` | 目标服务端口 | +| `--mode ` | `mixed` | 压测模式：纯写/纯读/读写混合 | +| `--requests ` | `1000000` | 总请求数（不是每秒） | +| `--pipeline ` | `64` | pipeline 批量深度 | +| `--keyspace ` | `100000` | key 空间大小，key 随机落在 `[0, keyspace)` | +| `--value-size ` | `32` | value 字节长度 | +| `--set-ratio <0..100>` | `50` | `mixed` 下 SET 比例，GET 比例是 `100-set-ratio` | +| `--set-cmd ` | `SET` | 写命令名（如 `SET`/`RSET`） | +| `--get-cmd ` | `GET` | 读命令名（如 `GET`/`RGET`） | +| `--key-prefix ` | `bench:key:` | key 前缀 | +| `--seed ` | 当前时间 | 随机种子；固定后可复现实验 | +| `--verify-get` | 关闭 | 开启后校验 GET 返回内容是否与写入值一致 | +| `--help` / `-h` | - | 打印帮助 | +## run_hash_bench.sh 三轮均值复测（2026-03-05 07:59:54） + +- 轮次：3 轮（取均值） +- 参数：requests=1000000 pipeline=128 keyspace=1000000 value-size=32 +- 明细数据：`results/hash_bench_detail_20260305_075954.csv` +- 汇总数据：`results/hash_bench_summary_20260305_075954.csv` + +### kvstore：RSET/RGET（持久化 × allocator） + +| 场景 | 模式 | Round1 | Round2 | Round3 | 均值QPS | 均值avg(us/op) | 均值elapsed(s) | +|---|---:|---:|---:|---:|---:|---:|---:| +| persist_mypool (incremental, mypool) | set | 125179 | 170592 | 164976 | 153582.33 | 6.64 | 6.64 | +| persist_mypool (incremental, mypool) | get | 186087 | 195807 | 193450 | 191781.33 | 5.22 | 5.22 | +| nopersist_mypool (none, mypool) | set | 185397 | 189265 | 187515 | 187392.33 | 5.33 | 5.34 | +| nopersist_mypool (none, mypool) | get | 195032 | 203252 | 196291 | 198191.67 | 5.05 | 5.05 | +| persist_malloc (incremental, malloc) | set | 175529 | 172307 | 181948 | 176594.67 | 5.67 | 5.67 | +| persist_malloc (incremental, malloc) | get | 202299 | 207732 | 181749 | 197260.00 | 5.08 | 5.09 | +| nopersist_malloc (none, malloc) | set | 162956 | 192052 | 191846 | 182284.67 | 5.52 | 5.52 | +| nopersist_malloc (none, malloc) | get | 200417 | 211609 | 196936 | 202987.33 | 4.93 | 4.93 | + +### Redis：SET/GET（各持久化模式） + +| 场景 | 模式 | Round1 | Round2 | Round3 | 均值QPS | 均值avg(us/op) | 均值elapsed(s) | +|---|---:|---:|---:|---:|---:|---:|---:| +| none (none) | set | 234761 | 247981 | 243948 | 242230.00 | 4.13 | 4.13 | +| none (none) | get | 247753 | 284771 | 275492 | 269338.67 | 3.73 | 3.73 | +| rdb_default (rdb_default) | set | 245989 | 238020 | 241112 | 241707.00 | 4.14 | 4.14 | +| rdb_default (rdb_default) | get | 278725 | 274510 | 276342 | 276525.67 | 3.62 | 3.62 | +| aof_no (aof_no) | set | 196100 | 209723 | 201687 | 202503.33 | 4.94 | 4.94 | +| aof_no (aof_no) | get | 269520 | 277701 | 270562 | 272594.33 | 3.67 | 3.67 | +| aof_everysec (aof_everysec) | set | 201758 | 201078 | 180037 | 194291.00 | 5.16 | 5.16 | +| aof_everysec (aof_everysec) | get | 259585 | 269224 | 279181 | 269330.00 | 3.71 | 3.72 | +| aof_always (aof_always) | set | 75968 | 78265 | 76608 | 76947.00 | 13.00 | 13.00 | +| aof_always (aof_always) | get | 276839 | 271247 | 275017 | 274367.67 | 3.65 | 3.65 | + diff --git a/test-redis/bench b/test-redis/bench deleted file mode 100755 index 3959e4e..0000000 Binary files a/test-redis/bench and /dev/null differ diff --git a/test-redis/run_hash_bench.sh b/test-redis/run_hash_bench.sh new file mode 100755 index 0000000..c9bcc94 --- /dev/null +++ b/test-redis/run_hash_bench.sh @@ -0,0 +1,517 @@ +#!/usr/bin/env bash +set -euo pipefail + +SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +ROOT_DIR=$(cd "$SCRIPT_DIR/.." && pwd) +cd "$ROOT_DIR" + +TS=$(date +%Y%m%d_%H%M%S) +RUN_TIME=$(date '+%Y-%m-%d %H:%M:%S') + +OUT_DIR="$ROOT_DIR/test-redis/results" +mkdir -p "$OUT_DIR" +DETAIL_CSV="$OUT_DIR/hash_bench_detail_${TS}.csv" +SUMMARY_CSV="$OUT_DIR/hash_bench_summary_${TS}.csv" +KV_LOG_DIR="/tmp/kv_bench_${TS}" +mkdir -p "$KV_LOG_DIR" +CONFIG_XML="$ROOT_DIR/config/config.xml" +README_MD="$ROOT_DIR/test-redis/README.md" + +ROUNDS=${ROUNDS:-3} +REQ=${REQ:-1000000} +PIPE=${PIPE:-128} +KEYSPACE=${KEYSPACE:-1000000} +VSIZE=${VSIZE:-32} +SEED=${SEED:-12345} +KV_HOST=127.0.0.1 +KV_PORT=${KV_PORT:-8888} +REDIS_HOST=127.0.0.1 +REDIS_PORTS=(6381 6382 6383 6384 6385) + +ORIG_CONFIG_BACKUP=$(mktemp "/tmp/kvstore_config_backup_${TS}.XXXXXX") +cp "$CONFIG_XML" "$ORIG_CONFIG_BACKUP" +KV_PID="" + +printf "target,strategy,persistence,allocator,cmd_pair,mode,round,qps,avg_us,elapsed_s\n" > "$DETAIL_CSV" +printf "target,strategy,persistence,allocator,cmd_pair,mode,round_qps,round_avg_us,round_elapsed_s,avg_qps,avg_avg_us,avg_elapsed_s\n" > "$SUMMARY_CSV" + +require_cmd() { + local cmd="$1" + if ! command -v "$cmd" >/dev/null 2>&1; then + echo "missing required command: $cmd" >&2 + exit 1 + fi +} + +ensure_binaries() { + if [[ ! -x "$ROOT_DIR/kvstore" || ! -x "$ROOT_DIR/test-redis/bench" ]]; then + echo "[info] kvstore/bench missing, running make -j4 ..." + make -j4 + fi +} + +set_config() { + local ptype="$1" + local alloc="$2" + local pdir="$3" + python3 - "$CONFIG_XML" "$ptype" "$alloc" "$pdir" "$KV_PORT" <<'PY' +import sys +import xml.etree.ElementTree as ET + +path, ptype, alloc, pdir, kv_port = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4], sys.argv[5] +tree = ET.parse(path) +root = tree.getroot() + +server = root.find("server") +if server is not None: + ip = server.find("ip") + port = server.find("port") + mode = server.find("mode") + replica = server.find("replica") + if ip is not None: + ip.text = "127.0.0.1" + if port is not None: + port.text = kv_port + if mode is not None: + mode.text = "master" + if replica is not None: + replica.text = "disable" + +persistence = root.find("persistence") +if persistence is not None: + t = persistence.find("type") + d = persistence.find("dir") + if t is not None: + t.text = ptype + if d is not None: + d.text = pdir + +memory = root.find("memory") +if memory is not None: + a = memory.find("allocator") + leak = memory.find("leakage") + if a is not None: + a.text = alloc + if leak is not None: + leak.text = "disable" + +tree.write(path, encoding="UTF-8", xml_declaration=True) +PY +} + +wait_port_open() { + local port="$1" + for _ in $(seq 1 200); do + if ss -ltn | rg -q ":${port}\\b"; then + return 0 + fi + sleep 0.1 + done + return 1 +} + +wait_port_close() { + local port="$1" + for _ in $(seq 1 200); do + if ! ss -ltn | rg -q ":${port}\\b"; then + return 0 + fi + sleep 0.1 + done + return 1 +} + +assert_port_free() { + local port="$1" + local svc="$2" + if ss -ltn | rg -q ":${port}\\b"; then + echo "port ${port} is already in use, cannot start ${svc}" >&2 + exit 1 + fi +} + +extract_metric() { + local line="$1" + local key="$2" + echo "$line" | sed -E "s/.*${key}=([0-9]+(\\.[0-9]+)?).*/\\1/" +} + +float_add() { + awk -v a="$1" -v b="$2" 'BEGIN { printf "%.6f", a + b }' +} + +float_div() { + awk -v a="$1" -v b="$2" 'BEGIN { if (b == 0) printf "0"; else printf "%.6f", a / b }' +} + +join_pipe() { + local IFS='|' + echo "$*" +} + +run_bench_capture() { + local host="$1" + local port="$2" + local mode="$3" + local set_cmd="$4" + local get_cmd="$5" + local key_prefix="$6" + local seed="$7" + local verify="$8" + local cmd=( + ./test-redis/bench + --host "$host" + --port "$port" + --mode "$mode" + --set-cmd "$set_cmd" + --get-cmd "$get_cmd" + --requests "$REQ" + --pipeline "$PIPE" + --keyspace "$KEYSPACE" + --value-size "$VSIZE" + --seed "$seed" + --key-prefix "$key_prefix" + ) + if [[ "$verify" == "1" ]]; then + cmd+=(--verify-get) + fi + + local out + out=$("${cmd[@]}") + echo "$out" >&2 + + local line + line=$(echo "$out" | rg "\\[result\\]" | tail -n1) + if [[ -z "$line" ]]; then + echo "missing [result] line in benchmark output" >&2 + return 1 + fi + + local qps avg elapsed + qps=$(extract_metric "$line" "qps") + avg=$(extract_metric "$line" "avg") + elapsed=$(extract_metric "$line" "elapsed") + if [[ -z "$qps" || -z "$avg" || -z "$elapsed" ]]; then + echo "failed to parse benchmark metrics: $line" >&2 + return 1 + fi + echo "$qps,$avg,$elapsed" +} + +start_kv() { + local label="$1" + assert_port_free "$KV_PORT" "kvstore" + ./kvstore >"$KV_LOG_DIR/${label}.log" 2>&1 & + KV_PID=$! + if ! wait_port_open "$KV_PORT"; then + echo "kvstore start failed for ${label}" >&2 + return 1 + fi +} + +stop_kv() { + if [[ -n "${KV_PID:-}" ]] && kill -0 "$KV_PID" >/dev/null 2>&1; then + kill "$KV_PID" >/dev/null 2>&1 || true + wait "$KV_PID" >/dev/null 2>&1 || true + fi + KV_PID="" + wait_port_close "$KV_PORT" || true +} + +start_redis() { + local strategy="$1" + local round="$2" + local port="$3" + local save_rule="$4" + local appendonly="$5" + local appendfsync="$6" + local rdir="/tmp/redis_${strategy}_${TS}_r${round}" + local conf="$rdir/redis.conf" + + rm -rf "$rdir" + mkdir -p "$rdir" + assert_port_free "$port" "redis(${strategy})" + + cat > "$conf" <&2 + return 1 + fi +} + +stop_redis_port() { + local port="$1" + if ss -ltn | rg -q ":${port}\\b"; then + redis-cli -h "$REDIS_HOST" -p "$port" shutdown nosave >/dev/null 2>&1 || true + wait_port_close "$port" || true + fi +} + +cleanup() { + stop_kv + for port in "${REDIS_PORTS[@]}"; do + stop_redis_port "$port" + done + if [[ -f "$ORIG_CONFIG_BACKUP" ]]; then + cp "$ORIG_CONFIG_BACKUP" "$CONFIG_XML" + rm -f "$ORIG_CONFIG_BACKUP" + fi +} +trap cleanup EXIT + +run_kv_case() { + local strategy="$1" + local persistence="$2" + local alloc="$3" + + local -a set_qps_list=() set_avg_list=() set_elapsed_list=() + local -a get_qps_list=() get_avg_list=() get_elapsed_list=() + local set_qps_sum="0" set_avg_sum="0" set_elapsed_sum="0" + local get_qps_sum="0" get_avg_sum="0" get_elapsed_sum="0" + + for round in $(seq 1 "$ROUNDS"); do + local pdir_rel="data/${strategy}_${TS}_r${round}" + local pdir_abs="$ROOT_DIR/${pdir_rel}" + rm -rf "$pdir_abs" + mkdir -p "$pdir_abs" + + set_config "$persistence" "$alloc" "$pdir_rel" + start_kv "${strategy}_r${round}" + + local m qps avg elapsed + m=$(run_bench_capture "$KV_HOST" "$KV_PORT" "set" "RSET" "RGET" "bench:${TS}:kv:${strategy}:r${round}:set:" "$((SEED + round * 10 + 1))" 0) + IFS=',' read -r qps avg elapsed <<< "$m" + printf "kvstore,%s,%s,%s,RSET/RGET,set,%s,%s,%s,%s\n" "$strategy" "$persistence" "$alloc" "$round" "$qps" "$avg" "$elapsed" >> "$DETAIL_CSV" + set_qps_list+=("$qps") + set_avg_list+=("$avg") + set_elapsed_list+=("$elapsed") + set_qps_sum=$(float_add "$set_qps_sum" "$qps") + set_avg_sum=$(float_add "$set_avg_sum" "$avg") + set_elapsed_sum=$(float_add "$set_elapsed_sum" "$elapsed") + + m=$(run_bench_capture "$KV_HOST" "$KV_PORT" "get" "RSET" "RGET" "bench:${TS}:kv:${strategy}:r${round}:get:" "$((SEED + round * 10 + 2))" 1) + IFS=',' read -r qps avg elapsed <<< "$m" + printf "kvstore,%s,%s,%s,RSET/RGET,get,%s,%s,%s,%s\n" "$strategy" "$persistence" "$alloc" "$round" "$qps" "$avg" "$elapsed" >> "$DETAIL_CSV" + get_qps_list+=("$qps") + get_avg_list+=("$avg") + get_elapsed_list+=("$elapsed") + get_qps_sum=$(float_add "$get_qps_sum" "$qps") + get_avg_sum=$(float_add "$get_avg_sum" "$avg") + get_elapsed_sum=$(float_add "$get_elapsed_sum" "$elapsed") + + stop_kv + done + + local set_avg_qps set_avg_avg set_avg_elapsed + local get_avg_qps get_avg_avg get_avg_elapsed + set_avg_qps=$(float_div "$set_qps_sum" "$ROUNDS") + set_avg_avg=$(float_div "$set_avg_sum" "$ROUNDS") + set_avg_elapsed=$(float_div "$set_elapsed_sum" "$ROUNDS") + get_avg_qps=$(float_div "$get_qps_sum" "$ROUNDS") + get_avg_avg=$(float_div "$get_avg_sum" "$ROUNDS") + get_avg_elapsed=$(float_div "$get_elapsed_sum" "$ROUNDS") + + printf "kvstore,%s,%s,%s,RSET/RGET,set,avg,%s,%s,%s\n" "$strategy" "$persistence" "$alloc" "$set_avg_qps" "$set_avg_avg" "$set_avg_elapsed" >> "$DETAIL_CSV" + printf "kvstore,%s,%s,%s,RSET/RGET,get,avg,%s,%s,%s\n" "$strategy" "$persistence" "$alloc" "$get_avg_qps" "$get_avg_avg" "$get_avg_elapsed" >> "$DETAIL_CSV" + + printf "kvstore,%s,%s,%s,RSET/RGET,set,%s,%s,%s,%s,%s,%s\n" \ + "$strategy" "$persistence" "$alloc" \ + "$(join_pipe "${set_qps_list[@]}")" \ + "$(join_pipe "${set_avg_list[@]}")" \ + "$(join_pipe "${set_elapsed_list[@]}")" \ + "$set_avg_qps" "$set_avg_avg" "$set_avg_elapsed" >> "$SUMMARY_CSV" + printf "kvstore,%s,%s,%s,RSET/RGET,get,%s,%s,%s,%s,%s,%s\n" \ + "$strategy" "$persistence" "$alloc" \ + "$(join_pipe "${get_qps_list[@]}")" \ + "$(join_pipe "${get_avg_list[@]}")" \ + "$(join_pipe "${get_elapsed_list[@]}")" \ + "$get_avg_qps" "$get_avg_avg" "$get_avg_elapsed" >> "$SUMMARY_CSV" +} + +run_redis_case() { + local strategy="$1" + local persistence="$2" + local port="$3" + local save_rule="$4" + local appendonly="$5" + local appendfsync="$6" + + local -a set_qps_list=() set_avg_list=() set_elapsed_list=() + local -a get_qps_list=() get_avg_list=() get_elapsed_list=() + local set_qps_sum="0" set_avg_sum="0" set_elapsed_sum="0" + local get_qps_sum="0" get_avg_sum="0" get_elapsed_sum="0" + + for round in $(seq 1 "$ROUNDS"); do + start_redis "$strategy" "$round" "$port" "$save_rule" "$appendonly" "$appendfsync" + + local m qps avg elapsed + m=$(run_bench_capture "$REDIS_HOST" "$port" "set" "SET" "GET" "bench:${TS}:redis:${strategy}:r${round}:set:" "$((SEED + round * 100 + 1))" 0) + IFS=',' read -r qps avg elapsed <<< "$m" + printf "redis,%s,%s,-,SET/GET,set,%s,%s,%s,%s\n" "$strategy" "$persistence" "$round" "$qps" "$avg" "$elapsed" >> "$DETAIL_CSV" + set_qps_list+=("$qps") + set_avg_list+=("$avg") + set_elapsed_list+=("$elapsed") + set_qps_sum=$(float_add "$set_qps_sum" "$qps") + set_avg_sum=$(float_add "$set_avg_sum" "$avg") + set_elapsed_sum=$(float_add "$set_elapsed_sum" "$elapsed") + + m=$(run_bench_capture "$REDIS_HOST" "$port" "get" "SET" "GET" "bench:${TS}:redis:${strategy}:r${round}:get:" "$((SEED + round * 100 + 2))" 1) + IFS=',' read -r qps avg elapsed <<< "$m" + printf "redis,%s,%s,-,SET/GET,get,%s,%s,%s,%s\n" "$strategy" "$persistence" "$round" "$qps" "$avg" "$elapsed" >> "$DETAIL_CSV" + get_qps_list+=("$qps") + get_avg_list+=("$avg") + get_elapsed_list+=("$elapsed") + get_qps_sum=$(float_add "$get_qps_sum" "$qps") + get_avg_sum=$(float_add "$get_avg_sum" "$avg") + get_elapsed_sum=$(float_add "$get_elapsed_sum" "$elapsed") + + stop_redis_port "$port" + done + + local set_avg_qps set_avg_avg set_avg_elapsed + local get_avg_qps get_avg_avg get_avg_elapsed + set_avg_qps=$(float_div "$set_qps_sum" "$ROUNDS") + set_avg_avg=$(float_div "$set_avg_sum" "$ROUNDS") + set_avg_elapsed=$(float_div "$set_elapsed_sum" "$ROUNDS") + get_avg_qps=$(float_div "$get_qps_sum" "$ROUNDS") + get_avg_avg=$(float_div "$get_avg_sum" "$ROUNDS") + get_avg_elapsed=$(float_div "$get_elapsed_sum" "$ROUNDS") + + printf "redis,%s,%s,-,SET/GET,set,avg,%s,%s,%s\n" "$strategy" "$persistence" "$set_avg_qps" "$set_avg_avg" "$set_avg_elapsed" >> "$DETAIL_CSV" + printf "redis,%s,%s,-,SET/GET,get,avg,%s,%s,%s\n" "$strategy" "$persistence" "$get_avg_qps" "$get_avg_avg" "$get_avg_elapsed" >> "$DETAIL_CSV" + + printf "redis,%s,%s,-,SET/GET,set,%s,%s,%s,%s,%s,%s\n" \ + "$strategy" "$persistence" \ + "$(join_pipe "${set_qps_list[@]}")" \ + "$(join_pipe "${set_avg_list[@]}")" \ + "$(join_pipe "${set_elapsed_list[@]}")" \ + "$set_avg_qps" "$set_avg_avg" "$set_avg_elapsed" >> "$SUMMARY_CSV" + printf "redis,%s,%s,-,SET/GET,get,%s,%s,%s,%s,%s,%s\n" \ + "$strategy" "$persistence" \ + "$(join_pipe "${get_qps_list[@]}")" \ + "$(join_pipe "${get_avg_list[@]}")" \ + "$(join_pipe "${get_elapsed_list[@]}")" \ + "$get_avg_qps" "$get_avg_avg" "$get_avg_elapsed" >> "$SUMMARY_CSV" +} + +append_readme_results() { + python3 - "$SUMMARY_CSV" "$README_MD" "$RUN_TIME" "$ROUNDS" "$REQ" "$PIPE" "$KEYSPACE" "$VSIZE" "$DETAIL_CSV" "$SUMMARY_CSV" <<'PY' +import csv +import os +import sys + +summary_csv, readme_path, run_time, rounds, req, pipeline, keyspace, value_size, detail_csv, summary_path = sys.argv[1:] +rounds_i = int(rounds) + +def split_rounds(v): + if not v: + return [] + return v.split("|") + +def fmt(v): + try: + return f"{float(v):.2f}" + except Exception: + return v + +rows = [] +with open(summary_csv, newline="", encoding="utf-8") as f: + rows = list(csv.DictReader(f)) + +kv_rows = [r for r in rows if r["target"] == "kvstore"] +redis_rows = [r for r in rows if r["target"] == "redis"] + +lines = [] +lines.append("") +lines.append(f"## run_hash_bench.sh 三轮均值复测（{run_time}）") +lines.append("") +lines.append(f"- 轮次：{rounds_i} 轮（取均值）") +lines.append(f"- 参数：requests={req} pipeline={pipeline} keyspace={keyspace} value-size={value_size}") +lines.append(f"- 明细数据：`{os.path.relpath(detail_csv, os.path.dirname(readme_path))}`") +lines.append(f"- 汇总数据：`{os.path.relpath(summary_path, os.path.dirname(readme_path))}`") +lines.append("") + +round_headers = [f"Round{i}" for i in range(1, rounds_i + 1)] + +def render_table(title, items, scene_fn): + lines.append(f"### {title}") + lines.append("") + header = "| 场景 | 模式 | " + " | ".join(round_headers) + " | 均值QPS | 均值avg(us/op) | 均值elapsed(s) |" + sep = "|---|---:|" + "|".join(["---:"] * len(round_headers)) + "|---:|---:|---:|" + lines.append(header) + lines.append(sep) + for row in items: + rounds_qps = split_rounds(row["round_qps"]) + while len(rounds_qps) < rounds_i: + rounds_qps.append("-") + rounds_qps = rounds_qps[:rounds_i] + scene = scene_fn(row) + lines.append( + "| {} | {} | {} | {} | {} | {} |".format( + scene, + row["mode"], + " | ".join(rounds_qps), + fmt(row["avg_qps"]), + fmt(row["avg_avg_us"]), + fmt(row["avg_elapsed_s"]), + ) + ) + lines.append("") + +render_table( + "kvstore：RSET/RGET（持久化 × allocator）", + kv_rows, + lambda r: f"{r['strategy']} ({r['persistence']}, {r['allocator']})", +) +render_table( + "Redis：SET/GET（各持久化模式）", + redis_rows, + lambda r: f"{r['strategy']} ({r['persistence']})", +) + +with open(readme_path, "a", encoding="utf-8") as f: + f.write("\n".join(lines) + "\n") +PY +} + +main() { + require_cmd python3 + require_cmd rg + require_cmd ss + require_cmd redis-server + require_cmd redis-cli + ensure_binaries + + run_kv_case "persist_mypool" "incremental" "mypool" + run_kv_case "nopersist_mypool" "none" "mypool" + run_kv_case "persist_malloc" "incremental" "malloc" + run_kv_case "nopersist_malloc" "none" "malloc" + + run_redis_case "none" "none" 6381 "\"\"" "no" "everysec" + run_redis_case "rdb_default" "rdb_default" 6382 "900 1 300 10 60 10000" "no" "everysec" + run_redis_case "aof_no" "aof_no" 6383 "\"\"" "yes" "no" + run_redis_case "aof_everysec" "aof_everysec" 6384 "\"\"" "yes" "everysec" + run_redis_case "aof_always" "aof_always" 6385 "\"\"" "yes" "always" + + append_readme_results + + echo "DETAIL_CSV=$DETAIL_CSV" + echo "SUMMARY_CSV=$SUMMARY_CSV" + echo "README_UPDATED=$README_MD" +} + +main "$@"