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

ptx_parser/parser/instruction/
prefetch.rs
