<div dir="ltr"><div>Daniel, imagine hardware that can only do what Windows does: future fences signalled by userspace whenever userspace wants, and no kernel queues like we have today.</div><div><br></div><div>The only reason why current AMD GPUs work is because they have a ring buffer per queue with pointers to userspace command buffers followed by fences. What will we do if that ring buffer is removed?</div><div><br></div><div>Marek<br></div></div><br><div class="gmail_quote"><div dir="ltr" class="gmail_attr">On Tue, Apr 20, 2021 at 11:50 AM Daniel Stone <<a href="mailto:daniel@fooishbar.org">daniel@fooishbar.org</a>> wrote:<br></div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir="ltr"><div dir="ltr">Hi,</div><br><div class="gmail_quote"><div dir="ltr" class="gmail_attr">On Tue, 20 Apr 2021 at 16:16, Christian König <<a href="mailto:ckoenig.leichtzumerken@gmail.com" target="_blank">ckoenig.leichtzumerken@gmail.com</a>> wrote:</div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div>
<div>Am 20.04.21 um 17:07 schrieb Daniel
Stone:</div><blockquote type="cite">
<div dir="ltr">
<div class="gmail_quote">
<div>If the compositor no longer has a guarantee that the
buffer will be ready for composition in a reasonable amount
of time (which dma_fence gives us, and this proposal does
not appear to give us), then the compositor isn't trying to
use the buffer for compositing, it's waiting asynchronously
on a notification that the fence has signaled before it
attempts to use the buffer.</div>
<div><br>
</div>
<div>Marek's initial suggestion is that the kernel signal the
fence, which would unblock composition (and presumably show
garbage on screen, or at best jump back to old content).</div>
<div><br>
</div>
<div>My position is that the compositor will know the process
has crashed anyway - because its socket has been closed - at
which point we destroy all the client's resources including
its windows and buffers regardless. Signaling the fence
doesn't give us any value here, _unless_ the compositor is
just blindly waiting for the fence to signal ... which it
can't do because there's no guarantee the fence will ever
signal.</div>
</div>
</div>
</blockquote>
<br>
Yeah, but that assumes that the compositor has change to not blindly
wait for the client to finish rendering and as Daniel explained that
is rather unrealistic.<br>
<br>
What we need is a fallback mechanism which signals the fence after a
timeout and gives a penalty to the one causing the timeout.<br>
<br>
That gives us the same functionality we have today with the in
software scheduler inside the kernel.<br></div></blockquote><div><br></div><div>OK, if that's the case then I think I'm really missing something which isn't explained in this thread, because I don't understand what the additional complexity and API change gains us (see my first reply in this thread).</div><div><br></div><div>By way of example - say I have a blind-but-explicit compositor that takes a drm_syncobj along with a dmabuf with each client presentation request, but doesn't check syncobj completion, it just imports that into a VkSemaphore + VkImage and schedules work for the next frame.</div><div><br></div><div>Currently, that generates an execbuf ioctl for the composition (ignore KMS for now) with a sync point to wait on, and the kernel+GPU scheduling guarantees that the composition work will not begin until the client rendering work has retired. We have a further guarantee that this work will complete in reasonable time, for some value of 'reasonable'.</div><div><br></div><div>My understanding of this current proposal is that:</div><div>* userspace creates a 'present fence' with this new ioctl</div><div>* the fence becomes signaled when a value is written to a location in memory, which is visible through both CPU and GPU mappings of that page</div><div>* this 'present fence' is imported as a VkSemaphore (?) and the userspace Vulkan driver will somehow wait on this value either before submitting work or as a possibly-hardware-assisted GPU-side wait (?)</div><div>* the kernel's scheduler is thus eliminated from the equation, and every execbuf is submitted directly to hardware, because either userspace knows that the fence has already been signaled, or it will issue a GPU-side wait (?)</div><div>* but the kernel is still required to monitor completion of every fence itself, so it can forcibly complete, or penalise the client (?)</div><div><br></div><div>Lastly, let's say we stop ignoring KMS: what happens for the render-with-GPU-display-on-KMS case? Do we need to do the equivalent of glFinish() in userspace and only submit the KMS atomic request when the GPU work has fully retired?</div><div><br></div><div>Clarifying those points would be really helpful so this is less of a strawman. I have some further opinions, but I'm going to wait until I understand what I'm actually arguing against before I go too far. :) The last point is very salient though.</div><div><br></div><div>Cheers,</div><div>Daniel </div></div></div>
</blockquote></div>