Crash after destroying a couple of SwapchainKHR instances :/ #862

hcabel · 2024-01-22T14:32:50Z

hcabel
Jan 22, 2024

Hey I'm pretty new to ash and while I was trying to create multiple swapchain to support multiple window I realize that sometime I get a STATUS_ACCESS_VIOLATION or a HEAP_CORRUPTION... crash when calling the destroy_swapchain function of the swapchain loader :/
So I though it might be because I create a swapchain loader per swapchain instance, but even after moving the loader to my vulkan_context structure the crash is still occurring.
here is some code:

pub(super)
struct Swapchain
{
	vulkan_context: Weak<VulkanContext>,
	raw: vk::SwapchainKHR,
	frames: Vec<Frame>,
}

impl Swapchain
{
	pub(super)
	fn new(vulkan_context: &Rc<VulkanContext>, sizes: &[f32; 2]) -> Self
	{
		win_render_log!(Verbose, "Creating swapchain...");

		let surface_format = choose_surface_format(
			vulkan_context,
			vk::Format::B8G8R8A8_SRGB,
			vk::ColorSpaceKHR::SRGB_NONLINEAR,
		);
		let present_mode = choose_present_mode(
			vulkan_context,
			vk::PresentModeKHR::MAILBOX,
		);
		let extent = choose_extent(
			vulkan_context,
			sizes
		);
		let image_count = choose_image_count(
			vulkan_context,
			3,
		);

		let unique_queue_family_indices =
			vulkan_context.queue_family_indices
				.get_unique_values()
				.iter()
				.map(|&index| index as u32)
				.collect::<Vec<u32>>();
		let sharing_mode = {
			if unique_queue_family_indices.len() == 1 {
				vk::SharingMode::EXCLUSIVE
			} else {
				vk::SharingMode::CONCURRENT
			}
		};

		let create_info = vk::SwapchainCreateInfoKHR::builder()
			.surface(vulkan_context.surface.handle)
			.min_image_count(image_count)
			.image_format(surface_format.format)
			.image_color_space(surface_format.color_space)
			.image_extent(extent)
			.image_array_layers(1)
			.image_usage(vk::ImageUsageFlags::COLOR_ATTACHMENT)
			.image_sharing_mode(sharing_mode)
			.queue_family_indices(&unique_queue_family_indices)
			.pre_transform(vk::SurfaceTransformFlagsKHR::IDENTITY)
			.present_mode(present_mode)
			.composite_alpha(vk::CompositeAlphaFlagsKHR::OPAQUE);


		win_render_log!(Verbose, "Format: \"{:?}\" \"{:?}\"",
			surface_format.format,
			surface_format.color_space
		);
		win_render_log!(Verbose, "Present mode: \"{:?}\"", present_mode);
		win_render_log!(Verbose, "Extent: {}x{}", extent.width, extent.height);
		win_render_log!(Verbose, "Image count: {}", image_count);

		let swapchain = unsafe {
			vulkan_context.swapchain_loader.create_swapchain(&create_info, None)
				.expect("Unable to create swapchain")
		};

		let swapchain_images = unsafe {
			vulkan_context.swapchain_loader.get_swapchain_images(swapchain)
				.expect("Unable to get swapchain images")
		};

		let frames =
			swapchain_images.iter().map(|&image| {
				Frame::new(
					vulkan_context,
					&image,
					surface_format.format,
					extent,
				)
			}).collect::<Vec<_>>();

		Self {
			vulkan_context: Rc::downgrade(vulkan_context),
			raw: swapchain,
			frames,
		}
	}
}


impl Drop for Swapchain
{
	fn drop(&mut self)
	{
		win_render_log!(Verbose, "Dropping swapchain...");

		let vulkan_context = {
			let rc = self.vulkan_context.upgrade();
			if rc.is_none() {
				win_render_log!(Error, "Swapchain cleanup failed! Vulkan context is dropped!");
				return;
			}
			rc.unwrap()
		};

		self.frames.clear();

		unsafe {
			vulkan_context.swapchain_loader.destroy_swapchain(self.raw, None);
		}
	}
}

nothing fency, creating a swapchain then calling the delete function when Dropped.

