ReduceMax

产品支持情况

产品	是否支持
Ascend 950PR/Ascend 950DT	√
Atlas A3 训练系列产品/Atlas A3 推理系列产品	√
Atlas A2 训练系列产品/Atlas A2 推理系列产品	√
Atlas 200I/500 A2 推理产品	√
Atlas 推理系列产品 AI Core	√
Atlas 推理系列产品 Vector Core	x
Atlas 训练系列产品	√
Kirin X90	√
Kirin 9030	√

功能说明

头文件路径为："basic_api/kernel_operator_vec_reduce_intf.h"。

ReduceMax接口用于从所有输入数据中找出最大值和最大值索引。

ReduceMax计算过程如下图所示：首先，在每个repeat迭代中计算得到最大值和repeat内部索引，这些中间结果暂存于sharedTmpBuffer工作区中；然后，在中间结果的基础上继续按repeat迭代得到最终的最大值和最大值索引。需要注意的是，每次repeat迭代获取的最大值索引是repeat内部索引，返回最终结果时，需要根据迭代位置和repeat内部索引推导全量数据的最大值索引。

图 1 ReduceMax计算示意图

ReduceMax计算示意图

函数原型

tensor前n个数据计算：

C++

template <typename T>
__aicore__ inline void ReduceMax(const LocalTensor<T>& dst, const LocalTensor<T>& src, const LocalTensor<T>& sharedTmpBuffer, const int32_t count, bool calIndex = 0)

tensor高维切分计算：

mask逐bit模式：

C++

template <typename T>
__aicore__ inline void ReduceMax(const LocalTensor<T>& dst, const LocalTensor<T>& src, const LocalTensor<T>& sharedTmpBuffer, const uint64_t mask[], const int32_t repeatTime, const int32_t srcRepStride, bool calIndex = 0)

mask连续模式：

C++

template <typename T>
__aicore__ inline void ReduceMax(const LocalTensor<T>& dst, const LocalTensor<T>& src, const LocalTensor<T>& sharedTmpBuffer, const int32_t mask, const int32_t repeatTime, const int32_t srcRepStride, bool calIndex = 0)

参数说明

表 1 模板参数说明

参数名	描述
T	操作数数据类型。

表 2 参数说明

参数名称	输入/输出	含义
dst	输出	目的操作数。类型为LocalTensor，支持的TPosition为VECIN、VECCALC、VECOUT（存储位置为Unified Buffer）。
src	输入	源操作数。类型为LocalTensor，支持的TPosition为VECIN、VECCALC、VECOUT（存储位置为Unified Buffer）。
sharedTmpBuffer	输入	指令执行期间存储中间结果，用于内部计算所需操作空间，需特别注意空间大小。详情请参考关键特性说明。类型为LocalTensor，支持的TPosition为VECIN、VECCALC、VECOUT（存储位置为Unified Buffer）。
count	输入	参与计算的元素个数。关于该参数的具体说明请参考连续计算。最大处理的数据量不能超过UB大小限制。
mask/mask[]	输入	`mask`用于控制每次迭代内参与计算的源操作数。详细设置参考掩码概述。
repeatTime	输入	迭代次数。关于该参数的具体描述请参考高维切分。注：与高维切分中不同的是，`repeatTime`可以支持更大的取值范围，保证不超过int32_t的最大值即可。
srcRepStride	输入	源操作数相邻迭代间的地址步长，即源操作数每次迭代跳过的DataBlock数目。取值范围为[0, $2^{16}-1$]。
calIndex	输入	指定是否获取最大值的索引，bool类型，默认值为`false`，取值： • `true`：同时获取最大值和最大值索引。 • `false`：不获取索引，只获取最大值。

注：以上高维切分相关参数mask，repeatTime，srcRepStride请参考高维切分中的介绍。

数据类型

支持的数据类型如下：

Ascend 950PR/Ascend 950DT，支持int16_t、uint16_t、half、int32_t、uint32_t、float、int64_t、uint64_t。
Atlas A3 训练系列产品/Atlas A3 推理系列产品，支持half、float。
Atlas A2 训练系列产品/Atlas A2 推理系列产品，支持half、float。
Atlas 200I/500 A2 推理产品，支持half、float。
Atlas 推理系列产品 AI Core，支持half、float。
Atlas 训练系列产品，支持half。
Kirin X90，支持half、float。
Kirin 9030，支持half、float。

