File size: 4,117 Bytes
167e081
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
import os
import torch

import pytest

import tile_kernels
from tile_kernels.testing.bench import dtype_to_str, make_param_id
from tile_kernels.testing.generator import generate_topk_idx, generate_hidden_sizes, generate_moe_params
from tile_kernels.testing.numeric import assert_equal, count_bytes

# Disable TileLang prints
os.environ['TILELANG_PRINT_ON_COMPILATION'] = '0'


def generate_test_data(params):
    hidden = params['hidden']
    with_weights = params['with_weights']
    in_dtype = params['in_dtype']
    out_dtype = params['out_dtype']
    with_sf = params['with_sf']
    num_experts = params['num_experts']
    num_ep_ranks = params['num_ep_ranks']
    num_topk = params['num_topk']

    topk_idx = generate_topk_idx(params)
    num_tokens = topk_idx.shape[0]
    num_expanded_tokens = num_tokens * num_topk
    expanded = torch.randn((num_expanded_tokens, hidden), dtype=in_dtype, device='cuda')
    _, _, _, token_topk_to_pos, _, _, _, _ = tile_kernels.moe.get_fused_mapping(topk_idx, num_experts, 0, 1)

    topk_weights = torch.rand((num_tokens, num_topk), dtype=torch.float32, device='cuda') if with_weights else None
    if out_dtype == torch.float8_e4m3fn:
        sf = torch.randn((1,), dtype=torch.float32, device='cuda')
    else:
        sf = None
    if with_sf:
        x_sf = torch.randn((num_expanded_tokens,), dtype=torch.float32, device='cuda')
    else:
        x_sf = None
    fp8_format = 'e4m3' if out_dtype == torch.float8_e4m3fn else ''

    x_input = (expanded, x_sf) if x_sf is not None else expanded

    return (expanded, token_topk_to_pos, topk_weights, sf, x_sf, fp8_format, x_input, num_tokens)


def generate_test_params(is_benchmark: bool) -> list[dict]:
    params = [
        {**moe, 'hidden': hidden, 'with_weights': with_weights,
         'in_dtype': in_dtype, 'out_dtype': out_dtype, 'with_sf': with_sf}
        for moe in generate_moe_params(is_benchmark=is_benchmark)
        for hidden in generate_hidden_sizes(256)
        for with_weights in (True, False)
        for in_dtype in (torch.float32, torch.bfloat16)
        for out_dtype in (in_dtype, torch.float8_e4m3fn)
        for with_sf in (True, False)
    ]
    if is_benchmark:
        params = [p for p in params if p['num_topk'] == 6 and p['with_weights']]
    return params


@pytest.mark.parametrize('params', generate_test_params(is_benchmark=False), ids=make_param_id)
def test_reduce_fused(params):
    (expanded, token_topk_to_pos, topk_weights, sf, x_sf, fp8_format, x_input,
     _) = generate_test_data(params)

    # Test correctness: tile_kernels kernel
    func = lambda: tile_kernels.moe.reduce_fused(
        x_input, topk_weights, token_topk_to_pos, fp8_format, sf, None
    )
    r_tk = func()

    # Test correctness: torch reference
    r_ref = tile_kernels.torch.reduce_fused(
        x_input, topk_weights, token_topk_to_pos, fp8_format, sf
    )
    assert_equal(r_tk, r_ref)


@pytest.mark.benchmark
@pytest.mark.parametrize('params', generate_test_params(is_benchmark=True), ids=make_param_id)
def test_reduce_fused_benchmark(benchmark_timer, benchmark_record, params):
    hidden = params['hidden']
    out_dtype = params['out_dtype']

    (expanded, token_topk_to_pos, topk_weights, sf, x_sf, fp8_format, x_input,
     num_tokens) = generate_test_data(params)
    in_dtype = params['in_dtype']

    func = lambda: tile_kernels.moe.reduce_fused(
        x_input, topk_weights, token_topk_to_pos, fp8_format, sf, None
    )
    r_tk = func()

    num_bytes = count_bytes(token_topk_to_pos, x_sf, r_tk)
    num_bytes += torch.count_nonzero(token_topk_to_pos != -1).item() * hidden * (torch.finfo(in_dtype).bits // 8)
    if topk_weights is not None:
        num_bytes += count_bytes(topk_weights)

    t_us = benchmark_timer(func)

    bandwidth_gbs = num_bytes / t_us / 1e3

    params.pop('num_send_tokens')
    benchmark_record(
        kernel='reduce_fused',
        operation='fwd',
        params={'num_tokens': num_tokens, **params, 'in_dtype': dtype_to_str(in_dtype), 'out_dtype': dtype_to_str(out_dtype)},
        time_us=t_us,
        bandwidth_gbs=bandwidth_gbs,
    )