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}
170
171pub mod section_1 {
172    use super::*;
173    use crate::r#type::instruction::mma_sp::section_1::*;
174
175    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k16RowColF32Bf16Bf16F32 {
176        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
177            push_opcode(tokens, "mma");
178                    match &self.spvariant {
179                            Spvariant::SpOrderedMetadata => {
180                                    push_directive(tokens, "sp::ordered_metadata");
181                            }
182                            Spvariant::Sp => {
183                                    push_directive(tokens, "sp");
184                            }
185                    }
186                    push_directive(tokens, "sync");
187                    push_directive(tokens, "aligned");
188                    push_directive(tokens, "m16n8k16");
189                    push_directive(tokens, "row");
190                    push_directive(tokens, "col");
191                    push_directive(tokens, "f32");
192                    push_directive(tokens, "bf16");
193                    push_directive(tokens, "bf16");
194                    push_directive(tokens, "f32");
195                    self.d.unparse_tokens(tokens);
196            tokens.push(PtxToken::Comma);
197                    self.a.unparse_tokens(tokens);
198            tokens.push(PtxToken::Comma);
199                    self.b.unparse_tokens(tokens);
200            tokens.push(PtxToken::Comma);
201                    self.c.unparse_tokens(tokens);
202            tokens.push(PtxToken::Comma);
203                    self.e.unparse_tokens(tokens);
204            tokens.push(PtxToken::Comma);
205                    self.f.unparse_tokens(tokens);
206            tokens.push(PtxToken::Semicolon);
207        }
208    }
209
210    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k32RowColF32Bf16Bf16F32 {
211        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
212            push_opcode(tokens, "mma");
213                    match &self.spvariant {
214                            Spvariant::SpOrderedMetadata => {
215                                    push_directive(tokens, "sp::ordered_metadata");
216                            }
217                            Spvariant::Sp => {
218                                    push_directive(tokens, "sp");
219                            }
220                    }
221                    push_directive(tokens, "sync");
222                    push_directive(tokens, "aligned");
223                    push_directive(tokens, "m16n8k32");
224                    push_directive(tokens, "row");
225                    push_directive(tokens, "col");
226                    push_directive(tokens, "f32");
227                    push_directive(tokens, "bf16");
228                    push_directive(tokens, "bf16");
229                    push_directive(tokens, "f32");
230                    self.d.unparse_tokens(tokens);
231            tokens.push(PtxToken::Comma);
232                    self.a.unparse_tokens(tokens);
233            tokens.push(PtxToken::Comma);
234                    self.b.unparse_tokens(tokens);
235            tokens.push(PtxToken::Comma);
236                    self.c.unparse_tokens(tokens);
237            tokens.push(PtxToken::Comma);
238                    self.e.unparse_tokens(tokens);
239            tokens.push(PtxToken::Comma);
240                    self.f.unparse_tokens(tokens);
241            tokens.push(PtxToken::Semicolon);
242        }
243    }
244
245    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k8RowColF32Tf32Tf32F32 {
246        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
247            push_opcode(tokens, "mma");
248                    match &self.spvariant {
249                            Spvariant::SpOrderedMetadata => {
250                                    push_directive(tokens, "sp::ordered_metadata");
251                            }
252                            Spvariant::Sp => {
253                                    push_directive(tokens, "sp");
254                            }
255                    }
256                    push_directive(tokens, "sync");
257                    push_directive(tokens, "aligned");
258                    push_directive(tokens, "m16n8k8");
259                    push_directive(tokens, "row");
260                    push_directive(tokens, "col");
261                    push_directive(tokens, "f32");
262                    push_directive(tokens, "tf32");
263                    push_directive(tokens, "tf32");
264                    push_directive(tokens, "f32");
265                    self.d.unparse_tokens(tokens);
266            tokens.push(PtxToken::Comma);
267                    self.a.unparse_tokens(tokens);
268            tokens.push(PtxToken::Comma);
269                    self.b.unparse_tokens(tokens);
270            tokens.push(PtxToken::Comma);
271                    self.c.unparse_tokens(tokens);
272            tokens.push(PtxToken::Comma);
273                    self.e.unparse_tokens(tokens);
274            tokens.push(PtxToken::Comma);
275                    self.f.unparse_tokens(tokens);
276            tokens.push(PtxToken::Semicolon);
277        }
278    }
279
280    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k16RowColF32Tf32Tf32F32 {
281        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
282            push_opcode(tokens, "mma");
283                    match &self.spvariant {
284                            Spvariant::SpOrderedMetadata => {
285                                    push_directive(tokens, "sp::ordered_metadata");
286                            }
287                            Spvariant::Sp => {
288                                    push_directive(tokens, "sp");
289                            }
290                    }
291                    push_directive(tokens, "sync");
292                    push_directive(tokens, "aligned");
293                    push_directive(tokens, "m16n8k16");
294                    push_directive(tokens, "row");
295                    push_directive(tokens, "col");
296                    push_directive(tokens, "f32");
297                    push_directive(tokens, "tf32");
298                    push_directive(tokens, "tf32");
299                    push_directive(tokens, "f32");
300                    self.d.unparse_tokens(tokens);
301            tokens.push(PtxToken::Comma);
302                    self.a.unparse_tokens(tokens);
303            tokens.push(PtxToken::Comma);
304                    self.b.unparse_tokens(tokens);
305            tokens.push(PtxToken::Comma);
306                    self.c.unparse_tokens(tokens);
307            tokens.push(PtxToken::Comma);
308                    self.e.unparse_tokens(tokens);
309            tokens.push(PtxToken::Comma);
310                    self.f.unparse_tokens(tokens);
311            tokens.push(PtxToken::Semicolon);
312        }
313    }
314
315    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k64RowColF32F8typeF8typeF32 {
316        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
317            push_opcode(tokens, "mma");
318                    match &self.spvariant {
319                            Spvariant::SpOrderedMetadata => {
320                                    push_directive(tokens, "sp::ordered_metadata");
321                            }
322                            Spvariant::Sp => {
323                                    push_directive(tokens, "sp");
324                            }
325                    }
326                    push_directive(tokens, "sync");
327                    push_directive(tokens, "aligned");
328                    push_directive(tokens, "m16n8k64");
329                    push_directive(tokens, "row");
330                    push_directive(tokens, "col");
331                    push_directive(tokens, "f32");
332                    match &self.f8type {
333                            F8type::E4m3 => {
334                                    push_directive(tokens, "e4m3");
335                            }
336                            F8type::E5m2 => {
337                                    push_directive(tokens, "e5m2");
338                            }
339                    }
340                    match &self.f8type1 {
341                            F8type::E4m3 => {
342                                    push_directive(tokens, "e4m3");
343                            }
344                            F8type::E5m2 => {
345                                    push_directive(tokens, "e5m2");
346                            }
347                    }
348                    push_directive(tokens, "f32");
349                    self.d.unparse_tokens(tokens);
350            tokens.push(PtxToken::Comma);
351                    self.a.unparse_tokens(tokens);
352            tokens.push(PtxToken::Comma);
353                    self.b.unparse_tokens(tokens);
354            tokens.push(PtxToken::Comma);
355                    self.c.unparse_tokens(tokens);
356            tokens.push(PtxToken::Comma);
357                    self.e.unparse_tokens(tokens);
358            tokens.push(PtxToken::Comma);
359                    self.f.unparse_tokens(tokens);
360            tokens.push(PtxToken::Semicolon);
361        }
362    }
363
364    impl PtxUnparser for MmaSpOrderedMetadataSyncAlignedM16n8k64RowColKindDtypeF8f6f4typeF8f6f4typeCtype {
365        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
366            push_opcode(tokens, "mma");
367                    push_directive(tokens, "sp::ordered_metadata");
368                    push_directive(tokens, "sync");
369                    push_directive(tokens, "aligned");
370                    push_directive(tokens, "m16n8k64");
371                    push_directive(tokens, "row");
372                    push_directive(tokens, "col");
373                    match &self.kind {
374                            Kind::KindF8f6f4 => {
375                                    push_directive(tokens, "kind::f8f6f4");
376                            }
377                    }
378                    match &self.dtype {
379                            Dtype::F16 => {
380                                    push_directive(tokens, "f16");
381                            }
382                            Dtype::F32 => {
383                                    push_directive(tokens, "f32");
384                            }
385                    }
386                    match &self.f8f6f4type {
387                            F8f6f4type::E4m3 => {
388                                    push_directive(tokens, "e4m3");
389                            }
390                            F8f6f4type::E5m2 => {
391                                    push_directive(tokens, "e5m2");
392                            }
393                            F8f6f4type::E3m2 => {
394                                    push_directive(tokens, "e3m2");
395                            }
396                            F8f6f4type::E2m3 => {
397                                    push_directive(tokens, "e2m3");
398                            }
399                            F8f6f4type::E2m1 => {
400                                    push_directive(tokens, "e2m1");
401                            }
402                    }
403                    match &self.f8f6f4type1 {
404                            F8f6f4type::E4m3 => {
405                                    push_directive(tokens, "e4m3");
406                            }
407                            F8f6f4type::E5m2 => {
408                                    push_directive(tokens, "e5m2");
409                            }
410                            F8f6f4type::E3m2 => {
411                                    push_directive(tokens, "e3m2");
412                            }
413                            F8f6f4type::E2m3 => {
414                                    push_directive(tokens, "e2m3");
415                            }
416                            F8f6f4type::E2m1 => {
417                                    push_directive(tokens, "e2m1");
418                            }
419                    }
420                    match &self.ctype {
421                            Ctype::F16 => {
422                                    push_directive(tokens, "f16");
423                            }
424                            Ctype::F32 => {
425                                    push_directive(tokens, "f32");
426                            }
427                    }
428                    self.d.unparse_tokens(tokens);
429            tokens.push(PtxToken::Comma);
430                    self.a.unparse_tokens(tokens);
431            tokens.push(PtxToken::Comma);
432                    self.b.unparse_tokens(tokens);
433            tokens.push(PtxToken::Comma);
434                    self.c.unparse_tokens(tokens);
435            tokens.push(PtxToken::Comma);
436                    self.e.unparse_tokens(tokens);
437            tokens.push(PtxToken::Comma);
438                    self.f.unparse_tokens(tokens);
439            tokens.push(PtxToken::Semicolon);
440        }
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 for MmaSpvariantSyncAlignedM16n8k128RowColKindBlockScaleScaleVecSizeF32E2m1E2m1F32Stype {
450        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
451            push_opcode(tokens, "mma");
452                    match &self.spvariant {
453                            Spvariant::SpOrderedMetadata => {
454                                    push_directive(tokens, "sp::ordered_metadata");
455                            }
456                    }
457                    push_directive(tokens, "sync");
458                    push_directive(tokens, "aligned");
459                    push_directive(tokens, "m16n8k128");
460                    push_directive(tokens, "row");
461                    push_directive(tokens, "col");
462                    match &self.kind {
463                            Kind::KindMxf4 => {
464                                    push_directive(tokens, "kind::mxf4");
465                            }
466                    }
467                    push_directive(tokens, "block_scale");
468                    if let Some(scale_vec_size_0) = self.scale_vec_size.as_ref() {
469                            match scale_vec_size_0 {
470                                    ScaleVecSize::ScaleVec2x => {
471                                            push_directive(tokens, "scale_vec::2X");
472                                    }
473                            }
474                    }
475                    push_directive(tokens, "f32");
476                    push_directive(tokens, "e2m1");
477                    push_directive(tokens, "e2m1");
478                    push_directive(tokens, "f32");
479                    match &self.stype {
480                            Stype::Ue8m0 => {
481                                    push_directive(tokens, "ue8m0");
482                            }
483                    }
484                    self.d.unparse_tokens(tokens);
485            tokens.push(PtxToken::Comma);
486                    self.a.unparse_tokens(tokens);
487            tokens.push(PtxToken::Comma);
488                    self.b.unparse_tokens(tokens);
489            tokens.push(PtxToken::Comma);
490                    self.c.unparse_tokens(tokens);
491            tokens.push(PtxToken::Comma);
492                    self.e.unparse_tokens(tokens);
493            tokens.push(PtxToken::Comma);
494                    self.f.unparse_tokens(tokens);
495            tokens.push(PtxToken::Comma);
496                    self.scale_a_data.unparse_tokens(tokens);
497            tokens.push(PtxToken::Comma);
498                    self.byte_id_a.unparse_tokens(tokens);
499            tokens.push(PtxToken::Comma);
500                    self.scale_b_data.unparse_tokens(tokens);
501            tokens.push(PtxToken::Comma);
502                    self.byte_id_b.unparse_tokens(tokens);
503            tokens.push(PtxToken::Semicolon);
504        }
505    }
506
507}
508
509pub mod section_3 {
510    use super::*;
511    use crate::r#type::instruction::mma_sp::section_3::*;
512
513    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k128RowColKindBlockScaleScaleVecSizeF32E2m1E2m1F32Stype1 {
514        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
515            push_opcode(tokens, "mma");
516                    match &self.spvariant {
517                            Spvariant::SpOrderedMetadata => {
518                                    push_directive(tokens, "sp::ordered_metadata");
519                            }
520                    }
521                    push_directive(tokens, "sync");
522                    push_directive(tokens, "aligned");
523                    push_directive(tokens, "m16n8k128");
524                    push_directive(tokens, "row");
525                    push_directive(tokens, "col");
526                    match &self.kind {
527                            Kind::KindMxf4nvf4 => {
528                                    push_directive(tokens, "kind::mxf4nvf4");
529                            }
530                    }
531                    push_directive(tokens, "block_scale");
532                    match &self.scale_vec_size {
533                            ScaleVecSize::ScaleVec2x => {
534                                    push_directive(tokens, "scale_vec::2X");
535                            }
536                            ScaleVecSize::ScaleVec4x => {
537                                    push_directive(tokens, "scale_vec::4X");
538                            }
539                    }
540                    push_directive(tokens, "f32");
541                    push_directive(tokens, "e2m1");
542                    push_directive(tokens, "e2m1");
543                    push_directive(tokens, "f32");
544                    match &self.stype {
545                            Stype::Ue8m0 => {
546                                    push_directive(tokens, "ue8m0");
547                            }
548                            Stype::Ue4m3 => {
549                                    push_directive(tokens, "ue4m3");
550                            }
551                    }
552                    self.d.unparse_tokens(tokens);
553            tokens.push(PtxToken::Comma);
554                    self.a.unparse_tokens(tokens);
555            tokens.push(PtxToken::Comma);
556                    self.b.unparse_tokens(tokens);
557            tokens.push(PtxToken::Comma);
558                    self.c.unparse_tokens(tokens);
559            tokens.push(PtxToken::Comma);
560                    self.e.unparse_tokens(tokens);
561            tokens.push(PtxToken::Comma);
562                    self.f.unparse_tokens(tokens);
563            tokens.push(PtxToken::Comma);
564                    self.scale_a_data.unparse_tokens(tokens);
565            tokens.push(PtxToken::Comma);
566                    self.byte_id_a.unparse_tokens(tokens);
567            tokens.push(PtxToken::Comma);
568                    self.scale_b_data.unparse_tokens(tokens);
569            tokens.push(PtxToken::Comma);
570                    self.byte_id_b.unparse_tokens(tokens);
571            tokens.push(PtxToken::Semicolon);
572        }
573    }
574
575}
576
577pub mod section_4 {
578    use super::*;
579    use crate::r#type::instruction::mma_sp::section_4::*;
580
581    impl PtxUnparser for MmaSpvariantSyncAlignedM16n8k64RowColKindBlockScaleScaleVecSizeF32F8f6f4typeF8f6f4typeF32Stype {
582        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
583            push_opcode(tokens, "mma");
584                    match &self.spvariant {
585                            Spvariant::SpOrderedMetadata => {
586                                    push_directive(tokens, "sp::ordered_metadata");
587                            }
588                    }
589                    push_directive(tokens, "sync");
590                    push_directive(tokens, "aligned");
591                    push_directive(tokens, "m16n8k64");
592                    push_directive(tokens, "row");
593                    push_directive(tokens, "col");
594                    match &self.kind {
595                            Kind::KindMxf8f6f4 => {
596                                    push_directive(tokens, "kind::mxf8f6f4");
597                            }
598                    }
599                    push_directive(tokens, "block_scale");
600                    if let Some(scale_vec_size_1) = self.scale_vec_size.as_ref() {
601                            match scale_vec_size_1 {
602                                    ScaleVecSize::ScaleVec1x => {
603                                            push_directive(tokens, "scale_vec::1X");
604                                    }
605                            }
606                    }
607                    push_directive(tokens, "f32");
608                    match &self.f8f6f4type {
609                            F8f6f4type::E4m3 => {
610                                    push_directive(tokens, "e4m3");
611                            }
612                            F8f6f4type::E5m2 => {
613                                    push_directive(tokens, "e5m2");
614                            }
615                            F8f6f4type::E3m2 => {
616                                    push_directive(tokens, "e3m2");
617                            }
618                            F8f6f4type::E2m3 => {
619                                    push_directive(tokens, "e2m3");
620                            }
621                            F8f6f4type::E2m1 => {
622                                    push_directive(tokens, "e2m1");
623                            }
624                    }
625                    match &self.f8f6f4type1 {
626                            F8f6f4type::E4m3 => {
627                                    push_directive(tokens, "e4m3");
628                            }
629                            F8f6f4type::E5m2 => {
630                                    push_directive(tokens, "e5m2");
631                            }
632                            F8f6f4type::E3m2 => {
633                                    push_directive(tokens, "e3m2");
634                            }
635                            F8f6f4type::E2m3 => {
636                                    push_directive(tokens, "e2m3");
637                            }
638                            F8f6f4type::E2m1 => {
639                                    push_directive(tokens, "e2m1");
640                            }
641                    }
642                    push_directive(tokens, "f32");
643                    match &self.stype {
644                            Stype::Ue8m0 => {
645                                    push_directive(tokens, "ue8m0");
646                            }
647                    }
648                    self.d.unparse_tokens(tokens);
649            tokens.push(PtxToken::Comma);
650                    self.a.unparse_tokens(tokens);
651            tokens.push(PtxToken::Comma);
652                    self.b.unparse_tokens(tokens);
653            tokens.push(PtxToken::Comma);
654                    self.c.unparse_tokens(tokens);
655            tokens.push(PtxToken::Comma);
656                    self.e.unparse_tokens(tokens);
657            tokens.push(PtxToken::Comma);
658                    self.f.unparse_tokens(tokens);
659            tokens.push(PtxToken::Comma);
660                    self.scale_a_data.unparse_tokens(tokens);
661            tokens.push(PtxToken::Comma);
662                    self.byte_id_a.unparse_tokens(tokens);
663            tokens.push(PtxToken::Comma);
664                    self.scale_b_data.unparse_tokens(tokens);
665            tokens.push(PtxToken::Comma);
666                    self.byte_id_b.unparse_tokens(tokens);
667            tokens.push(PtxToken::Semicolon);
668        }
669    }
670
671}
672
673pub mod section_5 {
674    use super::*;
675    use crate::r#type::instruction::mma_sp::section_5::*;
676
677    impl PtxUnparser for MmaSpvariantSyncAlignedShapeRowColSatfiniteS32AtypeBtypeS32 {
678        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
679            push_opcode(tokens, "mma");
680                    match &self.spvariant {
681                            Spvariant::SpOrderedMetadata => {
682                                    push_directive(tokens, "sp::ordered_metadata");
683                            }
684                            Spvariant::Sp => {
685                                    push_directive(tokens, "sp");
686                            }
687                    }
688                    push_directive(tokens, "sync");
689                    push_directive(tokens, "aligned");
690                    match &self.shape {
691                            Shape::M16n8k32 => {
692                                    push_directive(tokens, "m16n8k32");
693                            }
694                            Shape::M16n8k64 => {
695                                    push_directive(tokens, "m16n8k64");
696                            }
697                    }
698                    push_directive(tokens, "row");
699                    push_directive(tokens, "col");
700                    if self.satfinite {
701                            push_directive(tokens, "satfinite");
702                    }
703                    push_directive(tokens, "s32");
704                    match &self.atype {
705                            Atype::U8 => {
706                                    push_directive(tokens, "u8");
707                            }
708                            Atype::S8 => {
709                                    push_directive(tokens, "s8");
710                            }
711                    }
712                    match &self.btype {
713                            Btype::U8 => {
714                                    push_directive(tokens, "u8");
715                            }
716                            Btype::S8 => {
717                                    push_directive(tokens, "s8");
718                            }
719                    }
720                    push_directive(tokens, "s32");
721                    self.d.unparse_tokens(tokens);
722            tokens.push(PtxToken::Comma);
723                    self.a.unparse_tokens(tokens);
724            tokens.push(PtxToken::Comma);
725                    self.b.unparse_tokens(tokens);
726            tokens.push(PtxToken::Comma);
727                    self.c.unparse_tokens(tokens);
728            tokens.push(PtxToken::Comma);
729                    self.e.unparse_tokens(tokens);
730            tokens.push(PtxToken::Comma);
731                    self.f.unparse_tokens(tokens);
732            tokens.push(PtxToken::Semicolon);
733        }
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
801}
802
ptx_parser/unparser/instruction/mma_sp.rs

ptx_parser/unparser/instruction/
mma_sp.rs
