More complete implementation of "lose the device". (#4645)

* More complete implementation of "lose the device".

This provides a way for wgpu-core to specify a callback on "lose the
device". It ensures this callback is called at the appropriate times:
either after device.destroy has empty queues, or on demand from
device.lose.

A test has been added to device.rs.

* Updated CHANGELOG.md.

* Fix conversion to *const c_char.

* Use an allow lint to permit trivial_casts.

* rustfmt changes.
This commit is contained in:
Brad Werth authored and GitHub committed 2023-11-08 22:22:18 +01:00
1 parent 5f79800244
commit 4e65eca1e8
11 files changed
+316 -52

No files matched your search

+2
View File
@@ -247,6 +247,8 @@ By @teoxoy in [#4185](https://github.com/gfx-rs/wgpu/pull/4185)
- Calls to lost devices now return `DeviceError::Lost` instead of `DeviceError::Invalid`. By @bradwerth in [#4238]([https://github.com/gfx-rs/wgpu/pull/4238])
- Let the `"strict_asserts"` feature enable check that wgpu-core's lock-ordering tokens are unique per thread. By @jimblandy in [#4258]([https://github.com/gfx-rs/wgpu/pull/4258])
- Allow filtering labels out before they are passed to GPU drivers by @nical in [https://github.com/gfx-rs/wgpu/pull/4246](4246)
- `DeviceLostClosure` callback mechanism provided so user agents can resolve `GPUDevice.lost` Promises at the appropriate time by @bradwerth in [#4645](https://github.com/gfx-rs/wgpu/pull/4645)
#### Vulkan
+32
View File
@@ -448,3 +448,35 @@ static DEVICE_DESTROY_THEN_MORE: GpuTestConfiguration = GpuTestConfiguration::ne
buffer_for_unmap.unmap();
});
});
#[gpu_test]
static DEVICE_DESTROY_THEN_LOST: GpuTestConfiguration = GpuTestConfiguration::new()
.parameters(TestParameters::default())
.run_sync(|ctx| {
// This test checks that when device.destroy is called, the provided
// DeviceLostClosure is called with reason DeviceLostReason::Destroyed.
let was_called = std::sync::Arc::<std::sync::atomic::AtomicBool>::new(false.into());
// Set a LoseDeviceCallback on the device.
let was_called_clone = was_called.clone();
let callback = Box::new(move |reason, _m| {
was_called_clone.store(true, std::sync::atomic::Ordering::SeqCst);
assert!(
matches!(reason, wgt::DeviceLostReason::Destroyed),
"Device lost info reason should match DeviceLostReason::Destroyed."
);
});
ctx.device.set_device_lost_callback(callback);
// Destroy the device.
ctx.device.destroy();
// Make sure the device queues are empty, which ensures that the closure
// has been called.
assert!(ctx.device.poll(wgpu::Maintain::Wait));
assert!(
was_called.load(std::sync::atomic::Ordering::SeqCst),
"Device lost callback should have been called."
);
});
+28 -21
View File
@@ -3,7 +3,9 @@ use crate::device::trace;
use crate::{
binding_model::{self, BindGroupLayout},
command, conv,
device::{life::WaitIdleError, map_buffer, queue, Device, DeviceError, HostMap},
device::{
life::WaitIdleError, map_buffer, queue, Device, DeviceError, DeviceLostClosure, HostMap,
},
global::Global,
hal_api::HalApi,
hub::Token,
@@ -2672,6 +2674,21 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
}
}
pub fn device_set_device_lost_closure<A: HalApi>(
&self,
device_id: DeviceId,
device_lost_closure: DeviceLostClosure,
) {
let hub = A::hub(self);
let mut token = Token::root();
let (mut device_guard, mut token) = hub.devices.write(&mut token);
if let Ok(device) = device_guard.get_mut(device_id) {
let mut life_tracker = device.lock_life(&mut token);
life_tracker.device_lost_closure = Some(device_lost_closure);
}
}
pub fn device_destroy<A: HalApi>(&self, device_id: DeviceId) {
log::trace!("Device::destroy {device_id:?}");
@@ -2683,36 +2700,26 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
// Follow the steps at
// https://gpuweb.github.io/gpuweb/#dom-gpudevice-destroy.
// It's legal to call destroy multiple times, but if the device
// is already invalid, there's nothing more to do. There's also
// no need to return an error.
if !device.valid {
return;
}
// The last part of destroy is to lose the device. The spec says
// delay that until all "currently-enqueued operations on any
// queue on this device are completed."
// TODO: implement this delay.
// Finish by losing the device.
// TODO: associate this "destroyed" reason more tightly with
// the GPUDeviceLostReason defined in webgpu.idl.
device.lose(Some("destroyed"));
// queue on this device are completed." This is accomplished by
// setting valid to false, and then relying upon maintain to
// check for empty queues and a DeviceLostClosure. At that time,
// the DeviceLostClosure will be called with "destroyed" as the
// reason.
device.valid = false;
}
}
pub fn device_lose<A: HalApi>(&self, device_id: DeviceId, reason: Option<&str>) {
log::trace!("Device::lose {device_id:?}");
pub fn device_mark_lost<A: HalApi>(&self, device_id: DeviceId, message: &str) {
log::trace!("Device::mark_lost {device_id:?}");
let hub = A::hub(self);
let mut token = Token::root();
let (mut device_guard, _) = hub.devices.write(&mut token);
let (mut device_guard, mut token) = hub.devices.write(&mut token);
if let Ok(device) = device_guard.get_mut(device_id) {
device.lose(reason);
device.lose(&mut token, message);
}
}
+7 -1
View File
@@ -3,7 +3,7 @@ use crate::device::trace;
use crate::{
device::{
queue::{EncoderInFlight, SubmittedWorkDoneClosure, TempResource},
DeviceError,
DeviceError, DeviceLostClosure,
},
hal_api::HalApi,
hub::{Hub, Token},
@@ -313,6 +313,11 @@ pub(super) struct LifetimeTracker<A: hal::Api> {
/// must happen _after_ all mapped buffer callbacks are mapped, so we defer them
/// here until the next time the device is maintained.
work_done_closures: SmallVec<[SubmittedWorkDoneClosure; 1]>,
/// Closure to be called on "lose the device". This is invoked directly by
/// device.lose or by the UserCallbacks returned from maintain when the device
/// has been destroyed and its queues are empty.
pub device_lost_closure: Option<DeviceLostClosure>,
}
impl<A: hal::Api> LifetimeTracker<A> {
@@ -326,6 +331,7 @@ impl<A: hal::Api> LifetimeTracker<A> {
free_resources: NonReferencedResources::new(),
ready_to_map: Vec::new(),
work_done_closures: SmallVec::new(),
device_lost_closure: None,
}
}
+97 -1
View File
@@ -12,8 +12,9 @@ use crate::{
use arrayvec::ArrayVec;
use hal::Device as _;
use smallvec::SmallVec;
use std::os::raw::c_char;
use thiserror::Error;
use wgt::{BufferAddress, TextureFormat};
use wgt::{BufferAddress, DeviceLostReason, TextureFormat};
use std::{iter, num::NonZeroU32, ptr};
@@ -169,12 +170,15 @@ pub type BufferMapPendingClosure = (BufferMapOperation, BufferAccessResult);
pub struct UserClosures {
pub mappings: Vec<BufferMapPendingClosure>,
pub submissions: SmallVec<[queue::SubmittedWorkDoneClosure; 1]>,
pub device_lost_invocations: SmallVec<[DeviceLostInvocation; 1]>,
}
impl UserClosures {
fn extend(&mut self, other: Self) {
self.mappings.extend(other.mappings);
self.submissions.extend(other.submissions);
self.device_lost_invocations
.extend(other.device_lost_invocations);
}
fn fire(self) {
@@ -189,6 +193,98 @@ impl UserClosures {
for closure in self.submissions {
closure.call();
}
for invocation in self.device_lost_invocations {
invocation
.closure
.call(invocation.reason, invocation.message);
}
}
}
#[cfg(any(
not(target_arch = "wasm32"),
all(
feature = "fragile-send-sync-non-atomic-wasm",
not(target_feature = "atomics")
)
))]
pub type DeviceLostCallback = Box<dyn FnOnce(DeviceLostReason, String) + Send + 'static>;
#[cfg(not(any(
not(target_arch = "wasm32"),
all(
feature = "fragile-send-sync-non-atomic-wasm",
not(target_feature = "atomics")
)
)))]
pub type DeviceLostCallback = Box<dyn FnOnce(DeviceLostReason, String) + 'static>;
#[repr(C)]
pub struct DeviceLostClosureC {
pub callback: unsafe extern "C" fn(user_data: *mut u8, reason: u8, message: *const c_char),
pub user_data: *mut u8,
}
#[cfg(any(
not(target_arch = "wasm32"),
all(
feature = "fragile-send-sync-non-atomic-wasm",
not(target_feature = "atomics")
)
))]
unsafe impl Send for DeviceLostClosureC {}
pub struct DeviceLostClosure {
// We wrap this so creating the enum in the C variant can be unsafe,
// allowing our call function to be safe.
inner: DeviceLostClosureInner,
}
pub struct DeviceLostInvocation {
closure: DeviceLostClosure,
reason: DeviceLostReason,
message: String,
}
enum DeviceLostClosureInner {
Rust { callback: DeviceLostCallback },
C { inner: DeviceLostClosureC },
}
impl DeviceLostClosure {
pub fn from_rust(callback: DeviceLostCallback) -> Self {
Self {
inner: DeviceLostClosureInner::Rust { callback },
}
}
/// # Safety
///
/// - The callback pointer must be valid to call with the provided `user_data`
/// pointer.
///
/// - Both pointers must point to `'static` data, as the callback may happen at
/// an unspecified time.
pub unsafe fn from_c(inner: DeviceLostClosureC) -> Self {
Self {
inner: DeviceLostClosureInner::C { inner },
}
}
#[allow(trivial_casts)]
pub(crate) fn call(self, reason: DeviceLostReason, message: String) {
match self.inner {
DeviceLostClosureInner::Rust { callback } => callback(reason, message),
// SAFETY: the contract of the call to from_c says that this unsafe is sound.
DeviceLostClosureInner::C { inner } => unsafe {
// We need to pass message as a c_char typed pointer. To avoid trivial
// conversion warnings on some platforms, we use the allow lint.
(inner.callback)(
inner.user_data,
reason as u8,
message.as_ptr() as *const c_char,
)
},
}
}
}
+28 -7
View File
@@ -8,8 +8,8 @@ use crate::{
command, conv,
device::life::WaitIdleError,
device::{
AttachmentData, CommandAllocator, MissingDownlevelFlags, MissingFeatures,
RenderPassContext, CLEANUP_WAIT_MS,
AttachmentData, CommandAllocator, DeviceLostInvocation, MissingDownlevelFlags,
MissingFeatures, RenderPassContext, CLEANUP_WAIT_MS,
},
hal_api::HalApi,
hal_label,
@@ -34,7 +34,7 @@ use hal::{CommandEncoder as _, Device as _};
use parking_lot::{Mutex, MutexGuard};
use smallvec::SmallVec;
use thiserror::Error;
use wgt::{TextureFormat, TextureSampleType, TextureViewDimension};
use wgt::{DeviceLostReason, TextureFormat, TextureSampleType, TextureViewDimension};
use std::{borrow::Cow, iter, num::NonZeroU32};
@@ -315,9 +315,24 @@ impl<A: HalApi> Device<A> {
let mapping_closures = life_tracker.handle_mapping(hub, &self.raw, &self.trackers, token);
life_tracker.cleanup(&self.raw);
// Detect if we have been destroyed and now need to lose the device.
// If we are invalid (set at start of destroy) and our queue is empty,
// and we have a DeviceLostClosure, return the closure to be called by
// our caller. This will complete the steps for both destroy and for
// "lose the device".
let mut device_lost_invocations = SmallVec::new();
if !self.valid && life_tracker.queue_empty() && life_tracker.device_lost_closure.is_some() {
device_lost_invocations.push(DeviceLostInvocation {
closure: life_tracker.device_lost_closure.take().unwrap(),
reason: DeviceLostReason::Destroyed,
message: String::new(),
});
}
let closures = UserClosures {
mappings: mapping_closures,
submissions: submission_closures,
device_lost_invocations,
};
Ok((closures, life_tracker.queue_empty()))
}
@@ -3304,17 +3319,23 @@ impl<A: HalApi> Device<A> {
})
}
pub(crate) fn lose(&mut self, _reason: Option<&str>) {
pub(crate) fn lose<'this, 'token: 'this>(
&'this mut self,
token: &mut Token<'token, Self>,
message: &str,
) {
// Follow the steps at https://gpuweb.github.io/gpuweb/#lose-the-device.
// Mark the device explicitly as invalid. This is checked in various
// places to prevent new work from being submitted.
self.valid = false;
// The following steps remain in "lose the device":
// 1) Resolve the GPUDevice device.lost promise.
// TODO: triggger this passively or actively, and supply the reason.
let mut life_tracker = self.lock_life(token);
if life_tracker.device_lost_closure.is_some() {
let device_lost_closure = life_tracker.device_lost_closure.take().unwrap();
device_lost_closure.call(DeviceLostReason::Unknown, message.to_string());
}
// 2) Complete any outstanding mapAsync() steps.
// 3) Complete any outstanding onSubmittedWorkDone() steps.
+12
View File
@@ -6707,3 +6707,15 @@ mod send_sync {
)))]
impl<T> WasmNotSync for T {}
}
/// Reason for "lose the device".
///
/// Corresponds to [WebGPU `GPUDeviceLostReason`](https://gpuweb.github.io/gpuweb/#enumdef-gpudevicelostreason).
#[repr(u8)]
#[derive(Debug, Copy, Clone)]
pub enum DeviceLostReason {
/// Triggered by driver
Unknown = 0,
/// After Device::destroy
Destroyed = 1,
}
+20 -3
View File
@@ -22,6 +22,7 @@ use std::{
sync::Arc,
};
use wgc::command::{bundle_ffi::*, compute_ffi::*, render_ffi::*};
use wgc::device::DeviceLostClosure;
use wgc::id::TypedId;
use wgt::{WasmNotSend, WasmNotSync};
@@ -1455,14 +1456,30 @@ impl crate::Context for Context {
wgc::gfx_select!(device => global.device_drop(*device));
}
fn device_set_device_lost_callback(
&self,
device: &Self::DeviceId,
_device_data: &Self::DeviceData,
device_lost_callback: crate::context::DeviceLostCallback,
) {
let global = &self.0;
let device_lost_closure = DeviceLostClosure::from_rust(device_lost_callback);
wgc::gfx_select!(device => global.device_set_device_lost_closure(*device, device_lost_closure));
}
fn device_destroy(&self, device: &Self::DeviceId, _device_data: &Self::DeviceData) {
let global = &self.0;
wgc::gfx_select!(device => global.device_destroy(*device));
}
fn device_lose(&self, device: &Self::DeviceId, _device_data: &Self::DeviceData) {
// TODO: accept a reason, and pass it to device_lose.
fn device_mark_lost(
&self,
device: &Self::DeviceId,
_device_data: &Self::DeviceData,
message: &str,
) {
// We do not provide a reason to device_lose, because all reasons other than
// destroyed (which this is not) are "unknown".
let global = &self.0;
wgc::gfx_select!(device => global.device_lose(*device, None));
wgc::gfx_select!(device => global.device_mark_lost(*device, message));
}
fn device_poll(
&self,
+15 -1
View File
@@ -1937,12 +1937,26 @@ impl crate::context::Context for Context {
device_data.0.destroy();
}
fn device_lose(&self, _device: &Self::DeviceId, _device_data: &Self::DeviceData) {
fn device_mark_lost(
&self,
_device: &Self::DeviceId,
_device_data: &Self::DeviceData,
_message: &str,
) {
// TODO: figure out the GPUDevice implementation of this, including resolving
// the device.lost promise, which will require a different invocation pattern
// with a callback.
}
fn device_set_device_lost_callback(
&self,
_device: &Self::DeviceId,
_device_data: &Self::DeviceData,
_device_lost_callback: crate::context::DeviceLostCallback,
) {
unimplemented!();
}
fn device_poll(
&self,
_device: &Self::DeviceId,
+49 -5
View File
@@ -2,7 +2,7 @@ use std::{any::Any, fmt::Debug, future::Future, num::NonZeroU64, ops::Range, pin
use wgt::{
strict_assert, strict_assert_eq, AdapterInfo, BufferAddress, BufferSize, Color,
DownlevelCapabilities, DynamicOffset, Extent3d, Features, ImageDataLayout,
DeviceLostReason, DownlevelCapabilities, DynamicOffset, Extent3d, Features, ImageDataLayout,
ImageSubresourceRange, IndexFormat, Limits, ShaderStages, SurfaceStatus, TextureFormat,
TextureFormatFeatures, WasmNotSend, WasmNotSync,
};
@@ -269,8 +269,19 @@ pub trait Context: Debug + WasmNotSend + WasmNotSync + Sized {
desc: &RenderBundleEncoderDescriptor,
) -> (Self::RenderBundleEncoderId, Self::RenderBundleEncoderData);
fn device_drop(&self, device: &Self::DeviceId, device_data: &Self::DeviceData);
fn device_set_device_lost_callback(
&self,
device: &Self::DeviceId,
device_data: &Self::DeviceData,
device_lost_callback: DeviceLostCallback,
);
fn device_destroy(&self, device: &Self::DeviceId, device_data: &Self::DeviceData);
fn device_lose(&self, device: &Self::DeviceId, device_data: &Self::DeviceData);
fn device_mark_lost(
&self,
device: &Self::DeviceId,
device_data: &Self::DeviceData,
message: &str,
);
fn device_poll(
&self,
device: &Self::DeviceId,
@@ -1199,6 +1210,22 @@ pub type SubmittedWorkDoneCallback = Box<dyn FnOnce() + Send + 'static>;
)
)))]
pub type SubmittedWorkDoneCallback = Box<dyn FnOnce() + 'static>;
#[cfg(any(
not(target_arch = "wasm32"),
all(
feature = "fragile-send-sync-non-atomic-wasm",
not(target_feature = "atomics")
)
))]
pub type DeviceLostCallback = Box<dyn FnOnce(DeviceLostReason, String) + Send + 'static>;
#[cfg(not(any(
not(target_arch = "wasm32"),
all(
feature = "fragile-send-sync-non-atomic-wasm",
not(target_feature = "atomics")
)
)))]
pub type DeviceLostCallback = Box<dyn FnOnce(DeviceLostReason, String) + 'static>;
/// An object safe variant of [`Context`] implemented by all types that implement [`Context`].
pub(crate) trait DynContext: Debug + WasmNotSend + WasmNotSync {
@@ -1365,8 +1392,14 @@ pub(crate) trait DynContext: Debug + WasmNotSend + WasmNotSync {
desc: &RenderBundleEncoderDescriptor,
) -> (ObjectId, Box<crate::Data>);
fn device_drop(&self, device: &ObjectId, device_data: &crate::Data);
fn device_set_device_lost_callback(
&self,
device: &ObjectId,
device_data: &crate::Data,
device_lost_callback: DeviceLostCallback,
);
fn device_destroy(&self, device: &ObjectId, device_data: &crate::Data);
fn device_lose(&self, device: &ObjectId, device_data: &crate::Data);
fn device_mark_lost(&self, device: &ObjectId, device_data: &crate::Data, message: &str);
fn device_poll(&self, device: &ObjectId, device_data: &crate::Data, maintain: Maintain)
-> bool;
fn device_on_uncaptured_error(
@@ -2428,16 +2461,27 @@ where
Context::device_drop(self, &device, device_data)
}
fn device_set_device_lost_callback(
&self,
device: &ObjectId,
device_data: &crate::Data,
device_lost_callback: DeviceLostCallback,
) {
let device = <T::DeviceId>::from(*device);
let device_data = downcast_ref(device_data);
Context::device_set_device_lost_callback(self, &device, device_data, device_lost_callback)
}
fn device_destroy(&self, device: &ObjectId, device_data: &crate::Data) {
let device = <T::DeviceId>::from(*device);
let device_data = downcast_ref(device_data);
Context::device_destroy(self, &device, device_data)
}
fn device_lose(&self, device: &ObjectId, device_data: &crate::Data) {
fn device_mark_lost(&self, device: &ObjectId, device_data: &crate::Data, message: &str) {
let device = <T::DeviceId>::from(*device);
let device_data = downcast_ref(device_data);
Context::device_lose(self, &device, device_data)
Context::device_mark_lost(self, &device, device_data, message)
}
fn device_poll(
+26 -13
View File
@@ -32,19 +32,19 @@ pub use wgt::{
BindingType, BlendComponent, BlendFactor, BlendOperation, BlendState, BufferAddress,
BufferBindingType, BufferSize, BufferUsages, Color, ColorTargetState, ColorWrites,
CommandBufferDescriptor, CompareFunction, CompositeAlphaMode, DepthBiasState,
DepthStencilState, DeviceType, DownlevelCapabilities, DownlevelFlags, Dx12Compiler,
DynamicOffset, Extent3d, Face, Features, FilterMode, FrontFace, Gles3MinorVersion,
ImageDataLayout, ImageSubresourceRange, IndexFormat, InstanceDescriptor, InstanceFlags, Limits,
MultisampleState, Origin2d, Origin3d, PipelineStatisticsTypes, PolygonMode, PowerPreference,
PredefinedColorSpace, PresentMode, PresentationTimestamp, PrimitiveState, PrimitiveTopology,
PushConstantRange, QueryType, RenderBundleDepthStencil, SamplerBindingType, SamplerBorderColor,
ShaderLocation, ShaderModel, ShaderStages, StencilFaceState, StencilOperation, StencilState,
StorageTextureAccess, SurfaceCapabilities, SurfaceStatus, TextureAspect, TextureDimension,
TextureFormat, TextureFormatFeatureFlags, TextureFormatFeatures, TextureSampleType,
TextureUsages, TextureViewDimension, VertexAttribute, VertexFormat, VertexStepMode,
WasmNotSend, WasmNotSync, COPY_BUFFER_ALIGNMENT, COPY_BYTES_PER_ROW_ALIGNMENT, MAP_ALIGNMENT,
PUSH_CONSTANT_ALIGNMENT, QUERY_RESOLVE_BUFFER_ALIGNMENT, QUERY_SET_MAX_QUERIES, QUERY_SIZE,
VERTEX_STRIDE_ALIGNMENT,
DepthStencilState, DeviceLostReason, DeviceType, DownlevelCapabilities, DownlevelFlags,
Dx12Compiler, DynamicOffset, Extent3d, Face, Features, FilterMode, FrontFace,
Gles3MinorVersion, ImageDataLayout, ImageSubresourceRange, IndexFormat, InstanceDescriptor,
InstanceFlags, Limits, MultisampleState, Origin2d, Origin3d, PipelineStatisticsTypes,
PolygonMode, PowerPreference, PredefinedColorSpace, PresentMode, PresentationTimestamp,
PrimitiveState, PrimitiveTopology, PushConstantRange, QueryType, RenderBundleDepthStencil,
SamplerBindingType, SamplerBorderColor, ShaderLocation, ShaderModel, ShaderStages,
StencilFaceState, StencilOperation, StencilState, StorageTextureAccess, SurfaceCapabilities,
SurfaceStatus, TextureAspect, TextureDimension, TextureFormat, TextureFormatFeatureFlags,
TextureFormatFeatures, TextureSampleType, TextureUsages, TextureViewDimension, VertexAttribute,
VertexFormat, VertexStepMode, WasmNotSend, WasmNotSync, COPY_BUFFER_ALIGNMENT,
COPY_BYTES_PER_ROW_ALIGNMENT, MAP_ALIGNMENT, PUSH_CONSTANT_ALIGNMENT,
QUERY_RESOLVE_BUFFER_ALIGNMENT, QUERY_SET_MAX_QUERIES, QUERY_SIZE, VERTEX_STRIDE_ALIGNMENT,
};
#[cfg(any(
@@ -2811,6 +2811,19 @@ impl Device {
pub fn destroy(&self) {
DynContext::device_destroy(&*self.context, &self.id, self.data.as_ref())
}
/// Set a DeviceLostCallback on this device.
pub fn set_device_lost_callback(
&self,
callback: impl FnOnce(DeviceLostReason, String) + Send + 'static,
) {
DynContext::device_set_device_lost_callback(
&*self.context,
&self.id,
self.data.as_ref(),
Box::new(callback),
)
}
}
impl Drop for Device {