mirrors/linux
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2026-04-10 20:38:50 -04:00
Code Issues Packages Projects Releases Wiki Activity

drm/amd/amdgpu: Add Annotations to Process Isolation functions

Browse Source 
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@amd.com>
Cc: Alex Deucher <alexander.deucher@amd.com>
Signed-off-by: Srinivasan Shanmugam <srinivasan.shanmugam@amd.com>
Suggested-by: Alex Deucher <alexander.deucher@amd.com>
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>
This commit is contained in:
Srinivasan Shanmugam
2024-11-28 01:11:36 +05:30
committed by Alex Deucher
parent 57bcfa89fe
commit 55f4139b65
1 changed files with 29 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.c
View File

@@ -1985,6 +1985,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)
@@ -2030,6 +2041,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;
@@ -2057,6 +2077,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;