返回值说明

无

约束说明

源操作数及sharedTmpBuffer的地址对齐约束请参考通用地址对齐约束，起始地址需要32字节对齐；目的操作数的起始地址对齐约束请参考ReduceRepeat-表3。
操作数地址重叠约束请参考通用地址重叠约束。
需要使用sharedTmpBuffer的情况下，支持dst与sharedTmpBuffer地址重叠（通常情况下dst比sharedTmpBuffer所需的空间要小），此时sharedTmpBuffer必须满足所需空间要求，详情请参考关键特性说明。

针对如下型号，当mask=0或repeatTime=0时，不会执行归约操作，不会对目的操作数进行写入，该接口将被视为NOP（空操作）。
- Atlas A3 训练系列产品/Atlas A3 推理系列产品
- Atlas A2 训练系列产品/Atlas A2 推理系列产品

srcRepStride取值范围为[0, $2^{16}-1$]，需要结合UB的实际大小避免出现越界。
如果存在多个最大值，该指令会将最小索引写入目的操作数。
dst结果存储顺序为最大值，最大值索引，若不需要索引，只会存储最大值。
索引按操作数的数据类型存储，读取索引需要将类型转换到整型。请参考ReduceRepeat关键特性说明。
当输入类型是half的时候，只支持获取最大不超过65535（uint16_t能表示的最大值）的索引值。
针对Ascend 950PR/Ascend 950DT，int64_t/uint64_t数据类型仅支持tensor前n个数据计算接口。
对于Ascend 950PR/Ascend 950DT，因接口内部算法实现不同，无需使用sharedTmpBuffer，可以直接传入src或者任意大小的sharedTmpBuffer。

针对如下型号，需要使用sharedTmpBuffer。
- Atlas A3 训练系列产品/Atlas A3 推理系列产品
- Atlas A2 训练系列产品/Atlas A2 推理系列产品
- Atlas 200I/500 A2 推理产品
- Atlas 推理系列产品 AI Core
- Atlas 训练系列产品
- Kirin X90
- Kirin 9030

关键特性说明

索引值需要强制类型转换，详情请参考ReduceRepeat关键特性说明。

sharedTmpBuffer所需空间设置：

sharedTmpBuffer空间需要开发者申请并传入，根据是否需要获取索引，sharedTmpBuffer空间计算方式不同：需要返回索引的情况下，需要把每轮计算所需的空间进行累加，同时每轮计算的空间都要考虑UB空间32字节对齐的要求；无需返回索引的情况下，只需要提供第一轮计算所需的空间并满足32字节对齐要求即可，后续的轮次可以直接使用这块空间，此时不需要推导索引的过程，所以之前轮次的中间数据可以直接覆盖。计算所需空间的算法如下：

无需返回最大值索引：

C++

int firstMaxRepeat = repeatTime; // 对 于tensor高 维 切 分 计 算 接 口，firstMaxRepeat就 是repeatTime；对 于tensor前n个 数 据 计 算 接 口，firstMaxRepeat为count/elementsPerRepeat
int iter1OutputCount = firstMaxRepeat * 2; // 第 一 轮 操 作 产 生 的 元 素 个 数，无 论 开 发 者 是 否 需 要 返 回 索 引，底 层 指 令 都 会 返 回 索 引，所 以 这 里 要 为 索 引 预 留 空 间，产 生 的 元 素 个 数 为repeat次 数*2
int iter1AlignEnd = DivCeil(iter1OutputCount, elementsPerBlock) * elementsPerBlock; // 第 一 轮 产 生 的 元 素 个 数 按 照datablock(32字 节)向 上 对 齐
int finalWorkLocalNeedSize = iter1AlignEnd; // 第 一 轮 计 算 完 成 后，后 续 可 能 还 需 要 多 轮 迭 代，但 是 可 以 复 用 同 一 块 空 间，所 以 第 一 轮 计 算 所 需 的 空 间 就 是 最 终sharedTmpBuffer所 需 的 空 间 大 小

需要返回最大值索引：

C++

