ptx_parser/parser/instruction/
cp_reduce_async_bulk_tensor.rs

1//! Original PTX specification:
2//!
3//! // shared::cta -> global
4//! cp.reduce.async.bulk.tensor.dim.dst.src.redOp{.load_mode}.completion_mechanism{.level::cache_hint} [tensorMap, tensorCoords], [srcMem] {,cache-policy};
5//! .dst =                  { .global };
6//! .src =                  { .shared::cta };
7//! .dim =                  { .1d, .2d, .3d, .4d, .5d };
8//! .completion_mechanism = { .bulk_group };
9//! .load_mode =            { .tile, .im2col_no_offs };
10//! .redOp =                { .add, .min, .max, .inc, .dec, .and, .or, .xor};
11
12#![allow(unused)]
13
14use crate::lexer::PtxToken;
15use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
16use crate::r#type::common::*;
17
18pub mod section_0 {
19    use super::*;
20    use crate::r#type::instruction::cp_reduce_async_bulk_tensor::section_0::*;
21
22    // ============================================================================
23    // Generated enum parsers
24    // ============================================================================
25
26    impl PtxParser for CompletionMechanism {
27        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
28            // Try BulkGroup
29            {
30                let saved_pos = stream.position();
31                if stream.expect_string(".bulk_group").is_ok() {
32                    return Ok(CompletionMechanism::BulkGroup);
33                }
34                stream.set_position(saved_pos);
35            }
36            let span = stream
37                .peek()
38                .map(|(_, s)| s.clone())
39                .unwrap_or(Span { start: 0, end: 0 });
40            let expected = &[".bulk_group"];
41            let found = stream
42                .peek()
43                .map(|(t, _)| format!("{:?}", t))
44                .unwrap_or_else(|_| "<end of input>".to_string());
45            Err(crate::parser::unexpected_value(span, expected, found))
46        }
47    }
48
49    impl PtxParser for Dim {
50        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
51            // Try _1d
52            {
53                let saved_pos = stream.position();
54                if stream.expect_string(".1d").is_ok() {
55                    return Ok(Dim::_1d);
56                }
57                stream.set_position(saved_pos);
58            }
59            let saved_pos = stream.position();
60            // Try _2d
61            {
62                let saved_pos = stream.position();
63                if stream.expect_string(".2d").is_ok() {
64                    return Ok(Dim::_2d);
65                }
66                stream.set_position(saved_pos);
67            }
68            stream.set_position(saved_pos);
69            let saved_pos = stream.position();
70            // Try _3d
71            {
72                let saved_pos = stream.position();
73                if stream.expect_string(".3d").is_ok() {
74                    return Ok(Dim::_3d);
75                }
76                stream.set_position(saved_pos);
77            }
78            stream.set_position(saved_pos);
79            let saved_pos = stream.position();
80            // Try _4d
81            {
82                let saved_pos = stream.position();
83                if stream.expect_string(".4d").is_ok() {
84                    return Ok(Dim::_4d);
85                }
86                stream.set_position(saved_pos);
87            }
88            stream.set_position(saved_pos);
89            let saved_pos = stream.position();
90            // Try _5d
91            {
92                let saved_pos = stream.position();
93                if stream.expect_string(".5d").is_ok() {
94                    return Ok(Dim::_5d);
95                }
96                stream.set_position(saved_pos);
97            }
98            stream.set_position(saved_pos);
99            let span = stream
100                .peek()
101                .map(|(_, s)| s.clone())
102                .unwrap_or(Span { start: 0, end: 0 });
103            let expected = &[".1d", ".2d", ".3d", ".4d", ".5d"];
104            let found = stream
105                .peek()
106                .map(|(t, _)| format!("{:?}", t))
107                .unwrap_or_else(|_| "<end of input>".to_string());
108            Err(crate::parser::unexpected_value(span, expected, found))
109        }
110    }
111
112    impl PtxParser for Dst {
113        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
114            // Try Global
115            {
116                let saved_pos = stream.position();
117                if stream.expect_string(".global").is_ok() {
118                    return Ok(Dst::Global);
119                }
120                stream.set_position(saved_pos);
121            }
122            let span = stream
123                .peek()
124                .map(|(_, s)| s.clone())
125                .unwrap_or(Span { start: 0, end: 0 });
126            let expected = &[".global"];
127            let found = stream
128                .peek()
129                .map(|(t, _)| format!("{:?}", t))
130                .unwrap_or_else(|_| "<end of input>".to_string());
131            Err(crate::parser::unexpected_value(span, expected, found))
132        }
133    }
134
135    impl PtxParser for LoadMode {
136        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
137            // Try Im2colNoOffs
138            {
139                let saved_pos = stream.position();
140                if stream.expect_string(".im2col_no_offs").is_ok() {
141                    return Ok(LoadMode::Im2colNoOffs);
142                }
143                stream.set_position(saved_pos);
144            }
145            let saved_pos = stream.position();
146            // Try Tile
147            {
148                let saved_pos = stream.position();
149                if stream.expect_string(".tile").is_ok() {
150                    return Ok(LoadMode::Tile);
151                }
152                stream.set_position(saved_pos);
153            }
154            stream.set_position(saved_pos);
155            let span = stream
156                .peek()
157                .map(|(_, s)| s.clone())
158                .unwrap_or(Span { start: 0, end: 0 });
159            let expected = &[".im2col_no_offs", ".tile"];
160            let found = stream
161                .peek()
162                .map(|(t, _)| format!("{:?}", t))
163                .unwrap_or_else(|_| "<end of input>".to_string());
164            Err(crate::parser::unexpected_value(span, expected, found))
165        }
166    }
167
168    impl PtxParser for Redop {
169        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
170            // Try Add
171            {
172                let saved_pos = stream.position();
173                if stream.expect_string(".add").is_ok() {
174                    return Ok(Redop::Add);
175                }
176                stream.set_position(saved_pos);
177            }
178            let saved_pos = stream.position();
179            // Try Min
180            {
181                let saved_pos = stream.position();
182                if stream.expect_string(".min").is_ok() {
183                    return Ok(Redop::Min);
184                }
185                stream.set_position(saved_pos);
186            }
187            stream.set_position(saved_pos);
188            let saved_pos = stream.position();
189            // Try Max
190            {
191                let saved_pos = stream.position();
192                if stream.expect_string(".max").is_ok() {
193                    return Ok(Redop::Max);
194                }
195                stream.set_position(saved_pos);
196            }
197            stream.set_position(saved_pos);
198            let saved_pos = stream.position();
199            // Try Inc
200            {
201                let saved_pos = stream.position();
202                if stream.expect_string(".inc").is_ok() {
203                    return Ok(Redop::Inc);
204                }
205                stream.set_position(saved_pos);
206            }
207            stream.set_position(saved_pos);
208            let saved_pos = stream.position();
209            // Try Dec
210            {
211                let saved_pos = stream.position();
212                if stream.expect_string(".dec").is_ok() {
213                    return Ok(Redop::Dec);
214                }
215                stream.set_position(saved_pos);
216            }
217            stream.set_position(saved_pos);
218            let saved_pos = stream.position();
219            // Try And
220            {
221                let saved_pos = stream.position();
222                if stream.expect_string(".and").is_ok() {
223                    return Ok(Redop::And);
224                }
225                stream.set_position(saved_pos);
226            }
227            stream.set_position(saved_pos);
228            let saved_pos = stream.position();
229            // Try Xor
230            {
231                let saved_pos = stream.position();
232                if stream.expect_string(".xor").is_ok() {
233                    return Ok(Redop::Xor);
234                }
235                stream.set_position(saved_pos);
236            }
237            stream.set_position(saved_pos);
238            let saved_pos = stream.position();
239            // Try Or
240            {
241                let saved_pos = stream.position();
242                if stream.expect_string(".or").is_ok() {
243                    return Ok(Redop::Or);
244                }
245                stream.set_position(saved_pos);
246            }
247            stream.set_position(saved_pos);
248            let span = stream
249                .peek()
250                .map(|(_, s)| s.clone())
251                .unwrap_or(Span { start: 0, end: 0 });
252            let expected = &[
253                ".add", ".min", ".max", ".inc", ".dec", ".and", ".xor", ".or",
254            ];
255            let found = stream
256                .peek()
257                .map(|(t, _)| format!("{:?}", t))
258                .unwrap_or_else(|_| "<end of input>".to_string());
259            Err(crate::parser::unexpected_value(span, expected, found))
260        }
261    }
262
263    impl PtxParser for Src {
264        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
265            // Try SharedCta
266            {
267                let saved_pos = stream.position();
268                if stream.expect_string(".shared::cta").is_ok() {
269                    return Ok(Src::SharedCta);
270                }
271                stream.set_position(saved_pos);
272            }
273            let span = stream
274                .peek()
275                .map(|(_, s)| s.clone())
276                .unwrap_or(Span { start: 0, end: 0 });
277            let expected = &[".shared::cta"];
278            let found = stream
279                .peek()
280                .map(|(t, _)| format!("{:?}", t))
281                .unwrap_or_else(|_| "<end of input>".to_string());
282            Err(crate::parser::unexpected_value(span, expected, found))
283        }
284    }
285
286    impl PtxParser for CpReduceAsyncBulkTensorDimDstSrcRedopLoadModeCompletionMechanismLevelCacheHint {
287        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
288            stream.expect_string("cp")?;
289            stream.expect_string(".reduce")?;
290            let reduce = ();
291            stream.expect_complete()?;
292            stream.expect_string(".async")?;
293            let async_ = ();
294            stream.expect_complete()?;
295            stream.expect_string(".bulk")?;
296            let bulk = ();
297            stream.expect_complete()?;
298            stream.expect_string(".tensor")?;
299            let tensor = ();
300            stream.expect_complete()?;
301            let dim = Dim::parse(stream)?;
302            stream.expect_complete()?;
303            let dst = Dst::parse(stream)?;
304            stream.expect_complete()?;
305            let src = Src::parse(stream)?;
306            stream.expect_complete()?;
307            let redop = Redop::parse(stream)?;
308            stream.expect_complete()?;
309            let saved_pos = stream.position();
310            let load_mode = match LoadMode::parse(stream) {
311                Ok(val) => Some(val),
312                Err(_) => {
313                    stream.set_position(saved_pos);
314                    None
315                }
316            };
317            stream.expect_complete()?;
318            let completion_mechanism = CompletionMechanism::parse(stream)?;
319            stream.expect_complete()?;
320            let saved_pos = stream.position();
321            let level_cache_hint = stream.expect_string(".level::cache_hint").is_ok();
322            if !level_cache_hint {
323                stream.set_position(saved_pos);
324            }
325            stream.expect_complete()?;
326            let tensormap = TexHandler2::parse(stream)?;
327            stream.expect_complete()?;
328            stream.expect(&PtxToken::Comma)?;
329            let srcmem = AddressOperand::parse(stream)?;
330            stream.expect_complete()?;
331            let saved_pos = stream.position();
332            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
333            if !has_comma {
334                stream.set_position(saved_pos);
335            }
336            let saved_pos = stream.position();
337            let cache_policy = match GeneralOperand::parse(stream) {
338                Ok(val) => Some(val),
339                Err(_) => {
340                    stream.set_position(saved_pos);
341                    None
342                }
343            };
344            stream.expect_complete()?;
345            stream.expect_complete()?;
346            stream.expect(&PtxToken::Semicolon)?;
347            Ok(
348                CpReduceAsyncBulkTensorDimDstSrcRedopLoadModeCompletionMechanismLevelCacheHint {
349                    reduce,
350                    async_,
351                    bulk,
352                    tensor,
353                    dim,
354                    dst,
355                    src,
356                    redop,
357                    load_mode,
358                    completion_mechanism,
359                    level_cache_hint,
360                    tensormap,
361                    srcmem,
362                    cache_policy,
363                },
364            )
365        }
366    }
367}
ptx_parser/parser/instruction/cp_reduce_async_bulk_tensor.rs

ptx_parser/parser/instruction/
cp_reduce_async_bulk_tensor.rs
