1 /*
2 * Copyright (c) 2025-2026, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package hat.dialect;
26
27 import jdk.incubator.code.CodeContext;
28 import jdk.incubator.code.CodeTransformer;
29 import jdk.incubator.code.Op;
30 import jdk.incubator.code.CodeType;
31 import jdk.incubator.code.Value;
32 import jdk.incubator.code.dialect.java.JavaType;
33 import optkl.util.ops.Precedence.LoadOrConv;
34
35 import java.util.List;
36
37 public abstract sealed class HATThreadOp extends HATOp implements Dim, LoadOrConv {
38
39 protected HATThreadOp(List<Value> operands) {
40 super(operands);
41 }
42
43 protected HATThreadOp(HATThreadOp that, CodeContext cc) {
44 super(that, cc);
45 }
46
47 @Override
48 public final CodeType resultType() {
49 return JavaType.INT;
50 }
51
52 public static HATThreadOp create(String name) {
53 return switch (name) {
54 case "gix" -> new HATThreadOp.HAT_GI.HAT_GIX();
55 case "giy" -> new HATThreadOp.HAT_GI.HAT_GIY();
56 case "giz" -> new HATThreadOp.HAT_GI.HAT_GIZ();
57 case "gsx" -> new HATThreadOp.HAT_GS.HAT_GSX();
58 case "gsy" -> new HATThreadOp.HAT_GS.HAT_GSY();
59 case "gsz" -> new HATThreadOp.HAT_GS.HAT_GSZ();
60 case "lix" -> new HATThreadOp.HAT_LI.HAT_LIX();
61 case "liy" -> new HATThreadOp.HAT_LI.HAT_LIY();
62 case "liz" -> new HATThreadOp.HAT_LI.HAT_LIZ();
63 case "lsx" -> new HATThreadOp.HAT_LS.HAT_LSX();
64 case "lsy" -> new HATThreadOp.HAT_LS.HAT_LSY();
65 case "lsz" -> new HATThreadOp.HAT_LS.HAT_LSZ();
66 case "bix" -> new HATThreadOp.HAT_BI.HAT_BIX();
67 case "biy" -> new HATThreadOp.HAT_BI.HAT_BIY();
68 case "biz" -> new HATThreadOp.HAT_BI.HAT_BIZ();
69 case "bsx" -> new HATThreadOp.HAT_BS.HAT_BSX();
70 case "bsy" -> new HATThreadOp.HAT_BS.HAT_BSY();
71 case "bsz" -> new HATThreadOp.HAT_BS.HAT_BSZ();
72 case "wrs" -> new HATThreadOp.HAT_WARP_SIZE();
73 default -> throw new IllegalStateException("[ERROR] Illegal/unsupported parallel construct: " + name);
74 };
75 }
76
77 public abstract static sealed class HAT_LI extends HATThreadOp {
78
79 protected HAT_LI() {
80 super(List.of());
81 }
82
83 protected HAT_LI(HAT_LI op, CodeContext copyContext) {
84 super(op, copyContext);
85 }
86
87 public static final class HAT_LIX extends HAT_LI implements Dim.X {
88 public HAT_LIX(HAT_LIX op, CodeContext copyContext) {
89 super(op, copyContext);
90 }
91
92 public HAT_LIX() {
93 super();
94 }
95
96 @Override
97 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
98 return new HAT_LIX(this, copyContext);
99 }
100 }
101
102 public static final class HAT_LIY extends HAT_LI implements Dim.Y {
103 public HAT_LIY(HAT_LIY op, CodeContext copyContext) {
104 super(op, copyContext);
105 }
106
107 public HAT_LIY() {
108 super();
109 }
110
111 @Override
112 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
113 return new HAT_LIY(this, copyContext);
114 }
115 }
116
117 public static final class HAT_LIZ extends HAT_LI implements Dim.Z {
118 public HAT_LIZ(HAT_LI op, CodeContext copyContext) {
119 super(op, copyContext);
120 }
121
122 public HAT_LIZ() {
123 super();
124 }
125
126 @Override
127 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
128 return new HAT_LIZ(this, copyContext);
129 }
130 }
131 }
132
133 public abstract static sealed class HAT_BI extends HATThreadOp {
134 protected HAT_BI() {
135 super(List.of());
136 }
137
138 protected HAT_BI(HAT_BI op, CodeContext copyContext) {
139 super(op, copyContext);
140 }
141
142 public static final class HAT_BIX extends HAT_BI implements Dim.X {
143 public HAT_BIX(HAT_BI op, CodeContext copyContext) {
144 super(op, copyContext);
145 }
146
147 public HAT_BIX() {
148 super();
149 }
150
151 @Override
152 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
153 return new HAT_BIX(this, copyContext);
154 }
155 }
156
157 public static final class HAT_BIY extends HAT_BI implements Dim.Y {
158 public HAT_BIY(HAT_BI op, CodeContext copyContext) {
159 super(op, copyContext);
160 }
161
162 public HAT_BIY() {
163 super();
164 }
165
166 @Override
167 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
168 return new HAT_BIY(this, copyContext);
169 }
170 }
171
172 public static final class HAT_BIZ extends HAT_BI implements Dim.Z {
173 public HAT_BIZ(HAT_BI op, CodeContext copyContext) {
174 super(op, copyContext);
175 }
176
177 public HAT_BIZ() {
178 super();
179 }
180
181 @Override
182 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
183 return new HAT_BIZ(this, copyContext);
184 }
185 }
186 }
187
188 public abstract static sealed class HAT_BS extends HATThreadOp {
189
190 protected HAT_BS() {
191 super(List.of());
192 }
193
194 protected HAT_BS(HAT_BS op, CodeContext copyContext) {
195 super(op, copyContext);
196 }
197
198 public static final class HAT_BSX extends HAT_BS implements Dim.X {
199
200 public HAT_BSX(HAT_BS op, CodeContext copyContext) {
201 super(op, copyContext);
202 }
203
204 public HAT_BSX() {
205 super();
206 }
207
208 @Override
209 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
210 return new HAT_BSX(this, copyContext);
211 }
212 }
213
214 public static final class HAT_BSY extends HAT_BS implements Dim.Y {
215
216 public HAT_BSY(HAT_BS op, CodeContext copyContext) {
217 super(op, copyContext);
218 }
219
220 public HAT_BSY() {
221 super();
222 }
223
224 @Override
225 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
226 return new HAT_BSY(this, copyContext);
227 }
228
229 }
230
231 public static final class HAT_BSZ extends HAT_BS implements Dim.Z {
232
233 public HAT_BSZ(HAT_BS op, CodeContext copyContext) {
234 super(op, copyContext);
235 }
236
237 public HAT_BSZ() {
238 super();
239 }
240
241 @Override
242 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
243 return new HAT_BSZ(this, copyContext);
244 }
245 }
246 }
247
248 public abstract static sealed class HAT_LS extends HATThreadOp {
249
250 protected HAT_LS() {
251 super(List.of());
252 }
253
254 protected HAT_LS(HAT_LS op, CodeContext copyContext) {
255 super(op, copyContext);
256 }
257
258 public static final class HAT_LSX extends HAT_LS implements Dim.X {
259 public HAT_LSX(HAT_LS op, CodeContext copyContext) {
260 super(op, copyContext);
261 }
262
263 public HAT_LSX() {
264 super();
265 }
266
267 @Override
268 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
269 return new HAT_LSX(this, copyContext);
270 }
271 }
272
273 public static final class HAT_LSY extends HAT_LS implements Dim.Y {
274 public HAT_LSY(HAT_LS op, CodeContext copyContext) {
275 super(op, copyContext);
276 }
277
278 public HAT_LSY() {
279 super();
280 }
281
282 @Override
283 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
284 return new HAT_LSY(this, copyContext);
285 }
286 }
287
288 public static final class HAT_LSZ extends HAT_LS implements Dim.Z {
289 public HAT_LSZ(HAT_LS op, CodeContext copyContext) {
290 super(op, copyContext);
291 }
292
293 public HAT_LSZ() {
294 super();
295 }
296
297 @Override
298 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
299 return new HAT_LSZ(this, copyContext);
300 }
301 }
302 }
303
304 public abstract static sealed class HAT_GI extends HATThreadOp {
305
306 protected HAT_GI() {
307 super(List.of());
308 }
309
310 protected HAT_GI(HAT_GI op, CodeContext copyContext) {
311 super(op, copyContext);
312 }
313
314 public static final class HAT_GIX extends HAT_GI implements Dim.X {
315 public HAT_GIX(HAT_GI op, CodeContext copyContext) {
316 super(op, copyContext);
317 }
318
319 public HAT_GIX() {
320 super();
321 }
322
323 @Override
324 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
325 return new HAT_GIX(this, copyContext);
326 }
327 }
328
329 public static final class HAT_GIY extends HAT_GI implements Dim.Y {
330 public HAT_GIY(HAT_GI op, CodeContext copyContext) {
331 super(op, copyContext);
332 }
333
334 public HAT_GIY() {
335 super();
336 }
337
338 @Override
339 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
340 return new HAT_GIY(this, copyContext);
341 }
342 }
343
344 public static final class HAT_GIZ extends HAT_GI implements Dim.Z {
345 public HAT_GIZ(HAT_GI op, CodeContext copyContext) {
346 super(op, copyContext);
347 }
348
349 public HAT_GIZ() {
350 super();
351 }
352
353 @Override
354 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
355 return new HAT_GIZ(this, copyContext);
356 }
357 }
358 }
359
360 public abstract static sealed class HAT_GS extends HATThreadOp {
361
362 protected HAT_GS() {
363 super(List.of());
364 }
365
366 protected HAT_GS(HAT_GS op, CodeContext copyContext) {
367 super(op, copyContext);
368 }
369
370 public static final class HAT_GSX extends HAT_GS implements Dim.X {
371 public HAT_GSX(HAT_GS op, CodeContext copyContext) {
372 super(op, copyContext);
373 }
374
375 public HAT_GSX() {
376 super();
377 }
378
379 @Override
380 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
381 return new HAT_GSX(this, copyContext);
382 }
383 }
384
385 public static final class HAT_GSY extends HAT_GS implements Dim.Y {
386 public HAT_GSY(HAT_GS op, CodeContext copyContext) {
387 super(op, copyContext);
388 }
389
390 public HAT_GSY() {
391 super();
392 }
393
394 @Override
395 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
396 return new HAT_GSY(this, copyContext);
397 }
398 }
399
400 public static final class HAT_GSZ extends HAT_GS implements Dim.Z {
401 public HAT_GSZ(HAT_GS op, CodeContext copyContext) {
402 super(op, copyContext);
403 }
404
405 public HAT_GSZ() {
406 super();
407 }
408
409 @Override
410 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
411 return new HAT_GSZ(this, copyContext);
412 }
413 }
414 }
415
416 public static final class HAT_WARP_SIZE extends HATThreadOp {
417
418 public HAT_WARP_SIZE() {
419 super(List.of());
420 }
421
422 public HAT_WARP_SIZE(HAT_WARP_SIZE op, CodeContext codeContext) {
423 super(op, codeContext);
424 }
425
426 @Override
427 public Op transform(CodeContext codeContext, CodeTransformer codeTransformer) {
428 return new HAT_WARP_SIZE(this, codeContext);
429 }
430 }
431 }