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