ptx_parser/unparser/instruction/
mma_sp.rs

1//! Original PTX specification:
2//!
3//! // Half precision floating point type:
4//! mma.spvariant.sync.aligned.m16n8k16.row.col.dtype.f16.f16.ctype  d, a, b, c, e, f;
5//! mma.spvariant.sync.aligned.m16n8k32.row.col.dtype.f16.f16.ctype  d, a, b, c, e, f;
6//! .ctype     = {.f16, .f32};
7//! .dtype     = {.f16, .f32};
8//! .spvariant = {.sp, .sp::ordered_metadata};
9//! ----------------------------------------------------
10//! // Alternate floating point type:
11//! mma.spvariant.sync.aligned.m16n8k16.row.col.f32.bf16.bf16.f32     d, a, b, c, e, f;
12//! mma.spvariant.sync.aligned.m16n8k32.row.col.f32.bf16.bf16.f32     d, a, b, c, e, f;
13//! mma.spvariant.sync.aligned.m16n8k8.row.col.f32.tf32.tf32.f32      d, a, b, c, e, f;
14//! mma.spvariant.sync.aligned.m16n8k16.row.col.f32.tf32.tf32.f32     d, a, b, c, e, f;
15//! mma.spvariant.sync.aligned.m16n8k64.row.col.f32.f8type.f8type.f32 d, a, b, c, e, f;
16//! mma.sp::ordered_metadata.sync.aligned.m16n8k64.row.col.kind.dtype.f8f6f4type.f8f6f4type.ctype d, a, b, c, e, f;
17//! .f8type     = {.e4m3, .e5m2};
18//! .spvariant  = {.sp, .sp::ordered_metadata};
19//! .f8f6f4type = {.e4m3, .e5m2, .e3m2, .e2m3, .e2m1};
20//! .kind       = {.kind::f8f6f4};
21//! .ctype      = {.f16, .f32};
22//! .dtype      = {.f16, .f32};
23//! ----------------------------------------------------
24//! // Alternate floating point type:
25//! // Alternate floating point type with block scaling:
26//! mma.spvariant.sync.aligned.m16n8k128.row.col.kind.block_scale{.scale_vec_size}.f32.e2m1.e2m1.f32.stype d, a, b, c, e, f, scale-a-data, {byte-id-a, thread-id-a}, scale-b-data, {byte-id-b, thread-id-b};
27//! .spvariant      = {.sp::ordered_metadata};
28//! .kind           = {.kind::mxf4};
29//! .scale_vec_size = {.scale_vec::2X};
30//! .stype          = {.ue8m0};
31//! ----------------------------------------------------
32//! // Alternate floating point type:
33//! mma.spvariant.sync.aligned.m16n8k128.row.col.kind.block_scale.scale_vec_size.f32.e2m1.e2m1.f32.stype d, a, b, c, e, f, scale-a-data, {byte-id-a, thread-id-a}, scale-b-data, {byte-id-b, thread-id-b};
34//! .spvariant      = {.sp::ordered_metadata};
35//! .kind           = {.kind::mxf4nvf4};
36//! .scale_vec_size = {.scale_vec::2X, .scale_vec::4X};
37//! .stype          = {.ue8m0, .ue4m3};
38//! ----------------------------------------------------
39//! // Alternate floating point type:
40//! mma.spvariant.sync.aligned.m16n8k64.row.col.kind.block_scale{.scale_vec_size}.f32.f8f6f4type.f8f6f4type.f32.stype d, a, b, c, e, f, scale-a-data, {byte-id-a, thread-id-a}, scale-b-data, {byte-id-b, thread-id-b};
41//! .spvariant      = {.sp::ordered_metadata};
42//! .kind           = {.kind::mxf8f6f4};
43//! .scale_vec_size = {.scale_vec::1X};
44//! .f8f6f4type     = {.e4m3, .e5m2, .e3m2, .e2m3, .e2m1};
45//! .stype          = {.ue8m0};
46//! ----------------------------------------------------
47//! // Alternate floating point type:
48//! // Integer type:
49//! mma.spvariant.sync.aligned.shape.row.col{.satfinite}.s32.atype.btype.s32 d, a, b, c, e, f;
50//! .shape     = {.m16n8k32, .m16n8k64};
51//! .atype     = {.u8, .s8};
52//! .btype     = {.u8, .s8};
53//! .spvariant = {.sp, .sp::ordered_metadata};
54//! ----------------------------------------------------
55//! // Alternate floating point type:
56//! mma.spvariant.sync.aligned.shape.row.col{.satfinite}.s32.atype.btype.s32 d, a, b, c, e, f;
57//! .shape     = {.m16n8k64, .m16n8k128};
58//! .atype     = {.u4, .s4};
59//! .btype     = {.u4, .s4};
60//! .spvariant = {.sp, .sp::ordered_metadata};
61
62#![allow(unused)]
63
64use crate::lexer::PtxToken;
65use crate::unparser::{PtxUnparser, common::*};
66
67pub mod section_0 {
68    use super::*;
69    use crate::r#type::instruction::mma_sp::section_0::*;
70
71    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k16RowColDtypeF16F16Ctype {
72        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
73            push_opcode(tokens, "mma");
74            match &self.spvariant {
75                Spvariant::SpOrderedMetadata => {
76                    push_directive(tokens, "sp::ordered_metadata");
77                }
78                Spvariant::Sp => {
79                    push_directive(tokens, "sp");
80                }
81            }
82            push_directive(tokens, "sync");
83            push_directive(tokens, "aligned");
84            push_directive(tokens, "m16n8k16");
85            push_directive(tokens, "row");
86            push_directive(tokens, "col");
87            match &self.dtype {
88                Dtype::F16 => {
89                    push_directive(tokens, "f16");
90                }
91                Dtype::F32 => {
92                    push_directive(tokens, "f32");
93                }
94            }
95            push_directive(tokens, "f16");
96            push_directive(tokens, "f16");
97            match &self.ctype {
98                Ctype::F16 => {
99                    push_directive(tokens, "f16");
100                }
101                Ctype::F32 => {
102                    push_directive(tokens, "f32");
103                }
104            }
105            self.d.unparse_tokens(tokens);
106            tokens.push(PtxToken::Comma);
107            self.a.unparse_tokens(tokens);
108            tokens.push(PtxToken::Comma);
109            self.b.unparse_tokens(tokens);
110            tokens.push(PtxToken::Comma);
111            self.c.unparse_tokens(tokens);
112            tokens.push(PtxToken::Comma);
113            self.e.unparse_tokens(tokens);
114            tokens.push(PtxToken::Comma);
115            self.f.unparse_tokens(tokens);
116            tokens.push(PtxToken::Semicolon);
117        }
118    }
119
120    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k32RowColDtypeF16F16Ctype {
121        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
122            push_opcode(tokens, "mma");
123            match &self.spvariant {
124                Spvariant::SpOrderedMetadata => {
125                    push_directive(tokens, "sp::ordered_metadata");
126                }
127                Spvariant::Sp => {
128                    push_directive(tokens, "sp");
129                }
130            }
131            push_directive(tokens, "sync");
132            push_directive(tokens, "aligned");
133            push_directive(tokens, "m16n8k32");
134            push_directive(tokens, "row");
135            push_directive(tokens, "col");
136            match &self.dtype {
137                Dtype::F16 => {
138                    push_directive(tokens, "f16");
139                }
140                Dtype::F32 => {
141                    push_directive(tokens, "f32");
142                }
143            }
144            push_directive(tokens, "f16");
145            push_directive(tokens, "f16");
146            match &self.ctype {
147                Ctype::F16 => {
148                    push_directive(tokens, "f16");
149                }
150                Ctype::F32 => {
151                    push_directive(tokens, "f32");
152                }
153            }
154            self.d.unparse_tokens(tokens);
155            tokens.push(PtxToken::Comma);
156            self.a.unparse_tokens(tokens);
157            tokens.push(PtxToken::Comma);
158            self.b.unparse_tokens(tokens);
159            tokens.push(PtxToken::Comma);
160            self.c.unparse_tokens(tokens);
161            tokens.push(PtxToken::Comma);
162            self.e.unparse_tokens(tokens);
163            tokens.push(PtxToken::Comma);
164            self.f.unparse_tokens(tokens);
165            tokens.push(PtxToken::Semicolon);
166        }
167    }
168}
169
170pub mod section_1 {
171    use super::*;
172    use crate::r#type::instruction::mma_sp::section_1::*;
173
174    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k16RowColF32Bf16Bf16F32 {
175        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
176            push_opcode(tokens, "mma");
177            match &self.spvariant {
178                Spvariant::SpOrderedMetadata => {
179                    push_directive(tokens, "sp::ordered_metadata");
180                }
181                Spvariant::Sp => {
182                    push_directive(tokens, "sp");
183                }
184            }
185            push_directive(tokens, "sync");
186            push_directive(tokens, "aligned");
187            push_directive(tokens, "m16n8k16");
188            push_directive(tokens, "row");
189            push_directive(tokens, "col");
190            push_directive(tokens, "f32");
191            push_directive(tokens, "bf16");
192            push_directive(tokens, "bf16");
193            push_directive(tokens, "f32");
194            self.d.unparse_tokens(tokens);
195            tokens.push(PtxToken::Comma);
196            self.a.unparse_tokens(tokens);
197            tokens.push(PtxToken::Comma);
198            self.b.unparse_tokens(tokens);
199            tokens.push(PtxToken::Comma);
200            self.c.unparse_tokens(tokens);
201            tokens.push(PtxToken::Comma);
202            self.e.unparse_tokens(tokens);
203            tokens.push(PtxToken::Comma);
204            self.f.unparse_tokens(tokens);
205            tokens.push(PtxToken::Semicolon);
206        }
207    }
208
209    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k32RowColF32Bf16Bf16F32 {
210        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
211            push_opcode(tokens, "mma");
212            match &self.spvariant {
213                Spvariant::SpOrderedMetadata => {
214                    push_directive(tokens, "sp::ordered_metadata");
215                }
216                Spvariant::Sp => {
217                    push_directive(tokens, "sp");
218                }
219            }
220            push_directive(tokens, "sync");
221            push_directive(tokens, "aligned");
222            push_directive(tokens, "m16n8k32");
223            push_directive(tokens, "row");
224            push_directive(tokens, "col");
225            push_directive(tokens, "f32");
226            push_directive(tokens, "bf16");
227            push_directive(tokens, "bf16");
228            push_directive(tokens, "f32");
229            self.d.unparse_tokens(tokens);
230            tokens.push(PtxToken::Comma);
231            self.a.unparse_tokens(tokens);
232            tokens.push(PtxToken::Comma);
233            self.b.unparse_tokens(tokens);
234            tokens.push(PtxToken::Comma);
235            self.c.unparse_tokens(tokens);
236            tokens.push(PtxToken::Comma);
237            self.e.unparse_tokens(tokens);
238            tokens.push(PtxToken::Comma);
239            self.f.unparse_tokens(tokens);
240            tokens.push(PtxToken::Semicolon);
241        }
242    }
243
244    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k8RowColF32Tf32Tf32F32 {
245        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
246            push_opcode(tokens, "mma");
247            match &self.spvariant {
248                Spvariant::SpOrderedMetadata => {
249                    push_directive(tokens, "sp::ordered_metadata");
250                }
251                Spvariant::Sp => {
252                    push_directive(tokens, "sp");
253                }
254            }
255            push_directive(tokens, "sync");
256            push_directive(tokens, "aligned");
257            push_directive(tokens, "m16n8k8");
258            push_directive(tokens, "row");
259            push_directive(tokens, "col");
260            push_directive(tokens, "f32");
261            push_directive(tokens, "tf32");
262            push_directive(tokens, "tf32");
263            push_directive(tokens, "f32");
264            self.d.unparse_tokens(tokens);
265            tokens.push(PtxToken::Comma);
266            self.a.unparse_tokens(tokens);
267            tokens.push(PtxToken::Comma);
268            self.b.unparse_tokens(tokens);
269            tokens.push(PtxToken::Comma);
270            self.c.unparse_tokens(tokens);
271            tokens.push(PtxToken::Comma);
272            self.e.unparse_tokens(tokens);
273            tokens.push(PtxToken::Comma);
274            self.f.unparse_tokens(tokens);
275            tokens.push(PtxToken::Semicolon);
276        }
277    }
278
279    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k16RowColF32Tf32Tf32F32 {
280        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
281            push_opcode(tokens, "mma");
282            match &self.spvariant {
283                Spvariant::SpOrderedMetadata => {
284                    push_directive(tokens, "sp::ordered_metadata");
285                }
286                Spvariant::Sp => {
287                    push_directive(tokens, "sp");
288                }
289            }
290            push_directive(tokens, "sync");
291            push_directive(tokens, "aligned");
292            push_directive(tokens, "m16n8k16");
293            push_directive(tokens, "row");
294            push_directive(tokens, "col");
295            push_directive(tokens, "f32");
296            push_directive(tokens, "tf32");
297            push_directive(tokens, "tf32");
298            push_directive(tokens, "f32");
299            self.d.unparse_tokens(tokens);
300            tokens.push(PtxToken::Comma);
301            self.a.unparse_tokens(tokens);
302            tokens.push(PtxToken::Comma);
303            self.b.unparse_tokens(tokens);
304            tokens.push(PtxToken::Comma);
305            self.c.unparse_tokens(tokens);
306            tokens.push(PtxToken::Comma);
307            self.e.unparse_tokens(tokens);
308            tokens.push(PtxToken::Comma);
309            self.f.unparse_tokens(tokens);
310            tokens.push(PtxToken::Semicolon);
311        }
312    }
313
314    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k64RowColF32F8typeF8typeF32 {
315        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
316            push_opcode(tokens, "mma");
317            match &self.spvariant {
318                Spvariant::SpOrderedMetadata => {
319                    push_directive(tokens, "sp::ordered_metadata");
320                }
321                Spvariant::Sp => {
322                    push_directive(tokens, "sp");
323                }
324            }
325            push_directive(tokens, "sync");
326            push_directive(tokens, "aligned");
327            push_directive(tokens, "m16n8k64");
328            push_directive(tokens, "row");
329            push_directive(tokens, "col");
330            push_directive(tokens, "f32");
331            match &self.f8type {
332                F8type::E4m3 => {
333                    push_directive(tokens, "e4m3");
334                }
335                F8type::E5m2 => {
336                    push_directive(tokens, "e5m2");
337                }
338            }
339            match &self.f8type1 {
340                F8type::E4m3 => {
341                    push_directive(tokens, "e4m3");
342                }
343                F8type::E5m2 => {
344                    push_directive(tokens, "e5m2");
345                }
346            }
347            push_directive(tokens, "f32");
348            self.d.unparse_tokens(tokens);
349            tokens.push(PtxToken::Comma);
350            self.a.unparse_tokens(tokens);
351            tokens.push(PtxToken::Comma);
352            self.b.unparse_tokens(tokens);
353            tokens.push(PtxToken::Comma);
354            self.c.unparse_tokens(tokens);
355            tokens.push(PtxToken::Comma);
356            self.e.unparse_tokens(tokens);
357            tokens.push(PtxToken::Comma);
358            self.f.unparse_tokens(tokens);
359            tokens.push(PtxToken::Semicolon);
360        }
361    }
362
363    impl PtxUnparser
364        for MmaSpOrderedMetadataSyncAlignedM16n8k64RowColKindDtypeF8f6f4typeF8f6f4typeCtype
365    {
366        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
367            push_opcode(tokens, "mma");
368            push_directive(tokens, "sp::ordered_metadata");
369            push_directive(tokens, "sync");
370            push_directive(tokens, "aligned");
371            push_directive(tokens, "m16n8k64");
372            push_directive(tokens, "row");
373            push_directive(tokens, "col");
374            match &self.kind {
375                Kind::KindF8f6f4 => {
376                    push_directive(tokens, "kind::f8f6f4");
377                }
378            }
379            match &self.dtype {
380                Dtype::F16 => {
381                    push_directive(tokens, "f16");
382                }
383                Dtype::F32 => {
384                    push_directive(tokens, "f32");
385                }
386            }
387            match &self.f8f6f4type {
388                F8f6f4type::E4m3 => {
389                    push_directive(tokens, "e4m3");
390                }
391                F8f6f4type::E5m2 => {
392                    push_directive(tokens, "e5m2");
393                }
394                F8f6f4type::E3m2 => {
395                    push_directive(tokens, "e3m2");
396                }
397                F8f6f4type::E2m3 => {
398                    push_directive(tokens, "e2m3");
399                }
400                F8f6f4type::E2m1 => {
401                    push_directive(tokens, "e2m1");
402                }
403            }
404            match &self.f8f6f4type1 {
405                F8f6f4type::E4m3 => {
406                    push_directive(tokens, "e4m3");
407                }
408                F8f6f4type::E5m2 => {
409                    push_directive(tokens, "e5m2");
410                }
411                F8f6f4type::E3m2 => {
412                    push_directive(tokens, "e3m2");
413                }
414                F8f6f4type::E2m3 => {
415                    push_directive(tokens, "e2m3");
416                }
417                F8f6f4type::E2m1 => {
418                    push_directive(tokens, "e2m1");
419                }
420            }
421            match &self.ctype {
422                Ctype::F16 => {
423                    push_directive(tokens, "f16");
424                }
425                Ctype::F32 => {
426                    push_directive(tokens, "f32");
427                }
428            }
429            self.d.unparse_tokens(tokens);
430            tokens.push(PtxToken::Comma);
431            self.a.unparse_tokens(tokens);
432            tokens.push(PtxToken::Comma);
433            self.b.unparse_tokens(tokens);
434            tokens.push(PtxToken::Comma);
435            self.c.unparse_tokens(tokens);
436            tokens.push(PtxToken::Comma);
437            self.e.unparse_tokens(tokens);
438            tokens.push(PtxToken::Comma);
439            self.f.unparse_tokens(tokens);
440            tokens.push(PtxToken::Semicolon);
441        }
442    }
443}
444
445pub mod section_2 {
446    use super::*;
447    use crate::r#type::instruction::mma_sp::section_2::*;
448
449    impl PtxUnparser
450        for MmaSpvariantSyncAlignedM16n8k128RowColKindBlockScaleScaleVecSizeF32E2m1E2m1F32Stype
451    {
452        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
453            push_opcode(tokens, "mma");
454            match &self.spvariant {
455                Spvariant::SpOrderedMetadata => {
456                    push_directive(tokens, "sp::ordered_metadata");
457                }
458            }
459            push_directive(tokens, "sync");
460            push_directive(tokens, "aligned");
461            push_directive(tokens, "m16n8k128");
462            push_directive(tokens, "row");
463            push_directive(tokens, "col");
464            match &self.kind {
465                Kind::KindMxf4 => {
466                    push_directive(tokens, "kind::mxf4");
467                }
468            }
469            push_directive(tokens, "block_scale");
470            if let Some(scale_vec_size_0) = self.scale_vec_size.as_ref() {
471                match scale_vec_size_0 {
472                    ScaleVecSize::ScaleVec2x => {
473                        push_directive(tokens, "scale_vec::2X");
474                    }
475                }
476            }
477            push_directive(tokens, "f32");
478            push_directive(tokens, "e2m1");
479            push_directive(tokens, "e2m1");
480            push_directive(tokens, "f32");
481            match &self.stype {
482                Stype::Ue8m0 => {
483                    push_directive(tokens, "ue8m0");
484                }
485            }
486            self.d.unparse_tokens(tokens);
487            tokens.push(PtxToken::Comma);
488            self.a.unparse_tokens(tokens);
489            tokens.push(PtxToken::Comma);
490            self.b.unparse_tokens(tokens);
491            tokens.push(PtxToken::Comma);
492            self.c.unparse_tokens(tokens);
493            tokens.push(PtxToken::Comma);
494            self.e.unparse_tokens(tokens);
495            tokens.push(PtxToken::Comma);
496            self.f.unparse_tokens(tokens);
497            tokens.push(PtxToken::Comma);
498            self.scale_a_data.unparse_tokens(tokens);
499            tokens.push(PtxToken::Comma);
500            self.byte_id_a.unparse_tokens(tokens);
501            tokens.push(PtxToken::Comma);
502            self.scale_b_data.unparse_tokens(tokens);
503            tokens.push(PtxToken::Comma);
504            self.byte_id_b.unparse_tokens(tokens);
505            tokens.push(PtxToken::Semicolon);
506        }
507    }
508}
509
510pub mod section_3 {
511    use super::*;
512    use crate::r#type::instruction::mma_sp::section_3::*;
513
514    impl PtxUnparser
515        for MmaSpvariantSyncAlignedM16n8k128RowColKindBlockScaleScaleVecSizeF32E2m1E2m1F32Stype1
516    {
517        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
518            push_opcode(tokens, "mma");
519            match &self.spvariant {
520                Spvariant::SpOrderedMetadata => {
521                    push_directive(tokens, "sp::ordered_metadata");
522                }
523            }
524            push_directive(tokens, "sync");
525            push_directive(tokens, "aligned");
526            push_directive(tokens, "m16n8k128");
527            push_directive(tokens, "row");
528            push_directive(tokens, "col");
529            match &self.kind {
530                Kind::KindMxf4nvf4 => {
531                    push_directive(tokens, "kind::mxf4nvf4");
532                }
533            }
534            push_directive(tokens, "block_scale");
535            match &self.scale_vec_size {
536                ScaleVecSize::ScaleVec2x => {
537                    push_directive(tokens, "scale_vec::2X");
538                }
539                ScaleVecSize::ScaleVec4x => {
540                    push_directive(tokens, "scale_vec::4X");
541                }
542            }
543            push_directive(tokens, "f32");
544            push_directive(tokens, "e2m1");
545            push_directive(tokens, "e2m1");
546            push_directive(tokens, "f32");
547            match &self.stype {
548                Stype::Ue8m0 => {
549                    push_directive(tokens, "ue8m0");
550                }
551                Stype::Ue4m3 => {
552                    push_directive(tokens, "ue4m3");
553                }
554            }
555            self.d.unparse_tokens(tokens);
556            tokens.push(PtxToken::Comma);
557            self.a.unparse_tokens(tokens);
558            tokens.push(PtxToken::Comma);
559            self.b.unparse_tokens(tokens);
560            tokens.push(PtxToken::Comma);
561            self.c.unparse_tokens(tokens);
562            tokens.push(PtxToken::Comma);
563            self.e.unparse_tokens(tokens);
564            tokens.push(PtxToken::Comma);
565            self.f.unparse_tokens(tokens);
566            tokens.push(PtxToken::Comma);
567            self.scale_a_data.unparse_tokens(tokens);
568            tokens.push(PtxToken::Comma);
569            self.byte_id_a.unparse_tokens(tokens);
570            tokens.push(PtxToken::Comma);
571            self.scale_b_data.unparse_tokens(tokens);
572            tokens.push(PtxToken::Comma);
573            self.byte_id_b.unparse_tokens(tokens);
574            tokens.push(PtxToken::Semicolon);
575        }
576    }
577}
578
579pub mod section_4 {
580    use super::*;
581    use crate::r#type::instruction::mma_sp::section_4::*;
582
583    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k64RowColKindBlockScaleScaleVecSizeF32F8f6f4typeF8f6f4typeF32Stype {
584        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
585            push_opcode(tokens, "mma");
586                    match &self.spvariant {
587                            Spvariant::SpOrderedMetadata => {
588                                    push_directive(tokens, "sp::ordered_metadata");
589                            }
590                    }
591                    push_directive(tokens, "sync");
592                    push_directive(tokens, "aligned");
593                    push_directive(tokens, "m16n8k64");
594                    push_directive(tokens, "row");
595                    push_directive(tokens, "col");
596                    match &self.kind {
597                            Kind::KindMxf8f6f4 => {
598                                    push_directive(tokens, "kind::mxf8f6f4");
599                            }
600                    }
601                    push_directive(tokens, "block_scale");
602                    if let Some(scale_vec_size_1) = self.scale_vec_size.as_ref() {
603                            match scale_vec_size_1 {
604                                    ScaleVecSize::ScaleVec1x => {
605                                            push_directive(tokens, "scale_vec::1X");
606                                    }
607                            }
608                    }
609                    push_directive(tokens, "f32");
610                    match &self.f8f6f4type {
611                            F8f6f4type::E4m3 => {
612                                    push_directive(tokens, "e4m3");
613                            }
614                            F8f6f4type::E5m2 => {
615                                    push_directive(tokens, "e5m2");
616                            }
617                            F8f6f4type::E3m2 => {
618                                    push_directive(tokens, "e3m2");
619                            }
620                            F8f6f4type::E2m3 => {
621                                    push_directive(tokens, "e2m3");
622                            }
623                            F8f6f4type::E2m1 => {
624                                    push_directive(tokens, "e2m1");
625                            }
626                    }
627                    match &self.f8f6f4type1 {
628                            F8f6f4type::E4m3 => {
629                                    push_directive(tokens, "e4m3");
630                            }
631                            F8f6f4type::E5m2 => {
632                                    push_directive(tokens, "e5m2");
633                            }
634                            F8f6f4type::E3m2 => {
635                                    push_directive(tokens, "e3m2");
636                            }
637                            F8f6f4type::E2m3 => {
638                                    push_directive(tokens, "e2m3");
639                            }
640                            F8f6f4type::E2m1 => {
641                                    push_directive(tokens, "e2m1");
642                            }
643                    }
644                    push_directive(tokens, "f32");
645                    match &self.stype {
646                            Stype::Ue8m0 => {
647                                    push_directive(tokens, "ue8m0");
648                            }
649                    }
650                    self.d.unparse_tokens(tokens);
651            tokens.push(PtxToken::Comma);
652                    self.a.unparse_tokens(tokens);
653            tokens.push(PtxToken::Comma);
654                    self.b.unparse_tokens(tokens);
655            tokens.push(PtxToken::Comma);
656                    self.c.unparse_tokens(tokens);
657            tokens.push(PtxToken::Comma);
658                    self.e.unparse_tokens(tokens);
659            tokens.push(PtxToken::Comma);
660                    self.f.unparse_tokens(tokens);
661            tokens.push(PtxToken::Comma);
662                    self.scale_a_data.unparse_tokens(tokens);
663            tokens.push(PtxToken::Comma);
664                    self.byte_id_a.unparse_tokens(tokens);
665            tokens.push(PtxToken::Comma);
666                    self.scale_b_data.unparse_tokens(tokens);
667            tokens.push(PtxToken::Comma);
668                    self.byte_id_b.unparse_tokens(tokens);
669            tokens.push(PtxToken::Semicolon);
670        }
671    }
672}
673
674pub mod section_5 {
675    use super::*;
676    use crate::r#type::instruction::mma_sp::section_5::*;
677
678    impl PtxUnparser for MmaSpvariantSyncAlignedShapeRowColSatfiniteS32AtypeBtypeS32 {
679        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
680            push_opcode(tokens, "mma");
681            match &self.spvariant {
682                Spvariant::SpOrderedMetadata => {
683                    push_directive(tokens, "sp::ordered_metadata");
684                }
685                Spvariant::Sp => {
686                    push_directive(tokens, "sp");
687                }
688            }
689            push_directive(tokens, "sync");
690            push_directive(tokens, "aligned");
691            match &self.shape {
692                Shape::M16n8k32 => {
693                    push_directive(tokens, "m16n8k32");
694                }
695                Shape::M16n8k64 => {
696                    push_directive(tokens, "m16n8k64");
697                }
698            }
699            push_directive(tokens, "row");
700            push_directive(tokens, "col");
701            if self.satfinite {
702                push_directive(tokens, "satfinite");
703            }
704            push_directive(tokens, "s32");
705            match &self.atype {
706                Atype::U8 => {
707                    push_directive(tokens, "u8");
708                }
709                Atype::S8 => {
710                    push_directive(tokens, "s8");
711                }
712            }
713            match &self.btype {
714                Btype::U8 => {
715                    push_directive(tokens, "u8");
716                }
717                Btype::S8 => {
718                    push_directive(tokens, "s8");
719                }
720            }
721            push_directive(tokens, "s32");
722            self.d.unparse_tokens(tokens);
723            tokens.push(PtxToken::Comma);
724            self.a.unparse_tokens(tokens);
725            tokens.push(PtxToken::Comma);
726            self.b.unparse_tokens(tokens);
727            tokens.push(PtxToken::Comma);
728            self.c.unparse_tokens(tokens);
729            tokens.push(PtxToken::Comma);
730            self.e.unparse_tokens(tokens);
731            tokens.push(PtxToken::Comma);
732            self.f.unparse_tokens(tokens);
733            tokens.push(PtxToken::Semicolon);
734        }
735    }
736}
737
738pub mod section_6 {
739    use super::*;
740    use crate::r#type::instruction::mma_sp::section_6::*;
741
742    impl PtxUnparser for MmaSpvariantSyncAlignedShapeRowColSatfiniteS32AtypeBtypeS321 {
743        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
744            push_opcode(tokens, "mma");
745            match &self.spvariant {
746                Spvariant::SpOrderedMetadata => {
747                    push_directive(tokens, "sp::ordered_metadata");
748                }
749                Spvariant::Sp => {
750                    push_directive(tokens, "sp");
751                }
752            }
753            push_directive(tokens, "sync");
754            push_directive(tokens, "aligned");
755            match &self.shape {
756                Shape::M16n8k128 => {
757                    push_directive(tokens, "m16n8k128");
758                }
759                Shape::M16n8k64 => {
760                    push_directive(tokens, "m16n8k64");
761                }
762            }
763            push_directive(tokens, "row");
764            push_directive(tokens, "col");
765            if self.satfinite {
766                push_directive(tokens, "satfinite");
767            }
768            push_directive(tokens, "s32");
769            match &self.atype {
770                Atype::U4 => {
771                    push_directive(tokens, "u4");
772                }
773                Atype::S4 => {
774                    push_directive(tokens, "s4");
775                }
776            }
777            match &self.btype {
778                Btype::U4 => {
779                    push_directive(tokens, "u4");
780                }
781                Btype::S4 => {
782                    push_directive(tokens, "s4");
783                }
784            }
785            push_directive(tokens, "s32");
786            self.d.unparse_tokens(tokens);
787            tokens.push(PtxToken::Comma);
788            self.a.unparse_tokens(tokens);
789            tokens.push(PtxToken::Comma);
790            self.b.unparse_tokens(tokens);
791            tokens.push(PtxToken::Comma);
792            self.c.unparse_tokens(tokens);
793            tokens.push(PtxToken::Comma);
794            self.e.unparse_tokens(tokens);
795            tokens.push(PtxToken::Comma);
796            self.f.unparse_tokens(tokens);
797            tokens.push(PtxToken::Semicolon);
798        }
799    }
800}
ptx_parser/unparser/instruction/mma_sp.rs

ptx_parser/unparser/instruction/
mma_sp.rs
