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
34                .peek()
35                .map(|(_, s)| s.clone())
36                .unwrap_or(Span { start: 0, end: 0 });
37            let expected = &[".global.shared::cta"];
38            let found = stream
39                .peek()
40                .map(|(t, _)| format!("{:?}", t))
41                .unwrap_or_else(|_| "<end of input>".to_string());
42            Err(crate::parser::unexpected_value(span, expected, found))
43        }
44    }
45
46    impl PtxParser for FenceQualifiers {
47        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
48            // Try ToProxyFromProxyReleaseScope
49            {
50                let saved_seq_pos = stream.position();
51                match (|| -> Result<_, PtxParseError> {
52                    let to_proxy_from_proxy = ToProxyFromProxy::parse(stream)?;
53                    stream.expect_string(".release")?;
54                    let release = ();
55                    let scope = Scope::parse(stream)?;
56                    Ok((to_proxy_from_proxy, release, scope))
57                })() {
58                    Ok((to_proxy_from_proxy, release, scope)) => {
59                        return Ok(FenceQualifiers::ToProxyFromProxyReleaseScope(
60                            to_proxy_from_proxy,
61                            release,
62                            scope,
63                        ));
64                    }
65                    Err(_) => {
66                        stream.set_position(saved_seq_pos);
67                    }
68                }
69            }
70            let span = stream
71                .peek()
72                .map(|(_, s)| s.clone())
73                .unwrap_or(Span { start: 0, end: 0 });
74            let expected = &["<complex>"];
75            let found = stream
76                .peek()
77                .map(|(t, _)| format!("{:?}", t))
78                .unwrap_or_else(|_| "<end of input>".to_string());
79            Err(crate::parser::unexpected_value(span, expected, found))
80        }
81    }
82
83    impl PtxParser for Scope {
84        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
85            // Try Cluster
86            {
87                let saved_pos = stream.position();
88                if stream.expect_string(".cluster").is_ok() {
89                    return Ok(Scope::Cluster);
90                }
91                stream.set_position(saved_pos);
92            }
93            let saved_pos = stream.position();
94            // Try Cta
95            {
96                let saved_pos = stream.position();
97                if stream.expect_string(".cta").is_ok() {
98                    return Ok(Scope::Cta);
99                }
100                stream.set_position(saved_pos);
101            }
102            stream.set_position(saved_pos);
103            let saved_pos = stream.position();
104            // Try Gpu
105            {
106                let saved_pos = stream.position();
107                if stream.expect_string(".gpu").is_ok() {
108                    return Ok(Scope::Gpu);
109                }
110                stream.set_position(saved_pos);
111            }
112            stream.set_position(saved_pos);
113            let saved_pos = stream.position();
114            // Try Sys
115            {
116                let saved_pos = stream.position();
117                if stream.expect_string(".sys").is_ok() {
118                    return Ok(Scope::Sys);
119                }
120                stream.set_position(saved_pos);
121            }
122            stream.set_position(saved_pos);
123            let span = stream
124                .peek()
125                .map(|(_, s)| s.clone())
126                .unwrap_or(Span { start: 0, end: 0 });
127            let expected = &[".cluster", ".cta", ".gpu", ".sys"];
128            let found = stream
129                .peek()
130                .map(|(t, _)| format!("{:?}", t))
131                .unwrap_or_else(|_| "<end of input>".to_string());
132            Err(crate::parser::unexpected_value(span, expected, found))
133        }
134    }
135
136    impl PtxParser for ToProxyFromProxy {
137        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
138            // Try TensormapGeneric
139            {
140                let saved_pos = stream.position();
141                if stream.expect_string(".tensormap::generic").is_ok() {
142                    return Ok(ToProxyFromProxy::TensormapGeneric);
143                }
144                stream.set_position(saved_pos);
145            }
146            let span = stream
147                .peek()
148                .map(|(_, s)| s.clone())
149                .unwrap_or(Span { start: 0, end: 0 });
150            let expected = &[".tensormap::generic"];
151            let found = stream
152                .peek()
153                .map(|(t, _)| format!("{:?}", t))
154                .unwrap_or_else(|_| "<end of input>".to_string());
155            Err(crate::parser::unexpected_value(span, expected, found))
156        }
157    }
158
159    impl PtxParser for TensormapCpFenceproxyCpQualifiersFenceQualifiersSyncAligned {
160        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
161            stream.expect_string("tensormap")?;
162            stream.expect_string(".cp_fenceproxy")?;
163            let cp_fenceproxy = ();
164            stream.expect_complete()?;
165            let cp_qualifiers = CpQualifiers::parse(stream)?;
166            stream.expect_complete()?;
167            let fence_qualifiers = FenceQualifiers::parse(stream)?;
168            stream.expect_complete()?;
169            stream.expect_string(".sync")?;
170            let sync = ();
171            stream.expect_complete()?;
172            stream.expect_string(".aligned")?;
173            let aligned = ();
174            stream.expect_complete()?;
175            let dst = AddressOperand::parse(stream)?;
176            stream.expect_complete()?;
177            stream.expect(&PtxToken::Comma)?;
178            let src = AddressOperand::parse(stream)?;
179            stream.expect_complete()?;
180            stream.expect(&PtxToken::Comma)?;
181            let size = GeneralOperand::parse(stream)?;
182            stream.expect_complete()?;
183            stream.expect_complete()?;
184            stream.expect(&PtxToken::Semicolon)?;
185            Ok(
186                TensormapCpFenceproxyCpQualifiersFenceQualifiersSyncAligned {
187                    cp_fenceproxy,
188                    cp_qualifiers,
189                    fence_qualifiers,
190                    sync,
191                    aligned,
192                    dst,
193                    src,
194                    size,
195                },
196            )
197        }
198    }
199}
ptx_parser/parser/instruction/tensormap_cp_fenceproxy.rs

ptx_parser/parser/instruction/
tensormap_cp_fenceproxy.rs
