Skip to contentSkip to conversation

KFD queue management improvements and fixes

PATCH In review Felix Kuehling 2 participants 24 messages Sep 27, 2017 – Oct 17, 2017 14 messages not in the archive

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

cover KFD queue management improvements and fixes

These patches cherry-pick most fixes, improvements and refactoring in the device queue manager from our internal branch. I squashed some patches that applied incremental fixes to the same code. Patch 5 is the extreme case that comes with a bunch of refactoring too. I think I squashed about a dozen patches by 5 authors that all overlapped and and applied incremental fixes and improvements to process termination handling.

The last missing fixes in kfd_device_queue_manager.c are related to SDMA, which I'll leave for another patch series that also need changes in amdgpu. It will also add SDMA support for CZ. That's another 11 patches that I may be able to squash to 2 or 3.

Felix Kuehling (4):
drm/amdkfd: Fix MQD updates
drm/amdkfd: Improve process termination handling in the queue manager drm/amdkfd: Clean up process queue management
drm/amdkfd: Limit queue number per process and device to 127

Yong Zhao (4):
drm/amdkfd: Avoid name confusion involved in queue unmapping drm/amdkfd: Simplify execute and unmap queue APIs drm/amdkfd: Avoid submitting an unnecessary packet to HWS drm/amdkfd: Compress unnecessary function parameters

shaoyunl (1):
drm/amdkfd: Improve multiple SDMA queues support per process

 drivers/gpu/drm/amd/amdkfd/kfd_chardev.c           |   3 +-
 drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c            |   5 +-
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 376 ++++++++++++++-------
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.h  |   5 +
 drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c    |  27 +-
 drivers/gpu/drm/amd/amdkfd/kfd_priv.h              |  41 ++-
 drivers/gpu/drm/amd/amdkfd/kfd_process.c           |  36 +-
 .../gpu/drm/amd/amdkfd/kfd_process_queue_manager.c |  62 ++--
 8 files changed, 348 insertions(+), 207 deletions(-)
Signature · 6 lines
2.7.4

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

A message that is not in the archive (sent off-list or not yet received): 1506485396-6326-1-git-send-email-Felix.Kuehling-5C7GfCeVMHo@public.gmane.org

#2 lore raw

PATCH 1/9 drm/amdkfd: Avoid name confusion involved in queue unmapping

From: Yong Zhao <[email protected]>

When unmapping the queues from HW scheduler, there are two actions:
reset and preempt. So naming the variables with only preempt is inapproriate.

For functions such as destroy_queues_cpsch, what they do actually is to unmap the queues on HW scheduler rather than to destroy them. Change the name to reflect that fact. On the other hand, there is already a function called destroy_queue_cpsch() which exactly destroys a queue, and the name is very close to destroy_queues_cpsch(), resulting in confusion.

---
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 32 +++++++++++-----------
 drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c    | 18 ++++++------
 drivers/gpu/drm/amd/amdkfd/kfd_priv.h              | 20 +++++++-------
 3 files changed, 35 insertions(+), 35 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +16 -16
index 471b34e..1995e0a 100644
@@ -45,8 +45,8 @@ static int create_compute_queue_nocpsch(struct device_queue_manager *dqm,
 					struct qcm_process_device *qpd);
 
 static int execute_queues_cpsch(struct device_queue_manager *dqm, bool lock);