int firstMaxRepeat = repeatTime; 
// 对 于tensor高 维 切 分 计 算 接 口，firstMaxRepeat就 是repeatTime；对 于tensor前n个 数 据 计 算 接 口，firstMaxRepeat为count/elementsPerRepeat
int iter1OutputCount = firstMaxRepeat * 2;                                            // 第 一 轮 操 作 产 生 的 元 素 个 数
int iter2AlignStart = RoundUp(iter1OutputCount, elementsPerBlock) * elementsPerBlock; // 第 二 轮 操 作 起 始 位 置 偏 移，即 第 一 轮 产 生 的 元 素 个 数 按 照datablock(32字 节)向 上 对 齐 的 结 果
// 第 一 轮 计 算 完 成 后，后 续 可 能 还 需 要 多 轮 迭 代，此 时 不 可 以 复 用 同 一 块 空 间，因 为 第 一 轮 的 中 间 结 果 索 引 还 需 要 再 进 行 使 用，所 以 需 要 继 续 准 备 后 续 轮 次 的 空 间
int iter2OutputCount = RoundUp(iter1OutputCount, elementsPerRepeat) * 2;              // 第 二 轮 操 作 产 生 的 元 素 个 数
int iter2AlignEnd = RoundUp(iter2OutputCount, elementsPerBlock) * elementsPerBlock;   // 第 二 轮 产 生 的 元 素 个 数 按 照datablock(32字 节)向 上 对 齐 的 结 果
int finalWorkLocalNeedSize = iter2AlignStart + iter2AlignEnd;                         // 第 二 轮 结 束 即 可 获 取 最 大 值 和 索 引 时，最 终sharedTmpBuffer所 需 的 空 间 大 小
if (iter2OutputCount > 2) {                                                           // 第 二 轮 操 作 产 生 的 元 素 个 数 大 于2时，需 要 继 续 进 行 第 三 轮 操 作
    int iter3AlignStart = iter2AlignEnd;                                              // 第 三 轮 操 作 相 对 第 二 轮 输 出 空 间 的 起 始 位 置 偏 移
    int iter3OutputCount = RoundUp(iter2OutputCount, elementsPerRepeat) * 2;          // 第 三 轮 操 作 产 生 的 元 素 个 数
    int iter3AlignEnd = RoundUp(iter3OutputCount, elementsPerBlock) * elementsPerBlock; // 第 三 轮 产 生 的 元 素 个 数 按 照datablock(32字 节)向 上 对 齐 的 结 果
    finalWorkLocalNeedSize = iter2AlignStart + iter3AlignStart + iter3AlignEnd;       // 最 终sharedTmpBuffer所 需 的 空 间 大 小
}

以上计算出来的最终的空间大小单位是元素个数，若转成Bytes数表示为finalWorkLocalNeedSize * typeSize(Bytes)。

说明

开发者为了节省地址空间，可以选择sharedTmpBuffer空间复用源操作数的空间。此时因为sharedTmpBuffer需要的最小空间一定小于源操作数的空间，所以无需关注和计算最小空间。

调用示例

详细示例请参考ReduceMax样例。

tensor高维切分计算样例-mask连续模式：

C++

// dstLocal,srcLocal和sharedTmpBuffer均 为half类 型,srcLocal的 计 算 数 据 量 为8320,并 且 连 续 排 布，需 要 索 引 值，使 用tensor高 维 切 分 计 算 接 口，设 定repeatTime为65，mask为 全 部 元 素 参 与 计 算
int32_t mask = 128;
AscendC::ReduceMax<half>(dstLocal, srcLocal, sharedTmpBuffer, mask, 65, 8, true);

tensor高维切分计算样例-mask逐bit模式：

C++

// dstLocal,srcLocal和sharedTmpBuffer均 为half类 型,srcLocal的 计 算 数 据 量 为8320,并 且 连 续 排 布，需 要 索 引 值，使 用tensor高 维 切 分 计 算 接 口，设 定repeatTime为65,mask为 全 部 元 素 参 与 计 算
uint64_t mask[2] = { 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF };
AscendC::ReduceMax<half>(dstLocal, srcLocal, sharedTmpBuffer, mask, 65, 8, true);

tensor前n个数据计算样例：

C++

// dstLocal,srcLocal和sharedTmpBuffer均 为half类 型,srcLocal的 计 算 数 据 量 为8320,并 且 连 续 排 布，需 要 索 引 值，使 用tensor前n个 数 据 计 算 接 口
AscendC::ReduceMax<half>(dstLocal, srcLocal, sharedTmpBuffer, 8320, true);

sharedTmpBuffer空间计算示例：

