Commit fdb6a053 authored by Thomas Hellström's avatar Thomas Hellström Committed by Rodrigo Vivi
Browse files

drm/xe: Internally change the compute_mode and no_dma_fence mode naming 



The name "compute_mode" can be confusing since compute uses either this
mode or fault_mode to achieve the long-running semantics, and compute_mode
can, moving forward, enable fault_mode under the hood to work around
hardware limitations.

Also the name no_dma_fence_mode really refers to what we elsewhere call
long-running mode and the mode contrary to what its name suggests allows
dma-fences as in-fences.

So in an attempt to be more consistent, rename
no_dma_fence_mode -> lr_mode
compute_mode      -> preempt_fence_mode

And adjust flags so that

preempt_fence_mode sets XE_VM_FLAG_LR_MODE
fault_mode sets XE_VM_FLAG_LR_MODE | XE_VM_FLAG_FAULT_MODE

v2:
- Fix a typo in the commit message (Oak Zeng)

Signed-off-by: default avatarThomas Hellström <thomas.hellstrom@linux.intel.com>
Reviewed-by: default avatarOak Zeng <oak.zeng@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20231127123349.23698-1-thomas.hellstrom@linux.intel.com


Signed-off-by: default avatarRodrigo Vivi <rodrigo.vivi@intel.com>
parent d2f51c50

drivers/gpu/drm/xe/xe_exec.c