Before you ask:

it's indeed dropped prior to the device/instance.
The frame doesn't contain anything yet it's literally an empty struct

(edit): I've made a very simple program that trigger this crash down the comment

Thanks for your time :)

Answered by Friz64

Jan 24, 2024

The values your builders point to are too short lived, resulting in a use after free. Extend the lifetime of these values by placing them in their own variable.

Fixed version (click to expand)

use std::{
    ffi::{CStr, CString},
    slice,
};

use ash::{extensions, vk};
use winit::{
    dpi::PhysicalSize,
    event::WindowEvent,
    event_loop::EventLoop,
    raw_window_handle::{HasWindowHandle, RawWindowHandle},
    window::WindowBuilder,
};

struct WindowSurface {
    pub loader: extensions::khr::Surface,
    pub handle: vk::SurfaceKHR,
}

pub struct DebugMessenger {
    messenger: vk::DebugUtilsMessengerEXT,
    loader: extensions::ext::DebugUtils,
}

pub fn main() {
    let event_lo…

View full answer

Ralith · 2024-01-22T20:16:48Z

Ralith
Jan 22, 2024
Maintainer

Did you keep your Entry object around? Do the validation layers have anything to say?

8 replies

hcabel Jan 22, 2024
Author

Yeah the entry is stored in my vulkan context, and for the validation layer sadly no I don't have any message it just crash

hcabel Jan 24, 2024
Author

Hey, I've made a very very minimalist program that crash the same way on my side, I would REALLY appreciate if you can have a look a it.

Cargo.toml:

[package]
name = "ash_crash"
version = "0.1.0"
edition = "2021"

[[bin]]
name = "ash_crash"
path = "src/main.rs"

[dependencies]
ash = "0.37.3+1.3.251"
ash-window = "0.12.0"
winit = "0.29.10"

and the main:


use std::ffi::{CString, CStr};

use ash::{vk, extensions};
use winit::{
	event_loop::EventLoop,
	raw_window_handle::{
		RawWindowHandle,
		HasWindowHandle
	},
	window::WindowBuilder,
	dpi::PhysicalSize,
	event::WindowEvent
};

struct WindowSurface
{
	pub loader: extensions::khr::Surface,
	pub handle: vk::SurfaceKHR,
}

pub
struct DebugMessenger
{
	messenger: vk::DebugUtilsMessengerEXT,
	loader: extensions::ext::DebugUtils,
}

pub fn main()
{

	let event_loop = EventLoop::new().unwrap();

	let windows = vec![
		create_window(&event_loop),
		create_window(&event_loop),
		create_window(&event_loop),
		create_window(&event_loop),
	];

	let ash_entry = unsafe {
		ash::Entry::load().unwrap()
	};

	let instance = unsafe {
		let create_info = vk::InstanceCreateInfo::builder()
			.application_info(
				&vk::ApplicationInfo::builder()
					.application_name(&CString::new("Vulkan").unwrap())
					.application_version(vk::make_api_version(0, 1, 0, 0))
					.engine_name(&CString::new("No Engine").unwrap())
					.engine_version(vk::make_api_version(0, 1, 0, 0))
					.api_version(vk::make_api_version(0, 1, 3, 0))
					.build()
			)
			.enabled_layer_names(&[
				CStr::from_bytes_with_nul(b"VK_LAYER_KHRONOS_validation\0").unwrap().as_ptr(),
			])
			.enabled_extension_names(&[
				extensions::khr::Surface::name().as_ptr(),
				extensions::khr::Win32Surface::name().as_ptr(),
				extensions::ext::DebugUtils::name().as_ptr(),
			])
			.build();

		ash_entry.create_instance(&create_info, None).unwrap()
	};

	let debug_messenger = {
		let create_info = vk::DebugUtilsMessengerCreateInfoEXT::builder()
			.message_severity(
				vk::DebugUtilsMessageSeverityFlagsEXT::WARNING
				| vk::DebugUtilsMessageSeverityFlagsEXT::VERBOSE
				| vk::DebugUtilsMessageSeverityFlagsEXT::ERROR,
			)
			.message_type(
				vk::DebugUtilsMessageTypeFlagsEXT::GENERAL
				| vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE
				| vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION
			)
			.pfn_user_callback(Some(vulkan_debug_utils_callback))
			.build();

		let loader = extensions::ext::DebugUtils::new(&ash_entry, &instance);
		let messenger = unsafe {
			loader
				.create_debug_utils_messenger(
					&create_info,
					None,
				).unwrap()
		};

		DebugMessenger {
			messenger,
			loader,
		}
	};

	let window_surface = {
		let (display_handle, window_handle) =
			match windows[0].window_handle().unwrap().as_raw() {
				RawWindowHandle::Win32(handle) =>
					(
						handle.hinstance.unwrap().get() as *const std::ffi::c_void,
						handle.hwnd.get() as *const std::ffi::c_void,
					),
				_ => { panic!("Unsupported window handle"); }
			};

		let surface_create_info = vk::Win32SurfaceCreateInfoKHR::builder()
			.hinstance(display_handle)
			.hwnd(window_handle)
			.build();

		let loader = extensions::khr::Surface::new(&ash_entry, &instance);
		let surface = unsafe {
			let surface_fn = extensions::khr::Win32Surface::new(&ash_entry, &instance);
			surface_fn.create_win32_surface(&surface_create_info, None).unwrap()
		};
		WindowSurface {
			loader,
			handle: surface,
		}
	};

	let physical_devices = unsafe {
		instance.enumerate_physical_devices().unwrap()
	};
	let physical_device = physical_devices[0];

	let physical_device_properties = unsafe {
		instance.get_physical_device_properties(physical_device)
	};

	println!("Physical device: {:?} (type: {:?})",
		unsafe {
			std::ffi::CStr::from_ptr(
				physical_device_properties.device_name.as_ptr()
			)
		}.to_str().unwrap(),
		physical_device_properties.device_type
	);

	let queue_family_properties = unsafe {
		instance.get_physical_device_queue_family_properties(physical_device)
	};

	let queue_family_index = queue_family_properties.iter()
		.enumerate()
		.find_map(|(index, properties)| {
			let supports_graphics = properties.queue_flags.contains(vk::QueueFlags::GRAPHICS);
			let supports_surface = unsafe {
				window_surface.loader
					.get_physical_device_surface_support(
						physical_device,
						index as u32,
						window_surface.handle,
					).unwrap()
			};

			if supports_graphics && supports_surface {
				Some(index as u32)
			} else {
				None
			}
		}).unwrap();

	let device = unsafe {
		let queue_create_info = vk::DeviceQueueCreateInfo::builder()
			.queue_family_index(queue_family_index)
			.queue_priorities(&[1.0])
			.build();

		let device_create_info = vk::DeviceCreateInfo::builder()
			.queue_create_infos(&[queue_create_info])
			.enabled_extension_names(&[
				extensions::khr::Swapchain::name().as_ptr(),
			])
			.build();

		instance.create_device(physical_device, &device_create_info, None).unwrap()
	};

	let swapchain_loader = extensions::khr::Swapchain::new(&instance, &device);

	let swapchains = {
		let mut swapchain_vec = Vec::new();
		for window in windows.iter() {
			print!("\n\nCreating swapchain for window {:?}...\n\n", window.id());
			swapchain_vec.push(
				create_new_swapchain(
					&swapchain_loader,
					&window_surface,
					vk::Extent2D {
						width: window.inner_size().width,
						height: window.inner_size().height,
					},
					physical_device
				)
			);
		}

		swapchain_vec
	};

	let last_window_id = windows.last().unwrap().id();

	let _ = event_loop
		.run(|event, elwt| {
		use winit::event::Event;

			match event {
				Event::WindowEvent { event, window_id } => {
					match event {
						WindowEvent::CloseRequested => {
							if last_window_id == window_id {
								elwt.exit();
							}
						},
						_ => {}
					}
				},
				_ => {}
			}

		});

	unsafe {
		for swapchain in swapchains {
			swapchain_loader.destroy_swapchain(swapchain, None);
		}

		device.destroy_device(None);
		window_surface.loader.destroy_surface(window_surface.handle, None);

		debug_messenger.loader.destroy_debug_utils_messenger(debug_messenger.messenger, None);
		instance.destroy_instance(None);
	}
}

fn create_window(event_loop: &EventLoop<()>) -> winit::window::Window
{
	let window = WindowBuilder::new()
		.with_title("Vulkan crash test")
		.with_inner_size(PhysicalSize::new(100, 100))
		.build(event_loop)
		.unwrap();

	window
}

unsafe extern "system"
fn vulkan_debug_utils_callback(
	message_severity: vk::DebugUtilsMessageSeverityFlagsEXT,
	message_type: vk::DebugUtilsMessageTypeFlagsEXT,
	p_callback_data: *const vk::DebugUtilsMessengerCallbackDataEXT,
	_p_user_data: *mut std::ffi::c_void,
)
	-> vk::Bool32
{
	let message = CStr::from_ptr((*p_callback_data).p_message);
	let severity = match message_severity {
		vk::DebugUtilsMessageSeverityFlagsEXT::VERBOSE => "Verbose",
		vk::DebugUtilsMessageSeverityFlagsEXT::INFO => "Info",
		vk::DebugUtilsMessageSeverityFlagsEXT::WARNING => "Warning",
		vk::DebugUtilsMessageSeverityFlagsEXT::ERROR => "Error",
		_ => "Unknown",
	};

	let ty = match message_type {
		vk::DebugUtilsMessageTypeFlagsEXT::GENERAL => "General",
		vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION => "Validation",
		vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE => "Performance",
		_ => "Unknown",
	};

	println!("[Vulkan] |{}| {}: {:?}", severity, ty, message);

	vk::FALSE
}

fn create_new_swapchain(
	loader: &extensions::khr::Swapchain,
	surface: &WindowSurface,
	extent: vk::Extent2D,
	physical_device: vk::PhysicalDevice,
)
	-> vk::SwapchainKHR
{
	let surface_format = unsafe {
		surface.loader.get_physical_device_surface_formats(
			physical_device,
			surface.handle,
		).unwrap()[0]
	};
	let present_mode = vk::PresentModeKHR::FIFO;
	let image_count = 3;

	let swapchain_create_info = vk::SwapchainCreateInfoKHR::builder()
		.surface(surface.handle)
		.min_image_count(image_count)
		.image_color_space(surface_format.color_space)
		.image_format(surface_format.format)
		.image_extent(extent)
		.image_array_layers(1)
		.image_usage(vk::ImageUsageFlags::COLOR_ATTACHMENT)
		.image_sharing_mode(vk::SharingMode::EXCLUSIVE)
		.pre_transform(vk::SurfaceTransformFlagsKHR::IDENTITY)
		.composite_alpha(vk::CompositeAlphaFlagsKHR::OPAQUE)
		.present_mode(present_mode)
		.clipped(true)
		.build();

	unsafe {
		loader.create_swapchain(&swapchain_create_info, None).unwrap()
	}
}

Friz64 Jan 24, 2024

The values your builders point to are too short lived, resulting in a use after free. Extend the lifetime of these values by placing them in their own variable.

Fixed version (click to expand)

use std::{
    ffi::{CStr, CString},
    slice,
};

use ash::{extensions, vk};
use winit::{
    dpi::PhysicalSize,
    event::WindowEvent,
    event_loop::EventLoop,
    raw_window_handle::{HasWindowHandle, RawWindowHandle},
    window::WindowBuilder,
};

struct WindowSurface {
    pub loader: extensions::khr::Surface,
    pub handle: vk::SurfaceKHR,
}

pub struct DebugMessenger {
    messenger: vk::DebugUtilsMessengerEXT,
    loader: extensions::ext::DebugUtils,
}

pub fn main() {
    let event_loop = EventLoop::new().unwrap();

    let windows = vec![
        create_window(&event_loop),
        create_window(&event_loop),
        create_window(&event_loop),
        create_window(&event_loop),
    ];

    let ash_entry = unsafe { ash::Entry::load().unwrap() };

    let instance = unsafe {
        let app_name = CString::new("Vulkan").unwrap();
        let engine_name = CString::new("No Engine").unwrap();
        let enabled_layer_names = [CStr::from_bytes_with_nul(b"VK_LAYER_KHRONOS_validation\0")
            .unwrap()
            .as_ptr()];
        let enabled_extension_names = [
            extensions::khr::Surface::name().as_ptr(),
            extensions::khr::Win32Surface::name().as_ptr(),
            extensions::ext::DebugUtils::name().as_ptr(),
        ];
        let app_info = vk::ApplicationInfo::builder()
            .application_name(&app_name)
            .application_version(vk::make_api_version(0, 1, 0, 0))
            .engine_name(&engine_name)
            .engine_version(vk::make_api_version(0, 1, 0, 0))
            .api_version(vk::make_api_version(0, 1, 3, 0));
        let create_info = vk::InstanceCreateInfo::builder()
            .application_info(&app_info)
            .enabled_layer_names(&enabled_layer_names)
            .enabled_extension_names(&enabled_extension_names);

        ash_entry.create_instance(&create_info, None).unwrap()
    };

    let debug_messenger = {
        let create_info = vk::DebugUtilsMessengerCreateInfoEXT::builder()
            .message_severity(
                vk::DebugUtilsMessageSeverityFlagsEXT::WARNING
                    | vk::DebugUtilsMessageSeverityFlagsEXT::VERBOSE
                    | vk::DebugUtilsMessageSeverityFlagsEXT::ERROR,
            )
            .message_type(
                vk::DebugUtilsMessageTypeFlagsEXT::GENERAL
                    | vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE
                    | vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION,
            )
            .pfn_user_callback(Some(vulkan_debug_utils_callback));

        let loader = extensions::ext::DebugUtils::new(&ash_entry, &instance);
        let messenger = unsafe {
            loader
                .create_debug_utils_messenger(&create_info, None)
                .unwrap()
        };

        DebugMessenger { messenger, loader }
    };

    let window_surface = {
        let (display_handle, window_handle) = match windows[0].window_handle().unwrap().as_raw() {
            RawWindowHandle::Win32(handle) => (
                handle.hinstance.unwrap().get() as *const std::ffi::c_void,
                handle.hwnd.get() as *const std::ffi::c_void,
            ),
            _ => {
                panic!("Unsupported window handle");
            }
        };

        let surface_create_info = vk::Win32SurfaceCreateInfoKHR::builder()
            .hinstance(display_handle)
            .hwnd(window_handle);

        let loader = extensions::khr::Surface::new(&ash_entry, &instance);
        let surface = unsafe {
            let surface_fn = extensions::khr::Win32Surface::new(&ash_entry, &instance);
            surface_fn
                .create_win32_surface(&surface_create_info, None)
                .unwrap()
        };
        WindowSurface {
            loader,
            handle: surface,
        }
    };

    let physical_devices = unsafe { instance.enumerate_physical_devices().unwrap() };
    let physical_device = physical_devices[0];

    let physical_device_properties =
        unsafe { instance.get_physical_device_properties(physical_device) };

    println!(
        "Physical device: {:?} (type: {:?})",
        unsafe { std::ffi::CStr::from_ptr(physical_device_properties.device_name.as_ptr()) }
            .to_str()
            .unwrap(),
        physical_device_properties.device_type
    );

    let queue_family_properties =
        unsafe { instance.get_physical_device_queue_family_properties(physical_device) };

    let queue_family_index = queue_family_properties
        .iter()
        .enumerate()
        .find_map(|(index, properties)| {
            let supports_graphics = properties.queue_flags.contains(vk::QueueFlags::GRAPHICS);
            let supports_surface = unsafe {
                window_surface
                    .loader
                    .get_physical_device_surface_support(
                        physical_device,
                        index as u32,
                        window_surface.handle,
                    )
                    .unwrap()
            };

            if supports_graphics && supports_surface {
                Some(index as u32)
            } else {
                None
            }
        })
        .unwrap();

    let device = unsafe {
        let queue_priorities = [1.0];
        let queue_create_info = vk::DeviceQueueCreateInfo::builder()
            .queue_family_index(queue_family_index)
            .queue_priorities(&queue_priorities);

        let enabled_extension_names = [extensions::khr::Swapchain::name().as_ptr()];
        let device_create_info = vk::DeviceCreateInfo::builder()
            .queue_create_infos(slice::from_ref(&queue_create_info))
            .enabled_extension_names(&enabled_extension_names);

        instance
            .create_device(physical_device, &device_create_info, None)
            .unwrap()
    };

    let swapchain_loader = extensions::khr::Swapchain::new(&instance, &device);

    let swapchains = {
        let mut swapchain_vec = Vec::new();
        for window in windows.iter() {
            print!("\n\nCreating swapchain for window {:?}...\n\n", window.id());
            swapchain_vec.push(create_new_swapchain(
                &swapchain_loader,
                &window_surface,
                vk::Extent2D {
                    width: window.inner_size().width,
                    height: window.inner_size().height,
                },
                physical_device,
            ));
        }

        swapchain_vec
    };

    let last_window_id = windows.last().unwrap().id();

    let _ = event_loop.run(|event, elwt| {
        use winit::event::Event;

        match event {
            Event::WindowEvent { event, window_id } => match event {
                WindowEvent::CloseRequested => {
                    if last_window_id == window_id {
                        elwt.exit();
                    }
                }
                _ => {}
            },
            _ => {}
        }
    });

    unsafe {
        for swapchain in swapchains {
            swapchain_loader.destroy_swapchain(swapchain, None);
        }

        device.destroy_device(None);
        window_surface
            .loader
            .destroy_surface(window_surface.handle, None);

        debug_messenger
            .loader
            .destroy_debug_utils_messenger(debug_messenger.messenger, None);
        instance.destroy_instance(None);
    }
}

fn create_window(event_loop: &EventLoop<()>) -> winit::window::Window {
    let window = WindowBuilder::new()
        .with_title("Vulkan crash test")
        .with_inner_size(PhysicalSize::new(100, 100))
        .build(event_loop)
        .unwrap();

    window
}

unsafe extern "system" fn vulkan_debug_utils_callback(
    message_severity: vk::DebugUtilsMessageSeverityFlagsEXT,
    message_type: vk::DebugUtilsMessageTypeFlagsEXT,
    p_callback_data: *const vk::DebugUtilsMessengerCallbackDataEXT,
    _p_user_data: *mut std::ffi::c_void,
) -> vk::Bool32 {
    let message = CStr::from_ptr((*p_callback_data).p_message);
    let severity = match message_severity {
        vk::DebugUtilsMessageSeverityFlagsEXT::VERBOSE => "Verbose",
        vk::DebugUtilsMessageSeverityFlagsEXT::INFO => "Info",
        vk::DebugUtilsMessageSeverityFlagsEXT::WARNING => "Warning",
        vk::DebugUtilsMessageSeverityFlagsEXT::ERROR => "Error",
        _ => "Unknown",
    };

    let ty = match message_type {
        vk::DebugUtilsMessageTypeFlagsEXT::GENERAL => "General",
        vk::DebugUtilsMessageTypeFlagsEXT::VALIDATION => "Validation",
        vk::DebugUtilsMessageTypeFlagsEXT::PERFORMANCE => "Performance",
        _ => "Unknown",
    };

    println!("[Vulkan] |{}| {}: {:?}", severity, ty, message);

    vk::FALSE
}

fn create_new_swapchain(
    loader: &extensions::khr::Swapchain,
    surface: &WindowSurface,
    extent: vk::Extent2D,
    physical_device: vk::PhysicalDevice,
) -> vk::SwapchainKHR {
    let surface_format = unsafe {
        surface
            .loader
            .get_physical_device_surface_formats(physical_device, surface.handle)
            .unwrap()[0]
    };
    let present_mode = vk::PresentModeKHR::FIFO;
    let image_count = 3;

    let swapchain_create_info = vk::SwapchainCreateInfoKHR::builder()
        .surface(surface.handle)
        .min_image_count(image_count)
        .image_color_space(surface_format.color_space)
        .image_format(surface_format.format)
        .image_extent(extent)
        .image_array_layers(1)
        .image_usage(vk::ImageUsageFlags::COLOR_ATTACHMENT)
        .image_sharing_mode(vk::SharingMode::EXCLUSIVE)
        .pre_transform(vk::SurfaceTransformFlagsKHR::IDENTITY)
        .composite_alpha(vk::CompositeAlphaFlagsKHR::OPAQUE)
        .present_mode(present_mode)
        .clipped(true);

    unsafe {
        loader
            .create_swapchain(&swapchain_create_info, None)
            .unwrap()
    }
}

Answer selected by MarijnS95

Friz64 Jan 24, 2024

To have the Rust compiler catch this class of bug in the future, avoid using .build() on builders unless it is absolutely necessary! Calling .build() erases all lifetime information, allowing for this bug to happen. All builders implement Deref, which allows you to (mostly) seamlessly reference their underlying datastructure. This common pitfall is being adressed in a future ash version: #602

hcabel Jan 24, 2024
Author

@Friz64 Thanks for your suggestion, sadly it does not fix the issue. (Yeah this code example is very rough 😆)
Try multiple time this crash doesn't happened all the time (~75%) creating more window will crash more often too.

Thanks for the .build() tips I wasn't aware of that, thanks ❤️

MarijnS95 Jan 24, 2024
Maintainer

Maybe run the code through rustmft, that should make it less rough :)

