jay-compositor 1.15.0

The Jay compositor
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use crate::gfx_api::FdSync;
use crate::gfx_api::ReservedSyncobjPoint;
use crate::utils::errorfmt::ErrorFmt;
use crate::video::drm::syncobj::SyncobjPoint;
use crate::vulkan_core::VulkanCoreError;
use crate::vulkan_core::device::VulkanDeviceInf;
use crate::vulkan_core::fence::VulkanDeviceFenceExt;
use crate::vulkan_core::fence::VulkanFence;
use crate::vulkan_core::timeline_semaphore::VulkanTimelineSemaphore;
use ash::vk::Fence;
use ash::vk::PipelineStageFlags2;
use ash::vk::SemaphoreSubmitInfo;
use ash::vk::SemaphoreWaitInfo;
use ash::vk::SubmitInfo2;
use std::rc::Rc;
use std::slice;

pub enum VulkanSync<D>
where
    D: VulkanDeviceInf,
{
    Fence(Rc<VulkanFence<D>>),
    TimelineSemaphore {
        tls: Rc<VulkanTimelineSemaphore<D>>,
        pending: Rc<ReservedSyncobjPoint>,
    },
}

impl<D> VulkanSync<D>
where
    D: VulkanDeviceInf,
{
    pub fn handle_validation(&self) {
        if let VulkanSync::TimelineSemaphore { tls, pending } = self
            && tls.device.instance().validation
        {
            let info = SemaphoreWaitInfo::default()
                .semaphores(slice::from_ref(&tls.semaphore))
                .values(slice::from_ref(&pending.point.0));
            unsafe {
                let _ = tls.device.device().wait_semaphores(&info, 0);
            }
        }
    }

    pub fn fence(&self) -> Fence {
        match self {
            VulkanSync::Fence(f) => f.fence,
            VulkanSync::TimelineSemaphore { .. } => Fence::null(),
        }
    }

    pub fn to_sync(&self, block: impl FnOnce()) -> Option<FdSync> {
        match self {
            VulkanSync::Fence(release_fence) => {
                zone!("export_sync_file");
                let release_sync_file = match release_fence.export_sync_file() {
                    Ok(s) => s,
                    Err(e) => {
                        log::error!("Could not export sync file from fence: {}", ErrorFmt(e));
                        block();
                        None
                    }
                };
                release_sync_file.map(FdSync::SyncFile)
            }
            VulkanSync::TimelineSemaphore { pending, .. } => Some(FdSync::Syncobj(pending.clone())),
        }
    }
}

pub trait VulkanDeviceSyncExt: VulkanDeviceInf {
    fn create_sync<'a>(
        self: &Rc<Self>,
        tls: Option<&Rc<VulkanTimelineSemaphore<Self>>>,
        semaphore_submit_info: &'a mut SemaphoreSubmitInfo<'_>,
        submit_info: &mut SubmitInfo2<'a>,
    ) -> Result<VulkanSync<Self>, VulkanCoreError>;
}

impl<D> VulkanDeviceSyncExt for D
where
    D: VulkanDeviceInf,
{
    fn create_sync<'a>(
        self: &Rc<Self>,
        tls: Option<&Rc<VulkanTimelineSemaphore<Self>>>,
        semaphore_submit_info: &'a mut SemaphoreSubmitInfo<'_>,
        submit_info: &mut SubmitInfo2<'a>,
    ) -> Result<VulkanSync<Self>, VulkanCoreError> {
        if let Some(tls) = tls {
            match create_tls_sync(self, tls, semaphore_submit_info, submit_info) {
                Ok(s) => return Ok(s),
                Err(e) => {
                    log::warn!("Could not create sync obj sync: {}", ErrorFmt(e));
                }
            }
        }
        self.create_fence().map(VulkanSync::Fence)
    }
}

fn create_tls_sync<'a, D>(
    device: &Rc<D>,
    tls: &Rc<VulkanTimelineSemaphore<D>>,
    semaphore_submit_info: &'a mut SemaphoreSubmitInfo<'_>,
    submit_info: &mut SubmitInfo2<'a>,
) -> Result<VulkanSync<D>, VulkanCoreError>
where
    D: VulkanDeviceInf,
{
    let point = SyncobjPoint(tls.next_point.fetch_add(1));
    let eventfd = device
        .eventfd_cache()
        .acquire()
        .map_err(VulkanCoreError::AcquireEventfd)?;
    tls.sync_ctx
        .wait_for_point(&eventfd.fd, &tls.syncobj, point, true)
        .map_err(VulkanCoreError::CreateSyncobjWait)?;
    let pending = Rc::new(ReservedSyncobjPoint {
        ctx: tls.sync_ctx.clone(),
        syncobj: tls.syncobj.clone(),
        point,
        sync_file: Default::default(),
        signaled: eventfd,
    });
    *semaphore_submit_info = SemaphoreSubmitInfo::default()
        .semaphore(tls.semaphore)
        .value(point.0)
        .stage_mask(PipelineStageFlags2::ALL_COMMANDS);
    *submit_info = submit_info.signal_semaphore_infos(slice::from_ref(semaphore_submit_info));
    Ok(VulkanSync::TimelineSemaphore {
        tls: tls.clone(),
        pending,
    })
}