kossLAN/wry
1
0
Fork 0
forked from wry/wry
Code Pull requests Activity

all: use run-on-drop crate

Browse source
This commit is contained in:
Julian Orth 2026-02-13 11:09:07 +01:00
parent 346c6a7345
commit 0932ad11b5
19 changed files with 60 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/gfx_apis/vulkan/blend_buffer.rs
View file

@ -7,13 +7,13 @@ use {
image::{QueueFamily, QueueState, VulkanImage, VulkanImageMemory},
renderer::VulkanRenderer,
},
utils::on_drop::OnDrop,
},
ash::vk::{
Extent3D, ImageAspectFlags, ImageCreateInfo, ImageLayout, ImageSubresourceRange,
ImageTiling, ImageType, ImageViewCreateInfo, ImageViewType, SampleCountFlags, SharingMode,
},
gpu_alloc::UsageFlags,
run_on_drop::on_drop,
std::{cell::Cell, collections::hash_map::Entry, rc::Rc},
};
@ -60,7 +60,7 @@ impl VulkanRenderer {
.usage(usage);
let image = unsafe { self.device.device.create_image(&create_info, None) };
let image = image.map_err(VulkanError::CreateImage)?;
let destroy_image = OnDrop(|| unsafe { self.device.device.destroy_image(image, None) });
let destroy_image = on_drop(|| unsafe { self.device.device.destroy_image(image, None) });
let memory_requirements =
unsafe { self.device.device.get_image_memory_requirements(image) };
let allocation =

11
src/gfx_apis/vulkan/bo_allocator.rs
View file

@ -10,7 +10,7 @@ use {
device::VulkanDevice, format::VulkanFormat, renderer::image_barrier,
staging::VulkanStagingBuffer,
},
utils::{errorfmt::ErrorFmt, on_drop::OnDrop},
utils::errorfmt::ErrorFmt,
video::{
Modifier,
dmabuf::{DmaBuf, DmaBufIds, DmaBufPlane, PlaneVec},
@ -33,6 +33,7 @@ use {
PipelineStageFlags2, QUEUE_FAMILY_FOREIGN_EXT, SampleCountFlags, SharingMode, SubmitInfo2,
SubresourceLayout,
},
run_on_drop::on_drop,
std::{rc::Rc, slice},
uapi::OwnedFd,
};
@ -140,7 +141,7 @@ impl VulkanBoAllocator {
let res = unsafe { data.device.device.create_image(&create_info, None) };
res.map_err(VulkanError::CreateImage)?
};
let destroy_image = OnDrop(|| unsafe { data.device.device.destroy_image(image, None) });
let destroy_image = on_drop(|| unsafe { data.device.device.destroy_image(image, None) });
let modifier = {
let mut props = ImageDrmFormatModifierPropertiesEXT::default();
unsafe {
@ -187,7 +188,7 @@ impl VulkanBoAllocator {
};
memory.map_err(VulkanError::AllocateMemory)?
};
let destroy_memory = OnDrop(|| unsafe { data.device.device.free_memory(memory, None) });
let destroy_memory = on_drop(|| unsafe { data.device.device.free_memory(memory, None) });
unsafe {
data.device
.device
@ -326,7 +327,7 @@ impl VulkanBoAllocator {
let res = unsafe { data.device.device.create_image(&create_info, None) };
res.map_err(VulkanError::CreateImage)?
};
let destroy_image = OnDrop(|| unsafe { data.device.device.destroy_image(image, None) });
let destroy_image = on_drop(|| unsafe { data.device.device.destroy_image(image, None) });
let num_device_memories = match disjoint {
true => dmabuf.planes.len(),
false => 1,
@ -397,7 +398,7 @@ impl VulkanBoAllocator {
let device_memory = device_memory.map_err(VulkanError::AllocateMemory)?;
fd.unwrap();
device_memories.push(device_memory);
free_device_memories.push(OnDrop(move || unsafe {
free_device_memories.push(on_drop(move || unsafe {
data.device.device.free_memory(device_memory, None)
}));
}

14
src/gfx_apis/vulkan/buffer_cache.rs
View file

@ -1,17 +1,15 @@
use {
crate::{
gfx_apis::vulkan::{
VulkanError,
allocator::{VulkanAllocation, VulkanAllocator},
device::VulkanDevice,
},
utils::on_drop::OnDrop,
crate::gfx_apis::vulkan::{
VulkanError,
allocator::{VulkanAllocation, VulkanAllocator},
device::VulkanDevice,
},
ash::vk::{
Buffer, BufferCreateInfo, BufferDeviceAddressInfo, BufferUsageFlags, DeviceAddress,
DeviceSize,
},
gpu_alloc::UsageFlags,
run_on_drop::on_drop,
std::{cell::RefCell, mem::ManuallyDrop, ops::Deref, rc::Rc},
uapi::Packed,
};
@ -119,7 +117,7 @@ impl VulkanBufferCache {
.map_err(VulkanError::CreateBuffer)?
}
};
let destroy_buffer = OnDrop(|| unsafe { self.device.device.destroy_buffer(buffer, None) });
let destroy_buffer = on_drop(|| unsafe { self.device.device.destroy_buffer(buffer, None) });
let mut memory_requirements =
unsafe { self.device.device.get_buffer_memory_requirements(buffer) };
memory_requirements.alignment = memory_requirements.alignment.max(self.min_alignment);

5
src/gfx_apis/vulkan/device.rs
View file

@ -10,7 +10,7 @@ use {
map_extension_properties,
},
},
utils::{bitflags::BitflagsExt, on_drop::OnDrop},
utils::bitflags::BitflagsExt,
video::{
dmabuf::DmaBufIds,
drm::{Drm, sync_obj::SyncObjCtx},
@ -45,6 +45,7 @@ use {
},
},
isnt::std_1::collections::IsntHashMapExt,
run_on_drop::on_drop,
std::{
cell::Cell,
ffi::{CStr, CString},
@ -447,7 +448,7 @@ impl VulkanInstance {
Ok(d) => d,
Err(e) => return Err(VulkanError::CreateDevice(e)),
};
let destroy_device = OnDrop(|| unsafe { device.destroy_device(None) });
let destroy_device = on_drop(|| unsafe { device.destroy_device(None) });
let blend_limits = self.load_blend_format_limits(phy_dev)?;
let formats = self.load_formats(phy_dev)?;
let supports_xrgb8888 = formats

6
src/gfx_apis/vulkan/dmabuf_buffer.rs
View file

@ -3,7 +3,6 @@ use {
format::Format,
gfx_api::GfxBuffer,
gfx_apis::vulkan::{VulkanError, device::VulkanDevice},
utils::on_drop::OnDrop,
},
ash::{
Device,
@ -13,6 +12,7 @@ use {
MemoryDedicatedAllocateInfo, MemoryFdPropertiesKHR, MemoryPropertyFlags,
},
},
run_on_drop::on_drop,
std::{any::Any, rc::Rc},
uapi::OwnedFd,
};
@ -61,7 +61,7 @@ impl VulkanDevice {
.map_err(VulkanError::CreateBuffer)?
}
};
let destroy_buffer = OnDrop(|| unsafe { self.device.destroy_buffer(buffer, None) });
let destroy_buffer = on_drop(|| unsafe { self.device.destroy_buffer(buffer, None) });
let requirements = unsafe { self.device.get_buffer_memory_requirements(buffer) };
let memory_type = self.find_memory_type(
MemoryPropertyFlags::HOST_VISIBLE,
@ -89,7 +89,7 @@ impl VulkanDevice {
}
};
fd.unwrap();
let free_memory = OnDrop(|| unsafe { self.device.free_memory(memory, None) });
let free_memory = on_drop(|| unsafe { self.device.free_memory(memory, None) });
unsafe {
self.device
.bind_buffer_memory(buffer, memory, 0)

10
src/gfx_apis/vulkan/image.rs
View file

@ -15,7 +15,6 @@ use {
},
rect::Region,
theme::Color,
utils::on_drop::OnDrop,
video::dmabuf::{DmaBuf, PlaneVec},
},
ash::vk::{
@ -31,6 +30,7 @@ use {
SubresourceLayout,
},
gpu_alloc::UsageFlags,
run_on_drop::on_drop,
std::{
cell::Cell,
fmt::{Debug, Formatter},
@ -349,7 +349,7 @@ impl VulkanDmaBufImageTemplate {
let image = unsafe { device.device.create_image(&create_info, None) };
image.map_err(VulkanError::CreateImage)?
};
let destroy_image = OnDrop(|| unsafe { device.device.destroy_image(image, None) });
let destroy_image = on_drop(|| unsafe { device.device.destroy_image(image, None) });
let num_device_memories = match self.disjoint {
true => self.dmabuf.planes.len(),
false => 1,
@ -419,7 +419,7 @@ impl VulkanDmaBufImageTemplate {
let device_memory = device_memory.map_err(VulkanError::AllocateMemory)?;
fd.unwrap();
device_memories.push(device_memory);
free_device_memories.push(OnDrop(move || unsafe {
free_device_memories.push(on_drop(move || unsafe {
device.device.free_memory(device_memory, None)
}));
}
@ -440,7 +440,7 @@ impl VulkanDmaBufImageTemplate {
if for_rendering && self.render_needs_bridge {
let (bridge_image, allocation) = self.create_bridge()?;
primary_image = bridge_image;
destroy_bridge_image = Some(OnDrop(|| unsafe {
destroy_bridge_image = Some(on_drop(|| unsafe {
device.device.destroy_image(primary_image, None)
}));
bridge = Some(VulkanFramebufferBridge {
@ -496,7 +496,7 @@ impl VulkanDmaBufImageTemplate {
let image = unsafe { self.renderer.device.device.create_image(&create_info, None) };
let image = image.map_err(VulkanError::CreateImage)?;
let destroy_image =
OnDrop(|| unsafe { self.renderer.device.device.destroy_image(image, None) });
on_drop(|| unsafe { self.renderer.device.device.destroy_image(image, None) });
let memory_requirements = unsafe {
self.renderer
.device

8
src/gfx_apis/vulkan/instance.rs
View file

@ -1,8 +1,5 @@
use {
crate::{
gfx_apis::vulkan::{VULKAN_VALIDATION, VulkanError},
utils::on_drop::OnDrop,
},
crate::gfx_apis::vulkan::{VULKAN_VALIDATION, VulkanError},
ahash::{AHashMap, AHashSet},
ash::{
Entry, Instance, LoadingError,
@ -18,6 +15,7 @@ use {
isnt::std_1::collections::IsntHashMapExt,
log::Level,
once_cell::sync::Lazy,
run_on_drop::on_drop,
std::{
ffi::{CStr, CString, c_void},
fmt::{Display, Formatter},
@ -108,7 +106,7 @@ impl VulkanInstance {
Ok(i) => i,
Err(e) => return Err(VulkanError::CreateInstance(e)),
};
let destroy_instance = OnDrop(|| unsafe { instance.destroy_instance(None) });
let destroy_instance = on_drop(|| unsafe { instance.destroy_instance(None) });
let debug_utils = debug_utils::Instance::new(entry, &instance);
let messenger = unsafe { debug_utils.create_debug_utils_messenger(&debug_info, None) };
let messenger = match messenger {

12
src/gfx_apis/vulkan/pipeline.rs
View file

@ -1,10 +1,7 @@
use {
crate::{
gfx_apis::vulkan::{
VulkanError, descriptor::VulkanDescriptorSetLayout, device::VulkanDevice,
shaders::VulkanShader,
},
utils::on_drop::OnDrop,
crate::gfx_apis::vulkan::{
VulkanError, descriptor::VulkanDescriptorSetLayout, device::VulkanDevice,
shaders::VulkanShader,
},
arrayvec::ArrayVec,
ash::{
@ -21,6 +18,7 @@ use {
SpecializationInfo, SpecializationMapEntry,
},
},
run_on_drop::on_drop,
std::{rc::Rc, slice},
};
@ -77,7 +75,7 @@ impl VulkanDevice {
layout.map_err(VulkanError::CreatePipelineLayout)?
};
let destroy_layout =
OnDrop(|| unsafe { self.device.destroy_pipeline_layout(pipeline_layout, None) });
on_drop(|| unsafe { self.device.destroy_pipeline_layout(pipeline_layout, None) });
let mut frag_spec_data = ArrayVec::<_, { 5 * 4 }>::new();
let mut frag_spec_entries = ArrayVec::<_, 5>::new();
let mut frag_spec_entry = |data: &[u8]| {

5
src/gfx_apis/vulkan/shm_image.rs
View file

@ -14,7 +14,7 @@ use {
transfer::{TransferType, VulkanShmImageAsyncData},
},
rect::Rect,
utils::{errorfmt::ErrorFmt, on_drop::OnDrop},
utils::errorfmt::ErrorFmt,
},
ash::vk::{
AccessFlags2, Buffer, BufferImageCopy2, BufferMemoryBarrier2, CommandBufferBeginInfo,
@ -26,6 +26,7 @@ use {
},
gpu_alloc::UsageFlags,
isnt::std_1::primitive::IsntSliceExt,
run_on_drop::on_drop,
std::{cell::Cell, mem, ptr, rc::Rc, slice},
};
@ -407,7 +408,7 @@ impl VulkanRenderer {
.usage(usage);
let image = unsafe { self.device.device.create_image(&create_info, None) };
let image = image.map_err(VulkanError::CreateImage)?;
let destroy_image = OnDrop(|| unsafe { self.device.device.destroy_image(image, None) });
let destroy_image = on_drop(|| unsafe { self.device.device.destroy_image(image, None) });
let memory_requirements =
unsafe { self.device.device.get_image_memory_requirements(image) };
let allocation =

11
src/gfx_apis/vulkan/staging.rs
View file

@ -8,16 +8,14 @@ use {
device::VulkanDevice,
renderer::VulkanRenderer,
},
utils::{
clonecell::CloneCell,
on_drop::{OnDrop, OnDrop2},
},
utils::clonecell::CloneCell,
},
ash::{
Device,
vk::{Buffer, BufferCreateInfo, BufferUsageFlags},
},
gpu_alloc::UsageFlags,
run_on_drop::on_drop,
std::{any::Any, cell::Cell, rc::Rc},
};
@ -55,7 +53,7 @@ impl VulkanDevice {
) -> Result<VulkanStagingBuffer, VulkanError> {
let (vk_usage, usage) = get_usage(upload, download, transient);
let buffer = self.create_buffer(size, vk_usage)?;
let destroy_buffer = OnDrop(|| unsafe { self.device.destroy_buffer(buffer, None) });
let destroy_buffer = on_drop(|| unsafe { self.device.destroy_buffer(buffer, None) });
let memory_requirements = unsafe { self.device.get_buffer_memory_requirements(buffer) };
let allocation = allocator.alloc(&memory_requirements, usage, true)?;
{
@ -85,8 +83,7 @@ impl VulkanDevice {
let buffer = self.create_buffer(shell.size, vk_usage)?;
let memory_requirements = unsafe { self.device.get_buffer_memory_requirements(buffer) };
let slf = self.clone();
let destroy_buffer =
OnDrop2::new(move || unsafe { slf.device.destroy_buffer(buffer, None) });
let destroy_buffer = on_drop(move || unsafe { slf.device.destroy_buffer(buffer, None) });
let slf = self.clone();
let finish_allocation = move |res| {
let allocation: VulkanAllocation = res?;