Skip to main content

wgpu_core/device/
trace.rs

1#[cfg(feature = "trace")]
2mod record;
3#[cfg(feature = "replay")]
4mod replay;
5
6use core::convert::Infallible;
7
8use alloc::{borrow::Cow, string::String, vec::Vec};
9use macro_rules_attribute::apply;
10
11use crate::{
12    binding_model::BindGroupLayoutEntry,
13    command::{serde_object_reference_struct, BasePass, Command, ReferenceType, RenderCommand},
14    id::{markers, PointerId},
15    pipeline::GeneralRenderPipelineDescriptor,
16};
17
18#[cfg(feature = "trace")]
19pub use record::*;
20#[cfg(feature = "replay")]
21pub use replay::*;
22
23type FileName = String;
24
25pub const FILE_NAME: &str = "trace.ron";
26
27#[derive(Debug)]
28#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
29pub enum Data {
30    File(FileName),
31    String(DataKind, String),
32    Binary(DataKind, Vec<u8>),
33}
34
35#[derive(Clone, Copy, Debug, Eq, PartialEq)]
36#[cfg_attr(
37    feature = "serde",
38    derive(serde::Serialize, serde::Deserialize),
39    serde(rename_all = "lowercase")
40)]
41pub enum DataKind {
42    Bin,
43    Wgsl,
44
45    /// IR of Naga module, serialized in RON format
46    Ron,
47    Spv,
48    Dxil,
49    Hlsl,
50    MetalLib,
51    Msl,
52    Glsl,
53}
54
55impl core::fmt::Display for DataKind {
56    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
57        let s = match self {
58            DataKind::Bin => "bin",
59            DataKind::Wgsl => "wgsl",
60            DataKind::Ron => "ron",
61            DataKind::Spv => "spv",
62            DataKind::Dxil => "dxil",
63            DataKind::Hlsl => "hlsl",
64            DataKind::MetalLib => "metallib",
65            DataKind::Msl => "metal",
66            DataKind::Glsl => "glsl",
67        };
68        write!(f, "{s}")
69    }
70}
71
72impl DataKind {
73    #[cfg(feature = "replay")]
74    fn is_string(&self) -> bool {
75        match *self {
76            DataKind::Wgsl | DataKind::Ron | DataKind::Hlsl | DataKind::Msl | DataKind::Glsl => {
77                true
78            }
79            DataKind::Bin | DataKind::Spv | DataKind::Dxil | DataKind::MetalLib => false,
80        }
81    }
82}
83
84impl Data {
85    pub fn kind(&self) -> DataKind {
86        match self {
87            Data::File(file) => {
88                if file.ends_with(".bin") {
89                    DataKind::Bin
90                } else if file.ends_with(".wgsl") {
91                    DataKind::Wgsl
92                } else if file.ends_with(".ron") {
93                    DataKind::Ron
94                } else if file.ends_with(".spv") {
95                    DataKind::Spv
96                } else if file.ends_with(".dxil") {
97                    DataKind::Dxil
98                } else if file.ends_with(".hlsl") {
99                    DataKind::Hlsl
100                } else if file.ends_with(".metallib") {
101                    DataKind::MetalLib
102                } else if file.ends_with(".metal") {
103                    DataKind::Msl
104                } else if file.ends_with(".glsl") {
105                    DataKind::Glsl
106                } else {
107                    panic!("unknown data file extension: {file}");
108                }
109            }
110            Data::String(kind, _) => *kind,
111            Data::Binary(kind, _) => *kind,
112        }
113    }
114}
115
116#[allow(clippy::large_enum_variant)]
117#[derive(Debug)]
118#[apply(serde_object_reference_struct)]
119pub enum Action<'a, R: ReferenceType> {
120    Init {
121        desc: crate::device::DeviceDescriptor<'a>,
122        backend: wgt::Backend,
123    },
124    ConfigureSurface(
125        R::Surface,
126        wgt::SurfaceConfiguration<Vec<wgt::TextureFormat>>,
127    ),
128    CreateBuffer(R::Buffer, crate::resource::BufferDescriptor<'a>),
129    DestroyBuffer(R::Buffer),
130    DropBuffer(R::Buffer),
131    CreateTexture(R::Texture, crate::resource::TextureDescriptor<'a>),
132    CreateTextureError(R::Texture, crate::resource::TextureDescriptor<'a>),
133    DestroyTexture(R::Texture),
134    DropTexture(R::Texture),
135    CreateTextureView {
136        id: R::TextureView,
137        parent: R::Texture,
138        desc: crate::resource::TextureViewDescriptor<'a>,
139    },
140    DropTextureView(R::TextureView),
141    CreateExternalTexture {
142        id: R::ExternalTexture,
143        desc: crate::resource::ExternalTextureDescriptor<'a>,
144        planes: alloc::boxed::Box<[R::TextureView]>,
145    },
146    DestroyExternalTexture(R::ExternalTexture),
147    DropExternalTexture(R::ExternalTexture),
148    CreateSampler(
149        PointerId<markers::Sampler>,
150        crate::resource::SamplerDescriptor<'a>,
151    ),
152    DropSampler(PointerId<markers::Sampler>),
153    GetSurfaceTexture {
154        id: R::Texture,
155        parent: R::Surface,
156    },
157    Present(R::Surface),
158    DiscardSurfaceTexture(R::Surface),
159    ReleaseSurfaceTexture(R::Surface),
160    CreateBindGroupLayout(
161        PointerId<markers::BindGroupLayout>,
162        crate::binding_model::BindGroupLayoutDescriptor<'a, BindGroupLayoutEntry>,
163    ),
164    GetRenderPipelineBindGroupLayout {
165        id: PointerId<markers::BindGroupLayout>,
166        pipeline: PointerId<markers::RenderPipeline>,
167        index: u32,
168    },
169    GetComputePipelineBindGroupLayout {
170        id: PointerId<markers::BindGroupLayout>,
171        pipeline: PointerId<markers::ComputePipeline>,
172        index: u32,
173    },
174    GetRayTracingPipelineBindGroupLayout {
175        id: PointerId<markers::BindGroupLayout>,
176        pipeline: PointerId<markers::RayTracingPipeline>,
177        index: u32,
178    },
179    DropBindGroupLayout(PointerId<markers::BindGroupLayout>),
180    CreatePipelineLayout(
181        PointerId<markers::PipelineLayout>,
182        crate::binding_model::PipelineLayoutDescriptor<'a, PointerId<markers::BindGroupLayout>>,
183    ),
184    DropPipelineLayout(PointerId<markers::PipelineLayout>),
185    CreateBindGroup(PointerId<markers::BindGroup>, TraceBindGroupDescriptor<'a>),
186    DropBindGroup(PointerId<markers::BindGroup>),
187    CreateShaderModule {
188        id: PointerId<markers::ShaderModule>,
189        desc: crate::pipeline::ShaderModuleDescriptor<'a>,
190        data: Data,
191    },
192    CreateShaderModulePassthrough {
193        id: PointerId<markers::ShaderModule>,
194        data: Vec<Data>,
195
196        label: crate::Label<'a>,
197        entry_points: Cow<'a, [wgt::PassthroughShaderEntryPoint<'a>]>,
198    },
199    DropShaderModule(PointerId<markers::ShaderModule>),
200    CreateComputePipeline {
201        id: PointerId<markers::ComputePipeline>,
202        desc: TraceComputePipelineDescriptor<'a>,
203    },
204    DropComputePipeline(PointerId<markers::ComputePipeline>),
205    CreateGeneralRenderPipeline {
206        id: PointerId<markers::RenderPipeline>,
207        desc: TraceGeneralRenderPipelineDescriptor<'a>,
208    },
209    DropRenderPipeline(PointerId<markers::RenderPipeline>),
210    CreateRayTracingPipeline {
211        id: PointerId<markers::RayTracingPipeline>,
212        desc: TraceRayTracingPipelineDescriptor<'a>,
213    },
214    DropRayTracingPipeline(PointerId<markers::RayTracingPipeline>),
215    CreatePipelineCache {
216        id: PointerId<markers::PipelineCache>,
217        desc: crate::pipeline::PipelineCacheDescriptor<'a>,
218    },
219    DropPipelineCache(PointerId<markers::PipelineCache>),
220    CreateRenderBundle {
221        id: R::RenderBundle,
222        desc: crate::command::RenderBundleEncoderDescriptor<'a>,
223        base: BasePass<RenderCommand<R>, Infallible>,
224    },
225    DropRenderBundle(PointerId<markers::RenderBundle>),
226    CreateQuerySet {
227        id: PointerId<markers::QuerySet>,
228        desc: crate::resource::QuerySetDescriptor<'a>,
229    },
230    DropQuerySet(PointerId<markers::QuerySet>),
231    DestroyQuerySet(PointerId<markers::QuerySet>),
232    WriteBuffer {
233        id: R::Buffer,
234        data: Data,
235        offset: wgt::BufferAddress,
236        size: wgt::BufferAddress,
237        queued: bool,
238    },
239    WriteTexture {
240        to: wgt::TexelCopyTextureInfo<R::Texture>,
241        data: Data,
242        layout: wgt::TexelCopyBufferLayout,
243        size: wgt::Extent3d,
244    },
245    Submit(crate::SubmissionIndex, Vec<Command<R>>),
246    FailedCommands {
247        commands: Option<Vec<Command<R>>>,
248        /// If `None`, then encoding failed due to a validation error (returned
249        /// from `CommandEncoder::finish`). If `Some`, submission failed due to
250        /// a resource having been destroyed.
251        failed_at_submit: Option<crate::SubmissionIndex>,
252        error: String,
253    },
254    CreateBlas {
255        id: R::Blas,
256        desc: crate::resource::BlasDescriptor<'a>,
257        sizes: wgt::BlasGeometrySizeDescriptors,
258    },
259    DropBlas(R::Blas),
260    CreateTlas {
261        id: R::Tlas,
262        desc: crate::resource::TlasDescriptor<'a>,
263    },
264    DropTlas(R::Tlas),
265}
266
267/// cbindgen:ignore
268pub type TraceBindGroupDescriptor<'a> = crate::binding_model::BindGroupDescriptor<
269    'a,
270    PointerId<markers::BindGroupLayout>,
271    PointerId<markers::Buffer>,
272    PointerId<markers::Sampler>,
273    PointerId<markers::TextureView>,
274    PointerId<markers::Tlas>,
275    PointerId<markers::ExternalTexture>,
276>;
277
278/// Not a public API. For use by `player` only.
279///
280/// cbindgen:ignore
281#[doc(hidden)]
282pub type TraceGeneralRenderPipelineDescriptor<'a> = GeneralRenderPipelineDescriptor<
283    'a,
284    PointerId<markers::PipelineLayout>,
285    PointerId<markers::ShaderModule>,
286    PointerId<markers::PipelineCache>,
287>;
288
289/// Not a public API. For use by `player` only.
290///
291/// cbindgen:ignore
292#[doc(hidden)]
293pub type TraceComputePipelineDescriptor<'a> = crate::pipeline::ComputePipelineDescriptor<
294    'a,
295    PointerId<markers::PipelineLayout>,
296    PointerId<markers::ShaderModule>,
297    PointerId<markers::PipelineCache>,
298>;
299
300/// Not a public API. For use by `player` only.
301///
302/// cbindgen:ignore
303#[doc(hidden)]
304pub type TraceRayTracingPipelineDescriptor<'a> =
305    crate::ray_tracing_pipeline::RayTracingPipelineDescriptor<
306        'a,
307        PointerId<markers::PipelineLayout>,
308        PointerId<markers::ShaderModule>,
309        PointerId<markers::PipelineCache>,
310    >;