C++

// ReduceMax接 口sharedTmpBuffer计 算 示 例 一：
// dstLocal,srcLocal和sharedTmpBuffer均 为half类 型,srcLocal的 计 算 数 据 量 为8320, 使 用tensor高 维 切 分 计 算 接 口, repeatTime为65, mask为128,需 要 索 引 值
// tensor高 维 切 分 计 算 接 口 调 用 示 例 为：
AscendC::ReduceMax<half>(dstLocal, srcLocal, sharedTmpBuffer, 128, 65, 8, true);
// 此 时sharedTmpBuffer所 需 的 最 小 空 间 计 算 过 程 为：
int RoundUp(int a, int b)
{
    return (a + b - 1) / b;
}
int typeSize = 2;
int elementsPerBlock = 32 / typeSize = 16;
int elementsPerRepeat = 256 / typeSize = 128;
int firstMaxRepeat = repeatTime;
int iter1OutputCount = firstMaxRepeat * 2 = 130;                                          // 第 一 轮 操 作 产 生 的 元 素 个 数
int iter2AlignStart = RoundUp(iter1OutputCount, elementsPerBlock)*elementsPerBlock = 144; // 对 第 一 轮 操 作 输 出 个 数 向 上 取 整
int iter2OutputCount = RoundUp(iter1OutputCount, elementsPerRepeat)*2 = 4;                // 第 二 轮 操 作 产 生 的 元 素 个 数
int iter3AlignStart = RoundUp(iter2OutputCount, elementsPerBlock)*elementsPerBlock = 16;  // 对 第 二 轮 操 作 输 出 个 数 向 上 取 整
int iter3OutputCount = RoundUp(iter2OutputCount, elementsPerRepeat)*2 = 2;                // 第 三 轮 操 作 产 生 的 元 素 个 数
int iter3AlignEnd = RoundUp(iter3OutputCount, elementsPerBlock) * elementsPerBlock = 16;  // 第 三 轮 产 生 的 元 素 个 数 做 向 上 取 整
// 最 终sharedTmpBuffer所 需 的 最 小 空 间 为iter2AlignStart + iter3AlignStart + iter3AlignEnd = 144 + 16 + 16 = 176 ,也 就 是352Bytes
// ReduceMax接 口sharedTmpBuffer计 算 示 例 二：
// dstLocal,srcLocal和sharedTmpBuffer均 为half类 型,srcLocal的 计 算 数 据 量 为32640, 使 用tensor高 维 切 分 计 算 接 口,repeatTime为255, mask为128,需 要 索 引 值
// tensor高 维 切 分 计 算 接 口 调 用 示 例 为：
AscendC::ReduceMax<half>(dstLocal, srcLocal, sharedTmpBuffer, 128, 255, 8, true);
// 此 时sharedTmpBuffer所 需 的 最 小 空 间 计 算 过 程 为：
int typeSize = 2;
int elementsPerBlock = 32 / typeSize = 16;
int elementsPerRepeat = 256 / typeSize = 128;
int firstMaxRepeat = repeatTime;
int iter1OutputCount = firstMaxRepeat * 2 = 510;                                          // 第 一 轮 操 作 产 生 的 元 素 个 数
int iter2AlignStart = RoundUp(iter1OutputCount, elementsPerBlock)*elementsPerBlock = 512; // 对 第 一 轮 操 作 输 出 个 数 向 上 取 整
int iter2OutputCount = RoundUp(iter1OutputCount, elementsPerRepeat)*2 = 8;                // 第 二 轮 操 作 产 生 的 元 素 个 数
int iter3AlignStart = RoundUp(iter2OutputCount, elementsPerBlock)*elementsPerBlock = 16;  // 对 第 二 轮 操 作 输 出 个 数 向 上 取 整
int iter3OutputCount = RoundUp(iter2OutputCount, elementsPerRepeat)*2 = 2;                // 第 三 轮 操 作 产 生 的 元 素 个 数
int iter3AlignEnd = RoundUp(iter3OutputCount, elementsPerBlock) * elementsPerBlock = 16;  // 第 三 轮 产 生 的 元 素 个 数 做 向 上 取 整
// 需 要 的 空 间 为iter2AlignStart + iter3AlignStart + iter3AlignEnd = 512 + 16 + 16 = 544 ,也 就 是1088Bytes
// ReduceMax接 口sharedTmpBuffer计 算 示 例 三：
// dstLocal,srcLocal和sharedTmpBuffer均 为half类 型,srcLocal的 计 算 数 据 量 为65408,使 用tensor前n个 数 据 计 算 接 口,count=65408,需 要 索 引 值
// tensor前n个 数 据 计 算 接 口 调 用 示 例 为：
AscendC::ReduceMax<half>(dstLocal, srcLocal, sharedTmpBuffer, 65408, true);
// 此 时sharedTmpBuffer所 需 的 最 小 空 间 计 算 过 程 为：
int typeSize = 2;
int elementsPerBlock = 32 / typeSize = 16;
int elementsPerRepeat = 256 / typeSize = 128;
int firstMaxRepeat = count / elementsPerRepeat = 511;
int iter1OutputCount = firstMaxRepeat * 2 = 1022;                                          // 第 一 轮 操 作 产 生 的 元 素 个 数
int iter2AlignStart = RoundUp(iter1OutputCount, elementsPerBlock)*elementsPerBlock = 1024; // 对iter1OutputCount输 出 个 数 向 上 取 整
int iter2OutputCount = RoundUp(iter1OutputCount, elementsPerRepeat)*2 = 16;                // 第 二 轮 操 作 产 生 的 元 素 个 数
int iter3AlignStart = RoundUp(iter2OutputCount, elementsPerBlock)*elementsPerBlock = 16;   // 对iter2OutputCount输 出 个 数 向 上 取 整
int iter3OutputCount = RoundUp(iter2OutputCount, elementsPerRepeat)*2 = 2;                 // 第 三 轮 操 作 产 生 的 元 素 个 数
int iter3AlignEnd = RoundUp(iter3OutputCount, elementsPerBlock) * elementsPerBlock = 16;   // 第 三 轮 产 生 的 元 素 个 数 做 向 上 取 整
// 需 要 的 空 间 为iter2AlignStart + iter3AlignStart + iter3AlignEnd = 1024 + 16 + 16 = 1056,也 就 是2112Bytes
// ReduceMax接 口sharedTmpBuffer计 算 示 例 四：
// dstLocal,srcLocal和sharedTmpBuffer均 为half类 型，srcLocal的 的 计 算 数 据 量 为512，使 用tensor高 维 切 分 计 算 接 口,repeatTime为4, mask为128,需 要 索 引 值
// tensor高 维 切 分 计 算 接 口 调 用 示 例 为：
AscendC::ReduceMax<half>(dstLocal, srcLocal, sharedTmpBuffer, 128, 4, 8, true);
// 此 时sharedTmpBuffer所 需 的 最 小 空 间 计 算 过 程 为：
int typeSize = 2;
int elementsPerBlock = 32 / typeSize = 16;
int elementsPerRepeat = 256 / typeSize = 128;
int firstMaxRepeat = repeatTime;
int iter1OutputCount = firstMaxRepeat * 2 = 8;                                           // 第 一 轮 操 作 产 生 的 元 素 个 数
int iter2AlignStart = RoundUp(iter1OutputCount, elementsPerBlock)*elementsPerBlock = 16; // 对iter1OutputCount输 出 个 数 向 上 取 整
int iter2OutputCount = RoundUp(iter1OutputCount, elementsPerRepeat)*2 = 2;               // 第 二 轮 操 作 产 生 的 元 素 个 数
// 本 用 例 中，由 于 第 二 轮 操 作 产 生 的 元 素 个 数 为2，即 第 二 轮 结 束 就 可 以 拿 到 最 大 值 和 其 索 引 值，因 此 需 要 的 空 间 为iter2AlignStart + RoundUp(iter2OutputCount, elementsPerBlock) * elementsPerBlock = 16 + 16 = 32，也 就 是64Bytes
// ReduceMax接 口sharedTmpBuffer计 算 示 例 五：
// dstLocal,srcLocal和sharedTmpBuffer均 为half类 型,srcLocal的 计 算 数 据 量count为65408,使 用tensor前n个 数 据 计 算 接 口,count=65408，不 需 要 索 引 值
// tensor前n个 数 据 计 算 接 口 调 用 示 例 为：
AscendC::ReduceMax<half>(dstLocal, srcLocal, sharedTmpBuffer, 65408, false);
// 此 时sharedTmpBuffer所 需 的 最 小 空 间 计 算 过 程 为：
int typeSize = 2;
int elementsPerBlock = 32 / typeSize = 16;
int elementsPerRepeat = 256 / typeSize = 128;
int firstMaxRepeat = count / elementsPerRepeat = 511;
int iter1OutputCount = firstMaxRepeat * 2 = 1022;                                          // 第 一 轮 操 作 产 生 的 元 素 个 数
int iter1AlignEnd = RoundUp(iter1OutputCount, elementsPerBlock) * elementsPerBlock = 1024; // 第 一 轮 产 生 的 元 素 个 数 做 向 上 取 整
// 由 于calIndex为false,因 此 最 终sharedTmpBuffer所 需 的 最 小 空 间 大 小 就 是 对 第 一 轮 产 生 元 素 做 向 上 取 整 后 的 结 果，此 处 就 是1024，也 就 是2048Bytes
// ReduceMax接 口sharedTmpBuffer计 算 示 例 六：
// dstLocal,srcLocal和sharedTmpBuffer均 为float类 型,srcLocal的 计 算 数 据 量 为8320, 使 用tensor高 维 切 分 计 算 接 口, repeatTime为130, mask为64,需 要 索 引 值
// tensor高 维 切 分 计 算 接 口 调 用 示 例 为：
AscendC::ReduceMax<float>(dstLocal, srcLocal, sharedTmpBuffer, 64, 130, 8, true);
// 此 时sharedTmpBuffer所 需 的 最 小 空 间 计 算 过 程 为：
int typeSize = 4;
int elementsPerBlock = 32 / typeSize = 8;
int elementsPerRepeat = 256 / typeSize = 64;
int firstMaxRepeat = repeatTime;
int iter1OutputCount = firstMaxRepeat * 2 = 260;                                          // 第 一 轮 操 作 产 生 的 元 素 个 数
int iter2AlignStart = RoundUp(iter1OutputCount, elementsPerBlock)*elementsPerBlock = 264; // 对 第 一 轮 操 作 输 出 个 数 向 上 取 整
int iter2OutputCount = RoundUp(iter1OutputCount, elementsPerRepeat)*2 = 10;               // 第 二 轮 操 作 产 生 的 元 素 个 数
int iter3AlignStart = RoundUp(iter2OutputCount, elementsPerBlock)*elementsPerBlock = 16;  // 对 第 二 轮 操 作 输 出 个 数 向 上 取 整
int iter3OutputCount = RoundUp(iter2OutputCount, elementsPerRepeat)*2 = 2;                // 第 三 轮 操 作 产 生 的 元 素 个 数
int iter3AlignEnd = RoundUp(iter3OutputCount, elementsPerBlock) * elementsPerBlock = 8;   // 第 三 轮 产 生 的 元 素 个 数 做 向 上 取 整
// 最 终sharedTmpBuffer所 需 的 最 小 空 间 就 是iter2AlignStart + iter3AlignStart + iter3AlignEnd = 264 + 16 + 8 = 288,也 就 是1152Bytes

