【PR】: 为 ACL Runtime API 补齐 C++ 模板封装和函数重载接口-runtime-AtomGit

已合并

【PR】: 为 ACL Runtime API 补齐 C++ 模板封装和函数重载接口 #1981

ykl999创建于 5月8日从ykl999/runtime_6612： feat/aclrt-cxx-v2 合入到 cann/runtime： master

【PR】: 为 ACL Runtime API 补齐 C++ 模板封装和函数重载接口 #1981

已合并

ykl999创建于 5月8日

从ykl999/runtime_6612 feat/aclrt-cxx-v2合入到cann/runtime master

共 6 个文件变更+1474-0

Mdocs/03_api_ref/01_概述.md+1-0

	@@ -37,6 +37,7 @@ acl接口的头文件在“${INSTALL_DIR}/include/”目录下，库文件在“
37	\| 定义接口的头文件 \| 用途 \| 对应的库文件 \|	37	\| 定义接口的头文件 \| 用途 \| 对应的库文件 \|
38	\| --- \| --- \| --- \|	38	\| --- \| --- \| --- \|
39	\| acl/acl_rt.h \| 用于定义初始化/去初始化、Device管理、Context管理、Stream管理、同步等待、内存管理等接口。 \| libacl_rt.so<br>说明：为了兼容旧版本，旧版本中支持使用libascendcl.so，但后续版本这种方式会废弃，建议使用libacl_rt.so，防止后续版本出现兼容性问题。 \|	39	\| acl/acl_rt.h \| 用于定义初始化/去初始化、Device管理、Context管理、Stream管理、同步等待、内存管理等接口。 \| libacl_rt.so<br>说明：为了兼容旧版本，旧版本中支持使用libascendcl.so，但后续版本这种方式会废弃，建议使用libacl_rt.so，防止后续版本出现兼容性问题。 \|
		40	+\| acl/acl_rt_api.h \| 用于定义 C++ 扩展接口，提供函数重载和模板封装（仅适用于 C++ 程序）。依赖 acl_rt.h。 \| libacl_rt.so \|
40	\| acl/acl_dump.h \| 用于定义模型和算子Dump接口。 \| libascend_dump.so \|	41	\| acl/acl_dump.h \| 用于定义模型和算子Dump接口。 \| libascend_dump.so \|
41	\| acl/acl_prof.h \| 用于定义Profiling数据采集接口。 \| libmsprofiler.so<br>说明：为了兼容旧版本，旧版本中支持使用libascendcl.so，但后续版本这种方式会废弃，建议使用libmsprofiler.so，防止后续版本出现兼容性问题。 \|	42	\| acl/acl_prof.h \| 用于定义Profiling数据采集接口。 \| libmsprofiler.so<br>说明：为了兼容旧版本，旧版本中支持使用libascendcl.so，但后续版本这种方式会废弃，建议使用libmsprofiler.so，防止后续版本出现兼容性问题。 \|
42	\| acl/acl_tdt.h \| 用于定义Tensor数据传输接口。 \| libacl_tdt_channel.so \|	43	\| acl/acl_tdt.h \| 用于定义Tensor数据传输接口。 \| libacl_tdt_channel.so \|

Adocs/03_api_ref/26_C++ API Routines.md+1019-0

