UMOPA (2-way)

Unsigned 16-bit integer sum of outer products to 32-bit integer, accumulating

This instruction works with a 32-bit element ZA tile.

This instruction multiplies the sub-matrix in the first source vector by the sub-matrix in the second source vector. The first source holds SVLS×2 sub-matrix of unsigned 16-bit integer values, and the second source holds 2×SVLS sub-matrix of unsigned 16-bit integer values.

Each source vector is independently predicated by a corresponding governing predicate. When a 16-bit source element is inactive, it is treated as having the value 0.

The resulting SVLS×SVLS widened 32-bit integer sum of outer products is then destructively added to the 32-bit integer destination tile. This is equivalent to performing a 2-way dot product and accumulate to each of the destination tile elements.

Each 32-bit container of the first source vector holds 2 consecutive column elements of each row of a SVLS×2 sub-matrix, and each 32-bit container of the second source vector holds 2 consecutive row elements of each column of a 2×SVLS sub-matrix.

SME2
(FEAT_SME2)

313029282726252423222120191817161514131211109876543210
10100001100ZmPmPnZn010ZAda
u0S

Encoding

UMOPA <ZAda>.S, <Pn>/M, <Pm>/M, <Zn>.H, <Zm>.H

Decode for this encoding

if !IsFeatureImplemented(FEAT_SME2) then EndOfDecode(Decode_UNDEF); end; let esize : integer{} = 32; let a : integer = UInt(Pn); let b : integer = UInt(Pm); let n : integer = UInt(Zn); let m : integer = UInt(Zm); let da : integer = UInt(ZAda); let unsigned : boolean = TRUE;

Assembler Symbols

<ZAda>

Is the name of the ZA tile ZA0-ZA3, encoded in the "ZAda" field.

<Pn>

Is the name of the first governing scalable predicate register P0-P7, encoded in the "Pn" field.

<Pm>

Is the name of the second governing scalable predicate register P0-P7, encoded in the "Pm" field.

<Zn>

Is the name of the first source scalable vector register, encoded in the "Zn" field.

<Zm>

Is the name of the second source scalable vector register, encoded in the "Zm" field.

Operation

CheckStreamingSVEAndZAEnabled(); let VL : integer{} = CurrentVL(); let PL : integer{} = VL DIV 8; let dim : integer{} = VL DIV esize; let mask1 : bits(PL) = P{}(a); let mask2 : bits(PL) = P{}(b); let operand1 : bits(VL) = Z{}(n); let operand2 : bits(VL) = Z{}(m); let operand3 : bits(dim*dim*esize) = ZAtile{}(da, esize); var result : bits(dim*dim*esize); var prod : integer; for row = 0 to dim-1 do for col = 0 to dim-1 do var sum : bits(esize) = operand3[(row*dim+col)*:esize]; for k = 0 to 1 do if (ActivePredicateElement{PL}(mask1, 2*row + k, esize DIV 2) && ActivePredicateElement{PL}(mask2, 2*col + k, esize DIV 2)) then let op1elt : bits(esize DIV 2) = operand1[(2*row + k)*:(esize DIV 2)]; let op2elt : bits(esize DIV 2) = operand2[(2*col + k)*:(esize DIV 2)]; let element1 : integer = if unsigned then UInt(op1elt) else SInt(op1elt); let element2 : integer = if unsigned then UInt(op2elt) else SInt(op2elt); prod = element1 * element2; sum = sum + prod; end; end; result[(row*dim+col)*:esize] = sum; end; end; ZAtile{dim*dim*esize}(da, esize) = result;

Operational information

This instruction is a data-independent-time instruction as described in About PSTATE.DIT.


2026-03_rel 2026-03-26 20:48:11

Copyright © 2010-2026 Arm Limited or its affiliates. All rights reserved. This document is Non-Confidential.