tensor高维切分计算接口完整示例：

C++

#include "kernel_operator.h"

int srcDataSize = 512;
int mask = 128;
int repStride = 8;
int repeat = srcDataSize / mask;

// 初 始 化srcLocal 、dstLocal 、sharedTmpBuffer
AscendC::LocalTensor<half> srcLocal = inQueueSrc.DeQue<half>();
AscendC::LocalTensor<half> dstLocal = outQueueDst.AllocTensor<half>();
AscendC::LocalTensor<half> sharedTmpBuffer = workQueue.AllocTensor<half>();
// mask为128一 次 计 算128个 元 素,4次repeat计 算 完512个 数,calIndex为true，获 取 最 大 值 的 索 引
AscendC::ReduceMax<half>(dstLocal, srcLocal, sharedTmpBuffer, mask, repeat, repStride, true);
// 释 放Tensor
outQueueDst.EnQue<half>(dstLocal);
inQueueSrc.FreeTensor(srcLocal);
workQueue.FreeTensor(sharedTmpBuffer);

示例结果如下：

输入数据src_gm：
[0.4795 0.951 0.866 0.008545 0.8037 0.551 0.754 0.73 0.6035 0.251 0.4841 0.05914 0.9414 0.379 0.664 0.6914 0.9307 0.3853 0.4048 ... 0.4106 0.604 ]
输出数据dst_gm：
[0.9985, 6.8e-06] // 6.8e-06使用reinterpret_cast方法转换后为索引值114

