On 10/19/24 00:47, Faith Ekstrand wrote:
The timing here isn't great, unfortunately. I'd love to contribute
more to the discussion but I'm going on leave starting next week until
mid-Febuary so I won't be able to participate much until then. I'll
try to leave a few thoughts, though.
Thanks for the comments! I'll actually also be quite busy until then
(Uni), but maybe by February they'll be a consensus on the path forward 😀.
On Fri, Oct 18, 2024 at 5:10 PM Derek Lesho
wrote:
Hey everyone 👋,
I'm Derek from the Wine project, and wanted to start a discussion
with
y'all about potentially extending the Mesa OGL drivers to help us
with a
functionality gap we're facing.
Problem Space:
In the last few years Wine's support for running 32-bit windows
apps in
a 64-bit host environment (wow64) has almost reached feature
completion,
but there remains a pain point with OpenGL applications: Namely that
Wine can't return a 64-bit GL implementation's buffer mappings to
a 32
bit application when the address is outside of the 32-bit range.
Currently, we have a workaround that will copy any changes to the
mapping back to the host upon glBufferUnmap, but this of course is
slow
when the implementation directly returns mapped memory, and
doesn't work
for GL_PERSISTENT_BIT, where directly mapped memory is required.
A few years ago we also faced this problem with Vulkan's, which was
solved through the VK_EXT_map_memory_placed extension Faith drafted,
allowing us to use our Wine-internal allocator to provide the
pages the
driver maps to. I'm now wondering if an GL equivalent would also
be seen
as feasible amongst the devs here.
Proposed solution:
As the GL backend handles host mapping in its own code, only giving
suballocations from its mappings back to the App, the problem is a
little bit less straight forward in comparison to our Vulkan
solution:
If we just allowed the application to set its own placed mapping when
calling glMapBuffer, the driver might then have to handle moving
buffers
out of already mapped ranges, and would lose control over its own
memory
management schemes.
Therefore, I propose a GL extension that allows the GL client to
provide
a mapping and unmapping callback to the implementation, to be used
whenever the driver needs to perform such operations. This way the
driver remains in full control of its memory management affairs,
and the
amount of work for an implementation as well as potential for bugs is
kept minimal. I've written a draft implementation in Zink using
map_memory_placed [1] and a corresponding Wine MR utilizing it
[2], and
would be curious to hear your thoughts. I don't have experience in
the
Mesa codebase, so I apologize if the branch is a tad messy.
It's an interesting approach, to be sure. I don't mean that as a bad
or good thing as I haven't given this enough thought with GL in mind
to have a better, more well thought out plan.
The most obvious issue that jumps out to me is that we really want
that callback to be set before anyone ever maps a buffer that might
possibly get exposed to the client and we want it to never change. If
this were Vulkan, we'd have you provide it at vkCreateDevice() time.
But this is GL where everybody loves a big mutable state object. If we
do go with callbacks (and it's still not 100% clear to me what the
right choice is), we'd want them to be somehow set-once and set before
any buffers are created. I'm not 100% sure how you'd spec that or how
we'd enforce it. There may be some precedent for this somewhere in GL
(no_error, maybe?) but I'm not sure.
Right, in the case of Zink I was just lucky it doesn't happen to map
anything upon context creation. If I understand what you mean by using a
no_error like approach correctly, I think that should definitely work, I
think we would then just somewhat-awkwardly want to pass through the
callback address as two context attributes, one for the lower and one
for the higher part of the address.
However, even if we find a way to make the mapping callback's global on
the context level, that then still requires from the driver that they
relegate mappings in these contexts to dedicated memory pools. This
might be desired, in order to allow other GL clients in the process to
continue using the full 64-bit address space, although in practice I
don't think Wine uses any libraries that create GL contexts (*other than
potentially GStreamer which we are moving away from).
If we just want to keep it simple and workaround the GL context, maybe
Wine could just export its allocator in ntdll.so in a way that where
Mesa could then directly call it when present. That way we could even
avoid the need for a GL extension that will at the end of the day
probably only be used by Wine, plus av