-static int destroy_queues_cpsch(struct device_queue_manager *dqm,
-				bool preempt_static_queues, bool lock);
+static int unmap_queues_cpsch(struct device_queue_manager *dqm,
+				bool static_queues_included, bool lock);
 
 static int create_sdma_queue_nocpsch(struct device_queue_manager *dqm,
 					struct queue *q,
@@ -707,7 +707,7 @@ static int start_cpsch(struct device_queue_manager *dqm)
 
 static int stop_cpsch(struct device_queue_manager *dqm)
 {
-	destroy_queues_cpsch(dqm, true, true);
+	unmap_queues_cpsch(dqm, true, true);
 
 	kfd_gtt_sa_free(dqm->dev, dqm->fence_mem);
 	pm_uninit(&dqm->packets);
@@ -750,7 +750,7 @@ static void destroy_kernel_queue_cpsch(struct device_queue_manager *dqm,
 {
 	mutex_lock(&dqm->lock);
 	/* here we actually preempt the DIQ */
-	destroy_queues_cpsch(dqm, true, false);
+	unmap_queues_cpsch(dqm, true, false);
 	list_del(&kq->list);
 	dqm->queue_count--;
 	qpd->is_debug = false;
@@ -849,19 +849,19 @@ int amdkfd_fence_wait_timeout(unsigned int *fence_addr,
 	return 0;
 }
 
-static int destroy_sdma_queues(struct device_queue_manager *dqm,
+static int unmap_sdma_queues(struct device_queue_manager *dqm,
 				unsigned int sdma_engine)
 {
 	return pm_send_unmap_queue(&dqm->packets, KFD_QUEUE_TYPE_SDMA,
-			KFD_PREEMPT_TYPE_FILTER_DYNAMIC_QUEUES, 0, false,
+			KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES, 0, false,
 			sdma_engine);
 }
 
-static int destroy_queues_cpsch(struct device_queue_manager *dqm,
-				bool preempt_static_queues, bool lock)
+static int unmap_queues_cpsch(struct device_queue_manager *dqm,
+				bool static_queues_included, bool lock)
 {
 	int retval;
-	enum kfd_preempt_type_filter preempt_type;
+	enum kfd_unmap_queues_filter filter;
 	struct kfd_process_device *pdd;
 
 	retval = 0;
@@ -875,16 +875,16 @@ static int destroy_queues_cpsch(struct device_queue_manager *dqm,
 		dqm->sdma_queue_count);
 
 	if (dqm->sdma_queue_count > 0) {
-		destroy_sdma_queues(dqm, 0);
-		destroy_sdma_queues(dqm, 1);
+		unmap_sdma_queues(dqm, 0);
+		unmap_sdma_queues(dqm, 1);
 	}
 
-	preempt_type = preempt_static_queues ?
-			KFD_PREEMPT_TYPE_FILTER_ALL_QUEUES :
-			KFD_PREEMPT_TYPE_FILTER_DYNAMIC_QUEUES;
+	filter = static_queues_included ?
+			KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES :
+			KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES;
 
 	retval = pm_send_unmap_queue(&dqm->packets, KFD_QUEUE_TYPE_COMPUTE,
-			preempt_type, 0, false, 0);
+			filter, 0, false, 0);
 	if (retval)
 		goto out;
 
@@ -916,7 +916,7 @@ static int execute_queues_cpsch(struct device_queue_manager *dqm, bool lock)
 	if (lock)
 		mutex_lock(&dqm->lock);
 
-	retval = destroy_queues_cpsch(dqm, false, false);
+	retval = unmap_queues_cpsch(dqm, false, false);
 	if (retval) {
 		pr_err("The cp might be in an unrecoverable state due to an unsuccessful queues preemption");
 		goto out;
drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c +9 -9
index 9eda884..e5a15ba 100644
@@ -476,7 +476,7 @@ int pm_send_query_status(struct packet_manager *pm, uint64_t fence_address,
 }
 
 int pm_send_unmap_queue(struct packet_manager *pm, enum kfd_queue_type type,
-			enum kfd_preempt_type_filter mode,
+			enum kfd_unmap_queues_filter filter,
 			uint32_t filter_param, bool reset,
 			unsigned int sdma_engine)
 {
@@ -494,8 +494,8 @@ int pm_send_unmap_queue(struct packet_manager *pm, enum kfd_queue_type type,
 
 	packet = (struct pm4_mes_unmap_queues *)buffer;
 	memset(buffer, 0, sizeof(struct pm4_mes_unmap_queues));
-	pr_debug("static_queue: unmapping queues: mode is %d , reset is %d , type is %d\n",
-		mode, reset, type);
+	pr_debug("static_queue: unmapping queues: filter is %d , reset is %d , type is %d\n",
+		filter, reset, type);
 	packet->header.u32All = build_pm4_header(IT_UNMAP_QUEUES,
 					sizeof(struct pm4_mes_unmap_queues));
 	switch (type) {
@@ -521,29 +521,29 @@ int pm_send_unmap_queue(struct packet_manager *pm, enum kfd_queue_type type,
 		packet->bitfields2.action =
 				action__mes_unmap_queues__preempt_queues;
 
-	switch (mode) {
-	case KFD_PREEMPT_TYPE_FILTER_SINGLE_QUEUE:
+	switch (filter) {
+	case KFD_UNMAP_QUEUES_FILTER_SINGLE_QUEUE:
 		packet->bitfields2.queue_sel =
 				queue_sel__mes_unmap_queues__perform_request_on_specified_queues;
 		packet->bitfields2.num_queues = 1;
 		packet->bitfields3b.doorbell_offset0 = filter_param;
 		break;
-	case KFD_PREEMPT_TYPE_FILTER_BY_PASID:
+	case KFD_UNMAP_QUEUES_FILTER_BY_PASID:
 		packet->bitfields2.queue_sel =
 				queue_sel__mes_unmap_queues__perform_request_on_pasid_queues;
 		packet->bitfields3a.pasid = filter_param;
 		break;
-	case KFD_PREEMPT_TYPE_FILTER_ALL_QUEUES:
+	case KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES:
 		packet->bitfields2.queue_sel =
 				queue_sel__mes_unmap_queues__unmap_all_queues;
 		break;
-	case KFD_PREEMPT_TYPE_FILTER_DYNAMIC_QUEUES:
+	case KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES:
 		/* in this case, we do not preempt static queues */
 		packet->bitfields2.queue_sel =
 				queue_sel__mes_unmap_queues__unmap_all_non_static_queues;
 		break;
 	default:
-		WARN(1, "filter %d", mode);
+		WARN(1, "filter %d", filter);
 		retval = -EINVAL;
 		goto err_invalid;
 	}
drivers/gpu/drm/amd/amdkfd/kfd_priv.h +10 -10
index 10c0626..b0a5bea 100644
@@ -225,22 +225,22 @@ void kfd_chardev_exit(void);
 struct device *kfd_chardev(void);
 
 /**
- * enum kfd_preempt_type_filter
+ * enum kfd_unmap_queues_filter
  *
- * @KFD_PREEMPT_TYPE_FILTER_SINGLE_QUEUE: Preempts single queue.
+ * @KFD_UNMAP_QUEUES_FILTER_SINGLE_QUEUE: Preempts single queue.
  *
- * @KFD_PRERMPT_TYPE_FILTER_ALL_QUEUES: Preempts all queues in the
+ * @KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES: Preempts all queues in the
  *						running queues list.
  *
- * @KFD_PRERMPT_TYPE_FILTER_BY_PASID: Preempts queues that belongs to
+ * @KFD_UNMAP_QUEUES_FILTER_BY_PASID: Preempts queues that belongs to
  *						specific process.
  *
  */
-enum kfd_preempt_type_filter {
-	KFD_PREEMPT_TYPE_FILTER_SINGLE_QUEUE,
-	KFD_PREEMPT_TYPE_FILTER_ALL_QUEUES,
-	KFD_PREEMPT_TYPE_FILTER_DYNAMIC_QUEUES,
-	KFD_PREEMPT_TYPE_FILTER_BY_PASID
+enum kfd_unmap_queues_filter {
+	KFD_UNMAP_QUEUES_FILTER_SINGLE_QUEUE,
+	KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES,
+	KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES,
+	KFD_UNMAP_QUEUES_FILTER_BY_PASID
 };
 
 /**
@@ -698,7 +698,7 @@ int pm_send_query_status(struct packet_manager *pm, uint64_t fence_address,
 				uint32_t fence_value);
 
 int pm_send_unmap_queue(struct packet_manager *pm, enum kfd_queue_type type,
-			enum kfd_preempt_type_filter mode,
+			enum kfd_unmap_queues_filter mode,
 			uint32_t filter_param, bool reset,
 			unsigned int sdma_engine);
 
Signature · 6 lines
2.7.4

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

A message that is not in the archive (sent off-list or not yet received): 1506485396-6326-2-git-send-email-Felix.Kuehling-5C7GfCeVMHo@public.gmane.org

Reviewed-by
#4 lore raw

Re: [PATCH 1/9] drm/amdkfd: Avoid name confusion involved in queue unmapping

Quoted 216 lines · Felix Kuehling

From: Yong Zhao <[email protected]>

When unmapping the queues from HW scheduler, there are two actions:
reset and preempt. So naming the variables with only preempt is inapproriate.

For functions such as destroy_queues_cpsch, what they do actually is to unmap the queues on HW scheduler rather than to destroy them. Change the name to reflect that fact. On the other hand, there is already a function called destroy_queue_cpsch() which exactly destroys a queue, and the name is very close to destroy_queues_cpsch(), resulting in confusion.

---
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 32 +++++++++++-----------
 drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c    | 18 ++++++------
 drivers/gpu/drm/amd/amdkfd/kfd_priv.h              | 20 +++++++-------
 3 files changed, 35 insertions(+), 35 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +16 -16
index 471b34e..1995e0a 100644
@@ -45,8 +45,8 @@ static int create_compute_queue_nocpsch(struct device_queue_manager *dqm,
                                        struct qcm_process_device *qpd);
 
 static int execute_queues_cpsch(struct device_queue_manager *dqm, bool lock);
-static int destroy_queues_cpsch(struct device_queue_manager *dqm,
-                               bool preempt_static_queues, bool lock);
+static int unmap_queues_cpsch(struct device_queue_manager *dqm,
+                               bool static_queues_included, bool lock);
 
 static int create_sdma_queue_nocpsch(struct device_queue_manager *dqm,
                                        struct queue *q,
@@ -707,7 +707,7 @@ static int start_cpsch(struct device_queue_manager *dqm)
 
 static int stop_cpsch(struct device_queue_manager *dqm)
 {
-       destroy_queues_cpsch(dqm, true, true);
+       unmap_queues_cpsch(dqm, true, true);
 
        kfd_gtt_sa_free(dqm->dev, dqm->fence_mem);
        pm_uninit(&dqm->packets);
@@ -750,7 +750,7 @@ static void destroy_kernel_queue_cpsch(struct device_queue_manager *dqm,
 {
        mutex_lock(&dqm->lock);
        /* here we actually preempt the DIQ */
-       destroy_queues_cpsch(dqm, true, false);
+       unmap_queues_cpsch(dqm, true, false);
        list_del(&kq->list);
        dqm->queue_count--;
        qpd->is_debug = false;
@@ -849,19 +849,19 @@ int amdkfd_fence_wait_timeout(unsigned int *fence_addr,
        return 0;
 }
 
-static int destroy_sdma_queues(struct device_queue_manager *dqm,
+static int unmap_sdma_queues(struct device_queue_manager *dqm,
                                unsigned int sdma_engine)
 {
        return pm_send_unmap_queue(&dqm->packets, KFD_QUEUE_TYPE_SDMA,
-                       KFD_PREEMPT_TYPE_FILTER_DYNAMIC_QUEUES, 0, false,
+                       KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES, 0, false,
                        sdma_engine);
 }
 
-static int destroy_queues_cpsch(struct device_queue_manager *dqm,
-                               bool preempt_static_queues, bool lock)
+static int unmap_queues_cpsch(struct device_queue_manager *dqm,
+                               bool static_queues_included, bool lock)
 {
        int retval;
-       enum kfd_preempt_type_filter preempt_type;
+       enum kfd_unmap_queues_filter filter;
        struct kfd_process_device *pdd;
 
        retval = 0;
@@ -875,16 +875,16 @@ static int destroy_queues_cpsch(struct device_queue_manager *dqm,
                dqm->sdma_queue_count);
 
        if (dqm->sdma_queue_count > 0) {
-               destroy_sdma_queues(dqm, 0);
-               destroy_sdma_queues(dqm, 1);
+               unmap_sdma_queues(dqm, 0);
+               unmap_sdma_queues(dqm, 1);
        }
 
-       preempt_type = preempt_static_queues ?
-                       KFD_PREEMPT_TYPE_FILTER_ALL_QUEUES :
-                       KFD_PREEMPT_TYPE_FILTER_DYNAMIC_QUEUES;
+       filter = static_queues_included ?
+                       KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES :
+                       KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES;
 
        retval = pm_send_unmap_queue(&dqm->packets, KFD_QUEUE_TYPE_COMPUTE,
-                       preempt_type, 0, false, 0);
+                       filter, 0, false, 0);
        if (retval)
                goto out;
 
@@ -916,7 +916,7 @@ static int execute_queues_cpsch(struct device_queue_manager *dqm, bool lock)
        if (lock)
                mutex_lock(&dqm->lock);
 
-       retval = destroy_queues_cpsch(dqm, false, false);
+       retval = unmap_queues_cpsch(dqm, false, false);
        if (retval) {
                pr_err("The cp might be in an unrecoverable state due to an unsuccessful queues preemption");
                goto out;
drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c +9 -9
index 9eda884..e5a15ba 100644
@@ -476,7 +476,7 @@ int pm_send_query_status(struct packet_manager *pm, uint64_t fence_address,
 }
 
 int pm_send_unmap_queue(struct packet_manager *pm, enum kfd_queue_type type,
-                       enum kfd_preempt_type_filter mode,
+                       enum kfd_unmap_queues_filter filter,
                        uint32_t filter_param, bool reset,
                        unsigned int sdma_engine)
 {
@@ -494,8 +494,8 @@ int pm_send_unmap_queue(struct packet_manager *pm, enum kfd_queue_type type,
 
        packet = (struct pm4_mes_unmap_queues *)buffer;
        memset(buffer, 0, sizeof(struct pm4_mes_unmap_queues));
-       pr_debug("static_queue: unmapping queues: mode is %d , reset is %d , type is %d\n",
-               mode, reset, type);
+       pr_debug("static_queue: unmapping queues: filter is %d , reset is %d , type is %d\n",
+               filter, reset, type);
        packet->header.u32All = build_pm4_header(IT_UNMAP_QUEUES,
                                        sizeof(struct pm4_mes_unmap_queues));
        switch (type) {
@@ -521,29 +521,29 @@ int pm_send_unmap_queue(struct packet_manager *pm, enum kfd_queue_type type,
                packet->bitfields2.action =
                                action__mes_unmap_queues__preempt_queues;
 
-       switch (mode) {
-       case KFD_PREEMPT_TYPE_FILTER_SINGLE_QUEUE:
+       switch (filter) {
+       case KFD_UNMAP_QUEUES_FILTER_SINGLE_QUEUE:
                packet->bitfields2.queue_sel =
                                queue_sel__mes_unmap_queues__perform_request_on_specified_queues;
                packet->bitfields2.num_queues = 1;
                packet->bitfields3b.doorbell_offset0 = filter_param;
                break;
-       case KFD_PREEMPT_TYPE_FILTER_BY_PASID:
+       case KFD_UNMAP_QUEUES_FILTER_BY_PASID:
                packet->bitfields2.queue_sel =
                                queue_sel__mes_unmap_queues__perform_request_on_pasid_queues;
                packet->bitfields3a.pasid = filter_param;
                break;
-       case KFD_PREEMPT_TYPE_FILTER_ALL_QUEUES:
+       case KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES:
                packet->bitfields2.queue_sel =
                                queue_sel__mes_unmap_queues__unmap_all_queues;
                break;
-       case KFD_PREEMPT_TYPE_FILTER_DYNAMIC_QUEUES:
+       case KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES:
                /* in this case, we do not preempt static queues */
                packet->bitfields2.queue_sel =
                                queue_sel__mes_unmap_queues__unmap_all_non_static_queues;
                break;
        default:
-               WARN(1, "filter %d", mode);
+               WARN(1, "filter %d", filter);
                retval = -EINVAL;
                goto err_invalid;
        }
drivers/gpu/drm/amd/amdkfd/kfd_priv.h +10 -11
index 10c0626..b0a5bea 100644
@@ -225,22 +225,22 @@ void kfd_chardev_exit(void);
 struct device *kfd_chardev(void);
 
 /**
- * enum kfd_preempt_type_filter
+ * enum kfd_unmap_queues_filter
  *
- * @KFD_PREEMPT_TYPE_FILTER_SINGLE_QUEUE: Preempts single queue.
+ * @KFD_UNMAP_QUEUES_FILTER_SINGLE_QUEUE: Preempts single queue.
  *
- * @KFD_PRERMPT_TYPE_FILTER_ALL_QUEUES: Preempts all queues in the
+ * @KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES: Preempts all queues in the
  *                                             running queues list.
  *
- * @KFD_PRERMPT_TYPE_FILTER_BY_PASID: Preempts queues that belongs to
+ * @KFD_UNMAP_QUEUES_FILTER_BY_PASID: Preempts queues that belongs to
  *                                             specific process.
  *
  */
-enum kfd_preempt_type_filter {
-       KFD_PREEMPT_TYPE_FILTER_SINGLE_QUEUE,
-       KFD_PREEMPT_TYPE_FILTER_ALL_QUEUES,
-       KFD_PREEMPT_TYPE_FILTER_DYNAMIC_QUEUES,
-       KFD_PREEMPT_TYPE_FILTER_BY_PASID
+enum kfd_unmap_queues_filter {
+       KFD_UNMAP_QUEUES_FILTER_SINGLE_QUEUE,
+       KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES,
+       KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES,
+       KFD_UNMAP_QUEUES_FILTER_BY_PASID
 };
 
 /**
@@ -698,7 +698,7 @@ int pm_send_query_status(struct packet_manager *pm, uint64_t fence_address,
                                uint32_t fence_value);
 
 int pm_send_unmap_queue(struct packet_manager *pm, enum kfd_queue_type type,
-                       enum kfd_preempt_type_filter mode,
+                       enum kfd_unmap_queues_filter mode,
                        uint32_t filter_param, bool reset,
                        unsigned int sdma_engine);
 
--
Quoted 2 lines

2.7.4

This patch is:

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

#5 lore raw

PATCH 2/9 drm/amdkfd: Simplify execute and unmap queue APIs

In reply to a message not in the archive

From: Yong Zhao <[email protected]>

Pass filter parameters directly to unmap_queues_cpsch.

Also remove lock parameters and do locking explicitly in the caller.

---
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 75 +++++++++-------------
 1 file changed, 32 insertions(+), 43 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +32 -43
index 1995e0a..be925a4 100644
@@ -44,9 +44,10 @@ static int create_compute_queue_nocpsch(struct device_queue_manager *dqm,
 					struct queue *q,
 					struct qcm_process_device *qpd);
 
-static int execute_queues_cpsch(struct device_queue_manager *dqm, bool lock);
+static int execute_queues_cpsch(struct device_queue_manager *dqm);
 static int unmap_queues_cpsch(struct device_queue_manager *dqm,
-				bool static_queues_included, bool lock);
+				enum kfd_unmap_queues_filter filter,
+				uint32_t filter_param);
 
 static int create_sdma_queue_nocpsch(struct device_queue_manager *dqm,
 					struct queue *q,
@@ -379,7 +380,7 @@ static int update_queue(struct device_queue_manager *dqm, struct queue *q)
 		dqm->queue_count--;
 
 	if (sched_policy != KFD_SCHED_POLICY_NO_HWS)
-		retval = execute_queues_cpsch(dqm, false);
+		retval = execute_queues_cpsch(dqm);
 
 out_unlock:
 	mutex_unlock(&dqm->lock);
@@ -695,7 +696,9 @@ static int start_cpsch(struct device_queue_manager *dqm)
 
 	init_interrupts(dqm);
 
-	execute_queues_cpsch(dqm, true);
+	mutex_lock(&dqm->lock);
+	execute_queues_cpsch(dqm);
+	mutex_unlock(&dqm->lock);
 
 	return 0;
 fail_allocate_vidmem:
@@ -707,7 +710,9 @@ static int start_cpsch(struct device_queue_manager *dqm)
 
 static int stop_cpsch(struct device_queue_manager *dqm)
 {
-	unmap_queues_cpsch(dqm, true, true);
+	mutex_lock(&dqm->lock);
+	unmap_queues_cpsch(dqm, KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES, 0);
+	mutex_unlock(&dqm->lock);
 
 	kfd_gtt_sa_free(dqm->dev, dqm->fence_mem);
 	pm_uninit(&dqm->packets);
@@ -738,7 +743,7 @@ static int create_kernel_queue_cpsch(struct device_queue_manager *dqm,
 	list_add(&kq->list, &qpd->priv_queue_list);
 	dqm->queue_count++;
 	qpd->is_debug = true;
-	execute_queues_cpsch(dqm, false);
+	execute_queues_cpsch(dqm);
 	mutex_unlock(&dqm->lock);
 
 	return 0;
@@ -750,11 +755,11 @@ static void destroy_kernel_queue_cpsch(struct device_queue_manager *dqm,
 {
 	mutex_lock(&dqm->lock);
 	/* here we actually preempt the DIQ */
-	unmap_queues_cpsch(dqm, true, false);
+	unmap_queues_cpsch(dqm, KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES, 0);
 	list_del(&kq->list);
 	dqm->queue_count--;
 	qpd->is_debug = false;
-	execute_queues_cpsch(dqm, false);
+	execute_queues_cpsch(dqm);
 	/*
 	 * Unconditionally decrement this counter, regardless of the queue's
 	 * type.
@@ -813,7 +818,7 @@ static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q,
 	list_add(&q->list, &qpd->queues_list);
 	if (q->properties.is_active) {
 		dqm->queue_count++;
-		retval = execute_queues_cpsch(dqm, false);
+		retval = execute_queues_cpsch(dqm);
 	}
 
 	if (q->properties.type == KFD_QUEUE_TYPE_SDMA)
@@ -857,19 +862,18 @@ static int unmap_sdma_queues(struct device_queue_manager *dqm,
 			sdma_engine);
 }
 
+/* dqm->lock mutex has to be locked before calling this function */
 static int unmap_queues_cpsch(struct device_queue_manager *dqm,
-				bool static_queues_included, bool lock)
+				enum kfd_unmap_queues_filter filter,
+				uint32_t filter_param)
 {
 	int retval;
-	enum kfd_unmap_queues_filter filter;
 	struct kfd_process_device *pdd;
 
 	retval = 0;
 
-	if (lock)
-		mutex_lock(&dqm->lock);
 	if (!dqm->active_runlist)
-		goto out;
+		return retval;
 
 	pr_debug("Before destroying queues, sdma queue count is : %u\n",
 		dqm->sdma_queue_count);
@@ -879,14 +883,10 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
 		unmap_sdma_queues(dqm, 1);
 	}
 
-	filter = static_queues_included ?
-			KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES :
-			KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES;
-
 	retval = pm_send_unmap_queue(&dqm->packets, KFD_QUEUE_TYPE_COMPUTE,
-			filter, 0, false, 0);
+			filter, filter_param, false, 0);
 	if (retval)
-		goto out;
+		return retval;
 
 	*dqm->fence_addr = KFD_FENCE_INIT;
 	pm_send_query_status(&dqm->packets, dqm->fence_gpu_addr,
@@ -898,50 +898,39 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
 		pdd = kfd_get_process_device_data(dqm->dev,
 				kfd_get_process(current));
 		pdd->reset_wavefronts = true;
-		goto out;
+		return retval;
 	}
 	pm_release_ib(&dqm->packets);
 	dqm->active_runlist = false;
 
-out:
-	if (lock)
-		mutex_unlock(&dqm->lock);
 	return retval;
 }
 
-static int execute_queues_cpsch(struct device_queue_manager *dqm, bool lock)
+/* dqm->lock mutex has to be locked before calling this function */
+static int execute_queues_cpsch(struct device_queue_manager *dqm)
 {
 	int retval;
 
-	if (lock)
-		mutex_lock(&dqm->lock);
-
-	retval = unmap_queues_cpsch(dqm, false, false);
+	retval = unmap_queues_cpsch(dqm, KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES,
+			0);
 	if (retval) {
 		pr_err("The cp might be in an unrecoverable state due to an unsuccessful queues preemption");
-		goto out;
+		return retval;
 	}
 
-	if (dqm->queue_count <= 0 || dqm->processes_count <= 0) {
-		retval = 0;
-		goto out;
-	}
+	if (dqm->queue_count <= 0 || dqm->processes_count <= 0)
+		return 0;
 
-	if (dqm->active_runlist) {
-		retval = 0;
-		goto out;
-	}
+	if (dqm->active_runlist)
+		return 0;
 
 	retval = pm_send_runlist(&dqm->packets, &dqm->queues);
 	if (retval) {
 		pr_err("failed to execute runlist");
-		goto out;
+		return retval;
 	}
 	dqm->active_runlist = true;
 
-out:
-	if (lock)
-		mutex_unlock(&dqm->lock);
 	return retval;
 }
 
@@ -984,7 +973,7 @@ static int destroy_queue_cpsch(struct device_queue_manager *dqm,
 	if (q->properties.is_active)
 		dqm->queue_count--;
 
-	execute_queues_cpsch(dqm, false);
+	execute_queues_cpsch(dqm);
 
 	mqd->uninit_mqd(mqd, q->mqd, q->mqd_mem_obj);
 
Signature · 6 lines
2.7.4

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

A message that is not in the archive (sent off-list or not yet received): 1506485396-6326-3-git-send-email-Felix.Kuehling-5C7GfCeVMHo@public.gmane.org

#7 lore raw

Re: [PATCH 2/9] drm/amdkfd: Simplify execute and unmap queue APIs

Quoted 205 lines · Felix Kuehling

From: Yong Zhao <[email protected]>

Pass filter parameters directly to unmap_queues_cpsch.

Also remove lock parameters and do locking explicitly in the caller.

---
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 75 +++++++++-------------
 1 file changed, 32 insertions(+), 43 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +32 -44
index 1995e0a..be925a4 100644
@@ -44,9 +44,10 @@ static int create_compute_queue_nocpsch(struct device_queue_manager *dqm,
                                        struct queue *q,
                                        struct qcm_process_device *qpd);
 
-static int execute_queues_cpsch(struct device_queue_manager *dqm, bool lock);
+static int execute_queues_cpsch(struct device_queue_manager *dqm);
 static int unmap_queues_cpsch(struct device_queue_manager *dqm,
-                               bool static_queues_included, bool lock);
+                               enum kfd_unmap_queues_filter filter,
+                               uint32_t filter_param);
 
 static int create_sdma_queue_nocpsch(struct device_queue_manager *dqm,
                                        struct queue *q,
@@ -379,7 +380,7 @@ static int update_queue(struct device_queue_manager *dqm, struct queue *q)
                dqm->queue_count--;
 
        if (sched_policy != KFD_SCHED_POLICY_NO_HWS)
-               retval = execute_queues_cpsch(dqm, false);
+               retval = execute_queues_cpsch(dqm);
 
 out_unlock:
        mutex_unlock(&dqm->lock);
@@ -695,7 +696,9 @@ static int start_cpsch(struct device_queue_manager *dqm)
 
        init_interrupts(dqm);
 
-       execute_queues_cpsch(dqm, true);
+       mutex_lock(&dqm->lock);
+       execute_queues_cpsch(dqm);
+       mutex_unlock(&dqm->lock);
 
        return 0;
 fail_allocate_vidmem:
@@ -707,7 +710,9 @@ static int start_cpsch(struct device_queue_manager *dqm)
 
 static int stop_cpsch(struct device_queue_manager *dqm)
 {
-       unmap_queues_cpsch(dqm, true, true);
+       mutex_lock(&dqm->lock);
+       unmap_queues_cpsch(dqm, KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES, 0);
+       mutex_unlock(&dqm->lock);
 
        kfd_gtt_sa_free(dqm->dev, dqm->fence_mem);
        pm_uninit(&dqm->packets);
@@ -738,7 +743,7 @@ static int create_kernel_queue_cpsch(struct device_queue_manager *dqm,
        list_add(&kq->list, &qpd->priv_queue_list);
        dqm->queue_count++;
        qpd->is_debug = true;
-       execute_queues_cpsch(dqm, false);
+       execute_queues_cpsch(dqm);
        mutex_unlock(&dqm->lock);
 
        return 0;
@@ -750,11 +755,11 @@ static void destroy_kernel_queue_cpsch(struct device_queue_manager *dqm,
 {
        mutex_lock(&dqm->lock);
        /* here we actually preempt the DIQ */
-       unmap_queues_cpsch(dqm, true, false);
+       unmap_queues_cpsch(dqm, KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES, 0);
        list_del(&kq->list);
        dqm->queue_count--;
        qpd->is_debug = false;
-       execute_queues_cpsch(dqm, false);
+       execute_queues_cpsch(dqm);
        /*
         * Unconditionally decrement this counter, regardless of the queue's
         * type.
@@ -813,7 +818,7 @@ static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q,
        list_add(&q->list, &qpd->queues_list);
        if (q->properties.is_active) {
                dqm->queue_count++;
-               retval = execute_queues_cpsch(dqm, false);
+               retval = execute_queues_cpsch(dqm);
        }
 
        if (q->properties.type == KFD_QUEUE_TYPE_SDMA)
@@ -857,19 +862,18 @@ static int unmap_sdma_queues(struct device_queue_manager *dqm,
                        sdma_engine);
 }
 
+/* dqm->lock mutex has to be locked before calling this function */
 static int unmap_queues_cpsch(struct device_queue_manager *dqm,
-                               bool static_queues_included, bool lock)
+                               enum kfd_unmap_queues_filter filter,
+                               uint32_t filter_param)
 {
        int retval;
-       enum kfd_unmap_queues_filter filter;
        struct kfd_process_device *pdd;
 
        retval = 0;
 
-       if (lock)
-               mutex_lock(&dqm->lock);
        if (!dqm->active_runlist)
-               goto out;
+               return retval;
 
        pr_debug("Before destroying queues, sdma queue count is : %u\n",
                dqm->sdma_queue_count);
@@ -879,14 +883,10 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
                unmap_sdma_queues(dqm, 1);
        }
 
-       filter = static_queues_included ?
-                       KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES :
-                       KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES;
-
        retval = pm_send_unmap_queue(&dqm->packets, KFD_QUEUE_TYPE_COMPUTE,
-                       filter, 0, false, 0);
+                       filter, filter_param, false, 0);
        if (retval)
-               goto out;
+               return retval;
 
        *dqm->fence_addr = KFD_FENCE_INIT;
        pm_send_query_status(&dqm->packets, dqm->fence_gpu_addr,
@@ -898,50 +898,39 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
                pdd = kfd_get_process_device_data(dqm->dev,
                                kfd_get_process(current));
                pdd->reset_wavefronts = true;
-               goto out;
+               return retval;
        }
        pm_release_ib(&dqm->packets);
        dqm->active_runlist = false;
 
-out:
-       if (lock)
-               mutex_unlock(&dqm->lock);
        return retval;
 }
 
-static int execute_queues_cpsch(struct device_queue_manager *dqm, bool lock)
+/* dqm->lock mutex has to be locked before calling this function */
+static int execute_queues_cpsch(struct device_queue_manager *dqm)
 {
        int retval;
 
-       if (lock)
-               mutex_lock(&dqm->lock);
-
-       retval = unmap_queues_cpsch(dqm, false, false);
+       retval = unmap_queues_cpsch(dqm, KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES,
+                       0);
        if (retval) {
                pr_err("The cp might be in an unrecoverable state due to an unsuccessful queues preemption");
-               goto out;
+               return retval;
        }
 
-       if (dqm->queue_count <= 0 || dqm->processes_count <= 0) {
-               retval = 0;
-               goto out;
-       }
+       if (dqm->queue_count <= 0 || dqm->processes_count <= 0)
+               return 0;
 
-       if (dqm->active_runlist) {
-               retval = 0;
-               goto out;
-       }
+       if (dqm->active_runlist)
+               return 0;
 
        retval = pm_send_runlist(&dqm->packets, &dqm->queues);
        if (retval) {
                pr_err("failed to execute runlist");
-               goto out;
+               return retval;
        }
        dqm->active_runlist = true;
 
-out:
-       if (lock)
-               mutex_unlock(&dqm->lock);
        return retval;
 }
 
@@ -984,7 +973,7 @@ static int destroy_queue_cpsch(struct device_queue_manager *dqm,
        if (q->properties.is_active)
                dqm->queue_count--;
 
-       execute_queues_cpsch(dqm, false);
+       execute_queues_cpsch(dqm);
 
        mqd->uninit_mqd(mqd, q->mqd, q->mqd_mem_obj);
 
--
Quoted 2 lines

2.7.4

This patch is basically fine, but it actually contains two separate changes that are not related to each other. It makes the patch hard to understand and follow and makes future bisecting harder. Therefore, I took the patch but split it to two patches. Please tell me if you have any objection.

Oded
_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

A message that is not in the archive (sent off-list or not yet received): CAFCwf11tnqjDPVUyCTyzHMqmhTCQ3DXnQLOeDQ3H+CZ2iDzs1g-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org

#9 lore raw

Re: [PATCH 2/9] drm/amdkfd: Simplify execute and unmap queue APIs

Quoted 5 lines · Oded Gabbay

This patch is basically fine, but it actually contains two separate changes that are not related to each other. It makes the patch hard to understand and follow and makes future bisecting harder. Therefore, I took the patch but split it to two patches. Please tell me if you have any objection.

No problem, thanks. I think it was laziness on my part. Since the patches affected the same unmap interface, it was easier to squash them and resolve the conflicts only once.

Regards,
  Felix

Quoted 2 lines

Oded

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

#10 lore raw

PATCH 3/9 drm/amdkfd: Fix MQD updates

In reply to a message not in the archive

When a queue is mapped, the MQD is owned by the FW. The FW overwrites the MQD on the next unmap operation. Therefore the queue must be unmapped before updating the MQD.

For the non-HWS case, also fix disabling of queues and creation of queues in disabled state.

---
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 84 ++++++++++++++++------
 1 file changed, 62 insertions(+), 22 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +62 -22
index be925a4..dccb493 100644
@@ -49,6 +49,8 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
 				enum kfd_unmap_queues_filter filter,
 				uint32_t filter_param);
 
+static int map_queues_cpsch(struct device_queue_manager *dqm);
+
 static int create_sdma_queue_nocpsch(struct device_queue_manager *dqm,
 					struct queue *q,
 					struct qcm_process_device *qpd);
@@ -274,6 +276,9 @@ static int create_compute_queue_nocpsch(struct device_queue_manager *dqm,
 	dqm->dev->kfd2kgd->set_scratch_backing_va(
 			dqm->dev->kgd, qpd->sh_hidden_private_base, qpd->vmid);
 
+	if (!q->properties.is_active)
+		return 0;
+
 	retval = mqd->load_mqd(mqd, q->mqd, q->pipe, q->queue, &q->properties,
 			       q->process->mm);
 	if (retval)
@@ -365,23 +370,50 @@ static int update_queue(struct device_queue_manager *dqm, struct queue *q)
 		goto out_unlock;
 	}
 
-	if (q->properties.is_active)
-		prev_active = true;
+	/* Save previous activity state for counters */
+	prev_active = q->properties.is_active;
+
+	/* Make sure the queue is unmapped before updating the MQD */
+	if (sched_policy != KFD_SCHED_POLICY_NO_HWS) {
+		retval = unmap_queues_cpsch(dqm,
+				KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES, 0);
+		if (retval != 0) {
+			pr_err("unmap queue failed\n");
+			goto out_unlock;
+		}
+	} else if (sched_policy == KFD_SCHED_POLICY_NO_HWS &&
+		   prev_active &&
+		   (q->properties.type == KFD_QUEUE_TYPE_COMPUTE ||
+		    q->properties.type == KFD_QUEUE_TYPE_SDMA)) {
+		retval = mqd->destroy_mqd(mqd, q->mqd,
+				KFD_PREEMPT_TYPE_WAVEFRONT_DRAIN,
+				KFD_UNMAP_LATENCY_MS, q->pipe, q->queue);
+		if (retval) {
+			pr_err("destroy mqd failed\n");
+			goto out_unlock;
+		}
+	}
+
+	retval = mqd->update_mqd(mqd, q->mqd, &q->properties);
+
+	if (sched_policy != KFD_SCHED_POLICY_NO_HWS)
+		retval = map_queues_cpsch(dqm);
+	else if (sched_policy == KFD_SCHED_POLICY_NO_HWS &&
+		 q->properties.is_active &&
+		 (q->properties.type == KFD_QUEUE_TYPE_COMPUTE ||
+		  q->properties.type == KFD_QUEUE_TYPE_SDMA))
+		retval = mqd->load_mqd(mqd, q->mqd, q->pipe, q->queue,
+				       &q->properties, q->process->mm);
 
 	/*
-	 *
 	 * check active state vs. the previous state
 	 * and modify counter accordingly
 	 */
-	retval = mqd->update_mqd(mqd, q->mqd, &q->properties);
-	if ((q->properties.is_active) && (!prev_active))
+	if (q->properties.is_active && !prev_active)
 		dqm->queue_count++;
 	else if (!q->properties.is_active && prev_active)
 		dqm->queue_count--;
 
-	if (sched_policy != KFD_SCHED_POLICY_NO_HWS)
-		retval = execute_queues_cpsch(dqm);
-
 out_unlock:
 	mutex_unlock(&dqm->lock);
 	return retval;
@@ -863,6 +895,27 @@ static int unmap_sdma_queues(struct device_queue_manager *dqm,
 }
 
 /* dqm->lock mutex has to be locked before calling this function */
+static int map_queues_cpsch(struct device_queue_manager *dqm)
+{
+	int retval;
+
+	if (dqm->queue_count <= 0 || dqm->processes_count <= 0)
+		return 0;
+
+	if (dqm->active_runlist)
+		return 0;
+
+	retval = pm_send_runlist(&dqm->packets, &dqm->queues);
+	if (retval) {
+		pr_err("failed to execute runlist\n");
+		return retval;
+	}
+	dqm->active_runlist = true;
+
+	return retval;
+}
+
+/* dqm->lock mutex has to be locked before calling this function */
 static int unmap_queues_cpsch(struct device_queue_manager *dqm,
 				enum kfd_unmap_queues_filter filter,
 				uint32_t filter_param)
@@ -918,20 +971,7 @@ static int execute_queues_cpsch(struct device_queue_manager *dqm)
 		return retval;
 	}
 
-	if (dqm->queue_count <= 0 || dqm->processes_count <= 0)
-		return 0;
-
-	if (dqm->active_runlist)
-		return 0;
-
-	retval = pm_send_runlist(&dqm->packets, &dqm->queues);
-	if (retval) {
-		pr_err("failed to execute runlist");
-		return retval;
-	}
-	dqm->active_runlist = true;
-
-	return retval;
+	return map_queues_cpsch(dqm);
 }
 
 static int destroy_queue_cpsch(struct device_queue_manager *dqm,
Signature · 6 lines
2.7.4

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

A message that is not in the archive (sent off-list or not yet received): 1506485396-6326-4-git-send-email-Felix.Kuehling-5C7GfCeVMHo@public.gmane.org

#12 lore raw

Re: [PATCH 3/9] drm/amdkfd: Fix MQD updates

Quoted 146 lines · Felix Kuehling

When a queue is mapped, the MQD is owned by the FW. The FW overwrites the MQD on the next unmap operation. Therefore the queue must be unmapped before updating the MQD.

For the non-HWS case, also fix disabling of queues and creation of queues in disabled state.

---
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 84 ++++++++++++++++------
 1 file changed, 62 insertions(+), 22 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +62 -23
index be925a4..dccb493 100644
@@ -49,6 +49,8 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
                                enum kfd_unmap_queues_filter filter,
                                uint32_t filter_param);
 
+static int map_queues_cpsch(struct device_queue_manager *dqm);
+
 static int create_sdma_queue_nocpsch(struct device_queue_manager *dqm,
                                        struct queue *q,
                                        struct qcm_process_device *qpd);
@@ -274,6 +276,9 @@ static int create_compute_queue_nocpsch(struct device_queue_manager *dqm,
        dqm->dev->kfd2kgd->set_scratch_backing_va(
                        dqm->dev->kgd, qpd->sh_hidden_private_base, qpd->vmid);
 
+       if (!q->properties.is_active)
+               return 0;
+
        retval = mqd->load_mqd(mqd, q->mqd, q->pipe, q->queue, &q->properties,
                               q->process->mm);
        if (retval)
@@ -365,23 +370,50 @@ static int update_queue(struct device_queue_manager *dqm, struct queue *q)
                goto out_unlock;
        }
 
-       if (q->properties.is_active)
-               prev_active = true;
+       /* Save previous activity state for counters */
+       prev_active = q->properties.is_active;
+
+       /* Make sure the queue is unmapped before updating the MQD */
+       if (sched_policy != KFD_SCHED_POLICY_NO_HWS) {
+               retval = unmap_queues_cpsch(dqm,
+                               KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES, 0);
+               if (retval != 0) {
+                       pr_err("unmap queue failed\n");
+                       goto out_unlock;
+               }
+       } else if (sched_policy == KFD_SCHED_POLICY_NO_HWS &&
+                  prev_active &&
+                  (q->properties.type == KFD_QUEUE_TYPE_COMPUTE ||
+                   q->properties.type == KFD_QUEUE_TYPE_SDMA)) {
+               retval = mqd->destroy_mqd(mqd, q->mqd,
+                               KFD_PREEMPT_TYPE_WAVEFRONT_DRAIN,
+                               KFD_UNMAP_LATENCY_MS, q->pipe, q->queue);
+               if (retval) {
+                       pr_err("destroy mqd failed\n");
+                       goto out_unlock;
+               }
+       }
+
+       retval = mqd->update_mqd(mqd, q->mqd, &q->properties);
+
+       if (sched_policy != KFD_SCHED_POLICY_NO_HWS)
+               retval = map_queues_cpsch(dqm);
+       else if (sched_policy == KFD_SCHED_POLICY_NO_HWS &&
+                q->properties.is_active &&
+                (q->properties.type == KFD_QUEUE_TYPE_COMPUTE ||
+                 q->properties.type == KFD_QUEUE_TYPE_SDMA))
+               retval = mqd->load_mqd(mqd, q->mqd, q->pipe, q->queue,
+                                      &q->properties, q->process->mm);
 
        /*
-        *
         * check active state vs. the previous state
         * and modify counter accordingly
         */
-       retval = mqd->update_mqd(mqd, q->mqd, &q->properties);
-       if ((q->properties.is_active) && (!prev_active))
+       if (q->properties.is_active && !prev_active)
                dqm->queue_count++;
        else if (!q->properties.is_active && prev_active)
                dqm->queue_count--;
 
-       if (sched_policy != KFD_SCHED_POLICY_NO_HWS)
-               retval = execute_queues_cpsch(dqm);
-
 out_unlock:
        mutex_unlock(&dqm->lock);
        return retval;
@@ -863,6 +895,27 @@ static int unmap_sdma_queues(struct device_queue_manager *dqm,
 }
 
 /* dqm->lock mutex has to be locked before calling this function */
+static int map_queues_cpsch(struct device_queue_manager *dqm)
+{
+       int retval;
+
+       if (dqm->queue_count <= 0 || dqm->processes_count <= 0)
+               return 0;
+
+       if (dqm->active_runlist)
+               return 0;
+
+       retval = pm_send_runlist(&dqm->packets, &dqm->queues);
+       if (retval) {
+               pr_err("failed to execute runlist\n");
+               return retval;
+       }
+       dqm->active_runlist = true;
+
+       return retval;
+}
+
+/* dqm->lock mutex has to be locked before calling this function */
 static int unmap_queues_cpsch(struct device_queue_manager *dqm,
                                enum kfd_unmap_queues_filter filter,
                                uint32_t filter_param)
@@ -918,20 +971,7 @@ static int execute_queues_cpsch(struct device_queue_manager *dqm)
                return retval;
        }
 
-       if (dqm->queue_count <= 0 || dqm->processes_count <= 0)
-               return 0;
-
-       if (dqm->active_runlist)
-               return 0;
-
-       retval = pm_send_runlist(&dqm->packets, &dqm->queues);
-       if (retval) {
-               pr_err("failed to execute runlist");
-               return retval;
-       }
-       dqm->active_runlist = true;
-
-       return retval;
+       return map_queues_cpsch(dqm);
 }
 
 static int destroy_queue_cpsch(struct device_queue_manager *dqm,
--
Quoted 2 lines

2.7.4

Applied to -next
Thanks,
Oded
_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

#13 lore raw

PATCH 4/9 drm/amdkfd: Avoid submitting an unnecessary packet to HWS

In reply to a message not in the archive

From: Yong Zhao <[email protected]>

---
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 28 ++++++++++++----------
 1 file changed, 16 insertions(+), 12 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +16 -12
index dccb493..0f2a756 100644
@@ -44,7 +44,8 @@ static int create_compute_queue_nocpsch(struct device_queue_manager *dqm,
 					struct queue *q,
 					struct qcm_process_device *qpd);
 
-static int execute_queues_cpsch(struct device_queue_manager *dqm);
+static int execute_queues_cpsch(struct device_queue_manager *dqm,
+				bool static_queues_included);
 static int unmap_queues_cpsch(struct device_queue_manager *dqm,
 				enum kfd_unmap_queues_filter filter,
 				uint32_t filter_param);
@@ -729,7 +730,7 @@ static int start_cpsch(struct device_queue_manager *dqm)
 	init_interrupts(dqm);
 
 	mutex_lock(&dqm->lock);
-	execute_queues_cpsch(dqm);
+	execute_queues_cpsch(dqm, false);
 	mutex_unlock(&dqm->lock);
 
 	return 0;
@@ -775,7 +776,7 @@ static int create_kernel_queue_cpsch(struct device_queue_manager *dqm,
 	list_add(&kq->list, &qpd->priv_queue_list);
 	dqm->queue_count++;
 	qpd->is_debug = true;
-	execute_queues_cpsch(dqm);
+	execute_queues_cpsch(dqm, false);
 	mutex_unlock(&dqm->lock);
 
 	return 0;
@@ -786,12 +787,10 @@ static void destroy_kernel_queue_cpsch(struct device_queue_manager *dqm,
 					struct qcm_process_device *qpd)
 {
 	mutex_lock(&dqm->lock);
-	/* here we actually preempt the DIQ */
-	unmap_queues_cpsch(dqm, KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES, 0);
 	list_del(&kq->list);
 	dqm->queue_count--;
 	qpd->is_debug = false;
-	execute_queues_cpsch(dqm);
+	execute_queues_cpsch(dqm, true);
 	/*
 	 * Unconditionally decrement this counter, regardless of the queue's
 	 * type.
@@ -850,7 +849,7 @@ static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q,
 	list_add(&q->list, &qpd->queues_list);
 	if (q->properties.is_active) {
 		dqm->queue_count++;
-		retval = execute_queues_cpsch(dqm);
+		retval = execute_queues_cpsch(dqm, false);
 	}
 
 	if (q->properties.type == KFD_QUEUE_TYPE_SDMA)
@@ -960,14 +959,19 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
 }
 
 /* dqm->lock mutex has to be locked before calling this function */
-static int execute_queues_cpsch(struct device_queue_manager *dqm)
+static int execute_queues_cpsch(struct device_queue_manager *dqm,
+				bool static_queues_included)
 {
 	int retval;
+	enum kfd_unmap_queues_filter filter;
+
+	filter = static_queues_included ?
+			KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES :
+			KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES;
 
-	retval = unmap_queues_cpsch(dqm, KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES,
-			0);
+	retval = unmap_queues_cpsch(dqm, filter, 0);
 	if (retval) {
-		pr_err("The cp might be in an unrecoverable state due to an unsuccessful queues preemption");
+		pr_err("The cp might be in an unrecoverable state due to an unsuccessful queues preemption\n");
 		return retval;
 	}
 
@@ -1013,7 +1017,7 @@ static int destroy_queue_cpsch(struct device_queue_manager *dqm,
 	if (q->properties.is_active)
 		dqm->queue_count--;
 
-	execute_queues_cpsch(dqm);
+	execute_queues_cpsch(dqm, false);
 
 	mqd->uninit_mqd(mqd, q->mqd, q->mqd_mem_obj);
 
Signature · 6 lines
2.7.4

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

A message that is not in the archive (sent off-list or not yet received): 1506485396-6326-5-git-send-email-Felix.Kuehling-5C7GfCeVMHo@public.gmane.org

#15 lore raw

Re: [PATCH 4/9] drm/amdkfd: Avoid submitting an unnecessary packet to HWS

Quoted 97 lines · Felix Kuehling

From: Yong Zhao <[email protected]>

---
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 28 ++++++++++++----------
 1 file changed, 16 insertions(+), 12 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +16 -13
index dccb493..0f2a756 100644
@@ -44,7 +44,8 @@ static int create_compute_queue_nocpsch(struct device_queue_manager *dqm,
                                        struct queue *q,
                                        struct qcm_process_device *qpd);
 
-static int execute_queues_cpsch(struct device_queue_manager *dqm);
+static int execute_queues_cpsch(struct device_queue_manager *dqm,
+                               bool static_queues_included);
 static int unmap_queues_cpsch(struct device_queue_manager *dqm,
                                enum kfd_unmap_queues_filter filter,
                                uint32_t filter_param);
@@ -729,7 +730,7 @@ static int start_cpsch(struct device_queue_manager *dqm)
        init_interrupts(dqm);
 
        mutex_lock(&dqm->lock);
-       execute_queues_cpsch(dqm);
+       execute_queues_cpsch(dqm, false);
        mutex_unlock(&dqm->lock);
 
        return 0;
@@ -775,7 +776,7 @@ static int create_kernel_queue_cpsch(struct device_queue_manager *dqm,
        list_add(&kq->list, &qpd->priv_queue_list);
        dqm->queue_count++;
        qpd->is_debug = true;
-       execute_queues_cpsch(dqm);
+       execute_queues_cpsch(dqm, false);
        mutex_unlock(&dqm->lock);
 
        return 0;
@@ -786,12 +787,10 @@ static void destroy_kernel_queue_cpsch(struct device_queue_manager *dqm,
                                        struct qcm_process_device *qpd)
 {
        mutex_lock(&dqm->lock);
-       /* here we actually preempt the DIQ */
-       unmap_queues_cpsch(dqm, KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES, 0);
        list_del(&kq->list);
        dqm->queue_count--;
        qpd->is_debug = false;
-       execute_queues_cpsch(dqm);
+       execute_queues_cpsch(dqm, true);
        /*
         * Unconditionally decrement this counter, regardless of the queue's
         * type.
@@ -850,7 +849,7 @@ static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q,
        list_add(&q->list, &qpd->queues_list);
        if (q->properties.is_active) {
                dqm->queue_count++;
-               retval = execute_queues_cpsch(dqm);
+               retval = execute_queues_cpsch(dqm, false);
        }
 
        if (q->properties.type == KFD_QUEUE_TYPE_SDMA)
@@ -960,14 +959,19 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
 }
 
 /* dqm->lock mutex has to be locked before calling this function */
-static int execute_queues_cpsch(struct device_queue_manager *dqm)
+static int execute_queues_cpsch(struct device_queue_manager *dqm,
+                               bool static_queues_included)
 {
        int retval;
+       enum kfd_unmap_queues_filter filter;
+
+       filter = static_queues_included ?
+                       KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES :
+                       KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES;
 
-       retval = unmap_queues_cpsch(dqm, KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES,
-                       0);
+       retval = unmap_queues_cpsch(dqm, filter, 0);
        if (retval) {
-               pr_err("The cp might be in an unrecoverable state due to an unsuccessful queues preemption");
+               pr_err("The cp might be in an unrecoverable state due to an unsuccessful queues preemption\n");
                return retval;
        }
 
@@ -1013,7 +1017,7 @@ static int destroy_queue_cpsch(struct device_queue_manager *dqm,
        if (q->properties.is_active)
                dqm->queue_count--;
 
-       execute_queues_cpsch(dqm);
+       execute_queues_cpsch(dqm, false);
 
        mqd->uninit_mqd(mqd, q->mqd, q->mqd_mem_obj);
 
--
Quoted 2 lines

2.7.4

The patch is correct, but the API is inconsistent with the new API you wrote for unmap_queues_cpsch in patch 2, where the filter is passed explicitly to the function.

I suggest to change the execute_queues_cpsch API to be the same as unmap_queues_cpsch

Oded
_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

A message that is not in the archive (sent off-list or not yet received): CAFCwf113j3LDjeST-me4NOK=o6N+JxCcaR8zxPt+XtuOy091mA-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org

#17 lore raw

Re: [PATCH 4/9] drm/amdkfd: Avoid submitting an unnecessary packet to HWS

Quoted 105 lines · Oded Gabbay
Quoted 97 lines · Felix Kuehling

From: Yong Zhao <[email protected]>

---
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 28 ++++++++++++----------
 1 file changed, 16 insertions(+), 12 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +16 -13
index dccb493..0f2a756 100644
@@ -44,7 +44,8 @@ static int create_compute_queue_nocpsch(struct device_queue_manager *dqm,
                                        struct queue *q,
                                        struct qcm_process_device *qpd);
 
-static int execute_queues_cpsch(struct device_queue_manager *dqm);
+static int execute_queues_cpsch(struct device_queue_manager *dqm,
+                               bool static_queues_included);
 static int unmap_queues_cpsch(struct device_queue_manager *dqm,
                                enum kfd_unmap_queues_filter filter,
                                uint32_t filter_param);
@@ -729,7 +730,7 @@ static int start_cpsch(struct device_queue_manager *dqm)
        init_interrupts(dqm);
 
        mutex_lock(&dqm->lock);
-       execute_queues_cpsch(dqm);
+       execute_queues_cpsch(dqm, false);
        mutex_unlock(&dqm->lock);
 
        return 0;
@@ -775,7 +776,7 @@ static int create_kernel_queue_cpsch(struct device_queue_manager *dqm,
        list_add(&kq->list, &qpd->priv_queue_list);
        dqm->queue_count++;
        qpd->is_debug = true;
-       execute_queues_cpsch(dqm);
+       execute_queues_cpsch(dqm, false);
        mutex_unlock(&dqm->lock);
 
        return 0;
@@ -786,12 +787,10 @@ static void destroy_kernel_queue_cpsch(struct device_queue_manager *dqm,
                                        struct qcm_process_device *qpd)
 {
        mutex_lock(&dqm->lock);
-       /* here we actually preempt the DIQ */
-       unmap_queues_cpsch(dqm, KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES, 0);
        list_del(&kq->list);
        dqm->queue_count--;
        qpd->is_debug = false;
-       execute_queues_cpsch(dqm);
+       execute_queues_cpsch(dqm, true);
        /*
         * Unconditionally decrement this counter, regardless of the queue's
         * type.
@@ -850,7 +849,7 @@ static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q,
        list_add(&q->list, &qpd->queues_list);
        if (q->properties.is_active) {
                dqm->queue_count++;
-               retval = execute_queues_cpsch(dqm);
+               retval = execute_queues_cpsch(dqm, false);
        }
 
        if (q->properties.type == KFD_QUEUE_TYPE_SDMA)
@@ -960,14 +959,19 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
 }
 
 /* dqm->lock mutex has to be locked before calling this function */
-static int execute_queues_cpsch(struct device_queue_manager *dqm)
+static int execute_queues_cpsch(struct device_queue_manager *dqm,
+                               bool static_queues_included)
 {
        int retval;
+       enum kfd_unmap_queues_filter filter;
+
+       filter = static_queues_included ?
+                       KFD_UNMAP_QUEUES_FILTER_ALL_QUEUES :
+                       KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES;
 
-       retval = unmap_queues_cpsch(dqm, KFD_UNMAP_QUEUES_FILTER_DYNAMIC_QUEUES,
-                       0);
+       retval = unmap_queues_cpsch(dqm, filter, 0);
        if (retval) {
-               pr_err("The cp might be in an unrecoverable state due to an unsuccessful queues preemption");
+               pr_err("The cp might be in an unrecoverable state due to an unsuccessful queues preemption\n");
                return retval;
        }
 
@@ -1013,7 +1017,7 @@ static int destroy_queue_cpsch(struct device_queue_manager *dqm,
        if (q->properties.is_active)
                dqm->queue_count--;
 
-       execute_queues_cpsch(dqm);
+       execute_queues_cpsch(dqm, false);
 
        mqd->uninit_mqd(mqd, q->mqd, q->mqd_mem_obj);
 
--
Quoted 2 lines

2.7.4

The patch is correct, but the API is inconsistent with the new API you wrote for unmap_queues_cpsch in patch 2, where the filter is passed explicitly to the function.

Quoted 4 lines

I suggest to change the execute_queues_cpsch API to be the same as unmap_queues_cpsch

Oded

Hi Felix, Yong.
I would like to send a pull request to Dave for kernel 4.15 with all the patches you sent in the last 3 weeks, but I'm blocked by the fix I asked for this patch.
Do you think you could make it happen until the end of the week ?

Thanks,
Oded
_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

A message that is not in the archive (sent off-list or not yet received): CAFCwf13vQn8NG0dxS1jxT1yj3e7evbOgM9vt1DXrSUf_fzm0JQ-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org

#19 lore raw

Re: [PATCH 4/9] drm/amdkfd: Avoid submitting an unnecessary packet to HWS

I'll send you a patch by Friday.

Regards,
  Felix

Quoted 8 lines · Oded Gabbay

Hi Felix, Yong.
I would like to send a pull request to Dave for kernel 4.15 with all the patches you sent in the last 3 weeks, but I'm blocked by the fix I asked for this patch.
Do you think you could make it happen until the end of the week ?

Thanks,
Oded

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

#20 lore raw

PATCH 5/9 drm/amdkfd: Improve process termination handling in the queue manager

In reply to a message not in the archive

Separate device queue termination from process queue manager termination. Unmap all queues at once instead of one at a time. Unmap device queues before the PASID is unbound, in the kfd_process_iommu_unbind_callback.

When resetting wavefronts in non-HWS mode, do it before the VMID is released.

---
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 187 ++++++++++++++++-----
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.h  |   5 +
 drivers/gpu/drm/amd/amdkfd/kfd_priv.h              |  18 +-
 drivers/gpu/drm/amd/amdkfd/kfd_process.c           |  36 ++--
 .../gpu/drm/amd/amdkfd/kfd_process_queue_manager.c |  37 ++--
 5 files changed, 200 insertions(+), 83 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +147 -40
index 0f2a756..d0e7288 100644
@@ -295,65 +295,73 @@ static int create_compute_queue_nocpsch(struct device_queue_manager *dqm,
 	return retval;
 }
 
-static int destroy_queue_nocpsch(struct device_queue_manager *dqm,
+/* Access to DQM has to be locked before calling destroy_queue_nocpsch_locked
+ * to avoid asynchronized access
+ */
+static int destroy_queue_nocpsch_locked(struct device_queue_manager *dqm,
 				struct qcm_process_device *qpd,
 				struct queue *q)
 {
 	int retval;
 	struct mqd_manager *mqd;
 
-	retval = 0;
-
-	mutex_lock(&dqm->lock);
+	mqd = dqm->ops.get_mqd_manager(dqm,
+		get_mqd_type_from_queue_type(q->properties.type));
+	if (!mqd)
+		return -ENOMEM;
 
-	if (q->properties.type == KFD_QUEUE_TYPE_COMPUTE) {
-		mqd = dqm->ops.get_mqd_manager(dqm, KFD_MQD_TYPE_COMPUTE);
-		if (mqd == NULL) {
-			retval = -ENOMEM;
-			goto out;
-		}
+	if (q->properties.type == KFD_QUEUE_TYPE_COMPUTE)
 		deallocate_hqd(dqm, q);
-	} else if (q->properties.type == KFD_QUEUE_TYPE_SDMA) {
-		mqd = dqm->ops.get_mqd_manager(dqm, KFD_MQD_TYPE_SDMA);
-		if (mqd == NULL) {
-			retval = -ENOMEM;
-			goto out;
-		}
+	else if (q->properties.type == KFD_QUEUE_TYPE_SDMA) {
 		dqm->sdma_queue_count--;
 		deallocate_sdma_queue(dqm, q->sdma_id);
 	} else {
 		pr_debug("q->properties.type %d is invalid\n",
 				q->properties.type);
-		retval = -EINVAL;
-		goto out;
+		return -EINVAL;
 	}
+	dqm->total_queue_count--;
 
 	retval = mqd->destroy_mqd(mqd, q->mqd,
 				KFD_PREEMPT_TYPE_WAVEFRONT_RESET,
 				KFD_UNMAP_LATENCY_MS,
 				q->pipe, q->queue);
-
-	if (retval)
-		goto out;
+	if (retval == -ETIME)
+		qpd->reset_wavefronts = true;
 
 	mqd->uninit_mqd(mqd, q->mqd, q->mqd_mem_obj);
 
 	list_del(&q->list);
-	if (list_empty(&qpd->queues_list))
+	if (list_empty(&qpd->queues_list)) {
+		if (qpd->reset_wavefronts) {
+			pr_warn("Resetting wave fronts (nocpsch) on dev %p\n",
+					dqm->dev);
+			/* dbgdev_wave_reset_wavefronts has to be called before
+			 * deallocate_vmid(), i.e. when vmid is still in use.
+			 */
+			dbgdev_wave_reset_wavefronts(dqm->dev,
+					qpd->pqm->process);
+			qpd->reset_wavefronts = false;
+		}
+
 		deallocate_vmid(dqm, qpd, q);
+	}
 	if (q->properties.is_active)
 		dqm->queue_count--;
 
-	/*
-	 * Unconditionally decrement this counter, regardless of the queue's
-	 * type
-	 */
-	dqm->total_queue_count--;
-	pr_debug("Total of %d queues are accountable so far\n",
-			dqm->total_queue_count);
+	return retval;
+}
 
-out:
+static int destroy_queue_nocpsch(struct device_queue_manager *dqm,
+				struct qcm_process_device *qpd,
+				struct queue *q)
+{
+	int retval;
+
+	mutex_lock(&dqm->lock);
+	retval = destroy_queue_nocpsch_locked(dqm, qpd, q);
 	mutex_unlock(&dqm->lock);
+
 	return retval;
 }
 
@@ -919,10 +927,7 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
 				enum kfd_unmap_queues_filter filter,
 				uint32_t filter_param)
 {
-	int retval;
-	struct kfd_process_device *pdd;
-
-	retval = 0;
+	int retval = 0;
 
 	if (!dqm->active_runlist)
 		return retval;
@@ -946,12 +951,9 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
 	/* should be timed out */
 	retval = amdkfd_fence_wait_timeout(dqm->fence_addr, KFD_FENCE_COMPLETED,
 				QUEUE_PREEMPT_DEFAULT_TIMEOUT_MS);
-	if (retval) {
-		pdd = kfd_get_process_device_data(dqm->dev,
-				kfd_get_process(current));
-		pdd->reset_wavefronts = true;
+	if (retval)
 		return retval;
-	}
+
 	pm_release_ib(&dqm->packets);
 	dqm->active_runlist = false;
 
@@ -1017,7 +1019,9 @@ static int destroy_queue_cpsch(struct device_queue_manager *dqm,
 	if (q->properties.is_active)
 		dqm->queue_count--;
 
-	execute_queues_cpsch(dqm, false);
+	retval = execute_queues_cpsch(dqm, false);
+	if (retval == -ETIME)
+		qpd->reset_wavefronts = true;
 
 	mqd->uninit_mqd(mqd, q->mqd, q->mqd_mem_obj);
 
@@ -1107,6 +1111,107 @@ static bool set_cache_memory_policy(struct device_queue_manager *dqm,
 	return retval;
 }
 
+static int process_termination_nocpsch(struct device_queue_manager *dqm,
+		struct qcm_process_device *qpd)
+{
+	struct queue *q, *next;
+	struct device_process_node *cur, *next_dpn;
+	int retval = 0;
+
+	mutex_lock(&dqm->lock);
+
+	/* Clear all user mode queues */
+	list_for_each_entry_safe(q, next, &qpd->queues_list, list) {
+		int ret;
+
+		ret = destroy_queue_nocpsch_locked(dqm, qpd, q);
+		if (ret)
+			retval = ret;
+	}
+
+	/* Unregister process */
+	list_for_each_entry_safe(cur, next_dpn, &dqm->queues, list) {
+		if (qpd == cur->qpd) {
+			list_del(&cur->list);
+			kfree(cur);
+			dqm->processes_count--;
+			break;
+		}
+	}
+
+	mutex_unlock(&dqm->lock);
+	return retval;
+}
+
+
+static int process_termination_cpsch(struct device_queue_manager *dqm,
+		struct qcm_process_device *qpd)
+{
+	int retval;
+	struct queue *q, *next;
+	struct kernel_queue *kq, *kq_next;
+	struct mqd_manager *mqd;
+	struct device_process_node *cur, *next_dpn;
+	bool unmap_static_queues = false;
+
+	retval = 0;
+
+	mutex_lock(&dqm->lock);
+
+	/* Clean all kernel queues */
+	list_for_each_entry_safe(kq, kq_next, &qpd->priv_queue_list, list) {
+		list_del(&kq->list);
+		dqm->queue_count--;
+		qpd->is_debug = false;
+		dqm->total_queue_count--;
+		unmap_static_queues = true;
+	}
+
+	/* Clear all user mode queues */
+	list_for_each_entry(q, &qpd->queues_list, list) {
+		if (q->properties.type == KFD_QUEUE_TYPE_SDMA)
+			dqm->sdma_queue_count--;
+
+		if (q->properties.is_active)
+			dqm->queue_count--;
+
+		dqm->total_queue_count--;
+	}
+
+	/* Unregister process */
+	list_for_each_entry_safe(cur, next_dpn, &dqm->queues, list) {
+		if (qpd == cur->qpd) {
+			list_del(&cur->list);
+			kfree(cur);
+			dqm->processes_count--;
+			break;
+		}
+	}
+
+	retval = execute_queues_cpsch(dqm, unmap_static_queues);
+	if (retval || qpd->reset_wavefronts) {
+		pr_warn("Resetting wave fronts (cpsch) on dev %p\n", dqm->dev);
+		dbgdev_wave_reset_wavefronts(dqm->dev, qpd->pqm->process);
+		qpd->reset_wavefronts = false;
+	}
+
+	/* lastly, free mqd resources */
+	list_for_each_entry_safe(q, next, &qpd->queues_list, list) {
+		mqd = dqm->ops.get_mqd_manager(dqm,
+			get_mqd_type_from_queue_type(q->properties.type));
+		if (!mqd) {
+			retval = -ENOMEM;
+			goto out;
+		}
+		list_del(&q->list);
+		mqd->uninit_mqd(mqd, q->mqd, q->mqd_mem_obj);
+	}
+
+out:
+	mutex_unlock(&dqm->lock);
+	return retval;
+}
+
 struct device_queue_manager *device_queue_manager_init(struct kfd_dev *dev)
 {
 	struct device_queue_manager *dqm;
@@ -1135,6 +1240,7 @@ struct device_queue_manager *device_queue_manager_init(struct kfd_dev *dev)
 		dqm->ops.create_kernel_queue = create_kernel_queue_cpsch;
 		dqm->ops.destroy_kernel_queue = destroy_kernel_queue_cpsch;
 		dqm->ops.set_cache_memory_policy = set_cache_memory_policy;
+		dqm->ops.process_termination = process_termination_cpsch;
 		break;
 	case KFD_SCHED_POLICY_NO_HWS:
 		/* initialize dqm for no cp scheduling */
@@ -1149,6 +1255,7 @@ struct device_queue_manager *device_queue_manager_init(struct kfd_dev *dev)
 		dqm->ops.initialize = initialize_nocpsch;
 		dqm->ops.uninitialize = uninitialize;
 		dqm->ops.set_cache_memory_policy = set_cache_memory_policy;
+		dqm->ops.process_termination = process_termination_nocpsch;
 		break;
 	default:
 		pr_err("Invalid scheduling policy %d\n", sched_policy);
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h +5 -0
index 60d46ce..31c2b1f 100644
@@ -77,6 +77,8 @@ struct device_process_node {
  * @set_cache_memory_policy: Sets memory policy (cached/ non cached) for the
  * memory apertures.
  *
+ * @process_termination: Clears all process queues belongs to that device.
+ *
  */
 
 struct device_queue_manager_ops {
@@ -120,6 +122,9 @@ struct device_queue_manager_ops {
 					   enum cache_policy alternate_policy,
 					   void __user *alternate_aperture_base,
 					   uint64_t alternate_aperture_size);
+
+	int (*process_termination)(struct device_queue_manager *dqm,
+			struct qcm_process_device *qpd);
 };
 
 struct device_queue_manager_asic_ops {
drivers/gpu/drm/amd/amdkfd/kfd_priv.h +15 -3
index b0a5bea..b936a12 100644
@@ -424,6 +424,12 @@ struct qcm_process_device {
 	unsigned int queue_count;
 	unsigned int vmid;
 	bool is_debug;
+
+	/* This flag tells if we should reset all wavefronts on
+	 * process termination
+	 */
+	bool reset_wavefronts;
+
 	/*
 	 * All the memory management data should be here too
 	 */
@@ -457,6 +463,8 @@ struct kfd_process_device {
 	/* The device that owns this data. */
 	struct kfd_dev *dev;
 
+	/* The process that owns this kfd_process_device. */
+	struct kfd_process *process;
 
 	/* per-process-per device QCM data structure */
 	struct qcm_process_device qpd;
@@ -472,10 +480,12 @@ struct kfd_process_device {
 	/* Is this process/pasid bound to this device? (amd_iommu_bind_pasid) */
 	enum kfd_pdd_bound bound;
 
-	/* This flag tells if we should reset all
-	 * wavefronts on process termination
+	/* Flag used to tell the pdd has dequeued from the dqm.
+	 * This is used to prevent dev->dqm->ops.process_termination() from
+	 * being called twice when it is already called in IOMMU callback
+	 * function.
 	 */
-	bool reset_wavefronts;
+	bool already_dequeued;
 };
 
 #define qpd_to_pdd(x) container_of(x, struct kfd_process_device, qpd)
@@ -657,6 +667,8 @@ struct process_queue_node {
 	struct list_head process_queue_list;
 };
 
+void kfd_process_dequeue_from_device(struct kfd_process_device *pdd);
+void kfd_process_dequeue_from_all_devices(struct kfd_process *p);
 int pqm_init(struct process_queue_manager *pqm, struct kfd_process *p);
 void pqm_uninit(struct process_queue_manager *pqm);
 int pqm_create_queue(struct process_queue_manager *pqm,
drivers/gpu/drm/amd/amdkfd/kfd_process.c +10 -26
index 0464c31..82ad037 100644
@@ -171,9 +171,6 @@ static void kfd_process_wq_release(struct work_struct *work)
 		pr_debug("Releasing pdd (topology id %d) for process (pasid %d) in workqueue\n",
 				pdd->dev->id, p->pasid);
 
-		if (pdd->reset_wavefronts)
-			dbgdev_wave_reset_wavefronts(pdd->dev, p);
-
 		if (pdd->bound == PDD_BOUND)
 			amd_iommu_unbind_pasid(pdd->dev->pdev, p->pasid);
 
@@ -236,24 +233,17 @@ static void kfd_process_notifier_release(struct mmu_notifier *mn,
 
 	mutex_lock(&p->mutex);
 
-	/* In case our notifier is called before IOMMU notifier */
+	kfd_process_dequeue_from_all_devices(p);
 	pqm_uninit(&p->pqm);
 
 	/* Iterate over all process device data structure and check
-	 * if we should delete debug managers and reset all wavefronts
+	 * if we should delete debug managers
 	 */
-	list_for_each_entry(pdd, &p->per_device_data, per_device_list) {
+	list_for_each_entry(pdd, &p->per_device_data, per_device_list)
 		if ((pdd->dev->dbgmgr) &&
 				(pdd->dev->dbgmgr->pasid == p->pasid))
 			kfd_dbgmgr_destroy(pdd->dev->dbgmgr);
 
-		if (pdd->reset_wavefronts) {
-			pr_warn("Resetting all wave fronts\n");
-			dbgdev_wave_reset_wavefronts(pdd->dev, p);
-			pdd->reset_wavefronts = false;
-		}
-	}
-
 	mutex_unlock(&p->mutex);
 
 	/*
@@ -362,8 +352,9 @@ struct kfd_process_device *kfd_create_process_device_data(struct kfd_dev *dev,
 		INIT_LIST_HEAD(&pdd->qpd.queues_list);
 		INIT_LIST_HEAD(&pdd->qpd.priv_queue_list);
 		pdd->qpd.dqm = dev->dqm;
-		pdd->reset_wavefronts = false;
+		pdd->process = p;
 		pdd->bound = PDD_UNBOUND;
+		pdd->already_dequeued = false;
 		list_add(&pdd->per_device_list, &p->per_device_data);
 	}
 
@@ -492,19 +483,12 @@ void kfd_process_iommu_unbind_callback(struct kfd_dev *dev, unsigned int pasid)
 	if ((dev->dbgmgr) && (dev->dbgmgr->pasid == p->pasid))
 		kfd_dbgmgr_destroy(dev->dbgmgr);
 
-	pqm_uninit(&p->pqm);
-
 	pdd = kfd_get_process_device_data(dev, p);
-
-	if (!pdd) {
-		mutex_unlock(&p->mutex);
-		return;
-	}
-
-	if (pdd->reset_wavefronts) {
-		dbgdev_wave_reset_wavefronts(pdd->dev, p);
-		pdd->reset_wavefronts = false;
-	}
+	if (pdd)
+		/* For GPU relying on IOMMU, we need to dequeue here
+		 * when PASID is still bound.
+		 */
+		kfd_process_dequeue_from_device(pdd);
 
 	mutex_unlock(&p->mutex);
 }
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +23 -14
index 68fe0d9..31ec3ca 100644
@@ -63,6 +63,25 @@ static int find_available_queue_slot(struct process_queue_manager *pqm,
 	return 0;
 }
 
+void kfd_process_dequeue_from_device(struct kfd_process_device *pdd)
+{
+	struct kfd_dev *dev = pdd->dev;
+
+	if (pdd->already_dequeued)
+		return;
+
+	dev->dqm->ops.process_termination(dev->dqm, &pdd->qpd);
+	pdd->already_dequeued = true;
+}
+
+void kfd_process_dequeue_from_all_devices(struct kfd_process *p)
+{
+	struct kfd_process_device *pdd;
+
+	list_for_each_entry(pdd, &p->per_device_data, per_device_list)
+		kfd_process_dequeue_from_device(pdd);
+}
+
 int pqm_init(struct process_queue_manager *pqm, struct kfd_process *p)
 {
 	INIT_LIST_HEAD(&pqm->queues);
@@ -78,21 +97,14 @@ int pqm_init(struct process_queue_manager *pqm, struct kfd_process *p)
 
 void pqm_uninit(struct process_queue_manager *pqm)
 {
-	int retval;
 	struct process_queue_node *pqn, *next;
 
 	list_for_each_entry_safe(pqn, next, &pqm->queues, process_queue_list) {
-		retval = pqm_destroy_queue(
-				pqm,
-				(pqn->q != NULL) ?
-					pqn->q->properties.queue_id :
-					pqn->kq->queue->properties.queue_id);
-
-		if (retval != 0) {
-			pr_err("failed to destroy queue\n");
-			return;
-		}
+		uninit_queue(pqn->q);
+		list_del(&pqn->process_queue_list);
+		kfree(pqn);
 	}
+
 	kfree(pqm->queue_slot_bitmap);
 	pqm->queue_slot_bitmap = NULL;
 }
@@ -290,9 +302,6 @@ int pqm_destroy_queue(struct process_queue_manager *pqm, unsigned int qid)
 	if (pqn->q) {
 		dqm = pqn->q->device->dqm;
 		retval = dqm->ops.destroy_queue(dqm, &pdd->qpd, pqn->q);
-		if (retval != 0)
-			return retval;
-
 		uninit_queue(pqn->q);
 	}
 
Signature · 6 lines
2.7.4

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

A message that is not in the archive (sent off-list or not yet received): 1506485396-6326-6-git-send-email-Felix.Kuehling-5C7GfCeVMHo@public.gmane.org

#22 lore raw

Re: [PATCH 5/9] drm/amdkfd: Improve process termination handling in the queue manager

Quoted 510 lines · Felix Kuehling

Separate device queue termination from process queue manager termination. Unmap all queues at once instead of one at a time. Unmap device queues before the PASID is unbound, in the kfd_process_iommu_unbind_callback.

When resetting wavefronts in non-HWS mode, do it before the VMID is released.

---
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 187 ++++++++++++++++-----
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.h  |   5 +
 drivers/gpu/drm/amd/amdkfd/kfd_priv.h              |  18 +-
 drivers/gpu/drm/amd/amdkfd/kfd_process.c           |  36 ++--
 .../gpu/drm/amd/amdkfd/kfd_process_queue_manager.c |  37 ++--
 5 files changed, 200 insertions(+), 83 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +147 -40
index 0f2a756..d0e7288 100644
@@ -295,65 +295,73 @@ static int create_compute_queue_nocpsch(struct device_queue_manager *dqm,
        return retval;
 }
 
-static int destroy_queue_nocpsch(struct device_queue_manager *dqm,
+/* Access to DQM has to be locked before calling destroy_queue_nocpsch_locked
+ * to avoid asynchronized access
+ */
+static int destroy_queue_nocpsch_locked(struct device_queue_manager *dqm,
                                struct qcm_process_device *qpd,
                                struct queue *q)
 {
        int retval;
        struct mqd_manager *mqd;
 
-       retval = 0;
-
-       mutex_lock(&dqm->lock);
+       mqd = dqm->ops.get_mqd_manager(dqm,
+               get_mqd_type_from_queue_type(q->properties.type));
+       if (!mqd)
+               return -ENOMEM;
 
-       if (q->properties.type == KFD_QUEUE_TYPE_COMPUTE) {
-               mqd = dqm->ops.get_mqd_manager(dqm, KFD_MQD_TYPE_COMPUTE);
-               if (mqd == NULL) {
-                       retval = -ENOMEM;
-                       goto out;
-               }
+       if (q->properties.type == KFD_QUEUE_TYPE_COMPUTE)
                deallocate_hqd(dqm, q);
-       } else if (q->properties.type == KFD_QUEUE_TYPE_SDMA) {
-               mqd = dqm->ops.get_mqd_manager(dqm, KFD_MQD_TYPE_SDMA);
-               if (mqd == NULL) {
-                       retval = -ENOMEM;
-                       goto out;
-               }
+       else if (q->properties.type == KFD_QUEUE_TYPE_SDMA) {
                dqm->sdma_queue_count--;
                deallocate_sdma_queue(dqm, q->sdma_id);
        } else {
                pr_debug("q->properties.type %d is invalid\n",
                                q->properties.type);
-               retval = -EINVAL;
-               goto out;
+               return -EINVAL;
        }
+       dqm->total_queue_count--;
 
        retval = mqd->destroy_mqd(mqd, q->mqd,
                                KFD_PREEMPT_TYPE_WAVEFRONT_RESET,
                                KFD_UNMAP_LATENCY_MS,
                                q->pipe, q->queue);
-
-       if (retval)
-               goto out;
+       if (retval == -ETIME)
+               qpd->reset_wavefronts = true;
 
        mqd->uninit_mqd(mqd, q->mqd, q->mqd_mem_obj);
 
        list_del(&q->list);
-       if (list_empty(&qpd->queues_list))
+       if (list_empty(&qpd->queues_list)) {
+               if (qpd->reset_wavefronts) {
+                       pr_warn("Resetting wave fronts (nocpsch) on dev %p\n",
+                                       dqm->dev);
+                       /* dbgdev_wave_reset_wavefronts has to be called before
+                        * deallocate_vmid(), i.e. when vmid is still in use.
+                        */
+                       dbgdev_wave_reset_wavefronts(dqm->dev,
+                                       qpd->pqm->process);
+                       qpd->reset_wavefronts = false;
+               }
+
                deallocate_vmid(dqm, qpd, q);
+       }
        if (q->properties.is_active)
                dqm->queue_count--;
 
-       /*
-        * Unconditionally decrement this counter, regardless of the queue's
-        * type
-        */
-       dqm->total_queue_count--;
-       pr_debug("Total of %d queues are accountable so far\n",
-                       dqm->total_queue_count);
+       return retval;
+}
 
-out:
+static int destroy_queue_nocpsch(struct device_queue_manager *dqm,
+                               struct qcm_process_device *qpd,
+                               struct queue *q)
+{
+       int retval;
+
+       mutex_lock(&dqm->lock);
+       retval = destroy_queue_nocpsch_locked(dqm, qpd, q);
        mutex_unlock(&dqm->lock);
+
        return retval;
 }
 
@@ -919,10 +927,7 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
                                enum kfd_unmap_queues_filter filter,
                                uint32_t filter_param)
 {
-       int retval;
-       struct kfd_process_device *pdd;
-
-       retval = 0;
+       int retval = 0;
 
        if (!dqm->active_runlist)
                return retval;
@@ -946,12 +951,9 @@ static int unmap_queues_cpsch(struct device_queue_manager *dqm,
        /* should be timed out */
        retval = amdkfd_fence_wait_timeout(dqm->fence_addr, KFD_FENCE_COMPLETED,
                                QUEUE_PREEMPT_DEFAULT_TIMEOUT_MS);
-       if (retval) {
-               pdd = kfd_get_process_device_data(dqm->dev,
-                               kfd_get_process(current));
-               pdd->reset_wavefronts = true;
+       if (retval)
                return retval;
-       }
+
        pm_release_ib(&dqm->packets);
        dqm->active_runlist = false;
 
@@ -1017,7 +1019,9 @@ static int destroy_queue_cpsch(struct device_queue_manager *dqm,
        if (q->properties.is_active)
                dqm->queue_count--;
 
-       execute_queues_cpsch(dqm, false);
+       retval = execute_queues_cpsch(dqm, false);
+       if (retval == -ETIME)
+               qpd->reset_wavefronts = true;
 
        mqd->uninit_mqd(mqd, q->mqd, q->mqd_mem_obj);
 
@@ -1107,6 +1111,107 @@ static bool set_cache_memory_policy(struct device_queue_manager *dqm,
        return retval;
 }
 
+static int process_termination_nocpsch(struct device_queue_manager *dqm,
+               struct qcm_process_device *qpd)
+{
+       struct queue *q, *next;
+       struct device_process_node *cur, *next_dpn;
+       int retval = 0;
+
+       mutex_lock(&dqm->lock);
+
+       /* Clear all user mode queues */
+       list_for_each_entry_safe(q, next, &qpd->queues_list, list) {
+               int ret;
+
+               ret = destroy_queue_nocpsch_locked(dqm, qpd, q);
+               if (ret)
+                       retval = ret;
+       }
+
+       /* Unregister process */
+       list_for_each_entry_safe(cur, next_dpn, &dqm->queues, list) {
+               if (qpd == cur->qpd) {
+                       list_del(&cur->list);
+                       kfree(cur);
+                       dqm->processes_count--;
+                       break;
+               }
+       }
+
+       mutex_unlock(&dqm->lock);
+       return retval;
+}
+
+
+static int process_termination_cpsch(struct device_queue_manager *dqm,
+               struct qcm_process_device *qpd)
+{
+       int retval;
+       struct queue *q, *next;
+       struct kernel_queue *kq, *kq_next;
+       struct mqd_manager *mqd;
+       struct device_process_node *cur, *next_dpn;
+       bool unmap_static_queues = false;
+
+       retval = 0;
+
+       mutex_lock(&dqm->lock);
+
+       /* Clean all kernel queues */
+       list_for_each_entry_safe(kq, kq_next, &qpd->priv_queue_list, list) {
+               list_del(&kq->list);
+               dqm->queue_count--;
+               qpd->is_debug = false;
+               dqm->total_queue_count--;
+               unmap_static_queues = true;
+       }
+
+       /* Clear all user mode queues */
+       list_for_each_entry(q, &qpd->queues_list, list) {
+               if (q->properties.type == KFD_QUEUE_TYPE_SDMA)
+                       dqm->sdma_queue_count--;
+
+               if (q->properties.is_active)
+                       dqm->queue_count--;
+
+               dqm->total_queue_count--;
+       }
+
+       /* Unregister process */
+       list_for_each_entry_safe(cur, next_dpn, &dqm->queues, list) {
+               if (qpd == cur->qpd) {
+                       list_del(&cur->list);
+                       kfree(cur);
+                       dqm->processes_count--;
+                       break;
+               }
+       }
+
+       retval = execute_queues_cpsch(dqm, unmap_static_queues);
+       if (retval || qpd->reset_wavefronts) {
+               pr_warn("Resetting wave fronts (cpsch) on dev %p\n", dqm->dev);
+               dbgdev_wave_reset_wavefronts(dqm->dev, qpd->pqm->process);
+               qpd->reset_wavefronts = false;
+       }
+
+       /* lastly, free mqd resources */
+       list_for_each_entry_safe(q, next, &qpd->queues_list, list) {
+               mqd = dqm->ops.get_mqd_manager(dqm,
+                       get_mqd_type_from_queue_type(q->properties.type));
+               if (!mqd) {
+                       retval = -ENOMEM;
+                       goto out;
+               }
+               list_del(&q->list);
+               mqd->uninit_mqd(mqd, q->mqd, q->mqd_mem_obj);
+       }
+
+out:
+       mutex_unlock(&dqm->lock);
+       return retval;
+}
+
 struct device_queue_manager *device_queue_manager_init(struct kfd_dev *dev)
 {
        struct device_queue_manager *dqm;
@@ -1135,6 +1240,7 @@ struct device_queue_manager *device_queue_manager_init(struct kfd_dev *dev)
                dqm->ops.create_kernel_queue = create_kernel_queue_cpsch;
                dqm->ops.destroy_kernel_queue = destroy_kernel_queue_cpsch;
                dqm->ops.set_cache_memory_policy = set_cache_memory_policy;
+               dqm->ops.process_termination = process_termination_cpsch;
                break;
        case KFD_SCHED_POLICY_NO_HWS:
                /* initialize dqm for no cp scheduling */
@@ -1149,6 +1255,7 @@ struct device_queue_manager *device_queue_manager_init(struct kfd_dev *dev)
                dqm->ops.initialize = initialize_nocpsch;
                dqm->ops.uninitialize = uninitialize;
                dqm->ops.set_cache_memory_policy = set_cache_memory_policy;
+               dqm->ops.process_termination = process_termination_nocpsch;
                break;
        default:
                pr_err("Invalid scheduling policy %d\n", sched_policy);
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.h +5 -0
index 60d46ce..31c2b1f 100644
@@ -77,6 +77,8 @@ struct device_process_node {
  * @set_cache_memory_policy: Sets memory policy (cached/ non cached) for the
  * memory apertures.
  *
+ * @process_termination: Clears all process queues belongs to that device.
+ *
  */
 
 struct device_queue_manager_ops {
@@ -120,6 +122,9 @@ struct device_queue_manager_ops {
                                           enum cache_policy alternate_policy,
                                           void __user *alternate_aperture_base,
                                           uint64_t alternate_aperture_size);
+
+       int (*process_termination)(struct device_queue_manager *dqm,
+                       struct qcm_process_device *qpd);
 };
 
 struct device_queue_manager_asic_ops {
drivers/gpu/drm/amd/amdkfd/kfd_priv.h +15 -3
index b0a5bea..b936a12 100644
@@ -424,6 +424,12 @@ struct qcm_process_device {
        unsigned int queue_count;
        unsigned int vmid;
        bool is_debug;
+
+       /* This flag tells if we should reset all wavefronts on
+        * process termination
+        */
+       bool reset_wavefronts;
+
        /*
         * All the memory management data should be here too
         */
@@ -457,6 +463,8 @@ struct kfd_process_device {
        /* The device that owns this data. */
        struct kfd_dev *dev;
 
+       /* The process that owns this kfd_process_device. */
+       struct kfd_process *process;
 
        /* per-process-per device QCM data structure */
        struct qcm_process_device qpd;
@@ -472,10 +480,12 @@ struct kfd_process_device {
        /* Is this process/pasid bound to this device? (amd_iommu_bind_pasid) */
        enum kfd_pdd_bound bound;
 
-       /* This flag tells if we should reset all
-        * wavefronts on process termination
+       /* Flag used to tell the pdd has dequeued from the dqm.
+        * This is used to prevent dev->dqm->ops.process_termination() from
+        * being called twice when it is already called in IOMMU callback
+        * function.
         */
-       bool reset_wavefronts;
+       bool already_dequeued;
 };
 
 #define qpd_to_pdd(x) container_of(x, struct kfd_process_device, qpd)
@@ -657,6 +667,8 @@ struct process_queue_node {
        struct list_head process_queue_list;
 };
 
+void kfd_process_dequeue_from_device(struct kfd_process_device *pdd);
+void kfd_process_dequeue_from_all_devices(struct kfd_process *p);
 int pqm_init(struct process_queue_manager *pqm, struct kfd_process *p);
 void pqm_uninit(struct process_queue_manager *pqm);
 int pqm_create_queue(struct process_queue_manager *pqm,
drivers/gpu/drm/amd/amdkfd/kfd_process.c +10 -26
index 0464c31..82ad037 100644
@@ -171,9 +171,6 @@ static void kfd_process_wq_release(struct work_struct *work)
                pr_debug("Releasing pdd (topology id %d) for process (pasid %d) in workqueue\n",
                                pdd->dev->id, p->pasid);
 
-               if (pdd->reset_wavefronts)
-                       dbgdev_wave_reset_wavefronts(pdd->dev, p);
-
                if (pdd->bound == PDD_BOUND)
                        amd_iommu_unbind_pasid(pdd->dev->pdev, p->pasid);
 
@@ -236,24 +233,17 @@ static void kfd_process_notifier_release(struct mmu_notifier *mn,
 
        mutex_lock(&p->mutex);
 
-       /* In case our notifier is called before IOMMU notifier */
+       kfd_process_dequeue_from_all_devices(p);
        pqm_uninit(&p->pqm);
 
        /* Iterate over all process device data structure and check
-        * if we should delete debug managers and reset all wavefronts
+        * if we should delete debug managers
         */
-       list_for_each_entry(pdd, &p->per_device_data, per_device_list) {
+       list_for_each_entry(pdd, &p->per_device_data, per_device_list)
                if ((pdd->dev->dbgmgr) &&
                                (pdd->dev->dbgmgr->pasid == p->pasid))
                        kfd_dbgmgr_destroy(pdd->dev->dbgmgr);
 
-               if (pdd->reset_wavefronts) {
-                       pr_warn("Resetting all wave fronts\n");
-                       dbgdev_wave_reset_wavefronts(pdd->dev, p);
-                       pdd->reset_wavefronts = false;
-               }
-       }
-
        mutex_unlock(&p->mutex);
 
        /*
@@ -362,8 +352,9 @@ struct kfd_process_device *kfd_create_process_device_data(struct kfd_dev *dev,
                INIT_LIST_HEAD(&pdd->qpd.queues_list);
                INIT_LIST_HEAD(&pdd->qpd.priv_queue_list);
                pdd->qpd.dqm = dev->dqm;
-               pdd->reset_wavefronts = false;
+               pdd->process = p;
                pdd->bound = PDD_UNBOUND;
+               pdd->already_dequeued = false;
                list_add(&pdd->per_device_list, &p->per_device_data);
        }
 
@@ -492,19 +483,12 @@ void kfd_process_iommu_unbind_callback(struct kfd_dev *dev, unsigned int pasid)
        if ((dev->dbgmgr) && (dev->dbgmgr->pasid == p->pasid))
                kfd_dbgmgr_destroy(dev->dbgmgr);
 
-       pqm_uninit(&p->pqm);
-
        pdd = kfd_get_process_device_data(dev, p);
-
-       if (!pdd) {
-               mutex_unlock(&p->mutex);
-               return;
-       }
-
-       if (pdd->reset_wavefronts) {
-               dbgdev_wave_reset_wavefronts(pdd->dev, p);
-               pdd->reset_wavefronts = false;
-       }
+       if (pdd)
+               /* For GPU relying on IOMMU, we need to dequeue here
+                * when PASID is still bound.
+                */
+               kfd_process_dequeue_from_device(pdd);
 
        mutex_unlock(&p->mutex);
 }
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +23 -15
index 68fe0d9..31ec3ca 100644
@@ -63,6 +63,25 @@ static int find_available_queue_slot(struct process_queue_manager *pqm,
        return 0;
 }
 
+void kfd_process_dequeue_from_device(struct kfd_process_device *pdd)
+{
+       struct kfd_dev *dev = pdd->dev;
+
+       if (pdd->already_dequeued)
+               return;
+
+       dev->dqm->ops.process_termination(dev->dqm, &pdd->qpd);
+       pdd->already_dequeued = true;
+}
+
+void kfd_process_dequeue_from_all_devices(struct kfd_process *p)
+{
+       struct kfd_process_device *pdd;
+
+       list_for_each_entry(pdd, &p->per_device_data, per_device_list)
+               kfd_process_dequeue_from_device(pdd);
+}
+
 int pqm_init(struct process_queue_manager *pqm, struct kfd_process *p)
 {
        INIT_LIST_HEAD(&pqm->queues);
@@ -78,21 +97,14 @@ int pqm_init(struct process_queue_manager *pqm, struct kfd_process *p)
 
 void pqm_uninit(struct process_queue_manager *pqm)
 {
-       int retval;
        struct process_queue_node *pqn, *next;
 
        list_for_each_entry_safe(pqn, next, &pqm->queues, process_queue_list) {
-               retval = pqm_destroy_queue(
-                               pqm,
-                               (pqn->q != NULL) ?
-                                       pqn->q->properties.queue_id :
-                                       pqn->kq->queue->properties.queue_id);
-
-               if (retval != 0) {
-                       pr_err("failed to destroy queue\n");
-                       return;
-               }
+               uninit_queue(pqn->q);
+               list_del(&pqn->process_queue_list);
+               kfree(pqn);
        }
+
        kfree(pqm->queue_slot_bitmap);
        pqm->queue_slot_bitmap = NULL;
 }
@@ -290,9 +302,6 @@ int pqm_destroy_queue(struct process_queue_manager *pqm, unsigned int qid)
        if (pqn->q) {
                dqm = pqn->q->device->dqm;
                retval = dqm->ops.destroy_queue(dqm, &pdd->qpd, pqn->q);
-               if (retval != 0)
-                       return retval;
-
                uninit_queue(pqn->q);
        }
 
--
Quoted 2 lines

2.7.4

Applied to -next
Thanks,
Oded
_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

#23 lore raw

PATCH 6/9 drm/amdkfd: Compress unnecessary function parameters

In reply to a message not in the archive

From: Yong Zhao <[email protected]>

---
 drivers/gpu/drm/amd/amdkfd/kfd_chardev.c               |  3 +--
 drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c                |  5 +++--
 drivers/gpu/drm/amd/amdkfd/kfd_priv.h                  |  2 --
 drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c | 10 +++-------
 4 files changed, 7 insertions(+), 13 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +1 -2
index e4a8c2e..c4632aeb 100644
@@ -282,8 +282,7 @@ static int kfd_ioctl_create_queue(struct file *filep, struct kfd_process *p,
 			p->pasid,
 			dev->id);
 
-	err = pqm_create_queue(&p->pqm, dev, filep, &q_properties,
-				0, q_properties.type, &queue_id);
+	err = pqm_create_queue(&p->pqm, dev, filep, &q_properties, &queue_id);
 	if (err != 0)
 		goto err_create_queue;
 
drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c +3 -2
index 7d5635f..c407f6b 100644
@@ -184,9 +184,10 @@ static int dbgdev_register_diq(struct kfd_dbgdev *dbgdev)
 	struct kernel_queue *kq = NULL;
 	int status;
 
+	properties.type = KFD_QUEUE_TYPE_DIQ;
+
 	status = pqm_create_queue(dbgdev->pqm, dbgdev->dev, NULL,
-				&properties, 0, KFD_QUEUE_TYPE_DIQ,
-				&qid);
+				&properties, &qid);
 
 	if (status) {
 		pr_err("Failed to create DIQ\n");
drivers/gpu/drm/amd/amdkfd/kfd_priv.h +0 -2
index b936a12..ca37210 100644
@@ -675,8 +675,6 @@ int pqm_create_queue(struct process_queue_manager *pqm,
 			    struct kfd_dev *dev,
 			    struct file *f,
 			    struct queue_properties *properties,
-			    unsigned int flags,
-			    enum kfd_queue_type type,
 			    unsigned int *qid);
 int pqm_destroy_queue(struct process_queue_manager *pqm, unsigned int qid);
 int pqm_update_queue(struct process_queue_manager *pqm, unsigned int qid,
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +3 -7
index 31ec3ca..63c569b 100644
@@ -142,20 +142,17 @@ int pqm_create_queue(struct process_queue_manager *pqm,
 			    struct kfd_dev *dev,
 			    struct file *f,
 			    struct queue_properties *properties,
-			    unsigned int flags,
-			    enum kfd_queue_type type,
 			    unsigned int *qid)
 {
 	int retval;
 	struct kfd_process_device *pdd;
-	struct queue_properties q_properties;
 	struct queue *q;
 	struct process_queue_node *pqn;
 	struct kernel_queue *kq;
 	int num_queues = 0;
 	struct queue *cur;
+	enum kfd_queue_type type = properties->type;
 
-	memcpy(&q_properties, properties, sizeof(struct queue_properties));
 	q = NULL;
 	kq = NULL;
 
@@ -206,7 +203,7 @@ int pqm_create_queue(struct process_queue_manager *pqm,
 			goto err_create_queue;
 		}
 
-		retval = create_cp_queue(pqm, dev, &q, &q_properties, f, *qid);
+		retval = create_cp_queue(pqm, dev, &q, properties, f, *qid);
 		if (retval != 0)
 			goto err_create_queue;
 		pqn->q = q;
@@ -243,9 +240,8 @@ int pqm_create_queue(struct process_queue_manager *pqm,
 	list_add(&pqn->process_queue_list, &pqm->queues);
 
 	if (q) {
-		*properties = q->properties;
 		pr_debug("PQM done creating queue\n");
-		print_queue_properties(properties);
+		print_queue_properties(&q->properties);
 	}
 
 	return retval;
Signature · 6 lines
2.7.4

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

A message that is not in the archive (sent off-list or not yet received): 1506485396-6326-7-git-send-email-Felix.Kuehling-5C7GfCeVMHo@public.gmane.org

Reviewed-by
#25 lore raw

Re: [PATCH 6/9] drm/amdkfd: Compress unnecessary function parameters

Quoted 101 lines · Felix Kuehling

From: Yong Zhao <[email protected]>

---
 drivers/gpu/drm/amd/amdkfd/kfd_chardev.c               |  3 +--
 drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c                |  5 +++--
 drivers/gpu/drm/amd/amdkfd/kfd_priv.h                  |  2 --
 drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c | 10 +++-------
 4 files changed, 7 insertions(+), 13 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_chardev.c +1 -2
index e4a8c2e..c4632aeb 100644
@@ -282,8 +282,7 @@ static int kfd_ioctl_create_queue(struct file *filep, struct kfd_process *p,
                        p->pasid,
                        dev->id);
 
-       err = pqm_create_queue(&p->pqm, dev, filep, &q_properties,
-                               0, q_properties.type, &queue_id);
+       err = pqm_create_queue(&p->pqm, dev, filep, &q_properties, &queue_id);
        if (err != 0)
                goto err_create_queue;
 
drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c +3 -2
index 7d5635f..c407f6b 100644
@@ -184,9 +184,10 @@ static int dbgdev_register_diq(struct kfd_dbgdev *dbgdev)
        struct kernel_queue *kq = NULL;
        int status;
 
+       properties.type = KFD_QUEUE_TYPE_DIQ;
+
        status = pqm_create_queue(dbgdev->pqm, dbgdev->dev, NULL,
-                               &properties, 0, KFD_QUEUE_TYPE_DIQ,
-                               &qid);
+                               &properties, &qid);
 
        if (status) {
                pr_err("Failed to create DIQ\n");
drivers/gpu/drm/amd/amdkfd/kfd_priv.h +0 -2
index b936a12..ca37210 100644
@@ -675,8 +675,6 @@ int pqm_create_queue(struct process_queue_manager *pqm,
                            struct kfd_dev *dev,
                            struct file *f,
                            struct queue_properties *properties,
-                           unsigned int flags,
-                           enum kfd_queue_type type,
                            unsigned int *qid);
 int pqm_destroy_queue(struct process_queue_manager *pqm, unsigned int qid);
 int pqm_update_queue(struct process_queue_manager *pqm, unsigned int qid,
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +3 -8
index 31ec3ca..63c569b 100644
@@ -142,20 +142,17 @@ int pqm_create_queue(struct process_queue_manager *pqm,
                            struct kfd_dev *dev,
                            struct file *f,
                            struct queue_properties *properties,
-                           unsigned int flags,
-                           enum kfd_queue_type type,
                            unsigned int *qid)
 {
        int retval;
        struct kfd_process_device *pdd;
-       struct queue_properties q_properties;
        struct queue *q;
        struct process_queue_node *pqn;
        struct kernel_queue *kq;
        int num_queues = 0;
        struct queue *cur;
+       enum kfd_queue_type type = properties->type;
 
-       memcpy(&q_properties, properties, sizeof(struct queue_properties));
        q = NULL;
        kq = NULL;
 
@@ -206,7 +203,7 @@ int pqm_create_queue(struct process_queue_manager *pqm,
                        goto err_create_queue;
                }
 
-               retval = create_cp_queue(pqm, dev, &q, &q_properties, f, *qid);
+               retval = create_cp_queue(pqm, dev, &q, properties, f, *qid);
                if (retval != 0)
                        goto err_create_queue;
                pqn->q = q;
@@ -243,9 +240,8 @@ int pqm_create_queue(struct process_queue_manager *pqm,
        list_add(&pqn->process_queue_list, &pqm->queues);
 
        if (q) {
-               *properties = q->properties;
                pr_debug("PQM done creating queue\n");
-               print_queue_properties(properties);
+               print_queue_properties(&q->properties);
        }
 
        return retval;
--
Quoted 2 lines

2.7.4

This patch is:

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

#26 lore raw

PATCH 7/9 drm/amdkfd: Clean up process queue management

In reply to a message not in the archive

Removed unused num_concurrent_processes.

Implemented counting of queues in QPD. This makes counting the queue list repeatedly in several places unnecessary.

---
 drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 5 +++++
 drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c        | 7 +------
 drivers/gpu/drm/amd/amdkfd/kfd_priv.h                  | 1 -
 drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c | 9 ++-------
 4 files changed, 8 insertions(+), 14 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +5 -0
index d0e7288..a7455db 100644
@@ -188,6 +188,7 @@ static int create_queue_nocpsch(struct device_queue_manager *dqm,
 	}
 
 	list_add(&q->list, &qpd->queues_list);
+	qpd->queue_count++;
 	if (q->properties.is_active)
 		dqm->queue_count++;
 
@@ -346,6 +347,7 @@ static int destroy_queue_nocpsch_locked(struct device_queue_manager *dqm,
 
 		deallocate_vmid(dqm, qpd, q);
 	}
+	qpd->queue_count--;
 	if (q->properties.is_active)
 		dqm->queue_count--;
 
@@ -855,6 +857,7 @@ static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q,
 		goto out;
 
 	list_add(&q->list, &qpd->queues_list);
+	qpd->queue_count++;
 	if (q->properties.is_active) {
 		dqm->queue_count++;
 		retval = execute_queues_cpsch(dqm, false);
@@ -1016,6 +1019,7 @@ static int destroy_queue_cpsch(struct device_queue_manager *dqm,
 		dqm->sdma_queue_count--;
 
 	list_del(&q->list);
+	qpd->queue_count--;
 	if (q->properties.is_active)
 		dqm->queue_count--;
 
@@ -1204,6 +1208,7 @@ static int process_termination_cpsch(struct device_queue_manager *dqm,
 			goto out;
 		}
 		list_del(&q->list);
+		qpd->queue_count--;
 		mqd->uninit_mqd(mqd, q->mqd, q->mqd_mem_obj);
 	}
 
drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c +1 -6
index e5a15ba..5d1770e 100644
@@ -140,8 +140,6 @@ static int pm_create_map_process(struct packet_manager *pm, uint32_t *buffer,
 				struct qcm_process_device *qpd)
 {
 	struct pm4_mes_map_process *packet;
-	struct queue *cur;
-	uint32_t num_queues;
 
 	packet = (struct pm4_mes_map_process *)buffer;
 
@@ -156,10 +154,7 @@ static int pm_create_map_process(struct packet_manager *pm, uint32_t *buffer,
 	packet->bitfields10.gds_size = qpd->gds_size;
 	packet->bitfields10.num_gws = qpd->num_gws;
 	packet->bitfields10.num_oac = qpd->num_oac;
-	num_queues = 0;
-	list_for_each_entry(cur, &qpd->queues_list, list)
-		num_queues++;
-	packet->bitfields10.num_queues = (qpd->is_debug) ? 0 : num_queues;
+	packet->bitfields10.num_queues = (qpd->is_debug) ? 0 : qpd->queue_count;
 
 	packet->sh_mem_config = qpd->sh_mem_config;
 	packet->sh_mem_bases = qpd->sh_mem_bases;
drivers/gpu/drm/amd/amdkfd/kfd_priv.h +0 -1
index ca37210..5b33ddd 100644
@@ -408,7 +408,6 @@ struct scheduling_resources {
 struct process_queue_manager {
 	/* data */
 	struct kfd_process	*process;
-	unsigned int		num_concurrent_processes;
 	struct list_head	queues;
 	unsigned long		*queue_slot_bitmap;
 };
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +2 -7
index 63c569b..88ad178 100644
@@ -149,8 +149,6 @@ int pqm_create_queue(struct process_queue_manager *pqm,
 	struct queue *q;
 	struct process_queue_node *pqn;
 	struct kernel_queue *kq;
-	int num_queues = 0;
-	struct queue *cur;
 	enum kfd_queue_type type = properties->type;
 
 	q = NULL;
@@ -168,11 +166,8 @@ int pqm_create_queue(struct process_queue_manager *pqm,
 	 * If we are just about to create DIQ, the is_debug flag is not set yet
 	 * Hence we also check the type as well
 	 */
-	if ((pdd->qpd.is_debug) ||
-		(type == KFD_QUEUE_TYPE_DIQ)) {
-		list_for_each_entry(cur, &pdd->qpd.queues_list, list)
-			num_queues++;
-		if (num_queues >= dev->device_info->max_no_of_hqd/2)
+	if ((pdd->qpd.is_debug) || (type == KFD_QUEUE_TYPE_DIQ)) {
+		if (pdd->qpd.queue_count >= dev->device_info->max_no_of_hqd/2)
 			return -ENOSPC;
 	}
 
Signature · 6 lines
2.7.4

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

A message that is not in the archive (sent off-list or not yet received): 1506485396-6326-8-git-send-email-Felix.Kuehling-5C7GfCeVMHo@public.gmane.org

Reviewed-by
#28 lore raw

Re: [PATCH 7/9] drm/amdkfd: Clean up process queue management

Quoted 122 lines · Felix Kuehling

Removed unused num_concurrent_processes.

Implemented counting of queues in QPD. This makes counting the queue list repeatedly in several places unnecessary.

---
 drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 5 +++++
 drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c        | 7 +------
 drivers/gpu/drm/amd/amdkfd/kfd_priv.h                  | 1 -
 drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c | 9 ++-------
 4 files changed, 8 insertions(+), 14 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +5 -0
index d0e7288..a7455db 100644
@@ -188,6 +188,7 @@ static int create_queue_nocpsch(struct device_queue_manager *dqm,
        }
 
        list_add(&q->list, &qpd->queues_list);
+       qpd->queue_count++;
        if (q->properties.is_active)
                dqm->queue_count++;
 
@@ -346,6 +347,7 @@ static int destroy_queue_nocpsch_locked(struct device_queue_manager *dqm,
 
                deallocate_vmid(dqm, qpd, q);
        }
+       qpd->queue_count--;
        if (q->properties.is_active)
                dqm->queue_count--;
 
@@ -855,6 +857,7 @@ static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q,
                goto out;
 
        list_add(&q->list, &qpd->queues_list);
+       qpd->queue_count++;
        if (q->properties.is_active) {
                dqm->queue_count++;
                retval = execute_queues_cpsch(dqm, false);
@@ -1016,6 +1019,7 @@ static int destroy_queue_cpsch(struct device_queue_manager *dqm,
                dqm->sdma_queue_count--;
 
        list_del(&q->list);
+       qpd->queue_count--;
        if (q->properties.is_active)
                dqm->queue_count--;
 
@@ -1204,6 +1208,7 @@ static int process_termination_cpsch(struct device_queue_manager *dqm,
                        goto out;
                }
                list_del(&q->list);
+               qpd->queue_count--;
                mqd->uninit_mqd(mqd, q->mqd, q->mqd_mem_obj);
        }
 
drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c +1 -6
index e5a15ba..5d1770e 100644
@@ -140,8 +140,6 @@ static int pm_create_map_process(struct packet_manager *pm, uint32_t *buffer,
                                struct qcm_process_device *qpd)
 {
        struct pm4_mes_map_process *packet;
-       struct queue *cur;
-       uint32_t num_queues;
 
        packet = (struct pm4_mes_map_process *)buffer;
 
@@ -156,10 +154,7 @@ static int pm_create_map_process(struct packet_manager *pm, uint32_t *buffer,
        packet->bitfields10.gds_size = qpd->gds_size;
        packet->bitfields10.num_gws = qpd->num_gws;
        packet->bitfields10.num_oac = qpd->num_oac;
-       num_queues = 0;
-       list_for_each_entry(cur, &qpd->queues_list, list)
-               num_queues++;
-       packet->bitfields10.num_queues = (qpd->is_debug) ? 0 : num_queues;
+       packet->bitfields10.num_queues = (qpd->is_debug) ? 0 : qpd->queue_count;
 
        packet->sh_mem_config = qpd->sh_mem_config;
        packet->sh_mem_bases = qpd->sh_mem_bases;
drivers/gpu/drm/amd/amdkfd/kfd_priv.h +0 -1
index ca37210..5b33ddd 100644
@@ -408,7 +408,6 @@ struct scheduling_resources {
 struct process_queue_manager {
        /* data */
        struct kfd_process      *process;
-       unsigned int            num_concurrent_processes;
        struct list_head        queues;
        unsigned long           *queue_slot_bitmap;
 };
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +2 -8
index 63c569b..88ad178 100644
@@ -149,8 +149,6 @@ int pqm_create_queue(struct process_queue_manager *pqm,
        struct queue *q;
        struct process_queue_node *pqn;
        struct kernel_queue *kq;
-       int num_queues = 0;
-       struct queue *cur;
        enum kfd_queue_type type = properties->type;
 
        q = NULL;
@@ -168,11 +166,8 @@ int pqm_create_queue(struct process_queue_manager *pqm,
         * If we are just about to create DIQ, the is_debug flag is not set yet
         * Hence we also check the type as well
         */
-       if ((pdd->qpd.is_debug) ||
-               (type == KFD_QUEUE_TYPE_DIQ)) {
-               list_for_each_entry(cur, &pdd->qpd.queues_list, list)
-                       num_queues++;
-               if (num_queues >= dev->device_info->max_no_of_hqd/2)
+       if ((pdd->qpd.is_debug) || (type == KFD_QUEUE_TYPE_DIQ)) {
+               if (pdd->qpd.queue_count >= dev->device_info->max_no_of_hqd/2)
                        return -ENOSPC;
        }
 
--
Quoted 2 lines

2.7.4

This patch is:

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

#29 lore raw

PATCH 8/9 drm/amdkfd: Limit queue number per process and device to 127

In reply to a message not in the archive

HWS uses bit 7 in the queue number of the map process packet for an undocumented feature. Therefore the queue number per process and device must be 127 or less.

---
 drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +6 -4
index 88ad178..5129dc1 100644
@@ -150,6 +150,7 @@ int pqm_create_queue(struct process_queue_manager *pqm,
 	struct process_queue_node *pqn;
 	struct kernel_queue *kq;
 	enum kfd_queue_type type = properties->type;
+	unsigned int max_queues = 127; /* HWS limit */
 
 	q = NULL;
 	kq = NULL;
@@ -166,10 +167,11 @@ int pqm_create_queue(struct process_queue_manager *pqm,
 	 * If we are just about to create DIQ, the is_debug flag is not set yet
 	 * Hence we also check the type as well
 	 */
-	if ((pdd->qpd.is_debug) || (type == KFD_QUEUE_TYPE_DIQ)) {
-		if (pdd->qpd.queue_count >= dev->device_info->max_no_of_hqd/2)
-			return -ENOSPC;
-	}
+	if ((pdd->qpd.is_debug) || (type == KFD_QUEUE_TYPE_DIQ))
+		max_queues = dev->device_info->max_no_of_hqd/2;
+
+	if (pdd->qpd.queue_count >= max_queues)
+		return -ENOSPC;
 
 	retval = find_available_queue_slot(pqm, qid);
 	if (retval != 0)
Signature · 6 lines
2.7.4

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

A message that is not in the archive (sent off-list or not yet received): 1506485396-6326-9-git-send-email-Felix.Kuehling-5C7GfCeVMHo@public.gmane.org

Reviewed-by
#31 lore raw

Re: [PATCH 8/9] drm/amdkfd: Limit queue number per process and device to 127

Quoted 38 lines · Felix Kuehling

HWS uses bit 7 in the queue number of the map process packet for an undocumented feature. Therefore the queue number per process and device must be 127 or less.

---
 drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +6 -5
index 88ad178..5129dc1 100644
@@ -150,6 +150,7 @@ int pqm_create_queue(struct process_queue_manager *pqm,
        struct process_queue_node *pqn;
        struct kernel_queue *kq;
        enum kfd_queue_type type = properties->type;
+       unsigned int max_queues = 127; /* HWS limit */
 
        q = NULL;
        kq = NULL;
@@ -166,10 +167,11 @@ int pqm_create_queue(struct process_queue_manager *pqm,
         * If we are just about to create DIQ, the is_debug flag is not set yet
         * Hence we also check the type as well
         */
-       if ((pdd->qpd.is_debug) || (type == KFD_QUEUE_TYPE_DIQ)) {
-               if (pdd->qpd.queue_count >= dev->device_info->max_no_of_hqd/2)
-                       return -ENOSPC;
-       }
+       if ((pdd->qpd.is_debug) || (type == KFD_QUEUE_TYPE_DIQ))
+               max_queues = dev->device_info->max_no_of_hqd/2;
+
+       if (pdd->qpd.queue_count >= max_queues)
+               return -ENOSPC;
 
        retval = find_available_queue_slot(pqm, qid);
        if (retval != 0)
--
Quoted 2 lines

2.7.4

This patch is:

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

#32 lore raw

PATCH 9/9 drm/amdkfd: Improve multiple SDMA queues support per process

In reply to a message not in the archive

From: shaoyunl <[email protected]>

HWS does not support over-subscription and the scheduler can not internally modify the engine. Driver needs to program the correct engine ID.

Fix the queue and engine selection to create queues on alternating SDMA engines. This allows concurrent bi-directional DMA transfers in a process that creates two SDMA queues.

---
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 29 +++++++++++-----------
 drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c    |  2 +-
 2 files changed, 16 insertions(+), 15 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +15 -14
index a7455db..64878b9 100644
@@ -621,8 +621,8 @@ static int create_sdma_queue_nocpsch(struct device_queue_manager *dqm,
 	if (retval)
 		return retval;
 
-	q->properties.sdma_queue_id = q->sdma_id % CIK_SDMA_QUEUES_PER_ENGINE;
-	q->properties.sdma_engine_id = q->sdma_id / CIK_SDMA_ENGINE_NUM;
+	q->properties.sdma_queue_id = q->sdma_id / CIK_SDMA_QUEUES_PER_ENGINE;
+	q->properties.sdma_engine_id = q->sdma_id % CIK_SDMA_QUEUES_PER_ENGINE;
 
 	pr_debug("SDMA id is:    %d\n", q->sdma_id);
 	pr_debug("SDMA queue id: %d\n", q->properties.sdma_queue_id);
@@ -704,6 +704,7 @@ static int initialize_cpsch(struct device_queue_manager *dqm)
 	dqm->queue_count = dqm->processes_count = 0;
 	dqm->sdma_queue_count = 0;
 	dqm->active_runlist = false;
+	dqm->sdma_bitmap = (1 << CIK_SDMA_QUEUES) - 1;
 	retval = dqm->ops_asic_specific.initialize(dqm);
 	if (retval)
 		mutex_destroy(&dqm->lock);
@@ -811,14 +812,6 @@ static void destroy_kernel_queue_cpsch(struct device_queue_manager *dqm,
 	mutex_unlock(&dqm->lock);
 }
 
-static void select_sdma_engine_id(struct queue *q)
-{
-	static int sdma_id;
-
-	q->sdma_id = sdma_id;
-	sdma_id = (sdma_id + 1) % 2;
-}
-
 static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q,
 			struct qcm_process_device *qpd, int *allocate_vmid)
 {
@@ -839,9 +832,15 @@ static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q,
 		goto out;
 	}
 
-	if (q->properties.type == KFD_QUEUE_TYPE_SDMA)
-		select_sdma_engine_id(q);
-
+	if (q->properties.type == KFD_QUEUE_TYPE_SDMA) {
+		retval = allocate_sdma_queue(dqm, &q->sdma_id);
+		if (retval != 0)
+			goto out;
+		q->properties.sdma_queue_id =
+			q->sdma_id / CIK_SDMA_QUEUES_PER_ENGINE;
+		q->properties.sdma_engine_id =
+			q->sdma_id % CIK_SDMA_QUEUES_PER_ENGINE;
+	}
 	mqd = dqm->ops.get_mqd_manager(dqm,
 			get_mqd_type_from_queue_type(q->properties.type));
 
@@ -1015,8 +1014,10 @@ static int destroy_queue_cpsch(struct device_queue_manager *dqm,
 		goto failed;
 	}
 
-	if (q->properties.type == KFD_QUEUE_TYPE_SDMA)
+	if (q->properties.type == KFD_QUEUE_TYPE_SDMA) {
 		dqm->sdma_queue_count--;
+		deallocate_sdma_queue(dqm, q->sdma_id);
+	}
 
 	list_del(&q->list);
 	qpd->queue_count--;
drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c +1 -1
index 5d1770e..16da8ad 100644
@@ -203,7 +203,7 @@ static int pm_create_map_queue(struct packet_manager *pm, uint32_t *buffer,
 			queue_type__mes_map_queues__debug_interface_queue_vi;
 		break;
 	case KFD_QUEUE_TYPE_SDMA:
-		packet->bitfields2.engine_sel =
+		packet->bitfields2.engine_sel = q->properties.sdma_engine_id +
 				engine_sel__mes_map_queues__sdma0_vi;
 		use_static = false; /* no static queues under SDMA */
 		break;
Signature · 6 lines
2.7.4

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

A message that is not in the archive (sent off-list or not yet received): 1506485396-6326-10-git-send-email-Felix.Kuehling-5C7GfCeVMHo@public.gmane.org

#34 lore raw

Re: [PATCH 9/9] drm/amdkfd: Improve multiple SDMA queues support per process

Quoted 99 lines · Felix Kuehling

From: shaoyunl <[email protected]>

HWS does not support over-subscription and the scheduler can not internally modify the engine. Driver needs to program the correct engine ID.

Fix the queue and engine selection to create queues on alternating SDMA engines. This allows concurrent bi-directional DMA transfers in a process that creates two SDMA queues.

---
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 29 +++++++++++-----------
 drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c    |  2 +-
 2 files changed, 16 insertions(+), 15 deletions(-)
drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +15 -14
index a7455db..64878b9 100644
@@ -621,8 +621,8 @@ static int create_sdma_queue_nocpsch(struct device_queue_manager *dqm,
        if (retval)
                return retval;
 
-       q->properties.sdma_queue_id = q->sdma_id % CIK_SDMA_QUEUES_PER_ENGINE;
-       q->properties.sdma_engine_id = q->sdma_id / CIK_SDMA_ENGINE_NUM;
+       q->properties.sdma_queue_id = q->sdma_id / CIK_SDMA_QUEUES_PER_ENGINE;
+       q->properties.sdma_engine_id = q->sdma_id % CIK_SDMA_QUEUES_PER_ENGINE;
 
        pr_debug("SDMA id is:    %d\n", q->sdma_id);
        pr_debug("SDMA queue id: %d\n", q->properties.sdma_queue_id);
@@ -704,6 +704,7 @@ static int initialize_cpsch(struct device_queue_manager *dqm)
        dqm->queue_count = dqm->processes_count = 0;
        dqm->sdma_queue_count = 0;
        dqm->active_runlist = false;
+       dqm->sdma_bitmap = (1 << CIK_SDMA_QUEUES) - 1;
        retval = dqm->ops_asic_specific.initialize(dqm);
        if (retval)
                mutex_destroy(&dqm->lock);
@@ -811,14 +812,6 @@ static void destroy_kernel_queue_cpsch(struct device_queue_manager *dqm,
        mutex_unlock(&dqm->lock);
 }
 
-static void select_sdma_engine_id(struct queue *q)
-{
-       static int sdma_id;
-
-       q->sdma_id = sdma_id;
-       sdma_id = (sdma_id + 1) % 2;
-}
-
 static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q,
                        struct qcm_process_device *qpd, int *allocate_vmid)
 {
@@ -839,9 +832,15 @@ static int create_queue_cpsch(struct device_queue_manager *dqm, struct queue *q,
                goto out;
        }
 
-       if (q->properties.type == KFD_QUEUE_TYPE_SDMA)
-               select_sdma_engine_id(q);
-
+       if (q->properties.type == KFD_QUEUE_TYPE_SDMA) {
+               retval = allocate_sdma_queue(dqm, &q->sdma_id);
+               if (retval != 0)
+                       goto out;
+               q->properties.sdma_queue_id =
+                       q->sdma_id / CIK_SDMA_QUEUES_PER_ENGINE;
+               q->properties.sdma_engine_id =
+                       q->sdma_id % CIK_SDMA_QUEUES_PER_ENGINE;
+       }
        mqd = dqm->ops.get_mqd_manager(dqm,
                        get_mqd_type_from_queue_type(q->properties.type));
 
@@ -1015,8 +1014,10 @@ static int destroy_queue_cpsch(struct device_queue_manager *dqm,
                goto failed;
        }
 
-       if (q->properties.type == KFD_QUEUE_TYPE_SDMA)
+       if (q->properties.type == KFD_QUEUE_TYPE_SDMA) {
                dqm->sdma_queue_count--;
+               deallocate_sdma_queue(dqm, q->sdma_id);
+       }
 
        list_del(&q->list);
        qpd->queue_count--;
drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c +1 -2
index 5d1770e..16da8ad 100644
@@ -203,7 +203,7 @@ static int pm_create_map_queue(struct packet_manager *pm, uint32_t *buffer,
                        queue_type__mes_map_queues__debug_interface_queue_vi;
                break;
        case KFD_QUEUE_TYPE_SDMA:
-               packet->bitfields2.engine_sel =
+               packet->bitfields2.engine_sel = q->properties.sdma_engine_id +
                                engine_sel__mes_map_queues__sdma0_vi;
                use_static = false; /* no static queues under SDMA */
                break;
--
Quoted 2 lines

2.7.4

Applied to -next
Thanks,
Oded
_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

#35 lore raw
In reply to a message not in the archive
Quoted 8 lines · Felix Kuehling

These patches cherry-pick most fixes, improvements and refactoring in the device queue manager from our internal branch. I squashed some patches that applied incremental fixes to the same code. Patch 5 is the extreme case that comes with a bunch of refactoring too. I think I squashed about a dozen patches by 5 authors that all overlapped and and applied incremental fixes and improvements to process termination handling.

Quoted 4 lines

The last missing fixes in kfd_device_queue_manager.c are related to SDMA, which I'll leave for another patch series that also need changes in amdgpu. It will also add SDMA support for CZ. That's another 11 patches that I may be able to squash to 2 or 3.

Hi Felix,
Thanks for the patches.
I'm sorry for the delay in reviewing them. It's the month of the holidays here so I have little time in front of a computer.

Oded

Quoted 26 lines

Felix Kuehling (4):
drm/amdkfd: Fix MQD updates
drm/amdkfd: Improve process termination handling in the queue manager drm/amdkfd: Clean up process queue management
drm/amdkfd: Limit queue number per process and device to 127

Yong Zhao (4):
drm/amdkfd: Avoid name confusion involved in queue unmapping drm/amdkfd: Simplify execute and unmap queue APIs drm/amdkfd: Avoid submitting an unnecessary packet to HWS drm/amdkfd: Compress unnecessary function parameters

shaoyunl (1):
drm/amdkfd: Improve multiple SDMA queues support per process

 drivers/gpu/drm/amd/amdkfd/kfd_chardev.c           |   3 +-
 drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c            |   5 +-
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 376 ++++++++++++++-------
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.h  |   5 +
 drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c    |  27 +-
 drivers/gpu/drm/amd/amdkfd/kfd_priv.h              |  41 ++-
 drivers/gpu/drm/amd/amdkfd/kfd_process.c           |  36 +-
 .../gpu/drm/amd/amdkfd/kfd_process_queue_manager.c |  62 ++--
 8 files changed, 348 insertions(+), 207 deletions(-)
Quoted 3 lines

--
2.7.4

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

A message that is not in the archive (sent off-list or not yet received): CAFCwf11iMcn18Hqfh2563qZXkL9y5oKbWW4Pn04-7-ikG2P=aA-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org

#37 lore raw
Quoted 9 lines · Oded Gabbay
Quoted 8 lines · Felix Kuehling

These patches cherry-pick most fixes, improvements and refactoring in the device queue manager from our internal branch. I squashed some patches that applied incremental fixes to the same code. Patch 5 is the extreme case that comes with a bunch of refactoring too. I think I squashed about a dozen patches by 5 authors that all overlapped and and applied incremental fixes and improvements to process termination handling.

Quoted 8 lines
Quoted 4 lines

The last missing fixes in kfd_device_queue_manager.c are related to SDMA, which I'll leave for another patch series that also need changes in amdgpu. It will also add SDMA support for CZ. That's another 11 patches that I may be able to squash to 2 or 3.

Hi Felix,
Thanks for the patches.
I'm sorry for the delay in reviewing them. It's the month of the holidays here so I have little time in front of a computer.

I hope you enjoyed the holidays. Thanks for applying the patches.

I've been busy working on the event handling code. I saw a lot of opportunity for cleanups and improvements and also had some internal feedback that event handling performance was slow with many signal events. I hope to have a patch series ready for review by the end of this week. After that I want to get back to SDMA support.

Regards,
  Felix

Quoted 31 lines

Oded

Quoted 28 lines

Felix Kuehling (4):
drm/amdkfd: Fix MQD updates
drm/amdkfd: Improve process termination handling in the queue manager drm/amdkfd: Clean up process queue management
drm/amdkfd: Limit queue number per process and device to 127

Yong Zhao (4):
drm/amdkfd: Avoid name confusion involved in queue unmapping drm/amdkfd: Simplify execute and unmap queue APIs drm/amdkfd: Avoid submitting an unnecessary packet to HWS drm/amdkfd: Compress unnecessary function parameters

shaoyunl (1):
drm/amdkfd: Improve multiple SDMA queues support per process

 drivers/gpu/drm/amd/amdkfd/kfd_chardev.c           |   3 +-
 drivers/gpu/drm/amd/amdkfd/kfd_dbgdev.c            |   5 +-
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.c  | 376 ++++++++++++++-------
 .../gpu/drm/amd/amdkfd/kfd_device_queue_manager.h  |   5 +
 drivers/gpu/drm/amd/amdkfd/kfd_packet_manager.c    |  27 +-
 drivers/gpu/drm/amd/amdkfd/kfd_priv.h              |  41 ++-
 drivers/gpu/drm/amd/amdkfd/kfd_process.c           |  36 +-
 .../gpu/drm/amd/amdkfd/kfd_process_queue_manager.c |  62 ++--
 8 files changed, 348 insertions(+), 207 deletions(-)

--
2.7.4

_______________________________________________
amd-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/amd-gfx