tensor前n个数据计算接口完整调用示例：

C++

#include "kernel_operator.h"

int srcDataSize = 288;
// 初 始 化srcLocal 、dstLocal 、sharedTmpBuffer
AscendC::LocalTensor<half> srcLocal = inQueueSrc.DeQue<half>();
AscendC::LocalTensor<half> dstLocal = outQueueDst.AllocTensor<half>();
AscendC::LocalTensor<half> sharedTmpBuffer = workQueue.AllocTensor<half>();

// level2接 口 计 算 前288个 数，calIndex为true，获 取 最 大 值 的 索 引
AscendC::ReduceMax<half>(dstLocal, srcLocal, sharedTmpBuffer, srcDataSize, true);
// 释 放Tensor
outQueueDst.EnQue<half>(dstLocal);
inQueueSrc.FreeTensor(srcLocal);
workQueue.FreeTensor(sharedTmpBuffer);

示例结果如下：

输入数据src_gm：
[0.4778 0.5903 0.2433 0.698 0.1943 0.407 0.891 0.1766 0.5977 0.9473 0.6523 0.10913 0.0143 0.86 0.2366 0.625 0.3696 0.708 0.946 ... 0.262 ]
输出数据dst_gm：
[0.999, 1.38e-05] // 1.38e-05使用reinterpret_cast方法转换后为索引值232

