TROWEXPANDSUB

Instruction Diagram

Mode 1 — Scalar per Row (ColMajor src1)

Mode 2 — 32-Byte Block per Row (RowMajor src1)

Introduction

Row broadcast subtraction: subtracts the scalar per row of the expanded operand from each row of src0.

The instruction supports two modes, determined by the layout of the expanded operand (src1 when src0 matches the shape of dst, and src0 when src1 matches the shape of dst):

• Mode 1: The expanded operand is in ColMajor layout with a single column (one scalar per row). Each scalar is broadcast to the entire row.
• Mode 2: The expanded operand is in RowMajor layout with 32 / sizeof(T) columns per row (one 32-byte block per row). Each 32-byte block repeats naturally within the vector repeat stride, providing row-level broadcast.

Mathematical Semantics

Assume R = dst.GetValidRow() and C = dst.GetValidCol().

Mode 1

Assume that s_i is the scalar per row obtained from the expanded operand (one value per row, ColMajor layout).

For 0 <= i < R and 0 <= j < C:

$$\mathrm{dst}_{i,j} = \mathrm{full}_{i,j} - s_i$$

Here, full refers to the full-size operand with shape matching dst (which can be src0 or src1).

Mode 2

Assume that b_i is the 32-byte block obtained from the expanded operand in row i (RowMajor layout, 32 / sizeof(T) values per row). This block repeats naturally within each vector repeat stride.

For 0 <= i < R and 0 <= j < C:

$$\mathrm{dst}_{i,j} = \mathrm{full}_{i,j} - b_i[\,j \bmod (32 / \mathit{sizeof}(T))\,]$$

Assembly Syntax

Synchronous form:

%dst = trowexpandsub %src0, %src1 : !pto.tile<...>, !pto.tile<...> -> !pto.tile<...>

AS Level 1 (SSA)

%dst = pto.trowexpandsub %src0, %src1 : !pto.tile<...>, !pto.tile<...> -> !pto.tile<...>

AS Level 2 (DPS)

pto.trowexpandsub ins(%src0, %src1 : !pto.tile_buf<...>, !pto.tile_buf<...>) outs(%dst : !pto.tile_buf<...>)

C++ Built-in APIs

Declared in include/pto/common/pto_instr.hpp:

The public include header is <pto/pto-inst.hpp>, and the internal declaration is located in pto/common/pto_instr.hpp.

template <typename TileDataDst, typename TileDataSrc0, typename TileDataSrc1, typename... WaitEvents>
PTO_INST RecordEvent TROWEXPANDSUB(TileDataDst &dst, TileDataSrc0 &src0, TileDataSrc1 &src1, WaitEvents &... events);

template <typename TileDataDst, typename TileDataSrc0, typename TileDataSrc1, typename TileDataTmp,
          typename... WaitEvents>
PTO_INST RecordEvent TROWEXPANDSUB(TileDataDst &dst, TileDataSrc0 &src0, TileDataSrc1 &src1, TileDataTmp &tmp, WaitEvents &... events);

Constraints

• TileDataDst::DType == TileDataSrc0::DType == TileDataSrc1::DType
• TileDataDst::DType, TileDataSrc0::DType, and TileDataSrc1::DType must be one of the following: half, float, int16, int32 (applicable to Atlas A2 training products/Atlas A2 inference products, Atlas A3 training products/Atlas A3 inference products, and Ascend 950PR/Ascend 950DT), uint16, uint32, bfloat16_t, int8, uint8 (applicable only to Ascend 950PR/Ascend 950DT).
• TileDataDst must be RowMajor (TileDataDst::isRowMajor == true).
• Exactly one of src0 or src1 must have the same valid shape as dst (that is, validRow == dst.validRow and validCol == dst.validCol); this operand is the full-size operand. The other operand is the expanded operand (row broadcast source).
• The full-size operand must be RowMajor (isRowMajor == true).

Mode 1 — Expanded Operand Is ColMajor (Scalar per Row)

When the expanded operand is ColMajor (isRowMajor == false):

• Its valid column count must be 1 (one scalar per row): srcX.GetValidCol() == 1.
• Its valid row count must equal dst.GetValidRow(): srcX.GetValidRow() == dst.GetValidRow().

Mode 2 — Expanded Operand Is RowMajor (32-Byte Block per Row)

