archive-gh-me/wgpu
1
0
Fork 0
mirror of https://github.com/gfx-rs/wgpu.git synced 2025-12-08 21:26:17 +00:00
Code Issues Projects Releases Wiki Activity

Early tracing of swapchain-related things, clean up the hub API

Browse Source
This commit is contained in:
Dzmitry Malyshau 2021-03-03 19:59:29 -05:00
parent fb1b98ebb1
commit 10245cece9
6 changed files with 39 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
player/src/lib.rs
View File

@ -196,13 +196,11 @@ impl GlobalPlay for wgc::hub::Global<IdentityPassThroughFactory> {
self.sampler_drop::<B>(id);
}
A::GetSwapChainTexture { id, parent_id } => {
if let Some(id) = id {
self.device_maintain_ids::<B>(device).unwrap();
self.swap_chain_get_current_texture_view::<B>(parent_id, id)
.unwrap()
.view_id
.unwrap();
}
self.device_maintain_ids::<B>(device).unwrap();
self.swap_chain_get_current_texture_view::<B>(parent_id, id)
.unwrap()
.view_id
.unwrap();
}
A::CreateBindGroupLayout(id, desc) => {
let (_, error) = self.device_create_bind_group_layout::<B>(device, &desc, id);

6
wgpu-core/src/device/mod.rs
View File

@ -4022,7 +4022,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let id = hub
.bind_group_layouts
.register_error(id_in, "<derived>", &mut token);
.prepare(id_in)
.assign_error("<derived>", &mut token);
(id, Some(error))
}
@ -4149,7 +4150,8 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let id = hub
.bind_group_layouts
.register_error(id_in, "<derived>", &mut token);
.prepare(id_in)
.assign_error("<derived>", &mut token);
(id, Some(error))
}

2
wgpu-core/src/device/trace.rs
View File

@ -50,7 +50,7 @@ pub enum Action<'a> {
DestroySampler(id::SamplerId),
CreateSwapChain(id::SwapChainId, wgt::SwapChainDescriptor),
GetSwapChainTexture {
id: Option<id::TextureViewId>,
id: id::TextureViewId,
parent_id: id::SwapChainId,
},
PresentSwapChain(id::SwapChainId),

24
wgpu-core/src/hub.rs
View File

