sfpi/include/wormhole/sfpi_imp.h at 08d39202f283ab9122e162bcead5b7c90014fa86 · tenstorrent/sfpi · GitHub

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
174
/*
 * SPDX-FileCopyrightText: © 2023 Tenstorrent Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

///////////////////////////////////////////////////////////////////////////////
// sfpi_imp.h: SFPu Interface implementation for Grayskull
///////////////////////////////////////////////////////////////////////////////

#pragma once

namespace sfpi {

//////////////////////////////////////////////////////////////////////////////
constexpr __vConstFloat vConst0p8373(CREG_IDX_0P837300003);
constexpr __vConstFloat vConstFloatPrgm0(CREG_IDX_PRGM1);
constexpr __vConstFloat vConstFloatPrgm1(CREG_IDX_PRGM2);
constexpr __vConstFloat vConstFloatPrgm2(CREG_IDX_PRGM3);

constexpr __vConstIntBase vConstTileId(CREG_IDX_TILEID);
constexpr __vConstIntBase vConstIntPrgm0(CREG_IDX_PRGM1);
constexpr __vConstIntBase vConstIntPrgm1(CREG_IDX_PRGM2);
constexpr __vConstIntBase vConstIntPrgm2(CREG_IDX_PRGM3);

//////////////////////////////////////////////////////////////////////////////
sfpi_inline __vCond __vDReg::operator==(const float x) const {return __vCond(__vCond::__vCondEQ, vFloat(*this), x); }
sfpi_inline __vCond __vDReg::operator!=(const float x) const { return __vCond(__vCond::__vCondNE, vFloat(*this), x); }
sfpi_inline __vCond __vDReg::operator<(const float x) const { return __vCond(__vCond::__vCondLT, vFloat(*this), x); }
sfpi_inline __vCond __vDReg::operator<=(const float x) const { return __vCond(__vCond::__vCondLTE, vFloat(*this), x); }
sfpi_inline __vCond __vDReg::operator>(const float x) const { return __vCond(__vCond::__vCondGT, vFloat(*this), x); }
sfpi_inline __vCond __vDReg::operator>=(const float x) const { return __vCond(__vCond::__vCondGTE, vFloat(*this), x); }

template <>
sfpi_inline vFloat __vDReg::operator=(const vFloat vec) const
{
    __builtin_rvtt_sfpstore(vec.get(), SFPSTORE_MOD0_FMT_SRCB, SFPSTORE_ADDR_MODE_NOINC, reg);
    return vec;
}

sfpi_inline vFloat __vDReg::operator=(const double d) const
{
    vFloat v(static_cast<float>(d));
    *this = v;
    return v;
}

sfpi_inline vFloat __vDReg::operator=(s2vFloat16 f) const
{
    vFloat v(f);
    *this = v;
    return v;
}

sfpi_inline vFloat __vDReg::operator=(const float f) const
{
    vFloat v(f);
    *this = v;
    return v;
}

template <typename vecType, typename std::enable_if_t<std::is_base_of<__vBase, vecType>::value>*>
sfpi_inline vecType __vDReg::operator=(const vecType vec) const
{
    __builtin_rvtt_sfpstore(vec.get(), SFPSTORE_MOD0_FMT_INT32_TO_SM, SFPSTORE_ADDR_MODE_NOINC, reg);
    return vec;
}

sfpi_inline void __vDReg::operator=(const __vDReg dreg) const
{
    vFloat tmp = dreg;
    __builtin_rvtt_sfpstore(tmp.get(), SFPSTORE_MOD0_FMT_SRCB, SFPSTORE_ADDR_MODE_NOINC, reg);
}

sfpi_inline vFloat __vDReg::operator=(const __vConstFloat creg) const
{
    __rvtt_vec_t lr = __builtin_rvtt_sfpassignlreg(creg.get());
    __builtin_rvtt_sfpstore(lr, SFPSTORE_MOD0_FMT_SRCB, SFPSTORE_ADDR_MODE_NOINC, reg);
    return vFloat(lr);
}

//////////////////////////////////////////////////////////////////////////////
sfpi_inline __vCond vFloat::operator==(const float x) const { return __vCond(__vCond::__vCondEQ, *this, x); }
sfpi_inline __vCond vFloat::operator!=(const float x) const { return __vCond(__vCond::__vCondNE, *this, x); }
sfpi_inline __vCond vFloat::operator<(const float x) const { return __vCond(__vCond::__vCondLT, *this, x); }
sfpi_inline __vCond vFloat::operator<=(const float x) const { return __vCond(__vCond::__vCondLTE, *this, x); }
sfpi_inline __vCond vFloat::operator>(const float x) const { return __vCond(__vCond::__vCondGT, *this, x); }
sfpi_inline __vCond vFloat::operator>=(const float x) const { return __vCond(__vCond::__vCondGTE, *this, x); }

sfpi_inline vFloat vFloat::operator-=(const vFloat a)
{
    __rvtt_vec_t neg1 = __builtin_rvtt_sfpassignlreg(vConstNeg1.get());
    assign(__builtin_rvtt_sfpmad(neg1, a.get(), v, SFPMAD_MOD1_OFFSET_NONE));
    return v;
}

sfpi_inline vFloat::vFloat(const __vDReg dreg)
{
    v = __builtin_rvtt_sfpload(SFPLOAD_MOD0_FMT_SRCB, SFPLOAD_ADDR_MODE_NOINC, dreg.get());
    initialized = true;
}

sfpi_inline void vFloat::loadf(const float val)
{
    assign(__builtin_rvtt_sfpxloadi(SFPXLOADI_MOD0_FLOAT, __f32asui(val)));
}

//////////////////////////////////////////////////////////////////////////////
sfpi_inline void __vIntBase::loadsi(int32_t val)
{
    assign(__builtin_rvtt_sfpxloadi(SFPXLOADI_MOD0_INT32, val));
}

sfpi_inline void __vIntBase::loadui(uint32_t val)
{
    assign(__builtin_rvtt_sfpxloadi(SFPXLOADI_MOD0_UINT32, val));
}

sfpi_inline vInt::vInt(const __vDReg dreg)
{
    v = __builtin_rvtt_sfpload(SFPLOAD_MOD0_FMT_INT32_TO_SM, SFPLOAD_ADDR_MODE_NOINC, dreg.get());
    initialized = true;
}

sfpi_inline vUInt::vUInt(const __vDReg dreg)
{
    v = __builtin_rvtt_sfpload(SFPLOAD_MOD0_FMT_INT32_TO_SM, SFPLOAD_ADDR_MODE_NOINC, dreg.get());
    initialized = true;
}

template <typename vType, typename std::enable_if_t<std::is_base_of<__vIntBase, vType>::value>*>
sfpi_inline vType __vIntBase::operator^(const vType b) const
{
    return __builtin_rvtt_sfpxor(v, b.get());
}

template <typename vType, typename std::enable_if_t<std::is_base_of<__vIntBase, vType>::value>*>
sfpi_inline vType __vIntBase::operator^=(const vType b)
{
    v = __builtin_rvtt_sfpxor(v, b.get());
    return v;
}

sfpi_inline void __vConstFloat::operator=(const float in) const
{
    vFloat tmp = in;
    __builtin_rvtt_sfpconfig_v(tmp.get(), get());
}

sfpi_inline void __vConstFloat::operator=(const s2vFloat16 in) const
{
    vFloat tmp = in;
    __builtin_rvtt_sfpconfig_v(tmp.get(), get());
}

sfpi_inline void __vConstIntBase::operator=(const int in) const
{
    vInt tmp = in;
    __builtin_rvtt_sfpconfig_v(tmp.get(), get());
}

enum class LRegs {
    LReg0 = 0,
    LReg1 = 1,
    LReg2 = 2,
    LReg3 = 3,
    LReg4 = 4,
    LReg5 = 5,
    LReg6 = 6,
    LReg7 = 7,
    LRegCount = SFP_LREG_COUNT,
};

} // namespace sfpi