Re: [PATCH drm-next v2 00/16] [RFC] DRM GPUVA Manager & Nouveau VM_BIND UAPI

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]<


On 3/10/23 18:25, Boris Brezillon wrote:
Hi Danilo,

On Fri, 10 Mar 2023 17:45:58 +0100
Danilo Krummrich <dakr@xxxxxxxxxx> wrote:
Hi Boris,

On Thu, 9 Mar 2023 10:12:43 +0100
Boris Brezillon <boris.brezillon@xxxxxxxxxxxxx> wrote:

Ok, so I just noticed you only have one bind queue per drm_file
(cli->sched_entity), and jobs are executed in-order on a given queue,
so I guess that allows you to modify the VA space at submit time
without risking any modifications to the VA space coming from other
bind-queues targeting the same VM. And, if I'm correct, synchronous
bind/unbind ops take the same path, so no risk for those to modify the
VA space either (just wonder if it's a good thing to have to sync
bind/unbind operations waiting on async ones, but that's a different

Yes, that's all correct.

The page table allocation happens through nouveau_uvmm_vmm_get() which
either allocates the corresponding page tables or increases the
reference count, in case they already exist, accordingly.
The call goes all the way through nvif into the nvkm layer (not the
easiest to follow the call chain) and ends up in nvkm_vmm_ptes_get().

There are multiple reasons for updating the VA space at submit time in

1) Subsequent EXEC ioctl() calls would need to wait for the bind jobs
they depend on within the ioctl() rather than in the scheduler queue,
because at the point of time where the ioctl() happens the VA space
wouldn't be up-to-date.

Hm, actually that's what explicit sync is all about, isn't it? If you
have async binding ops, you should retrieve the bind-op out-fences and
pass them back as in-fences to the EXEC call, so you're sure all the
memory mappings you depend on are active when you execute those GPU
jobs. And if you're using sync binds, the changes are guaranteed to be
applied before the ioctl() returns. Am I missing something?

No, you're right and this is exactly how I implemented it. The difference is where to wait for the bind jobs out-fences.

In the EXEC ioctl() we need to validate the GEM objects backing the dependent mappings and add the jobs fence to the GEMs DMA reservation. If the VA space isn't up-to-date we might not be able to look up the relevant GEMs and miss them.

If the VA space change happens in the bind jobs submit path (ioctl()), it is guaranteed that the view of the VA space is up-to-date (actually it might even be ahead of the actual current state) when the EXEC ioctl() is called. Hence, I can just pass the out-fences of the binds jobs the EXEC depends on to the job scheduler and return from the ioctl(). The job scheduler will then wait for the actual mappings being populated before executing the EXEC job.

If the VA space change is done when the bind job executes on the scheduler we would need to wait for the bind jobs out-fences in the EXEC ioctl() itself.

2) Let's assume a new mapping is requested and within it's range other
mappings already exist. Let's also assume that those existing mappings
aren't contiguous, such that there are gaps between them. In such a case
I need to allocate page tables only for the gaps between the existing
mappings, or alternatively, allocate them for the whole range of the new
mapping, but free / decrease the reference count of the page tables for
the ranges of the previously existing mappings afterwards.
In the first case I need to know the gaps to allocate page tables for
when submitting the job, which means the VA space must be up-to-date. In
the latter one I must save the ranges of the previously existing
mappings somewhere in order to clean them up, hence I need to allocate
memory to store this information. Since I can't allocate this memory in
the jobs run() callback (fence signalling critical section) I need to do
it when submitting the job already and hence the VA space must be
up-to-date again.

Yep that makes perfect sense, and that explains how the whole thing can
work. When I initially read the patch series, I had more complex use
cases in mind, with multiple bind queues targeting the same VM, and
synchronous bind taking a fast path (so they don't have to wait on
async binds which can in turn wait on external deps). This model makes
it hard to predict what the VA space will look like when an async bind
operation gets to be executed, thus making page table allocation more
complex, or forcing us to over-estimate the amount of pages we need for
this update (basically one page per MMU level, except maybe the top
level, plus the number of pages you'll always need for the bind
operation itself).

However, this is due to how page table management currently works in
Nouveau and we might change that in the future.

I'm curious to hear about that if you have a bit of time. I'm starting
from scratch with pancsf, and I might consider going for something
similar to what you plan to do next.

There is no concrete plan yet. However, with the current implementation there are a few shortcomings (also in handling sparse ranges) that I'd like to address in the future.

Synchronous binds/unbinds taking the same path through the scheduler is
a downside of this approach.

Indeed. I mean, I can probably live with this limitation, but I'm
curious to know if the pg table management changes you're considering
for the future would solve that problem.

As mentioned above, I have a few ideas, but I did not think through them entirely yet.

A few thoughts though: If running synchronous binds/unbinds through the job scheduler is a concern I think it could be beneficial to (pre-)allocate page tables for newly requested mappings without the need to know whether there are existing mappings within this range already (ideally without tracking page table allocations separate from GPUVAs), such that we can update the VA space at job execution time. Same thing for freeing page tables for a range that only partially contains mappings at all. For that, reference counting page tables per mapping wouldn't really work.

On the other hand we need to consider that freeing page tables for a given range and allocating new page tables for the same or an overlapping range would need to be ordered in order to avoid races.

Anyway, thanks for taking the time to answer my question, things are
much clearer now.

I'm happy to discuss this. Feel free to also reach out in IRC, my nick is 'dakr'.


[Index of Archives]     [Linux ARM Kernel]     [Linux ARM]     [Linux Omap]     [Fedora ARM]     [IETF Annouce]     [Security]     [Bugtraq]     [Linux]     [Linux OMAP]     [Linux MIPS]     [eCos]     [Asterisk Internet PBX]     [Linux API]

  Powered by Linux