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
6#[cfg(supports_64bit_atomics)]
7use core::sync::atomic::AtomicU64;
8#[cfg(not(supports_64bit_atomics))]
9use portable_atomic::AtomicU64;
10
11use crate::TlasInstance;
12
13mod buffer;
14pub use buffer::Buffer;
15mod command;
16pub use command::CommandBuffer;
17
18#[derive(Clone, Debug)]
19pub struct Api;
20
21pub struct Context {
22    options: Arc<wgt::NoopBackendOptions>,
23}
24#[derive(Debug)]
25pub struct Encoder;
26#[derive(Debug)]
27pub struct Resource;
28
29#[derive(Debug)]
30pub struct Fence {
31    value: AtomicU64,
32}
33
34type DeviceResult<T> = Result<T, crate::DeviceError>;
35
36impl crate::Api for Api {
37    const VARIANT: wgt::Backend = wgt::Backend::Noop;
38
39    type Instance = Context;
40    type Surface = Context;
41    type Adapter = Context;
42    type Device = Context;
43
44    type Queue = Context;
45    type CommandEncoder = CommandBuffer;
46    type CommandBuffer = CommandBuffer;
47
48    type Buffer = Buffer;
49    type Texture = Resource;
50    type SurfaceTexture = Resource;
51    type TextureView = Resource;
52    type Sampler = Resource;
53    type QuerySet = Resource;
54    type Fence = Fence;
55    type AccelerationStructure = Resource;
56    type PipelineCache = Resource;
57
58    type BindGroupLayout = Resource;
59    type BindGroup = Resource;
60    type PipelineLayout = Resource;
61    type ShaderModule = Resource;
62    type RenderPipeline = Resource;
63    type ComputePipeline = Resource;
64}
65
66crate::impl_dyn_resource!(Buffer, CommandBuffer, Context, Fence, Resource);
67
68impl crate::DynAccelerationStructure for Resource {}
69impl crate::DynBindGroup for Resource {}
70impl crate::DynBindGroupLayout for Resource {}
71impl crate::DynBuffer for Buffer {}
72impl crate::DynCommandBuffer for CommandBuffer {}
73impl crate::DynComputePipeline for Resource {}
74impl crate::DynFence for Fence {}
75impl crate::DynPipelineCache for Resource {}
76impl crate::DynPipelineLayout for Resource {}
77impl crate::DynQuerySet for Resource {}
78impl crate::DynRenderPipeline 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        },
182        downlevel: wgt::DownlevelCapabilities {
183            flags: wgt::DownlevelFlags::all(),
184            limits: wgt::DownlevelLimits {},
185            shader_model: wgt::ShaderModel::Sm5,
186        },
187        cooperative_matrix_properties: Vec::new(),
188    }
189};
190
191impl crate::Surface for Context {
192    type A = Api;
193
194    unsafe fn configure(
195        &self,
196        device: &Context,
197        config: &crate::SurfaceConfiguration,
198    ) -> Result<(), crate::SurfaceError> {
199        Ok(())
200    }
201
202    unsafe fn unconfigure(&self, device: &Context) {}
203
204    unsafe fn acquire_texture(
205        &self,
206        _timeout: Option<Duration>,
207        _fence: &Fence,
208    ) -> Result<crate::AcquiredSurfaceTexture<Api>, crate::SurfaceError> {
209        Err(crate::SurfaceError::Timeout)
210    }
211    unsafe fn discard_texture(&self, texture: Resource) {}
212}
213
214impl crate::Adapter for Context {
215    type A = Api;
216
217    unsafe fn open(
218        &self,
219        features: wgt::Features,
220        _limits: &wgt::Limits,
221        _memory_hints: &wgt::MemoryHints,
222    ) -> DeviceResult<crate::OpenDevice<Api>> {
223        Ok(crate::OpenDevice {
224            device: Context {
225                options: Arc::clone(&self.options),
226            },
227            queue: Context {
228                options: Arc::clone(&self.options),
229            },
230        })
231    }
232    unsafe fn texture_format_capabilities(
233        &self,
234        format: wgt::TextureFormat,
235    ) -> crate::TextureFormatCapabilities {
236        crate::TextureFormatCapabilities::empty()
237    }
238
239    unsafe fn surface_capabilities(&self, surface: &Context) -> Option<crate::SurfaceCapabilities> {
240        None
241    }
242
243    unsafe fn get_presentation_timestamp(&self) -> wgt::PresentationTimestamp {
244        wgt::PresentationTimestamp::INVALID_TIMESTAMP
245    }
246
247    fn get_ordered_buffer_usages(&self) -> wgt::BufferUses {
248        wgt::BufferUses::INCLUSIVE | wgt::BufferUses::MAP_WRITE
249    }
250
251    fn get_ordered_texture_usages(&self) -> wgt::TextureUses {
252        wgt::TextureUses::INCLUSIVE
253            | wgt::TextureUses::COLOR_TARGET
254            | wgt::TextureUses::DEPTH_STENCIL_WRITE
255    }
256}
257
258impl crate::Queue for Context {
259    type A = Api;
260
261    unsafe fn submit(
262        &self,
263        command_buffers: &[&CommandBuffer],
264        surface_textures: &[&Resource],
265        (fence, fence_value): (&mut Fence, crate::FenceValue),
266    ) -> DeviceResult<()> {
267        // All commands are executed synchronously.
268        for cb in command_buffers {
269            // SAFETY: Caller is responsible for ensuring synchronization between commands and
270            // other mutations.
271            unsafe {
272                cb.execute();
273            }
274        }
275        fence.value.store(fence_value, Ordering::Release);
276        Ok(())
277    }
278    unsafe fn present(
279        &self,
280        surface: &Context,
281        texture: Resource,
282    ) -> Result<(), crate::SurfaceError> {
283        Ok(())
284    }
285
286    unsafe fn get_timestamp_period(&self) -> f32 {
287        1.0
288    }
289
290    unsafe fn wait_for_idle(&self) -> Result<(), crate::DeviceError> {
291        Ok(())
292    }
293}
294
295impl crate::Device for Context {
296    type A = Api;
297
298    unsafe fn create_buffer(&self, desc: &crate::BufferDescriptor) -> DeviceResult<Buffer> {
299        Buffer::new(desc)
300    }
301
302    unsafe fn destroy_buffer(&self, buffer: Buffer) {}
303    unsafe fn add_raw_buffer(&self, _buffer: &Buffer) {}
304
305    unsafe fn map_buffer(
306        &self,
307        buffer: &Buffer,
308        range: crate::MemoryRange,
309    ) -> DeviceResult<crate::BufferMapping> {
310        // Safety: the `wgpu-core` validation layer will prevent any user-accessible aliasing
311        // mappings from being created, so we don’t need to perform any checks here, except for
312        // bounds checks on the range which are built into `get_slice_ptr()`.
313        Ok(crate::BufferMapping {
314            ptr: ptr::NonNull::new(buffer.get_slice_ptr(range).cast::<u8>()).unwrap(),
315            is_coherent: true,
316        })
317    }
318    unsafe fn unmap_buffer(&self, buffer: &Buffer) {}
319    unsafe fn flush_mapped_ranges<I>(&self, buffer: &Buffer, ranges: I) {}
320    unsafe fn invalidate_mapped_ranges<I>(&self, buffer: &Buffer, ranges: I) {}
321
322    unsafe fn create_texture(&self, desc: &crate::TextureDescriptor) -> DeviceResult<Resource> {
323        Ok(Resource)
324    }
325    unsafe fn destroy_texture(&self, texture: Resource) {}
326    unsafe fn add_raw_texture(&self, _texture: &Resource) {}
327
328    unsafe fn create_texture_view(
329        &self,
330        texture: &Resource,
331        desc: &crate::TextureViewDescriptor,
332    ) -> DeviceResult<Resource> {
333        Ok(Resource)
334    }
335    unsafe fn destroy_texture_view(&self, view: Resource) {}
336    unsafe fn create_sampler(&self, desc: &crate::SamplerDescriptor) -> DeviceResult<Resource> {
337        Ok(Resource)
338    }
339    unsafe fn destroy_sampler(&self, sampler: Resource) {}
340
341    unsafe fn create_command_encoder(
342        &self,
343        desc: &crate::CommandEncoderDescriptor<Context>,
344    ) -> DeviceResult<CommandBuffer> {
345        Ok(CommandBuffer::new())
346    }
347
348    unsafe fn create_bind_group_layout(
349        &self,
350        desc: &crate::BindGroupLayoutDescriptor,
351    ) -> DeviceResult<Resource> {
352        Ok(Resource)
353    }
354    unsafe fn destroy_bind_group_layout(&self, bg_layout: Resource) {}
355    unsafe fn create_pipeline_layout(
356        &self,
357        desc: &crate::PipelineLayoutDescriptor<Resource>,
358    ) -> DeviceResult<Resource> {
359        Ok(Resource)
360    }
361    unsafe fn destroy_pipeline_layout(&self, pipeline_layout: Resource) {}
362    unsafe fn create_bind_group(
363        &self,
364        desc: &crate::BindGroupDescriptor<Resource, Buffer, Resource, Resource, Resource>,
365    ) -> DeviceResult<Resource> {
366        Ok(Resource)
367    }
368    unsafe fn destroy_bind_group(&self, group: Resource) {}
369
370    unsafe fn create_shader_module(
371        &self,
372        desc: &crate::ShaderModuleDescriptor,
373        shader: crate::ShaderInput,
374    ) -> Result<Resource, crate::ShaderError> {
375        Ok(Resource)
376    }
377    unsafe fn destroy_shader_module(&self, module: Resource) {}
378    unsafe fn create_render_pipeline(
379        &self,
380        desc: &crate::RenderPipelineDescriptor<Resource, Resource, Resource>,
381    ) -> Result<Resource, crate::PipelineError> {
382        Ok(Resource)
383    }
384    unsafe fn destroy_render_pipeline(&self, pipeline: Resource) {}
385    unsafe fn create_compute_pipeline(
386        &self,
387        desc: &crate::ComputePipelineDescriptor<Resource, Resource, Resource>,
388    ) -> Result<Resource, crate::PipelineError> {
389        Ok(Resource)
390    }
391    unsafe fn destroy_compute_pipeline(&self, pipeline: Resource) {}
392    unsafe fn create_pipeline_cache(
393        &self,
394        desc: &crate::PipelineCacheDescriptor<'_>,
395    ) -> Result<Resource, crate::PipelineCacheError> {
396        Ok(Resource)
397    }
398    unsafe fn destroy_pipeline_cache(&self, cache: Resource) {}
399
400    unsafe fn create_query_set(
401        &self,
402        desc: &wgt::QuerySetDescriptor<crate::Label>,
403    ) -> DeviceResult<Resource> {
404        Ok(Resource)
405    }
406    unsafe fn destroy_query_set(&self, set: Resource) {}
407    unsafe fn create_fence(&self) -> DeviceResult<Fence> {
408        Ok(Fence {
409            value: AtomicU64::new(0),
410        })
411    }
412    unsafe fn destroy_fence(&self, fence: Fence) {}
413    unsafe fn get_fence_value(&self, fence: &Fence) -> DeviceResult<crate::FenceValue> {
414        Ok(fence.value.load(Ordering::Acquire))
415    }
416    unsafe fn wait(
417        &self,
418        fence: &Fence,
419        value: crate::FenceValue,
420        timeout: Option<Duration>,
421    ) -> DeviceResult<bool> {
422        // The relevant commands must have already been submitted, and noop-backend commands are
423        // executed synchronously, so there is no waiting — either it is already done,
424        // or this method was called incorrectly.
425        assert!(
426            fence.value.load(Ordering::Acquire) >= value,
427            "submission must have already been done"
428        );
429        Ok(true)
430    }
431
432    unsafe fn start_graphics_debugger_capture(&self) -> bool {
433        false
434    }
435    unsafe fn stop_graphics_debugger_capture(&self) {}
436    unsafe fn create_acceleration_structure(
437        &self,
438        desc: &crate::AccelerationStructureDescriptor,
439    ) -> DeviceResult<Resource> {
440        Ok(Resource)
441    }
442    unsafe fn get_acceleration_structure_build_sizes<'a>(
443        &self,
444        _desc: &crate::GetAccelerationStructureBuildSizesDescriptor<'a, Buffer>,
445    ) -> crate::AccelerationStructureBuildSizes {
446        Default::default()
447    }
448    unsafe fn get_acceleration_structure_device_address(
449        &self,
450        _acceleration_structure: &Resource,
451    ) -> wgt::BufferAddress {
452        Default::default()
453    }
454    unsafe fn destroy_acceleration_structure(&self, _acceleration_structure: Resource) {}
455
456    fn tlas_instance_to_bytes(&self, instance: TlasInstance) -> Vec<u8> {
457        vec![]
458    }
459
460    fn get_internal_counters(&self) -> wgt::HalCounters {
461        Default::default()
462    }
463
464    fn check_if_oom(&self) -> DeviceResult<()> {
465        Ok(())
466    }
467}
wgpu_hal/noop/mod.rs

wgpu_hal/noop/
mod.rs
