ptx_parser/parser/instruction/
prefetch.rs

1//! Original PTX specification:
2//!
3//! prefetch{.space}.level                    [a];   // prefetch to data cache
4//! prefetch.global.level::eviction_priority  [a];   // prefetch to data cache
5//! prefetchu.L1  [a];             // prefetch to uniform cache
6//! prefetch{.tensormap_space}.tensormap [a];  // prefetch the tensormap
7//! .space =                    { .global, .local };
8//! .level =                    { .L1, .L2 };
9//! .level::eviction_priority = { .L2::evict_last, .L2::evict_normal };
10//! .tensormap_space =          { .const, .param };
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::prefetch::section_0::*;
21
22    // ============================================================================
23    // Generated enum parsers
24    // ============================================================================
25
26    impl PtxParser for Level {
27        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
28            // Try L1
29            {
30                let saved_pos = stream.position();
31                if stream.expect_string(".L1").is_ok() {
32                    return Ok(Level::L1);
33                }
34                stream.set_position(saved_pos);
35            }
36            let saved_pos = stream.position();
37            // Try L2
38            {
39                let saved_pos = stream.position();
40                if stream.expect_string(".L2").is_ok() {
41                    return Ok(Level::L2);
42                }
43                stream.set_position(saved_pos);
44            }
45            stream.set_position(saved_pos);
46            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
47            let expected = &[".L1", ".L2"];
48            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
49            Err(crate::parser::unexpected_value(span, expected, found))
50        }
51    }
52
53    impl PtxParser for LevelEvictionPriority {
54        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
55            // Try L2EvictNormal
56            {
57                let saved_pos = stream.position();
58                if stream.expect_string(".L2::evict_normal").is_ok() {
59                    return Ok(LevelEvictionPriority::L2EvictNormal);
60                }
61                stream.set_position(saved_pos);
62            }
63            let saved_pos = stream.position();
64            // Try L2EvictLast
65            {
66                let saved_pos = stream.position();
67                if stream.expect_string(".L2::evict_last").is_ok() {
68                    return Ok(LevelEvictionPriority::L2EvictLast);
69                }
70                stream.set_position(saved_pos);
71            }
72            stream.set_position(saved_pos);
73            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
74            let expected = &[".L2::evict_normal", ".L2::evict_last"];
75            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
76            Err(crate::parser::unexpected_value(span, expected, found))
77        }
78    }
79
80    impl PtxParser for Space {
81        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
82            // Try Global
83            {
84                let saved_pos = stream.position();
85                if stream.expect_string(".global").is_ok() {
86                    return Ok(Space::Global);
87                }
88                stream.set_position(saved_pos);
89            }
90            let saved_pos = stream.position();
91            // Try Local
92            {
93                let saved_pos = stream.position();
94                if stream.expect_string(".local").is_ok() {
95                    return Ok(Space::Local);
96                }
97                stream.set_position(saved_pos);
98            }
99            stream.set_position(saved_pos);
100            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
101            let expected = &[".global", ".local"];
102            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
103            Err(crate::parser::unexpected_value(span, expected, found))
104        }
105    }
106
107    impl PtxParser for TensormapSpace {
108        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
109            // Try Const
110            {
111                let saved_pos = stream.position();
112                if stream.expect_string(".const").is_ok() {
113                    return Ok(TensormapSpace::Const);
114                }
115                stream.set_position(saved_pos);
116            }
117            let saved_pos = stream.position();
118            // Try Param
119            {
120                let saved_pos = stream.position();
121                if stream.expect_string(".param").is_ok() {
122                    return Ok(TensormapSpace::Param);
123                }
124                stream.set_position(saved_pos);
125            }
126            stream.set_position(saved_pos);
127            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
128            let expected = &[".const", ".param"];
129            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
130            Err(crate::parser::unexpected_value(span, expected, found))
131        }
132    }
133
134    impl PtxParser for PrefetchSpaceLevel {
135        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
136            stream.expect_string("prefetch")?;
137            let saved_pos = stream.position();
138            let space = match Space::parse(stream) {
139                Ok(val) => Some(val),
140                Err(_) => {
141                    stream.set_position(saved_pos);
142                    None
143                }
144            };
145            stream.expect_complete()?;
146            let level = Level::parse(stream)?;
147            stream.expect_complete()?;
148            let a = AddressOperand::parse(stream)?;
149            stream.expect_complete()?;
150            stream.expect_complete()?;
151            stream.expect(&PtxToken::Semicolon)?;
152            Ok(PrefetchSpaceLevel {
153                space,
154                level,
155                a,
156            })
157        }
158    }
159
160
161    impl PtxParser for PrefetchGlobalLevelEvictionPriority {
162        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
163            stream.expect_string("prefetch")?;
164            stream.expect_string(".global")?;
165            let global = ();
166            stream.expect_complete()?;
167            let level_eviction_priority = LevelEvictionPriority::parse(stream)?;
168            stream.expect_complete()?;
169            let a = AddressOperand::parse(stream)?;
170            stream.expect_complete()?;
171            stream.expect_complete()?;
172            stream.expect(&PtxToken::Semicolon)?;
173            Ok(PrefetchGlobalLevelEvictionPriority {
174                global,
175                level_eviction_priority,
176                a,
177            })
178        }
179    }
180
181
182    impl PtxParser for PrefetchuL1 {
183        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
184            stream.expect_string("prefetchu")?;
185            stream.expect_string(".L1")?;
186            let l1 = ();
187            stream.expect_complete()?;
188            let a = AddressOperand::parse(stream)?;
189            stream.expect_complete()?;
190            stream.expect_complete()?;
191            stream.expect(&PtxToken::Semicolon)?;
192            Ok(PrefetchuL1 {
193                l1,
194                a,
195            })
196        }
197    }
198
199
200    impl PtxParser for PrefetchTensormapSpaceTensormap {
201        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
202            stream.expect_string("prefetch")?;
203            let saved_pos = stream.position();
204            let tensormap_space = match TensormapSpace::parse(stream) {
205                Ok(val) => Some(val),
206                Err(_) => {
207                    stream.set_position(saved_pos);
208                    None
209                }
210            };
211            stream.expect_complete()?;
212            stream.expect_string(".tensormap")?;
213            let tensormap = ();
214            stream.expect_complete()?;
215            let a = AddressOperand::parse(stream)?;
216            stream.expect_complete()?;
217            stream.expect_complete()?;
218            stream.expect(&PtxToken::Semicolon)?;
219            Ok(PrefetchTensormapSpaceTensormap {
220                tensormap_space,
221                tensormap,
222                a,
223            })
224        }
225    }
226
227
228}
229
ptx_parser/parser/instruction/prefetch.rs

ptx_parser/parser/instruction/
prefetch.rs
