drm/xe: split kernel vs permanent engine flags

If an engine is only destroyed on driver unload, we can skip its
clean-up steps with the GuC because the GuC is going to be tuned off as
well, so it doesn't matter if we're in sync with it or not. Currently,
we apply this optimization to all engines marked as kernel, but this
stops us to supporting kernel engines that don't stick around until
unload. To remove this limitation, add a separate flag to indicate if
the engine is expected to only be destryed on driver unload and use that
to trigger the optimzation.

While at it, add a small comment to explain what each engine flag
represents.

v2: s/XE_BUG_ON/XE_WARN_ON, s/ENGINE/EXEC_QUEUE
v3: rebased

Signed-off-by: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Cc: Matthew Brost <matthew.brost@intel.com>
Reviewed-by: Matthew Brost <matthew.brost@intel.com>
Link: https://lore.kernel.org/r/20230822173334.1664332-3-daniele.ceraolospurio@intel.com
Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>

diff --git a/drivers/gpu/drm/xe/xe_exec_queue.c b/drivers/gpu/drm/xe/xe_exec_queue.c
index f6619688f92fd311afed52c7e1862735c42f2952..867465b0c57ba35c881887a5e687b3b50bde5e10 100644 (file)
--- a/drivers/gpu/drm/xe/xe_exec_queue.c
+++ b/drivers/gpu/drm/xe/xe_exec_queue.c
@@ -41,6 +41,9 @@ static struct xe_exec_queue *__xe_exec_queue_create(struct xe_device *xe,
        int err;
        int i;
 
+       /* only kernel queues can be permanent */
+       XE_WARN_ON((flags & EXEC_QUEUE_FLAG_PERMANENT) && !(flags & EXEC_QUEUE_FLAG_KERNEL));
+
        q = kzalloc(sizeof(*q) + sizeof(struct xe_lrc) * width, GFP_KERNEL);
        if (!q)
                return ERR_PTR(-ENOMEM);

diff --git a/drivers/gpu/drm/xe/xe_exec_queue_types.h b/drivers/gpu/drm/xe/xe_exec_queue_types.h
index 4506289b8b7bdde7aa434f3cb893e3f9c246450b..1f0051a91dae0638f67356cfd9e457fde725ebd2 100644 (file)
--- a/drivers/gpu/drm/xe/xe_exec_queue_types.h
+++ b/drivers/gpu/drm/xe/xe_exec_queue_types.h
@@ -65,14 +65,22 @@ struct xe_exec_queue {
        /** @fence_irq: fence IRQ used to signal job completion */
        struct xe_hw_fence_irq *fence_irq;
 
-#define EXEC_QUEUE_FLAG_BANNED         BIT(0)
-#define EXEC_QUEUE_FLAG_KERNEL         BIT(1)
-#define EXEC_QUEUE_FLAG_PERSISTENT             BIT(2)
-#define EXEC_QUEUE_FLAG_COMPUTE_MODE   BIT(3)
-/* Caller needs to hold rpm ref when creating engine with EXEC_QUEUE_FLAG_VM */
-#define EXEC_QUEUE_FLAG_VM                     BIT(4)
-#define EXEC_QUEUE_FLAG_BIND_ENGINE_CHILD      BIT(5)
-#define EXEC_QUEUE_FLAG_WA                     BIT(6)
+/* queue no longer allowed to submit */
+#define EXEC_QUEUE_FLAG_BANNED                 BIT(0)
+/* queue used for kernel submission only */
+#define EXEC_QUEUE_FLAG_KERNEL                 BIT(1)
+/* kernel engine only destroyed at driver unload */
+#define EXEC_QUEUE_FLAG_PERMANENT              BIT(2)
+/* queue keeps running pending jobs after destroy ioctl */
+#define EXEC_QUEUE_FLAG_PERSISTENT             BIT(3)
+/* queue for use with compute VMs */
+#define EXEC_QUEUE_FLAG_COMPUTE_MODE           BIT(4)
+/* for VM jobs. Caller needs to hold rpm ref when creating queue with this flag */
+#define EXEC_QUEUE_FLAG_VM                     BIT(5)
+/* child of VM queue for multi-tile VM jobs */
+#define EXEC_QUEUE_FLAG_BIND_ENGINE_CHILD      BIT(6)
+/* queue used for WA setup */
+#define EXEC_QUEUE_FLAG_WA                     BIT(7)
 
        /**
         * @flags: flags for this exec queue, should statically setup aside from ban

diff --git a/drivers/gpu/drm/xe/xe_guc_submit.c b/drivers/gpu/drm/xe/xe_guc_submit.c
index 87f2972b7c2086341666e4973d7661fe15825a4c..832e79fb0a025468ab11cdc54ad1b3d2215db408 100644 (file)
--- a/drivers/gpu/drm/xe/xe_guc_submit.c
+++ b/drivers/gpu/drm/xe/xe_guc_submit.c
@@ -965,7 +965,7 @@ static void guc_exec_queue_fini_async(struct xe_exec_queue *q)
        INIT_WORK(&q->guc->fini_async, __guc_exec_queue_fini_async);
 
        /* We must block on kernel engines so slabs are empty on driver unload */
-       if (q->flags & EXEC_QUEUE_FLAG_KERNEL)
+       if (q->flags & EXEC_QUEUE_FLAG_PERMANENT)
                __guc_exec_queue_fini_async(&q->guc->fini_async);
        else
                queue_work(system_wq, &q->guc->fini_async);
@@ -988,7 +988,7 @@ static void __guc_exec_queue_process_msg_cleanup(struct xe_sched_msg *msg)
        struct xe_exec_queue *q = msg->private_data;
        struct xe_guc *guc = exec_queue_to_guc(q);
 
-       XE_WARN_ON(q->flags & EXEC_QUEUE_FLAG_KERNEL);
+       XE_WARN_ON(q->flags & EXEC_QUEUE_FLAG_PERMANENT);
        trace_xe_exec_queue_cleanup_entity(q);
 
        if (exec_queue_registered(q))
@@ -1208,7 +1208,7 @@ static void guc_exec_queue_fini(struct xe_exec_queue *q)
 {
        struct xe_sched_msg *msg = q->guc->static_msgs + STATIC_MSG_CLEANUP;
 
-       if (!(q->flags & EXEC_QUEUE_FLAG_KERNEL))
+       if (!(q->flags & EXEC_QUEUE_FLAG_PERMANENT))
                guc_exec_queue_add_msg(q, msg, CLEANUP);
        else
                __guc_exec_queue_fini(exec_queue_to_guc(q), q);

diff --git a/drivers/gpu/drm/xe/xe_migrate.c b/drivers/gpu/drm/xe/xe_migrate.c
index 06e85f7162d4117a8b992c623bae47dfb7932a50..6e0d4e2c497ab1c97d40c42778010063790974b6 100644 (file)
--- a/drivers/gpu/drm/xe/xe_migrate.c
+++ b/drivers/gpu/drm/xe/xe_migrate.c
@@ -343,11 +343,14 @@ struct xe_migrate *xe_migrate_init(struct xe_tile *tile)
 
                m->q = xe_exec_queue_create(xe, vm,
                                            BIT(hwe->logical_instance), 1,
-                                           hwe, EXEC_QUEUE_FLAG_KERNEL);
+                                           hwe,
+                                           EXEC_QUEUE_FLAG_KERNEL |
+                                           EXEC_QUEUE_FLAG_PERMANENT);
        } else {
                m->q = xe_exec_queue_create_class(xe, primary_gt, vm,
                                                  XE_ENGINE_CLASS_COPY,
-                                                 EXEC_QUEUE_FLAG_KERNEL);
+                                                 EXEC_QUEUE_FLAG_KERNEL |
+                                                 EXEC_QUEUE_FLAG_PERMANENT);
        }
        if (IS_ERR(m->q)) {
                xe_vm_close_and_put(vm);