mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-22 15:31:03 +01:00
* fix more compile errors * fix err * fix all compile errors * fix clippy errors * fix issues in ray-traced-triangle example * fix clippy warnings * fix wasm not compiling * fix test * fix clippy (again) * fix some rustfmt issues * fix more rustfmt issues * fix even more rustfmt issues * fix yet more rustfmt issues * add #[allow(dead_code)] to some structs to fix clippy on web assembly * more format fixes * even more format fixes * close to final format fixes * final format fixes (hopefully) * actual final format fixes (hopefully) * move ray_cube_cube example and fix bugs * move other examples * fix crash when dropping * fix test * apply clippy and rustfmt changes * fix some memory leaks * fix incompatibility with new wgpu trunk changes * fix clippy & fmt * fix clippy errors on github * update to trunk * remove a line that printed log "Created blas ..." in device create tlas * fix merge issues * fix merge * fix fmt * restored example ray scene functionality * WIP fix rebase * Fix compile issues * More fixes * Fix rebase * Add wgls backend write_value_type AccelerationStructure * Add back xtask Cargo.lock * Revert serde path * Doc typos * Add -diff * Revert more serde * Revert serde again? * Fix doc typo * add test * clippy & fmt * fix error "blas does not exist" * fix various things * fix unused acceleration structures causing invalid SPIR-V * fix merge * fix use after free in a different way (now moved tlas instances to wgpu_core) * refactor & fmt * remove accidentally created file * remove accidentally created file (actually) * merge & fix * Fix problems * fix validation error * fix validation * fix merge * fmt * fix merge * use staging buffer trackers in creating the ray-tracing staging buffers (not the tlas_s) * change one missed staging buffer's tracker * wip: example * finished shadow! * fix merge * clippy * remove some uses of blas ids * fmt * fix merge * deduplicate code shared between command_encoder_build_acceleration_structures and command_encoder_build_acceleration_structures_unsafe_tlas * clippy * fix merge * fix warnings * clippy & fmt * re-add matching to get_raw_tlas_instance_size and tlas_instance_into_bytes * fmt * fix command * wip: fix merge * fix merge * fmt & docs * fix wasm clippy * fix issues with tests * fix issues with tests * fmt & clippy (wasm) * wip ray-traced-triangle (non hal) * unify camera location in ray_shadows * fix tests * add readme to ray_traced_triangle * note that vertex format must be f32x3 (not yet validated) * changelog * require VertexFormat::Float32x3 * fix compile error * when creating and building acceleration structures require Features::RAY_TRACING_ACCELERATION_STRUCTURE is enabled * remove duplicate workaround * fix most feedback * remove all changes from .gitattributes * fix compile error in test * more changes along same lines * format * apply feedback to more places * fix `cargo clippy` not just `cargo clippy --all-features` * cache max instances from tlas creation * fix clippy * fix examples * fix tests * remove now useless docs * add more docs * yet more docs * still more docs * Documentation. * Running out of unique commit messages to say writing docs. * Add more references to docs. * Get BindGroup in scope * Remove unintentional changes * Remove #[allow(dead_code)] * Remove old comments * Add device.poll * make ray_scene start right way up * fmt * move scratch buffer to its own module * actually remove intentional changes (turns out wgt is inconsistent) * use better names in ray_scene/shader.wgsl * fmt * remove more unintentional changes. * work on ray_tracing use after free * spelling Co-authored-by: Connor Fitzgerald <connorwadefitzgerald@gmail.com> * grammar Co-authored-by: Connor Fitzgerald <connorwadefitzgerald@gmail.com> * move things into struct (should be all vectors with 3 item types or more) * remove long-standing locks. * fmt * move not using index buffer to test * impl index & index mut for tlas package * impl index & index mut for tlas package * fix errors * fix test errors * move everything out of ray_tracing.rs * more index_mut * fmt * fix docs links * move to separate impl block * fix older request review * fmt * remove missed deref * fix wasm clippy * change to suggestions * fmt * add a note as to why `command_encoder_build_acceleration_structures_unsafe_tlas` and `command_encoder_build_acceleration_structures` are currently separate * add a todo to reconsider soon `command_encoder_build_acceleration_structures_unsafe_tlas` * switch to mat4 in ray-tracing examples * Combine RT Tests Under Single Submodule * Add More Raytracing Tests and Re-Organize * Documentation and Formatting Fixes * Remove Forced Alignment in wgpu-hal * work on out_of_order_as_build and add out_of_order_as_build_use * fmt * update test label naming * fix one validation error * fix clippy & fmt * add acceleration structure creation tests * make mis-matched index test use the correct function * move validation into validate_command_buffer * fix tests * add blas and tlas to pending writes to remove (now unneeded) `device.poll()`s * remove commented out code from examples and properly use the constants in ray_shadow * add examples to examples\README.md * rename ray tracing to ray queries in readme * remove unneeded usage from scratch buffer creation * use snatchables for raw acceleration structures * format * add EXPERIMENTAL_ to features * fix missed comment --------- Co-authored-by: Daniel Keitel <daniel.mg.keitel@fau.de> Co-authored-by: JMS55 <47158642+JMS55@users.noreply.github.com> Co-authored-by: atlas dostal <rodol@rivalrebels.com> Co-authored-by: vero <email@atlasdostal.com> Co-authored-by: Connor Fitzgerald <connorwadefitzgerald@gmail.com>
235 lines
9.6 KiB
Rust
235 lines
9.6 KiB
Rust
/*! Allocating resource ids, and tracking the resources they refer to.
|
|
|
|
The `wgpu_core` API uses identifiers of type [`Id<R>`] to refer to
|
|
resources of type `R`. For example, [`id::DeviceId`] is an alias for
|
|
`Id<markers::Device>`, and [`id::BufferId`] is an alias for
|
|
`Id<markers::Buffer>`. `Id` implements `Copy`, `Hash`, `Eq`, `Ord`, and
|
|
of course `Debug`.
|
|
|
|
[`id::DeviceId`]: crate::id::DeviceId
|
|
[`id::BufferId`]: crate::id::BufferId
|
|
|
|
Each `Id` contains not only an index for the resource it denotes but
|
|
also a Backend indicating which `wgpu` backend it belongs to.
|
|
|
|
`Id`s also incorporate a generation number, for additional validation.
|
|
|
|
The resources to which identifiers refer are freed explicitly.
|
|
Attempting to use an identifier for a resource that has been freed
|
|
elicits an error result.
|
|
|
|
## Assigning ids to resources
|
|
|
|
The users of `wgpu_core` generally want resource ids to be assigned
|
|
in one of two ways:
|
|
|
|
- Users like `wgpu` want `wgpu_core` to assign ids to resources itself.
|
|
For example, `wgpu` expects to call `Global::device_create_buffer`
|
|
and have the return value indicate the newly created buffer's id.
|
|
|
|
- Users like `player` and Firefox want to allocate ids themselves, and
|
|
pass `Global::device_create_buffer` and friends the id to assign the
|
|
new resource.
|
|
|
|
To accommodate either pattern, `wgpu_core` methods that create
|
|
resources all expect an `id_in` argument that the caller can use to
|
|
specify the id, and they all return the id used. For example, the
|
|
declaration of `Global::device_create_buffer` looks like this:
|
|
|
|
```ignore
|
|
impl Global {
|
|
/* ... */
|
|
pub fn device_create_buffer<A: HalApi>(
|
|
&self,
|
|
device_id: id::DeviceId,
|
|
desc: &resource::BufferDescriptor,
|
|
id_in: Input<G>,
|
|
) -> (id::BufferId, Option<resource::CreateBufferError>) {
|
|
/* ... */
|
|
}
|
|
/* ... */
|
|
}
|
|
```
|
|
|
|
Users that want to assign resource ids themselves pass in the id they
|
|
want as the `id_in` argument, whereas users that want `wgpu_core`
|
|
itself to choose ids always pass `()`. In either case, the id
|
|
ultimately assigned is returned as the first element of the tuple.
|
|
|
|
Producing true identifiers from `id_in` values is the job of an
|
|
[`crate::identity::IdentityManager`] or ids will be received from outside through `Option<Id>` arguments.
|
|
|
|
## Id allocation and streaming
|
|
|
|
Perhaps surprisingly, allowing users to assign resource ids themselves
|
|
enables major performance improvements in some applications.
|
|
|
|
The `wgpu_core` API is designed for use by Firefox's [WebGPU]
|
|
implementation. For security, web content and GPU use must be kept
|
|
segregated in separate processes, with all interaction between them
|
|
mediated by an inter-process communication protocol. As web content uses
|
|
the WebGPU API, the content process sends messages to the GPU process,
|
|
which interacts with the platform's GPU APIs on content's behalf,
|
|
occasionally sending results back.
|
|
|
|
In a classic Rust API, a resource allocation function takes parameters
|
|
describing the resource to create, and if creation succeeds, it returns
|
|
the resource id in a `Result::Ok` value. However, this design is a poor
|
|
fit for the split-process design described above: content must wait for
|
|
the reply to its buffer-creation message (say) before it can know which
|
|
id it can use in the next message that uses that buffer. On a common
|
|
usage pattern, the classic Rust design imposes the latency of a full
|
|
cross-process round trip.
|
|
|
|
We can avoid incurring these round-trip latencies simply by letting the
|
|
content process assign resource ids itself. With this approach, content
|
|
can choose an id for the new buffer, send a message to create the
|
|
buffer, and then immediately send the next message operating on that
|
|
buffer, since it already knows its id. Allowing content and GPU process
|
|
activity to be pipelined greatly improves throughput.
|
|
|
|
To help propagate errors correctly in this style of usage, when resource
|
|
creation fails, the id supplied for that resource is marked to indicate
|
|
as much, allowing subsequent operations using that id to be properly
|
|
flagged as errors as well.
|
|
|
|
[`process`]: crate::identity::IdentityManager::process
|
|
[`Id<R>`]: crate::id::Id
|
|
[wrapped in a mutex]: trait.IdentityHandler.html#impl-IdentityHandler%3CI%3E-for-Mutex%3CIdentityManager%3E
|
|
[WebGPU]: https://www.w3.org/TR/webgpu/
|
|
|
|
*/
|
|
|
|
use crate::{
|
|
binding_model::{BindGroup, BindGroupLayout, PipelineLayout},
|
|
command::{CommandBuffer, RenderBundle},
|
|
device::{queue::Queue, Device},
|
|
instance::Adapter,
|
|
pipeline::{ComputePipeline, PipelineCache, RenderPipeline, ShaderModule},
|
|
registry::{Registry, RegistryReport},
|
|
resource::{
|
|
Blas, Buffer, Fallible, QuerySet, Sampler, StagingBuffer, Texture, TextureView, Tlas,
|
|
},
|
|
};
|
|
use std::{fmt::Debug, sync::Arc};
|
|
|
|
#[derive(Debug, PartialEq, Eq)]
|
|
pub struct HubReport {
|
|
pub adapters: RegistryReport,
|
|
pub devices: RegistryReport,
|
|
pub queues: RegistryReport,
|
|
pub pipeline_layouts: RegistryReport,
|
|
pub shader_modules: RegistryReport,
|
|
pub bind_group_layouts: RegistryReport,
|
|
pub bind_groups: RegistryReport,
|
|
pub command_buffers: RegistryReport,
|
|
pub render_bundles: RegistryReport,
|
|
pub render_pipelines: RegistryReport,
|
|
pub compute_pipelines: RegistryReport,
|
|
pub pipeline_caches: RegistryReport,
|
|
pub query_sets: RegistryReport,
|
|
pub buffers: RegistryReport,
|
|
pub textures: RegistryReport,
|
|
pub texture_views: RegistryReport,
|
|
pub samplers: RegistryReport,
|
|
}
|
|
|
|
impl HubReport {
|
|
pub fn is_empty(&self) -> bool {
|
|
self.adapters.is_empty()
|
|
}
|
|
}
|
|
|
|
#[allow(rustdoc::private_intra_doc_links)]
|
|
/// All the resources tracked by a [`crate::global::Global`].
|
|
///
|
|
/// ## Locking
|
|
///
|
|
/// Each field in `Hub` is a [`Registry`] holding all the values of a
|
|
/// particular type of resource, all protected by a single RwLock.
|
|
/// So for example, to access any [`Buffer`], you must acquire a read
|
|
/// lock on the `Hub`s entire buffers registry. The lock guard
|
|
/// gives you access to the `Registry`'s [`Storage`], which you can
|
|
/// then index with the buffer's id. (Yes, this design causes
|
|
/// contention; see [#2272].)
|
|
///
|
|
/// But most `wgpu` operations require access to several different
|
|
/// kinds of resource, so you often need to hold locks on several
|
|
/// different fields of your [`Hub`] simultaneously.
|
|
///
|
|
/// Inside the `Registry` there are `Arc<T>` where `T` is a Resource
|
|
/// Lock of `Registry` happens only when accessing to get the specific resource
|
|
///
|
|
/// [`Storage`]: crate::storage::Storage
|
|
pub struct Hub {
|
|
pub(crate) adapters: Registry<Arc<Adapter>>,
|
|
pub(crate) devices: Registry<Arc<Device>>,
|
|
pub(crate) queues: Registry<Arc<Queue>>,
|
|
pub(crate) pipeline_layouts: Registry<Fallible<PipelineLayout>>,
|
|
pub(crate) shader_modules: Registry<Fallible<ShaderModule>>,
|
|
pub(crate) bind_group_layouts: Registry<Fallible<BindGroupLayout>>,
|
|
pub(crate) bind_groups: Registry<Fallible<BindGroup>>,
|
|
pub(crate) command_buffers: Registry<Arc<CommandBuffer>>,
|
|
pub(crate) render_bundles: Registry<Fallible<RenderBundle>>,
|
|
pub(crate) render_pipelines: Registry<Fallible<RenderPipeline>>,
|
|
pub(crate) compute_pipelines: Registry<Fallible<ComputePipeline>>,
|
|
pub(crate) pipeline_caches: Registry<Fallible<PipelineCache>>,
|
|
pub(crate) query_sets: Registry<Fallible<QuerySet>>,
|
|
pub(crate) buffers: Registry<Fallible<Buffer>>,
|
|
pub(crate) staging_buffers: Registry<StagingBuffer>,
|
|
pub(crate) textures: Registry<Fallible<Texture>>,
|
|
pub(crate) texture_views: Registry<Fallible<TextureView>>,
|
|
pub(crate) samplers: Registry<Fallible<Sampler>>,
|
|
pub(crate) blas_s: Registry<Fallible<Blas>>,
|
|
pub(crate) tlas_s: Registry<Fallible<Tlas>>,
|
|
}
|
|
|
|
impl Hub {
|
|
pub(crate) fn new() -> Self {
|
|
Self {
|
|
adapters: Registry::new(),
|
|
devices: Registry::new(),
|
|
queues: Registry::new(),
|
|
pipeline_layouts: Registry::new(),
|
|
shader_modules: Registry::new(),
|
|
bind_group_layouts: Registry::new(),
|
|
bind_groups: Registry::new(),
|
|
command_buffers: Registry::new(),
|
|
render_bundles: Registry::new(),
|
|
render_pipelines: Registry::new(),
|
|
compute_pipelines: Registry::new(),
|
|
pipeline_caches: Registry::new(),
|
|
query_sets: Registry::new(),
|
|
buffers: Registry::new(),
|
|
staging_buffers: Registry::new(),
|
|
textures: Registry::new(),
|
|
texture_views: Registry::new(),
|
|
samplers: Registry::new(),
|
|
blas_s: Registry::new(),
|
|
tlas_s: Registry::new(),
|
|
}
|
|
}
|
|
|
|
pub fn generate_report(&self) -> HubReport {
|
|
HubReport {
|
|
adapters: self.adapters.generate_report(),
|
|
devices: self.devices.generate_report(),
|
|
queues: self.queues.generate_report(),
|
|
pipeline_layouts: self.pipeline_layouts.generate_report(),
|
|
shader_modules: self.shader_modules.generate_report(),
|
|
bind_group_layouts: self.bind_group_layouts.generate_report(),
|
|
bind_groups: self.bind_groups.generate_report(),
|
|
command_buffers: self.command_buffers.generate_report(),
|
|
render_bundles: self.render_bundles.generate_report(),
|
|
render_pipelines: self.render_pipelines.generate_report(),
|
|
compute_pipelines: self.compute_pipelines.generate_report(),
|
|
pipeline_caches: self.pipeline_caches.generate_report(),
|
|
query_sets: self.query_sets.generate_report(),
|
|
buffers: self.buffers.generate_report(),
|
|
textures: self.textures.generate_report(),
|
|
texture_views: self.texture_views.generate_report(),
|
|
samplers: self.samplers.generate_report(),
|
|
}
|
|
}
|
|
}
|