ptx_parser/parser/instruction/
membar.rs

1//! Original PTX specification:
2//!
3//! // Thread fence:
4//! fence{.sem}.scope;
5//! // Thread fence (uni-directional):
6//! fence.acquire.sync_restrict::shared::cluster.cluster;
7//! fence.release.sync_restrict::shared::cta.cluster;
8//! // Operation fence (uni-directional):
9//! fence.op_restrict.release.cluster;
10//! // Proxy fence (bi-directional):
11//! fence.proxy.proxykind;
12//! // Proxy fence (uni-directional):
13//! fence.proxy.to_proxykind::from_proxykind.release.scope;
14//! fence.proxy.to_proxykind::from_proxykind.acquire.scope  [addr], size;
15//! fence.proxy.async::generic.acquire.sync_restrict::shared::cluster.cluster;
16//! fence.proxy.async::generic.release.sync_restrict::shared::cta.cluster;
17//! // Old style membar:
18//! membar.level;
19//! membar.proxy.proxykind;
20//! .sem       = { .sc, .acq_rel, .acquire, .release };
21//! .scope     = { .cta, .cluster, .gpu, .sys };
22//! .level     = { .cta, .gl, .sys };
23//! .proxykind = { .alias, .async, .async.global, .async.shared::cta, .async.shared::cluster};
24//! .op_restrict = { .mbarrier_init };
25//! .to_proxykind::from_proxykind = {.tensormap::generic};
26
27#![allow(unused)]
28
29use crate::lexer::PtxToken;
30use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
31use crate::r#type::common::*;
32
33pub mod section_0 {
34    use super::*;
35    use crate::r#type::instruction::membar::section_0::*;
36
37    // ============================================================================
38    // Generated enum parsers
39    // ============================================================================
40
41    impl PtxParser for Level {
42        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
43            // Try Cta
44            {
45                let saved_pos = stream.position();
46                if stream.expect_string(".cta").is_ok() {
47                    return Ok(Level::Cta);
48                }
49                stream.set_position(saved_pos);
50            }
51            let saved_pos = stream.position();
52            // Try Sys
53            {
54                let saved_pos = stream.position();
55                if stream.expect_string(".sys").is_ok() {
56                    return Ok(Level::Sys);
57                }
58                stream.set_position(saved_pos);
59            }
60            stream.set_position(saved_pos);
61            let saved_pos = stream.position();
62            // Try Gl
63            {
64                let saved_pos = stream.position();
65                if stream.expect_string(".gl").is_ok() {
66                    return Ok(Level::Gl);
67                }
68                stream.set_position(saved_pos);
69            }
70            stream.set_position(saved_pos);
71            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
72            let expected = &[".cta", ".sys", ".gl"];
73            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
74            Err(crate::parser::unexpected_value(span, expected, found))
75        }
76    }
77
78    impl PtxParser for OpRestrict {
79        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
80            // Try MbarrierInit
81            {
82                let saved_pos = stream.position();
83                if stream.expect_string(".mbarrier_init").is_ok() {
84                    return Ok(OpRestrict::MbarrierInit);
85                }
86                stream.set_position(saved_pos);
87            }
88            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
89            let expected = &[".mbarrier_init"];
90            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
91            Err(crate::parser::unexpected_value(span, expected, found))
92        }
93    }
94
95    impl PtxParser for Proxykind {
96        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
97            // Try AsyncSharedCluster
98            {
99                let saved_pos = stream.position();
100                if stream.expect_string(".async.shared::cluster").is_ok() {
101                    return Ok(Proxykind::AsyncSharedCluster);
102                }
103                stream.set_position(saved_pos);
104            }
105            let saved_pos = stream.position();
106            // Try AsyncSharedCta
107            {
108                let saved_pos = stream.position();
109                if stream.expect_string(".async.shared::cta").is_ok() {
110                    return Ok(Proxykind::AsyncSharedCta);
111                }
112                stream.set_position(saved_pos);
113            }
114            stream.set_position(saved_pos);
115            let saved_pos = stream.position();
116            // Try AsyncGlobal
117            {
118                let saved_pos = stream.position();
119                if stream.expect_string(".async.global").is_ok() {
120                    return Ok(Proxykind::AsyncGlobal);
121                }
122                stream.set_position(saved_pos);
123            }
124            stream.set_position(saved_pos);
125            let saved_pos = stream.position();
126            // Try Alias
127            {
128                let saved_pos = stream.position();
129                if stream.expect_string(".alias").is_ok() {
130                    return Ok(Proxykind::Alias);
131                }
132                stream.set_position(saved_pos);
133            }
134            stream.set_position(saved_pos);
135            let saved_pos = stream.position();
136            // Try Async
137            {
138                let saved_pos = stream.position();
139                if stream.expect_string(".async").is_ok() {
140                    return Ok(Proxykind::Async);
141                }
142                stream.set_position(saved_pos);
143            }
144            stream.set_position(saved_pos);
145            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
146            let expected = &[".async.shared::cluster", ".async.shared::cta", ".async.global", ".alias", ".async"];
147            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
148            Err(crate::parser::unexpected_value(span, expected, found))
149        }
150    }
151
152    impl PtxParser for Scope {
153        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
154            // Try Cluster
155            {
156                let saved_pos = stream.position();
157                if stream.expect_string(".cluster").is_ok() {
158                    return Ok(Scope::Cluster);
159                }
160                stream.set_position(saved_pos);
161            }
162            let saved_pos = stream.position();
163            // Try Cta
164            {
165                let saved_pos = stream.position();
166                if stream.expect_string(".cta").is_ok() {
167                    return Ok(Scope::Cta);
168                }
169                stream.set_position(saved_pos);
170            }
171            stream.set_position(saved_pos);
172            let saved_pos = stream.position();
173            // Try Gpu
174            {
175                let saved_pos = stream.position();
176                if stream.expect_string(".gpu").is_ok() {
177                    return Ok(Scope::Gpu);
178                }
179                stream.set_position(saved_pos);
180            }
181            stream.set_position(saved_pos);
182            let saved_pos = stream.position();
183            // Try Sys
184            {
185                let saved_pos = stream.position();
186                if stream.expect_string(".sys").is_ok() {
187                    return Ok(Scope::Sys);
188                }
189                stream.set_position(saved_pos);
190            }
191            stream.set_position(saved_pos);
192            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
193            let expected = &[".cluster", ".cta", ".gpu", ".sys"];
194            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
195            Err(crate::parser::unexpected_value(span, expected, found))
196        }
197    }
198
199    impl PtxParser for Sem {
200        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
201            // Try AcqRel
202            {
203                let saved_pos = stream.position();
204                if stream.expect_string(".acq_rel").is_ok() {
205                    return Ok(Sem::AcqRel);
206                }
207                stream.set_position(saved_pos);
208            }
209            let saved_pos = stream.position();
210            // Try Acquire
211            {
212                let saved_pos = stream.position();
213                if stream.expect_string(".acquire").is_ok() {
214                    return Ok(Sem::Acquire);
215                }
216                stream.set_position(saved_pos);
217            }
218            stream.set_position(saved_pos);
219            let saved_pos = stream.position();
220            // Try Release
221            {
222                let saved_pos = stream.position();
223                if stream.expect_string(".release").is_ok() {
224                    return Ok(Sem::Release);
225                }
226                stream.set_position(saved_pos);
227            }
228            stream.set_position(saved_pos);
229            let saved_pos = stream.position();
230            // Try Sc
231            {
232                let saved_pos = stream.position();
233                if stream.expect_string(".sc").is_ok() {
234                    return Ok(Sem::Sc);
235                }
236                stream.set_position(saved_pos);
237            }
238            stream.set_position(saved_pos);
239            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
240            let expected = &[".acq_rel", ".acquire", ".release", ".sc"];
241            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
242            Err(crate::parser::unexpected_value(span, expected, found))
243        }
244    }
245
246    impl PtxParser for ToProxykindFromProxykind {
247        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
248            // Try TensormapGeneric
249            {
250                let saved_pos = stream.position();
251                if stream.expect_string(".tensormap::generic").is_ok() {
252                    return Ok(ToProxykindFromProxykind::TensormapGeneric);
253                }
254                stream.set_position(saved_pos);
255            }
256            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
257            let expected = &[".tensormap::generic"];
258            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
259            Err(crate::parser::unexpected_value(span, expected, found))
260        }
261    }
262
263    impl PtxParser for FenceSemScope {
264        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
265            stream.expect_string("fence")?;
266            let saved_pos = stream.position();
267            let sem = match Sem::parse(stream) {
268                Ok(val) => Some(val),
269                Err(_) => {
270                    stream.set_position(saved_pos);
271                    None
272                }
273            };
274            stream.expect_complete()?;
275            let scope = Scope::parse(stream)?;
276            stream.expect_complete()?;
277            stream.expect_complete()?;
278            stream.expect(&PtxToken::Semicolon)?;
279            Ok(FenceSemScope {
280                sem,
281                scope,
282            })
283        }
284    }
285
286
287    impl PtxParser for FenceAcquireSyncRestrictSharedClusterCluster {
288        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
289            stream.expect_string("fence")?;
290            stream.expect_string(".acquire")?;
291            let acquire = ();
292            stream.expect_complete()?;
293            stream.expect_string(".sync_restrict::shared::cluster")?;
294            let sync_restrict_shared_cluster = ();
295            stream.expect_complete()?;
296            stream.expect_string(".cluster")?;
297            let cluster = ();
298            stream.expect_complete()?;
299            stream.expect_complete()?;
300            stream.expect(&PtxToken::Semicolon)?;
301            Ok(FenceAcquireSyncRestrictSharedClusterCluster {
302                acquire,
303                sync_restrict_shared_cluster,
304                cluster,
305            })
306        }
307    }
308
309
310    impl PtxParser for FenceReleaseSyncRestrictSharedCtaCluster {
311        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
312            stream.expect_string("fence")?;
313            stream.expect_string(".release")?;
314            let release = ();
315            stream.expect_complete()?;
316            stream.expect_string(".sync_restrict::shared::cta")?;
317            let sync_restrict_shared_cta = ();
318            stream.expect_complete()?;
319            stream.expect_string(".cluster")?;
320            let cluster = ();
321            stream.expect_complete()?;
322            stream.expect_complete()?;
323            stream.expect(&PtxToken::Semicolon)?;
324            Ok(FenceReleaseSyncRestrictSharedCtaCluster {
325                release,
326                sync_restrict_shared_cta,
327                cluster,
328            })
329        }
330    }
331
332
333    impl PtxParser for FenceOpRestrictReleaseCluster {
334        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
335            stream.expect_string("fence")?;
336            let op_restrict = OpRestrict::parse(stream)?;
337            stream.expect_complete()?;
338            stream.expect_string(".release")?;
339            let release = ();
340            stream.expect_complete()?;
341            stream.expect_string(".cluster")?;
342            let cluster = ();
343            stream.expect_complete()?;
344            stream.expect_complete()?;
345            stream.expect(&PtxToken::Semicolon)?;
346            Ok(FenceOpRestrictReleaseCluster {
347                op_restrict,
348                release,
349                cluster,
350            })
351        }
352    }
353
354
355    impl PtxParser for FenceProxyProxykind {
356        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
357            stream.expect_string("fence")?;
358            stream.expect_string(".proxy")?;
359            let proxy = ();
360            stream.expect_complete()?;
361            let proxykind = Proxykind::parse(stream)?;
362            stream.expect_complete()?;
363            stream.expect_complete()?;
364            stream.expect(&PtxToken::Semicolon)?;
365            Ok(FenceProxyProxykind {
366                proxy,
367                proxykind,
368            })
369        }
370    }
371
372
373    impl PtxParser for FenceProxyToProxykindFromProxykindReleaseScope {
374        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
375            stream.expect_string("fence")?;
376            stream.expect_string(".proxy")?;
377            let proxy = ();
378            stream.expect_complete()?;
379            let to_proxykind_from_proxykind = ToProxykindFromProxykind::parse(stream)?;
380            stream.expect_complete()?;
381            stream.expect_string(".release")?;
382            let release = ();
383            stream.expect_complete()?;
384            let scope = Scope::parse(stream)?;
385            stream.expect_complete()?;
386            stream.expect_complete()?;
387            stream.expect(&PtxToken::Semicolon)?;
388            Ok(FenceProxyToProxykindFromProxykindReleaseScope {
389                proxy,
390                to_proxykind_from_proxykind,
391                release,
392                scope,
393            })
394        }
395    }
396
397
398    impl PtxParser for FenceProxyToProxykindFromProxykindAcquireScope {
399        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
400            stream.expect_string("fence")?;
401            stream.expect_string(".proxy")?;
402            let proxy = ();
403            stream.expect_complete()?;
404            let to_proxykind_from_proxykind = ToProxykindFromProxykind::parse(stream)?;
405            stream.expect_complete()?;
406            stream.expect_string(".acquire")?;
407            let acquire = ();
408            stream.expect_complete()?;
409            let scope = Scope::parse(stream)?;
410            stream.expect_complete()?;
411            let addr = AddressOperand::parse(stream)?;
412            stream.expect_complete()?;
413            stream.expect(&PtxToken::Comma)?;
414            let size = GeneralOperand::parse(stream)?;
415            stream.expect_complete()?;
416            stream.expect_complete()?;
417            stream.expect(&PtxToken::Semicolon)?;
418            Ok(FenceProxyToProxykindFromProxykindAcquireScope {
419                proxy,
420                to_proxykind_from_proxykind,
421                acquire,
422                scope,
423                addr,
424                size,
425            })
426        }
427    }
428
429
430    impl PtxParser for FenceProxyAsyncGenericAcquireSyncRestrictSharedClusterCluster {
431        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
432            stream.expect_string("fence")?;
433            stream.expect_string(".proxy")?;
434            let proxy = ();
435            stream.expect_complete()?;
436            stream.expect_string(".async::generic")?;
437            let async_generic = ();
438            stream.expect_complete()?;
439            stream.expect_string(".acquire")?;
440            let acquire = ();
441            stream.expect_complete()?;
442            stream.expect_string(".sync_restrict::shared::cluster")?;
443            let sync_restrict_shared_cluster = ();
444            stream.expect_complete()?;
445            stream.expect_string(".cluster")?;
446            let cluster = ();
447            stream.expect_complete()?;
448            stream.expect_complete()?;
449            stream.expect(&PtxToken::Semicolon)?;
450            Ok(FenceProxyAsyncGenericAcquireSyncRestrictSharedClusterCluster {
451                proxy,
452                async_generic,
453                acquire,
454                sync_restrict_shared_cluster,
455                cluster,
456            })
457        }
458    }
459
460
461    impl PtxParser for FenceProxyAsyncGenericReleaseSyncRestrictSharedCtaCluster {
462        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
463            stream.expect_string("fence")?;
464            stream.expect_string(".proxy")?;
465            let proxy = ();
466            stream.expect_complete()?;
467            stream.expect_string(".async::generic")?;
468            let async_generic = ();
469            stream.expect_complete()?;
470            stream.expect_string(".release")?;
471            let release = ();
472            stream.expect_complete()?;
473            stream.expect_string(".sync_restrict::shared::cta")?;
474            let sync_restrict_shared_cta = ();
475            stream.expect_complete()?;
476            stream.expect_string(".cluster")?;
477            let cluster = ();
478            stream.expect_complete()?;
479            stream.expect_complete()?;
480            stream.expect(&PtxToken::Semicolon)?;
481            Ok(FenceProxyAsyncGenericReleaseSyncRestrictSharedCtaCluster {
482                proxy,
483                async_generic,
484                release,
485                sync_restrict_shared_cta,
486                cluster,
487            })
488        }
489    }
490
491
492    impl PtxParser for MembarLevel {
493        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
494            stream.expect_string("membar")?;
495            let level = Level::parse(stream)?;
496            stream.expect_complete()?;
497            stream.expect_complete()?;
498            stream.expect(&PtxToken::Semicolon)?;
499            Ok(MembarLevel {
500                level,
501            })
502        }
503    }
504
505
506    impl PtxParser for MembarProxyProxykind {
507        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
508            stream.expect_string("membar")?;
509            stream.expect_string(".proxy")?;
510            let proxy = ();
511            stream.expect_complete()?;
512            let proxykind = Proxykind::parse(stream)?;
513            stream.expect_complete()?;
514            stream.expect_complete()?;
515            stream.expect(&PtxToken::Semicolon)?;
516            Ok(MembarProxyProxykind {
517                proxy,
518                proxykind,
519            })
520        }
521    }
522
523
524}
525
ptx_parser/parser/instruction/membar.rs

ptx_parser/parser/instruction/
membar.rs
