wgpu_hal/noop/
mod.rs

1#![allow(unused_variables)]
2
3use alloc::{string::String, sync::Arc, vec, vec::Vec};
4use core::{ptr, sync::atomic::Ordering, time::Duration};
5
6use wgpu_sync::atomic::AtomicU64;
7
8use crate::TlasInstance;
9
10mod buffer;
11pub use buffer::Buffer;
12mod command;
13pub use command::CommandBuffer;
14
15#[derive(Clone, Debug)]
16pub struct Api;
17
18#[derive(Debug)]
19pub struct Context {
20    options: Arc<wgt::NoopBackendOptions>,
21}
22#[derive(Debug)]
23pub struct Encoder;
24#[derive(Debug)]
25pub struct Resource;
26
27#[derive(Debug)]
28pub struct Fence {
29    value: AtomicU64,
30}
31
32type DeviceResult<T> = Result<T, crate::DeviceError>;
33
34impl crate::Api for Api {
35    const VARIANT: wgt::Backend = wgt::Backend::Noop;
36
37    type Instance = Context;
38    type Surface = Context;
39    type Adapter = Context;
40    type Device = Context;
41
42    type Queue = Context;
43    type CommandEncoder = CommandBuffer;
44    type CommandBuffer = CommandBuffer;
45
46    type Buffer = Buffer;
47    type Texture = Resource;
48    type SurfaceTexture = Resource;
49    type TextureView = Resource;
50    type Sampler = Resource;
51    type QuerySet = Resource;
52    type Fence = Fence;
53    type AccelerationStructure = Resource;
54    type PipelineCache = Resource;
55
56    type BindGroupLayout = Resource;
57    type BindGroup = Resource;
58    type PipelineLayout = Resource;
59    type ShaderModule = Resource;
60    type RenderPipeline = Resource;
61    type RayTracingPipeline = Resource;
62    type ComputePipeline = Resource;
63}
64
65crate::impl_dyn_resource!(Buffer, CommandBuffer, Context, Fence, Resource);
66
67impl crate::DynAccelerationStructure for Resource {}
68impl crate::DynBindGroup for Resource {}
69impl crate::DynBindGroupLayout for Resource {}
70impl crate::DynBuffer for Buffer {}
71impl crate::DynCommandBuffer for CommandBuffer {}
72impl crate::DynComputePipeline for Resource {}
73impl crate::DynFence for Fence {}
74impl crate::DynPipelineCache for Resource {}
75impl crate::DynPipelineLayout for Resource {}
76impl crate::DynQuerySet for Resource {}
77impl crate::DynRenderPipeline for Resource {}
78impl crate::DynRayTracingPipeline for Resource {}
79impl crate::DynSampler for Resource {}
80impl crate::DynShaderModule for Resource {}
81impl crate::DynSurfaceTexture for Resource {}
82impl crate::DynTexture for Resource {}
83impl crate::DynTextureView for Resource {}
84
85impl core::borrow::Borrow<dyn crate::DynTexture> for Resource {
86    fn borrow(&self) -> &dyn crate::DynTexture {
87        self
88    }
89}
90
91impl crate::Instance for Context {
92    type A = Api;
93
94    unsafe fn init(desc: &crate::InstanceDescriptor<'_>) -> Result<Self, crate::InstanceError> {
95        let options = Arc::new(desc.backend_options.noop.clone());
96        if options.enable {
97            Ok(Context { options })
98        } else {
99            Err(crate::InstanceError::new(String::from(
100                "noop backend disabled because NoopBackendOptions::enable is false",
101            )))
102        }
103    }
104    unsafe fn create_surface(
105        &self,
106        _display_handle: raw_window_handle::RawDisplayHandle,
107        _window_handle: raw_window_handle::RawWindowHandle,
108    ) -> Result<Context, crate::InstanceError> {
109        Ok(Context {
110            options: Arc::clone(&self.options),
111        })
112    }
113    unsafe fn enumerate_adapters(
114        &self,
115        _surface_hint: Option<&Context>,
116    ) -> Vec<crate::ExposedAdapter<Api>> {
117        let device_type = self.options.device_type.unwrap_or(wgt::DeviceType::Other);
118        let subgroup_min_size = self
119            .options
120            .subgroup_min_size
121            .unwrap_or(wgt::MINIMUM_SUBGROUP_MIN_SIZE);
122        let subgroup_max_size = self
123            .options
124            .subgroup_max_size
125            .unwrap_or(wgt::MAXIMUM_SUBGROUP_MAX_SIZE);
126        let features = self.options.features.unwrap_or(wgt::Features::all());
127        let limits = self
128            .options
129            .limits
130            .clone()
131            .unwrap_or(CAPABILITIES.limits.clone());
132
133        let info = wgt::AdapterInfo {
134            subgroup_min_size,
135            subgroup_max_size,
136            ..adapter_info()
137        };
138
139        let capabilities = crate::Capabilities {
140            limits,
141            ..CAPABILITIES
142        };
143
144        vec![crate::ExposedAdapter {
145            adapter: Context {
146                options: Arc::clone(&self.options),
147            },
148            info,
149            features,
150            capabilities,
151        }]
152    }
153}
154
155/// Returns the adapter info for the noop backend.
156///
157/// This is used in the test harness to construct info about
158/// the noop backend adapter without actually initializing wgpu.
159pub fn adapter_info() -> wgt::AdapterInfo {
160    wgt::AdapterInfo {
161        name: String::from("noop wgpu backend"),
162        driver: String::from("wgpu"),
163        ..wgt::AdapterInfo::new(wgt::DeviceType::Cpu, wgt::Backend::Noop)
164    }
165}
166
167/// The capabilities of the noop backend.
168///
169/// This is used in the test harness to construct capabilities
170/// of the noop backend without actually initializing wgpu.
171pub const CAPABILITIES: crate::Capabilities = {
172    crate::Capabilities {
173        limits: wgt::Limits::unlimited(),
174        alignments: crate::Alignments {
175            // All maximally permissive
176            buffer_copy_offset: wgt::BufferSize::MIN,
177            buffer_copy_pitch: wgt::BufferSize::MIN,
178            uniform_bounds_check_alignment: wgt::BufferSize::MIN,
179            raw_tlas_instance_size: 0,
180            ray_tracing_scratch_buffer_alignment: 1,
181            ray_tracing_pipeline_group_data_size: 1,
182            ray_tracing_pipeline_group_data_alignment: 1,
183            ray_tracing_pipeline_data_offset_alignment: 1,
184        },
185        downlevel: wgt::DownlevelCapabilities {
186            flags: wgt::DownlevelFlags::all(),
187            limits: wgt::DownlevelLimits {},
188            shader_model: wgt::ShaderModel::Sm5,
189        },
190        cooperative_matrix_properties: Vec::new(),
191    }
192};
193
194impl crate::Surface for Context {
195    type A = Api;
196
197    unsafe fn configure(
198        &self,
199        device: &Context,
200        config: &crate::SurfaceConfiguration,
201    ) -> Result<(), crate::SurfaceError> {
202        Ok(())
203    }
204
205    unsafe fn unconfigure(&self, device: &Context) {}
206
207    unsafe fn acquire_texture(
208        &self,
209        _timeout: Option<Duration>,
210        _fence: &Fence,
211    ) -> Result<crate::AcquiredSurfaceTexture<Api>, crate::SurfaceError> {
212        Err(crate::SurfaceError::Timeout)
213    }
214    unsafe fn discard_texture(&self, texture: Resource) {}
215}
216
217impl crate::Adapter for Context {
218    type A = Api;
219
220    unsafe fn open(
221        &self,
222        features: wgt::Features,
223        _limits: &wgt::Limits,
224        _memory_hints: &wgt::MemoryHints,
225    ) -> DeviceResult<crate::OpenDevice<Api>> {
226        Ok(crate::OpenDevice {
227            device: Context {
228                options: Arc::clone(&self.options),
229            },
230            queue: Context {
231                options: Arc::clone(&self.options),
232            },
233        })
234    }
235    unsafe fn texture_format_capabilities(
236        &self,
237        format: wgt::TextureFormat,
238    ) -> crate::TextureFormatCapabilities {
239        crate::TextureFormatCapabilities::empty()
240    }
241
242    unsafe fn surface_capabilities(&self, surface: &Context) -> Option<crate::SurfaceCapabilities> {
243        None
244    }
245
246    unsafe fn get_presentation_timestamp(&self) -> wgt::PresentationTimestamp {
247        wgt::PresentationTimestamp::INVALID_TIMESTAMP
248    }
249
250    fn get_ordered_buffer_usages(&self) -> wgt::BufferUses {
251        wgt::BufferUses::INCLUSIVE | wgt::BufferUses::MAP_WRITE
252    }
253
254    fn get_ordered_texture_usages(&self) -> wgt::TextureUses {
255        wgt::TextureUses::INCLUSIVE
256            | wgt::TextureUses::COLOR_TARGET
257            | wgt::TextureUses::DEPTH_WRITE
258            | wgt::TextureUses::STENCIL_WRITE
259    }
260}
261
262impl crate::Queue for Context {
263    type A = Api;
264
265    unsafe fn submit(
266        &self,
267        command_buffers: &[&CommandBuffer],
268        surface_textures: &[&Resource],
269        (fence, fence_value): (&Fence, crate::FenceValue),
270    ) -> DeviceResult<()> {
271        // All commands are executed synchronously.
272        for cb in command_buffers {
273            // SAFETY: Caller is responsible for ensuring synchronization between commands and
274            // other mutations.
275            unsafe {
276                cb.execute();
277            }
278        }
279        fence.value.store(fence_value, Ordering::Release);
280        Ok(())
281    }
282    unsafe fn present(
283        &self,
284        surface: &Context,
285        texture: Resource,
286    ) -> Result<(), crate::SurfaceError> {
287        Ok(())
288    }
289
290    unsafe fn get_timestamp_period(&self) -> f32 {
291        1.0
292    }
293
294    unsafe fn wait_for_idle(&self) -> Result<(), crate::DeviceError> {
295        Ok(())
296    }
297}
298
299impl crate::Device for Context {
300    type A = Api;
301
302    unsafe fn create_buffer(&self, desc: &crate::BufferDescriptor) -> DeviceResult<Buffer> {
303        Buffer::new(desc)
304    }
305
306    unsafe fn destroy_buffer(&self, buffer: Buffer) {}
307    unsafe fn add_raw_buffer(&self, _buffer: &Buffer) {}
308
309    unsafe fn map_buffer(
310        &self,
311        buffer: &Buffer,
312        range: crate::MemoryRange,
313    ) -> DeviceResult<crate::BufferMapping> {
314        // Safety: the `wgpu-core` validation layer will prevent any user-accessible aliasing
315        // mappings from being created, so we don’t need to perform any checks here, except for
316        // bounds checks on the range which are built into `get_slice_ptr()`.
317        Ok(crate::BufferMapping {
318            ptr: ptr::NonNull::new(buffer.get_slice_ptr(range).cast::<u8>()).unwrap(),
319            is_coherent: true,
320        })
321    }
322    unsafe fn unmap_buffer(&self, buffer: &Buffer) {}
323    unsafe fn flush_mapped_ranges<I>(&self, buffer: &Buffer, ranges: I) {}
324    unsafe fn invalidate_mapped_ranges<I>(&self, buffer: &Buffer, ranges: I) {}
325
326    unsafe fn create_texture(&self, desc: &crate::TextureDescriptor) -> DeviceResult<Resource> {
327        Ok(Resource)
328    }
329    unsafe fn destroy_texture(&self, texture: Resource) {}
330    unsafe fn add_raw_texture(&self, _texture: &Resource) {}
331
332    unsafe fn create_texture_view(
333        &self,
334        texture: &Resource,
335        desc: &crate::TextureViewDescriptor,
336    ) -> DeviceResult<Resource> {
337        Ok(Resource)
338    }
339    unsafe fn destroy_texture_view(&self, view: Resource) {}
340    unsafe fn create_sampler(&self, desc: &crate::SamplerDescriptor) -> DeviceResult<Resource> {
341        Ok(Resource)
342    }
343    unsafe fn destroy_sampler(&self, sampler: Resource) {}
344
345    unsafe fn create_command_encoder(
346        &self,
347        desc: &crate::CommandEncoderDescriptor<Context>,
348    ) -> DeviceResult<CommandBuffer> {
349        Ok(CommandBuffer::new())
350    }
351
352    unsafe fn create_bind_group_layout(
353        &self,
354        desc: &crate::BindGroupLayoutDescriptor,
355    ) -> DeviceResult<Resource> {
356        Ok(Resource)
357    }
358    unsafe fn destroy_bind_group_layout(&self, bg_layout: Resource) {}
359    unsafe fn create_pipeline_layout(
360        &self,
361        desc: &crate::PipelineLayoutDescriptor<Resource>,
362    ) -> DeviceResult<Resource> {
363        Ok(Resource)
364    }
365    unsafe fn destroy_pipeline_layout(&self, pipeline_layout: Resource) {}
366    unsafe fn create_bind_group(
367        &self,
368        desc: &crate::BindGroupDescriptor<Resource, Buffer, Resource, Resource, Resource>,
369    ) -> DeviceResult<Resource> {
370        Ok(Resource)
371    }
372    unsafe fn destroy_bind_group(&self, group: Resource) {}
373
374    unsafe fn create_shader_module(
375        &self,
376        desc: &crate::ShaderModuleDescriptor,
377        shader: crate::ShaderInput,
378    ) -> Result<Resource, crate::ShaderError> {
379        Ok(Resource)
380    }
381    unsafe fn destroy_shader_module(&self, module: Resource) {}
382    unsafe fn create_render_pipeline(
383        &self,
384        desc: &crate::RenderPipelineDescriptor<Resource, Resource, Resource>,
385    ) -> Result<Resource, crate::PipelineError> {
386        Ok(Resource)
387    }
388    unsafe fn destroy_render_pipeline(&self, pipeline: Resource) {}
389    unsafe fn create_compute_pipeline(
390        &self,
391        desc: &crate::ComputePipelineDescriptor<Resource, Resource, Resource>,
392    ) -> Result<Resource, crate::PipelineError> {
393        Ok(Resource)
394    }
395    unsafe fn destroy_compute_pipeline(&self, pipeline: Resource) {}
396    unsafe fn create_ray_tracing_pipeline(
397        &self,
398        desc: &crate::RayTracingPipelineDescriptor<Resource, Resource, Resource>,
399    ) -> Result<Resource, crate::PipelineError> {
400        Ok(Resource)
401    }
402    unsafe fn destroy_ray_tracing_pipeline(&self, pipeline: Resource) {}
403    unsafe fn get_raytracing_pipeline_group_data(
404        &self,
405        pipeline: &Resource,
406        groups: core::ops::Range<u32>,
407    ) -> Result<Vec<u8>, crate::DeviceError> {
408        Ok(vec![0; groups.count()])
409    }
410    unsafe fn create_pipeline_cache(
411        &self,
412        desc: &crate::PipelineCacheDescriptor<'_>,
413    ) -> Result<Resource, crate::PipelineCacheError> {
414        Ok(Resource)
415    }
416    unsafe fn destroy_pipeline_cache(&self, cache: Resource) {}
417
418    unsafe fn create_query_set(
419        &self,
420        desc: &wgt::QuerySetDescriptor<crate::Label>,
421    ) -> DeviceResult<Resource> {
422        Ok(Resource)
423    }
424    unsafe fn destroy_query_set(&self, set: Resource) {}
425    unsafe fn create_fence(&self) -> DeviceResult<Fence> {
426        Ok(Fence {
427            value: AtomicU64::new(0),
428        })
429    }
430    unsafe fn destroy_fence(&self, fence: Fence) {}
431    unsafe fn get_fence_value(&self, fence: &Fence) -> DeviceResult<crate::FenceValue> {
432        Ok(fence.value.load(Ordering::Acquire))
433    }
434    unsafe fn wait(
435        &self,
436        fence: &Fence,
437        value: crate::FenceValue,
438        timeout: Option<Duration>,
439    ) -> DeviceResult<bool> {
440        // The relevant commands must have already been submitted, and noop-backend commands are
441        // executed synchronously, so there is no waiting — either it is already done,
442        // or this method was called incorrectly.
443        assert!(
444            fence.value.load(Ordering::Acquire) >= value,
445            "submission must have already been done"
446        );
447        Ok(true)
448    }
449
450    unsafe fn start_graphics_debugger_capture(&self) -> bool {
451        false
452    }
453    unsafe fn stop_graphics_debugger_capture(&self) {}
454    unsafe fn create_acceleration_structure(
455        &self,
456        desc: &crate::AccelerationStructureDescriptor,
457    ) -> DeviceResult<Resource> {
458        Ok(Resource)
459    }
460    unsafe fn get_acceleration_structure_build_sizes<'a>(
461        &self,
462        _desc: &crate::GetAccelerationStructureBuildSizesDescriptor<'a, Buffer>,
463    ) -> crate::AccelerationStructureBuildSizes {
464        Default::default()
465    }
466    unsafe fn get_acceleration_structure_device_address(
467        &self,
468        _acceleration_structure: &Resource,
469    ) -> wgt::BufferAddress {
470        Default::default()
471    }
472    unsafe fn destroy_acceleration_structure(&self, _acceleration_structure: Resource) {}
473
474    fn tlas_instance_to_bytes(&self, instance: TlasInstance, to_extend: &mut Vec<u8>) {}
475
476    fn get_internal_counters(&self) -> wgt::HalCounters {
477        Default::default()
478    }
479
480    fn check_if_oom(&self) -> DeviceResult<()> {
481        Ok(())
482    }
483}
wgpu_hal/noop/mod.rs

wgpu_hal/noop/
mod.rs