Per the readme, as quoted by @Friz64, you should almost never (have to) call .build() and it's a massive footgun at that. That's why it will be removed in the next release.

If you remove it, the Rust compiler will automatically tell you where your pointers (now lifetimed borrows!) are pointing to stale and dropped structures.

Few random notes:

don't use the +metadata part in crate dependencies' versions. This is only informational when the crate is published and won't be used to select an alternative crate version;
[[bin]] name = "<package name>" is not required for src/main.rs;
Calling .unwrap() is nicer outside the unsafe {} block, and puts some statements on a single line again;
Use CStr::from_bytes_with_nul(b"No engine\0") and friends (in a future Rust version c"No engine"!) to create 'static lifetimed strings that aren't deallocated;
Create surfaces in winit::Event...::Resumed and destroy them in ::Suspended to support mobile platforms;
Use our ash-window crate to take care of turning a RawWindowHandle into a surface.

hcabel Jan 25, 2024
Author

Thanks I appreciated those notes, I'll keep them in mind 👍
For the crash itself I can't find a way to resolve it, I've spend the last couple of hours trying to avoid any drop of any variable to see if it fix the issue but it doesn't... (based on the "fixed" version that Friz64 provided), but the crash still occur. I'm sorry if it's obvious and I'm missing it but I don't see which variable is being dropped and trigger the crash.
I might try to build Vulkan locally with the symbol later (hopefully the debugger will show something more than the assembly)

