1package vulkan
2
3import (
4 "fmt"
5 "image"
6 "math"
7 "os"
8 "runtime"
9 "slices"
10 "unsafe"
11
12 "github.com/bnema/neferwl/internal/ports"
13 vk "github.com/bnema/purego-vulkan/vulkan"
14)
15
16// Frames are recorded into a ring of slots, one per frame in flight. The
17// CPU never waits for a frame it just submitted: Render returns a sync
18// file the display waits on (KMS IN_FENCE_FD). A slot's fence is waited
19// only when the slot is reused, and objects a frame read (imports, GPU
20// buffers, client semaphores) are freed only once that frame completed.
21
22// frameSlots is how many frames may be in flight: one per output target.
23const frameSlots = 2
24
25// frameSlot is the command buffer and sync objects of one frame in flight.
26type frameSlot struct {
27 cmd vk.CommandBuffer
28 fence vk.Fence
29 // done is signalled with the frame and exported as its sync file.
30 done vk.Semaphore
31 frame uint64 // the frame recorded last, 0 before any
32 busy bool // submitted, fence not yet seen signalled
33}
34
35// deferredFree runs once frame completed.
36type deferredFree struct {
37 frame uint64
38 free func()
39}
40
41func (r *Renderer) createSlots() error {
42 d := r.dd
43 cmds := make([]vk.CommandBuffer, frameSlots)
44 ai := vk.CommandBufferAllocateInfo{SType: vk.StructureTypeCommandBufferAllocateInfo, CommandPool: r.pool, Level: vk.CommandBufferLevelPrimary, CommandBufferCount: frameSlots}
45 if err := checked("vkAllocateCommandBuffers", d.AllocateCommandBuffers(r.device, &ai, &cmds[0])); err != nil {
46 return err
47 }
48 for i := range r.slots {
49 s := &r.slots[i]
50 s.cmd = cmds[i]
51 fi := vk.FenceCreateInfo{SType: vk.StructureTypeFenceCreateInfo}
52 if err := checked("vkCreateFence", d.CreateFence(r.device, &fi, nil, &s.fence)); err != nil {
53 return err
54 }
55 if err := r.newDone(s); err != nil {
56 return err
57 }
58 }
59 return nil
60}
61
62// newDone creates a slot's frame semaphore, exportable as a sync file when
63// the device allows it; a device that refuses falls back to waiting for
64// frames on the CPU (syncFD off).
65func (r *Renderer) newDone(s *frameSlot) error {
66 d := r.dd
67 si := vk.SemaphoreCreateInfo{SType: vk.StructureTypeSemaphoreCreateInfo}
68 export := vk.ExportSemaphoreCreateInfo{SType: vk.StructureTypeExportSemaphoreCreateInfo, HandleTypes: vk.ExternalSemaphoreHandleTypeSyncFDBit}
69 if r.syncFD {
70 si.Next = unsafe.Pointer(&export)
71 if d.CreateSemaphore(r.device, &si, nil, &s.done) == vk.Success {
72 return nil
73 }
74 r.syncFD = false
75 si.Next = nil
76 }
77 return checked("vkCreateSemaphore", d.CreateSemaphore(r.device, &si, nil, &s.done))
78}
79
80func (r *Renderer) destroySlots() {
81 d := r.dd
82 for i := range r.slots {
83 s := &r.slots[i]
84 if s.fence != 0 {
85 d.DestroyFence(r.device, s.fence, nil)
86 }
87 if s.done != 0 {
88 d.DestroySemaphore(r.device, s.done, nil)
89 }
90 if s.cmd != 0 {
91 d.FreeCommandBuffers(r.device, r.pool, 1, &s.cmd)
92 }
93 *s = frameSlot{}
94 }
95}
96
97// waitFrame blocks until frame n completed. Frames not submitted yet and
98// frames known done return at once. Every slot holding a frame up to n
99// is waited and reset, so its fence is unsignalled before reuse.
100func (r *Renderer) waitFrame(n uint64) error {
101 n = min(n, r.submitted)
102 if n <= r.completed {
103 return nil
104 }
105 for i := range r.slots {
106 s := &r.slots[i]
107 if !s.busy || s.frame > n {
108 continue
109 }
110 if err := checked("vkWaitForFences", r.dd.WaitForFences(r.device, 1, &s.fence, 1, math.MaxUint64)); err != nil {
111 return err
112 }
113 if err := checked("vkResetFences", r.dd.ResetFences(r.device, 1, &s.fence)); err != nil {
114 return err
115 }
116 s.busy = false
117 }
118 r.completed = n
119 r.runDeferred()
120 return nil
121}
122
123// retire frees an object once the frame that last used it completed.
124func (r *Renderer) retire(frame uint64, free func()) {
125 if frame <= r.completed {
126 free()
127 return
128 }
129 r.deferred = append(r.deferred, deferredFree{frame: frame, free: free})
130}
131
132func (r *Renderer) runDeferred() {
133 r.deferred = slices.DeleteFunc(r.deferred, func(f deferredFree) bool {
134 if f.frame <= r.completed {
135 f.free()
136 return true
137 }
138 return false
139 })
140}
141
142// idle records that the device finished every submitted frame.
143func (r *Renderer) idle() {
144 for i := range r.slots {
145 s := &r.slots[i]
146 if s.busy {
147 _ = r.dd.ResetFences(r.device, 1, &s.fence)
148 s.busy = false
149 }
150 }
151 // Frames recorded but never submitted have no GPU work either.
152 r.completed = r.frame
153 r.runDeferred()
154}
155
156// Render draws a frame into the current target. done is signalled when
157// the GPU finished it; nil when the device cannot export a sync file,
158// then the frame is finished on return.
159func (r *Renderer) Render(s ports.Scene, contents map[ports.WindowID]ports.SurfaceContent) (done *os.File, err error) {
160 // A frame that fails before its submit keeps its number: objects it
161 // touched are freed once a later frame completes (never early).
162 r.frame++
163 slot := &r.slots[r.frame%frameSlots]
164 // The slot's previous frame must be done before its command buffer
165 // is recorded again.
166 if slot.busy {
167 if err := r.waitFrame(slot.frame); err != nil {
168 return nil, err
169 }
170 }
171 tg := r.target()
172 dmg := newDamage(tg, s, image.Rect(0, 0, r.width, r.height))
173 ds := r.draws(s, contents, dmg)
174 dmg.finish()
175 r.dropPools()
176 partial := !dmg.all()
177 if partial {
178 // The pass keeps the image: repaint the background under the
179 // region, then everything clipped to it.
180 ds = dmg.clip(append([]draw{r.fillDraw(dmg.area, parseColor(s.Background))}, ds...))
181 r.redrawn += dmg.area.Dx() * dmg.area.Dy()
182 } else {
183 r.redrawn += r.width * r.height
184 }
185 d := r.dd
186 cmd := slot.cmd
187 if err := checked("vkResetCommandBuffer", d.ResetCommandBuffer(cmd, 0)); err != nil {
188 return nil, err
189 }
190 begin := vk.CommandBufferBeginInfo{SType: vk.StructureTypeCommandBufferBeginInfo, Flags: vk.CommandBufferUsageOneTimeSubmitBit}
191 if err := checked("vkBeginCommandBuffer", d.BeginCommandBuffer(cmd, &begin)); err != nil {
192 return nil, err
193 }
194 // A full redraw clears the target: its old contents never matter
195 // (UNDEFINED). A partial one keeps them.
196 b := vk.ImageMemoryBarrier{SType: vk.StructureTypeImageMemoryBarrier, DstAccessMask: vk.AccessColorAttachmentWriteBit, OldLayout: vk.ImageLayoutUndefined, NewLayout: vk.ImageLayoutColorAttachmentOptimal, SrcQueueFamilyIndex: queueFamilyIgnored, DstQueueFamilyIndex: queueFamilyIgnored, Image: tg.image, SubresourceRange: colorRange}
197 if partial {
198 b.OldLayout = tg.layout
199 b.DstAccessMask |= vk.AccessColorAttachmentReadBit
200 }
201 if tg.exported {
202 // Acquire from the display (foreign queue family).
203 b.SrcQueueFamilyIndex, b.DstQueueFamilyIndex = vk.QueueFamilyForeignEXT, r.family
204 }
205 d.CmdPipelineBarrier(cmd, vk.PipelineStageTransferBit|vk.PipelineStageColorAttachmentOutputBit, vk.PipelineStageColorAttachmentOutputBit, 0, 0, nil, 0, nil, 1, &b)
206 // Client buffers come from the foreign queue family (their driver)
207 // and go back to it after the frame, so the next frame acquires them.
208 var dmas []*imported
209 acquires := map[*imported]*os.File{}
210 for _, dr := range ds {
211 if dr.im != nil && !slices.Contains(dmas, dr.im) {
212 dmas = append(dmas, dr.im)
213 dr.im.last = r.frame
214 }
215 if dr.acquire != nil {
216 acquires[dr.im] = dr.acquire
217 }
218 }
219 r.ownership(cmd, dmas, true)
220 r.recordDraws(cmd, tg.view, parseColor(s.Background), ds, partial)
221 r.ownership(cmd, dmas, false)
222 b.SrcAccessMask, b.OldLayout = vk.AccessColorAttachmentWriteBit, vk.ImageLayoutColorAttachmentOptimal
223 b.SrcQueueFamilyIndex, b.DstQueueFamilyIndex = queueFamilyIgnored, queueFamilyIgnored
224 if tg.exported {
225 // Release to the display: KMS scans it out after the fence.
226 b.NewLayout, b.DstAccessMask = vk.ImageLayoutGeneral, 0
227 b.SrcQueueFamilyIndex, b.DstQueueFamilyIndex = r.family, vk.QueueFamilyForeignEXT
228 d.CmdPipelineBarrier(cmd, vk.PipelineStageColorAttachmentOutputBit, vk.PipelineStageBottomOfPipeBit, 0, 0, nil, 0, nil, 1, &b)
229 } else {
230 b.NewLayout, b.DstAccessMask = vk.ImageLayoutTransferSrcOptimal, vk.AccessTransferReadBit
231 d.CmdPipelineBarrier(cmd, vk.PipelineStageColorAttachmentOutputBit, vk.PipelineStageTransferBit, 0, 0, nil, 0, nil, 1, &b)
232 }
233 if err := checked("vkEndCommandBuffer", d.EndCommandBuffer(cmd)); err != nil {
234 return nil, err
235 }
236 // Wait for the client's GPU writes to each buffer: its explicit
237 // acquire fence, else the buffer's implicit fences.
238 var waits []vk.Semaphore
239 for _, im := range dmas {
240 sem := vk.Semaphore(0)
241 if f := acquires[im]; f != nil {
242 sem = r.importFence(f)
243 } else {
244 sem = r.readFence(im)
245 }
246 if sem != 0 {
247 waits = append(waits, sem)
248 }
249 }
250 frame := r.frame
251 for _, sem := range waits {
252 r.retire(frame, func() { d.DestroySemaphore(r.device, sem, nil) })
253 }
254 submit := vk.SubmitInfo{SType: vk.StructureTypeSubmitInfo, CommandBufferCount: 1, CommandBuffers: &cmd}
255 stages := make([]vk.PipelineStageFlags, len(waits))
256 if len(waits) > 0 {
257 for i := range stages {
258 stages[i] = vk.PipelineStageFragmentShaderBit
259 }
260 submit.WaitSemaphoreCount, submit.WaitSemaphores, submit.WaitDstStageMask = uint32(len(waits)), &waits[0], &stages[0]
261 }
262 if r.syncFD {
263 submit.SignalSemaphoreCount, submit.SignalSemaphores = 1, &slot.done
264 }
265 if err := checked("vkQueueSubmit", d.QueueSubmit(r.queue, 1, &submit, slot.fence)); err != nil {
266 return nil, err
267 }
268 runtime.KeepAlive(stages)
269 runtime.KeepAlive(waits)
270 slot.frame, slot.busy, r.submitted = frame, true, frame
271 tg.layout = b.NewLayout
272 tg.hold(s, dmg)
273 r.last, r.readBack = tg, false
274 r.dropUnused()
275 r.dropShm()
276 if !r.syncFD {
277 return nil, r.waitFrame(frame)
278 }
279 var fd int32
280 get := vk.SemaphoreGetFdInfoKHR{SType: vk.StructureTypeSemaphoreGetFDInfoKHR, Semaphore: slot.done, HandleType: vk.ExternalSemaphoreHandleTypeSyncFDBit}
281 if d.GetSemaphoreFdKHR(r.device, &get, &fd) != vk.Success {
282 // The frame is drawn: finish it on the CPU. The semaphore stays
283 // signalled: replace it, so the slot's next submit signals a
284 // fresh one.
285 if err := r.waitFrame(frame); err != nil {
286 return nil, err
287 }
288 d.DestroySemaphore(r.device, slot.done, nil)
289 slot.done = 0
290 return nil, r.newDone(slot)
291 }
292 if fd < 0 {
293 // Already signalled: the driver may return -1.
294 return nil, r.waitFrame(frame)
295 }
296 f := os.NewFile(uintptr(fd), "neferwl-frame")
297 if f == nil {
298 return nil, fmt.Errorf("invalid frame sync file %d", fd)
299 }
300 return f, nil
301}
302
303// ownership moves client images between their driver (foreign queue
304// family, GENERAL: their contents survive) and the fragment shader.
305func (r *Renderer) ownership(cmd vk.CommandBuffer, dmas []*imported, acquire bool) {
306 for _, im := range dmas {
307 b := vk.ImageMemoryBarrier{SType: vk.StructureTypeImageMemoryBarrier, Image: im.image, SubresourceRange: colorRange}
308 if acquire {
309 b.OldLayout, b.NewLayout = vk.ImageLayoutGeneral, vk.ImageLayoutShaderReadOnlyOptimal
310 b.SrcQueueFamilyIndex, b.DstQueueFamilyIndex = vk.QueueFamilyForeignEXT, r.family
311 b.DstAccessMask = vk.AccessShaderReadBit
312 // The frame waits on the client's fence at the fragment
313 // stage: the transfer must come after that wait.
314 r.dd.CmdPipelineBarrier(cmd, vk.PipelineStageFragmentShaderBit, vk.PipelineStageFragmentShaderBit, 0, 0, nil, 0, nil, 1, &b)
315 } else {
316 b.OldLayout, b.NewLayout = vk.ImageLayoutShaderReadOnlyOptimal, vk.ImageLayoutGeneral
317 b.SrcQueueFamilyIndex, b.DstQueueFamilyIndex = r.family, vk.QueueFamilyForeignEXT
318 b.SrcAccessMask = vk.AccessShaderReadBit
319 r.dd.CmdPipelineBarrier(cmd, vk.PipelineStageFragmentShaderBit, vk.PipelineStageBottomOfPipeBit, 0, 0, nil, 0, nil, 1, &b)
320 }
321 }
322}
323
324// oneShot records and runs commands outside the frame ring and waits for
325// them (setup and screenshots only, never per frame).
326func (r *Renderer) oneShot(record func(vk.CommandBuffer)) error {
327 d := r.dd
328 var cmd vk.CommandBuffer
329 ai := vk.CommandBufferAllocateInfo{SType: vk.StructureTypeCommandBufferAllocateInfo, CommandPool: r.pool, Level: vk.CommandBufferLevelPrimary, CommandBufferCount: 1}
330 if err := checked("vkAllocateCommandBuffers", d.AllocateCommandBuffers(r.device, &ai, &cmd)); err != nil {
331 return err
332 }
333 defer d.FreeCommandBuffers(r.device, r.pool, 1, &cmd)
334 var fence vk.Fence
335 fi := vk.FenceCreateInfo{SType: vk.StructureTypeFenceCreateInfo}
336 if err := checked("vkCreateFence", d.CreateFence(r.device, &fi, nil, &fence)); err != nil {
337 return err
338 }
339 defer d.DestroyFence(r.device, fence, nil)
340 begin := vk.CommandBufferBeginInfo{SType: vk.StructureTypeCommandBufferBeginInfo, Flags: vk.CommandBufferUsageOneTimeSubmitBit}
341 if err := checked("vkBeginCommandBuffer", d.BeginCommandBuffer(cmd, &begin)); err != nil {
342 return err
343 }
344 record(cmd)
345 if err := checked("vkEndCommandBuffer", d.EndCommandBuffer(cmd)); err != nil {
346 return err
347 }
348 submit := vk.SubmitInfo{SType: vk.StructureTypeSubmitInfo, CommandBufferCount: 1, CommandBuffers: &cmd}
349 if err := checked("vkQueueSubmit", d.QueueSubmit(r.queue, 1, &submit, fence)); err != nil {
350 return err
351 }
352 return checked("vkWaitForFences", d.WaitForFences(r.device, 1, &fence, 1, math.MaxUint64))
353}
354
355// Clear draws a background-only frame and waits for it.
356func (r *Renderer) Clear(rgb [3]uint8) error {
357 done, err := r.Render(ports.Scene{Background: fmt.Sprintf("#%02x%02x%02x", rgb[0], rgb[1], rgb[2])}, nil)
358 if done != nil {
359 done.Close()
360 }
361 if err != nil {
362 return err
363 }
364 return r.waitFrame(r.frame)
365}