[反合][docs]根据doc tools扫描结果优化资料-memcache-AtomGit

MREADME.md+18-15

	@@ -1,5 +1,6 @@
		1	+<h1 align="center" style="margin: 0;"><img src="docs/source/memcache_icon.png" style="width: 37%" /></h1>
1	<div align="center">	2	<div align="center">
2	- <img src=doc/source/memcache_icon.png style="width: 37%" />	3	+
3	<hr style="display:block; border:none; height:0; border-top:2px solid #008000; width:100%; max-width:1250px; margin:20px auto;">	4	<hr style="display:block; border:none; height:0; border-top:2px solid #008000; width:100%; max-width:1250px; margin:20px auto;">
4	<h2 align="center">	5	<h2 align="center">
5	High-performance distributed key-value cache	6	High-performance distributed key-value cache
	@@ -16,6 +17,7 @@ High-performance distributed key-value cache
16	<br/>	17	<br/>
17		18
18	## 🔄Latest News	19	## 🔄Latest News
		20	+
19	- [2026/06] MemCache使能推理PrefixCache加速案例实践，请关注[wiki主页案例库](https://gitcode.com/Ascend/memcache/wiki/Home.md)获取最新案例	21	- [2026/06] MemCache使能推理PrefixCache加速案例实践，请关注[wiki主页案例库](https://gitcode.com/Ascend/memcache/wiki/Home.md)获取最新案例
20	- [2025/12] MemCache已作为vllm-ascend backend使能大模型推理加速，详情查看vllm-ascend开源社区，[使用示例](https://github.com/vllm-project/vllm-ascend/blob/main/docs/source/user_guide/feature_guide/kv_pool.md#example-of-using-memcache-as-a-kv-pool-backend)	22	- [2025/12] MemCache已作为vllm-ascend backend使能大模型推理加速，详情查看vllm-ascend开源社区，[使用示例](https://github.com/vllm-project/vllm-ascend/blob/main/docs/source/user_guide/feature_guide/kv_pool.md#example-of-using-memcache-as-a-kv-pool-backend)
21		23
	@@ -37,8 +39,9 @@ MemCache是针对LLM推理、GR推理场景设计的高性能分布式KVCache存
37	等路径提供OneCopy跨机跨介质数据直接访问能力，满足高带宽，低时延的读写性能述求。在鲲鹏硬件上，支持host_urma(K5)。支持host_shm实现同节点共享内存通信。	39	等路径提供OneCopy跨机跨介质数据直接访问能力，满足高带宽，低时延的读写性能述求。在鲲鹏硬件上，支持host_urma(K5)。支持host_shm实现同节点共享内存通信。
38	- 支持扩缩容：支持LocalService动态加入和移除	40	- 支持扩缩容：支持LocalService动态加入和移除
39	- HA能力：在K8S集群中，MetaService支持多活能力，支持元数据恢复，提供尽力而为的HA能力。	41	- HA能力：在K8S集群中，MetaService支持多活能力，支持元数据恢复，提供尽力而为的HA能力。
		42	+
40	<div align="center">	43	<div align="center">
41	- <img src="./doc/source/memcache_architecture.png" alt="architecture">	44	+ <img src="./docs/source/memcache_architecture.png" alt="architecture">
42	</div>	45	</div>
43		46
44	## 🧩核心组件	47	## 🧩核心组件
	@@ -47,51 +50,51 @@ MemCache包含LocalService和MetaService两大核心组件：
47		50
48	- MetaService：	51	- MetaService：
49	- 负责管理整个集群中内存池空间的分配和管理，处理LocalService的加入与退出。	52	- 负责管理整个集群中内存池空间的分配和管理，处理LocalService的加入与退出。
50	- - MetaService作为独立进程运行，提供两种启动方式：python API启动；二进制启动，详见 [whl安装使用](./doc/install_whl.md) 和 [run安装使用](./doc/install_run.md)	53	+ - MetaService作为独立进程运行，提供两种启动方式：python API启动；二进制启动，详见 [whl安装使用](./docs/install_whl.md) 和 [run安装使用](./docs/install_run.md)
51	- MetaService支持两种部署形态：	54	- MetaService支持两种部署形态：
52	*1、单点模式*：MetaService由单个进程组成，部署方式简单，但存在单点故障的问题。如果MetaService进程崩溃或无法访问，系统将无法继续提供服务，直至重新恢复为止。	55	*1、单点模式*：MetaService由单个进程组成，部署方式简单，但存在单点故障的问题。如果MetaService进程崩溃或无法访问，系统将无法继续提供服务，直至重新恢复为止。
53	*2、HA模式*：该模式基于K8S的的ClusterIP Service和Lease资源构建，部署较为复杂，该模式会部署多个MetaService进程实例，实现多活高可用。部署详见[怎么部署一个MemCache的HA集群](https://gitcode.com/Ascend/memcache/wiki/%E6%80%8E%E4%B9%88%E9%83%A8%E7%BD%B2%E4%B8%80%E4%B8%AAmemcache%E7%9A%84HA%E9%9B%86%E7%BE%A4.md)	56	*2、HA模式*：该模式基于K8S的的ClusterIP Service和Lease资源构建，部署较为复杂，该模式会部署多个MetaService进程实例，实现多活高可用。部署详见[怎么部署一个MemCache的HA集群](https://gitcode.com/Ascend/memcache/wiki/%E6%80%8E%E4%B9%88%E9%83%A8%E7%BD%B2%E4%B8%80%E4%B8%AAmemcache%E7%9A%84HA%E9%9B%86%E7%BE%A4.md)
54		57
55	-
56	- LocalService：负责承担如下功能：	58	- LocalService：负责承担如下功能：
57	- 客户端：作为客户端，以whl/so形式作为共享库被应用进程加载调用API	59	- 客户端：作为客户端，以whl/so形式作为共享库被应用进程加载调用API
58	- 内存提供者：负责提供一段连续的内存区域作为内存池空间的一部分，其内存可以被其他LocalService实例基于地址直接访问。	60	- 内存提供者：负责提供一段连续的内存区域作为内存池空间的一部分，其内存可以被其他LocalService实例基于地址直接访问。
59		61
60	-
61	## 🔥性能表现	62	## 🔥性能表现
62		63
63	MemCache核心能力是提供大容量内存池和高性能的H2D、D2H、D2RH、RH2D数据访问能力，由于MemCache以 [MemFabric](https://gitcode.com/Ascend/memfabric_hybrid) 作为池化底座，所以支持RH2D、D2RH等OneCopy跨机跨介质数据直接访问能力，下图为RH2D对比其他中转路径的对比示意图。	64	MemCache核心能力是提供大容量内存池和高性能的H2D、D2H、D2RH、RH2D数据访问能力，由于MemCache以 [MemFabric](https://gitcode.com/Ascend/memfabric_hybrid) 作为池化底座，所以支持RH2D、D2RH等OneCopy跨机跨介质数据直接访问能力，下图为RH2D对比其他中转路径的对比示意图。
64	<div align="center">	65	<div align="center">
65	- <img src="./doc/source/memcache_rh2d.png" alt="RH2D">	66	+ <img src="./docs/source/memcache_rh2d.png" alt="RH2D">
66	</div>	67	</div>
67		68
68	基于OneCopy跨机跨介质数据直接访问的能力，MemCache在A2/A3做了相关性能测试如下：	69	基于OneCopy跨机跨介质数据直接访问的能力，MemCache在A2/A3做了相关性能测试如下：
69	模拟构造DeepSeek-R1模型KV大小的block，单个block size为：61x128K + 61x16K = 8784KB ≈ 8.57MB，共122个离散地址。	70	模拟构造DeepSeek-R1模型KV大小的block，单个block size为：61x128K + 61x16K = 8784KB ≈ 8.57MB，共122个离散地址。
70		71
71	- 使用2个昇腾A2节点(每节点8张卡)组成双机内存池进行读写测试性能如下：	72	- 使用2个昇腾A2节点(每节点8张卡)组成双机内存池进行读写测试性能如下：
		73	+
72	<div align="center">	74	<div align="center">
73	- <img src="./doc/source/memcache_a2.png" alt="A2 perf">	75	+ <img src="./docs/source/memcache_a2.png" alt="A2 perf">
74	</div>	76	</div>
75		77
76	- 使用2个昇腾A3节点(每节点8张卡16Die)组成双机内存池进行读写测试性能如下：	78	- 使用2个昇腾A3节点(每节点8张卡16Die)组成双机内存池进行读写测试性能如下：
		79	+
77	<div align="center">	80	<div align="center">
78	- <img src="./doc/source/memcache_a3.png" alt="A3 perf">	81	+ <img src="./docs/source/memcache_a3.png" alt="A3 perf">
79	</div>	82	</div>
80		83
81	## 🚀快速入门	84	## 🚀快速入门
82		85
83	请访问以下文档获取简易教程。	86	请访问以下文档获取简易教程。
84		87
85	-- 安装使用：[whl安装和使用](./doc/install_whl.md)（适用于Python用户），[run编译、安装和使用](./doc/install_run.md)（适用于C++用户）	88	+- 安装使用：[whl安装和使用](./docs/install_whl.md)（适用于Python用户），[run编译、安装和使用](./docs/install_run.md)（适用于C++用户）
86	-- [配置文件](doc/memcache_config.md)：涉及MetaService、LocalService公共配置	89	+- [配置文件](docs/memcache_config.md)：涉及MetaService、LocalService公共配置
87	- [样例执行](./example/examples.md)：介绍如何端到端执行样例代码，包括C++和Python样例	90	- [样例执行](./example/examples.md)：介绍如何端到端执行样例代码，包括C++和Python样例
88	-- [DevContainer 远端开发](./doc/devcontainer_quickstart.md)：VS Code Remote-SSH + DevContainer 一站式开发环境搭建与全量示例运行指南	91	+- [DevContainer 远端开发](./docs/devcontainer_quickstart.md)：VS Code Remote-SSH + DevContainer 一站式开发环境搭建与全量示例运行指南
89		92
90	## 📑学习教程	93	## 📑学习教程
91		94
92	-- [C++接口](doc/memcache_c++_api.md)：C++接口介绍以及C++接口对应的API列表	95	+- [C++接口](docs/memcache_c++_api.md)：C++接口介绍以及C++接口对应的API列表
93	-- [Python接口](doc/memcache_python_api.md)：Python接口介绍以及Python接口对应的API列表	96	+- [Python接口](docs/memcache_python_api.md)：Python接口介绍以及Python接口对应的API列表
94	-- [RESTful接口](doc/memcache_restful_api.md)：指标监控接口介绍以及API列表	97	+- [RESTful接口](docs/memcache_restful_api.md)：指标监控接口介绍以及API列表
95		98
96	## 📦软件硬件配套说明	99	## 📦软件硬件配套说明
97		100
	@@ -103,6 +106,6 @@ MemCache核心能力是提供大容量内存池和高性能的H2D、D2H、**D2RH
103		106
104	## 📝相关信息	107	## 📝相关信息
105		108
106	-- [安全声明](./doc/SECURITYNOTE.md)	109	+- [安全声明](./docs/SECURITYNOTE.md)
107		110
108	- [许可证](./LICENSE)	111	- [许可证](./LICENSE)

Rdoc/SECURITYNOTE.md→docs/SECURITYNOTE.md+17-18

	@@ -1,4 +1,6 @@
1	-### 通信矩阵	1	+# 安全提示
		2	+
		3	+## 通信矩阵
2		4
3	\| 原设备 \| 源IP地址 \| 源端口 \| 目的设备 \| 目的IP地址 \| 目的端口（侦听） \| 协议 \| 端口说明 \| 侦听端口是否可更改 \| 认证方式 \|	5	\| 原设备 \| 源IP地址 \| 源端口 \| 目的设备 \| 目的IP地址 \| 目的端口（侦听） \| 协议 \| 端口说明 \| 侦听端口是否可更改 \| 认证方式 \|
4	\|-----------------\|-----------\|-----------------\|-----------------\|--------------------------\|---------------------------------------------------------\|---------------\|:-------------------------\|-----------\|------\|	6	\|-----------------\|-----------\|-----------------\|-----------------\|--------------------------\|---------------------------------------------------------\|---------------\|:-------------------------\|-----------\|------\|
	@@ -7,24 +9,23 @@
7	\| 参与hcom通信的实例 \| 客户端通信IP地址 \| 随机端口（由操作系统自动分配） \| 参与hcom通信的实例 \| hcom_url中的\<ip\> \| hcom_url中的\<port\> , 默认值7000, 可配范围[1025, 65535] \| TCP/RDMA/SDMA \| 用于hcom通信 \| 是 \| TLS \|	9	\| 参与hcom通信的实例 \| 客户端通信IP地址 \| 随机端口（由操作系统自动分配） \| 参与hcom通信的实例 \| hcom_url中的\<ip\> \| hcom_url中的\<port\> , 默认值7000, 可配范围[1025, 65535] \| TCP/RDMA/SDMA \| 用于hcom通信 \| 是 \| TLS \|
8	\| 管理/监控客户端 \| 客户端通信IP地址 \| 随机端口（由操作系统自动分配） \| meta service \| metrics_url中的\<ip\> \| metrics_url中的\<port\> , 默认值8000, 可配范围[1025, 65535] \| HTTPS/HTTP \| 用于RESTful API管理与监控 \| 是 \| mTLS(可选，默认关闭)/无认证 \|	10	\| 管理/监控客户端 \| 客户端通信IP地址 \| 随机端口（由操作系统自动分配） \| meta service \| metrics_url中的\<ip\> \| metrics_url中的\<port\> , 默认值8000, 可配范围[1025, 65535] \| HTTPS/HTTP \| 用于RESTful API管理与监控 \| 是 \| mTLS(可选，默认关闭)/无认证 \|
9		11
10	-说明：	12	+- 支持通过配置文件配置TLS私钥、证书、口令等，进行TLS安全连接。
11	-支持通过配置文件配置TLS私钥、证书、口令等，进行TLS安全连接。	13	+- 支持对 metrics HTTP 服务独立配置 mTLS（双向认证），通过 `ock.mmc.metrics.tls.*` 配置项开启。
12	-支持对 metrics HTTP 服务独立配置 mTLS（双向认证），通过 `ock.mmc.metrics.tls.*` 配置项开启。	14	+- 建议用户开启TLS配置开关，并使用加密的方式保存私钥，保证通信安全。
13	-建议用户开启TLS配置开关，并使用加密的方式保存私钥，保证通信安全。	15	+- 系统启动后，建议删除本地秘钥证书等信息敏感文件。
14	-系统启动后，建议删除本地秘钥证书等信息敏感文件。	16	+- 支持通过环境变量 `ACCLINK_CHECK_PERIOD_HOURS`和`ACCLINK_CERT_CHECK_AHEAD_DAYS` 配置证书检查周期与证书过期预警时间。
15	-支持通过环境变量 `ACCLINK_CHECK_PERIOD_HOURS`和`ACCLINK_CERT_CHECK_AHEAD_DAYS` 配置证书检查周期与证书过期预警时间。	17	+- 多local_service场景不同local_service之间会使用配置文件中的HCOM端口+local_rank作为实际使用的端口。
16	-多local_service场景不同local_service之间会使用配置文件中的HCOM端口+local_rank作为实际使用的端口。
17		18
18	\| 环境变量 \| 说明 \|	19	\| 环境变量 \| 说明 \|
19	\|-------------------------------\|-----------------------------------------------------------\|	20	\|-------------------------------\|-----------------------------------------------------------\|
20	-\| ACCLINK_CHECK_PERIOD_HOURS \| 指定证书检查周期（单位：小时），超出范围 [ 24, 24 * 30 ] 或不是整数，则设置默认值7 * 24 \|	21	+\| ACCLINK_CHECK_PERIOD_HOURS \| 指定证书检查周期（单位：小时），超出范围 [ 24, 24 \* 30 ] 或不是整数，则设置默认值 7 \* 24 \|
21	\| ACCLINK_CERT_CHECK_AHEAD_DAYS \| 指定证书预警时间（单位：天），超出范围 [ 7, 180 ] 或不是整数或换算成小时小于检查周期，则设置默认值30 \|	22	\| ACCLINK_CERT_CHECK_AHEAD_DAYS \| 指定证书预警时间（单位：天），超出范围 [ 7, 180 ] 或不是整数或换算成小时小于检查周期，则设置默认值30 \|
22		23
23	-### 运行用户建议	24	+## 运行用户建议
24		25
25	- 基于安全性考虑，建议您在执行任何命令时，不建议使用root等管理员类型账户执行，遵循权限最小化原则。	26	- 基于安全性考虑，建议您在执行任何命令时，不建议使用root等管理员类型账户执行，遵循权限最小化原则。
26		27
27	-### 文件权限最大值建议	28	+## 文件权限最大值建议
28		29
29	- 建议用户在主机（包括宿主机）及容器中设置运行系统umask值为0027及以上，保障新增文件夹默认最高权限为750，新增文件默认最高权限为640。	30	- 建议用户在主机（包括宿主机）及容器中设置运行系统umask值为0027及以上，保障新增文件夹默认最高权限为750，新增文件默认最高权限为640。
30	- 建议对使用当前项目已有和产生的文件、数据、目录，设置如下建议权限。	31	- 建议对使用当前项目已有和产生的文件、数据、目录，设置如下建议权限。
	@@ -49,9 +50,9 @@
49	\| 密钥组件、私钥、证书、加密密文 \| 600（rw-------） \|	50	\| 密钥组件、私钥、证书、加密密文 \| 600（rw-------） \|
50	\| 加解密接口、加解密脚本 \| 500（r-x------） \|	51	\| 加解密接口、加解密脚本 \| 500（r-x------） \|
51		52
52	-### 调用acc_links接口列表	53	+## 调用acc_links接口列表
53		54
54	-#### TCP服务端模块	55	+### TCP服务端模块
55		56
56	\| 接口功能描述 \| 接口声明 \|	57	\| 接口功能描述 \| 接口声明 \|
57	\|--------------\|--------------------------------------------------------------------------------------------------------------------------------------------------------\|	58	\|--------------\|--------------------------------------------------------------------------------------------------------------------------------------------------------\|
	@@ -66,13 +67,11 @@
66	\| 注册密码解密的函数 \| `void RegisterDecryptHandler(const AccDecryptHandler &h);` \|	67	\| 注册密码解密的函数 \| `void RegisterDecryptHandler(const AccDecryptHandler &h);` \|
67	\| 加载安全认证所需动态库 \| `int32_t LoadDynamicLib(const std::string &dynLibPath);` \|	68	\| 加载安全认证所需动态库 \| `int32_t LoadDynamicLib(const std::string &dynLibPath);` \|
68		69
69	-### 依赖软件声明	70	+## 依赖软件声明
70		71
71	-当前项目运行依赖 CANN 和 Ascend	72	+当前项目运行依赖 CANN 和 Ascend HDK，安装使用及注意事项参考 [CANN](https://www.hiascend.com/document/detail/zh/CANNCommunityEdition/81RC1beta1/index/index.html) 和 [Ascend HDK](https://support.huawei.com/enterprise/zh/undefined/ascend-hdk-pid-252764743) 并选择对应版本。
72	-HDK，安装使用及注意事项参考[CANN](https://www.hiascend.com/document/detail/zh/CANNCommunityEdition/81RC1beta1/index/index.html)
73	-和[Ascend HDK](https://support.huawei.com/enterprise/zh/undefined/ascend-hdk-pid-252764743)并选择对应版本。
74		73
75	-### 源码内公网地址	74	+## 源码内公网地址
76		75
77	\| 类型 \| 开源代码地址 \| 文件名 \| 公网IP地址/公网URL地址/域名/邮箱地址 \| 用途说明 \|	76	\| 类型 \| 开源代码地址 \| 文件名 \| 公网IP地址/公网URL地址/域名/邮箱地址 \| 用途说明 \|
78	\|------------\|---------------------------------------------\|------------------------\|---------------------------------------------\|-------------\|	77	\|------------\|---------------------------------------------\|------------------------\|---------------------------------------------\|-------------\|

Rdoc/c_cpp_naming.md→docs/c_cpp_naming.md+0-0

文件重命名但无更改。

Rdoc/devcontainer_quickstart.md→docs/devcontainer_quickstart.md+35-27

	@@ -2,15 +2,15 @@
2		2
3	## 前置条件	3	## 前置条件
4		4
5	-- 远端服务器：昇腾 NPU 服务器，已安装 NPU 驱动	5	+- 远端服务器：昇腾 NPU 服务器，已安装 NPU 驱动。
6	-- 本地机器：VS Code + Remote—SSH 扩展	6	+- 本地机器：VS Code + Remote—SSH 扩展。
7	-- 网络：本地能 SSH 到远端服务器，远端能拉 gitcode + Docker 镜像	7	+- 网络：本地能 SSH 到远端服务器，远端能拉 gitcode + Docker 镜像。
8		8
9	---	9	---
10		10
11	## 1. 远端克隆项目	11	## 1. 远端克隆项目
12		12
13	-SSH 登录远端服务器，克隆仓库：	13	+SSH 登录远端服务器，克隆仓库。
14		14
15	```bash	15	```bash
16	git clone https://gitcode.com/Ascend/memcache.git	16	git clone https://gitcode.com/Ascend/memcache.git
	@@ -23,7 +23,7 @@ cd memcache
23		23
24	不需要手动在远端启动 VS Code Server，VS Code 会自动处理。	24	不需要手动在远端启动 VS Code Server，VS Code 会自动处理。
25		25
26	-方式 A — 命令行快捷连接（本地终端执行）：	26	+方式 A —— 命令行快捷连接（本地终端执行）
27		27
28	```bash	28	```bash
29	code --remote ssh-remote+<你的服务器地址> /path/to/memcache	29	code --remote ssh-remote+<你的服务器地址> /path/to/memcache
	@@ -35,40 +35,42 @@ code --remote ssh-remote+<你的服务器地址> /path/to/memcache
35	code --remote ssh-remote+192.168.1.100 /home/user/memcache	35	code --remote ssh-remote+192.168.1.100 /home/user/memcache
36	```	36	```
37		37
38	-方式 B — VS Code UI：	38	+方式 B —— VS Code UI
39		39
40	-1. `F1` → `Remote-SSH: Connect to Host...`	40	+1. `F1` → `Remote-SSH: Connect to Host...`。
41	-2. 输入 `ssh user@host` 或从 `~/.ssh/config` 选择	41	+2. 输入 `ssh user@host` 或从 `~/.ssh/config` 选择。
42	-3. 输入服务器密码	42	+3. 输入服务器密码。
43	-4. 连接后 `File > Open Folder...` → 选择 `memcache` 目录	43	+4. 连接后 `File > Open Folder...` → 选择 `memcache` 目录。
44	-5. 输入服务器密码	44	+5. 输入服务器密码。
45		45
		46	+> [!NOTE] 说明
46	> VS Code 会自动在远端安装 `vscode-server`，首次连接需等待几十秒。	47	> VS Code 会自动在远端安装 `vscode-server`，首次连接需等待几十秒。
47		48
48	---	49	---
49		50
50	## 3. 在 Dev Container 中打开	51	## 3. 在 Dev Container 中打开
51		52
52	-1. 确保远端已安装 Docker（root 或 docker 组权限）	53	+1. 确保远端已安装 Docker（root 或 docker 组权限）。
53	-2. VS Code 中 `F1` → `Dev Containers: Reopen in Container`	54	+2. VS Code 中 `F1` → `Dev Containers: Reopen in Container`。
54	-3. 输入服务器密码	55	+3. 输入服务器密码。
55	-4. 等待镜像拉取 + 容器构建 + postCreateCommand 完成	56	+4. 等待镜像拉取 + 容器构建 + postCreateCommand 完成。
56		57
57	-第一次会拉取 `quay.nju.edu.cn/ascend/vllm-ascend:v0.20.2rc1-a3`（约 15-20 GB），耗时较长。	58	+> [!NOTE] 说明
		59	+>
		60	+> - 第一次会拉取 `quay.nju.edu.cn/ascend/vllm-ascend:v0.20.2rc1-a3`（约 15-20 GB），耗时较长。
		61	+> - 官方镜像源为 `quay.io/ascend/vllm-ascend:v0.22.1rc1-a3`，配置中使用中国国内镜像加速下载。
		62	+> A2 环境请改用 `quay.nju.edu.cn/ascend/vllm-ascend:v0.20.2rc1`。
58		63
59	-> 官方镜像源为 quay.io/ascend/vllm-ascend:v0.22.1rc1-a3，配置中使用中国国内镜像加速下载	64	+postCreateCommand 会自动执行以下操作（`.devcontainer/post_create.sh`）：
60	-> A2 环境请改用 `quay.nju.edu.cn/ascend/vllm-ascend:v0.20.2rc1`
61		65
62	-postCreateCommand 会自动做（`.devcontainer/post_create.sh`）：	66	+- 安装 Python 开发依赖（pre-commit、pytest、pybind11 等）。
63	-	67	+- 初始化 `3rdparty/` 子模块。
64	-- 安装 Python 开发依赖（pre-commit、pytest、pybind11 等）	68	+- 验证工具链版本（gcc、cmake、ninja、python）。
65	-- 初始化 `3rdparty/` 子模块	69	+- CMake 冒烟配置测试。
66	-- 验证工具链版本（gcc、cmake、ninja、python）	70	+- 安装 pre-commit hooks。
67	-- CMake 冒烟配置测试
68	-- 安装 pre-commit hooks
69	-
70	-完成后 VS Code 左下角显示 `Dev Container: MemCache Dev Container`。
71		71
		72	+> [!NOTE] 说明
		73	+> 完成后 VS Code 左下角显示 `Dev Container: MemCache Dev Container`。
72	> 点击右下角的 `show logs` 会在终端显示构建细节和进度	74	> 点击右下角的 `show logs` 会在终端显示构建细节和进度
73		75
74	---	76	---
	@@ -84,6 +86,7 @@ bash script/build_and_pack_run.sh --build_mode DEBUG --incremental
84	```	86	```
85		87
86	编译产物：	88	编译产物：
		89	+
87	- run 包：`output/memcache_hybrid-*.run`	90	- run 包：`output/memcache_hybrid-*.run`
88	- whl 包：`output/memcache/wheel/memcache_hybrid-*.whl`	91	- whl 包：`output/memcache/wheel/memcache_hybrid-*.whl`
89		92
	@@ -186,9 +189,11 @@ bash example/benchmark/bench_start.sh -t read -p 1 -b 16 -s 1048576 -n 100 -d 1
186	## 常见问题	189	## 常见问题
187		190
188	Q: 拉镜像太慢 / 超时	191	Q: 拉镜像太慢 / 超时
		192	+
189	`.devcontainer/Dockerfile` 中已将源指向国内 mirror `quay.nju.edu.cn`。如仍需代理，在远端 `/etc/docker/daemon.json` 配置 registry mirror。	193	`.devcontainer/Dockerfile` 中已将源指向国内 mirror `quay.nju.edu.cn`。如仍需代理，在远端 `/etc/docker/daemon.json` 配置 registry mirror。
190		194
191	Q: 构建时找不到 `pybind11`	195	Q: 构建时找不到 `pybind11`
		196	+
192	`postCreateCommand` 已安装，如跳过则手动：	197	`postCreateCommand` 已安装，如跳过则手动：
193		198
194	```bash	199	```bash
	@@ -196,12 +201,15 @@ pip install pybind11
196	```	201	```
197		202
198	Q: 没有 NPU 能不能跑	203	Q: 没有 NPU 能不能跑
		204	+
199	不能。MemCache 依赖昇腾 NPU 驱动（`davinci`、`devmm_svm`）。无 NPU 环境下构建会失败。	205	不能。MemCache 依赖昇腾 NPU 驱动（`davinci`、`devmm_svm`）。无 NPU 环境下构建会失败。
200		206
201	Q: 只想用 Python 不用 C++ 例子	207	Q: 只想用 Python 不用 C++ 例子
		208	+
202	```bash	209	```bash
203	bash script/run_all_examples.sh --python	210	bash script/run_all_examples.sh --python
204	```	211	```
205		212
206	Q: 需要修改 MetaService 或 LocalService 配置	213	Q: 需要修改 MetaService 或 LocalService 配置
		214	+
207	编辑 `config/mmc-meta.conf` 和 `config/mmc-local.conf`，或通过 `--meta-config` / `--local-config` 指定自定义路径。	215	编辑 `config/mmc-meta.conf` 和 `config/mmc-local.conf`，或通过 `--meta-config` / `--local-config` 指定自定义路径。

Rdoc/install_run.md→docs/install_run.md+22-22

	@@ -1,13 +1,14 @@
1	# run包编译、安装及使用	1	# run包编译、安装及使用
2	-介绍run包的安装及使用方法，适用于需要使用C++接口的用户
3		2
4	-run包没有发布二进制包，需要用户自行编译	3	+介绍run包的安装及使用方法，适用于需要使用C++接口的用户。
		4	+
		5	+run包没有发布二进制包，需要用户自行编译。
5		6
6	## run包编译	7	## run包编译
7		8
8	### 环境准备	9	### 环境准备
9		10
10	-编译工具建议版本	11	+编译工具建议版本。
11		12
12	- OS: Ubuntu 22.04 LTS+	13	- OS: Ubuntu 22.04 LTS+
13	- cmake: 3.20.x	14	- cmake: 3.20.x
	@@ -38,38 +39,37 @@ git submodule update --init 3rdparty/
38	git -c submodule.3rdparty/memfabric_hybrid.branch=master submodule update --remote 3rdparty/memfabric_hybrid	39	git -c submodule.3rdparty/memfabric_hybrid.branch=master submodule update --remote 3rdparty/memfabric_hybrid
39	```	40	```
40		41
41	-说明：	42	+- `--init 3rdparty/` 初始化并更新 `3rdparty/` 下全部子模块（含 memfabric_hybrid、spdlog、nlohmann、msgpack-c、libzmq 等），避免拉取 test 目录等不必要的依赖。
42	-- `--init 3rdparty/` 初始化并更新 `3rdparty/` 下全部子模块（含 memfabric_hybrid、spdlog、nlohmann、msgpack-c、libzmq 等），避免拉取 test 目录等不必要的依赖	43	+- 通过 `-c submodule.3rdparty/memfabric_hybrid.branch=<branch_name>` 参数可以指定拉取的目标分支。
43	-- 通过 `-c submodule.3rdparty/memfabric_hybrid.branch=<branch_name>` 参数可以指定拉取的目标分支	44	+- 若需拉取所有子模块（包括测试依赖），可使用 `git submodule update --recursive --init`。
44	-- 若需拉取所有子模块（包括测试依赖），可使用 `git submodule update --recursive --init`
45		45
46	3. 编译	46	3. 编译
47		47
48	-执行如下命令进行编译	48	+执行如下命令进行编译。
49		49
50	```bash	50	```bash
51	bash script/build_and_pack_run.sh --build_mode RELEASE --build_test OFF	51	bash script/build_and_pack_run.sh --build_mode RELEASE --build_test OFF
52	```	52	```
53		53
54	-- build_and_pack_run.sh支持2个参数，分别是--build_mode <build_mode>和--build_test <build_test>	54	+- build_and_pack_run.sh 支持2个参数，分别是`--build_mode <build_mode>`和`--build_test <build_test>`。
55	-- build_mode: 编译类型，可填RELEASE、DEBUG或ASAN，默认RELEASE	55	+- build_mode: 编译类型，可填RELEASE、DEBUG或ASAN，默认RELEASE。
56	-- build_test: 是否打包测试工具，可填ON或OFF，默认OFF	56	+- build_test: 是否打包测试工具，可填ON或OFF，默认OFF。
57		57
58	-编译成功后，生成的run包在output目录下，生成的whl包在output/memcache/wheel目录下	58	+编译成功后，生成的run包在output目录下，生成的whl包在output/memcache/wheel目录下。
59		59
60	## run包安装	60	## run包安装
61		61
62	### 安装MemFabric	62	### 安装MemFabric
63		63
64	-MemCache依赖MemFabric，需要先安装MemFabric，详细安装方法可参考[MemFabric使用指导](https://gitcode.com/Ascend/memfabric_hybrid/blob/master/doc/installation.md)	64	+MemCache依赖MemFabric，需要先安装MemFabric，详细安装方法可参考[MemFabric使用指导](https://gitcode.com/Ascend/memfabric_hybrid/blob/develop/docs/installation.md)。
		atomgit-bot7月29日 🟡 Medium Priority 本次 diff 在 `docs/install_run.md` 和 `docs/install_whl.md` 中将 MemFabric 安装文档链接从 `https://gitcode.com/Ascend/memfabric_hybrid/blob/master/doc/installation.md` 更新为 `https://gitcode.com/Ascend/memfabric_hybrid/blob/develop/docs/installation.md`（分支从 `master` 变为 `develop`，路径从 `doc/` 变为 `docs/`），但 `example/cpp/README.md`（第18行）和 `example/python/README.md`（第19行）中的相同链接未被更新，仍然指向 `blob/master/doc/installation.md`。影响：用户按不同文档操作时会得到不一致的指引。如果 MemFabric 仓库的 `master` 分支已不再维护或 `doc/` 目录已迁移，旧链接可能失效或指向过时内容。触发条件：用户按 `example/cpp/README.md` 或 `example/python/README.md` 的指引点击 MemFabric 安装链接。建议：将 `example/cpp/README.md` 和 `example/python/README.md` 中相同的 MemFabric 安装链接也更新为 `https://gitcode.com/Ascend/memfabric_hybrid/blob/develop/docs/installation.md`，保持文档一致性。
65		65
66	### 安装MemCache	66	### 安装MemCache
67		67
68	-MemCache将所有特性集成到run包中供用户使用，run包格式为 ```memcache_hybrid-${version}_${os}_${arch}.run```	68	+MemCache将所有特性集成到run包中供用户使用，run包格式为 `memcache_hybrid-${version}_${os}_${arch}.run`。
69		69
70	-其中，version表示MemCache的版本；os表示操作系统，如linux；arch表示架构，如x86_64或aarch64	70	+其中，version表示MemCache的版本；os表示操作系统，如linux；arch表示架构，如x86_64或aarch64。
71		71
72	-run包的默认安装根路径为 /usr/local/	72	+run包的默认安装根路径为 /usr/local/。
73		73
74	参考安装命令如下：	74	参考安装命令如下：
75		75
	@@ -78,13 +78,13 @@ cd output
78	bash memcache_hybrid-*_linux_aarch64.run # 请修改为实际路径和文件名	78	bash memcache_hybrid-*_linux_aarch64.run # 请修改为实际路径和文件名
79	```	79	```
80		80
81	-如果想要自定义安装路径，可以添加--install-path参数	81	+如果想要自定义安装路径，可以添加 `--install-path` 参数。
82		82
83	```bash	83	```bash
84	bash memcache_hybrid-*_linux_aarch64.run --install-path=${your path} # 请修改为实际路径和文件名	84	bash memcache_hybrid-*_linux_aarch64.run --install-path=${your path} # 请修改为实际路径和文件名
85	```	85	```
86		86
87	-安装的run包可以通过如下命令查看版本（此处以默认安装路径为例）	87	+安装的run包可以通过如下命令查看版本（此处以默认安装路径为例）。
88		88
89	```bash	89	```bash
90	cat /usr/local/memcache_hybrid/latest/version.info	90	cat /usr/local/memcache_hybrid/latest/version.info
	@@ -102,15 +102,15 @@ source /usr/local/memfabric_hybrid/set_env.sh
102		102
103	### 启动MetaService	103	### 启动MetaService
104		104
105	-MetaService作为独立进程运行，可以在设置配置项之后直接拉起	105	+MetaService作为独立进程运行，可以在设置配置项之后直接拉起。
106		106
107	1. 修改配置文件	107	1. 修改配置文件
108		108
109	-安装完成后配置文件位于安装目录下的memcache_hybrid/latest/config/mmc-meta.conf	109	+安装完成后配置文件位于安装目录下的`memcache_hybrid/latest/config/mmc-meta.conf`。
110		110
111	建议将配置文件复制到其他目录再进行修改，防止重新安装后被覆盖	111	建议将配置文件复制到其他目录再进行修改，防止重新安装后被覆盖
112		112
113	-运行前需要根据 [MetaService配置项](./memcache_config.md) 对配置文件 mmc-meta.conf 进行相关配置	113	+运行前需要根据 [MetaService配置项](./memcache_config.md) 对配置文件 mmc-meta.conf 进行相关配置。
114		114
115	2. 设置配置文件路径	115	2. 设置配置文件路径
116		116
	@@ -158,7 +158,7 @@ export MMC_LOCAL_CONFIG_PATH=/usr/local/memcache_hybrid/latest/config/mmc-local.
158		158
159	## 软件卸载	159	## 软件卸载
160		160
161	-卸载脚本是位于安装目录下的memcache_hybrid/latest/uninstall.sh，直接执行即可完成卸载	161	+卸载脚本是位于安装目录下的`memcache_hybrid/latest/uninstall.sh`，直接执行即可完成卸载。
162		162
163	```bash	163	```bash
164	# 这里使用的是默认安装路径，请修改为实际路径	164	# 这里使用的是默认安装路径，请修改为实际路径

Rdoc/install_whl.md→docs/install_whl.md+39-25

	@@ -1,10 +1,11 @@
1	# whl包安装及使用	1	# whl包安装及使用
2		2
3	-介绍whl包的安装及使用方法，适用于需要使用Python接口的用户	3	+介绍whl包的安装及使用方法，适用于需要使用Python接口的用户。
4		4
5	## 软件安装	5	## 软件安装
6		6
7	-whl包已发布到[pypi](https://pypi.org/project/memcache-hybrid/#files)，可以直接进行在线安装	7	+whl包已发布到[pypi](https://pypi.org/project/memcache-hybrid/#files)，可以直接在线安装。
		8	+
8	```bash	9	```bash
9	# 安装最新版本	10	# 安装最新版本
10	pip install memcache_hybrid	11	pip install memcache_hybrid
	@@ -19,39 +20,41 @@ pip show memcache_hybrid
19		20
20	### 安装依赖软件MemFabric	21	### 安装依赖软件MemFabric
21		22
22	-MemCache运行时需要依赖MemFabric	23	+MemCache运行时需要依赖MemFabric。
23		24
24	```bash	25	```bash
25	# 查看memfabric_hybrid	26	# 查看memfabric_hybrid
26	pip show memfabric_hybrid	27	pip show memfabric_hybrid
27	```	28	```
28		29
29	-如果安装的MemCache是1.1.x及以上版本，则在安装时会自动安装配套依赖的MemFabric，可以无需再安装	30	+- 如果安装的MemCache是1.1.x及以上版本，则在安装时会自动安装配套依赖的MemFabric，可以无需再安装。
30		31
31	-如果安装的MemCache是1.0.x版本，可通过[版本配套](https://gitcode.com/Ascend/memcache/releases)查看与MemCache匹配的MemFabric版本	32	+- 如果安装的MemCache是1.0.x版本，可通过[版本配套](https://gitcode.com/Ascend/memcache/releases)查看与MemCache匹配的MemFabric版本。
32		33
33	```bash	34	```bash
34	# 此处以1.0.8版本为例	35	# 此处以1.0.8版本为例
35	pip install memfabric_hybrid==1.0.8	36	pip install memfabric_hybrid==1.0.8
36	```	37	```
37		38
38	-MemFabric详细安装方法可参考[MemFabric使用指导](https://gitcode.com/Ascend/memfabric_hybrid/blob/master/doc/installation.md)	39	+MemFabric详细安装方法可参考[MemFabric使用指导](https://gitcode.com/Ascend/memfabric_hybrid/blob/develop/docs/installation.md)。
39		40
40	### 运行软件	41	### 运行软件
41		42
42	-我们提供了两种方式来启动软件，两种方式的区别在于设置配置项的方式不同	43	+我们提供了两种方式来启动软件，两种方式的区别在于设置配置项的方式不同。
43		44
44	-方式一：通过Python接口直接设置配置项（推荐）	45	+- 方式一：通过Python接口直接设置配置项（推荐）
45		46
46	-方式二：通过配置文件和环境变量设置配置项（兼容原有方式）	47	+- 方式二：通过配置文件和环境变量设置配置项（兼容原有方式）
47		48
48	-如果安装的MemCache是1.0.x版本，只能选择方式二，1.1.x及以上版本，您可以根据需要选择其中一种启动方式即可	49	+> [!NOTE] 说明
		50	+> 如果安装的MemCache是1.0.x版本，只能选择方式二，1.1.x及以上版本，您可以根据需要选择其中一种启动方式即可。
49		51
50	#### 方式一：通过Python接口直接设置配置项（推荐）	52	#### 方式一：通过Python接口直接设置配置项（推荐）
51		53
52	1. 启动MetaService	54	1. 启动MetaService
53		55
54	-MetaService作为独立进程运行，进入python控制台或者编写python脚本如下即可拉起进程：	56	+MetaService作为独立进程运行，进入Python控制台或者编写如下Python脚本即可拉起进程。
		57	+
55	```python	58	```python
56	from memcache_hybrid import MetaService, MetaConfig	59	from memcache_hybrid import MetaService, MetaConfig
57		60
	@@ -68,9 +71,9 @@ MetaService.main()
68		71
69	2. 启动LocalService	72	2. 启动LocalService
70		73
71	-LocalService作为客户端，以whl形式作为共享库提供API供应用进程调用加载，以下是通过Python接口设置配置项的一个简单示例	74	+LocalService作为客户端，以whl形式作为共享库提供API供应用进程调用加载，以下是通过Python接口设置配置项的一个简单示例。
72		75
73	-进入python控制台或者编写python脚本如下即可拉起示例进程：	76	+进入Python控制台或者编写如下Python脚本即可拉起示例进程。
74		77
75	```python	78	```python
76	from memcache_hybrid import DistributedObjectStore, LocalConfig	79	from memcache_hybrid import DistributedObjectStore, LocalConfig
	@@ -85,21 +88,24 @@ store = DistributedObjectStore()
85	assert store.setup(config) == 0, "setup local config failed"	88	assert store.setup(config) == 0, "setup local config failed"
86	```	89	```
87		90
88	-具体配置项可以参考[配置项说明](./memcache_config.md)，配置项的值请根据实际运行环境和场景进行修改	91	+具体配置项可以参考[配置项说明](./memcache_config.md)，配置项的值请根据实际运行环境和场景进行修改。
89		92
90	- 👆 NOTE：此种方式设置的配置项优先级高于方式二中通过配置文件设置的值，如果同时使用方式二配置了配置文件，实际运行时使用的是此方法设置的值	93	+> [!NOTE] 说明
		94	+> 此种方式设置的配置项优先级高于方式二中通过配置文件设置的值，如果同时使用方式二配置了配置文件，实际运行时使用的是此方法设置的值。
91		95
92	#### 方式二：通过配置文件和环境变量设置配置项（兼容原有方式）	96	#### 方式二：通过配置文件和环境变量设置配置项（兼容原有方式）
93		97
94	1. 设置配置文件	98	1. 设置配置文件
95		99
96	-pip安装完成后可通过以下命令查看具体安装位置	100	+pip安装完成后可通过以下命令查看具体安装位置。
		101	+
97	```bash	102	```bash
98	# 查看安装位置和版本	103	# 查看安装位置和版本
99	pip show memcache_hybrid	104	pip show memcache_hybrid
100	```	105	```
101		106
102	查询结果如下：	107	查询结果如下：
		108	+
103	```text	109	```text
104	Name: memcache_hybrid	110	Name: memcache_hybrid
105	Version: 1.0.0	111	Version: 1.0.0
	@@ -112,22 +118,28 @@ Location: /usr/local/lib/python3.11/site-packages
112	Requires:	118	Requires:
113	Required-by:	119	Required-by:
114	```	120	```
115	-这里安装的位置在/usr/local/lib/python3.11/site-packages，则配置文件位于/usr/local/lib/python3.11/site-packages/memcache_hybrid/config
116		121
117	- 👆 NOTE：1.0.x版本安装目录下不带配置文件，需要从[代码仓](https://gitcode.com/Ascend/memcache/tree/v1.0.0/config)获取。1.2.X及以上版本 whl 包已默认编译带上 ubsio 盘管理功能，config 目录下包含 mmc-meta.conf、mmc-local.conf 和 ubsio.conf	122	+这里安装的位置在`/usr/local/lib/python3.11/site-packages`，则配置文件位于`/usr/local/lib/python3.11/site-packages/memcache_hybrid/config`。
118		123
119	-软件运行时，配置文件 mmc-meta.conf（用于设置MetaService参数）、mmc-local.conf（用于设置LocalService参数）和 ubsio.conf（UBSIO/SSD 盘管理配置）可以位于任意目录	124	+> [!NOTE] 说明
		125	+>
		126	+> - 1.0.x 版本安装目录下不带配置文件，需要从[代码仓](https://gitcode.com/Ascend/memcache/tree/v1.0.0/config)获取。
		127	+> - 1.2.X 及以上版本 whl 包已默认编译带上 ubsio 盘管理功能，config 目录下包含 mmc-meta.conf、mmc-local.conf 和 ubsio.conf。
		128	+
		129	+软件运行时，配置文件 mmc-meta.conf（用于设置MetaService参数）、mmc-local.conf（用于设置LocalService参数）和 ubsio.conf（UBSIO/SSD 盘管理配置）可以位于任意目录。
120		130
121	建议将这两个配置文件复制到其他目录（比如/usr/local）再进行修改，防止重新安装后被覆盖	131	建议将这两个配置文件复制到其他目录（比如/usr/local）再进行修改，防止重新安装后被覆盖
122		132
123	-运行前可以根据 [配置项说明](./memcache_config.md) 对配置文件 mmc-meta.conf 和 mmc-local.conf 进行相关配置	133	+运行前可以根据 [配置项说明](./memcache_config.md) 对配置文件 mmc-meta.conf 和 mmc-local.conf 进行相关配置。
124		134
125	2. 设置环境变量	135	2. 设置环境变量
126		136
127	-通过环境变量来设置配置文件的路径	137	+通过环境变量来设置配置文件的路径。
		138	+
		139	+- 两个配置文件可以放在任意路径，这里以默认安装路径为例，请修改为实际路径。
		140	+- whl 包已默认编译带上 ubsio 盘管理功能，如启用 SSD 需修改配置文件并设置此环境变量，详见 SSD 使用文档。
		141	+
128	```bash	142	```bash
129	-# 两个配置文件可以放在任意路径，这里以默认安装路径为例，请修改为实际路径
130	-# whl 包已默认编译带上 ubsio 盘管理功能，如启用 SSD 需修改配置文件并设置此环境变量，详见 SSD 使用文档
131	export UBSIO_CONFIG_PATH=/usr/local/lib/python3.11/site-packages/memcache_hybrid/config/ubsio.conf	143	export UBSIO_CONFIG_PATH=/usr/local/lib/python3.11/site-packages/memcache_hybrid/config/ubsio.conf
132	export MMC_META_CONFIG_PATH=/usr/local/lib/python3.11/site-packages/memcache_hybrid/config/mmc-meta.conf	144	export MMC_META_CONFIG_PATH=/usr/local/lib/python3.11/site-packages/memcache_hybrid/config/mmc-meta.conf
133	export MMC_LOCAL_CONFIG_PATH=/usr/local/lib/python3.11/site-packages/memcache_hybrid/config/mmc-local.conf	145	export MMC_LOCAL_CONFIG_PATH=/usr/local/lib/python3.11/site-packages/memcache_hybrid/config/mmc-local.conf
	@@ -135,7 +147,8 @@ export MMC_LOCAL_CONFIG_PATH=/usr/local/lib/python3.11/site-packages/memcache_hy
135		147
136	3. 启动MetaService	148	3. 启动MetaService
137		149
138	-进入python控制台或者编写python脚本如下即可拉起进程：	150	+进入Python控制台或者编写如下Python脚本即可拉起进程。
		151	+
139	```python	152	```python
140	from memcache_hybrid import MetaService	153	from memcache_hybrid import MetaService
141	MetaService.main()	154	MetaService.main()
	@@ -143,9 +156,10 @@ MetaService.main()
143		156
144	4. 启动LocalService	157	4. 启动LocalService
145		158
146	-通过MemCache提供的[API](./memcache_python_api.md)初始化客户端并拉起LocalService，执行数据写入、查询、获取、删除等	159	+通过MemCache提供的[API](./memcache_python_api.md)初始化客户端并拉起LocalService，执行数据写入、查询、获取、删除等。
147		160
148	下面的脚本[test_mmc_demo.py](../example/python/test_mmc_demo.py)是我们提供的一个示例：	161	下面的脚本[test_mmc_demo.py](../example/python/test_mmc_demo.py)是我们提供的一个示例：
		162	+
149	```bash	163	```bash
150	python3 test_mmc_demo.py	164	python3 test_mmc_demo.py
151	```	165	```

Rdoc/memcache_c++_api.md→docs/memcache_c++_api.md+401-224

	@@ -1,59 +1,81 @@
1	# MemCache API	1	# MemCache API
2		2
3	## C++接口列表	3	## C++接口列表
		4	+
4	C++语言接口功能齐全，基于面向对象设计，提供统一的 `ObjectStore` 抽象基类，封装了实例管理、缓冲区注册、数据操作、批量处理及分层张量等功能。	5	C++语言接口功能齐全，基于面向对象设计，提供统一的 `ObjectStore` 抽象基类，封装了实例管理、缓冲区注册、数据操作、批量处理及分层张量等功能。
5		6
6	### 1. 实例创建与生命周期管理接口	7	### 1. 实例创建与生命周期管理接口
7		8
8	#### local_config	9	#### local_config
		10	+
9	`local_config` 是 `Setup` 接口使用的本地配置类型，定义位于 `src/memcache/include/mmc.h`。	11	`local_config` 是 `Setup` 接口使用的本地配置类型，定义位于 `src/memcache/include/mmc.h`。
10		12
11	-说明:	13	+> [!NOTE] 说明
12	-- 建议先通过 `create_default_local_config()` 获取带默认值的配置对象，再按需覆盖字段	14	+> 建议先通过 `create_default_local_config()` 获取带默认值的配置对象，再按需覆盖字段。
13		15
14	-常用字段:	16	+常用字段
15	-- `meta_service_url`: 元服务地址	17	+
16	-- `config_store_url`: 配置存储服务地址	18	+- `meta_service_url`：元服务地址。
17	-- `log_level`: 日志级别，如 `debug`、`info`、`warn`、`error`	19	+- `config_store_url`：配置存储服务地址。
18	-- `world_size`: 最大 rank 数	20	+- `log_level`：日志级别，如 `debug`、`info`、`warn`、`error`。
19	-- `protocol`: 数据传输协议，如 `host_rdma`、`host_urma`、`host_tcp`、`device_rdma`、`device_urma`、`device_uboe`、`device_sdma`	21	+- `world_size`：最大 rank 数。
20	-- `hcom_url`: HCOM 服务地址	22	+- `protocol`：数据传输协议，如 `host_rdma`、`host_urma`、`host_tcp`、`device_rdma`、`device_urma`、`device_uboe`、`device_sdma`。
21	-- `dram_size` / `hbm_size`: 本地服务 DRAM / HBM 容量	23	+- `hcom_url`：HCOM 服务地址。
22	-- `max_dram_size` / `max_hbm_size`: 所有本地进程可使用的 DRAM / HBM 总上限。	24	+- `dram_size` / `hbm_size`：本地服务 DRAM / HBM 容量。
		25	+- `max_dram_size` / `max_hbm_size`：所有本地进程可使用的 DRAM / HBM 总上限。
23		26
24	#### create_default_local_config	27	#### create_default_local_config
		28	+
25	```c++	29	```c++
26	local_config create_default_local_config();	30	local_config create_default_local_config();
27	```	31	```
28	-功能: 创建一个带内置默认值的 `local_config` 对象，便于用户只覆盖必要配置项。
29		32
30	-返回值:	33	+功能
31	-- 返回默认初始化后的 `local_config`	34	+
		35	+创建一个带内置默认值的 `local_config` 对象，便于用户只覆盖必要配置项。
		36	+
		37	+返回值
		38	+
		39	+返回默认初始化后的 `local_config`。
32		40
33	#### ObjectStore::CreateObjectStore	41	#### ObjectStore::CreateObjectStore
		42	+
34	```c++	43	```c++
35	static std::shared_ptr<ObjectStore> CreateObjectStore();	44	static std::shared_ptr<ObjectStore> CreateObjectStore();
36	```	45	```
37	-功能: 创建一个分布式内存缓存存储实例。
38		46
39	-返回值:	47	+功能
40	-- 返回 std::shared_ptr 管理的智能指针，确保资源自动释放，非空 shared_ptr 表示成功。	48	+
		49	+创建一个分布式内存缓存存储实例。
		50	+
		51	+返回值
		52	+
		53	+返回 std::shared_ptr 管理的智能指针，确保资源自动释放，非空 shared_ptr 表示成功。
41		54
42	#### Setup	55	#### Setup
		56	+
43	```c++	57	```c++
44	virtual int Setup(const local_config &config);	58	virtual int Setup(const local_config &config);
45	```	59	```
46	-功能: 初始化并校验本地配置，供后续 `Init` 使用。
47	-注：如果开启device_urma或device_uboe协议，则`max dram * world_size`的池化总大小必须大于32T
48		60
49	-参数:	61	+功能
50	-- `config`: 本地配置（`local_config`）	62	+
		63	+初始化并校验本地配置，供后续 `Init` 使用。
		64	+
		65	+> [!NOTE] 说明
		66	+> 如果开启device_urma或device_uboe协议，则`max dram * world_size`的池化总大小必须大于32T。
		67	+
		68	+参数
		69	+
		70	+`config`：本地配置（`local_config`）。
		71	+
		72	+返回值
51		73
52	-返回值:
53	- `0`：成功	74	- `0`：成功
54	- 其他：失败	75	- 其他：失败
55		76
56	-推荐调用顺序:	77	+推荐调用顺序
		78	+
57	```c++	79	```c++
58	auto store = ock::mmc::ObjectStore::CreateObjectStore();	80	auto store = ock::mmc::ObjectStore::CreateObjectStore();
59	local_config config = create_default_local_config();	81	local_config config = create_default_local_config();
	@@ -71,422 +93,577 @@ if (ret != 0) {
71	```	93	```
72		94
73	#### Init	95	#### Init
		96	+
74	```c++	97	```c++
75	virtual int Init(const uint32_t deviceId, bool initBm = true) = 0;	98	virtual int Init(const uint32_t deviceId, bool initBm = true) = 0;
76	```	99	```
77	-功能: 初始化当前存储实例，绑定到指定设备。
78		100
79	-参数:	101	+功能
80	-- `deviceId`: 目标设备ID	102	+
81	-- `initBm`: 是否初始化BM提供内存，默认值为 true。设 false 时将启动纯client模式，不支持数据读写操作	103	+初始化当前存储实例，绑定到指定设备。
		104	+
		105	+参数
		106	+
		107	+- `deviceId`：目标设备ID。
		108	+- `initBm`：是否初始化BM提供内存，默认值为 true。设 false 时将启动纯client模式，不支持数据读写操作。
		109	+
		110	+返回值
82		111
83	-返回值:
84	- `0`：成功	112	- `0`：成功
85	- 其他：失败	113	- 其他：失败
86		114
87	#### TearDown	115	#### TearDown
		116	+
88	```c++	117	```c++
89	virtual int TearDown() = 0;	118	virtual int TearDown() = 0;
90	```	119	```
91	-功能: 释放当前实例占用的所有资源，断开与元服务和本地服务的连接。
92		120
93	-返回值:	121	+功能
		122	+
		123	+释放当前实例占用的所有资源，断开与元服务和本地服务的连接。
		124	+
		125	+返回值
		126	+
94	- `0`：成功	127	- `0`：成功
95	- 其他：失败	128	- 其他：失败
96		129
97	### 2. 缓冲区注册接口	130	### 2. 缓冲区注册接口
98		131
99	#### RegisterBuffer	132	#### RegisterBuffer
		133	+
100	```c++	134	```c++
101	virtual int RegisterBuffer(void *buffer, size_t size) = 0;	135	virtual int RegisterBuffer(void *buffer, size_t size) = 0;
102	```	136	```
103	-功能: 将用户分配的内存区域注册到系统中，以启用 RDMA 或零拷贝传输。
104		137
105	-参数:	138	+功能
106	-- `buffer`: 内存起始地址	139	+
107	-- `size`: 缓冲区字节大小	140	+将用户分配的内存区域注册到系统中，以启用 RDMA 或零拷贝传输。
		141	+
		142	+参数
		143	+
		144	+- `buffer`：内存起始地址。
		145	+- `size`：缓冲区字节大小。
		146	+
		147	+返回值
108		148
109	-返回值:
110	- `0`：成功	149	- `0`：成功
111	- 其他：失败	150	- 其他：失败
112		151
113	#### UnRegisterBuffer	152	#### UnRegisterBuffer
		153	+
114	```c++	154	```c++
115	virtual int UnRegisterBuffer(void *buffer, size_t size) = 0;	155	virtual int UnRegisterBuffer(void *buffer, size_t size) = 0;
116	```	156	```
117	-功能: 注销已注册的内存区域。
118		157
119	-参数:	158	+功能
120	-- `buffer`: 内存起始地址
121	-- `size`: 缓冲区字节大小
122		159
123	-返回值:	160	+注销已注册的内存区域。
124	-- `0`: 成功	161	+
125	-- 其他: 失败	162	+参数
		163	+
		164	+- `buffer`：内存起始地址。
		165	+- `size`：缓冲区字节大小。
		166	+
		167	+返回值
		168	+
		169	+- `0`：成功
		170	+- 其他：失败
126		171
127	### 3. 数据操作接口	172	### 3. 数据操作接口
128		173
129	#### GetInto	174	#### GetInto
		175	+
130	```c++	176	```c++
131	virtual int GetInto(const std::string &key, void *buffer, size_t size, const int32_t direct = 2) = 0;	177	virtual int GetInto(const std::string &key, void *buffer, size_t size, const int32_t direct = 2) = 0;
132	```	178	```
133	-功能: 将指定键的数据读入预分配的 buffer 中。
134		179
135	-参数:	180	+功能
136	-- `key`: 数据键（长度 < 256字节）
137	-- `buffer`: 目标内存地址
138	-- `size`: 缓冲区容量
139	-- `direct`: 数据流向
140		181
141	-返回值:	182	+将指定键的数据读入预分配的 buffer 中。
142	-- `0`: 成功	183	+
143	-- 其他: 失败	184	+参数
		185	+
		186	+- `key`：数据键（长度 < 256字节）。
		187	+- `buffer`：目标内存地址。
		188	+- `size`：缓冲区容量。
		189	+- `direct`：数据流向。
		190	+
		191	+返回值
		192	+
		193	+- `0`：成功
		194	+- 其他：失败
144		195
145	#### PutFrom	196	#### PutFrom
		197	+
146	```c++	198	```c++
147	virtual int PutFrom(const std::string &key, void *buffer, size_t size, const int32_t direct = 3,	199	virtual int PutFrom(const std::string &key, void *buffer, size_t size, const int32_t direct = 3,
148	const ReplicateConfig &replicateConfig = {}) = 0;	200	const ReplicateConfig &replicateConfig = {}) = 0;
149	```	201	```
150	-功能: 将 buffer 中的数据写入缓存并关联到 key。
151		202
152	-参数:	203	+功能
153	-- `key`: 数据键（长度 < 256字节）
154	-- `buffer`: 目标内存地址
155	-- `size`: 缓冲区容量
156	-- `direct`: 数据流向
157	-- `replicateConfig`: 副本策略配置
158		204
159	-返回值:	205	+将 buffer 中的数据写入缓存并关联到 key。
160	-- `0`: 成功	206	+
161	-- 其他: 失败	207	+参数
		208	+
		209	+- `key`：数据键（长度 < 256字节）。
		210	+- `buffer`：目标内存地址。
		211	+- `size`：缓冲区容量。
		212	+- `direct`：数据流向。
		213	+- `replicateConfig`：副本策略配置。
		214	+
		215	+返回值
		216	+
		217	+- `0`：成功
		218	+- 其他：失败
162		219
163	#### Remove	220	#### Remove
		221	+
164	```c++	222	```c++
165	virtual int Remove(const std::string &key) = 0;	223	virtual int Remove(const std::string &key) = 0;
166	```	224	```
167	-功能: 删除指定键的数据对象。
168		225
169	-参数:	226	+功能
170	-- `key`: 数据键（长度 < 256字节）
171		227
172	-返回值:	228	+删除指定键的数据对象。
173	-- `0`: 成功	229	+
174	-- 其他: 失败	230	+参数
		231	+
		232	+`key`：数据键（长度 < 256字节）。
		233	+
		234	+返回值
		235	+
		236	+- `0`：成功
		237	+- 其他：失败
175		238
176	#### IsExist	239	#### IsExist
		240	+
177	```c++	241	```c++
178	virtual int IsExist(const std::string &key) = 0;	242	virtual int IsExist(const std::string &key) = 0;
179	```	243	```
180	-功能: 检查键是否存在。
181		244
182	-参数:	245	+功能
183	-- `key`: 数据键（长度 < 256字节）
184		246
185	-返回值:	247	+检查键是否存在。
186	-- `1`: 存在	248	+
187	-- `0`: 不存在	249	+参数
188	-- 其他: 失败	250	+
		251	+`key`：数据键（长度 < 256字节）。
		252	+
		253	+返回值
		254	+
		255	+- `1`：存在
		256	+- `0`：不存在
		257	+- 其他：失败
189		258
190	#### GetKeyInfo	259	#### GetKeyInfo
		260	+
191	```c++	261	```c++
192	virtual KeyInfo GetKeyInfo(const std::string &key, uint32_t flag = 0) = 0;	262	virtual KeyInfo GetKeyInfo(const std::string &key, uint32_t flag = 0) = 0;
193	```	263	```
194	-功能: 获取键的元信息。
195		264
196	-参数:	265	+功能
197	-- `key`: 数据的键，长度小于256个字节	266	+
198	-- `flag`: 查询标志，默认值为 `0`	267	+获取键的元信息。
		268	+
		269	+参数
		270	+
		271	+- `key`：数据的键，长度小于256个字节。
		272	+- `flag`：查询标志，默认值为 `0`。
		273	+
		274	+返回值
199		275
200	-返回值:
201	返回 KeyInfo，包含：	276	返回 KeyInfo，包含：
202	-- `size_`: 数据字节数
203	-- `blobNum_`: 数据副本数
204	-- `loc_`: 数据副本所在位置列表
205	-- `type_`: 数据副本所在介质类型列表
206	-- `gva_`: 数据副本对应的 GVA 列表
207		277
208	-> 补充说明：	278	+- `size_`：数据字节数。
209	-> `GetKeyInfo` 的实际签名带 `flag` 参数。默认值为 `0`	279	+- `blobNum_`：数据副本数。
210	-> `KeyInfo` 除 `size_`、`blobNum_`、`loc_`、`type_` 外，还包含 `gva_`，用于描述每个 blob 对应的 GVA 列表。	280	+- `loc_`：数据副本所在位置列表。
		281	+- `type_`：数据副本所在介质类型列表。
		282	+- `gva_`：数据副本对应的 GVA 列表。
		283	+
		284	+> [!NOTE] 补充说明
		285	+>
		286	+> - `GetKeyInfo` 的实际签名带 `flag` 参数。默认值为 `0`。
		287	+> - `KeyInfo` 除 `size_`、`blobNum_`、`loc_`、`type_` 外，还包含 `gva_`，用于描述每个 blob 对应的 GVA 列表。
211		288
212	### 4. 批量操作接口	289	### 4. 批量操作接口
213		290
214	#### BatchGetInto	291	#### BatchGetInto
		292	+
215	```c++	293	```c++
216	virtual std::vector<int> BatchGetInto(const std::vector<std::string> &keys, const std::vector<void *> &buffers,	294	virtual std::vector<int> BatchGetInto(const std::vector<std::string> &keys, const std::vector<void *> &buffers,
217	const std::vector<size_t> &sizes, const int32_t direct = 2) = 0;	295	const std::vector<size_t> &sizes, const int32_t direct = 2) = 0;
218	```	296	```
219	-功能: 批量读取多个键到各自缓冲区。
220		297
221	-参数:	298	+功能
222	-- `keys`: 数据键列表（每个键长度 < 256字节）
223	-- `buffers`: 目标内存地址列表，必须与keys一一对应
224	-- `sizes`: 缓冲区容量列表，必须与buffers长度一致
225	-- `direct`: 数据流向
226		299
227	-返回值:	300	+批量读取多个键到各自缓冲区。
228	-- 返回每个键对应的处理结果列表，每个元素 `0` 表示成功，负数表示失败	301	+
		302	+参数
		303	+
		304	+- `keys`：数据键列表（每个键长度 < 256字节）。
		305	+- `buffers`：目标内存地址列表，必须与keys一一对应。
		306	+- `sizes`：缓冲区容量列表，必须与buffers长度一致。
		307	+- `direct`：数据流向。
		308	+
		309	+返回值
		310	+
		311	+返回每个键对应的处理结果列表，每个元素 `0` 表示成功，负数表示失败。
229		312
230	#### BatchPutFrom	313	#### BatchPutFrom
		314	+
231	```c++	315	```c++
232	virtual std::vector<int> BatchPutFrom(const std::vector<std::string> &keys, const std::vector<void *> &buffers,	316	virtual std::vector<int> BatchPutFrom(const std::vector<std::string> &keys, const std::vector<void *> &buffers,
233	const std::vector<size_t> &sizes, const int32_t direct = 3,	317	const std::vector<size_t> &sizes, const int32_t direct = 3,
234	const ReplicateConfig &replicateConfig = {}) = 0;	318	const ReplicateConfig &replicateConfig = {}) = 0;
235	```	319	```
236	-功能: 批量写入多个键。
237		320
238	-参数:	321	+功能
239	-- `keys`: 数据键列表（每个键长度 < 256字节）
240	-- `buffers`: 目标内存地址列表，必须与keys一一对应
241	-- `sizes`: 缓冲区容量列表，必须与buffers长度一致
242	-- `direct`: 数据流向
243	-- `replicateConfig`: 副本策略配置
244		322
245	-返回值:	323	+批量写入多个键。
246	-- 返回每个键对应的处理结果列表，每个元素 `0` 表示成功，负数表示失败	324	+
		325	+参数
		326	+
		327	+- `keys`：数据键列表（每个键长度 < 256字节）。
		328	+- `buffers`：目标内存地址列表，必须与keys一一对应。
		329	+- `sizes`：缓冲区容量列表，必须与buffers长度一致。
		330	+- `direct`：数据流向。
		331	+- `replicateConfig`：副本策略配置。
		332	+
		333	+返回值
		334	+
		335	+返回每个键对应的处理结果列表，每个元素 `0` 表示成功，负数表示失败。
247		336
248	#### BatchRemove	337	#### BatchRemove
		338	+
249	```c++	339	```c++
250	virtual std::vector<int> BatchRemove(const std::vector<std::string> &keys) = 0;	340	virtual std::vector<int> BatchRemove(const std::vector<std::string> &keys) = 0;
251	```	341	```
252	-功能: 批量删除。
253		342
254	-参数:	343	+功能
255	-- `keys`: 数据键列表（每个键长度 < 256字节）
256		344
257	-返回值:	345	+批量删除。
258	-- 返回每个键对应的处理结果列表，每个元素 `0` 表示成功，负数表示失败	346	+
		347	+参数
		348	+
		349	+`keys`：数据键列表（每个键长度 < 256字节）。
		350	+
		351	+返回值
		352	+
		353	+返回每个键对应的处理结果列表，每个元素 `0` 表示成功，负数表示失败。
259		354
260	#### BatchIsExist	355	#### BatchIsExist
		356	+
261	```c++	357	```c++
262	virtual std::vector<int> BatchIsExist(const std::vector<std::string> &keys) = 0;	358	virtual std::vector<int> BatchIsExist(const std::vector<std::string> &keys) = 0;
263	```	359	```
264	-功能: 批量存在性检查。
265		360
266	-参数:	361	+功能
267	-- `keys`: 数据键列表（每个键长度 < 256字节）
268		362
269	-返回值:	363	+批量存在性检查。
270	-- `1`: 存在	364	+
271	-- `0`: 不存在	365	+参数
272	-- 其他: 失败	366	+
		367	+`keys`：数据键列表（每个键长度 < 256字节）。
		368	+
		369	+返回值
		370	+
		371	+- `1`：存在
		372	+- `0`：不存在
		373	+- 其他：失败
273		374
274	#### BatchGetKeyInfo	375	#### BatchGetKeyInfo
		376	+
275	```c++	377	```c++
276	virtual std::vector<KeyInfo> BatchGetKeyInfo(const std::vector<std::string> &keys, uint32_t flag = 0) = 0;	378	virtual std::vector<KeyInfo> BatchGetKeyInfo(const std::vector<std::string> &keys, uint32_t flag = 0) = 0;
277	```	379	```
278	-功能: 批量查询元信息。
279		380
280	-参数:	381	+功能
281	-- `keys`: 数据键列表（每个键长度 < 256字节）	382	+
282	-- `flag`: 查询标志，默认值为 `0`	383	+批量查询元信息。
		384	+
		385	+参数
		386	+
		387	+- `keys`：数据键列表（每个键长度 < 256字节）。
		388	+- `flag`：查询标志，默认值为 `0`。
		389	+
		390	+返回值
283		391
284	-返回值:
285	返回KeyInfo列表，每个KeyInfo包含：	392	返回KeyInfo列表，每个KeyInfo包含：
286	-- `size_`: 数据字节数	393	+
287	-- `blobNum_`: 数据副本数	394	+- `size_`：数据字节数。
288	-- `loc_`: 数据副本所在位置列表	395	+- `blobNum_`：数据副本数。
289	-- `type_`: 数据副本所在介质类型列表	396	+- `loc_`：数据副本所在位置列表。
290	-- `gva_`: 数据副本对应的 GVA 列表	397	+- `type_`：数据副本所在介质类型列表。
		398	+- `gva_`：数据副本对应的 GVA 列表。
291		399
292	#### BatchAddLease	400	#### BatchAddLease
		401	+
293	```c++	402	```c++
294	virtual std::vector<int> BatchAddLease(const std::vector<std::string> &keys, uint64_t leaseTtlMs = 0) = 0;	403	virtual std::vector<int> BatchAddLease(const std::vector<std::string> &keys, uint64_t leaseTtlMs = 0) = 0;
295	```	404	```
296	-功能: 批量为多个 key 增加读租约，并记录后续 GVA 读取所需的读租约状态。
297		405
298	-参数:	406	+功能
299	-- `keys`: 要增加读租约的 key 列表（每个键长度 < 256字节），不能为空
300	-- `leaseTtlMs`: 要增加的租约时间，单位为毫秒，默认为 `0`。为 `0` 时使用 meta 侧配置项
301	- `ock.mmc.meta.lease_ttl_ms`
302		407
303	-返回值:	408	+批量为多个 key 增加读租约，并记录后续 GVA 读取所需的读租约状态。
304	-- `std::vector<int>`: 每个元素表示对应 key 的处理结果，`0` 表示成功，其他值表示失败	409	+
305	- 返回列表长度与 `keys` 一致。	410	+参数
		411	+
		412	+- `keys`：要增加读租约的 key 列表（每个键长度 < 256字节），不能为空。
		413	+- `leaseTtlMs`：要增加的租约时间，单位为毫秒，默认为 `0`。为 `0` 时使用 meta 侧配置项 `ock.mmc.meta.lease_ttl_ms`。
		414	+
		415	+返回值
		416	+
		417	+`std::vector<int>`：每个元素表示对应 key 的处理结果，`0` 表示成功，其他值表示失败。返回列表长度与 `keys` 一致。
		418	+
		419	+使用说明
306		420
307	-使用说明:
308	- 该接口返回每个 key 的错误码，不返回 `KeyInfo`。	421	- 该接口返回每个 key 的错误码，不返回 `KeyInfo`。
309	- 该接口为非事务接口；某个 key 失败不会回滚其他 key 已经成功增加的读租约。	422	- 该接口为非事务接口；某个 key 失败不会回滚其他 key 已经成功增加的读租约。
310	- `leaseTtlMs` 为 `0` 时，meta 侧使用配置项 `ock.mmc.meta.lease_ttl_ms` 的值增加租约。	423	- `leaseTtlMs` 为 `0` 时，meta 侧使用配置项 `ock.mmc.meta.lease_ttl_ms` 的值增加租约。
311	- 调用方应只对返回值为 `0` 的 key 继续执行后续基于 GVA 的读取流程。	424	- 调用方应只对返回值为 `0` 的 key 继续执行后续基于 GVA 的读取流程。
312	-- 典型用法是先通过 `BatchGetKeyInfo(keys)` 获取 GVA，再调用 `BatchAddLease(keys)`	425	+- 典型用法是先通过 `BatchGetKeyInfo(keys)` 获取 GVA，再调用 `BatchAddLease(keys)`，为后续基于 GVA 的读取流程建立读租约状态。
313	- 为后续基于 GVA 的读取流程建立读租约状态。	426	+- 同一进程对同一 key 重复调用时，会复用当前进程中已有的读租约并在 meta 侧续租；完成读取后调用一次 `BatchRemoveLease` 即可释放。
314	-- 同一进程对同一 key 重复调用时，会复用当前进程中已有的读租约并在 meta 侧续租；
315	- 完成读取后调用一次 `BatchRemoveLease` 即可释放。
316		427
317	#### BatchRemoveLease	428	#### BatchRemoveLease
		429	+
318	```c++	430	```c++
319	virtual int BatchRemoveLease(const std::vector<std::string> &keys) = 0;	431	virtual int BatchRemoveLease(const std::vector<std::string> &keys) = 0;
320	```	432	```
321	-功能: 批量移除多个 key 的读租约，并清理当前进程中对应的 GVA 读取状态。
322		433
323	-参数:	434	+功能
324	-- `keys`: 要移除读租约的 key 列表（每个键长度 < 256字节），不能为空
325		435
326	-返回值:	436	+批量移除多个 key 的读租约，并清理当前进程中对应的 GVA 读取状态。
327	-- `int`: `0` 表示本地读租约检查通过并已触发移除租约请求发送流程；其他值表示失败。
328		437
329	-使用说明:	438	+参数
330	-- 调用方完成基于 GVA 的读取后，应调用该接口显式释放由 `BatchAddLease` 建立的读租约。	439	+
		440	+`keys`：要移除读租约的 key 列表（每个键长度 < 256字节），不能为空。
		441	+
		442	+返回值
		443	+
		444	+- `int`：`0` 表示本地读租约检查通过并已触发移除租约请求发送流程。
		445	+- 其他值表示失败。
		446	+
		447	+使用说明
		448	+
		449	+调用方完成基于 GVA 的读取后，应调用该接口显式释放由 `BatchAddLease` 建立的读租约。
331		450
332	#### BatchMalloc	451	#### BatchMalloc
		452	+
333	```c++	453	```c++
334	virtual std::vector<uintptr_t> BatchMalloc(const std::vector<std::string> &keys, const std::vector<size_t> &sizes,	454	virtual std::vector<uintptr_t> BatchMalloc(const std::vector<std::string> &keys, const std::vector<size_t> &sizes,
335	uint16_t media, uint64_t leaseTtlMs = 0) = 0;	455	uint16_t media, uint64_t leaseTtlMs = 0) = 0;
336	```	456	```
337	-功能: 批量为多个 key 申请全局内存，并返回每个 key 对应的起始 GVA。
338		457
339	-参数:	458	+功能
340	-- `keys`: 要申请内存的 key 列表，长度必须与 `sizes` 一致
341	-- `sizes`: 每个 key 对应的数据大小列表
342	-- `media`: 申请的介质类型，如 `MEDIA_HBM` 或 `MEDIA_DRAM`
343	-- `leaseTtlMs`: 要增加的租约时间，单位为毫秒，默认为 `0`。为 `0` 时使用 meta 侧配置项 `ock.mmc.meta.lease_ttl_ms`
344		459
345	-返回值:	460	+批量为多个 key 申请全局内存，并返回每个 key 对应的起始 GVA。
346	-- `std::vector<uintptr_t>`: 每个元素为一个 key 对应的起始 GVA	461	+
347	-- 申请失败或参数非法时，对应元素为 `0`	462	+参数
		463	+
		464	+- `keys`：要申请内存的 key 列表，长度必须与 `sizes` 一致。
		465	+- `sizes`：每个 key 对应的数据大小列表。
		466	+- `media`：申请的介质类型，如 `MEDIA_HBM` 或 `MEDIA_DRAM`。
		467	+- `leaseTtlMs`：要增加的租约时间，单位为毫秒，默认为 `0`。为 `0` 时使用 meta 侧配置项 `ock.mmc.meta.lease_ttl_ms`。
		468	+
		469	+返回值
		470	+
		471	+- `std::vector<uintptr_t>`：每个元素为一个 key 对应的起始 GVA。
		472	+- 申请失败或参数非法时，对应元素为 `0`。
348		473
349	#### BatchCopy	474	#### BatchCopy
		475	+
350	```c++	476	```c++
351	virtual int BatchCopy(std::vector<void > &gvas, std::vector<void > &buffers, std::vector<size_t> &sizes,	477	virtual int BatchCopy(std::vector<void > &gvas, std::vector<void > &buffers, std::vector<size_t> &sizes,
352	const int32_t direct = 3) = 0;	478	const int32_t direct = 3) = 0;
353	```	479	```
354	-功能: 批量在 GVA 地址与本地缓冲区之间执行数据拷贝。注意：写方向（如 `SMEMB_COPY_L2G`/`SMEMB_COPY_H2G`）只拷贝数据，不会将 GVA 对应的 blob 状态翻转为 READABLE；调用方必须再调用 `MmcacheStore::BatchWriteFinish` 显式通知写完成，blob 才会进入可读状态。
355		480
356	-参数:	481	+功能
357	-- `gvas`: GVA 地址列表
358	-- `buffers`: 本地缓冲区列表，必须与 `gvas` 一一对应
359	-- `sizes`: 每次拷贝的大小列表，长度必须与 `gvas` 一致
360	-- `direct`: 数据拷贝方向，取值参见 `smem_bm_copy_type`，常用值包括 `SMEMB_COPY_L2G`、`SMEMB_COPY_G2L`、`SMEMB_COPY_G2H`、`SMEMB_COPY_H2G`
361		482
362	-返回值:	483	+批量在 GVA 地址与本地缓冲区之间执行数据拷贝。
363	-- `0`: 成功	484	+
364	-- 其他: 失败	485	+> [!NOTE] 说明
		486	+> 写方向（如 `SMEMB_COPY_L2G`/`SMEMB_COPY_H2G`）只拷贝数据，不会将 GVA 对应的 blob 状态翻转为 READABLE；调用方必须再调用 `MmcacheStore::BatchWriteFinish` 显式通知写完成，blob 才会进入可读状态。
		487	+
		488	+参数
		489	+
		490	+- `gvas`：GVA 地址列表。
		491	+- `buffers`：本地缓冲区列表，必须与 `gvas` 一一对应。
		492	+- `sizes`：每次拷贝的大小列表，长度必须与 `gvas` 一致。
		493	+- `direct`：数据拷贝方向，取值参见 `smem_bm_copy_type`，常用值包括 `SMEMB_COPY_L2G`、`SMEMB_COPY_G2L`、`SMEMB_COPY_G2H`、`SMEMB_COPY_H2G`。
		494	+
		495	+返回值
		496	+
		497	+- `0`：成功
		498	+- 其他：失败
365		499
366	#### BatchWriteFinish	500	#### BatchWriteFinish
		501	+
367	```c++	502	```c++
368	virtual std::vector<int> BatchWriteFinish(const std::vector<std::string> &keys,	503	virtual std::vector<int> BatchWriteFinish(const std::vector<std::string> &keys,
369	const std::vector<int32_t> &writeResults) = 0;	504	const std::vector<int32_t> &writeResults) = 0;
370	```	505	```
371	-功能: 显式通知 meta service 给定 key 的写入已完成。调用方在 `BatchCopy` 写方向完成后必须调用此接口，meta service 才会将对应 blob 从 `ALLOCATED` 翻转为 `READABLE`，此后其他进程才能通过 `BatchGetKeyInfo` / `BatchCopy` 读方向读到数据。对于已处于 `READABLE` 的 key，再次调用为幂等并直接返回成功；对未分配过的 key 返回 `MMC_UNMATCHED_KEY`。
372		506
373	-参数:	507	+功能
374	-- `keys`: 已写入完成的键列表，每个键长度小于 256 个字节
375	-- `writeResults`: 与 `keys` 等长的每键写入结果，`0` 表示成功（对应 `MMC_WRITE_OK`，blob 翻为 `READABLE`），非 `0` 表示失败（对应 `MMC_WRITE_FAIL`，meta service 会移除该 blob）
376		508
377	-返回值:	509	+显式通知 meta service 给定 key 的写入已完成。
378	-- `std::vector<int>`: 与 `keys` 等长，每个元素为 meta service 对该键的实际更新结果；`0` 表示成功
379		510
380	-> 典型 GVA 跨进程读取流程：	511	+> [!NOTE] 说明
		512	+> 调用方在 `BatchCopy` 写方向完成后必须调用此接口，meta service 才会将对应 blob 从 `ALLOCATED` 翻转为 `READABLE`，此后其他进程才能通过 `BatchGetKeyInfo` / `BatchCopy` 读方向读到数据。对于已处于 `READABLE` 的 key，再次调用为幂等并直接返回成功；对未分配过的 key 返回 `MMC_UNMATCHED_KEY`。
		513	+
		514	+参数
		515	+
		516	+- `keys`：已写入完成的键列表，每个键长度小于 256 个字节。
		517	+- `writeResults`：与 `keys` 等长的每键写入结果，`0` 表示成功（对应 `MMC_WRITE_OK`，blob 翻为 `READABLE`），非 `0` 表示失败（对应 `MMC_WRITE_FAIL`，meta service 会移除该 blob）。
		518	+
		519	+返回值
		520	+
		521	+`std::vector<int>`：与 `keys` 等长，每个元素为 meta service 对该键的实际更新结果；`0` 表示成功。
		522	+
		523	+> [!NOTE] 典型 GVA 跨进程读取流程：
		524	+>
381	> - 写进程：`BatchMalloc -> BatchCopy`（写入数据）-> `BatchWriteFinish` 显式通知写完成，blob 翻为 READABLE。	525	> - 写进程：`BatchMalloc -> BatchCopy`（写入数据）-> `BatchWriteFinish` 显式通知写完成，blob 翻为 READABLE。
382	-> - 读进程：`BatchGetKeyInfo(keys, 0)` 获取 GVA -> `BatchAddLease(...)` 增加读租约并准备 GVA 读取状态 ->	526	+> - 读进程：`BatchGetKeyInfo(keys, 0)` 获取 GVA -> `BatchAddLease(...)` 增加读租约并准备 GVA 读取状态 -> `BatchCopy`（读取）-> `BatchRemoveLease(...)` 显式释放读租约。
383	-> `BatchCopy`（读取）-> `BatchRemoveLease(...)` 显式释放读租约。
384		527
385	### 5. 分层张量操作	528	### 5. 分层张量操作
386		529
387	#### PutFromLayers	530	#### PutFromLayers
		531	+
388	```c++	532	```c++
389	virtual int PutFromLayers(const std::string &key, const std::vector<void *> &buffers,	533	virtual int PutFromLayers(const std::string &key, const std::vector<void *> &buffers,
390	const std::vector<size_t> &sizes, const int32_t direct = 3,	534	const std::vector<size_t> &sizes, const int32_t direct = 3,
391	const ReplicateConfig &replicateConfig = {}) = 0;	535	const ReplicateConfig &replicateConfig = {}) = 0;
392		536
393	```	537	```
394	-功能: 将多个内存块（layers）拼接后作为一个逻辑对象写入缓存，并关联到指定键。
395		538
396	-参数:	539	+功能
397	-- `key`: 数据键（长度 < 256字节）
398	-- `buffers`: 多层内存地址列表
399	-- `sizes`: 每层缓冲区容量大小列表，必须与buffers长度一致
400	-- `direct`: 数据流向
401	-- `replicateConfig`: 副本策略配置
402		540
403	-返回值:	541	+将多个内存块（layers）拼接后作为一个逻辑对象写入缓存，并关联到指定键。
404	-- `0`: 成功	542	+
405	-- 其他: 失败	543	+参数
		544	+
		545	+- `key`：数据键（长度 < 256字节）。
		546	+- `buffers`：多层内存地址列表。
		547	+- `sizes`：每层缓冲区容量大小列表，必须与buffers长度一致。
		548	+- `direct`：数据流向。
		549	+- `replicateConfig`：副本策略配置。
		550	+
		551	+返回值
		552	+
		553	+- `0`：成功
		554	+- 其他：失败
406		555
407	#### GetIntoLayers	556	#### GetIntoLayers
		557	+
408	```c++	558	```c++
409	virtual int GetIntoLayers(const std::string &key, const std::vector<void *> &buffers,	559	virtual int GetIntoLayers(const std::string &key, const std::vector<void *> &buffers,
410	const std::vector<size_t> &sizes, const int32_t direct = 2) = 0;	560	const std::vector<size_t> &sizes, const int32_t direct = 2) = 0;
411	```	561	```
412	-功能: 从缓存中读取指定键的逻辑对象，并按预定义大小分发到多个目标缓冲区。
413		562
414	-参数:	563	+功能
415	-- `key`: 数据键（长度 < 256字节）
416	-- `buffers`: 多层内存地址列表
417	-- `sizes`: 每层缓冲区容量大小列表，必须与buffers长度一致
418	-- `direct`: 数据流向
419		564
420	-返回值:	565	+从缓存中读取指定键的逻辑对象，并按预定义大小分发到多个目标缓冲区。
421	-- `0`: 成功	566	+
422	-- 其他: 失败	567	+参数
		568	+
		569	+- `key`：数据键（长度 < 256字节）。
		570	+- `buffers`：多层内存地址列表。
		571	+- `sizes`：每层缓冲区容量大小列表，必须与buffers长度一致。
		572	+- `direct`：数据流向。
		573	+
		574	+返回值
		575	+
		576	+- `0`：成功
		577	+- 其他：失败
423		578
424	#### BatchPutFromLayers	579	#### BatchPutFromLayers
		580	+
425	```c++	581	```c++
426	virtual std::vector<int> BatchPutFromLayers(const std::vector<std::string> &keys,	582	virtual std::vector<int> BatchPutFromLayers(const std::vector<std::string> &keys,
427	const std::vector<std::vector<void *>> &buffers,	583	const std::vector<std::vector<void *>> &buffers,
428	const std::vector<std::vector<size_t>> &sizes, const int32_t direct = 3,	584	const std::vector<std::vector<size_t>> &sizes, const int32_t direct = 3,
429	const ReplicateConfig &replicateConfig = {}) = 0;	585	const ReplicateConfig &replicateConfig = {}) = 0;
430	```	586	```
431	-功能: 批量将多个逻辑对象（每个由多层内存块组成）写入缓存。
432		587
433	-参数:	588	+功能
434	-- `keys`: 数据键列表（每个键长度 < 256字节）	589	+
435	-- `buffers`: 多层内存地址列表，必须与keys一一对应	590	+批量将多个逻辑对象（每个由多层内存块组成）写入缓存。
436	-- `sizes`: 每层缓冲区容量大小列表，必须与buffers长度一致	591	+
437	-- `direct`: 数据流向	592	+参数
438	-- `replicateConfig`: 副本策略配置	593	+
		594	+- `keys`：数据键列表（每个键长度 < 256字节）。
		595	+- `buffers`：多层内存地址列表，必须与keys一一对应。
		596	+- `sizes`：每层缓冲区容量大小列表，必须与buffers长度一致。
		597	+- `direct`：数据流向。
		598	+- `replicateConfig`：副本策略配置。
		599	+
		600	+返回值
439		601
440	-返回值:
441	返回每个键对应的处理结果列表，每个元素 `0` 表示成功，负数表示失败	602	返回每个键对应的处理结果列表，每个元素 `0` 表示成功，负数表示失败
442		603
443	#### BatchGetIntoLayers	604	#### BatchGetIntoLayers
		605	+
444	```c++	606	```c++
445	virtual std::vector<int> BatchGetIntoLayers(const std::vector<std::string> &keys,	607	virtual std::vector<int> BatchGetIntoLayers(const std::vector<std::string> &keys,
446	const std::vector<std::vector<void *>> &buffers,	608	const std::vector<std::vector<void *>> &buffers,
447	const std::vector<std::vector<size_t>> &sizes,	609	const std::vector<std::vector<size_t>> &sizes,
448	const int32_t direct = 2) = 0;	610	const int32_t direct = 2) = 0;
449	```	611	```
450	-功能: 批量从缓存中读取多个逻辑对象，并分别分发到各自的多层缓冲区。
451		612
452	-参数:	613	+功能
453	-- `keys`: 数据键列表（每个键长度 < 256字节）
454	-- `buffers`: 多层内存地址列表，必须与keys一一对应
455	-- `sizes`: 每层缓冲区容量大小列表，必须与buffers长度一致
456	-- `direct`: 数据流向
457		614
458	-返回值:	615	+批量从缓存中读取多个逻辑对象，并分别分发到各自的多层缓冲区。
459	-返回每个键对应的处理结果列表，每个元素 `0` 表示成功，负数表示失败	616	+
		617	+参数
		618	+
		619	+- `keys`：数据键列表（每个键长度 < 256字节）。
		620	+- `buffers`：多层内存地址列表，必须与keys一一对应。
		621	+- `sizes`：每层缓冲区容量大小列表，必须与buffers长度一致。
		622	+- `direct`：数据流向。
		623	+
		624	+返回值
		625	+
		626	+返回每个键对应的处理结果列表，每个元素 `0` 表示成功，负数表示失败。
460		627
461	### 6. 辅助接口	628	### 6. 辅助接口
462		629
463	#### GetLocalServiceId	630	#### GetLocalServiceId
		631	+
464	```c++	632	```c++
465	virtual int GetLocalServiceId(uint32_t &localServiceId) = 0;	633	virtual int GetLocalServiceId(uint32_t &localServiceId) = 0;
466	```	634	```
467	-功能: 获取当前实例关联的本地服务 ID（用于调试或日志追踪）。
468		635
469	-参数:	636	+功能
470	-- `localServiceId`: 输出参数
471		637
472	-返回值:	638	+获取当前实例关联的本地服务 ID（用于调试或日志追踪）。
473	-- `0`: 成功	639	+
474	-- 其他: 失败	640	+参数
		641	+
		642	+`localServiceId`：输出参数。
		643	+
		644	+返回值
		645	+
		646	+- `0`：成功
		647	+- 其他：失败
475		648
476	## 数据结构	649	## 数据结构
477		650
478	### ReplicateConfig	651	### ReplicateConfig
		652	+
479	副本策略配置，包含以下字段：	653	副本策略配置，包含以下字段：
480	-- `replicaNum`: 副本数，默认1，最大8	654	+
481	-- `preferredLocalServiceIDs`: 优先分配的本地服务 ID 列表，列表大小必须小于或等于replicaNum	655	+- `replicaNum`：副本数，默认1，最大8。
		656	+- `preferredLocalServiceIDs`：优先分配的本地服务 ID 列表，列表大小必须小于或等于replicaNum。
482		657
483	### KeyInfo	658	### KeyInfo
		659	+
484	键元信息结构体，包含以下字段：	660	键元信息结构体，包含以下字段：
485	-- `size_`: 数据字节数	661	+
486	-- `blobNum_`: 数据副本数	662	+- `size_`：数据字节数。
487	-- `loc_`: 数据副本所在位置列表	663	+- `blobNum_`：数据副本数。
488	-- `type_`: 数据副本所在介质类型列表	664	+- `loc_`：数据副本所在位置列表。
489	-- `gva_`: 数据副本的全局虚拟地址列表	665	+- `type_`：数据副本所在介质类型列表。
		666	+- `gva_`：数据副本的全局虚拟地址列表。
490		667
491	## smem_bm_copy_type 枚举类型	668	## smem_bm_copy_type 枚举类型
492		669
	@@ -536,6 +713,6 @@ virtual int GetLocalServiceId(uint32_t &localServiceId) = 0;
536		713
537	## 注意事项	714	## 注意事项
538		715
539	-- 所有键的长度必须小于256个字节	716	+- 所有键的长度必须小于256个字节。
540	-- 支持同步和异步两种操作模式	717	+- 支持同步和异步两种操作模式。
541	-- 批量操作可以提高处理效率	718	+- 批量操作可以提高处理效率。

Rdoc/memcache_c_api.md→docs/memcache_c_api.md+475-283

	@@ -1,543 +1,735 @@
1	# MemCache API	1	# MemCache API
2		2
3	## C接口列表	3	## C接口列表
		4	+
4	C语言接口功能齐全，包含metaservice/localservice服务启停接口，客户端初始化和反初始化接口，数据操作接口和日志设置接口。	5	C语言接口功能齐全，包含metaservice/localservice服务启停接口，客户端初始化和反初始化接口，数据操作接口和日志设置接口。
5		6
6	### 1. 服务启动停止接口	7	### 1. 服务启动停止接口
7		8
8	#### mmcs_meta_service_start	9	#### mmcs_meta_service_start
		10	+
9	```c	11	```c
10	mmc_meta_service_t mmcs_meta_service_start(mmc_meta_service_config_t *config);	12	mmc_meta_service_t mmcs_meta_service_start(mmc_meta_service_config_t *config);
11	```	13	```
12	-功能: 启动分布式内存缓存的元数据服务，该服务是全局的。
13		14
14	-参数:	15	+功能
15	-- `config`: 元数据服务配置信息
16		16
17	-返回值:	17	+启动分布式内存缓存的元数据服务，该服务是全局的。
18	-- `mmc_meta_service_t`: 元数据服务句柄（成功），NULL（失败）	18	+
		19	+参数
		20	+
		21	+`config`：元数据服务配置信息。
		22	+
		23	+返回值
		24	+
		25	+`mmc_meta_service_t`：元数据服务句柄（成功），NULL（失败）。
19		26
20	#### mmcs_meta_service_stop	27	#### mmcs_meta_service_stop
		28	+
21	```c	29	```c
22	void mmcs_meta_service_stop(mmc_meta_service_t handle);	30	void mmcs_meta_service_stop(mmc_meta_service_t handle);
23	```	31	```
24	-功能: 停止分布式内存缓存的元数据服务。
25		32
26	-参数:	33	+功能
27	-- `handle`: 元数据服务句柄	34	+
		35	+停止分布式内存缓存的元数据服务。
		36	+
		37	+参数
		38	+
		39	+`handle`：元数据服务句柄。
28		40
29	#### mmcs_local_service_start	41	#### mmcs_local_service_start
		42	+
30	```c	43	```c
31	mmc_local_service_t mmcs_local_service_start(mmc_local_service_config_t *config);	44	mmc_local_service_t mmcs_local_service_start(mmc_local_service_config_t *config);
32	```	45	```
33	-功能: 启动分布式内存缓存的本地服务，负责本地内存对象的管理。
34	-注：如果开启device_urma协议，则`max dram * world_size`的池化总大小必须大于32T
35		46
36	-参数:	47	+功能
37	-- `config`: 本地服务配置信息
38		48
39	-返回值:	49	+启动分布式内存缓存的本地服务，负责本地内存对象的管理。
40	-- `mmc_local_service_t`: 本地服务句柄（成功），NULL（失败）	50	+
		51	+> [!NOTE] 说明
		52	+> 如果开启device_urma协议，则`max dram * world_size`的池化总大小必须大于32T。
		53	+
		54	+参数
		55	+
		56	+`config`：本地服务配置信息。
		57	+
		58	+返回值
		59	+
		60	+`mmc_local_service_t`：本地服务句柄（成功），NULL（失败）。
41		61
42	#### mmcs_local_service_stop	62	#### mmcs_local_service_stop
		63	+
43	```c	64	```c
44	void mmcs_local_service_stop(mmc_local_service_t handle);	65	void mmcs_local_service_stop(mmc_local_service_t handle);
45	```	66	```
46	-功能: 停止分布式内存缓存的本地服务。
47		67
48	-参数:	68	+功能
49	-- `handle`: 本地服务句柄	69	+
		70	+停止分布式内存缓存的本地服务。
		71	+
		72	+参数
		73	+
		74	+`handle`：本地服务句柄。
50		75
51	### 2. SDK初始化和反初始化	76	### 2. SDK初始化和反初始化
52		77
53	#### mmc_setup	78	#### mmc_setup
		79	+
54	```c	80	```c
55	int32_t mmc_setup(const local_config *config);	81	int32_t mmc_setup(const local_config *config);
56	```	82	```
57	-功能: 初始化并校验本地配置，供后续 `mmc_init` 使用。
58		83
59	-参数:	84	+功能
60	-- `config`: 本地配置（`local_config`）
61		85
62	-返回值:	86	+初始化并校验本地配置，供后续 `mmc_init` 使用。
63	-- `0`: 成功	87	+
64	-- 其他: 失败	88	+参数
		89	+
		90	+`config`：本地配置（`local_config`）。
		91	+
		92	+返回值
		93	+
		94	+- `0`：成功
		95	+- 其他：失败
65		96
66	#### mmc_init	97	#### mmc_init
		98	+
67	```c	99	```c
68	int32_t mmc_init(const mmc_init_config *config);	100	int32_t mmc_init(const mmc_init_config *config);
69	```	101	```
70	-功能: 初始化MemCache运行环境（只读客户端和可选local service）。
71		102
72	-参数:	103	+功能
73	-- `config`: 初始化参数（`mmc_init_config`）
74	- - `deviceId`: 设备ID
75	- - `initBm`: 是否初始化本地服务并提供内存（`true` 启用，`false` 只读客户端）
76		104
77	-返回值:	105	+初始化MemCache运行环境（只读客户端和可选local service）。
78	-- `0`: 成功	106	+
79	-- 其他: 失败	107	+参数
		108	+
		109	+`config`：初始化参数（`mmc_init_config`）。
		110	+
		111	+ - `deviceId`：设备ID。
		112	+ - `initBm`：是否初始化本地服务并提供内存（`true` 启用，`false` 只读客户端）。
		113	+
		114	+返回值
		115	+
		116	+- `0`：成功
		117	+- 其他：失败
80		118
81	#### mmc_uninit	119	#### mmc_uninit
		120	+
82	```c	121	```c
83	void mmc_uninit(void);	122	void mmc_uninit(void);
84	```	123	```
85	-功能: 反初始化MemCache运行环境，释放相关资源。	124	+
		125	+功能
		126	+
		127	+反初始化MemCache运行环境，释放相关资源。
86		128
87	### 3. 客户端底层初始化和反初始化（兼容接口）	129	### 3. 客户端底层初始化和反初始化（兼容接口）
88		130
89	#### mmcc_init	131	#### mmcc_init
		132	+
90	```c	133	```c
91	int32_t mmcc_init(mmc_client_config_t *config);	134	int32_t mmcc_init(mmc_client_config_t *config);
92	```	135	```
93	-功能: 初始化分布式内存缓存客户端，这是一个单例模式。
94		136
95	-参数:	137	+功能
96	-- `config`: 客户端配置信息
97		138
98	-返回值:	139	+初始化分布式内存缓存客户端，这是一个单例模式。
99	-- `0`: 成功	140	+
100	-- 其他: 失败	141	+参数
		142	+
		143	+`config`：客户端配置信息
		144	+
		145	+返回值
		146	+
		147	+- `0`：成功
		148	+- 其他：失败
101		149
102	#### mmcc_uninit	150	#### mmcc_uninit
		151	+
103	```c	152	```c
104	void mmcc_uninit(void);	153	void mmcc_uninit(void);
105	```	154	```
106	-功能: 反初始化客户端，释放相关资源。	155	+
		156	+功能
		157	+
		158	+反初始化客户端，释放相关资源。
107		159
108	### 4. 数据操作接口	160	### 4. 数据操作接口
109		161
110	#### mmcc_register_buffer	162	#### mmcc_register_buffer
		163	+
111	```c	164	```c
112	int32_t mmcc_register_buffer(uint64_t addr, uint64_t size);	165	int32_t mmcc_register_buffer(uint64_t addr, uint64_t size);
113	```	166	```
114	-功能: 将指定地址和大小的内存缓冲区注册到BM中，以加速device rdma操作。
115		167
116	-参数:	168	+功能
117	-- `addr`: 要注册的内存缓冲区地址
118	-- `size`: 要注册的内存缓冲区大小
119		169
120	-返回值:	170	+将指定地址和大小的内存缓冲区注册到BM中，以加速device rdma操作。
121	-- `0`: 成功	171	+
122	-- 其他: 失败	172	+参数
		173	+
		174	+- `addr`：要注册的内存缓冲区地址。
		175	+- `size`：要注册的内存缓冲区大小。
		176	+
		177	+返回值
		178	+
		179	+- `0`：成功
		180	+- 其他：失败
123		181
124	#### mmcc_unregister_buffer	182	#### mmcc_unregister_buffer
		183	+
125	```c	184	```c
126	int32_t mmcc_unregister_buffer(uint64_t addr, uint64_t size);	185	int32_t mmcc_unregister_buffer(uint64_t addr, uint64_t size);
127	```	186	```
128	-功能: 从BM中注销指定地址和大小的内存缓冲区。
129		187
130	-参数:	188	+功能
131	-- `addr`: 要注销的内存缓冲区地址
132	-- `size`: 要注销的内存缓冲区大小
133		189
134	-返回值:	190	+从BM中注销指定地址和大小的内存缓冲区。
135	-- `0`: 成功	191	+
136	-- 其他: 失败	192	+参数
		193	+
		194	+- `addr`：要注销的内存缓冲区地址。
		195	+- `size`：要注销的内存缓冲区大小。
		196	+
		197	+返回值
		198	+
		199	+- `0`：成功
		200	+- 其他：失败
137		201
138	#### mmcc_local_service_id	202	#### mmcc_local_service_id
		203	+
139	```c	204	```c
140	int32_t mmcc_local_service_id(uint32_t *localServiceId);	205	int32_t mmcc_local_service_id(uint32_t *localServiceId);
141	```	206	```
142	-功能: 获取本地服务的实例id。
143		207
144	-参数:	208	+功能
145	-- `localServiceId`: 本地服务的实例id
146		209
147	-返回值:	210	+获取本地服务的实例ID。
148	-- `0`: 成功	211	+
149	-- 其他: 失败	212	+参数
		213	+
		214	+`localServiceId`：本地服务的实例ID。
		215	+
		216	+返回值
		217	+
		218	+- `0`：成功
		219	+- 其他：失败
150		220
151	#### mmcc_put	221	#### mmcc_put
		222	+
152	```c	223	```c
153	int32_t mmcc_put(const char key, mmc_buffer buf, mmc_put_options options, uint32_t flags);	224	int32_t mmcc_put(const char key, mmc_buffer buf, mmc_put_options options, uint32_t flags);
154	```	225	```
155	-功能: 将指定 key 的数据放入分布式内存缓存中。
156		226
157	-参数:	227	+功能
158		228
159	-- `key`: 数据的键，长度小于256个字节	229	+将指定 key 的数据放入分布式内存缓存中。
160	-- `buf`: 要放入的数据缓冲区
161	-- `options`: 放置操作的选项
162	-- `flags`: 可选标志，保留字段
163		230
164	-返回值:	231	+参数
165	-- `0`: 成功	232	+
166	-- 其他: 失败	233	+- `key`：数据的键，长度小于256个字节。
		234	+- `buf`：要放入的数据缓冲区。
		235	+- `options`：放置操作的选项。
		236	+- `flags`：可选标志，保留字段。
		237	+
		238	+返回值
		239	+
		240	+- `0`：成功
		241	+- 其他：失败
167		242
168	#### mmcc_get	243	#### mmcc_get
		244	+
169	```c	245	```c
170	int32_t mmcc_get(const char key, mmc_buffer buf, uint32_t flags);	246	int32_t mmcc_get(const char key, mmc_buffer buf, uint32_t flags);
171	```	247	```
172	-功能: 从分布式内存缓存中获取指定 key 的数据。
173		248
174	-参数:	249	+功能
175		250
176	-- `key`: 数据的键，长度小于256个字节	251	+从分布式内存缓存中获取指定 key 的数据。
177	-- `buf`: 存储获取数据的缓冲区
178	-- `flags`: 可选标志，保留字段
179		252
180	-返回值:	253	+参数
181	-- `0`: 成功	254	+
182	-- 其他: 失败	255	+- `key`：数据的键，长度小于256个字节。
		256	+- `buf`：存储获取数据的缓冲区。
		257	+- `flags`：可选标志，保留字段。
		258	+
		259	+返回值
		260	+
		261	+- `0`：成功
		262	+- 其他：失败
183		263
184	#### mmcc_query	264	#### mmcc_query
		265	+
185	```c	266	```c
186	int32_t mmcc_query(const char key, mmc_data_info info, uint32_t flags);	267	int32_t mmcc_query(const char key, mmc_data_info info, uint32_t flags);
187	```	268	```
188	-功能: 查询分布式内存缓存中指定 key 的数据信息。
189		269
190	-参数:	270	+功能
191		271
192	-- `key`: 数据的键，长度小于256个字节	272	+查询分布式内存缓存中指定 key 的数据信息。
193	-- `info`: 存储数据信息的结构体
194	-- `flags`: 可选标志，保留字段
195		273
196	-返回值:	274	+参数
197	-- `0`: 成功	275	+
198	-- 其他: 失败	276	+- `key`：数据的键，长度小于256个字节。
		277	+- `info`：存储数据信息的结构体。
		278	+- `flags`：可选标志，保留字段。
		279	+
		280	+返回值
		281	+
		282	+- `0`：成功
		283	+- 其他：失败
199		284
200	#### mmcc_remove	285	#### mmcc_remove
		286	+
201	```c	287	```c
202	int32_t mmcc_remove(const char *key, uint32_t flags);	288	int32_t mmcc_remove(const char *key, uint32_t flags);
203	```	289	```
204	-功能: 从分布式内存缓存中删除指定 key 的对象。
205		290
206	-参数:	291	+功能
207		292
208	-- `key`: 数据的键，长度小于256个字节	293	+从分布式内存缓存中删除指定 key 的对象。
209	-- `flags`: 可选标志，保留字段
210		294
211	-返回值:	295	+参数
212	-- `0`: 成功	296	+
213	-- 其他: 失败	297	+- `key`：数据的键，长度小于256个字节。
		298	+- `flags`：可选标志，保留字段。
		299	+
		300	+返回值
		301	+
		302	+- `0`：成功
		303	+- 其他：失败
214		304
215	#### mmcc_exist	305	#### mmcc_exist
		306	+
216	```c	307	```c
217	int32_t mmcc_exist(const char *key, uint32_t flags);	308	int32_t mmcc_exist(const char *key, uint32_t flags);
218	```	309	```
219	-功能: 判断指定 key 是否存在于分布式内存缓存中。
220		310
221	-参数:	311	+功能
222		312
223	-- `key`: 数据的键，长度小于256个字节	313	+判断指定 key 是否存在于分布式内存缓存中。
224	-- `flags`: 可选标志，保留字段
225		314
226	-返回值:	315	+参数
227	-- `0`: 成功	316	+
228	-- 其他: 失败	317	+- `key`：数据的键，长度小于256个字节。
		318	+- `flags`：可选标志，保留字段。
		319	+
		320	+返回值
		321	+
		322	+- `0`：成功
		323	+- 其他：失败
229		324
230	#### mmcc_batch_query	325	#### mmcc_batch_query
		326	+
231	```c	327	```c
232	int32_t mmcc_batch_query(const char *keys, size_t keys_count, mmc_data_info info, uint32_t flags);	328	int32_t mmcc_batch_query(const char *keys, size_t keys_count, mmc_data_info info, uint32_t flags);
233	```	329	```
234	-功能: 批量查询指定 keys 的 blob 信息。
235		330
236	-参数:	331	+功能
237		332
238	-- `keys`: 数据键数组，每个键长度小于256个字节	333	+批量查询指定 keys 的 blob 信息。
239	-- `keys_count`: 键的数量
240	-- `info`: 输出的键的 Blob 信息
241	-- `flags`: 操作标志
242		334
243	-返回值:	335	+参数
244	-- `0`: 成功	336	+
245	-- 其他: 失败	337	+- `keys`：数据键数组，每个键长度小于256个字节。
		338	+- `keys_count`：键的数量。
		339	+- `info`：输出的键的 Blob 信息。
		340	+- `flags`：操作标志。
		341	+
		342	+返回值
		343	+
		344	+- `0`：成功
		345	+- 其他：失败
246		346
247	#### mmcc_batch_add_lease	347	#### mmcc_batch_add_lease
		348	+
248	```c	349	```c
249	int32_t mmcc_batch_add_lease(const char *keys, uint32_t keys_count, uint64_t lease_ttl_ms, int32_t results);	350	int32_t mmcc_batch_add_lease(const char *keys, uint32_t keys_count, uint64_t lease_ttl_ms, int32_t results);
250	```	351	```
251	-功能: 批量增加多个 key 的读租约，并记录后续 GVA 读取所需的读租约状态。
252		352
253	-参数:	353	+功能
254		354
255	-- `keys`: 数据键数组，每个键长度小于256个字节	355	+批量增加多个 key 的读租约，并记录后续 GVA 读取所需的读租约状态。
256	-- `keys_count`: 键的数量
257	-- `lease_ttl_ms`: 要增加的租约时间，单位为毫秒；为 `0` 时使用 MetaService 配置的默认租期
258	-- `results`: 每个增加租约操作的结果，`0` 表示成功，其他值表示失败
259		356
260	-返回值:	357	+参数
261	-- `0`: 调用成功，逐 key 结果见 `results`	358	+
262	-- 其他: 失败	359	+- `keys`：数据键数组，每个键长度小于256个字节。
		360	+- `keys_count`：键的数量。
		361	+- `lease_ttl_ms`：要增加的租约时间，单位为毫秒；为 `0` 时使用 MetaService 配置的默认租期。
		362	+- `results`：每个增加租约操作的结果，`0` 表示成功，其他值表示失败。
		363	+
		364	+返回值
		365	+
		366	+- `0`：调用成功，逐 key 结果见 `results`。
		367	+- 其他：失败。
263		368
264	#### mmcc_batch_remove_lease	369	#### mmcc_batch_remove_lease
		370	+
265	```c	371	```c
266	int32_t mmcc_batch_remove_lease(const char **keys, uint32_t keys_count);	372	int32_t mmcc_batch_remove_lease(const char **keys, uint32_t keys_count);
267	```	373	```
268	-功能: 批量移除多个 key 的读租约，并清理当前进程中对应的 GVA 读取状态。
269		374
270	-参数:	375	+功能
271		376
272	-- `keys`: 数据键数组，每个键长度小于256个字节	377	+批量移除多个 key 的读租约，并清理当前进程中对应的 GVA 读取状态。
273	-- `keys_count`: 键的数量
274		378
275	-返回值:	379	+参数
276	-- `0`: 本地读租约检查通过并已触发移除租约请求发送流程	380	+
277	-- 其他: 失败	381	+- `keys`：数据键数组，每个键长度小于256个字节。
		382	+- `keys_count`：键的数量。
		383	+
		384	+返回值
		385	+
		386	+- `0`：本地读租约检查通过并已触发移除租约请求发送流程。
		387	+- 其他：失败。
278		388
279	#### mmcc_batch_malloc	389	#### mmcc_batch_malloc
		390	+
280	```c	391	```c
281	int32_t mmcc_batch_malloc(const char *keys, uint32_t keys_count, const size_t sizes,	392	int32_t mmcc_batch_malloc(const char *keys, uint32_t keys_count, const size_t sizes,
282	mmc_put_options options, uint64_t lease_ttl_ms, uint64_t *gvas);	393	mmc_put_options options, uint64_t lease_ttl_ms, uint64_t *gvas);
283	```	394	```
284	-功能: 批量为多个 key 申请 GVA blob，并返回每个 key 对应的 GVA 起始地址。
285		395
286	-参数:	396	+功能
287		397
288	-- `keys`: 数据键数组，每个键长度小于256个字节	398	+批量为多个 key 申请 GVA blob，并返回每个 key 对应的 GVA 起始地址。
289	-- `keys_count`: 键的数量
290	-- `sizes`: 每个 key 对应的 GVA blob 大小
291	-- `options`: 申请 GVA blob 的选项
292	-- `lease_ttl_ms`: 要增加的租约时间，单位为毫秒；为 `0` 时使用 MetaService 配置的默认租期
293	-- `gvas`: 输出的 GVA 起始地址数组；对应 key 申请失败时该元素为 `0`
294		399
295	-返回值:	400	+参数
296	-- `0`: 成功	401	+
297	-- 其他: 失败	402	+- `keys`：数据键数组，每个键长度小于256个字节。
		403	+- `keys_count`：键的数量。
		404	+- `sizes`：每个 key 对应的 GVA blob 大小。
		405	+- `options`：申请 GVA blob 的选项。
		406	+- `lease_ttl_ms`：要增加的租约时间，单位为毫秒；为 `0` 时使用 MetaService 配置的默认租期。
		407	+- `gvas`：输出的 GVA 起始地址数组；对应 key 申请失败时该元素为 `0`。
		408	+
		409	+返回值
		410	+
		411	+- `0`：成功
		412	+- 其他：失败
298		413
299	#### mmcc_batch_copy	414	#### mmcc_batch_copy
		415	+
300	```c	416	```c
301	int32_t mmcc_batch_copy(const uint64_t gvas, void buffers, const size_t sizes,	417	int32_t mmcc_batch_copy(const uint64_t gvas, void buffers, const size_t sizes,
302	uint32_t count, int32_t direct);	418	uint32_t count, int32_t direct);
303	```	419	```
304	-功能: 批量在 GVA 地址和本地 buffer 之间进行数据拷贝。注意：写方向（如 `SMEMB_COPY_L2G`/`SMEMB_COPY_H2G`）只拷贝数据，不会将 GVA 对应的 blob 状态翻转为 READABLE；调用方必须再调用 `mmcc_batch_write_finish` 显式通知写完成。
305		420
306	-参数:	421	+功能
307		422
308	-- `gvas`: GVA 起始地址数组	423	+批量在 GVA 地址和本地 buffer 之间进行数据拷贝。
309	-- `buffers`: 本地 buffer 地址数组
310	-- `sizes`: 每段 GVA 地址要拷贝的数据大小
311	-- `count`: GVA 地址段数量
312	-- `direct`: 数据拷贝方向
313		424
314	-返回值:	425	+> [!NOTE] 注意
315	-- `0`: 成功	426	+> 写方向（如 `SMEMB_COPY_L2G`/`SMEMB_COPY_H2G`）只拷贝数据，不会将 GVA 对应的 blob 状态翻转为 READABLE；调用方必须再调用 `mmcc_batch_write_finish` 显式通知写完成。
316	-- 其他: 失败	427	+
		428	+参数
		429	+
		430	+- `gvas`：GVA 起始地址数组。
		431	+- `buffers`：本地 buffer 地址数组。
		432	+- `sizes`：每段 GVA 地址要拷贝的数据大小。
		433	+- `count`：GVA 地址段数量。
		434	+- `direct`：数据拷贝方向。
		435	+
		436	+返回值
		437	+
		438	+- `0`：成功
		439	+- 其他：失败
317		440
318	#### mmcc_batch_write_finish	441	#### mmcc_batch_write_finish
		442	+
319	```c	443	```c
320	int32_t mmcc_batch_write_finish(const char **keys, uint32_t keys_count,	444	int32_t mmcc_batch_write_finish(const char **keys, uint32_t keys_count,
321	const int32_t writeResults, int32_t outResults);	445	const int32_t writeResults, int32_t outResults);
322	```	446	```
323	-功能: 显式通知 meta service 给定 key 的写入已完成。调用方在 `mmcc_batch_copy` 写方向完成后必须调用此接口，meta service 才会将对应 blob 从 `ALLOCATED` 翻转为 `READABLE`，此后其他进程才能通过 `mmcc_query` / `mmcc_batch_copy` 读方向读到数据。对于已处于 `READABLE` 的 key，再次调用为幂等并直接返回成功；对未分配过的 key 返回 `MMC_UNMATCHED_KEY`。	447	+
		448	+功能
		449	+
		450	+显式通知 meta service 给定 key 的写入已完成。
		451	+
		452	+> [!NOTE] 说明
		453	+>
		454	+> - 调用方在 `mmcc_batch_copy` 写方向完成后必须调用此接口，meta service 才会将对应 blob 从 `ALLOCATED` 翻转为 `READABLE`，此后其他进程才能通过 `mmcc_query` / `mmcc_batch_copy` 读方向读到数据。
		455	+> - 对于已处于 `READABLE` 的 key，再次调用为幂等并直接返回成功。
		456	+> - 对未分配过的 key 返回 `MMC_UNMATCHED_KEY`。
324		457
325	参数:	458	参数:
326		459
327	-- `keys`: 已写入完成的键列表，每个键长度小于 256 个字节	460	+- `keys`：已写入完成的键列表，每个键长度小于 256 个字节。
328	-- `keys_count`: 键的数量	461	+- `keys_count`：键的数量。
329	-- `writeResults`: 与 `keys` 等长的每键写入结果，`0` 表示成功（对应 `MMC_WRITE_OK`，blob 翻为 `READABLE`），非 `0` 表示失败（对应 `MMC_WRITE_FAIL`，meta service 会移除该 blob）	462	+- `writeResults`：与 `keys` 等长的每键写入结果，`0` 表示成功（对应 `MMC_WRITE_OK`，blob 翻为 `READABLE`），非 `0` 表示失败（对应 `MMC_WRITE_FAIL`，meta service 会移除该 blob）。
330	-- `outResults`: 与 `keys` 等长的输出数组，每个元素为 meta service 对该键的实际更新结果	463	+- `outResults`：与 `keys` 等长的输出数组，每个元素为 meta service 对该键的实际更新结果。
331		464
332	-返回值:	465	+返回值
333	-- `0`: 批量 RPC 调用本身成功	466	+
334	-- 其他: RPC 调用失败（此时 `outResults` 中对应位置为错误码）	467	+- `0`：批量 RPC 调用本身成功。
		468	+- 其他：RPC 调用失败（此时 `outResults` 中对应位置为错误码）。
335		469
336	#### mmcc_batch_remove	470	#### mmcc_batch_remove
		471	+
337	```c	472	```c
338	int32_t mmcc_batch_remove(const char *keys, uint32_t keys_count, int32_t remove_results, uint32_t flags);	473	int32_t mmcc_batch_remove(const char *keys, uint32_t keys_count, int32_t remove_results, uint32_t flags);
339	```	474	```
340	-功能: 从 BM 中批量删除多个键。
341		475
342	-参数:	476	+功能
343	-- `keys`: 要从 BM 中删除的键列表，每个键长度小于256个字节
344	-- `keys_count`: 键的数量
345	-- `remove_results`: 每个删除操作的结果
346	-- `flags`: 操作标志
347		477
348	-返回值:	478	+从 BM 中批量删除多个键。
349	-- `0`: 成功	479	+
350	-- 其他: 失败	480	+参数
		481	+
		482	+- `keys`：要从 BM 中删除的键列表，每个键长度小于256个字节。
		483	+- `keys_count`：键的数量。
		484	+- `remove_results`：每个删除操作的结果。
		485	+- `flags`：操作标志。
		486	+
		487	+返回值
		488	+
		489	+- `0`：成功
		490	+- 其他：失败
351		491
352	#### mmcc_batch_exist	492	#### mmcc_batch_exist
		493	+
353	```c	494	```c
354	int32_t mmcc_batch_exist(const char *keys, uint32_t keys_count, int32_t exist_results, uint32_t flags);	495	int32_t mmcc_batch_exist(const char *keys, uint32_t keys_count, int32_t exist_results, uint32_t flags);
355	```	496	```
356	-功能: 判断多个键是否存在于 BM 中。
357		497
358	-参数:	498	+功能
359		499
360	-- `keys`: 数据键数组，每个键长度小于256个字节	500	+判断多个键是否存在于 BM 中。
361	-- `keys_count`: 键的数量
362	-- `exist_results`: BM 中键的存在状态列表
363	-- `flags`: 可选标志，保留字段
364		501
365	-返回值:	502	+参数
366	-- `0`: 成功	503	+
367	-- 其他: 失败	504	+- `keys`：数据键数组，每个键长度小于256个字节。
		505	+- `keys_count`：键的数量。
		506	+- `exist_results`：BM 中键的存在状态列表。
		507	+- `flags`：可选标志，保留字段。
		508	+
		509	+返回值
		510	+
		511	+- `0`：成功
		512	+- 其他：失败
368		513
369	#### mmcc_batch_put	514	#### mmcc_batch_put
		515	+
370	```c	516	```c
371	int32_t mmcc_batch_put(const char *keys, uint32_t keys_count, const mmc_buffer bufs,	517	int32_t mmcc_batch_put(const char *keys, uint32_t keys_count, const mmc_buffer bufs,
372	mmc_put_options& options, uint32_t flags, int *results);	518	mmc_put_options& options, uint32_t flags, int *results);
373	```	519	```
374	-功能: 批量将多个数据对象放入分布式内存缓存中。
375		520
376	-参数:	521	+功能
377	-- `keys`: 数据对象的键数组，每个键长度小于256个字节
378	-- `keys_count`: 数组中键的数量
379	-- `bufs`: 要放入的数据缓冲区数组
380	-- `options`: 批量放置操作的选项
381	-- `flags`: 可选标志，保留字段
382	-- `results`: 每个放置操作的结果
383		522
384	-返回值:	523	+批量将多个数据对象放入分布式内存缓存中。
385	-- `0`: 成功	524	+
386	-- 其他: 失败	525	+参数
		526	+
		527	+- `keys`：数据对象的键数组，每个键长度小于256个字节。
		528	+- `keys_count`：数组中键的数量。
		529	+- `bufs`：要放入的数据缓冲区数组。
		530	+- `options`：批量放置操作的选项。
		531	+- `flags`：可选标志，保留字段。
		532	+- `results`：每个放置操作的结果。
		533	+
		534	+返回值
		535	+
		536	+- `0`：成功
		537	+- 其他：失败
387		538
388	#### mmcc_batch_get	539	#### mmcc_batch_get
		540	+
389	```c	541	```c
390	int32_t mmcc_batch_get(const char *keys, uint32_t keys_count, mmc_buffer bufs, uint32_t flags, int *results);	542	int32_t mmcc_batch_get(const char *keys, uint32_t keys_count, mmc_buffer bufs, uint32_t flags, int *results);
391	```	543	```
392	-功能: 批量从分布式内存缓存中获取多个数据对象。
393		544
394	-参数:	545	+功能
395	-- `keys`: 数据对象的键数组，每个键长度小于256个字节
396	-- `keys_count`: 数组中键的数量
397	-- `bufs`: 存储检索数据的数据缓冲区数组
398	-- `flags`: 可选标志，保留字段
399	-- `results`: 每个获取操作的结果
400		546
401	-返回值:	547	+批量从分布式内存缓存中获取多个数据对象。
402	-- `0`: 成功	548	+
403	-- 其他: 失败	549	+参数
		550	+
		551	+- `keys`：数据对象的键数组，每个键长度小于256个字节。
		552	+- `keys_count`：数组中键的数量。
		553	+- `bufs`：存储检索数据的数据缓冲区数组。
		554	+- `flags`：可选标志，保留字段。
		555	+- `results`：每个获取操作的结果。
		556	+
		557	+返回值
		558	+
		559	+- `0`：成功
		560	+- 其他：失败
404		561
405	### 5. 日志设置接口	562	### 5. 日志设置接口
406		563
407	#### mmc_set_extern_logger	564	#### mmc_set_extern_logger
		565	+
408	```c	566	```c
409	int32_t mmc_set_extern_logger(void (func)(int level, const char msg));	567	int32_t mmc_set_extern_logger(void (func)(int level, const char msg));
410	```	568	```
411	-功能: 设置外部日志函数，用户可以设置自定义的日志记录函数。在自定义的日志记录函数中，用户可以使用统一的日志工具，这样日志消息就可以写入与调用者相同的日志文件中。如果未设置，日志消息将被打印到标准输出。	569	+
		570	+功能
		571	+
		572	+设置外部日志函数，用户可以设置自定义的日志记录函数。在自定义的日志记录函数中，用户可以使用统一的日志工具，这样日志消息就可以写入与调用者相同的日志文件中。如果未设置，日志消息将被打印到标准输出。
412		573
413	日志级别说明：	574	日志级别说明：
414	-- `0`: DEBUG
415	-- `1`: INFO
416	-- `2`: WARN
417	-- `3`: ERROR
418		575
419	-参数:	576	+- `0`：DEBUG
420	-- `func`: 外部日志记录函数	577	+- `1`：INFO
		578	+- `2`：WARN
		579	+- `3`：ERROR
421		580
422	-返回值:	581	+参数
423	-- `0`: 成功	582	+
424	-- 其他: 失败	583	+`func`：外部日志记录函数。
		584	+
		585	+返回值
		586	+
		587	+- `0`：成功
		588	+- 其他：失败
425		589
426	#### mmc_set_log_level	590	#### mmc_set_log_level
		591	+
427	```c	592	```c
428	int32_t mmc_set_log_level(int level);	593	int32_t mmc_set_log_level(int level);
429	```	594	```
430	-功能: 设置日志打印级别。
431		595
432	-参数:	596	+功能
433	-- `level`: 日志级别，0:debug 1:info 2:warn 3:error
434		597
435	-返回值:	598	+设置日志打印级别。
436	-- `0`: 成功	599	+
437	-- 其他: 失败	600	+参数
		601	+
		602	+`level`：日志级别。
		603	+
		604	+- 0：debug
		605	+- 1：info
		606	+- 2：warn
		607	+- 3：error
		608	+
		609	+返回值
		610	+
		611	+- `0`：成功
		612	+- 其他：失败
438		613
439	### smem_bm_copy_type 枚举类型	614	### smem_bm_copy_type 枚举类型
440		615
441	用于指定数据拷贝方向的枚举类型：	616	用于指定数据拷贝方向的枚举类型：
442	-- `SMEMB_COPY_L2G` (0): 从卡上内存到全局内存	617	+
443	-- `SMEMB_COPY_G2L` (1): 从全局内存到卡上内存	618	+- `SMEMB_COPY_L2G` (0)：从卡上内存到全局内存。
444	-- `SMEMB_COPY_G2H` (2): 从全局内存到主机内存	619	+- `SMEMB_COPY_G2L` (1)：从全局内存到卡上内存。
445	-- `SMEMB_COPY_H2G` (3): 从主机内存到全局内存	620	+- `SMEMB_COPY_G2H` (2)：从全局内存到主机内存。
446	-- `SMEMB_COPY_L2GH` (4): 从卡上内存到全局主机内存	621	+- `SMEMB_COPY_H2G` (3)：从主机内存到全局内存。
447	-- `SMEMB_COPY_GH2L` (5): 从全局主机内存到卡上内存	622	+- `SMEMB_COPY_L2GH` (4)：从卡上内存到全局主机内存。
448	-- `SMEMB_COPY_GH2H` (6): 从全局主机内存到主机内存	623	+- `SMEMB_COPY_GH2L` (5)：从全局主机内存到卡上内存。
449	-- `SMEMB_COPY_H2GH` (7): 从主机内存到全局主机内存	624	+- `SMEMB_COPY_GH2H` (6)：从全局主机内存到主机内存。
450	-- `SMEMB_COPY_G2G` (8): 从全局内存到全局内存	625	+- `SMEMB_COPY_H2GH` (7)：从主机内存到全局主机内存。
451	-- `SMEMB_COPY_AUTO` (9): 自动选择数据拷贝方向	626	+- `SMEMB_COPY_G2G` (8)：从全局内存到全局内存。
		627	+- `SMEMB_COPY_AUTO` (9)：自动选择数据拷贝方向。
452		628
453	## 数据结构	629	## 数据结构
454		630
455	### mmc_client_config_t	631	### mmc_client_config_t
		632	+
456	客户端配置结构体，包含以下字段：	633	客户端配置结构体，包含以下字段：
457	-- `discoveryURL`: 发现服务URL	634	+
458	-- `rankId`: Rank ID	635	+- `discoveryURL`：发现服务URL。
459	-- `rpcRetryTimeOut`: rpc重试超时时间	636	+- `rankId`：Rank ID。
460	-- `timeOut`: 超时时间	637	+- `rpcRetryTimeOut`：rpc重试超时时间。
461	-- `readThreadPoolNum`: 读线程池线程数	638	+- `timeOut`：超时时间。
462	-- `aggregateIO`: 是否聚合IO，默认false	639	+- `readThreadPoolNum`：读线程池线程数。
463	-- `writeThreadPoolNum`: 写线程池线程数	640	+- `aggregateIO`：是否聚合IO，默认false。
464	-- `logLevel`: 日志级别	641	+- `writeThreadPoolNum`：写线程池线程数。
465	-- `logFunc`: 外部日志函数	642	+- `logLevel`：日志级别。
466	-- `tlsConfig`: TLS配置	643	+- `logFunc`：外部日志函数。
		644	+- `tlsConfig`：TLS配置。
467		645
468	### ReplicateConfig	646	### ReplicateConfig
		647	+
469	客户端配置结构体，包含以下字段：	648	客户端配置结构体，包含以下字段：
470	-- `replicaNum`: 副本数，最大为8，默认为1	649	+
471	-- `preferredLocalServiceIDs`: 强制分配的实例id列表，列表大小必须小于或等于replicaNum	650	+- `replicaNum`：副本数，最大为8，默认为1。
		651	+- `preferredLocalServiceIDs`：强制分配的实例id列表，列表大小必须小于或等于replicaNum。
472		652
473	### mmc_meta_service_config_t	653	### mmc_meta_service_config_t
		654	+
474	元数据服务配置结构体，包含以下字段：	655	元数据服务配置结构体，包含以下字段：
475	-- `discoveryURL`: 发现服务URL	656	+
476	-- `configStoreURL`: config store URL	657	+- `discoveryURL`：发现服务URL。
477	-- `httpURL`: http服务URL	658	+- `configStoreURL`：config store URL。
478	-- `haEnable`: 是否使能高可用	659	+- `httpURL`：http服务URL。
479	-- `logLevel`: 日志级别	660	+- `haEnable`：是否使能高可用。
480	-- `logPath`: 日志文件保存路径	661	+- `logLevel`：日志级别。
481	-- `logRotationFileSize`: 轮转日志文件大小	662	+- `logPath`：日志文件保存路径。
482	-- `logRotationFileCount`: 轮转日志文件个数	663	+- `logRotationFileSize`：轮转日志文件大小。
483	-- `evictThresholdHigh`: 高水位驱逐阈值	664	+- `logRotationFileCount`：轮转日志文件个数。
484	-- `evictThresholdLow`: 低水位驱逐阈值	665	+- `evictThresholdHigh`：高水位驱逐阈值。
485	-- `accTlsConfig`: 元数据服务TLS配置	666	+- `evictThresholdLow`：低水位驱逐阈值。
486	-- `configStoreTlsConfig`: config store的TLS配置	667	+- `accTlsConfig`：元数据服务TLS配置。
487	-- `metricsTlsConfig`: metrics HTTP 服务的 mTLS 配置	668	+- `configStoreTlsConfig`：config store的TLS配置。
		669	+- `metricsTlsConfig`：metrics HTTP 服务的 mTLS 配置。
488		670
489	### mmc_local_service_config_t	671	### mmc_local_service_config_t
		672	+
490	本地服务配置结构体，包含以下字段：	673	本地服务配置结构体，包含以下字段：
491	-- `discoveryURL`: 发现服务URL	674	+
492	-- `deviceId`: 设备ID	675	+- `discoveryURL`：发现服务URL。
493	-- `rankId`: BM全局统一编号	676	+- `deviceId`：设备ID。
494	-- `worldSize`: 本地服务的总数	677	+- `rankId`：BM全局统一编号。
495	-- `bmIpPort`: BM IP端口	678	+- `worldSize`：本地服务的总数。
496	-- `bmHcomUrl`: BM HCOM URL	679	+- `bmIpPort`：BM IP端口。
497	-- `createId`: 创建ID	680	+- `bmHcomUrl`：BM HCOM URL。
498	-- `dataOpType`: 数据操作类型	681	+- `createId`：创建ID。
499	-- `localDRAMSize`: 本地DRAM大小	682	+- `dataOpType`：数据操作类型。
500	-- `localHBMSize`: 本地HBM大小	683	+- `localDRAMSize`：本地DRAM大小。
501	-- `flags`: 标志	684	+- `localHBMSize`：本地HBM大小。
502	-- `accTlsConfig`: 本地服务的TLS配置	685	+- `flags`：标志。
503	-- `logLevel`: 日志级别	686	+- `accTlsConfig`：本地服务的TLS配置。
504	-- `logFunc`: 外部日志函数	687	+- `logLevel`：日志级别。
505	-- `hcomTlsConfig`: 本地服务的TLS配置	688	+- `logFunc`：外部日志函数。
506	-- `configStoreTlsConfig`: config store的TLS配置	689	+- `hcomTlsConfig`：本地服务的TLS配置。
		690	+- `configStoreTlsConfig`：config store的TLS配置。
507		691
508	### mmc_buffer	692	### mmc_buffer
		693	+
509	内存缓冲区结构体，包含内存地址、类型和长度信息。	694	内存缓冲区结构体，包含内存地址、类型和长度信息。
510	-- `addr`: 内存地址	695	+
511	-- `type`: 介质类型，参考MediaType	696	+- `addr`：内存地址。
512	-- `offset`: 偏移	697	+- `type`：介质类型，参考MediaType。
513	-- `len`: 缓冲区长度	698	+- `offset`：偏移。
		699	+- `len`：缓冲区长度。
514		700
515	### mmc_put_options	701	### mmc_put_options
		702	+
516	放置操作选项，包含介质类型和亲和策略。	703	放置操作选项，包含介质类型和亲和策略。
517	-- `mediaType`: 介质类型	704	+
518	-- `policy`: 亲和策略	705	+- `mediaType`：介质类型。
519	-- `replicaNum`: 副本数，最大支持8副本	706	+- `policy`：亲和策略。
520	-- `preferredLocalServiceIDs`: 优先本地服务ID	707	+- `replicaNum`：副本数，最大支持8副本。
		708	+- `preferredLocalServiceIDs`：优先本地服务ID。
521		709
522	### mmc_data_info	710	### mmc_data_info
		711	+
523	数据信息结构体，包含大小、保护标志、blob数量和有效性标志。	712	数据信息结构体，包含大小、保护标志、blob数量和有效性标志。
524	-- `size`: 数据大小	713	+
525	-- `prot`: 保护标志	714	+- `size`：数据大小。
526	-- `numBlobs`: blob数量	715	+- `prot`：保护标志。
527	-- `valid`: 有效性标志	716	+- `numBlobs`：blob数量。
528	-- `ranks`: 各blob所在设备列表	717	+- `valid`：有效性标志。
529	-- `types`: 各blob所在介质类型	718	+- `ranks`：各blob所在设备列表。
		719	+- `types`：各blob所在介质类型。
530		720
531	### mmc_tls_config	721	### mmc_tls_config
		722	+
532	TLS配置结构体，包含以下字段：	723	TLS配置结构体，包含以下字段：
533	-- `tlsEnable`: TLS启用标志	724	+
534	-- `caPath`: 根证书文件路径	725	+- `tlsEnable`：TLS启用标志。
535	-- `crlPath`: 证书吊销列表文件路径	726	+- `caPath`：根证书文件路径。
536	-- `certPath`: 证书文件路径	727	+- `crlPath`：证书吊销列表文件路径。
537	-- `keyPath`: 私钥文件路径	728	+- `certPath`：证书文件路径。
538	-- `keyPassPath`: 私钥加密密码（口令）文件路径	729	+- `keyPath`：私钥文件路径。
539	-- `packagePath`: openssl动态库路径	730	+- `keyPassPath`：私钥加密密码（口令）文件路径。
540	-- `decrypterLibPath`: 自定义口令解密算法动态库路径	731	+- `packagePath`：openssl动态库路径。
		732	+- `decrypterLibPath`：自定义口令解密算法动态库路径。
541		733
542	## 错误码	734	## 错误码
543		735
	@@ -572,6 +764,6 @@ TLS配置结构体，包含以下字段：
572		764
573	## 注意事项	765	## 注意事项
574		766
575	-- 推荐调用顺序：`mmc_setup` -> `mmc_init` -> 数据读写接口 -> `mmc_uninit`	767	+- 推荐调用顺序：`mmc_setup` -> `mmc_init` -> 数据读写接口 -> `mmc_uninit`。
576	-- 所有键的长度必须小于256个字节	768	+- 所有键的长度必须小于256个字节。
577	-- 批量操作可以提高处理效率	769	+- 批量操作可以提高处理效率。

Rdoc/memcache_config.md→docs/memcache_config.md+5-5

Rdoc/memcache_python_api.md→docs/memcache_python_api.md+1200-1111

Rdoc/memcache_restful_api.md→docs/memcache_restful_api.md+177-153

Rdoc/memcache_ssd_usage.md→docs/memcache_ssd_usage.md+3-2

Rdoc/source/memcache_a2.png→docs/source/memcache_a2.png+0-0

Rdoc/source/memcache_a3.png→docs/source/memcache_a3.png+0-0

Rdoc/source/memcache_architecture.png→docs/source/memcache_architecture.png+0-0

Rdoc/source/memcache_icon.png→docs/source/memcache_icon.png+0-0

Rdoc/source/memcache_metaservice_ha.png→docs/source/memcache_metaservice_ha.png+0-0

Rdoc/source/memcache_rh2d.png→docs/source/memcache_rh2d.png+0-0

Mexample/benchmark/README.md+8-4

Mexample/cpp/README.md+3-1

Mexample/examples.md+4-2

Mexample/python/README.md+7-2

Mpre-commit/README.md+3-1

Mscript/README.md+16-8

	@@ -1,12 +1,12 @@
1	-## MemCache Configs	1	+# MemCache Configs
2		2
3	-#### MetaService Config	3	+## MetaService Config
4		4
5	\| key \| value type \| requirement \| default \| valid range \| description \|	5	\| key \| value type \| requirement \| default \| valid range \| description \|
6	\|------------------------------------------------------\|------------\|-------------\|--------------------------\|----------------------------\|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------\|	6	\|------------------------------------------------------\|------------\|-------------\|--------------------------\|----------------------------\|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------\|
7	\| ock.mmc.meta_service_url \| string \| optional \| tcp://127.0.0.1:5000 \| tcp://\<host>\<port> \| host supports ip and domain, port in [1025, 65535] \|	7	\| ock.mmc.meta_service_url \| string \| optional \| tcp://127.0.0.1:5000 \| tcp://\<host>\<port> \| host supports ip and domain, port in [1025, 65535] \|
8	\| ock.mmc.meta_service.config_store_url \| string \| optional \| tcp://127.0.0.1:6000 \| tcp://\<host>\<port> \| host supports ip and domain, port in [1025, 65535] \|	8	\| ock.mmc.meta_service.config_store_url \| string \| optional \| tcp://127.0.0.1:6000 \| tcp://\<host>\<port> \| host supports ip and domain, port in [1025, 65535] \|
9	-\| ock.mmc.meta_service.metrics_url \| string \| optional \| http://127.0.0.1:8000 \| <protocol>://<host>:<port> \| protocol is http or https, host supports ip and domain, port in [1025, 65535] \|	9	+\| ock.mmc.meta_service.metrics_url \| string \| optional \| http://127.0.0.1:8000 \| \<protocol>://\<host>:\<port>\| protocol is http or https, host supports ip and domain, port in [1025, 65535] \|
10	\| ock.mmc.meta.ha.enable \| bool \| optional \| false \| true/false \| enable meta service master/backup HA in k8s cluster \|	10	\| ock.mmc.meta.ha.enable \| bool \| optional \| false \| true/false \| enable meta service master/backup HA in k8s cluster \|
11	\| ock.mmc.meta.backup.enable \| bool \| optional \| false \| true/false \| enable meta service backup \|	11	\| ock.mmc.meta.backup.enable \| bool \| optional \| false \| true/false \| enable meta service backup \|
12	\| ock.mmc.meta_service.metrics_report_interval_seconds \| integer \| optional \| 30 \| [0, 86400] \| metrics summary printing interval in seconds, 0 disables periodic metrics printing \|	12	\| ock.mmc.meta_service.metrics_report_interval_seconds \| integer \| optional \| 30 \| [0, 86400] \| metrics summary printing interval in seconds, 0 disables periodic metrics printing \|
	@@ -48,7 +48,7 @@
48	\| ock.mmc.metrics.tls.package.path \| string \| optional \| \| 0 <= len < 256 \| openssl dynamic libraries path for metrics HTTP \|	48	\| ock.mmc.metrics.tls.package.path \| string \| optional \| \| 0 <= len < 256 \| openssl dynamic libraries path for metrics HTTP \|
49	\| ock.mmc.metrics.tls.decrypter.path \| string \| optional \| \| 0 <= len < 256 \| the keypass decrypter library path for metrics HTTP (leave empty if the password is not encrypted) \|	49	\| ock.mmc.metrics.tls.decrypter.path \| string \| optional \| \| 0 <= len < 256 \| the keypass decrypter library path for metrics HTTP (leave empty if the password is not encrypted) \|
50		50
51	-#### LocalService Config	51	+## LocalService Config
52		52
53	\| key \| value type \| requirement \| default \| valid range \| description \|	53	\| key \| value type \| requirement \| default \| valid range \| description \|
54	\|------------------------------------------------\|------------\|--------------\|----------------------\|---------------------------------------------------------------------------------------\|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\|	54	\|------------------------------------------------\|------------\|--------------\|----------------------\|---------------------------------------------------------------------------------------\|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\|
	@@ -107,7 +107,7 @@
107	\| ock.mmc.dynamic_config.enable \| bool \| optional \| false \| true/false \| Enable dynamic config polling. When enabled, LocalService periodically checks the config file for `meta_service_url` and `config_store_url` changes and lazily updates reconnection targets without restart \|	107	\| ock.mmc.dynamic_config.enable \| bool \| optional \| false \| true/false \| Enable dynamic config polling. When enabled, LocalService periodically checks the config file for `meta_service_url` and `config_store_url` changes and lazily updates reconnection targets without restart \|
108	\| ock.mmc.dynamic_config.interval \| integer \| optional \| 5 \| [1, 300] \| Polling interval in seconds for dynamic config file check \|	108	\| ock.mmc.dynamic_config.interval \| integer \| optional \| 5 \| [1, 300] \| Polling interval in seconds for dynamic config file check \|
109		109
110	-#### KV Events Config	110	+## KV Events Config
111		111
112	\| key \| value type \| requirement \| default \| valid range \| description \|	112	\| key \| value type \| requirement \| default \| valid range \| description \|
113	\|----------------------------------\|------------\|-------------\|---------\|----------------------\|---------------------------------------------------------------------------\|	113	\|----------------------------------\|------------\|-------------\|---------\|----------------------\|---------------------------------------------------------------------------\|