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

ptx_parser/parser/instruction/
membar.rs
