ptx_parser/parser/instruction/
tensormap_cp_fenceproxy.rs

1//! Original PTX specification:
2//!
3//! tensormap.cp_fenceproxy.cp_qualifiers.fence_qualifiers.sync.aligned  [dst], [src], size;
4//! .cp_qualifiers    = { .global.shared::cta };
5//! .fence_qualifiers = { .to_proxy::from_proxy.release.scope };
6//! .to_proxy::from_proxy  = { .tensormap::generic };
7//! .scope            = { .cta, .cluster, .gpu , .sys };
8
9#![allow(unused)]
10
11use crate::lexer::PtxToken;
12use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
13use crate::r#type::common::*;
14
15pub mod section_0 {
16    use super::*;
17    use crate::r#type::instruction::tensormap_cp_fenceproxy::section_0::*;
18
19    // ============================================================================
20    // Generated enum parsers
21    // ============================================================================
22
23    impl PtxParser for CpQualifiers {
24        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
25            // Try GlobalSharedCta
26            {
27                let saved_pos = stream.position();
28                if stream.expect_string(".global.shared::cta").is_ok() {
29                    return Ok(CpQualifiers::GlobalSharedCta);
30                }
31                stream.set_position(saved_pos);
32            }
33            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
34            let expected = &[".global.shared::cta"];
35            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
36            Err(crate::parser::unexpected_value(span, expected, found))
37        }
38    }
39
40    impl PtxParser for FenceQualifiers {
41        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
42            // Try ToProxyFromProxyReleaseScope
43            {
44                let saved_seq_pos = stream.position();
45                match (|| -> Result<_, PtxParseError> {
46            let to_proxy_from_proxy = ToProxyFromProxy::parse(stream)?;
47            stream.expect_string(".release")?;
48            let release = ();
49            let scope = Scope::parse(stream)?;
50                    Ok((to_proxy_from_proxy, release, scope))
51                })() {
52                    Ok((to_proxy_from_proxy, release, scope)) => {
53                        return Ok(FenceQualifiers::ToProxyFromProxyReleaseScope(to_proxy_from_proxy, release, scope));
54                    }
55                    Err(_) => {
56                        stream.set_position(saved_seq_pos);
57                    }
58                }
59            }
60            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
61            let expected = &["<complex>"];
62            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
63            Err(crate::parser::unexpected_value(span, expected, found))
64        }
65    }
66
67    impl PtxParser for Scope {
68        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
69            // Try Cluster
70            {
71                let saved_pos = stream.position();
72                if stream.expect_string(".cluster").is_ok() {
73                    return Ok(Scope::Cluster);
74                }
75                stream.set_position(saved_pos);
76            }
77            let saved_pos = stream.position();
78            // Try Cta
79            {
80                let saved_pos = stream.position();
81                if stream.expect_string(".cta").is_ok() {
82                    return Ok(Scope::Cta);
83                }
84                stream.set_position(saved_pos);
85            }
86            stream.set_position(saved_pos);
87            let saved_pos = stream.position();
88            // Try Gpu
89            {
90                let saved_pos = stream.position();
91                if stream.expect_string(".gpu").is_ok() {
92                    return Ok(Scope::Gpu);
93                }
94                stream.set_position(saved_pos);
95            }
96            stream.set_position(saved_pos);
97            let saved_pos = stream.position();
98            // Try Sys
99            {
100                let saved_pos = stream.position();
101                if stream.expect_string(".sys").is_ok() {
102                    return Ok(Scope::Sys);
103                }
104                stream.set_position(saved_pos);
105            }
106            stream.set_position(saved_pos);
107            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
108            let expected = &[".cluster", ".cta", ".gpu", ".sys"];
109            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
110            Err(crate::parser::unexpected_value(span, expected, found))
111        }
112    }
113
114    impl PtxParser for ToProxyFromProxy {
115        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
116            // Try TensormapGeneric
117            {
118                let saved_pos = stream.position();
119                if stream.expect_string(".tensormap::generic").is_ok() {
120                    return Ok(ToProxyFromProxy::TensormapGeneric);
121                }
122                stream.set_position(saved_pos);
123            }
124            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
125            let expected = &[".tensormap::generic"];
126            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
127            Err(crate::parser::unexpected_value(span, expected, found))
128        }
129    }
130
131    impl PtxParser for TensormapCpFenceproxyCpQualifiersFenceQualifiersSyncAligned {
132        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
133            stream.expect_string("tensormap")?;
134            stream.expect_string(".cp_fenceproxy")?;
135            let cp_fenceproxy = ();
136            stream.expect_complete()?;
137            let cp_qualifiers = CpQualifiers::parse(stream)?;
138            stream.expect_complete()?;
139            let fence_qualifiers = FenceQualifiers::parse(stream)?;
140            stream.expect_complete()?;
141            stream.expect_string(".sync")?;
142            let sync = ();
143            stream.expect_complete()?;
144            stream.expect_string(".aligned")?;
145            let aligned = ();
146            stream.expect_complete()?;
147            let dst = AddressOperand::parse(stream)?;
148            stream.expect_complete()?;
149            stream.expect(&PtxToken::Comma)?;
150            let src = AddressOperand::parse(stream)?;
151            stream.expect_complete()?;
152            stream.expect(&PtxToken::Comma)?;
153            let size = GeneralOperand::parse(stream)?;
154            stream.expect_complete()?;
155            stream.expect_complete()?;
156            stream.expect(&PtxToken::Semicolon)?;
157            Ok(TensormapCpFenceproxyCpQualifiersFenceQualifiersSyncAligned {
158                cp_fenceproxy,
159                cp_qualifiers,
160                fence_qualifiers,
161                sync,
162                aligned,
163                dst,
164                src,
165                size,
166            })
167        }
168    }
169
170
171}
172
ptx_parser/parser/instruction/tensormap_cp_fenceproxy.rs

ptx_parser/parser/instruction/
tensormap_cp_fenceproxy.rs
