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.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
70            let expected = &[".L2::evict_unchanged", ".L2::evict_normal", ".L2::evict_first", ".L2::evict_last"];
71            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
72            Err(crate::parser::unexpected_value(span, expected, found))
73        }
74    }
75
76    impl PtxParser for LevelSecondaryPriority {
77        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
78            // Try L2EvictUnchanged
79            {
80                let saved_pos = stream.position();
81                if stream.expect_string(".L2::evict_unchanged").is_ok() {
82                    return Ok(LevelSecondaryPriority::L2EvictUnchanged);
83                }
84                stream.set_position(saved_pos);
85            }
86            let saved_pos = stream.position();
87            // Try L2EvictFirst
88            {
89                let saved_pos = stream.position();
90                if stream.expect_string(".L2::evict_first").is_ok() {
91                    return Ok(LevelSecondaryPriority::L2EvictFirst);
92                }
93                stream.set_position(saved_pos);
94            }
95            stream.set_position(saved_pos);
96            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
97            let expected = &[".L2::evict_unchanged", ".L2::evict_first"];
98            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
99            Err(crate::parser::unexpected_value(span, expected, found))
100        }
101    }
102
103    impl PtxParser for CreatepolicyRangeGlobalLevelPrimaryPriorityLevelSecondaryPriorityB64 {
104        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
105            stream.expect_string("createpolicy")?;
106            stream.expect_string(".range")?;
107            let range = ();
108            stream.expect_complete()?;
109            let saved_pos = stream.position();
110            let global = stream.expect_string(".global").is_ok();
111            if !global {
112                stream.set_position(saved_pos);
113            }
114            stream.expect_complete()?;
115            let level_primary_priority = LevelPrimaryPriority::parse(stream)?;
116            stream.expect_complete()?;
117            let saved_pos = stream.position();
118            let level_secondary_priority = match LevelSecondaryPriority::parse(stream) {
119                Ok(val) => Some(val),
120                Err(_) => {
121                    stream.set_position(saved_pos);
122                    None
123                }
124            };
125            stream.expect_complete()?;
126            stream.expect_string(".b64")?;
127            let b64 = ();
128            stream.expect_complete()?;
129            let cache_policy = GeneralOperand::parse(stream)?;
130            stream.expect_complete()?;
131            stream.expect(&PtxToken::Comma)?;
132            let a = AddressOperand::parse(stream)?;
133            stream.expect_complete()?;
134            stream.expect(&PtxToken::Comma)?;
135            let primary_size = GeneralOperand::parse(stream)?;
136            stream.expect_complete()?;
137            stream.expect(&PtxToken::Comma)?;
138            let total_size = GeneralOperand::parse(stream)?;
139            stream.expect_complete()?;
140            stream.expect_complete()?;
141            stream.expect(&PtxToken::Semicolon)?;
142            Ok(CreatepolicyRangeGlobalLevelPrimaryPriorityLevelSecondaryPriorityB64 {
143                range,
144                global,
145                level_primary_priority,
146                level_secondary_priority,
147                b64,
148                cache_policy,
149                a,
150                primary_size,
151                total_size,
152            })
153        }
154    }
155
156
157    impl PtxParser for CreatepolicyFractionalLevelPrimaryPriorityLevelSecondaryPriorityB64 {
158        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
159            stream.expect_string("createpolicy")?;
160            stream.expect_string(".fractional")?;
161            let fractional = ();
162            stream.expect_complete()?;
163            let level_primary_priority = LevelPrimaryPriority::parse(stream)?;
164            stream.expect_complete()?;
165            let saved_pos = stream.position();
166            let level_secondary_priority = match LevelSecondaryPriority::parse(stream) {
167                Ok(val) => Some(val),
168                Err(_) => {
169                    stream.set_position(saved_pos);
170                    None
171                }
172            };
173            stream.expect_complete()?;
174            stream.expect_string(".b64")?;
175            let b64 = ();
176            stream.expect_complete()?;
177            let cache_policy = GeneralOperand::parse(stream)?;
178            stream.expect_complete()?;
179            let saved_pos = stream.position();
180            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
181            if !has_comma {
182                stream.set_position(saved_pos);
183            }
184            let saved_pos = stream.position();
185            let fraction = match GeneralOperand::parse(stream) {
186                Ok(val) => Some(val),
187                Err(_) => {
188                    stream.set_position(saved_pos);
189                    None
190                }
191            };
192            stream.expect_complete()?;
193            stream.expect_complete()?;
194            stream.expect(&PtxToken::Semicolon)?;
195            Ok(CreatepolicyFractionalLevelPrimaryPriorityLevelSecondaryPriorityB64 {
196                fractional,
197                level_primary_priority,
198                level_secondary_priority,
199                b64,
200                cache_policy,
201                fraction,
202            })
203        }
204    }
205
206
207    impl PtxParser for CreatepolicyCvtL2B64 {
208        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
209            stream.expect_string("createpolicy")?;
210            stream.expect_string(".cvt")?;
211            let cvt = ();
212            stream.expect_complete()?;
213            stream.expect_string(".L2")?;
214            let l2 = ();
215            stream.expect_complete()?;
216            stream.expect_string(".b64")?;
217            let b64 = ();
218            stream.expect_complete()?;
219            let cache_policy = GeneralOperand::parse(stream)?;
220            stream.expect_complete()?;
221            stream.expect(&PtxToken::Comma)?;
222            let access_property = GeneralOperand::parse(stream)?;
223            stream.expect_complete()?;
224            stream.expect_complete()?;
225            stream.expect(&PtxToken::Semicolon)?;
226            Ok(CreatepolicyCvtL2B64 {
227                cvt,
228                l2,
229                b64,
230                cache_policy,
231                access_property,
232            })
233        }
234    }
235
236
237}
238
ptx_parser/parser/instruction/createpolicy.rs

ptx_parser/parser/instruction/
createpolicy.rs