@ -491,26 +491,6 @@ impl<T: Resource, I: TypedId + Copy, F: IdentityHandlerFactory<I>> Registry<T, I
(self.data.write(), Token::new())
}
//TODO: consider remove this once everything uses `prepare`
pub(crate) fn register_identity<A: Access<T>>(
&self,
id_in: <F::Filter as IdentityHandler<I>>::Input,
value: T,
token: &mut Token<A>,
) -> Valid<I> {
self.prepare(id_in).assign(value, token)
}
//TODO: consider remove this once everything uses `prepare`
pub(crate) fn register_error<A: Access<T>>(
&self,
id_in: <F::Filter as IdentityHandler<I>>::Input,
label: &str,
token: &mut Token<A>,
) -> I {
self.prepare(id_in).assign_error(label, token)
}
pub fn unregister_locked(&self, id: I, guard: &mut Storage<T, I>) -> Option<T> {
let value = guard.remove(id);
//Note: careful about the order here!
@ -531,10 +511,6 @@ impl<T: Resource, I: TypedId + Copy, F: IdentityHandlerFactory<I>> Registry<T, I
(value, Token::new())
}
pub fn free_id(&self, id: I) {
self.identity.free(id)
}
pub fn label_for_resource(&self, id: I) -> String {
let guard = self.data.read();

44
wgpu-core/src/instance.rs
View File

@ -627,7 +627,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
};
let mut token = Token::root();
let id = self.surfaces.register_identity(id_in, surface, &mut token);
let id = self.surfaces.prepare(id_in).assign(surface, &mut token);
id.0
}
@ -649,7 +649,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
};
let mut token = Token::root();
let id = self.surfaces.register_identity(id_in, surface, &mut token);
let id = self.surfaces.prepare(id_in).assign(surface, &mut token);
id.0
}
@ -675,11 +675,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
for raw in inst.enumerate_adapters() {
let adapter = Adapter::new(raw);
tracing::info!("Adapter {} {:?}", backend_info, adapter.raw.info);
let id = hub.adapters.register_identity(
id_backend.clone(),
adapter,
&mut token,
);
let id = hub.adapters
.prepare(id_backend.clone())
.assign(adapter, &mut token);
adapters.push(id.0);
}
}
@ -825,11 +823,9 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
if selected < adapters_backend.len() {
let adapter = Adapter::new(adapters_backend.swap_remove(selected));
tracing::info!("Adapter {} {:?}", info_adapter, adapter.raw.info);
let id = backend_hub(self).adapters.register_identity(
id_backend.take().unwrap(),
adapter,
&mut token,
);
let id = backend_hub(self).adapters
.prepare(id_backend.take().unwrap())
.assign(adapter, &mut token);
return Ok(id.0);
}
selected -= adapters_backend.len();
@ -927,16 +923,13 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let mut token = Token::root();
let (mut adapter_guard, _) = hub.adapters.write(&mut token);
match adapter_guard.get_mut(adapter_id) {
Ok(adapter) => {
if adapter.life_guard.ref_count.take().unwrap().load() == 1 {
hub.adapters
.unregister_locked(adapter_id, &mut *adapter_guard);
}
}
Err(_) => {
hub.adapters.free_id(adapter_id);
}
let free = match adapter_guard.get_mut(adapter_id) {
Ok(adapter) => adapter.life_guard.ref_count.take().unwrap().load() == 1,
Err(_) => true,
};
if free {
hub.adapters
.unregister_locked(adapter_id, &mut *adapter_guard);
}
}
}
@ -953,6 +946,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let hub = B::hub(self);
let mut token = Token::root();
let fid = hub.devices.prepare(id_in);
let error = loop {
let (adapter_guard, mut token) = hub.adapters.read(&mut token);
@ -964,13 +958,11 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
Ok(device) => device,
Err(e) => break e,
};
let id = hub.devices.register_identity(id_in, device, &mut token);
let id = fid.assign(device, &mut token);
return (id.0, None);
};
let id = hub
.devices
.register_error(id_in, desc.label.borrow_or_default(), &mut token);
let id = fid.assign_error(desc.label.borrow_or_default(), &mut token);
(id, Some(error))
}
}

23
wgpu-core/src/swap_chain.rs
View File

@ -143,6 +143,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let hub = B::hub(self);
let mut token = Token::root();
let fid = hub.texture_views.prepare(view_id_in);
let (mut surface_guard, mut token) = self.surfaces.write(&mut token);
let surface = surface_guard
@ -153,8 +154,16 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
let sc = swap_chain_guard
.get_mut(swap_chain_id)
.map_err(|_| SwapChainError::Invalid)?;
#[cfg_attr(not(feature = "trace"), allow(unused_variables))]
#[allow(unused_variables)]
let device = &device_guard[sc.device_id.value];
#[cfg(feature = "trace")]
if let Some(ref trace) = device.trace {
trace.lock().add(Action::GetSwapChainTexture {
id: fid.id(),
parent_id: swap_chain_id,
});
}
let suf = B::get_surface_mut(surface);
let (image, status) = match unsafe { suf.acquire_image(FRAME_TIMEOUT_MS * 1_000_000) } {
@ -206,9 +215,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
};
let ref_count = view.life_guard.add_ref();
let id = hub
.texture_views
.register_identity(view_id_in, view, &mut token);
let id = fid.assign(view, &mut token);
if sc.acquired_view_id.is_some() {
return Err(SwapChainError::AlreadyAcquired);
@ -224,14 +231,6 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
None => None,
};
#[cfg(feature = "trace")]
if let Some(ref trace) = device.trace {
trace.lock().add(Action::GetSwapChainTexture {
id: view_id,
parent_id: swap_chain_id,
});
}
Ok(SwapChainOutput { status, view_id })
}