File size: 7,310 Bytes
0fef070 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 | # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License").
# You may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Dynamic-shape elementwise add kernel. Computes output = input_a + input_b with runtime-variable M-dimension."""
import nki
import nki.isa as nisa
import nki.language as nl
from ...core.utils.kernel_assert import kernel_assert
P_MAX = 128 # Partition dimension tile size (rows per M-tile)
H_TILE_SIZE = 512 # Hidden dimension tile size (columns per H-tile)
@nki.jit
def dynamic_elementwise_add(
input_a: nl.ndarray,
input_b: nl.ndarray,
num_m_tiles: nl.ndarray,
) -> nl.ndarray:
"""
Elementwise addition with dynamic partition dimension tiling.
Computes output = input_a + input_b for 2D bf16 tensors where the number of
M-dimension tiles to process is determined at runtime via num_m_tiles. Optimized
for M dimensions up to 2048 and H dimensions up to 8192.
Dimensions:
M: Row dimension, tiled at P_MAX (128). Dynamic at runtime via num_m_tiles.
H: Hidden/column dimension, tiled at H_TILE_SIZE (512). Static.
num_m_tiles: Runtime trip count for the M-tile loop (int32 scalar).
Args:
input_a (nl.ndarray): [M, H], First input tensor, bf16, on HBM.
input_b (nl.ndarray): [M, H], Second input tensor, bf16, on HBM. Must match input_a shape.
num_m_tiles (nl.ndarray): [1, 1], int32 scalar tensor on HBM. Value = number of M-tiles
to process (0 <= num_m_tiles <= M // P_MAX).
Returns:
result (nl.ndarray): [M, H], bf16 output tensor on HBM. Elements in the first
(num_m_tiles * P_MAX) rows contain input_a + input_b; remaining rows are unmodified.
Notes:
- M must be divisible by P_MAX (128)
- H must be divisible by H_TILE_SIZE (512)
- input_a and input_b must have identical shapes
Pseudocode:
result = allocate([M, H], bf16, HBM)
trip_count = load_register(num_m_tiles)
m_offset = 0 # tracked in SBUF; advanced inside the loop body, not loop-carried
# nl.fori_loop follows Pallas fori_loop semantics: the body is a function
# invoked per iteration with the loop index. Loop-carried dependencies
# (a value threaded from one iteration's return into the next) are NOT
# supported yet, so state like m_offset is kept in SBUF and mutated
# in place rather than passed through the loop.
def body(i):
for h_tile_idx in affine_range(H // H_TILE_SIZE):
h_start = h_tile_idx * H_TILE_SIZE
a_tile = dma_load(input_a[m_offset:m_offset+P_MAX, h_start:h_start+H_TILE_SIZE])
b_tile = dma_load(input_b[m_offset:m_offset+P_MAX, h_start:h_start+H_TILE_SIZE])
out_tile = a_tile + b_tile
dma_store(result[m_offset:m_offset+P_MAX, h_start:h_start+H_TILE_SIZE], out_tile)
m_offset += P_MAX # mutate SBUF state in place (no loop-carried value)
fori_loop(0, trip_count, body, step=1)
return result
"""
m_static, hidden = input_a.shape
# Input validation
kernel_assert(
input_a.shape == input_b.shape,
f"input_a and input_b must have the same shape, got {input_a.shape} and {input_b.shape}",
)
kernel_assert(
hidden % H_TILE_SIZE == 0,
f"Hidden dimension H={hidden} must be divisible by H_TILE_SIZE={H_TILE_SIZE}",
)
kernel_assert(
m_static % P_MAX == 0,
f"M dimension M={m_static} must be divisible by P_MAX={P_MAX}",
)
H_TILE_COUNT = hidden // H_TILE_SIZE
# Allocate output on HBM
result = nl.ndarray(shape=(m_static, hidden), dtype=input_a.dtype, buffer=nl.shared_hbm)
# Load num_m_tiles scalar into a hardware register for the fori_loop trip count
num_m_tiles_sbuf = nl.ndarray(shape=(1, 1), dtype=nl.int32, buffer=nl.sbuf)
nisa.dma_copy(dst=num_m_tiles_sbuf, src=num_m_tiles[0])
num_m_tiles_reg = nisa.register_alloc()
nisa.register_load(num_m_tiles_reg, num_m_tiles_sbuf)
# M-tile offset tracker in SBUF (incremented by P_MAX each iteration)
m_tile_start = nl.ndarray(shape=(1, 1), dtype=nl.int32, buffer=nl.sbuf)
nisa.memset(dst=m_tile_start, value=0)
def _process_m_tile(_):
for h_tile_idx in nl.affine_range(H_TILE_COUNT):
h_start = h_tile_idx * H_TILE_SIZE
# DMA load input_a tile from HBM to SBUF
a_tile = nl.ndarray(shape=(P_MAX, H_TILE_SIZE), dtype=input_a.dtype, buffer=nl.sbuf)
nisa.dma_copy(
dst=a_tile[0:P_MAX, 0:H_TILE_SIZE],
src=input_a.ap(
pattern=[[hidden, P_MAX], [1, H_TILE_SIZE]],
offset=h_start,
scalar_offset=m_tile_start,
indirect_dim=0,
),
)
# DMA load input_b tile from HBM to SBUF
b_tile = nl.ndarray(shape=(P_MAX, H_TILE_SIZE), dtype=input_b.dtype, buffer=nl.sbuf)
nisa.dma_copy(
dst=b_tile[0:P_MAX, 0:H_TILE_SIZE],
src=input_b.ap(
pattern=[[hidden, P_MAX], [1, H_TILE_SIZE]],
offset=h_start,
scalar_offset=m_tile_start,
indirect_dim=0,
),
)
# Elementwise add in SBUF
out_tile = nl.ndarray(shape=(P_MAX, H_TILE_SIZE), dtype=input_a.dtype, buffer=nl.sbuf)
nisa.tensor_tensor(
dst=out_tile[0:P_MAX, 0:H_TILE_SIZE],
data1=a_tile[0:P_MAX, 0:H_TILE_SIZE],
data2=b_tile[0:P_MAX, 0:H_TILE_SIZE],
op=nl.add,
)
# DMA store result tile from SBUF to HBM
nisa.dma_copy(
dst=result.ap(
pattern=[[hidden, P_MAX], [1, H_TILE_SIZE]],
offset=h_start,
scalar_offset=m_tile_start,
indirect_dim=0,
),
src=out_tile[0:P_MAX, 0:H_TILE_SIZE],
)
# Advance M-tile offset by P_MAX rows. State is mutated in SBUF rather than
# passed between iterations: fori_loop has no loop-carried dependency support.
nisa.tensor_scalar(dst=m_tile_start, data=m_tile_start, op0=nl.add, operand0=P_MAX)
# nl.fori_loop follows Pallas fori_loop semantics: it calls _process_m_tile(i)
# for each index in [0, num_m_tiles_reg). Loop-carried values are not supported
# yet, so m_tile_start lives in SBUF and is updated in place by the body above.
nl.fori_loop(0, num_m_tiles_reg, _process_m_tile, step=1)
# HBM fence: ensure all DMA writes complete before kernel returns
nisa.dma_copy(dst=result, src=result)
return result
|