2.4.2.1. DataCopy

2.4.3.1. 概 述

2.4.3.2. 矩 阵 计 算 分 形 介 绍

2.4.3.3. 矩 阵 计 算 的 搬 入

2.4.3.3.4. 矩 阵 数 据 搬 入 至L1 Buffer

2.4.3.3.5. 矩 阵 数 据 搬 入 至L0 Buffer

2.4.3.3.6. 辅 助 配 置 接 口

2.4.3.4. 数 据 搬 运

2.4.3.4.2. LoadData

2.4.3.5. 矩 阵 计 算

2.4.3.5.5. 关 键 特 性 说 明

2.4.3.5.6. 寄 存 器 配 置 说 明

2.4.3.6. 矩 阵 计 算 的 搬 出

2.4.3.6.10. L1到GM数 据 搬 运

2.4.3.6.11. 关 键 特 性 说 明

2.4.3.6.12. 寄 存 器 配 置 说 明

2.4.4.2. SIMD计 算 说 明

2.4.4.2.4. 掩 码

2.4.4.3. 数 据 搬 运

2.4.4.3.1. GM与UB数 据 搬 运

2.4.4.3.2. UB与UB数 据 搬 运

2.4.4.4. 基 础 算 术

2.4.4.5. 逻 辑 计 算

2.4.4.6. 复 合 计 算

2.4.4.7. 比 较 与 选 择

2.4.4.8. 类 型 转 换

2.4.4.8.1. 寄 存 器 配 置 说 明

2.4.4.9. 归 约 计 算

2.4.4.9.8. 寄 存 器 辅 助 接 口

2.4.4.10. 数 据 排 布 转 换

2.4.4.11. 数 据 填 充

2.4.4.12. 排 序 组 合（ISASI）

2.4.4.13. 离 散 与 聚 合

2.4.4.14. 掩 码 操 作

2.4.4.15. 数 据 重 排（ISASI）

2.4.5.1. 寄 存 器 数 据 类 型

2.4.5.3. Reg数 据 搬 运

2.4.5.4. MaskReg计 算

2.4.5.5. 基 础 算 术

2.4.5.6. 逻 辑 计 算

2.4.5.7. 复 合 计 算

2.4.5.8. 比 较 与 选 择

2.4.5.9. 类 型 转 换

2.4.5.10. 归 约 计 算

2.4.5.11. 数 据 填 充

2.4.5.12. 离 散 与 聚 合

2.4.5.13. 数 据 重 排

2.4.5.14. 数 据 压 缩

2.4.5.15. 直 方 图 计 算

2.4.5.16. 索 引 操 作

2.4.5.17. 同 步 控 制

2.4.5.18. 系 统 变 量 访 问

2.4.5.19. 数 据 类 型

2.4.7.1. Pipe和Que框 架

2.4.7.1.1. TPipe

2.4.7.1.3. TBufPool

