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.TypeElement;
31 import jdk.incubator.code.Value;
32 import jdk.incubator.code.dialect.java.JavaType;
33 import optkl.util.ops.Precedence;
34
35 import java.util.List;
36
37 public abstract sealed class HATThreadOp extends HATOp implements Dim, Precedence.LoadOrConv
38 permits HATThreadOp.HAT_BI,
39 HATThreadOp.HAT_BS,
40 HATThreadOp.HAT_GS,
41 HATThreadOp.HAT_GI,
42 HATThreadOp.HAT_LS,
43 HATThreadOp.HAT_LI {
44
45 public HATThreadOp(List<Value> operands) {
46 super(operands);
47 }
48
49 protected HATThreadOp(HATThreadOp that, CodeContext cc) {
50 super(that, cc);
51 }
52
53 @Override
54 final public TypeElement resultType() {
55 return JavaType.INT;
56 }
57
58 public static HATThreadOp create(String name) {
59 return switch (name) {
60 case "gix" -> new HATThreadOp.HAT_GI.HAT_GIX();
61 case "giy" -> new HATThreadOp.HAT_GI.HAT_GIY();
62 case "giz" -> new HATThreadOp.HAT_GI.HAT_GIZ();
63 case "gsx" -> new HATThreadOp.HAT_GS.HAT_GSX();
64 case "gsy" -> new HATThreadOp.HAT_GS.HAT_GSY();
65 case "gsz" -> new HATThreadOp.HAT_GS.HAT_GSZ();
66 case "lix" -> new HATThreadOp.HAT_LI.HAT_LIX();
67 case "liy" -> new HATThreadOp.HAT_LI.HAT_LIY();
68 case "liz" -> new HATThreadOp.HAT_LI.HAT_LIZ();
69 case "lsx" -> new HATThreadOp.HAT_LS.HAT_LSX();
70 case "lsy" -> new HATThreadOp.HAT_LS.HAT_LSY();
71 case "lsz" -> new HATThreadOp.HAT_LS.HAT_LSZ();
72 case "bix" -> new HATThreadOp.HAT_BI.HAT_BIX();
73 case "biy" -> new HATThreadOp.HAT_BI.HAT_BIY();
74 case "biz" -> new HATThreadOp.HAT_BI.HAT_BIZ();
75 case "bsx" -> new HATThreadOp.HAT_BS.HAT_BSX();
76 case "bsy" -> new HATThreadOp.HAT_BS.HAT_BSY();
77 case "bsz" -> new HATThreadOp.HAT_BS.HAT_BSZ();
78 default -> throw new RuntimeException("[ERROR] Illegal/unsupported parallel construct: " + name);
79 };
80 }
81
82 public static sealed abstract class HAT_LI extends HATThreadOp permits HAT_LI.HAT_LIX, HAT_LI.HAT_LIY, HAT_LI.HAT_LIZ {
83
84 public HAT_LI() {
85 super(List.of());
86 }
87
88 public HAT_LI(HAT_LI op, CodeContext copyContext) {
89 super(op, copyContext);
90 }
91
92 public static final class HAT_LIX extends HAT_LI implements Dim.X {
93 public HAT_LIX(HAT_LIX op, CodeContext copyContext) {
94 super(op, copyContext);
95 }
96
97 public HAT_LIX() {
98 super();
99 }
100
101 @Override
102 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
103 return new HAT_LIX(this, copyContext);
104 }
105 }
106
107 public static final class HAT_LIY extends HAT_LI implements Dim.Y {
108 public HAT_LIY(HAT_LIY op, CodeContext copyContext) {
109 super(op, copyContext);
110 }
111
112 public HAT_LIY() {
113 super();
114 }
115
116 @Override
117 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
118 return new HAT_LIY(this, copyContext);
119 }
120 }
121
122 public static final class HAT_LIZ extends HAT_LI implements Dim.Z {
123 public HAT_LIZ(HAT_LI op, CodeContext copyContext) {
124 super(op, copyContext);
125 }
126
127 public HAT_LIZ() {
128 super();
129 }
130
131 @Override
132 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
133 return new HAT_LIZ(this, copyContext);
134 }
135 }
136 }
137
138 public static abstract sealed class HAT_BI extends HATThreadOp {
139 public HAT_BI() {
140 super(List.of());
141 }
142
143 public HAT_BI(HAT_BI op, CodeContext copyContext) {
144 super(op, copyContext);
145 }
146
147 public static final class HAT_BIX extends HAT_BI implements Dim.X {
148 public HAT_BIX(HAT_BI op, CodeContext copyContext) {
149 super(op, copyContext);
150 }
151
152 public HAT_BIX() {
153 super();
154 }
155
156 @Override
157 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
158 return new HAT_BIX(this, copyContext);
159 }
160 }
161
162 public static final class HAT_BIY extends HAT_BI implements Dim.Y {
163 public HAT_BIY(HAT_BI op, CodeContext copyContext) {
164 super(op, copyContext);
165 }
166
167 public HAT_BIY() {
168 super();
169 }
170
171 @Override
172 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
173 return new HAT_BIY(this, copyContext);
174 }
175 }
176
177 public static final class HAT_BIZ extends HAT_BI implements Dim.Z {
178 public HAT_BIZ(HAT_BI op, CodeContext copyContext) {
179 super(op, copyContext);
180 }
181
182 public HAT_BIZ() {
183 super();
184 }
185
186 @Override
187 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
188 return new HAT_BIZ(this, copyContext);
189 }
190 }
191 }
192
193 public static abstract sealed class HAT_BS extends HATThreadOp {
194
195 public HAT_BS() {
196 super(List.of());
197 }
198
199 public HAT_BS(HAT_BS op, CodeContext copyContext) {
200 super(op, copyContext);
201 }
202
203 public static final class HAT_BSX extends HAT_BS implements Dim.X {
204
205 public HAT_BSX(HAT_BS op, CodeContext copyContext) {
206 super(op, copyContext);
207 }
208
209 public HAT_BSX() {
210 super();
211 }
212
213 @Override
214 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
215 return new HAT_BSX(this, copyContext);
216 }
217 }
218
219 public static final class HAT_BSY extends HAT_BS implements Dim.Y {
220
221 public HAT_BSY(HAT_BS op, CodeContext copyContext) {
222 super(op, copyContext);
223 }
224
225 public HAT_BSY() {
226 super();
227 }
228
229 @Override
230 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
231 return new HAT_BSY(this, copyContext);
232 }
233
234 }
235
236 public static final class HAT_BSZ extends HAT_BS implements Dim.Z {
237
238 public HAT_BSZ(HAT_BS op, CodeContext copyContext) {
239 super(op, copyContext);
240 }
241
242 public HAT_BSZ() {
243 super();
244 }
245
246 @Override
247 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
248 return new HAT_BSZ(this, copyContext);
249 }
250 }
251 }
252
253 public static abstract sealed class HAT_LS extends HATThreadOp permits HAT_LS.HAT_LSX, HAT_LS.HAT_LSY, HAT_LS.HAT_LSZ {
254
255 public HAT_LS() {
256 super(List.of());
257 }
258
259 public HAT_LS(HAT_LS op, CodeContext copyContext) {
260 super(op, copyContext);
261 }
262
263 public static final class HAT_LSX extends HAT_LS implements Dim.X {
264 public HAT_LSX(HAT_LS op, CodeContext copyContext) {
265 super(op, copyContext);
266 }
267
268 public HAT_LSX() {
269 super();
270 }
271
272 @Override
273 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
274 return new HAT_LSX(this, copyContext);
275 }
276 }
277
278 public static final class HAT_LSY extends HAT_LS implements Dim.Y {
279 public HAT_LSY(HAT_LS op, CodeContext copyContext) {
280 super(op, copyContext);
281 }
282
283 public HAT_LSY() {
284 super();
285 }
286
287 @Override
288 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
289 return new HAT_LSY(this, copyContext);
290 }
291 }
292
293 public static final class HAT_LSZ extends HAT_LS implements Dim.Z {
294 public HAT_LSZ(HAT_LS op, CodeContext copyContext) {
295 super(op, copyContext);
296 }
297
298 public HAT_LSZ() {
299 super();
300 }
301
302 @Override
303 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
304 return new HAT_LSZ(this, copyContext);
305 }
306 }
307 }
308
309 public static abstract sealed class HAT_GI extends HATThreadOp
310 permits HAT_GI.HAT_GIX, HAT_GI.HAT_GIY, HAT_GI.HAT_GIZ {
311
312 public HAT_GI() {
313 super(List.of());
314 }
315
316 public HAT_GI(HAT_GI op, CodeContext copyContext) {
317 super(op, copyContext);
318 }
319
320 public static final class HAT_GIX extends HAT_GI implements Dim.X {
321 public HAT_GIX(HAT_GI op, CodeContext copyContext) {
322 super(op, copyContext);
323 }
324
325 public HAT_GIX() {
326 super();
327 }
328
329 @Override
330 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
331 return new HAT_GIX(this, copyContext);
332 }
333 }
334
335 public static final class HAT_GIY extends HAT_GI implements Dim.Y {
336 public HAT_GIY(HAT_GI op, CodeContext copyContext) {
337 super(op, copyContext);
338 }
339
340 public HAT_GIY() {
341 super();
342 }
343
344 @Override
345 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
346 return new HAT_GIY(this, copyContext);
347 }
348 }
349
350 public static final class HAT_GIZ extends HAT_GI implements Dim.Z {
351 public HAT_GIZ(HAT_GI op, CodeContext copyContext) {
352 super(op, copyContext);
353 }
354
355 public HAT_GIZ() {
356 super();
357 }
358
359 @Override
360 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
361 return new HAT_GIZ(this, copyContext);
362 }
363 }
364 }
365
366 public static abstract sealed class HAT_GS extends HATThreadOp permits HAT_GS.HAT_GSY, HAT_GS.HAT_GSX, HAT_GS.HAT_GSZ {
367 public HAT_GS() {
368 super(List.of());
369 }
370
371 public HAT_GS(HAT_GS op, CodeContext copyContext) {
372 super(op, copyContext);
373 }
374
375 public static final class HAT_GSX extends HAT_GS implements Dim.X {
376 public HAT_GSX(HAT_GS op, CodeContext copyContext) {
377 super(op, copyContext);
378 }
379
380 public HAT_GSX() {
381 super();
382 }
383
384 @Override
385 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
386 return new HAT_GSX(this, copyContext);
387 }
388 }
389
390 public static final class HAT_GSY extends HAT_GS implements Dim.Y {
391 public HAT_GSY(HAT_GS op, CodeContext copyContext) {
392 super(op, copyContext);
393 }
394
395 public HAT_GSY() {
396 super();
397 }
398
399 @Override
400 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
401 return new HAT_GSY(this, copyContext);
402 }
403 }
404
405 public static final class HAT_GSZ extends HAT_GS implements Dim.Z {
406 public HAT_GSZ(HAT_GS op, CodeContext copyContext) {
407 super(op, copyContext);
408 }
409
410 public HAT_GSZ() {
411 super();
412 }
413
414 @Override
415 public Op transform(CodeContext copyContext, CodeTransformer opTransformer) {
416 return new HAT_GSZ(this, copyContext);
417 }
418 }
419 }
420 }