@@ -0,0 +1,1019 @@
	1	+# 26. C++ API Routines
	2	+
	3	+本章节描述 C++ 扩展接口，包括函数重载和模板封装，用于简化 C++ 场景下的 API 调用并提供类型安全的内存操作。
	4	+
	5	+> 说明：
	6	+> - 本章节接口仅适用于 C++ 程序，需在编译时启用 `__cplusplus` 宏。
	7	+> - 头文件：`include/external/acl/acl_rt_api.h`
	8	+> - 本章节接口是对 `acl_rt.h` 纯 C API 的 C++ 封装，内部调用底层 C API。
	9	+
	10	+## 函数重载
	11	+
	12	+- [`aclError aclrtSynchronizeDevice(int32_t timeout)`](#aclrtSynchronizeDevice)：设备同步，简化接口。
	13	+- [`aclError aclrtSynchronizeStream(aclrtStream stream, int32_t timeout)`](#aclrtSynchronizeStream)：流同步，简化接口。
	14	+- [`aclError aclrtSynchronizeEvent(aclrtEvent event, int32_t timeout)`](#aclrtSynchronizeEvent)：事件同步，简化接口。
	15	+- [`aclError aclrtStreamWaitEvent(aclrtStream stream, aclrtEvent event, int32_t timeout)`](#aclrtStreamWaitEvent)：流等待事件，简化接口。
	16	+- [`aclError aclrtCreateStream(aclrtStream *stream, uint32_t priority, uint32_t flag)`](#aclrtCreateStream)：创建流，简化接口。
	17	+- [`aclError aclrtSetOpExecuteTimeOut(uint64_t timeout, uint64_t *actualTimeout)`](#aclrtSetOpExecuteTimeOut)：设置算子执行超时，简化接口。
	18	+- [`aclError aclrtCreateEvent(aclrtEvent *event, uint32_t flag)`](#aclrtCreateEvent)：创建事件，简化接口。
	19	+
	20	+## 模板函数
	21	+
	22	+- [`template <typename T> aclError aclrtMalloc(T *devPtr, size_t size, aclrtMallocConfig cfg = nullptr)`](#aclrtMalloc)：类型安全的设备内存分配。
	23	+- [`template <typename T> aclError aclrtMallocHost(T *hostPtr, size_t size, aclrtMallocConfig cfg = nullptr)`](#aclrtMallocHost)：类型安全的主机内存分配。
	24	+- [`template <typename T, typename U> aclError aclrtMemcpy(T dst, size_t destMax, const U src, size_t count, aclrtMemcpyKind kind)`](#aclrtMemcpy)：类型安全的内存拷贝。
	25	+- [`template <typename T, typename U> aclError aclrtMemcpyAsync(T dst, size_t destMax, const U src, size_t count, aclrtMemcpyKind kind, aclrtStream stream)`](#aclrtMemcpyAsync)：异步内存拷贝。
	26	+- [`template <typename T, typename U> aclError aclrtMemcpy2d(T dst, size_t dpitch, const U src, size_t spitch, size_t width, size_t height, aclrtMemcpyKind kind)`](#aclrtMemcpy2d)：2D内存拷贝。
	27	+- [`template <typename T, typename U> aclError aclrtMemcpy2dAsync(T dst, size_t dpitch, const U src, size_t spitch, size_t width, size_t height, aclrtMemcpyKind kind, aclrtStream stream)`](#aclrtMemcpy2dAsync)：异步2D内存拷贝。
	28	+- [`template <typename T, typename U> aclError aclrtMemcpyBatch(...)`](#aclrtMemcpyBatch)：批量内存拷贝。
	29	+- [`template <typename T, typename U> aclError aclrtMemcpyBatchAsync(...)`](#aclrtMemcpyBatchAsync)：异步批量内存拷贝。
	30	+- [`template <typename T> aclError aclrtPointerGetAttributes(const T ptr, aclrtPtrAttributes attributes)`](#aclrtPointerGetAttributes)：类型安全的指针属性查询。
	31	+- [`template <typename T> aclError aclrtHostRegister(...)`](#aclrtHostRegister)：类型安全的主机内存注册。
	32	+- [`template <typename T> aclError aclrtHostGetDevicePointer(T pHost, T *pDevice, uint32_t flag)`](#aclrtHostGetDevicePointer)：主机内存到设备指针映射。
	33	+- [`template <typename T> aclError aclrtHostUnregister(T *ptr)`](#aclrtHostUnregister)：类型安全的主机内存注销。
	34	+- [`template <typename T> aclError aclrtMemAllocManaged(T **devPtr, size_t size, uint32_t flags = ACL_RT_MEM_ATTACH_GLOBAL)`](#aclrtMemAllocManaged)：类型安全的统一内存分配。
	35	+- [`template <typename T> aclError aclrtMemManagedPrefetchAsync(const T *ptr, size_t size, aclrtMemManagedLocation location, uint32_t flags, aclrtStream stream)`](#aclrtMemManagedPrefetchAsync)：预取统一内存。
	36	+- [`template <typename T> aclError aclrtMemManagedPrefetchBatchAsync(...)`](#aclrtMemManagedPrefetchBatchAsync)：批量预取统一内存。
	37	+
	38	+---
	39	+
	40	+<br>
	41	+<br>
	42	+<br>
	43	+
	44	+<a id="aclrtSynchronizeDevice"></a>
	45	+
	46	+## aclrtSynchronizeDevice
	47	+
	48	+```cpp
	49	+aclError aclrtSynchronizeDevice(int32_t timeout)
	50	+```
	51	+
	52	+### 产品支持情况
	53	+
	54	+\| 产品 \| 是否支持 \|
	55	+\| --- \| :---: \|
	56	+\| Ascend 950PR/Ascend 950DT \| √ \|
	57	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	atomgit-bot5月8日 ⚠️ aclrtSynchronizeDevice 文档错误标记为异步接口 aclrtSynchronizeDevice 是一个同步阻塞接口，文档的约束说明中错误地写为「本接口为异步接口，调用后需同步等待拷贝完成」。这与函数功能矛盾：该接口本身就是同步等待设备完成，不存在「拷贝完成」的概念，也不是异步接口。参考依据类别: bug 置信度: 100%
	58	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	59	+
	60	+### 功能说明
	61	+
	62	+设备同步，阻塞当前主机线程直到Device上所有显式或隐式创建的Stream都完成所有先前下发的任务。本接口为简化版本，内部调用 [aclrtSynchronizeDeviceWithTimeout](04_Device管理.md#aclrtSynchronizeDeviceWithTimeout)。
	63	+
	64	+### 参数说明
	65	+
	66	+\| 参数名 \| 输入/输出 \| 说明 \|
	67	+\| --- \| :---: \| --- \|
	68	+\| timeout \| 输入 \| 同步等待的超时时间，单位ms。 \|
	69	+
	70	+### 返回值说明
	71	+
	72	+返回0表示成功，返回其他值表示失败，请参见[aclError](25_数据类型及其操作接口.md#aclError)。
	73	+
	74	+### 约束说明
	75	+
	76	+- 本接口仅适用于 C++ 程序。
	77	+
	78	+---
	79	+
	80	+<br>
	81	+<br>
	82	+<br>
	83	+
	84	+<a id="aclrtSynchronizeStream"></a>
	85	+
	86	+## aclrtSynchronizeStream
	87	+
	88	+```cpp
	89	+aclError aclrtSynchronizeStream(aclrtStream stream, int32_t timeout)
	90	+```
	91	+
	92	+### 产品支持情况
	93	+
	94	+\| 产品 \| 是否支持 \|
	95	+\| --- \| :---: \|
	96	+\| Ascend 950PR/Ascend 950DT \| √ \|
	97	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	98	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	99	+
	100	+### 功能说明
	101	+
	102	+流同步接口的简化重载版本。内部调用 [aclrtSynchronizeStreamWithTimeout](06_Stream管理.md#aclrtSynchronizeStreamWithTimeout)。
	103	+
	104	+### 参数说明
	105	+
	106	+\| 参数名 \| 输入/输出 \| 说明 \|
	107	+\| --- \| :---: \| --- \|
	108	+\| stream \| 输入 \| 指定Stream指针。 \|
	109	+\| timeout \| 输入 \| 同步等待超时时间，单位ms。 \|
	110	+
	111	+### 返回值说明
	112	+
	113	+返回0表示成功，返回其他值表示失败，请参见[aclError](25_数据类型及其操作接口.md#aclError)。
	114	+
	115	+### 约束说明
	116	+
	117	+- 本接口仅适用于 C++ 程序。
	118	+
	119	+---
	120	+
	121	+<br>
	122	+<br>
	123	+<br>
	124	+
	125	+<a id="aclrtSynchronizeEvent"></a>
	126	+
	127	+## aclrtSynchronizeEvent
	128	+
	129	+```cpp
	130	+aclError aclrtSynchronizeEvent(aclrtEvent event, int32_t timeout)
	131	+```
	132	+
	133	+### 产品支持情况
	134	+
	135	+\| 产品 \| 是否支持 \|
	136	+\| --- \| :---: \|
	137	+\| Ascend 950PR/Ascend 950DT \| √ \|
	138	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	139	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	140	+
	141	+### 功能说明
	142	+
	143	+事件同步接口的简化重载版本。内部调用 [aclrtSynchronizeEventWithTimeout](07_Event管理.md#aclrtSynchronizeEventWithTimeout)。
	144	+
	145	+### 参数说明
	146	+
	147	+\| 参数名 \| 输入/输出 \| 说明 \|
	148	+\| --- \| :---: \| --- \|
	149	+\| event \| 输入 \| 指定Event指针。 \|
	150	+\| timeout \| 输入 \| 同步等待超时时间，单位ms。 \|
	151	+
	152	+### 返回值说明
	153	+
	154	+返回0表示成功，返回其他值表示失败，请参见[aclError](25_数据类型及其操作接口.md#aclError)。
	155	+
	156	+### 约束说明
	157	+
	158	+- 本接口仅适用于 C++ 程序。
	159	+
	160	+---
	161	+
	162	+<br>
	163	+<br>
	164	+<br>
	165	+
	166	+<a id="aclrtStreamWaitEvent"></a>
	167	+
	168	+## aclrtStreamWaitEvent
	169	+
	170	+```cpp
	171	+aclError aclrtStreamWaitEvent(aclrtStream stream, aclrtEvent event, int32_t timeout)
	172	+```
	173	+
	174	+### 产品支持情况
	175	+
	176	+\| 产品 \| 是否支持 \|
	177	+\| --- \| :---: \|
	178	+\| Ascend 950PR/Ascend 950DT \| √ \|
	179	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	180	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	181	+
	182	+### 功能说明
	183	+
	184	+流等待事件接口的简化重载版本。内部调用 [aclrtStreamWaitEventWithTimeout](06_Stream管理.md#aclrtStreamWaitEventWithTimeout)。
	185	+
	186	+### 参数说明
	187	+
	188	+\| 参数名 \| 输入/输出 \| 说明 \|
	189	+\| --- \| :---: \| --- \|
	190	+\| stream \| 输入 \| 指定Stream指针。 \|
	191	+\| event \| 输入 \| 指定Event指针。 \|
	192	+\| timeout \| 输入 \| 等待超时时间，单位ms。 \|
	193	+
	194	+### 返回值说明
	195	+
	196	+返回0表示成功，返回其他值表示失败，请参见[aclError](25_数据类型及其操作接口.md#aclError)。
	197	+
	198	+### 约束说明
	199	+
	200	+- 本接口仅适用于 C++ 程序。
	201	+- 本接口为异步接口，下发等待任务后立即返回，需确保Event已完成。
	202	+
	203	+---
	204	+
	205	+<br>
	206	+<br>
	207	+<br>
	208	+
	209	+<a id="aclrtCreateStream"></a>
	210	+
	211	+## aclrtCreateStream
	212	+
	213	+```cpp
	214	+aclError aclrtCreateStream(aclrtStream *stream, uint32_t priority, uint32_t flag)
	215	+```
	216	+
	217	+### 产品支持情况
	218	+
	219	+\| 产品 \| 是否支持 \|
	220	+\| --- \| :---: \|
	221	+\| Ascend 950PR/Ascend 950DT \| √ \|
	222	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	223	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	224	+
	225	+### 功能说明
	226	+
	227	+创建Stream接口的简化重载版本。内部调用 [aclrtCreateStreamWithConfig](06_Stream管理.md#aclrtCreateStreamWithConfig)。
	228	+
	229	+### 参数说明
	230	+
	231	+\| 参数名 \| 输入/输出 \| 说明 \|
	232	+\| --- \| :---: \| --- \|
	233	+\| stream \| 输出 \| 创建的Stream指针。 \|
	234	+\| priority \| 输入 \| Stream优先级。 \|
	235	+\| flag \| 输入 \| Stream配置标志。 \|
	236	+
	237	+### 返回值说明
	238	+
	239	+返回0表示成功，返回其他值表示失败，请参见[aclError](25_数据类型及其操作接口.md#aclError)。
	240	+
	241	+### 约束说明
	242	+
	243	+- 本接口仅适用于 C++ 程序。
	244	+
	245	+---
	246	+
	247	+<br>
	248	+<br>
	249	+<br>
	250	+
	251	+<a id="aclrtSetOpExecuteTimeOut"></a>
	252	+
	253	+## aclrtSetOpExecuteTimeOut
	254	+
	255	+```cpp
	256	+aclError aclrtSetOpExecuteTimeOut(uint64_t timeout, uint64_t *actualTimeout)
	257	+```
	258	+
	259	+### 产品支持情况
	260	+
	261	+\| 产品 \| 是否支持 \|
	262	+\| --- \| :---: \|
	263	+\| Ascend 950PR/Ascend 950DT \| √ \|
	264	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	265	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	266	+
	267	+### 功能说明
	268	+
	269	+设置算子执行超时时间的简化重载版本。内部调用 [aclrtSetOpExecuteTimeOutV2](03_运行时配置.md#aclrtSetOpExecuteTimeOutV2)。
	270	+
	271	+### 参数说明
	272	+
	273	+\| 参数名 \| 输入/输出 \| 说明 \|
	274	+\| --- \| :---: \| --- \|
	275	+\| timeout \| 输入 \| 设置的超时时间，单位ms。 \|
	276	+\| actualTimeout \| 输出 \| 返回实际生效的超时时间。 \|
	277	+
	278	+### 返回值说明
	279	+
	280	+返回0表示成功，返回其他值表示失败，请参见[aclError](25_数据类型及其操作接口.md#aclError)。
	281	+
	282	+### 约束说明
	283	+
	284	+- 本接口仅适用于 C++ 程序。
	285	+
	286	+---
	287	+
	288	+<br>
	289	+<br>
	290	+<br>
	291	+
	292	+<a id="aclrtCreateEvent"></a>
	293	+
	294	+## aclrtCreateEvent
	295	+
	296	+```cpp
	297	+aclError aclrtCreateEvent(aclrtEvent *event, uint32_t flag)
	298	+```
	299	+
	300	+### 产品支持情况
	301	+
	302	+\| 产品 \| 是否支持 \|
	303	+\| --- \| :---: \|
	304	+\| Ascend 950PR/Ascend 950DT \| √ \|
	305	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	306	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	307	+
	308	+### 功能说明
	309	+
	310	+创建Event接口的简化重载版本。内部调用 [aclrtCreateEventExWithFlag](07_Event管理.md#aclrtCreateEventExWithFlag)。
	311	+
	312	+### 参数说明
	313	+
	314	+\| 参数名 \| 输入/输出 \| 说明 \|
	315	+\| --- \| :---: \| --- \|
	316	+\| event \| 输出 \| 创建的Event指针。 \|
	317	+\| flag \| 输入 \| Event配置标志。 \|
	318	+
	319	+### 返回值说明
	320	+
	321	+返回0表示成功，返回其他值表示失败，请参见[aclError](25_数据类型及其操作接口.md#aclError)。
	322	+
	323	+### 约束说明
	324	+
	325	+- 本接口仅适用于 C++ 程序。
	326	+
	327	+---
	328	+
	329	+<br>
	330	+<br>
	331	+<br>
	332	+
	333	+<a id="aclrtMemcpyBatch"></a>
	334	+
	335	+## aclrtMemcpyBatch
	336	+
	337	+```cpp
	338	+template <typename T, typename U>
	339	+aclError aclrtMemcpyBatch(T *dsts, size_t destMaxs, U *srcs, size_t sizes, size_t numBatches, aclrtMemcpyBatchAttr attr)
	340	+
	341	+template <typename T, typename U>
	342	+aclError aclrtMemcpyBatch(T *dsts, size_t destMaxs, U *srcs, size_t sizes, size_t numBatches, aclrtMemcpyBatchAttr attrs, size_t attrsIndexes, size_t numAttrs)
	343	+```
	344	+
	345	+### 产品支持情况
	346	+
	347	+\| 产品 \| 是否支持 \|
	348	+\| --- \| :---: \|
	349	+\| Ascend 950PR/Ascend 950DT \| √ \|
	350	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	351	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	352	+
	353	+### 功能说明
	354	+
	355	+类型安全的批量内存拷贝模板函数。内部调用 [aclrtMemcpyBatchV2](11-03_内存拷贝与设置.md#aclrtMemcpyBatchV2)。
	356	+
	357	+### 参数说明
	358	+
	359	+\| 参数名 \| 输入/输出 \| 说明 \|
	360	+\| --- \| :---: \| --- \|
	361	+\| dsts \| 输出 \| 目标内存地址指针数组。 \|
	362	+\| destMaxs \| 输入 \| 目标内存最大长度数组，单位Byte。 \|
	363	+\| srcs \| 输入 \| 源内存地址指针数组。 \|
	364	+\| sizes \| 输入 \| 拷贝内存大小数组，单位Byte。 \|
	365	+\| numBatches \| 输入 \| 批量拷贝数量。 \|
	366	+\| attr \| 输入 \| 单个拷贝属性。 \|
	367	+\| attrs \| 输入 \| 拷贝属性数组。 \|
	368	+\| attrsIndexes \| 输入 \| 属性索引数组。 \|
	369	+\| numAttrs \| 输入 \| 属性数量。 \|
	370	+
	371	+### 返回值说明
	372	+
	373	+返回0表示成功，返回其他值表示失败。
	374	+
	375	+### 约束说明
	376	+
	377	+- 本接口仅适用于 C++ 程序。
	378	+
	379	+---
	380	+
	381	+<br>
	382	+<br>
	383	+<br>
	384	+
	385	+<a id="aclrtMemcpyBatchAsync"></a>
	386	+
	387	+## aclrtMemcpyBatchAsync
	388	+
	389	+```cpp
	390	+template <typename T, typename U>
	391	+aclError aclrtMemcpyBatchAsync(T *dsts, size_t destMaxs, U *srcs, size_t sizes, size_t numBatches, aclrtMemcpyBatchAttr attr, aclrtStream stream)
	392	+
	393	+template <typename T, typename U>
	394	+aclError aclrtMemcpyBatchAsync(T *dsts, size_t destMaxs, U *srcs, size_t sizes, size_t numBatches, aclrtMemcpyBatchAttr attrs, size_t attrsIndexes, size_t numAttrs, aclrtStream stream)
	395	+```
	396	+
	397	+### 产品支持情况
	398	+
	399	+\| 产品 \| 是否支持 \|
	400	+\| --- \| :---: \|
	401	+\| Ascend 950PR/Ascend 950DT \| √ \|
	402	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	403	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	404	+
	405	+### 功能说明
	406	+
	407	+类型安全的异步批量内存拷贝模板函数。内部调用 [aclrtMemcpyBatchAsyncV2](11-03_内存拷贝与设置.md#aclrtMemcpyBatchAsyncV2)。
	408	+
	409	+### 参数说明
	410	+
	411	+参数同 [aclrtMemcpyBatch](#aclrtMemcpyBatch)，额外增加 stream 参数。
	412	+
	413	+\| 参数名 \| 输入/输出 \| 说明 \|
	414	+\| --- \| :---: \| --- \|
	415	+\| stream \| 输入 \| 指定Stream指针。 \|
	416	+
	417	+### 返回值说明
	418	+
	419	+返回0表示成功，返回其他值表示失败。
	420	+
	421	+### 约束说明
	422	+
	423	+- 本接口仅适用于 C++ 程序。
	424	+- 本接口为异步接口，调用后需同步等待。
	425	+
	426	+---
	427	+
	428	+<br>
	429	+<br>
	430	+<br>
	431	+
	432	+<a id="aclrtPointerGetAttributes"></a>
	433	+
	434	+## aclrtPointerGetAttributes
	435	+
	436	+```cpp
	437	+template <typename T>
	438	+aclError aclrtPointerGetAttributes(const T ptr, aclrtPtrAttributes attributes)
	439	+```
	440	+
	441	+### 产品支持情况
	442	+
	443	+\| 产品 \| 是否支持 \|
	444	+\| --- \| :---: \|
	445	+\| Ascend 950PR/Ascend 950DT \| √ \|
	446	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	447	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	448	+
	449	+### 功能说明
	450	+
	451	+类型安全的指针属性查询模板函数。内部调用 [aclrtPointerGetAttributes](11-05_统一寻址.md#aclrtPointerGetAttributes)。
	452	+
	453	+### 参数说明
	454	+
	455	+\| 参数名 \| 输入/输出 \| 说明 \|
	456	+\| --- \| :---: \| --- \|
	457	+\| ptr \| 输入 \| 指定查询的指针地址。 \|
	458	+\| attributes \| 输出 \| 返回指针的属性信息。 \|
	459	+
	460	+### 返回值说明
	461	+
	462	+返回0表示成功，返回其他值表示失败。
	463	+
	464	+### 约束说明
	465	+
	466	+- 本接口仅适用于 C++ 程序。
	467	+
	468	+---
	469	+
	470	+<br>
	471	+<br>
	472	+<br>
	473	+
	474	+<a id="aclrtHostRegister"></a>
	475	+
	476	+## aclrtHostRegister
	477	+
	478	+```cpp
	479	+template <typename T>
	480	+aclError aclrtHostRegister(T ptr, uint64_t size, aclrtHostRegisterType type, T *devPtr)
	481	+
	482	+template <typename T>
	483	+aclError aclrtHostRegister(T *ptr, uint64_t size, uint32_t flag)
	484	+```
	485	+
	486	+### 产品支持情况
	487	+
	488	+\| 产品 \| 是否支持 \|
	489	+\| --- \| :---: \|
	490	+\| Ascend 950PR/Ascend 950DT \| √ \|
	491	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	492	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	493	+
	494	+### 功能说明
	495	+
	496	+类型安全的主机内存注册模板函数。内部调用 [aclrtHostRegister](11-02_主机内存管理.md#aclrtHostRegister) 或 [aclrtHostRegisterV2](11-02_主机内存管理.md#aclrtHostRegisterV2)。
	497	+
	498	+### 参数说明
	499	+
	500	+\| 参数名 \| 输入/输出 \| 说明 \|
	501	+\| --- \| :---: \| --- \|
	502	+\| ptr \| 输入 \| Host内存指针。 \|
	503	+\| size \| 输入 \| 注册内存大小，单位Byte。 \|
	504	+\| type \| 输入 \| 注册类型。 \|
	505	+\| devPtr \| 输出 \| 返回Device指针地址。 \|
	506	+\| flag \| 输入 \| 注册标志位。 \|
	507	+
	508	+### 返回值说明
	509	+
	510	+返回0表示成功，返回其他值表示失败。
	511	+
	512	+### 约束说明
	513	+
	514	+- 本接口仅适用于 C++ 程序。
	515	+- 注册的内存需通过 [aclrtHostUnregister](#aclrtHostUnregister) 注销。
	516	+
	517	+---
	518	+
	519	+<br>
	520	+<br>
	521	+<br>
	522	+
	523	+<a id="aclrtHostGetDevicePointer"></a>
	524	+
	525	+## aclrtHostGetDevicePointer
	526	+
	527	+```cpp
	528	+template <typename T>
	529	+aclError aclrtHostGetDevicePointer(T pHost, T *pDevice, uint32_t flag)
	530	+```
	531	+
	532	+### 产品支持情况
	533	+
	534	+\| 产品 \| 是否支持 \|
	535	+\| --- \| :---: \|
	536	+\| Ascend 950PR/Ascend 950DT \| √ \|
	537	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	538	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	539	+
	540	+### 功能说明
	541	+
	542	+类型安全的主机内存到设备指针映射模板函数。内部调用 [aclrtHostGetDevicePointer](11-05_统一寻址.md#aclrtHostGetDevicePointer)。
	543	+
	544	+### 参数说明
	545	+
	546	+\| 参数名 \| 输入/输出 \| 说明 \|
	547	+\| --- \| :---: \| --- \|
	548	+\| pHost \| 输入 \| Host内存指针。 \|
	549	+\| pDevice \| 输出 \| 返回Device指针地址。 \|
	550	+\| flag \| 输入 \| 预留参数，配置为0。 \|
	551	+
	552	+### 返回值说明
	553	+
	554	+返回0表示成功，返回其他值表示失败。
	555	+
	556	+### 约束说明
	557	+
	558	+- 本接口仅适用于 C++ 程序。
	559	+
	560	+---
	561	+
	562	+<br>
	563	+<br>
	564	+<br>
	565	+
	566	+<a id="aclrtHostUnregister"></a>
	567	+
	568	+## aclrtHostUnregister
	569	+
	570	+```cpp
	571	+template <typename T>
	572	+aclError aclrtHostUnregister(T *ptr)
	573	+```
	574	+
	575	+### 产品支持情况
	576	+
	577	+\| 产品 \| 是否支持 \|
	578	+\| --- \| :---: \|
	579	+\| Ascend 950PR/Ascend 950DT \| √ \|
	580	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	581	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	582	+
	583	+### 功能说明
	584	+
	585	+类型安全的主机内存注销模板函数。内部调用 [aclrtHostUnregister](11-02_主机内存管理.md#aclrtHostUnregister)。
	586	+
	587	+### 参数说明
	588	+
	589	+\| 参数名 \| 输入/输出 \| 说明 \|
	590	+\| --- \| :---: \| --- \|
	591	+\| ptr \| 输入 \| Host内存指针。 \|
	592	+
	593	+### 返回值说明
	594	+
	595	+返回0表示成功，返回其他值表示失败。
	596	+
	597	+### 约束说明
	598	+
	599	+- 本接口仅适用于 C++ 程序。
	600	+
	601	+---
	602	+
	603	+<br>
	604	+<br>
	605	+<br>
	606	+
	607	+<a id="aclrtMemAllocManaged"></a>
	608	+
	609	+## aclrtMemAllocManaged
	610	+
	611	+```cpp
	612	+template <typename T>
	613	+aclError aclrtMemAllocManaged(T **devPtr, size_t size, uint32_t flags = ACL_RT_MEM_ATTACH_GLOBAL)
	614	+```
	615	+
	616	+### 产品支持情况
	617	+
	618	+\| 产品 \| 是否支持 \|
	619	+\| --- \| :---: \|
	620	+\| Ascend 950PR/Ascend 950DT \| √ \|
	621	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	622	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	623	+
	624	+### 功能说明
	625	+
	626	+类型安全的统一内存分配模板函数。内部调用 [aclrtMemAllocManaged](11-05_统一寻址.md#aclrtMemAllocManaged)。
	627	+
	628	+### 参数说明
	629	+
	630	+\| 参数名 \| 输入/输出 \| 说明 \|
	631	+\| --- \| :---: \| --- \|
	632	+\| devPtr \| 输出 \| 返回统一内存指针。 \|
	633	+\| size \| 输入 \| 申请内存大小，单位Byte。 \|
	634	+\| flags \| 输入 \| 内存附加标志，默认ACL_RT_MEM_ATTACH_GLOBAL。 \|
	635	+
	636	+### 返回值说明
	637	+
	638	+返回0表示成功，返回其他值表示失败。
	639	+
	640	+### 约束说明
	641	+
	642	+- 本接口仅适用于 C++ 程序。
	643	+- 申请的内存需通过 [aclrtFree](11-01_设备内存分配与释放.md#aclrtFree) 释放。
	644	+
	645	+---
	646	+
	647	+<br>
	648	+<br>
	649	+<br>
	650	+
	651	+<a id="aclrtMemManagedPrefetchAsync"></a>
	652	+
	653	+## aclrtMemManagedPrefetchAsync
	654	+
	655	+```cpp
	656	+template <typename T>
	657	+aclError aclrtMemManagedPrefetchAsync(const T *ptr, size_t size, aclrtMemManagedLocation location, uint32_t flags, aclrtStream stream)
	658	+```
	659	+
	660	+### 产品支持情况
	661	+
	662	+\| 产品 \| 是否支持 \|
	663	+\| --- \| :---: \|
	664	+\| Ascend 950PR/Ascend 950DT \| √ \|
	665	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	666	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	667	+
	668	+### 功能说明
	669	+
	670	+类型安全的统一内存预取模板函数。内部调用 [aclrtMemManagedPrefetchAsync](11-05_统一寻址.md#aclrtMemManagedPrefetchAsync)。
	671	+
	672	+### 参数说明
	673	+
	674	+\| 参数名 \| 输入/输出 \| 说明 \|
	675	+\| --- \| :---: \| --- \|
	676	+\| ptr \| 输入 \| 统一内存指针。 \|
	677	+\| size \| 输入 \| 预取内存大小，单位Byte。 \|
	678	+\| location \| 输入 \| 预取目标位置。 \|
	679	+\| flags \| 输入 \| 预取附加标志。 \|
	680	+\| stream \| 输入 \| 指定Stream指针。 \|
	681	+
	682	+### 返回值说明
	683	+
	684	+返回0表示成功，返回其他值表示失败。
	685	+
	686	+### 约束说明
	687	+
	688	+- 本接口仅适用于 C++ 程序。
	689	+- 本接口为异步接口，调用后需同步等待。
	690	+
	691	+---
	692	+
	693	+<br>
	694	+<br>
	695	+<br>
	696	+
	697	+<a id="aclrtMemManagedPrefetchBatchAsync"></a>
	698	+
	699	+## aclrtMemManagedPrefetchBatchAsync
	700	+
	701	+```cpp
	702	+template <typename T>
	703	+aclError aclrtMemManagedPrefetchBatchAsync(const T *ptrs, size_t sizes, size_t count, aclrtMemManagedLocation prefetchLoc, uint64_t flags, aclrtStream stream)
	704	+
	705	+template <typename T>
	706	+aclError aclrtMemManagedPrefetchBatchAsync(const T *ptrs, size_t sizes, size_t count, aclrtMemManagedLocation prefetchLocs, size_t prefetchLocIdxs, size_t numPrefetchLocs, uint64_t flags, aclrtStream stream)
	707	+```
	708	+
	709	+### 产品支持情况
	710	+
	711	+\| 产品 \| 是否支持 \|
	712	+\| --- \| :---: \|
	713	+\| Ascend 950PR/Ascend 950DT \| √ \|
	714	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	715	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	716	+
	717	+### 功能说明
	718	+
	719	+类型安全的批量统一内存预取模板函数。内部调用 [aclrtMemManagedPrefetchBatchAsync](11-05_统一寻址.md#aclrtMemManagedPrefetchBatchAsync)。
	720	+
	721	+### 参数说明
	722	+
	723	+\| 参数名 \| 输入/输出 \| 说明 \|
	724	+\| --- \| :---: \| --- \|
	725	+\| ptrs \| 输入 \| 统一内存指针数组。 \|
	726	+\| sizes \| 输入 \| 预取内存大小数组，单位Byte。 \|
	727	+\| count \| 输入 \| 批量预取数量。 \|
	728	+\| prefetchLoc \| 输入 \| 单个预取目标位置。 \|
	729	+\| prefetchLocs \| 输入 \| 预取目标位置数组。 \|
	730	+\| prefetchLocIdxs \| 输入 \| 预取位置索引数组。 \|
	731	+\| numPrefetchLocs \| 输入 \| 预取位置数量。 \|
	732	+\| flags \| 输入 \| 预取附加标志。 \|
	733	+\| stream \| 输入 \| 指定Stream指针。 \|
	734	+
	735	+### 返回值说明
	736	+
	737	+返回0表示成功，返回其他值表示失败。
	738	+
	739	+### 约束说明
	740	+
	741	+- 本接口仅适用于 C++ 程序。
	742	+- 本接口为异步接口，调用后需同步等待。
	743	+
	744	+---
	745	+
	746	+<br>
	747	+<br>
	748	+<br>
	749	+
	750	+<a id="aclrtMalloc"></a>
	751	+
	752	+## aclrtMalloc
	753	+
	754	+```cpp
	755	+template <typename T>
	756	+aclError aclrtMalloc(T *devPtr, size_t size, aclrtMallocConfig cfg = nullptr)
	757	+
	758	+template <typename T>
	759	+aclError aclrtMalloc(T *devPtr, size_t size, aclrtMemMallocPolicy policy, aclrtMallocConfig cfg = nullptr)
	760	+```
	761	+
	762	+### 产品支持情况
	763	+
	764	+\| 产品 \| 是否支持 \|
	765	+\| --- \| :---: \|
	766	+\| Ascend 950PR/Ascend 950DT \| √ \|
	767	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	768	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	769	+
	770	+### 功能说明
	771	+
	772	+类型安全的设备内存分配模板函数。内部调用 [aclrtMallocWithCfg](11-01_设备内存分配与释放.md#aclrtMallocWithCfg)。
	773	+
	774	+### 参数说明
	775	+
	776	+\| 参数名 \| 输入/输出 \| 说明 \|
	777	+\| --- \| :---: \| --- \|
	778	+\| devPtr \| 输出 \| 返回设备内存指针。类型自动推导。 \|
	779	+\| size \| 输入 \| 申请内存大小，单位Byte。 \|
	780	+\| cfg \| 输入 \| 内存分配配置，默认nullptr。 \|
	781	+\| policy \| 输入 \| 内存分配策略。类型定义请参见[aclrtMemMallocPolicy](25_数据类型及其操作接口.md#aclrtMemMallocPolicy)。 \|
	782	+
	783	+### 返回值说明
	784	+
	785	+返回0表示成功，返回其他值表示失败，请参见[aclError](25_数据类型及其操作接口.md#aclError)。
	786	+
	787	+### 约束说明
	788	+
	789	+- 本接口仅适用于 C++ 程序。
	790	+- 申请的内存需通过 [aclrtFree](11-01_设备内存分配与释放.md#aclrtFree) 释放。
	791	+
	792	+---
	793	+
	794	+<br>
	795	+<br>
	796	+<br>
	797	+
	798	+<a id="aclrtMallocHost"></a>
	799	+
	800	+## aclrtMallocHost
	801	+
	802	+```cpp
	803	+template <typename T>
	804	+aclError aclrtMallocHost(T *hostPtr, size_t size, aclrtMallocConfig cfg = nullptr)
	805	+```
	806	+
	807	+### 产品支持情况
	808	+
	809	+\| 产品 \| 是否支持 \|
	810	+\| --- \| :---: \|
	811	+\| Ascend 950PR/Ascend 950DT \| √ \|
	812	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	813	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	814	+
	815	+### 功能说明
	816	+
	817	+类型安全的主机内存分配模板函数。内部调用 [aclrtMallocHostWithCfg](11-02_主机内存管理.md#aclrtMallocHostWithCfg)。
	818	+
	819	+### 参数说明
	820	+
	821	+\| 参数名 \| 输入/输出 \| 说明 \|
	822	+\| --- \| :---: \| --- \|
	823	+\| hostPtr \| 输出 \| 返回主机内存指针。类型自动推导。 \|
	824	+\| size \| 输入 \| 申请内存大小，单位Byte。 \|
	825	+\| cfg \| 输入 \| 内存分配配置，默认nullptr。 \|
	826	+
	827	+### 返回值说明
	828	+
	829	+返回0表示成功，返回其他值表示失败，请参见[aclError](25_数据类型及其操作接口.md#aclError)。
	830	+
	831	+### 约束说明
	832	+
	833	+- 本接口仅适用于 C++ 程序。
	834	+- 申请的内存需通过 [aclrtFreeHost](11-02_主机内存管理.md#aclrtFreeHost) 释放。
	835	+
	836	+---
	837	+
	838	+<br>
	839	+<br>
	840	+<br>
	841	+
	842	+<a id="aclrtMemcpy"></a>
	843	+
	844	+## aclrtMemcpy
	845	+
	846	+```cpp
	847	+template <typename T, typename U>
	848	+aclError aclrtMemcpy(T dst, size_t destMax, const U src, size_t count, aclrtMemcpyKind kind)
	849	+```
	850	+
	851	+### 产品支持情况
	852	+
	853	+\| 产品 \| 是否支持 \|
	854	+\| --- \| :---: \|
	855	+\| Ascend 950PR/Ascend 950DT \| √ \|
	856	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	857	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	858	+
	859	+### 功能说明
	860	+
	861	+类型安全的内存拷贝模板函数。内部调用 [aclrtMemcpy](11-03_内存拷贝与设置.md#aclrtMemcpy)。
	862	+
	863	+### 参数说明
	864	+
	865	+\| 参数名 \| 输入/输出 \| 说明 \|
	866	+\| --- \| :---: \| --- \|
	867	+\| dst \| 输出 \| 目标内存地址指针。类型自动推导。 \|
	868	+\| destMax \| 输入 \| 目标内存最大长度，单位Byte。 \|
	869	+\| src \| 输入 \| 源内存地址指针。类型自动推导。 \|
	870	+\| count \| 输入 \| 拷贝内存大小，单位Byte。 \|
	871	+\| kind \| 输入 \| 拷贝类型。类型定义请参见[aclrtMemcpyKind](25_数据类型及其操作接口.md#aclrtMemcpyKind)。 \|
	872	+
	873	+### 返回值说明
	874	+
	875	+返回0表示成功，返回其他值表示失败，请参见[aclError](25_数据类型及其操作接口.md#aclError)。
	876	+
	877	+### 约束说明
	878	+
	879	+- 本接口仅适用于 C++ 程序。
	880	+
	881	+---
	882	+
	883	+<br>
	884	+<br>
	885	+<br>
	886	+
	887	+<a id="aclrtMemcpyAsync"></a>
	888	+
	889	+## aclrtMemcpyAsync
	890	+
	891	+```cpp
	892	+template <typename T, typename U>
	893	+aclError aclrtMemcpyAsync(T dst, size_t destMax, const U src, size_t count, aclrtMemcpyKind kind, aclrtStream stream)
	894	+```
	895	+
	896	+### 产品支持情况
	897	+
	898	+\| 产品 \| 是否支持 \|
	899	+\| --- \| :---: \|
	900	+\| Ascend 950PR/Ascend 950DT \| √ \|
	901	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	902	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	903	+
	904	+### 功能说明
	905	+
	906	+类型安全的异步内存拷贝模板函数。内部调用 [aclrtMemcpyAsync](11-03_内存拷贝与设置.md#aclrtMemcpyAsync)。
	907	+
	908	+### 参数说明
	909	+
	910	+参数同 [aclrtMemcpy](#aclrtMemcpy)，额外增加 stream 参数。
	911	+
	912	+\| 参数名 \| 输入/输出 \| 说明 \|
	913	+\| --- \| :---: \| --- \|
	914	+\| stream \| 输入 \| 指定Stream指针。 \|
	915	+
	916	+### 返回值说明
	917	+
	918	+返回0表示成功，返回其他值表示失败，请参见[aclError](25_数据类型及其操作接口.md#aclError)。
	919	+
	920	+### 约束说明
	921	+
	922	+- 本接口仅适用于 C++ 程序。
	923	+- 本接口为异步接口，调用后需同步等待拷贝完成。
	924	+
	925	+---
	926	+
	927	+<br>
	928	+<br>
	929	+<br>
	930	+
	931	+<a id="aclrtMemcpy2d"></a>
	932	+
	933	+## aclrtMemcpy2d
	934	+
	935	+```cpp
	936	+template <typename T, typename U>
	937	+aclError aclrtMemcpy2d(T dst, size_t dpitch, const U src, size_t spitch, size_t width, size_t height, aclrtMemcpyKind kind)
	938	+```
	939	+
	940	+### 产品支持情况
	941	+
	942	+\| 产品 \| 是否支持 \|
	943	+\| --- \| :---: \|
	944	+\| Ascend 950PR/Ascend 950DT \| √ \|
	945	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	946	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	947	+
	948	+### 功能说明
	949	+
	950	+类型安全的2D内存拷贝模板函数。将src指向的2D内存数据拷贝到dst指向的2D内存。本接口内部调用 [aclrtMemcpy2d](11-03_内存拷贝与设置.md#aclrtMemcpy2d)。
	951	+
	952	+### 参数说明
	953	+
	954	+\| 参数名 \| 输入/输出 \| 说明 \|
	955	+\| --- \| :---: \| --- \|
	956	+\| dst \| 输出 \| 目标内存地址指针。类型自动推导。 \|
	957	+\| dpitch \| 输入 \| 目标内存的宽度pitch，单位Byte。 \|
	958	+\| src \| 输入 \| 源内存地址指针。类型自动推导。 \|
	959	+\| spitch \| 输入 \| 源内存的宽度pitch，单位Byte。 \|
	960	+\| width \| 输入 \| 拷贝内存的宽度，单位Byte。 \|
	961	+\| height \| 输入 \| 拷贝内存的高度，单位Byte。 \|
	962	+\| kind \| 输入 \| 拷贝类型。类型定义请参见[aclrtMemcpyKind](25_数据类型及其操作接口.md#aclrtMemcpyKind)。 \|
	963	+
	964	+### 返回值说明
	965	+
	966	+返回0表示成功，返回其他值表示失败，请参见[aclError](25_数据类型及其操作接口.md#aclError)。
	967	+
	968	+### 约束说明
	969	+
	970	+- 本接口仅适用于 C++ 程序。
	971	+
	972	+---
	973	+
	974	+<br>
	975	+<br>
	976	+<br>
	977	+
	978	+<a id="aclrtMemcpy2dAsync"></a>
	979	+
	980	+## aclrtMemcpy2dAsync
	981	+
	982	+```cpp
	983	+template <typename T, typename U>
	984	+aclError aclrtMemcpy2dAsync(T dst, size_t dpitch, const U src, size_t spitch, size_t width, size_t height, aclrtMemcpyKind kind, aclrtStream stream)
	985	+```
	986	+
	987	+### 产品支持情况
	988	+
	989	+\| 产品 \| 是否支持 \|
	990	+\| --- \| :---: \|
	991	+\| Ascend 950PR/Ascend 950DT \| √ \|
	992	+\| Atlas A3 训练系列产品/Atlas A3 推理系列产品 \| √ \|
	993	+\| Atlas A2 训练系列产品/Atlas A2 推理系列产品 \| √ \|
	994	+
	995	+### 功能说明
	996	+
	997	+类型安全的异步2D内存拷贝模板函数。将src指向的2D内存数据异步拷贝到dst指向的2D内存。本接口内部调用 [aclrtMemcpy2dAsync](11-03_内存拷贝与设置.md#aclrtMemcpy2dAsync)。
	998	+
	999	+### 参数说明
	1000	+
	1001	+\| 参数名 \| 输入/输出 \| 说明 \|
	1002	+\| --- \| :---: \| --- \|
	1003	+\| dst \| 输出 \| 目标内存地址指针。类型自动推导。 \|
	1004	+\| dpitch \| 输入 \| 目标内存的宽度pitch，单位Byte。 \|
	1005	+\| src \| 输入 \| 源内存地址指针。类型自动推导。 \|
	1006	+\| spitch \| 输入 \| 源内存的宽度pitch，单位Byte。 \|
	1007	+\| width \| 输入 \| 拷贝内存的宽度，单位Byte。 \|
	1008	+\| height \| 输入 \| 拷贝内存的高度，单位Byte。 \|
	1009	+\| kind \| 输入 \| 拷贝类型。类型定义请参见[aclrtMemcpyKind](25_数据类型及其操作接口.md#aclrtMemcpyKind)。 \|
	1010	+\| stream \| 输入 \| 指定Stream指针。 \|
	1011	+
	1012	+### 返回值说明
	1013	+
	1014	+返回0表示成功，返回其他值表示失败，请参见[aclError](25_数据类型及其操作接口.md#aclError)。
	1015	+
	1016	+### 约束说明
	1017	+
	1018	+- 本接口仅适用于 C++ 程序。
	1019	+- 本接口为异步接口，调用后需同步等待拷贝完成。

Mdocs/03_api_ref/api_ref.md+1-0

	@@ -42,3 +42,4 @@
42	- ## [23. 日志接口](23_日志接口.md)	42	- ## [23. 日志接口](23_日志接口.md)
43	- ## [24. 其他接口](24_其他接口.md)	43	- ## [24. 其他接口](24_其他接口.md)
44	- ## [25. 数据类型及其操作接口](25_数据类型及其操作接口.md)	44	- ## [25. 数据类型及其操作接口](25_数据类型及其操作接口.md)
		45	+- ## [26. C++ API Routines](26_C++ API Routines.md)

Ainclude/external/acl/acl_rt_api.h+226-0

@@ -0,0 +1,226 @@
	1	+/**
	2	+ * Copyright (c) 2026 Huawei Technologies Co., Ltd.
	3	+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
	4	+ * CANN Open Software License Agreement Version 2.0 (the "License").
	5	+ * Please refer to the License for details. You may not use this file except in compliance with the License.
	6	+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
	7	+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
	8	+ * See LICENSE in the root of the software repository for the full text of the License.
	9	+ */
	10	+
	11	+#ifndef INC_EXTERNAL_ACL_ACL_RT_API_H_
	12	+#define INC_EXTERNAL_ACL_ACL_RT_API_H_
	13	+
	14	+#include "acl_rt.h"
	15	+
	16	+#ifdef __cplusplus
	17	+
	18	+static inline aclError aclrtSynchronizeDevice(int32_t timeout)
	atomgit-bot5月8日 ⚠️ 头文件包含路径缺少完整目录前缀 #include "acl_rt.h" 使用相对路径。根据文档描述，正确路径应为 acl/acl_rt.h。需要确认编译环境是否正确设置 include 路径指向 include/external/acl 目录。参考依据类别: general 置信度: 80% ykl999 5月9日评论： 5月9日评论：
	19	+{
	20	+ return aclrtSynchronizeDeviceWithTimeout(timeout);
	21	+}
	22	+
	23	+static inline aclError aclrtSynchronizeStream(aclrtStream stream, int32_t timeout)
	24	+{
	25	+ return aclrtSynchronizeStreamWithTimeout(stream, timeout);
	26	+}
	27	+
	28	+static inline aclError aclrtSynchronizeEvent(aclrtEvent event, int32_t timeout)
	29	+{
	30	+ return aclrtSynchronizeEventWithTimeout(event, timeout);
	31	+}
	32	+
	33	+static inline aclError aclrtStreamWaitEvent(aclrtStream stream, aclrtEvent event, int32_t timeout)
	34	+{
	35	+ return aclrtStreamWaitEventWithTimeout(stream, event, timeout);
	36	+}
	37	+
	38	+static inline aclError aclrtCreateStream(aclrtStream *stream, uint32_t priority, uint32_t flag)
	39	+{
	40	+ return aclrtCreateStreamWithConfig(stream, priority, flag);
	41	+}
	42	+
	43	+static inline aclError aclrtSetOpExecuteTimeOut(uint64_t timeout, uint64_t *actualTimeout)
	44	+{
	45	+ return aclrtSetOpExecuteTimeOutV2(timeout, actualTimeout);
	46	+}
	47	+
	48	+static inline aclError aclrtCreateEvent(aclrtEvent *event, uint32_t flag)
	49	+{
	50	+ return aclrtCreateEventExWithFlag(event, flag);
	51	+}
	52	+
	53	+template <typename T>
	54	+static inline aclError aclrtMalloc(T *devPtr, size_t size, aclrtMallocConfig cfg = nullptr)
	55	+{
	56	+ return aclrtMallocWithCfg(reinterpret_cast<void **>(devPtr), size, ACL_MEM_MALLOC_HUGE_FIRST, cfg);
	57	+}
	58	+
	59	+template <typename T>
	60	+static inline aclError aclrtMalloc(T *devPtr, size_t size, aclrtMemMallocPolicy policy, aclrtMallocConfig cfg = nullptr)
	61	+{
	62	+ return aclrtMallocWithCfg(reinterpret_cast<void **>(devPtr), size, policy, cfg);
	63	+}
	64	+
	65	+template <typename T>
	66	+static inline aclError aclrtMallocHost(T *hostPtr, size_t size, aclrtMallocConfig cfg = nullptr)
	67	+{
	68	+ return aclrtMallocHostWithCfg(reinterpret_cast<void **>(hostPtr), static_cast<uint64_t>(size), cfg);
	69	+}
	70	+
	71	+template <typename T, typename U>
	72	+static inline aclError aclrtMemcpy(T dst, size_t destMax, const U src, size_t count, aclrtMemcpyKind kind)
	73	+{
	74	+ return aclrtMemcpy(static_cast<void >(dst), destMax, static_cast<const void >(src), count, kind);
	75	+}
	76	+
	77	+template <typename T, typename U>
	78	+static inline aclError aclrtMemcpyAsync(T dst, size_t destMax, const U src, size_t count,
	79	+ aclrtMemcpyKind kind, aclrtStream stream)
	80	+{
	81	+ return aclrtMemcpyAsync(static_cast<void >(dst), destMax, static_cast<const void >(src), count, kind, stream);
	82	+}
	83	+
	84	+template <typename T, typename U>
	85	+static inline aclError aclrtMemcpy2d(T dst, size_t dpitch, const U src, size_t spitch,
	86	+ size_t width, size_t height, aclrtMemcpyKind kind)
	87	+{
	88	+ return aclrtMemcpy2d(static_cast<void >(dst), dpitch, static_cast<const void >(src),
	89	+ spitch, width, height, kind);
	90	+}
	91	+
	92	+template <typename T, typename U>
	93	+static inline aclError aclrtMemcpy2dAsync(T dst, size_t dpitch, const U src, size_t spitch,
	94	+ size_t width, size_t height, aclrtMemcpyKind kind, aclrtStream stream)
	95	+{
	96	+ return aclrtMemcpy2dAsync(static_cast<void >(dst), dpitch, static_cast<const void >(src),
	97	+ spitch, width, height, kind, stream);
	98	+}
	99	+
	100	+template <typename T, typename U>
	101	+static inline aclError aclrtMemcpyBatch(T *dsts, size_t destMaxs, U *srcs, size_t sizes,
	102	+ size_t numBatches, aclrtMemcpyBatchAttr attr, size_t *failIndex = nullptr)
	103	+{
	104	+ (void)failIndex;
	105	+ aclrtMemcpyBatchAttr attrs[1] = {attr};
	106	+ size_t attrsIndexes[1] = {0};
	107	+ return aclrtMemcpyBatchV2(reinterpret_cast<void >(dsts), destMaxs, reinterpret_cast<void >(srcs),
	108	+ sizes, numBatches, attrs, attrsIndexes, 1);
	109	+}
	110	+
	111	+template <typename T, typename U>
	112	+static inline aclError aclrtMemcpyBatch(T *dsts, size_t destMaxs, U *srcs, size_t sizes,
	113	+ size_t numBatches, aclrtMemcpyBatchAttr *attrs,
	114	+ size_t attrsIndexes, size_t numAttrs, size_t failIndex = nullptr)
	115	+{
	116	+ (void)failIndex;
	117	+ return aclrtMemcpyBatchV2(reinterpret_cast<void >(dsts), destMaxs, reinterpret_cast<void >(srcs),
	118	+ sizes, numBatches, attrs, attrsIndexes, numAttrs);
	119	+}
	120	+
	121	+template <typename T, typename U>
	atomgit-bot5月8日 🚨 aclrtMemcpyBatchAsync 无限递归调用导致崩溃第三个 aclrtMemcpyBatchAsync 重载（带 failIndex 参数的版本）在第120行调用自身而非 aclrtMemcpyBatchAsyncV2。函数签名：`aclrtMemcpyBatchAsync(T *dsts, ..., size_t failIndex, aclrtStream stream)`，在函数体内 return 语句中再次调用 `aclrtMemcpyBatchAsync(...)`，这是无限递归，会导致栈溢出或编译器报错。应该调用 V2 版本的函数。参考依据类别: bug 置信度: 100%
	122	+static inline aclError aclrtMemcpyBatchAsync(T *dsts, size_t destMaxs, U *srcs, size_t sizes,
	123	+ size_t numBatches, aclrtMemcpyBatchAttr attr, aclrtStream stream)
	124	+{
	125	+ aclrtMemcpyBatchAttr attrs[1] = {attr};
	126	+ size_t attrsIndexes[1] = {0};
	127	+ return aclrtMemcpyBatchAsyncV2(reinterpret_cast<void >(dsts), destMaxs, reinterpret_cast<void >(srcs),
	128	+ sizes, numBatches, attrs, attrsIndexes, 1, stream);
	129	+}
	130	+
	131	+template <typename T, typename U>
	132	+static inline aclError aclrtMemcpyBatchAsync(T *dsts, size_t destMaxs, U *srcs, size_t sizes,
	133	+ size_t numBatches, aclrtMemcpyBatchAttr *attrs,
	134	+ size_t *attrsIndexes, size_t numAttrs, aclrtStream stream)
	135	+{
	136	+ return aclrtMemcpyBatchAsyncV2(reinterpret_cast<void >(dsts), destMaxs, reinterpret_cast<void >(srcs),
	137	+ sizes, numBatches, attrs, attrsIndexes, numAttrs, stream);
	138	+}
	139	+
	140	+template <typename T, typename U>
	141	+static inline aclError aclrtMemcpyBatchAsync(T *dsts, size_t destMaxs, U *srcs, size_t sizes,
	142	+ size_t numBatches, aclrtMemcpyBatchAttr attr,
	143	+ size_t *failIndex, aclrtStream stream)
	144	+{
	145	+ aclrtMemcpyBatchAttr attrs[1] = {attr};
	146	+ size_t attrsIndexes[1] = {0};
	147	+ return ::aclrtMemcpyBatchAsync(reinterpret_cast<void >(dsts), destMaxs, reinterpret_cast<void >(srcs),
	148	+ sizes, numBatches, attrs, attrsIndexes, 1, failIndex, stream);
	149	+}
	150	+
	151	+template <typename T, typename U>
	152	+static inline aclError aclrtMemcpyBatchAsync(T *dsts, size_t destMaxs, U *srcs, size_t sizes,
	153	+ size_t numBatches, aclrtMemcpyBatchAttr *attrs,
	154	+ size_t attrsIndexes, size_t numAttrs, size_t failIndex, aclrtStream stream)
	155	+{
	156	+ return ::aclrtMemcpyBatchAsync(reinterpret_cast<void >(dsts), destMaxs, reinterpret_cast<void >(srcs),
	157	+ sizes, numBatches, attrs, attrsIndexes, numAttrs, failIndex, stream);
	158	+}
	159	+
	160	+template <typename T>
	161	+static inline aclError aclrtPointerGetAttributes(const T ptr, aclrtPtrAttributes attributes)
	162	+{
	163	+ return aclrtPointerGetAttributes(static_cast<const void *>(ptr), attributes);
	164	+}
	165	+
	166	+template <typename T>
	167	+static inline aclError aclrtHostRegister(T ptr, uint64_t size, aclrtHostRegisterType type, T *devPtr)
	168	+{
	169	+ return aclrtHostRegister(static_cast<void >(ptr), size, type, reinterpret_cast<void *>(devPtr));
	170	+}
	171	+
	172	+template <typename T>
	173	+static inline aclError aclrtHostRegister(T *ptr, uint64_t size, uint32_t flag)
	174	+{
	175	+ return aclrtHostRegisterV2(static_cast<void *>(ptr), size, flag);
	176	+}
	177	+
	178	+template <typename T>
	179	+static inline aclError aclrtHostGetDevicePointer(T pHost, T *pDevice, uint32_t flag)
	180	+{
	181	+ return aclrtHostGetDevicePointer(static_cast<void >(pHost), reinterpret_cast<void *>(pDevice), flag);
	182	+}
	183	+
	184	+template <typename T>
	185	+static inline aclError aclrtHostUnregister(T *ptr)
	186	+{
	187	+ return aclrtHostUnregister(static_cast<void *>(ptr));
	188	+}
	189	+
	190	+template <typename T>
	191	+static inline aclError aclrtMemAllocManaged(T **devPtr, size_t size, uint32_t flags = ACL_RT_MEM_ATTACH_GLOBAL)
	192	+{
	193	+ return aclrtMemAllocManaged(reinterpret_cast<void **>(devPtr), static_cast<uint64_t>(size), flags);
	194	+}
	195	+
	196	+template <typename T>
	197	+static inline aclError aclrtMemManagedPrefetchAsync(const T *ptr, size_t size,
	198	+ aclrtMemManagedLocation location, uint32_t flags, aclrtStream stream)
	199	+{
	200	+ return aclrtMemManagedPrefetchAsync(static_cast<const void *>(ptr), size, location, flags, stream);
	201	+}
	202	+
	203	+template <typename T>
	204	+static inline aclError aclrtMemManagedPrefetchBatchAsync(const T *ptrs, size_t sizes, size_t count,
	205	+ aclrtMemManagedLocation prefetchLoc,
	206	+ uint64_t flags, aclrtStream stream)
	207	+{
	208	+ aclrtMemManagedLocation prefetchLocs[1] = {prefetchLoc};
	209	+ size_t prefetchLocIdxs[1] = {0};
	210	+ return aclrtMemManagedPrefetchBatchAsync(reinterpret_cast<const void **>(ptrs), sizes, count,
	211	+ prefetchLocs, prefetchLocIdxs, 1, flags, stream);
	212	+}
	213	+
	214	+template <typename T>
	215	+static inline aclError aclrtMemManagedPrefetchBatchAsync(const T *ptrs, size_t sizes, size_t count,
	216	+ aclrtMemManagedLocation *prefetchLocs,
	217	+ size_t *prefetchLocIdxs, size_t numPrefetchLocs,
	218	+ uint64_t flags, aclrtStream stream)
	219	+{
	220	+ return aclrtMemManagedPrefetchBatchAsync(reinterpret_cast<const void **>(ptrs), sizes, count,
	221	+ prefetchLocs, prefetchLocIdxs, numPrefetchLocs, flags, stream);
	222	+}
	223	+
	224	+#endif // __cplusplus
	225	+
	226	+#endif // INC_EXTERNAL_ACL_ACL_RT_API_H_

Mstub/gen_stubapi.py+2-0

	@@ -67,6 +67,8 @@ def collect_header_files(path):
67	file_path = os.path.join(root, file)	67	file_path = os.path.join(root, file)
68	file_path = file_path.replace('\\', '/')	68	file_path = file_path.replace('\\', '/')
69	prof_headers.append(file_path)	69	prof_headers.append(file_path)
		70	+ elif file == "acl_rt_api.h":
		71	+ continue # skip C++ API header, only process acl_rt.h (pure C API)
70	else:	72	else:
71	file_path = os.path.join(root, file)	73	file_path = os.path.join(root, file)
72	file_path = file_path.replace('\\', '/')	74	file_path = file_path.replace('\\', '/')

Mtests/ut/acl/testcase/acl_runtime_unittest.cpp+225-0

	@@ -15,6 +15,7 @@
15	#include "acl/error_codes/rt_error_codes.h"	15	#include "acl/error_codes/rt_error_codes.h"
16	#include "common/log_inner.h"	16	#include "common/log_inner.h"
17	#include "acl/acl_rt.h"	17	#include "acl/acl_rt.h"
		18	+#include "acl/acl_rt_api.h"
18	#include "acl_rt_impl_base.h"	19	#include "acl_rt_impl_base.h"
19		20
20	#include "set_device_vxx.h"	21	#include "set_device_vxx.h"
	@@ -7829,4 +7830,228 @@ TEST_F(UTEST_ACL_Runtime, aclrtMemMapSelectedLinkTest)
7829	.WillOnce(Return(ACL_RT_SUCCESS));	7830	.WillOnce(Return(ACL_RT_SUCCESS));
7830	ret = aclrtMemMapSelectedLink((void )mem1, size, (void )mem2, linkIdx);	7831	ret = aclrtMemMapSelectedLink((void )mem1, size, (void )mem2, linkIdx);
7831	EXPECT_EQ(ret, ACL_RT_SUCCESS);	7832	EXPECT_EQ(ret, ACL_RT_SUCCESS);
		7833	+}
		7834	+
		7835	+TEST_F(UTEST_ACL_Runtime, aclrtApiHeaderIncludeTest)
		7836	+{
		7837	+ // 验证 acl_rt_api.h 头文件包含正确，模板函数可编译
		7838	+
		7839	+ // 测试模板函数签名编译通过
		7840	+ float *devPtr = nullptr;
		7841	+ size_t size = 100;
		7842	+
		7843	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMalloc(_, _, _, _, _))
		7844	+ .WillOnce(Return(RT_ERROR_NONE));
		7845	+ aclError ret = aclrtMalloc(&devPtr, size);
		7846	+ EXPECT_EQ(ret, ACL_SUCCESS);
		7847	+
		7848	+ // 测试同步接口编译通过
		7849	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceSynchronizeWithTimeout(_))
		7850	+ .WillOnce(Return(RT_ERROR_NONE));
		7851	+ ret = aclrtSynchronizeDevice(5000);
		7852	+ EXPECT_EQ(ret, ACL_SUCCESS);
		7853	+}
		atomgit-bot5月8日 ⚠️ 空测试用例无实际验证逻辑 aclrtApiHeaderIncludeTest 仅创建一个变量并检查其初始值 ACL_SUCCESS，该测试没有实际验证任何功能，既未调用 API 也未检查头文件包含的正确性，属于无效测试。参考依据类别: general 置信度: 100%
		7854	+
		7855	+TEST_F(UTEST_ACL_Runtime, aclrtTemplateMallocTest)
		7856	+{
		7857	+ float *devPtr = nullptr;
		7858	+ size_t size = 100;
		7859	+
		7860	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMalloc(_, _, _, _, _))
		7861	+ .WillOnce(Return(RT_ERROR_NONE));
		7862	+ aclError ret = aclrtMalloc(&devPtr, size);
		7863	+ EXPECT_EQ(ret, ACL_SUCCESS);
		7864	+
		7865	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMalloc(_, _, _, _, _))
		7866	+ .WillOnce(Return(RT_ERROR_NONE));
		7867	+ ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE_FIRST);
		7868	+ EXPECT_EQ(ret, ACL_SUCCESS);
		atomgit-bot5月8日 💡 aclrtTemplateMallocTest 缺少失败路径测试测试仅覆盖 rtsMalloc 返回 RT_ERROR_NONE 的成功场景，缺少对返回错误码时的处理验证。此外，第二个测试调用使用显式内存策略但复用同一指针 devPtr，虽在 Mock 环境下安全，但语义上可能造成困惑。参考依据类别: general 置信度: 90%
		7869	+}
		7870	+
		7871	+TEST_F(UTEST_ACL_Runtime, aclrtTemplateMallocHostTest)
		7872	+{
		7873	+ float *hostPtr = nullptr;
		7874	+ size_t size = 100;
		7875	+
		7876	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMallocHost(_, _, _))
		7877	+ .WillOnce(Return(RT_ERROR_NONE));
		atomgit-bot5月8日 💡 aclrtTemplateMallocHostTest 缺少失败路径测试仅测试成功路径，缺少 rtsMallocHost 返回错误码时的测试覆盖。参考依据类别: general 置信度: 90%
		7878	+ aclError ret = aclrtMallocHost(&hostPtr, size);
		7879	+ EXPECT_EQ(ret, ACL_SUCCESS);
		7880	+}
		7881	+
		7882	+TEST_F(UTEST_ACL_Runtime, aclrtTemplateMemcpyTest)
		7883	+{
		7884	+ float src[10] = {1.0f};
		7885	+ float dst[10] = {0.0f};
		7886	+
		7887	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy(_, _, _, _, _))
		atomgit-bot5月8日 💡 aclrtTemplateMemcpyTest 缺少边界和失败测试仅测试成功路径，缺少：1) 源/目标指针为 nullptr 的边界测试；2) size=0 的边界测试；3) rtMemcpy 返回错误码时的失败路径。参考依据类别: general 置信度: 90%
		7888	+ .WillOnce(Return(RT_ERROR_NONE));
		7889	+ aclError ret = aclrtMemcpy(dst, 10 * sizeof(float), src, 10 * sizeof(float), ACL_MEMCPY_HOST_TO_HOST);
		7890	+ EXPECT_EQ(ret, ACL_SUCCESS);
		7891	+}
		7892	+
		7893	+TEST_F(UTEST_ACL_Runtime, aclrtTemplateMemcpyAsyncTest)
		7894	+{
		7895	+ float src = reinterpret_cast<float >(0x01);
		7896	+ float dst = reinterpret_cast<float >(0x02);
		7897	+ aclrtStream stream = reinterpret_cast<aclrtStream>(0x03);
		7898	+
		7899	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpyAsync(_, _, _, _, _, _))
		atomgit-bot5月8日 💡 aclrtTemplateMemcpyAsyncTest 使用伪造指针缺少语义验证使用 reinterpret_cast 创建的伪造指针地址（0x01, 0x02, 0x03），虽然可以编译通过，但测试无法验证实际的内存拷贝语义是否正确。建议补充集成测试或使用真实的内存分配。参考依据类别: general 置信度: 90%
		7900	+ .WillOnce(Return(RT_ERROR_NONE));
		7901	+ aclError ret = aclrtMemcpyAsync(dst, 10 * sizeof(float), src, 10 * sizeof(float), ACL_MEMCPY_HOST_TO_DEVICE, stream);
		7902	+ EXPECT_EQ(ret, ACL_SUCCESS);
		7903	+}
		7904	+
		7905	+TEST_F(UTEST_ACL_Runtime, aclrtTemplateMemcpy2dTest)
		7906	+{
		7907	+ float src = reinterpret_cast<float >(0x01);
		7908	+ float dst = reinterpret_cast<float >(0x02);
		7909	+ size_t dpitch = 2;
		7910	+ size_t spitch = 2;
		7911	+ size_t width = 1;
		7912	+ size_t height = 2;
		7913	+
		7914	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy2d(_, _, _, _, _, _, _))
		7915	+ .WillOnce(Return(RT_ERROR_NONE));
		7916	+ aclError ret = aclrtMemcpy2d(dst, dpitch, src, spitch, width, height, ACL_MEMCPY_HOST_TO_DEVICE);
		7917	+ EXPECT_EQ(ret, ACL_SUCCESS);
		7918	+}
		7919	+
		7920	+TEST_F(UTEST_ACL_Runtime, aclrtTemplateMemcpy2dAsyncTest)
		7921	+{
		7922	+ float src = reinterpret_cast<float >(0x01);
		7923	+ float dst = reinterpret_cast<float >(0x02);
		7924	+ aclrtStream stream = reinterpret_cast<aclrtStream>(0x03);
		7925	+ size_t dpitch = 2;
		7926	+ size_t spitch = 2;
		7927	+ size_t width = 1;
		7928	+ size_t height = 2;
		7929	+
		7930	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy2dAsync(_, _, _, _, _, _, _, _))
		7931	+ .WillOnce(Return(RT_ERROR_NONE));
		7932	+ aclError ret = aclrtMemcpy2dAsync(dst, dpitch, src, spitch, width, height, ACL_MEMCPY_HOST_TO_DEVICE, stream);
		7933	+ EXPECT_EQ(ret, ACL_SUCCESS);
		7934	+}
		7935	+
		7936	+TEST_F(UTEST_ACL_Runtime, aclrtOverloadSynchronizeDeviceTest)
		7937	+{
		7938	+ int32_t timeout = 100;
		7939	+
		7940	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceSynchronizeWithTimeout(_))
		7941	+ .WillOnce(Return(RT_ERROR_NONE));
		7942	+ aclError ret = aclrtSynchronizeDevice(timeout);
		7943	+ EXPECT_EQ(ret, ACL_SUCCESS);
		7944	+
		7945	+ timeout = -2;
		7946	+ ret = aclrtSynchronizeDevice(timeout);
		7947	+ EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
		7948	+}
		7949	+
		7950	+TEST_F(UTEST_ACL_Runtime, aclrtOverloadSynchronizeStreamTest)
		7951	+{
		7952	+ aclrtStream stream = reinterpret_cast<aclrtStream>(0x01);
		7953	+ int32_t timeout = 100;
		7954	+
		7955	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamSynchronizeWithTimeout(_, _))
		7956	+ .WillOnce(Return(RT_ERROR_NONE));
		7957	+ aclError ret = aclrtSynchronizeStream(stream, timeout);
		7958	+ EXPECT_EQ(ret, ACL_SUCCESS);
		7959	+}
		7960	+
		7961	+TEST_F(UTEST_ACL_Runtime, aclrtOverloadSynchronizeEventTest)
		7962	+{
		7963	+ aclrtEvent event = reinterpret_cast<aclrtEvent>(0x01);
		7964	+ int32_t timeout = 100;
		7965	+
		7966	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventSynchronizeWithTimeout(_, _))
		7967	+ .WillOnce(Return(RT_ERROR_NONE));
		7968	+ aclError ret = aclrtSynchronizeEvent(event, timeout);
		7969	+ EXPECT_EQ(ret, ACL_SUCCESS);
		7970	+}
		7971	+
		7972	+TEST_F(UTEST_ACL_Runtime, aclrtOverloadStreamWaitEventTest)
		atomgit-bot5月8日 ⚠️ aclrtSynchronizeDevice 重载缺少失败路径测试 timeout=-2 时调用函数期望返回 ACL_ERROR_RT_PARAM_INVALID，但该断言前未设置 Mock 期望。如果参数校验在底层调用之前进行（不经过 Mock），则测试有效；否则可能导致未定义行为。此外缺少其他边界值测试（如 timeout=0、timeout=-1 等）。参考依据类别: general 置信度: 95%
		7973	+{
		7974	+ aclrtStream stream = reinterpret_cast<aclrtStream>(0x01);
		7975	+ aclrtEvent event = reinterpret_cast<aclrtEvent>(0x02);
		7976	+ int32_t timeout = 100;
		7977	+
		7978	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsEventWait(_, _, _))
		7979	+ .WillOnce(Return(RT_ERROR_NONE));
		7980	+ aclError ret = aclrtStreamWaitEvent(stream, event, timeout);
		7981	+ EXPECT_EQ(ret, ACL_SUCCESS);
		7982	+}
		7983	+
		7984	+TEST_F(UTEST_ACL_Runtime, aclrtOverloadCreateEventTest)
		7985	+{
		7986	+ aclrtEvent event = nullptr;
		7987	+ uint32_t flag = 0x00000008u;
		7988	+
		7989	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventCreateExWithFlag(_, _))
		7990	+ .WillOnce(Return(RT_ERROR_NONE));
		7991	+ aclError ret = aclrtCreateEvent(&event, flag);
		7992	+ EXPECT_EQ(ret, ACL_SUCCESS);
		7993	+}
		7994	+
		7995	+TEST_F(UTEST_ACL_Runtime, aclrtTemplatePointerGetAttributesTest)
		7996	+{
		7997	+ float ptr = reinterpret_cast<float >(0x01);
		7998	+ aclrtPtrAttributes attributes;
		7999	+
		8000	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsPointerGetAttributes(_, _))
		8001	+ .WillOnce(Return(RT_ERROR_NONE));
		8002	+ aclError ret = aclrtPointerGetAttributes(ptr, &attributes);
		8003	+ EXPECT_EQ(ret, ACL_SUCCESS);
		8004	+}
		atomgit-bot5月8日 💡 aclrtTemplateHostRegisterTest 两个重载版本测试混合同一个测试函数内测试了两个不同的重载版本（带 devPtr 输出参数和不带），虽然可以工作，但建议拆分为独立的测试用例以提高测试隔离性和可维护性。参考依据类别: general 置信度: 90%
		8005	+
		8006	+TEST_F(UTEST_ACL_Runtime, aclrtTemplateHostRegisterTest)
		8007	+{
		8008	+ float hostPtr = reinterpret_cast<float >(0x01);
		8009	+ float *devPtr = nullptr;
		8010	+
		8011	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsHostRegister(_, _, _, _))
		8012	+ .WillOnce(Return(RT_ERROR_NONE));
		8013	+ aclError ret = aclrtHostRegister(hostPtr, 100, ACL_HOST_REGISTER_MAPPED, &devPtr);
		8014	+ EXPECT_EQ(ret, ACL_SUCCESS);
		8015	+
		8016	+ uint32_t flag = 0;
		8017	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtHostRegisterV2(_, _, _))
		8018	+ .WillOnce(Return(RT_ERROR_NONE));
		8019	+ ret = aclrtHostRegister(hostPtr, 100, flag);
		8020	+ EXPECT_EQ(ret, ACL_SUCCESS);
		8021	+}
		8022	+
		8023	+TEST_F(UTEST_ACL_Runtime, aclrtTemplateHostGetDevicePointerTest)
		8024	+{
		8025	+ float hostPtr = reinterpret_cast<float >(0x01);
		8026	+ float *devPtr = nullptr;
		8027	+ uint32_t flag = 0;
		8028	+
		8029	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtHostGetDevicePointer(_, _, _))
		8030	+ .WillOnce(Return(RT_ERROR_NONE));
		8031	+ aclError ret = aclrtHostGetDevicePointer(hostPtr, &devPtr, flag);
		atomgit-bot5月8日 💡 aclrtTemplateMemAllocManagedTest 测试结构问题第一个测试调用没有 Mock 设置却依赖之前 WillRepeatedly 的遗留设置，虽然结果正确但不够清晰。建议每个测试用例独立设置自己的 Mock 期望，提高测试隔离性。参考依据类别: general 置信度: 85%
		8032	+ EXPECT_EQ(ret, ACL_SUCCESS);
		8033	+}
		8034	+
		8035	+TEST_F(UTEST_ACL_Runtime, aclrtTemplateHostUnregisterTest)
		8036	+{
		8037	+ float hostPtr = reinterpret_cast<float >(0x01);
		8038	+
		8039	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsHostUnregister(_))
		8040	+ .WillOnce(Return(RT_ERROR_NONE));
		8041	+ aclError ret = aclrtHostUnregister(hostPtr);
		8042	+ EXPECT_EQ(ret, ACL_SUCCESS);
		8043	+}
		8044	+
		8045	+TEST_F(UTEST_ACL_Runtime, aclrtTemplateMemAllocManagedTest)
		8046	+{
		8047	+ float *devPtr = nullptr;
		8048	+ size_t size = 100;
		8049	+
		8050	+ EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemAllocManaged(_, _, _, _))
		8051	+ .WillRepeatedly(Return(RT_ERROR_NONE));
		8052	+ aclError ret = aclrtMemAllocManaged(&devPtr, size);
		8053	+ EXPECT_EQ(ret, ACL_SUCCESS);
		8054	+
		8055	+ ret = aclrtMemAllocManaged(&devPtr, size, ACL_RT_MEM_ATTACH_GLOBAL);
		8056	+ EXPECT_EQ(ret, ACL_SUCCESS);
7832	}	8057	}