From 1166944124255f70c4a15361868952c71f094d9c Mon Sep 17 00:00:00 2001 From: Karol Herbst Date: Sun, 9 Jul 2023 02:36:46 +0200 Subject: [PATCH] rusticl/mesa/screen: convert to ThreadSafeCPtr Signed-off-by: Karol Herbst Part-of: --- .../frontends/rusticl/mesa/pipe/screen.rs | 114 ++++++++++-------- 1 file changed, 67 insertions(+), 47 deletions(-) diff --git a/src/gallium/frontends/rusticl/mesa/pipe/screen.rs b/src/gallium/frontends/rusticl/mesa/pipe/screen.rs index 31b0c5a1e80..f4854b292d3 100644 --- a/src/gallium/frontends/rusticl/mesa/pipe/screen.rs +++ b/src/gallium/frontends/rusticl/mesa/pipe/screen.rs @@ -6,6 +6,7 @@ use crate::util::disk_cache::*; use mesa_rust_gen::*; use mesa_rust_util::has_required_feature; +use mesa_rust_util::ptr::ThreadSafeCPtr; use mesa_rust_util::string::*; use std::convert::TryInto; @@ -20,7 +21,7 @@ use std::sync::Arc; #[derive(PartialEq)] pub struct PipeScreen { ldev: PipeLoaderDevice, - screen: *mut pipe_screen, + screen: ThreadSafeCPtr, } pub const UUID_SIZE: usize = PIPE_UUID_SIZE as usize; @@ -99,14 +100,24 @@ impl PipeScreen { return None; } - Some(Self { ldev, screen }) + Some(Self { + ldev, + // SAFETY: `pipe_screen` is considered a thread-safe type + screen: unsafe { ThreadSafeCPtr::new(screen)? }, + }) + } + + fn screen(&self) -> &pipe_screen { + // SAFETY: We own the pointer, so it's valid for every caller of this function as we are + // responsible of freeing it. + unsafe { self.screen.as_ref() } } pub fn create_context(self: &Arc) -> Option { PipeContext::new( unsafe { - (*self.screen).context_create.unwrap()( - self.screen, + self.screen().context_create.unwrap()( + self.screen.as_ptr(), ptr::null_mut(), PIPE_CONTEXT_COMPUTE_ONLY | PIPE_CONTEXT_NO_LOD_BIAS, ) @@ -117,7 +128,7 @@ impl PipeScreen { fn resource_create(&self, tmpl: &pipe_resource) -> Option { PipeResource::new( - unsafe { (*self.screen).resource_create.unwrap()(self.screen, tmpl) }, + unsafe { self.screen().resource_create.unwrap()(self.screen.as_ptr(), tmpl) }, false, ) } @@ -127,13 +138,10 @@ impl PipeScreen { tmpl: &pipe_resource, mem: *mut c_void, ) -> Option { - unsafe { - if let Some(func) = (*self.screen).resource_from_user_memory { - PipeResource::new(func(self.screen, tmpl, mem), true) - } else { - None - } - } + PipeResource::new( + unsafe { self.screen().resource_from_user_memory?(self.screen.as_ptr(), tmpl, mem) }, + true, + ) } pub fn resource_create_buffer( @@ -263,24 +271,29 @@ impl PipeScreen { unsafe { PipeResource::new( - (*self.screen).resource_from_handle.unwrap()(self.screen, &tmpl, &mut handle, 0), + self.screen().resource_from_handle.unwrap()( + self.screen.as_ptr(), + &tmpl, + &mut handle, + 0, + ), false, ) } } pub fn param(&self, cap: pipe_cap) -> i32 { - unsafe { (*self.screen).get_param.unwrap()(self.screen, cap) } + unsafe { self.screen().get_param.unwrap()(self.screen.as_ptr(), cap) } } pub fn shader_param(&self, t: pipe_shader_type, cap: pipe_shader_cap) -> i32 { - unsafe { (*self.screen).get_shader_param.unwrap()(self.screen, t, cap) } + unsafe { self.screen().get_shader_param.unwrap()(self.screen.as_ptr(), t, cap) } } fn compute_param_wrapped(&self, cap: pipe_compute_cap, ptr: *mut c_void) -> i32 { unsafe { - (*self.screen).get_compute_param.unwrap()( - self.screen, + self.screen().get_compute_param.unwrap()( + self.screen.as_ptr(), pipe_shader_ir::PIPE_SHADER_IR_NIR, cap, ptr, @@ -293,18 +306,18 @@ impl PipeScreen { } pub fn name(&self) -> String { - unsafe { c_string_to_string((*self.screen).get_name.unwrap()(self.screen)) } + unsafe { c_string_to_string(self.screen().get_name.unwrap()(self.screen.as_ptr())) } } pub fn device_node_mask(&self) -> Option { - unsafe { Some((*self.screen).get_device_node_mask?(self.screen)) } + unsafe { Some(self.screen().get_device_node_mask?(self.screen.as_ptr())) } } pub fn device_uuid(&self) -> Option<[c_uchar; UUID_SIZE]> { let mut uuid = [0; UUID_SIZE]; let ptr = uuid.as_mut_ptr(); unsafe { - (*self.screen).get_device_uuid?(self.screen, ptr.cast()); + self.screen().get_device_uuid?(self.screen.as_ptr(), ptr.cast()); } Some(uuid) @@ -313,13 +326,17 @@ impl PipeScreen { pub fn device_luid(&self) -> Option<[c_uchar; LUID_SIZE]> { let mut luid = [0; LUID_SIZE]; let ptr = luid.as_mut_ptr(); - unsafe { (*self.screen).get_device_luid?(self.screen, ptr.cast()) } + unsafe { self.screen().get_device_luid?(self.screen.as_ptr(), ptr.cast()) } Some(luid) } pub fn device_vendor(&self) -> String { - unsafe { c_string_to_string((*self.screen).get_device_vendor.unwrap()(self.screen)) } + unsafe { + c_string_to_string(self.screen().get_device_vendor.unwrap()( + self.screen.as_ptr(), + )) + } } pub fn device_type(&self) -> pipe_loader_device_type { @@ -330,7 +347,7 @@ impl PipeScreen { let mut uuid = [0; UUID_SIZE]; let ptr = uuid.as_mut_ptr(); unsafe { - (*self.screen).get_driver_uuid?(self.screen, ptr.cast()); + self.screen().get_driver_uuid?(self.screen.as_ptr(), ptr.cast()); } Some(uuid) @@ -338,10 +355,11 @@ impl PipeScreen { pub fn cl_cts_version(&self) -> &CStr { unsafe { - let ptr = (*self.screen) + let ptr = self + .screen() .get_cl_cts_version .map_or(ptr::null(), |get_cl_cts_version| { - get_cl_cts_version(self.screen) + get_cl_cts_version(self.screen.as_ptr()) }); if ptr.is_null() { // this string is good enough to pass the CTS @@ -359,24 +377,28 @@ impl PipeScreen { bindings: u32, ) -> bool { unsafe { - (*self.screen).is_format_supported.unwrap()(self.screen, format, target, 0, 0, bindings) + self.screen().is_format_supported.unwrap()( + self.screen.as_ptr(), + format, + target, + 0, + 0, + bindings, + ) } } pub fn get_timestamp(&self) -> u64 { // We have get_timestamp in has_required_cbs, so it will exist unsafe { - (*self.screen) + self.screen() .get_timestamp - .expect("get_timestamp should be required")(self.screen) + .expect("get_timestamp should be required")(self.screen.as_ptr()) } } pub fn is_res_handle_supported(&self) -> bool { - unsafe { - (*self.screen).resource_from_handle.is_some() - && (*self.screen).resource_get_handle.is_some() - } + self.screen().resource_from_handle.is_some() && self.screen().resource_get_handle.is_some() } pub fn nir_shader_compiler_options( @@ -384,8 +406,8 @@ impl PipeScreen { shader: pipe_shader_type, ) -> *const nir_shader_compiler_options { unsafe { - (*self.screen).get_compiler_options.unwrap()( - self.screen, + self.screen().get_compiler_options.unwrap()( + self.screen.as_ptr(), pipe_shader_ir::PIPE_SHADER_IR_NIR, shader, ) @@ -394,33 +416,33 @@ impl PipeScreen { } pub fn shader_cache(&self) -> Option { - let ptr = if let Some(func) = unsafe { *self.screen }.get_disk_shader_cache { - unsafe { func(self.screen) } - } else { - ptr::null_mut() - }; + let ptr = unsafe { self.screen().get_disk_shader_cache?(self.screen.as_ptr()) }; DiskCacheBorrowed::from_ptr(ptr) } pub fn finalize_nir(&self, nir: &NirShader) { - if let Some(func) = unsafe { *self.screen }.finalize_nir { + if let Some(func) = self.screen().finalize_nir { unsafe { - func(self.screen, nir.get_nir().cast()); + func(self.screen.as_ptr(), nir.get_nir().cast()); } } } pub(super) fn unref_fence(&self, mut fence: *mut pipe_fence_handle) { unsafe { - (*self.screen).fence_reference.unwrap()(self.screen, &mut fence, ptr::null_mut()); + self.screen().fence_reference.unwrap()( + self.screen.as_ptr(), + &mut fence, + ptr::null_mut(), + ); } } pub(super) fn fence_finish(&self, fence: *mut pipe_fence_handle) { unsafe { - (*self.screen).fence_finish.unwrap()( - self.screen, + self.screen().fence_finish.unwrap()( + self.screen.as_ptr(), ptr::null_mut(), fence, OS_TIMEOUT_INFINITE as u64, @@ -431,9 +453,7 @@ impl PipeScreen { impl Drop for PipeScreen { fn drop(&mut self) { - unsafe { - (*self.screen).destroy.unwrap()(self.screen); - } + unsafe { self.screen().destroy.unwrap()(self.screen.as_ptr()) } } }