MarijnS95 · 2024-12-02T13:28:59Z

MarijnS95
Dec 2, 2024
Maintainer

The .build() footgun is removed in the latest release, so this should no longer be a problem. Feel free to request reopening when the sample still crashes, though this appears to be stale.

0 replies

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Crash after destroying a couple of SwapchainKHR instances :/ #862

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Replies: 2 comments 8 replies

{{title}}

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

Select a reply

Crash after destroying a couple of SwapchainKHR instances :/ #862

hcabel Jan 22, 2024

Replies: 2 comments · 8 replies

Ralith Jan 22, 2024 Maintainer

hcabel Jan 22, 2024 Author

hcabel Jan 24, 2024 Author

Friz64 Jan 24, 2024

Friz64 Jan 24, 2024

hcabel Jan 24, 2024 Author

MarijnS95 Jan 24, 2024 Maintainer

hcabel Jan 25, 2024 Author

MarijnS95 Dec 2, 2024 Maintainer

hcabel
Jan 22, 2024

Replies: 2 comments 8 replies

Ralith
Jan 22, 2024
Maintainer

hcabel Jan 22, 2024
Author

hcabel Jan 24, 2024
Author

hcabel Jan 24, 2024
Author

MarijnS95 Jan 24, 2024
Maintainer

hcabel Jan 25, 2024
Author

MarijnS95
Dec 2, 2024
Maintainer