+8 −8
Original line number Diff line number Diff line
@@ -100,7 +100,7 @@ static int xe_exec_begin(struct drm_exec *exec, struct xe_vm *vm) 
	LIST_HEAD(dups);

	int err = 0;



	if (xe_vm_no_dma_fences(vm))

	if (xe_vm_in_lr_mode(vm))

		return 0;



	/*
@@ -182,7 +182,7 @@ int xe_exec_ioctl(struct drm_device *dev, void *data, struct drm_file *file) 
	for (i = 0; i < args->num_syncs; i++) {

		err = xe_sync_entry_parse(xe, xef, &syncs[num_syncs++],

					  &syncs_user[i], true,

					  xe_vm_no_dma_fences(vm));

					  xe_vm_in_lr_mode(vm));

		if (err)

			goto err_syncs;

	}
@@ -197,7 +197,7 @@ int xe_exec_ioctl(struct drm_device *dev, void *data, struct drm_file *file) 
	}



retry:

	if (!xe_vm_no_dma_fences(vm) && xe_vm_userptr_check_repin(vm)) {

	if (!xe_vm_in_lr_mode(vm) && xe_vm_userptr_check_repin(vm)) {

		err = down_write_killable(&vm->lock);

		write_locked = true;

	} else {
@@ -279,7 +279,7 @@ int xe_exec_ioctl(struct drm_device *dev, void *data, struct drm_file *file) 
	}



	/* Wait behind munmap style rebinds */

	if (!xe_vm_no_dma_fences(vm)) {

	if (!xe_vm_in_lr_mode(vm)) {

		err = drm_sched_job_add_resv_dependencies(&job->drm,

							  xe_vm_resv(vm),

							  DMA_RESV_USAGE_KERNEL);
@@ -292,7 +292,7 @@ int xe_exec_ioctl(struct drm_device *dev, void *data, struct drm_file *file) 
	if (err)

		goto err_put_job;



	if (!xe_vm_no_dma_fences(vm)) {

	if (!xe_vm_in_lr_mode(vm)) {

		err = down_read_interruptible(&vm->userptr.notifier_lock);

		if (err)

			goto err_put_job;
@@ -307,7 +307,7 @@ int xe_exec_ioctl(struct drm_device *dev, void *data, struct drm_file *file) 
	 * the job and let the DRM scheduler / backend clean up the job.

	 */

	xe_sched_job_arm(job);

	if (!xe_vm_no_dma_fences(vm)) {

	if (!xe_vm_in_lr_mode(vm)) {

		/* Block userptr invalidations / BO eviction */

		dma_resv_add_fence(xe_vm_resv(vm),

				   &job->drm.s_fence->finished,
@@ -330,14 +330,14 @@ int xe_exec_ioctl(struct drm_device *dev, void *data, struct drm_file *file) 
	xe_sched_job_push(job);

	xe_vm_reactivate_rebind(vm);



	if (!err && !xe_vm_no_dma_fences(vm)) {

	if (!err && !xe_vm_in_lr_mode(vm)) {

		spin_lock(&xe->ttm.lru_lock);

		ttm_lru_bulk_move_tail(&vm->lru_bulk_move);

		spin_unlock(&xe->ttm.lru_lock);

	}



err_repin:

	if (!xe_vm_no_dma_fences(vm))

	if (!xe_vm_in_lr_mode(vm))

		up_read(&vm->userptr.notifier_lock);

err_put_job:

	if (err)

drivers/gpu/drm/xe/xe_exec_queue.c

+4 −4
Original line number Diff line number Diff line
@@ -327,7 +327,7 @@ static int exec_queue_set_persistence(struct xe_device *xe, struct xe_exec_queue 
	if (XE_IOCTL_DBG(xe, !create))

		return -EINVAL;



	if (XE_IOCTL_DBG(xe, xe_vm_in_compute_mode(q->vm)))

	if (XE_IOCTL_DBG(xe, xe_vm_in_preempt_fence_mode(q->vm)))

		return -EINVAL;



	if (value)
@@ -705,14 +705,14 @@ int xe_exec_queue_create_ioctl(struct drm_device *dev, void *data, 


		q = xe_exec_queue_create(xe, vm, logical_mask,

					 args->width, hwe,

					 xe_vm_no_dma_fences(vm) ? 0 :

					 xe_vm_in_lr_mode(vm) ? 0 :

					 EXEC_QUEUE_FLAG_PERSISTENT);

		up_read(&vm->lock);

		xe_vm_put(vm);

		if (IS_ERR(q))

			return PTR_ERR(q);



		if (xe_vm_in_compute_mode(vm)) {

		if (xe_vm_in_preempt_fence_mode(vm)) {

			q->compute.context = dma_fence_context_alloc(1);

			spin_lock_init(&q->compute.lock);
@@ -785,7 +785,7 @@ int xe_exec_queue_get_property_ioctl(struct drm_device *dev, void *data, 
 */

bool xe_exec_queue_is_lr(struct xe_exec_queue *q)

{

	return q->vm && xe_vm_no_dma_fences(q->vm) &&

	return q->vm && xe_vm_in_lr_mode(q->vm) &&

		!(q->flags & EXEC_QUEUE_FLAG_VM);

}

drivers/gpu/drm/xe/xe_guc_submit.c

+1 −1
Original line number Diff line number Diff line
@@ -1211,7 +1211,7 @@ static int guc_exec_queue_init(struct xe_exec_queue *q) 
	ge->q = q;

	init_waitqueue_head(&ge->suspend_wait);



	timeout = (q->vm && xe_vm_no_dma_fences(q->vm)) ? MAX_SCHEDULE_TIMEOUT :

	timeout = (q->vm && xe_vm_in_lr_mode(q->vm)) ? MAX_SCHEDULE_TIMEOUT :

		  q->hwe->eclass->sched_props.job_timeout_ms;

	err = xe_sched_init(&ge->sched, &drm_sched_ops, &xe_sched_ops,

			    get_submit_wq(guc),

drivers/gpu/drm/xe/xe_pt.c

+3 −3
Original line number Diff line number Diff line
@@ -1292,8 +1292,8 @@ __xe_pt_bind_vma(struct xe_tile *tile, struct xe_vma *vma, struct xe_exec_queue 
	 * non-faulting LR, in particular on user-space batch buffer chaining,

	 * it needs to be done here.

	 */

	if ((rebind && !xe_vm_no_dma_fences(vm) && !vm->batch_invalidate_tlb) ||

	    (!rebind && vm->scratch_bo[tile->id] && xe_vm_in_compute_mode(vm))) {

	if ((rebind && !xe_vm_in_lr_mode(vm) && !vm->batch_invalidate_tlb) ||

	    (!rebind && vm->scratch_bo[tile->id] && xe_vm_in_preempt_fence_mode(vm))) {

		ifence = kzalloc(sizeof(*ifence), GFP_KERNEL);

		if (!ifence)

			return ERR_PTR(-ENOMEM);
@@ -1355,7 +1355,7 @@ __xe_pt_bind_vma(struct xe_tile *tile, struct xe_vma *vma, struct xe_exec_queue 
			xe_bo_put_commit(&deferred);

		}

		if (!rebind && last_munmap_rebind &&

		    xe_vm_in_compute_mode(vm))

		    xe_vm_in_preempt_fence_mode(vm))

			xe_vm_queue_rebind_worker(vm);

	} else {

		kfree(rfence);

drivers/gpu/drm/xe/xe_sched_job.c

+1 −1
Original line number Diff line number Diff line
@@ -92,7 +92,7 @@ struct xe_sched_job *xe_sched_job_create(struct xe_exec_queue *q, 
	/* Migration and kernel engines have their own locking */

	if (!(q->flags & (EXEC_QUEUE_FLAG_KERNEL | EXEC_QUEUE_FLAG_VM))) {

		lockdep_assert_held(&q->vm->lock);

		if (!xe_vm_no_dma_fences(q->vm))

		if (!xe_vm_in_lr_mode(q->vm))

			xe_vm_assert_held(q->vm);

	}