2.4.7.1.4. 自 定 义TBufPool

2.4.7.1.5. TQue

2.4.7.1.6. TSCM

2.4.7.1.7. TQueBind

2.4.7.1.8. TBuf

2.4.7.2. 临 时 空 间 管 理

2.4.7.2.1. workspace

2.4.7.3. 内 存 管 理

2.4.7.3.1. LocalMemAllocator

2.4.8.2. 核 内 同 步

2.4.8.2.3. TQueSync

2.4.8.2.7. Mutex（ISASI）

2.4.8.3. 核 间 同 步

2.4.8.4. 任 务 间 同 步

2.4.11.1. 上 板 打 印

2.4.11.2. 异 常 检 测

2.4.11.3. CPU孪 生 调 试

2.4.11.4. 性 能 统 计

2.4.12.1. 执 行 模 式

2.4.12.2. 系 统 初 始 化

2.4.12.3. 数 学 计 算

2.4.12.3.1. NumericLimits

2.4.12.4. 系 统 资 源 与 变 量

2.4.13.1. CubeResGroupHandle

2.4.3.1. 概述

2.4.3.2. 矩阵计算分形介绍

2.4.3.3. 矩阵计算的搬入

2.4.3.3.4. 矩阵数据搬入至L1 Buffer

2.4.3.3.5. 矩阵数据搬入至L0 Buffer

2.4.3.3.6. 辅助配置接口

2.4.3.4. 数据搬运

2.4.3.5. 矩阵计算

2.4.3.5.5. 关键特性说明

2.4.3.5.6. 寄存器配置说明

2.4.3.6. 矩阵计算的搬出

2.4.3.6.10. L1到GM数据搬运

2.4.3.6.11. 关键特性说明

2.4.3.6.12. 寄存器配置说明

2.4.4.2. SIMD计算说明

2.4.4.2.4. 掩码

2.4.4.3. 数据搬运

2.4.4.3.1. GM与UB数据搬运

2.4.4.3.2. UB与UB数据搬运

2.4.4.4. 基础算术

2.4.4.5. 逻辑计算

2.4.4.6. 复合计算

2.4.4.7. 比较与选择

2.4.4.8. 类型转换

2.4.4.8.1. 寄存器配置说明

2.4.4.9. 归约计算

2.4.4.9.8. 寄存器辅助接口

2.4.4.10. 数据排布转换

2.4.4.11. 数据填充

2.4.4.12. 排序组合（ISASI）

2.4.4.13. 离散与聚合

2.4.4.14. 掩码操作

2.4.4.15. 数据重排（ISASI）

2.4.5.1. 寄存器数据类型

2.4.5.3. Reg数据搬运

2.4.5.4. MaskReg计算

2.4.5.5. 基础算术

2.4.5.6. 逻辑计算

2.4.5.7. 复合计算

2.4.5.8. 比较与选择

2.4.5.9. 类型转换

2.4.5.10. 归约计算

2.4.5.11. 数据填充

2.4.5.12. 离散与聚合

2.4.5.13. 数据重排

2.4.5.14. 数据压缩

2.4.5.15. 直方图计算

2.4.5.16. 索引操作

2.4.5.17. 同步控制

2.4.5.18. 系统变量访问

2.4.5.19. 数据类型

2.4.7.1. Pipe和Que框架

2.4.7.1.4. 自定义TBufPool

2.4.7.2. 临时空间管理

2.4.7.3. 内存管理

2.4.8.2. 核内同步

2.4.8.3. 核间同步

2.4.8.4. 任务间同步

2.4.11.1. 上板打印

2.4.11.2. 异常检测

2.4.11.3. CPU孪生调试

2.4.11.4. 性能统计

2.4.12.1. 执行模式

2.4.12.2. 系统初始化

2.4.12.3. 数学计算

2.4.12.4. 系统资源与变量

2.6.1.1. Tanh接口

2.6.1.2. Asin接口

2.6.1.3. Sin接口

2.6.1.4. Acos接口

2.6.1.5. Cos接口

2.6.1.6. Log接口

2.6.1.7. Atan接口

2.6.1.8. Power接口

2.6.1.9. Sinh接口

2.6.1.10. Cosh接口

2.6.1.11. Tan接口

2.6.1.12. Trunc接口

2.6.1.13. Frac接口

2.6.1.14. Erf接口