ptx_parser/parser/instruction/
createpolicy.rs

1//! Original PTX specification:
2//!
3//! // Range-based policy
4//! createpolicy.range{.global}.level::primary_priority{.level::secondary_priority}.b64
5//! cache-policy, [a], primary-size, total-size;
6//! // Fraction-based policy
7//! createpolicy.fractional.level::primary_priority{.level::secondary_priority}.b64
8//! cache-policy{, fraction};
9//! // Converting the access property from CUDA APIs
10//! createpolicy.cvt.L2.b64            cache-policy, access-property;
11//! .level::primary_priority =   { .L2::evict_last, .L2::evict_normal,
12//! .L2::evict_first, .L2::evict_unchanged };
13//! .level::secondary_priority = { .L2::evict_first, .L2::evict_unchanged };
14
15#![allow(unused)]
16
17use crate::lexer::PtxToken;
18use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
19use crate::r#type::common::*;
20
21pub mod section_0 {
22    use super::*;
23    use crate::r#type::instruction::createpolicy::section_0::*;
24
25    // ============================================================================
26    // Generated enum parsers
27    // ============================================================================
28
29    impl PtxParser for LevelPrimaryPriority {
30        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
31            // Try L2EvictUnchanged
32            {
33                let saved_pos = stream.position();
34                if stream.expect_string(".L2::evict_unchanged").is_ok() {
35                    return Ok(LevelPrimaryPriority::L2EvictUnchanged);
36                }
37                stream.set_position(saved_pos);
38            }
39            let saved_pos = stream.position();
40            // Try L2EvictNormal
41            {
42                let saved_pos = stream.position();
43                if stream.expect_string(".L2::evict_normal").is_ok() {
44                    return Ok(LevelPrimaryPriority::L2EvictNormal);
45                }
46                stream.set_position(saved_pos);
47            }
48            stream.set_position(saved_pos);
49            let saved_pos = stream.position();
50            // Try L2EvictFirst
51            {
52                let saved_pos = stream.position();
53                if stream.expect_string(".L2::evict_first").is_ok() {
54                    return Ok(LevelPrimaryPriority::L2EvictFirst);
55                }
56                stream.set_position(saved_pos);
57            }
58            stream.set_position(saved_pos);
59            let saved_pos = stream.position();
60            // Try L2EvictLast
61            {
62                let saved_pos = stream.position();
63                if stream.expect_string(".L2::evict_last").is_ok() {
64                    return Ok(LevelPrimaryPriority::L2EvictLast);
65                }
66                stream.set_position(saved_pos);
67            }
68            stream.set_position(saved_pos);
69            let span = stream
70                .peek()
71                .map(|(_, s)| s.clone())
72                .unwrap_or(Span { start: 0, end: 0 });
73            let expected = &[
74                ".L2::evict_unchanged",
75                ".L2::evict_normal",
76                ".L2::evict_first",
77                ".L2::evict_last",
78            ];
79            let found = stream
80                .peek()
81                .map(|(t, _)| format!("{:?}", t))
82                .unwrap_or_else(|_| "<end of input>".to_string());
83            Err(crate::parser::unexpected_value(span, expected, found))
84        }
85    }
86
87    impl PtxParser for LevelSecondaryPriority {
88        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
89            // Try L2EvictUnchanged
90            {
91                let saved_pos = stream.position();
92                if stream.expect_string(".L2::evict_unchanged").is_ok() {
93                    return Ok(LevelSecondaryPriority::L2EvictUnchanged);
94                }
95                stream.set_position(saved_pos);
96            }
97            let saved_pos = stream.position();
98            // Try L2EvictFirst
99            {
100                let saved_pos = stream.position();
101                if stream.expect_string(".L2::evict_first").is_ok() {
102                    return Ok(LevelSecondaryPriority::L2EvictFirst);
103                }
104                stream.set_position(saved_pos);
105            }
106            stream.set_position(saved_pos);
107            let span = stream
108                .peek()
109                .map(|(_, s)| s.clone())
110                .unwrap_or(Span { start: 0, end: 0 });
111            let expected = &[".L2::evict_unchanged", ".L2::evict_first"];
112            let found = stream
113                .peek()
114                .map(|(t, _)| format!("{:?}", t))
115                .unwrap_or_else(|_| "<end of input>".to_string());
116            Err(crate::parser::unexpected_value(span, expected, found))
117        }
118    }
119
120    impl PtxParser for CreatepolicyRangeGlobalLevelPrimaryPriorityLevelSecondaryPriorityB64 {
121        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
122            stream.expect_string("createpolicy")?;
123            stream.expect_string(".range")?;
124            let range = ();
125            stream.expect_complete()?;
126            let saved_pos = stream.position();
127            let global = stream.expect_string(".global").is_ok();
128            if !global {
129                stream.set_position(saved_pos);
130            }
131            stream.expect_complete()?;
132            let level_primary_priority = LevelPrimaryPriority::parse(stream)?;
133            stream.expect_complete()?;
134            let saved_pos = stream.position();
135            let level_secondary_priority = match LevelSecondaryPriority::parse(stream) {
136                Ok(val) => Some(val),
137                Err(_) => {
138                    stream.set_position(saved_pos);
139                    None
140                }
141            };
142            stream.expect_complete()?;
143            stream.expect_string(".b64")?;
144            let b64 = ();
145            stream.expect_complete()?;
146            let cache_policy = GeneralOperand::parse(stream)?;
147            stream.expect_complete()?;
148            stream.expect(&PtxToken::Comma)?;
149            let a = AddressOperand::parse(stream)?;
150            stream.expect_complete()?;
151            stream.expect(&PtxToken::Comma)?;
152            let primary_size = GeneralOperand::parse(stream)?;
153            stream.expect_complete()?;
154            stream.expect(&PtxToken::Comma)?;
155            let total_size = GeneralOperand::parse(stream)?;
156            stream.expect_complete()?;
157            stream.expect_complete()?;
158            stream.expect(&PtxToken::Semicolon)?;
159            Ok(
160                CreatepolicyRangeGlobalLevelPrimaryPriorityLevelSecondaryPriorityB64 {
161                    range,
162                    global,
163                    level_primary_priority,
164                    level_secondary_priority,
165                    b64,
166                    cache_policy,
167                    a,
168                    primary_size,
169                    total_size,
170                },
171            )
172        }
173    }
174
175    impl PtxParser for CreatepolicyFractionalLevelPrimaryPriorityLevelSecondaryPriorityB64 {
176        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
177            stream.expect_string("createpolicy")?;
178            stream.expect_string(".fractional")?;
179            let fractional = ();
180            stream.expect_complete()?;
181            let level_primary_priority = LevelPrimaryPriority::parse(stream)?;
182            stream.expect_complete()?;
183            let saved_pos = stream.position();
184            let level_secondary_priority = match LevelSecondaryPriority::parse(stream) {
185                Ok(val) => Some(val),
186                Err(_) => {
187                    stream.set_position(saved_pos);
188                    None
189                }
190            };
191            stream.expect_complete()?;
192            stream.expect_string(".b64")?;
193            let b64 = ();
194            stream.expect_complete()?;
195            let cache_policy = GeneralOperand::parse(stream)?;
196            stream.expect_complete()?;
197            let saved_pos = stream.position();
198            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
199            if !has_comma {
200                stream.set_position(saved_pos);
201            }
202            let saved_pos = stream.position();
203            let fraction = match GeneralOperand::parse(stream) {
204                Ok(val) => Some(val),
205                Err(_) => {
206                    stream.set_position(saved_pos);
207                    None
208                }
209            };
210            stream.expect_complete()?;
211            stream.expect_complete()?;
212            stream.expect(&PtxToken::Semicolon)?;
213            Ok(
214                CreatepolicyFractionalLevelPrimaryPriorityLevelSecondaryPriorityB64 {
215                    fractional,
216                    level_primary_priority,
217                    level_secondary_priority,
218                    b64,
219                    cache_policy,
220                    fraction,
221                },
222            )
223        }
224    }
225
226    impl PtxParser for CreatepolicyCvtL2B64 {
227        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
228            stream.expect_string("createpolicy")?;
229            stream.expect_string(".cvt")?;
230            let cvt = ();
231            stream.expect_complete()?;
232            stream.expect_string(".L2")?;
233            let l2 = ();
234            stream.expect_complete()?;
235            stream.expect_string(".b64")?;
236            let b64 = ();
237            stream.expect_complete()?;
238            let cache_policy = GeneralOperand::parse(stream)?;
239            stream.expect_complete()?;
240            stream.expect(&PtxToken::Comma)?;
241            let access_property = GeneralOperand::parse(stream)?;
242            stream.expect_complete()?;
243            stream.expect_complete()?;
244            stream.expect(&PtxToken::Semicolon)?;
245            Ok(CreatepolicyCvtL2B64 {
246                cvt,
247                l2,
248                b64,
249                cache_policy,
250                access_property,
251            })
252        }
253    }
254}
ptx_parser/parser/instruction/createpolicy.rs

ptx_parser/parser/instruction/
createpolicy.rs
