Debian Codegraph @

third_party/spirv-cross/reference/shaders-msl-no-opt/comp/subgroups.nocompat.invalid.vk.msl21.comp

raw
1 #pragma clang diagnostic ignored "-Wmissing-prototypes"
2
3 #include <metal_stdlib>
4 #include <simd/simd.h>
5
6 using namespace metal;
7
8 struct SSBO
9 {
10 float FragColor;
11 };
12
13 constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u);
14
15 template<typename T>
16 inline T spvSubgroupBroadcast(T value, ushort lane)
17 {
18 return simd_broadcast(value, lane);
19 }
20
21 template<>
22 inline bool spvSubgroupBroadcast(bool value, ushort lane)
23 {
24 return !!simd_broadcast((ushort)value, lane);
25 }
26
27 template<uint N>
28 inline vec<bool, N> spvSubgroupBroadcast(vec<bool, N> value, ushort lane)
29 {
30 return (vec<bool, N>)simd_broadcast((vec<ushort, N>)value, lane);
31 }
32
33 template<typename T>
34 inline T spvSubgroupBroadcastFirst(T value)
35 {
36 return simd_broadcast_first(value);
37 }
38
39 template<>
40 inline bool spvSubgroupBroadcastFirst(bool value)
41 {
42 return !!simd_broadcast_first((ushort)value);
43 }
44
45 template<uint N>
46 inline vec<bool, N> spvSubgroupBroadcastFirst(vec<bool, N> value)
47 {
48 return (vec<bool, N>)simd_broadcast_first((vec<ushort, N>)value);
49 }
50
51 inline uint4 spvSubgroupBallot(bool value)
52 {
53 simd_vote vote = simd_ballot(value);
54 // simd_ballot() returns a 64-bit integer-like object, but
55 // SPIR-V callers expect a uint4. We must convert.
56 // FIXME: This won't include higher bits if Apple ever supports
57 // 128 lanes in an SIMD-group.
58 return uint4((uint)((simd_vote::vote_t)vote & 0xFFFFFFFF), (uint)(((simd_vote::vote_t)vote >> 32) & 0xFFFFFFFF), 0, 0);
59 }
60
61 inline bool spvSubgroupBallotBitExtract(uint4 ballot, uint bit)
62 {
63 return !!extract_bits(ballot[bit / 32], bit % 32, 1);
64 }
65
66 inline uint spvSubgroupBallotFindLSB(uint4 ballot, uint gl_SubgroupSize)
67 {
68 uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0));
69 ballot &= mask;
70 return select(ctz(ballot.x), select(32 + ctz(ballot.y), select(64 + ctz(ballot.z), select(96 + ctz(ballot.w), uint(-1), ballot.w == 0), ballot.z == 0), ballot.y == 0), ballot.x == 0);
71 }
72
73 inline uint spvSubgroupBallotFindMSB(uint4 ballot, uint gl_SubgroupSize)
74 {
75 uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0));
76 ballot &= mask;
77 return select(128 - (clz(ballot.w) + 1), select(96 - (clz(ballot.z) + 1), select(64 - (clz(ballot.y) + 1), select(32 - (clz(ballot.x) + 1), uint(-1), ballot.x == 0), ballot.y == 0), ballot.z == 0), ballot.w == 0);
78 }
79
80 inline uint spvPopCount4(uint4 ballot)
81 {
82 return popcount(ballot.x) + popcount(ballot.y) + popcount(ballot.z) + popcount(ballot.w);
83 }
84
85 inline uint spvSubgroupBallotBitCount(uint4 ballot, uint gl_SubgroupSize)
86 {
87 uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupSize, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupSize - 32, 0)), uint2(0));
88 return spvPopCount4(ballot & mask);
89 }
90
91 inline uint spvSubgroupBallotInclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID)
92 {
93 uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID + 1, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0)), uint2(0));
94 return spvPopCount4(ballot & mask);
95 }
96
97 inline uint spvSubgroupBallotExclusiveBitCount(uint4 ballot, uint gl_SubgroupInvocationID)
98 {
99 uint4 mask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID - 32, 0)), uint2(0));
100 return spvPopCount4(ballot & mask);
101 }
102
103 template<typename T>
104 inline bool spvSubgroupAllEqual(T value)
105 {
106 return simd_all(all(value == simd_broadcast_first(value)));
107 }
108
109 template<>
110 inline bool spvSubgroupAllEqual(bool value)
111 {
112 return simd_all(value) || !simd_any(value);
113 }
114
115 template<uint N>
116 inline bool spvSubgroupAllEqual(vec<bool, N> value)
117 {
118 return simd_all(all(value == (vec<bool, N>)simd_broadcast_first((vec<ushort, N>)value)));
119 }
120
121 template<typename T>
122 inline T spvSubgroupShuffle(T value, ushort lane)
123 {
124 return simd_shuffle(value, lane);
125 }
126
127 template<>
128 inline bool spvSubgroupShuffle(bool value, ushort lane)
129 {
130 return !!simd_shuffle((ushort)value, lane);
131 }
132
133 template<uint N>
134 inline vec<bool, N> spvSubgroupShuffle(vec<bool, N> value, ushort lane)
135 {
136 return (vec<bool, N>)simd_shuffle((vec<ushort, N>)value, lane);
137 }
138
139 template<typename T>
140 inline T spvSubgroupShuffleXor(T value, ushort mask)
141 {
142 return simd_shuffle_xor(value, mask);
143 }
144
145 template<>
146 inline bool spvSubgroupShuffleXor(bool value, ushort mask)
147 {
148 return !!simd_shuffle_xor((ushort)value, mask);
149 }
150
151 template<uint N>
152 inline vec<bool, N> spvSubgroupShuffleXor(vec<bool, N> value, ushort mask)
153 {
154 return (vec<bool, N>)simd_shuffle_xor((vec<ushort, N>)value, mask);
155 }
156
157 template<typename T>
158 inline T spvSubgroupShuffleUp(T value, ushort delta)
159 {
160 return simd_shuffle_up(value, delta);
161 }
162
163 template<>
164 inline bool spvSubgroupShuffleUp(bool value, ushort delta)
165 {
166 return !!simd_shuffle_up((ushort)value, delta);
167 }
168
169 template<uint N>
170 inline vec<bool, N> spvSubgroupShuffleUp(vec<bool, N> value, ushort delta)
171 {
172 return (vec<bool, N>)simd_shuffle_up((vec<ushort, N>)value, delta);
173 }
174
175 template<typename T>
176 inline T spvSubgroupShuffleDown(T value, ushort delta)
177 {
178 return simd_shuffle_down(value, delta);
179 }
180
181 template<>
182 inline bool spvSubgroupShuffleDown(bool value, ushort delta)
183 {
184 return !!simd_shuffle_down((ushort)value, delta);
185 }
186
187 template<uint N>
188 inline vec<bool, N> spvSubgroupShuffleDown(vec<bool, N> value, ushort delta)
189 {
190 return (vec<bool, N>)simd_shuffle_down((vec<ushort, N>)value, delta);
191 }
192
193 template<typename T>
194 inline T spvQuadBroadcast(T value, uint lane)
195 {
196 return quad_broadcast(value, lane);
197 }
198
199 template<>
200 inline bool spvQuadBroadcast(bool value, uint lane)
201 {
202 return !!quad_broadcast((ushort)value, lane);
203 }
204
205 template<uint N>
206 inline vec<bool, N> spvQuadBroadcast(vec<bool, N> value, uint lane)
207 {
208 return (vec<bool, N>)quad_broadcast((vec<ushort, N>)value, lane);
209 }
210
211 template<typename T>
212 inline T spvQuadSwap(T value, uint dir)
213 {
214 return quad_shuffle_xor(value, dir + 1);
215 }
216
217 template<>
218 inline bool spvQuadSwap(bool value, uint dir)
219 {
220 return !!quad_shuffle_xor((ushort)value, dir + 1);
221 }
222
223 template<uint N>
224 inline vec<bool, N> spvQuadSwap(vec<bool, N> value, uint dir)
225 {
226 return (vec<bool, N>)quad_shuffle_xor((vec<ushort, N>)value, dir + 1);
227 }
228
229 kernel void main0(device SSBO& _9 [[buffer(0)]], uint gl_NumSubgroups [[simdgroups_per_threadgroup]], uint gl_SubgroupID [[simdgroup_index_in_threadgroup]], uint gl_SubgroupSize [[thread_execution_width]], uint gl_SubgroupInvocationID [[thread_index_in_simdgroup]])
230 {
231 uint4 gl_SubgroupEqMask = gl_SubgroupInvocationID >= 32 ? uint4(0, (1 << (gl_SubgroupInvocationID - 32)), uint2(0)) : uint4(1 << gl_SubgroupInvocationID, uint3(0));
232 uint4 gl_SubgroupGeMask = uint4(insert_bits(0u, 0xFFFFFFFF, min(gl_SubgroupInvocationID, 32u), (uint)max(min((int)gl_SubgroupSize, 32) - (int)gl_SubgroupInvocationID, 0)), insert_bits(0u, 0xFFFFFFFF, (uint)max((int)gl_SubgroupInvocationID - 32, 0), (uint)max((int)gl_SubgroupSize - (int)max(gl_SubgroupInvocationID, 32u), 0)), uint2(0));
233 uint4 gl_SubgroupGtMask = uint4(insert_bits(0u, 0xFFFFFFFF, min(gl_SubgroupInvocationID + 1, 32u), (uint)max(min((int)gl_SubgroupSize, 32) - (int)gl_SubgroupInvocationID - 1, 0)), insert_bits(0u, 0xFFFFFFFF, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0), (uint)max((int)gl_SubgroupSize - (int)max(gl_SubgroupInvocationID + 1, 32u), 0)), uint2(0));
234 uint4 gl_SubgroupLeMask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID + 1, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID + 1 - 32, 0)), uint2(0));
235 uint4 gl_SubgroupLtMask = uint4(extract_bits(0xFFFFFFFF, 0, min(gl_SubgroupInvocationID, 32u)), extract_bits(0xFFFFFFFF, 0, (uint)max((int)gl_SubgroupInvocationID - 32, 0)), uint2(0));
236 _9.FragColor = float(gl_NumSubgroups);
237 _9.FragColor = float(gl_SubgroupID);
238 _9.FragColor = float(gl_SubgroupSize);
239 _9.FragColor = float(gl_SubgroupInvocationID);
240 simdgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture);
241 simdgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture);
242 simdgroup_barrier(mem_flags::mem_device);
243 simdgroup_barrier(mem_flags::mem_threadgroup);
244 simdgroup_barrier(mem_flags::mem_texture);
245 bool elected = simd_is_first();
246 _9.FragColor = float4(gl_SubgroupEqMask).x;
247 _9.FragColor = float4(gl_SubgroupGeMask).x;
248 _9.FragColor = float4(gl_SubgroupGtMask).x;
249 _9.FragColor = float4(gl_SubgroupLeMask).x;
250 _9.FragColor = float4(gl_SubgroupLtMask).x;
251 float4 broadcasted = spvSubgroupBroadcast(float4(10.0), 8u);
252 bool2 broadcasted_bool = spvSubgroupBroadcast(bool2(true), 8u);
253 float3 first = spvSubgroupBroadcastFirst(float3(20.0));
254 bool4 first_bool = spvSubgroupBroadcastFirst(bool4(false));
255 uint4 ballot_value = spvSubgroupBallot(true);
256 bool inverse_ballot_value = spvSubgroupBallotBitExtract(ballot_value, gl_SubgroupInvocationID);
257 bool bit_extracted = spvSubgroupBallotBitExtract(uint4(10u), 8u);
258 uint bit_count = spvSubgroupBallotBitCount(ballot_value, gl_SubgroupSize);
259 uint inclusive_bit_count = spvSubgroupBallotInclusiveBitCount(ballot_value, gl_SubgroupInvocationID);
260 uint exclusive_bit_count = spvSubgroupBallotExclusiveBitCount(ballot_value, gl_SubgroupInvocationID);
261 uint lsb = spvSubgroupBallotFindLSB(ballot_value, gl_SubgroupSize);
262 uint msb = spvSubgroupBallotFindMSB(ballot_value, gl_SubgroupSize);
263 uint shuffled = spvSubgroupShuffle(10u, 8u);
264 bool shuffled_bool = spvSubgroupShuffle(true, 9u);
265 uint shuffled_xor = spvSubgroupShuffleXor(30u, 8u);
266 bool shuffled_xor_bool = spvSubgroupShuffleXor(false, 9u);
267 uint shuffled_up = spvSubgroupShuffleUp(20u, 4u);
268 bool shuffled_up_bool = spvSubgroupShuffleUp(true, 4u);
269 uint shuffled_down = spvSubgroupShuffleDown(20u, 4u);
270 bool shuffled_down_bool = spvSubgroupShuffleDown(false, 4u);
271 bool has_all = simd_all(true);
272 bool has_any = simd_any(true);
273 bool has_equal = spvSubgroupAllEqual(0);
274 has_equal = spvSubgroupAllEqual(true);
275 has_equal = spvSubgroupAllEqual(float3(0.0, 1.0, 2.0));
276 has_equal = spvSubgroupAllEqual(bool4(true, true, false, true));
277 float4 added = simd_sum(float4(20.0));
278 int4 iadded = simd_sum(int4(20));
279 float4 multiplied = simd_product(float4(20.0));
280 int4 imultiplied = simd_product(int4(20));
281 float4 lo = simd_min(float4(20.0));
282 float4 hi = simd_max(float4(20.0));
283 int4 slo = simd_min(int4(20));
284 int4 shi = simd_max(int4(20));
285 uint4 ulo = simd_min(uint4(20u));
286 uint4 uhi = simd_max(uint4(20u));
287 uint4 anded = simd_and(ballot_value);
288 uint4 ored = simd_or(ballot_value);
289 uint4 xored = simd_xor(ballot_value);
290 added = simd_prefix_inclusive_sum(added);
291 iadded = simd_prefix_inclusive_sum(iadded);
292 multiplied = simd_prefix_inclusive_product(multiplied);
293 imultiplied = simd_prefix_inclusive_product(imultiplied);
294 added = simd_prefix_exclusive_sum(multiplied);
295 multiplied = simd_prefix_exclusive_product(multiplied);
296 iadded = simd_prefix_exclusive_sum(imultiplied);
297 imultiplied = simd_prefix_exclusive_product(imultiplied);
298 added = quad_sum(added);
299 multiplied = quad_product(multiplied);
300 iadded = quad_sum(iadded);
301 imultiplied = quad_product(imultiplied);
302 lo = quad_min(lo);
303 hi = quad_max(hi);
304 ulo = quad_min(ulo);
305 uhi = quad_max(uhi);
306 slo = quad_min(slo);
307 shi = quad_max(shi);
308 anded = quad_and(anded);
309 ored = quad_or(ored);
310 xored = quad_xor(xored);
311 float4 swap_horiz = spvQuadSwap(float4(20.0), 0u);
312 bool4 swap_horiz_bool = spvQuadSwap(bool4(true), 0u);
313 float4 swap_vertical = spvQuadSwap(float4(20.0), 1u);
314 bool4 swap_vertical_bool = spvQuadSwap(bool4(true), 1u);
315 float4 swap_diagonal = spvQuadSwap(float4(20.0), 2u);
316 bool4 swap_diagonal_bool = spvQuadSwap(bool4(true), 2u);
317 float4 quad_broadcast0 = spvQuadBroadcast(float4(20.0), 3u);
318 bool4 quad_broadcast_bool = spvQuadBroadcast(bool4(true), 3u);
319 }
320