ReduceSum

Applicability

Product	Supported
Atlas 350 Accelerator Card	√
Atlas A3 training product / Atlas A3 inference product	√
Atlas A2 training product / Atlas A2 inference product	√
Atlas 200I/500 A2 inference product	x
Atlas inference product AI Core	x
Atlas inference product Vector Core	x
Atlas training product	x

Function Usage

Accumulates data of a multi-dimensional vector based on a specified dimension.

The specified dimension (Reduced axis) is defined as the R axis, and the non-specified dimension (Normal axis) is defined as the A axis. As shown in the following figure, for a two-dimensional matrix with the shape of (2, 3), if the data accumulation is performed on the first dimension, the output result is [5, 7, 9]; if the data accumulation is performed on the second dimension, the output result is [6, 15].

Figure 1 Example of ReduceSum computed in the first dimension

Figure 2 Example of ReduceSum computed in the last dimension

Prototype

Pass the temporary space through the sharedTmpBuffer input parameter.

        
             template <class T, class pattern, bool isReuseSource = false>
__aicore__ inline void ReduceSum(const LocalTensor<T>& dstTensor, const LocalTensor<T>& srcTensor, const LocalTensor<uint8_t>& sharedTmpBuffer, const uint32_t srcShape[], bool srcInnerPad)

Allocate the temporary space through the API framework.

        
             template <class T, class pattern, bool isReuseSource = false>
__aicore__ inline void ReduceSum(const LocalTensor<T>& dstTensor, const LocalTensor<T>& srcTensor, const uint32_t srcShape[], bool srcInnerPad)

Due to the complex mathematical computation involved in the internal implementation of this API, extra temporary space is required to store intermediate variables generated during computation. The temporary space can be passed by developers through the sharedTmpBuffer input parameter or allocated through the API framework.

When the sharedTmpBuffer input parameter is used for passing the temporary space, the tensor serves as the temporary space. In this case, the API framework is not required for temporary space allocation. This enables developers to manage the sharedTmpBuffer space and reuse the buffer after calling the API, so that the buffer is not repeatedly allocated or deallocated, improving the flexibility and buffer utilization.
When the API framework is used for temporary space allocation, developers do not need to allocate the space, but must reserve the required size for the temporary space.

If sharedTmpBuffer is used, developers must allocate space for the tensor. If the API framework is used, developers must reserve the temporary space. To obtain the size of the temporary space (BufferSize) to be reserved, use the API provided in GetReduceSumMaxMinTmpSize.

Parameters

**Table 1** Template parameters
Parameter	Description
T	Data type of the operand. For the Atlas 350 Accelerator Card, the supported data types are int32_t, uint32_t, float, int64_t, and uint64_t. For the Atlas A3 training product / Atlas A3 inference product , the supported data type is float. For the Atlas A2 training product / Atlas A2 inference product , the supported data type is float.
pattern	ReduceSum computation axes, including the Reduced axis and Normal axis. pattern is a string composed of letters A (standing for Normal axis) and R (standing for Reduced axis), with the number of letters equal to the number of dimensions in the vector. For example, AR indicates performing a ReduceSum operation on a two-dimensional vector: The first dimension is the Normal axis, and the second dimension is the Reduced axis, meaning that the data is summed along the second dimension. pattern is a struct defined in the AscendC::Pattern::Reduce namespace. You can ignore its member variables. Currently, the value of pattern can only be AR or RA.
isReuseSource	Whether the source operand can be modified. The default value is false. If developers allow the source operand to be modified, enable this parameter, to reduce memory space usage. If this parameter is set to true, the src memory space is reused during internal computation of this API to reduce memory space usage. If this parameter is set to false, the src memory space is not reused during internal computation of this API. For details about how to use isReuseSource, see Example 4.

**Table 2** API parameters
Parameter	Input/Output	Description
dstTensor	Output	Destination operand. The type is LocalTensor, and TPosition can be VECIN, VECCALC, or VECOUT.
srcTensor	Input	Source operand. The type is LocalTensor, and TPosition can be VECIN, VECCALC, or VECOUT. The source operand must have the same data type as the destination operand.
sharedTmpBuffer	Input	Temporary buffer. The type is LocalTensor, and TPosition can be VECIN, VECCALC, or VECOUT. This parameter is used to store intermediate variables during complex computation in ReduceSum and is provided by developers. For details about how to obtain the temporary space size (BufferSize), see GetReduceSumMaxMinTmpSize.
srcShape	Input	An array of the uint32_t type, indicating the shape information of the source operand. The dimension of the shape must be the consistent with that of the template parameter pattern. For example, if pattern is AR, the shape dimension must be two-dimensional. For the Atlas 350 Accelerator Card, only two-dimensional shapes are supported. For the Atlas A3 training product / Atlas A3 inference product , only two-dimensional shapes are supported. For the Atlas A2 training product / Atlas A2 inference product , only two-dimensional shapes are supported.
srcInnerPad	Input	Whether the innermost axis data to be computed is 32-byte aligned. For the Atlas 350 Accelerator Card, this parameter is reserved. In the API, the srcShape and pattern parameters are used to calculate whether the innermost axis data is 32-byte aligned. For the Atlas A3 training product / Atlas A3 inference product , only true is supported. For the Atlas A2 training product / Atlas A2 inference product , only true is supported.

Returns

None

Constraints

For details about the operand address alignment requirements, see General Address Alignment Restrictions.

The source operand address must not overlap the destination operand address.
The address of sharedTmpBuffer cannot overlap that of the source or destination operand.
The internal algorithm does not process data overflow during accumulation. In the overflow scenario, the API precision is not ensured.

Examples

For a complete operator sample, see ReduceSum operator sample.

      
           uint32_t shape[] = { 2, 8 };
constexpr bool isReuse = true;
AscendC::ReduceSum<float, AscendC::Pattern::Reduce::AR, isReuse>(dstLocal, srcLocal, tmp, shape, true); // tmp indicates the size of the input temporary space, shape indicates the input shape of srcLocal, and true indicates whether the address is 32-byte aligned.

Result example:

      
           The input and output data type is float.
Input (src):
[[ 0.0 4.0 2.0 0.0 -1.0 2.0 -1.0 7.0],
 [ 0.0 1.0 -9.0 2.0 2.0 2.0 8.0 3.0]]
Input pattern: AR
Input shape: (2, 8)
Output (dst): [13.0 9.0]

Parent topic: ReduceSum APIs