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

ptx_parser/parser/instruction/
cp_reduce_async_bulk_tensor.rs