When the expanded operand is RowMajor (isRowMajor == true):

• Its valid column count must be 32 / sizeof(T) (one 32-byte block per row): srcX.GetValidCol() == 32 / sizeof(T).
  • For half/int16/uint16: validCol == 16.
  • For float/int32/uint32: validCol == 8.
• Its valid row count must equal dst.GetValidRow(): srcX.GetValidRow() == dst.GetValidRow().

Other Target-Specific Constraints

The specific layout, fractal, and alignment constraints may vary by backend target. See the backend header files under include/pto/npu/*/TRowExpand*.hpp.

Temporary Tile

The C++ API provides an overload that explicitly passes in TileDataTmp &tmp. This overload supports only mode 1 (ColMajor expanded operand, scalar per row).

• Atlas A2/A3 training products/Atlas A2/A3 inference products: The tmp tile is used as a broadcast buffer. The scalar value per row of the ColMajor expanded operand is broadcast to the tmp buffer through the vbrcb instruction, creating a 32-byte block for each row, which is then used as the expanded operand in the binary operation. The repeat stride of the vbrcb instruction is 8 blocks (256 bytes), and each repeat processes 8 rows. The minimum tmp size is calculated as follows:
  • Common parameters:
    • R = dst.GetValidRow(), T = TileDataDst::DType.
  • When R < 256: $$\text{tmpSize} = \left\lceil\frac{R}{8}\right\rceil \times 256 \text{ bytes}$$
  • When R >= 256:
    • The operation uses a loop, with up to 30 repeats (240 rows) per iteration. The tmp buffer is reused across iterations, and each iteration requires: $$\text{tmpSize} = 30 \times 256 = 7680 \text{ bytes}$$
  • For any mode 1 call, a compact shape-independent upper bound is 8 KB (8192 bytes).
  • The 3-parameter overload without tmp supports mode 1 and mode 2. For mode 1, an internal 8 KB buffer (TMP_UB_OFFSET) is used. For mode 2, no broadcast buffer is required.
• Ascend 950PR/Ascend 950DT: The tmp tile is accepted but not used ([[maybe_unused]]). Ascend 950PR/Ascend 950DT hardware natively supports row broadcast through the broadcast mode of the vlds instruction, so no temporary buffer is required.

Examples

Automatic

#include <pto/pto-inst.hpp>

using namespace pto;

void example_auto() {
  using TileT = Tile<TileType::Vec, half, 16, 16>;
  using RowVecT = Tile<TileType::Vec, half, 16, 1, BLayout::ColMajor, 1, DYNAMIC, SLayout::NoneBox>;

  TileT src0, dst;
  RowVecT src1(16);
  TROWEXPANDSUB(dst, src0, src1);
}

Manual

#include <pto/pto-inst.hpp>

using namespace pto;

void example_manual() {
  using TileT = Tile<TileType::Vec, half, 16, 16>;
  using RowVecT = Tile<TileType::Vec, half, 16, 1, BLayout::ColMajor, 1, DYNAMIC, SLayout::NoneBox>;

  TileT src0, dst;
  RowVecT src1(16);
  TASSIGN(src0, 0x1000);
  TASSIGN(dst,  0x2000);
  TASSIGN(src1, 0x3000);
  TROWEXPANDSUB(dst, src0, src1);
}

ASM Examples

Automatic Mode

# Automatic mode: the compiler/runtime handles resource placement and scheduling.
%dst = pto.trowexpandsub %src0, %src1 : !pto.tile<...>, !pto.tile<...> -> !pto.tile<...>

Manual Mode

# Manual mode: explicitly bind resources first, then issue the instruction.
# Optional (when the instruction contains tile operands):
# pto.tassign %arg0, @tile(0x1000)
# pto.tassign %arg1, @tile(0x2000)
%dst = pto.trowexpandsub %src0, %src1 : !pto.tile<...>, !pto.tile<...> -> !pto.tile<...>

PTO Assembly Form

%dst = trowexpandsub %src0, %src1 : !pto.tile<...>, !pto.tile<...> -> !pto.tile<...>
# AS Level 2 (DPS)
pto.trowexpandsub ins(%src0, %src1 : !pto.tile_buf<...>, !pto.tile_buf<...>) outs(%dst : !pto.tile_buf<...>)