lgpu-hal 0.1.2

Micro hardware abstraction layer for lgpu
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//! Vulkan timeline semaphore synchronization.

use super::VulkanDevice;
use crate::HalError;
use ash::vk;

pub struct VulkanTimelineSemaphore {
    pub semaphore: vk::Semaphore,
}

unsafe impl Send for VulkanTimelineSemaphore {}
unsafe impl Sync for VulkanTimelineSemaphore {}

impl VulkanDevice {
    pub fn create_timeline_semaphore(
        &self,
        initial_value: u64,
    ) -> Result<VulkanTimelineSemaphore, HalError> {
        let mut type_info = vk::SemaphoreTypeCreateInfo::default()
            .semaphore_type(vk::SemaphoreType::TIMELINE)
            .initial_value(initial_value);
        let create_info = vk::SemaphoreCreateInfo::default().push_next(&mut type_info);

        let semaphore = unsafe {
            self.device
                .create_semaphore(&create_info, None)
                .map_err(|e| {
                    HalError::BackendError(format!("Failed to create timeline semaphore: {e}"))
                })?
        };

        Ok(VulkanTimelineSemaphore { semaphore })
    }

    pub fn wait_timeline_semaphore(
        &self,
        semaphore: &VulkanTimelineSemaphore,
        value: u64,
        timeout_nanos: u64,
    ) -> Result<(), HalError> {
        let semaphores = [semaphore.semaphore];
        let values = [value];
        let wait_info = vk::SemaphoreWaitInfo::default()
            .semaphores(&semaphores)
            .values(&values);

        unsafe {
            self.device
                .wait_semaphores(&wait_info, timeout_nanos)
                .map_err(|e| HalError::CommandError(format!("vkWaitSemaphores failed: {e}")))?;
        }
        Ok(())
    }

    pub fn get_timeline_semaphore_value(
        &self,
        semaphore: &VulkanTimelineSemaphore,
    ) -> Result<u64, HalError> {
        unsafe {
            self.device
                .get_semaphore_counter_value(semaphore.semaphore)
                .map_err(|e| {
                    HalError::CommandError(format!("vkGetSemaphoreCounterValue failed: {e}"))
                })
        }
    }

    pub fn signal_timeline_semaphore(
        &self,
        semaphore: &VulkanTimelineSemaphore,
        value: u64,
    ) -> Result<(), HalError> {
        let signal_info = vk::SemaphoreSignalInfo::default()
            .semaphore(semaphore.semaphore)
            .value(value);
        unsafe {
            self.device
                .signal_semaphore(&signal_info)
                .map_err(|e| HalError::CommandError(format!("vkSignalSemaphore failed: {e}")))?;
        }
        Ok(())
    }

    pub fn destroy_timeline_semaphore(&self, semaphore: VulkanTimelineSemaphore) {
        unsafe {
            self.device.destroy_semaphore(semaphore.semaphore, None);
        }
    }
}