On Mon, Dec 2, 2024 at 11:42 AM Srinivasan Shanmugam <srinivasan.shanmugam@xxxxxxx> wrote: > > This update adds explanations to key functions that manage how the > Kernel Fusion Driver (KFD) and Kernel Graphics Driver (KGD) share the > GPU. > > amdgpu_gfx_enforce_isolation_wait_for_kfd: Controls the waiting period > for KFD to ensure it takes turns with KGD in using the GPU. It uses a > mutex to safely manage shared data, like timing and state, and tracks > when KFD starts and stops waiting. > > amdgpu_gfx_enforce_isolation_ring_begin_use: Ensures KFD has enough time > to run before new tasks are submitted to the GPU ring. It uses a mutex > to synchronize access and may adjust the KFD scheduler. > > amdgpu_gfx_enforce_isolation_ring_end_use: Handles cleanup and state > updates when finishing the use of a GPU ring. It may also adjust the KFD > scheduler, using a mutex to manage shared data access. > > Cc: Christian König <christian.koenig@xxxxxxx> > Cc: Alex Deucher <alexander.deucher@xxxxxxx> > Signed-off-by: Srinivasan Shanmugam <srinivasan.shanmugam@xxxxxxx> > Suggested-by: Alex Deucher <alexander.deucher@xxxxxxx> Reviewed-by: Alex Deucher <alexander.deucher@xxxxxxx> > --- > v2: > - Incorporated feedbacks for function descriptions (Alex) > > drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.c | 29 +++++++++++++++++++++++++ > 1 file changed, 29 insertions(+) > > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.c > index e54f42e3797e..b1b133affbf9 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.c > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.c > @@ -1940,6 +1940,17 @@ void amdgpu_gfx_enforce_isolation_handler(struct work_struct *work) > mutex_unlock(&adev->enforce_isolation_mutex); > } > > +/** > + * amdgpu_gfx_enforce_isolation_wait_for_kfd - Manage KFD wait period for process isolation > + * @adev: amdgpu_device pointer > + * @idx: Index of the GPU partition > + * > + * When kernel submissions come in, the jobs are given a time slice and once > + * that time slice is up, if there are KFD user queues active, kernel > + * submissions are blocked until KFD has had its time slice. Once the KFD time > + * slice is up, KFD user queues are preempted and kernel submissions are > + * unblocked and allowed to run again. > + */ > static void > amdgpu_gfx_enforce_isolation_wait_for_kfd(struct amdgpu_device *adev, > u32 idx) > @@ -1985,6 +1996,15 @@ amdgpu_gfx_enforce_isolation_wait_for_kfd(struct amdgpu_device *adev, > msleep(GFX_SLICE_PERIOD_MS); > } > > +/** > + * amdgpu_gfx_enforce_isolation_ring_begin_use - Begin use of a ring with enforced isolation > + * @ring: Pointer to the amdgpu_ring structure > + * > + * Ring begin_use helper implementation for gfx which serializes access to the > + * gfx IP between kernel submission IOCTLs and KFD user queues when isolation > + * enforcement is enabled. The kernel submission IOCTLs and KFD user queues > + * each get a time slice when both are active. > + */ > void amdgpu_gfx_enforce_isolation_ring_begin_use(struct amdgpu_ring *ring) > { > struct amdgpu_device *adev = ring->adev; > @@ -2012,6 +2032,15 @@ void amdgpu_gfx_enforce_isolation_ring_begin_use(struct amdgpu_ring *ring) > mutex_unlock(&adev->enforce_isolation_mutex); > } > > +/** > + * amdgpu_gfx_enforce_isolation_ring_end_use - End use of a ring with enforced isolation > + * @ring: Pointer to the amdgpu_ring structure > + * > + * Ring end_use helper implementation for gfx which serializes access to the > + * gfx IP between kernel submission IOCTLs and KFD user queues when isolation > + * enforcement is enabled. The kernel submission IOCTLs and KFD user queues > + * each get a time slice when both are active. > + */ > void amdgpu_gfx_enforce_isolation_ring_end_use(struct amdgpu_ring *ring) > { > struct amdgpu_device *adev = ring->adev; > -- > 2.34.1 >