[PATCH 1/4] drm/scheduler: trivial error handling fix

[PATCH 1/4] drm/scheduler: trivial error handling fix

[Christian König]

Return -ENOMEM when allocating the rq_list fails.

Signed-off-by: Christian König <christian.koenig@amd.com>
---
 drivers/gpu/drm/scheduler/gpu_scheduler.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/drivers/gpu/drm/scheduler/gpu_scheduler.c b/drivers/gpu/drm/scheduler/gpu_scheduler.c
index f566405f49e3..85c1f95752cc 100644
--- a/drivers/gpu/drm/scheduler/gpu_scheduler.c
+++ b/drivers/gpu/drm/scheduler/gpu_scheduler.c
@@ -191,6 +191,9 @@ int drm_sched_entity_init(struct drm_sched_entity *entity,
 	entity->num_rq_list = num_rq_list;
 	entity->rq_list = kcalloc(num_rq_list, sizeof(struct drm_sched_rq *),
 				GFP_KERNEL);
+	if (!entity->rq_list)
+		return -ENOMEM;
+
 	for (i = 0; i < num_rq_list; ++i)
 		entity->rq_list[i] = rq_list[i];
 	entity->last_scheduled = NULL;
-- 
2.14.1

_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel

[PATCH 2/4] drm/scheduler: move entity handling into separate file

[Christian König]

This is complex enough on it's own. Move it into a separate C file.

Signed-off-by: Christian König <christian.koenig@amd.com>
---
 drivers/gpu/drm/scheduler/Makefile        |   2 +-
 drivers/gpu/drm/scheduler/gpu_scheduler.c | 441 +---------------------------
 drivers/gpu/drm/scheduler/sched_entity.c  | 459 ++++++++++++++++++++++++++++++
 include/drm/gpu_scheduler.h               |  28 +-
 4 files changed, 484 insertions(+), 446 deletions(-)
 create mode 100644 drivers/gpu/drm/scheduler/sched_entity.c

diff --git a/drivers/gpu/drm/scheduler/Makefile b/drivers/gpu/drm/scheduler/Makefile
index 7665883f81d4..f23785d4b3c8 100644
--- a/drivers/gpu/drm/scheduler/Makefile
+++ b/drivers/gpu/drm/scheduler/Makefile
@@ -20,6 +20,6 @@
 # OTHER DEALINGS IN THE SOFTWARE.
 #
 #
-gpu-sched-y := gpu_scheduler.o sched_fence.o
+gpu-sched-y := gpu_scheduler.o sched_fence.o sched_entity.o
 
 obj-$(CONFIG_DRM_SCHED) += gpu-sched.o
diff --git a/drivers/gpu/drm/scheduler/gpu_scheduler.c b/drivers/gpu/drm/scheduler/gpu_scheduler.c
index 85c1f95752cc..9ca741f3a0bc 100644
--- a/drivers/gpu/drm/scheduler/gpu_scheduler.c
+++ b/drivers/gpu/drm/scheduler/gpu_scheduler.c
@@ -58,8 +58,6 @@
 #define to_drm_sched_job(sched_job)		\
 		container_of((sched_job), struct drm_sched_job, queue_node)
 
-static bool drm_sched_entity_is_ready(struct drm_sched_entity *entity);
-static void drm_sched_wakeup(struct drm_gpu_scheduler *sched);
 static void drm_sched_process_job(struct dma_fence *f, struct dma_fence_cb *cb);
 
 /**
@@ -86,8 +84,8 @@ static void drm_sched_rq_init(struct drm_gpu_scheduler *sched,
  *
  * Adds a scheduler entity to the run queue.
  */
-static void drm_sched_rq_add_entity(struct drm_sched_rq *rq,
-				    struct drm_sched_entity *entity)
+void drm_sched_rq_add_entity(struct drm_sched_rq *rq,
+			     struct drm_sched_entity *entity)
 {
 	if (!list_empty(&entity->list))
 		return;
@@ -104,8 +102,8 @@ static void drm_sched_rq_add_entity(struct drm_sched_rq *rq,
  *
  * Removes a scheduler entity from the run queue.
  */
-static void drm_sched_rq_remove_entity(struct drm_sched_rq *rq,
-				       struct drm_sched_entity *entity)
+void drm_sched_rq_remove_entity(struct drm_sched_rq *rq,
+				struct drm_sched_entity *entity)
 {
 	if (list_empty(&entity->list))
 		return;
@@ -158,301 +156,6 @@ drm_sched_rq_select_entity(struct drm_sched_rq *rq)
 	return NULL;
 }
 
-/**
- * drm_sched_entity_init - Init a context entity used by scheduler when
- * submit to HW ring.
- *
- * @entity: scheduler entity to init
- * @rq_list: the list of run queue on which jobs from this
- *           entity can be submitted
- * @num_rq_list: number of run queue in rq_list
- * @guilty: atomic_t set to 1 when a job on this queue
- *          is found to be guilty causing a timeout
- *
- * Note: the rq_list should have atleast one element to schedule
- *       the entity
- *
- * Returns 0 on success or a negative error code on failure.
-*/
-int drm_sched_entity_init(struct drm_sched_entity *entity,
-			  struct drm_sched_rq **rq_list,
-			  unsigned int num_rq_list,
-			  atomic_t *guilty)
-{
-	int i;
-
-	if (!(entity && rq_list && num_rq_list > 0 && rq_list[0]))
-		return -EINVAL;
-
-	memset(entity, 0, sizeof(struct drm_sched_entity));
-	INIT_LIST_HEAD(&entity->list);
-	entity->rq = rq_list[0];
-	entity->guilty = guilty;
-	entity->num_rq_list = num_rq_list;
-	entity->rq_list = kcalloc(num_rq_list, sizeof(struct drm_sched_rq *),
-				GFP_KERNEL);
-	if (!entity->rq_list)
-		return -ENOMEM;
-
-	for (i = 0; i < num_rq_list; ++i)
-		entity->rq_list[i] = rq_list[i];
-	entity->last_scheduled = NULL;
-
-	spin_lock_init(&entity->rq_lock);
-	spsc_queue_init(&entity->job_queue);
-
-	atomic_set(&entity->fence_seq, 0);
-	entity->fence_context = dma_fence_context_alloc(2);
-
-	return 0;
-}
-EXPORT_SYMBOL(drm_sched_entity_init);
-
-/**
- * drm_sched_entity_is_idle - Check if entity is idle
- *
- * @entity: scheduler entity
- *
- * Returns true if the entity does not have any unscheduled jobs.
- */
-static bool drm_sched_entity_is_idle(struct drm_sched_entity *entity)
-{
-	rmb();
-
-	if (list_empty(&entity->list) ||
-	    spsc_queue_peek(&entity->job_queue) == NULL)
-		return true;
-
-	return false;
-}
-
-/**
- * drm_sched_entity_is_ready - Check if entity is ready
- *
- * @entity: scheduler entity
- *
- * Return true if entity could provide a job.
- */
-static bool drm_sched_entity_is_ready(struct drm_sched_entity *entity)
-{
-	if (spsc_queue_peek(&entity->job_queue) == NULL)
-		return false;
-
-	if (READ_ONCE(entity->dependency))
-		return false;
-
-	return true;
-}
-
-/**
- * drm_sched_entity_get_free_sched - Get the rq from rq_list with least load
- *
- * @entity: scheduler entity
- *
- * Return the pointer to the rq with least load.
- */
-static struct drm_sched_rq *
-drm_sched_entity_get_free_sched(struct drm_sched_entity *entity)
-{
-	struct drm_sched_rq *rq = NULL;
-	unsigned int min_jobs = UINT_MAX, num_jobs;
-	int i;
-
-	for (i = 0; i < entity->num_rq_list; ++i) {
-		num_jobs = atomic_read(&entity->rq_list[i]->sched->num_jobs);
-		if (num_jobs < min_jobs) {
-			min_jobs = num_jobs;
-			rq = entity->rq_list[i];
-		}
-	}
-
-	return rq;
-}
-
-static void drm_sched_entity_kill_jobs_cb(struct dma_fence *f,
-				    struct dma_fence_cb *cb)
-{
-	struct drm_sched_job *job = container_of(cb, struct drm_sched_job,
-						 finish_cb);
-	drm_sched_fence_finished(job->s_fence);
-	WARN_ON(job->s_fence->parent);
-	dma_fence_put(&job->s_fence->finished);
-	job->sched->ops->free_job(job);
-}
-
-
-/**
- * drm_sched_entity_flush - Flush a context entity
- *
- * @entity: scheduler entity
- * @timeout: time to wait in for Q to become empty in jiffies.
- *
- * Splitting drm_sched_entity_fini() into two functions, The first one does the waiting,
- * removes the entity from the runqueue and returns an error when the process was killed.
- *
- * Returns the remaining time in jiffies left from the input timeout
- */
-long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout)
-{
-	struct drm_gpu_scheduler *sched;
-	struct task_struct *last_user;
-	long ret = timeout;
-
-	sched = entity->rq->sched;
-	/**
-	 * The client will not queue more IBs during this fini, consume existing
-	 * queued IBs or discard them on SIGKILL
-	*/
-	if (current->flags & PF_EXITING) {
-		if (timeout)
-			ret = wait_event_timeout(
-					sched->job_scheduled,
-					drm_sched_entity_is_idle(entity),
-					timeout);
-	} else
-		wait_event_killable(sched->job_scheduled, drm_sched_entity_is_idle(entity));
-
-
-	/* For killed process disable any more IBs enqueue right now */
-	last_user = cmpxchg(&entity->last_user, current->group_leader, NULL);
-	if ((!last_user || last_user == current->group_leader) &&
-	    (current->flags & PF_EXITING) && (current->exit_code == SIGKILL))
-		drm_sched_rq_remove_entity(entity->rq, entity);
-
-	return ret;
-}
-EXPORT_SYMBOL(drm_sched_entity_flush);
-
-/**
- * drm_sched_entity_cleanup - Destroy a context entity
- *
- * @entity: scheduler entity
- *
- * This should be called after @drm_sched_entity_do_release. It goes over the
- * entity and signals all jobs with an error code if the process was killed.
- *
- */
-void drm_sched_entity_fini(struct drm_sched_entity *entity)
-{
-	struct drm_gpu_scheduler *sched;
-
-	sched = entity->rq->sched;
-	drm_sched_rq_remove_entity(entity->rq, entity);
-
-	/* Consumption of existing IBs wasn't completed. Forcefully
-	 * remove them here.
-	 */
-	if (spsc_queue_peek(&entity->job_queue)) {
-		struct drm_sched_job *job;
-		int r;
-
-		/* Park the kernel for a moment to make sure it isn't processing
-		 * our enity.
-		 */
-		kthread_park(sched->thread);
-		kthread_unpark(sched->thread);
-		if (entity->dependency) {
-			dma_fence_remove_callback(entity->dependency,
-						  &entity->cb);
-			dma_fence_put(entity->dependency);
-			entity->dependency = NULL;
-		}
-
-		while ((job = to_drm_sched_job(spsc_queue_pop(&entity->job_queue)))) {
-			struct drm_sched_fence *s_fence = job->s_fence;
-			drm_sched_fence_scheduled(s_fence);
-			dma_fence_set_error(&s_fence->finished, -ESRCH);
-
-			/*
-			 * When pipe is hanged by older entity, new entity might
-			 * not even have chance to submit it's first job to HW
-			 * and so entity->last_scheduled will remain NULL
-			 */
-			if (!entity->last_scheduled) {
-				drm_sched_entity_kill_jobs_cb(NULL, &job->finish_cb);
-			} else {
-				r = dma_fence_add_callback(entity->last_scheduled, &job->finish_cb,
-								drm_sched_entity_kill_jobs_cb);
-				if (r == -ENOENT)
-					drm_sched_entity_kill_jobs_cb(NULL, &job->finish_cb);
-				else if (r)
-					DRM_ERROR("fence add callback failed (%d)\n", r);
-			}
-		}
-	}
-
-	dma_fence_put(entity->last_scheduled);
-	entity->last_scheduled = NULL;
-	kfree(entity->rq_list);
-}
-EXPORT_SYMBOL(drm_sched_entity_fini);
-
-/**
- * drm_sched_entity_fini - Destroy a context entity
- *
- * @entity: scheduler entity
- *
- * Calls drm_sched_entity_do_release() and drm_sched_entity_cleanup()
- */
-void drm_sched_entity_destroy(struct drm_sched_entity *entity)
-{
-	drm_sched_entity_flush(entity, MAX_WAIT_SCHED_ENTITY_Q_EMPTY);
-	drm_sched_entity_fini(entity);
-}
-EXPORT_SYMBOL(drm_sched_entity_destroy);
-
-static void drm_sched_entity_wakeup(struct dma_fence *f, struct dma_fence_cb *cb)
-{
-	struct drm_sched_entity *entity =
-		container_of(cb, struct drm_sched_entity, cb);
-	entity->dependency = NULL;
-	dma_fence_put(f);
-	drm_sched_wakeup(entity->rq->sched);
-}
-
-static void drm_sched_entity_clear_dep(struct dma_fence *f, struct dma_fence_cb *cb)
-{
-	struct drm_sched_entity *entity =
-		container_of(cb, struct drm_sched_entity, cb);
-	entity->dependency = NULL;
-	dma_fence_put(f);
-}
-
-/**
- * drm_sched_entity_set_rq_priority - helper for drm_sched_entity_set_priority
- */
-static void drm_sched_entity_set_rq_priority(struct drm_sched_rq **rq,
-					     enum drm_sched_priority priority)
-{
-	*rq = &(*rq)->sched->sched_rq[priority];
-}
-
-/**
- * drm_sched_entity_set_priority - Sets priority of the entity
- *
- * @entity: scheduler entity
- * @priority: scheduler priority
- *
- * Update the priority of runqueus used for the entity.
- */
-void drm_sched_entity_set_priority(struct drm_sched_entity *entity,
-				   enum drm_sched_priority priority)
-{
-	unsigned int i;
-
-	spin_lock(&entity->rq_lock);
-
-	for (i = 0; i < entity->num_rq_list; ++i)
-		drm_sched_entity_set_rq_priority(&entity->rq_list[i], priority);
-
-	drm_sched_rq_remove_entity(entity->rq, entity);
-	drm_sched_entity_set_rq_priority(&entity->rq, priority);
-	drm_sched_rq_add_entity(entity->rq, entity);
-
-	spin_unlock(&entity->rq_lock);
-}
-EXPORT_SYMBOL(drm_sched_entity_set_priority);
-
 /**
  * drm_sched_dependency_optimized
  *
@@ -479,140 +182,6 @@ bool drm_sched_dependency_optimized(struct dma_fence* fence,
 }
 EXPORT_SYMBOL(drm_sched_dependency_optimized);
 
-static bool drm_sched_entity_add_dependency_cb(struct drm_sched_entity *entity)
-{
-	struct drm_gpu_scheduler *sched = entity->rq->sched;
-	struct dma_fence * fence = entity->dependency;
-	struct drm_sched_fence *s_fence;
-
-	if (fence->context == entity->fence_context ||
-            fence->context == entity->fence_context + 1) {
-                /*
-                 * Fence is a scheduled/finished fence from a job
-                 * which belongs to the same entity, we can ignore
-                 * fences from ourself
-                 */
-		dma_fence_put(entity->dependency);
-		return false;
-	}
-
-	s_fence = to_drm_sched_fence(fence);
-	if (s_fence && s_fence->sched == sched) {
-
-		/*
-		 * Fence is from the same scheduler, only need to wait for
-		 * it to be scheduled
-		 */
-		fence = dma_fence_get(&s_fence->scheduled);
-		dma_fence_put(entity->dependency);
-		entity->dependency = fence;
-		if (!dma_fence_add_callback(fence, &entity->cb,
-					    drm_sched_entity_clear_dep))
-			return true;
-
-		/* Ignore it when it is already scheduled */
-		dma_fence_put(fence);
-		return false;
-	}
-
-	if (!dma_fence_add_callback(entity->dependency, &entity->cb,
-				    drm_sched_entity_wakeup))
-		return true;
-
-	dma_fence_put(entity->dependency);
-	return false;
-}
-
-static struct drm_sched_job *
-drm_sched_entity_pop_job(struct drm_sched_entity *entity)
-{
-	struct drm_gpu_scheduler *sched = entity->rq->sched;
-	struct drm_sched_job *sched_job = to_drm_sched_job(
-						spsc_queue_peek(&entity->job_queue));
-
-	if (!sched_job)
-		return NULL;
-
-	while ((entity->dependency = sched->ops->dependency(sched_job, entity))) {
-		if (drm_sched_entity_add_dependency_cb(entity)) {
-
-			trace_drm_sched_job_wait_dep(sched_job, entity->dependency);
-			return NULL;
-		}
-	}
-
-	/* skip jobs from entity that marked guilty */
-	if (entity->guilty && atomic_read(entity->guilty))
-		dma_fence_set_error(&sched_job->s_fence->finished, -ECANCELED);
-
-	dma_fence_put(entity->last_scheduled);
-	entity->last_scheduled = dma_fence_get(&sched_job->s_fence->finished);
-
-	spsc_queue_pop(&entity->job_queue);
-	return sched_job;
-}
-
-/**
- * drm_sched_entity_select_rq - select a new rq for the entity
- *
- * @entity: scheduler entity
- *
- * Check all prerequisites and select a new rq for the entity for load
- * balancing.
- */
-static void drm_sched_entity_select_rq(struct drm_sched_entity *entity)
-{
-	struct dma_fence *fence;
-	struct drm_sched_rq *rq;
-
-	if (!spsc_queue_count(&entity->job_queue) == 0 ||
-	    entity->num_rq_list <= 1)
-		return;
-
-	fence = READ_ONCE(entity->last_scheduled);
-	if (fence && !dma_fence_is_signaled(fence))
-		return;
-
-	rq = drm_sched_entity_get_free_sched(entity);
-	spin_lock(&entity->rq_lock);
-	drm_sched_rq_remove_entity(entity->rq, entity);
-	entity->rq = rq;
-	spin_unlock(&entity->rq_lock);
-}
-
-/**
- * drm_sched_entity_push_job - Submit a job to the entity's job queue
- *
- * @sched_job: job to submit
- * @entity: scheduler entity
- *
- * Note: To guarantee that the order of insertion to queue matches
- * the job's fence sequence number this function should be
- * called with drm_sched_job_init under common lock.
- *
- * Returns 0 for success, negative error code otherwise.
- */
-void drm_sched_entity_push_job(struct drm_sched_job *sched_job,
-			       struct drm_sched_entity *entity)
-{
-	bool first;
-
-	trace_drm_sched_job(sched_job, entity);
-	atomic_inc(&entity->rq->sched->num_jobs);
-	WRITE_ONCE(entity->last_user, current->group_leader);
-	first = spsc_queue_push(&entity->job_queue, &sched_job->queue_node);
-
-	/* first job wakes up scheduler */
-	if (first) {
-		/* Add the entity to the run queue */
-		spin_lock(&entity->rq_lock);
-		drm_sched_rq_add_entity(entity->rq, entity);
-		spin_unlock(&entity->rq_lock);
-		drm_sched_wakeup(entity->rq->sched);
-	}
-}
-EXPORT_SYMBOL(drm_sched_entity_push_job);
-
 /* job_finish is called after hw fence signaled
  */
 static void drm_sched_job_finish(struct work_struct *work)
@@ -840,7 +409,7 @@ static bool drm_sched_ready(struct drm_gpu_scheduler *sched)
  * @sched: scheduler instance
  *
  */
-static void drm_sched_wakeup(struct drm_gpu_scheduler *sched)
+void drm_sched_wakeup(struct drm_gpu_scheduler *sched)
 {
 	if (drm_sched_ready(sched))
 		wake_up_interruptible(&sched->wake_up_worker);
diff --git a/drivers/gpu/drm/scheduler/sched_entity.c b/drivers/gpu/drm/scheduler/sched_entity.c
new file mode 100644
index 000000000000..1053f27af9df
--- /dev/null
+++ b/drivers/gpu/drm/scheduler/sched_entity.c
@@ -0,0 +1,459 @@
+/*
+ * Copyright 2015 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <linux/kthread.h>
+#include <drm/gpu_scheduler.h>
+
+#include "gpu_scheduler_trace.h"
+
+#define to_drm_sched_job(sched_job)		\
+		container_of((sched_job), struct drm_sched_job, queue_node)
+
+/**
+ * drm_sched_entity_init - Init a context entity used by scheduler when
+ * submit to HW ring.
+ *
+ * @entity: scheduler entity to init
+ * @rq_list: the list of run queue on which jobs from this
+ *           entity can be submitted
+ * @num_rq_list: number of run queue in rq_list
+ * @guilty: atomic_t set to 1 when a job on this queue
+ *          is found to be guilty causing a timeout
+ *
+ * Note: the rq_list should have atleast one element to schedule
+ *       the entity
+ *
+ * Returns 0 on success or a negative error code on failure.
+*/
+int drm_sched_entity_init(struct drm_sched_entity *entity,
+			  struct drm_sched_rq **rq_list,
+			  unsigned int num_rq_list,
+			  atomic_t *guilty)
+{
+	int i;
+
+	if (!(entity && rq_list && num_rq_list > 0 && rq_list[0]))
+		return -EINVAL;
+
+	memset(entity, 0, sizeof(struct drm_sched_entity));
+	INIT_LIST_HEAD(&entity->list);
+	entity->rq = rq_list[0];
+	entity->guilty = guilty;
+	entity->num_rq_list = num_rq_list;
+	entity->rq_list = kcalloc(num_rq_list, sizeof(struct drm_sched_rq *),
+				GFP_KERNEL);
+	if (!entity->rq_list)
+		return -ENOMEM;
+
+	for (i = 0; i < num_rq_list; ++i)
+		entity->rq_list[i] = rq_list[i];
+	entity->last_scheduled = NULL;
+
+	spin_lock_init(&entity->rq_lock);
+	spsc_queue_init(&entity->job_queue);
+
+	atomic_set(&entity->fence_seq, 0);
+	entity->fence_context = dma_fence_context_alloc(2);
+
+	return 0;
+}
+EXPORT_SYMBOL(drm_sched_entity_init);
+
+/**
+ * drm_sched_entity_is_idle - Check if entity is idle
+ *
+ * @entity: scheduler entity
+ *
+ * Returns true if the entity does not have any unscheduled jobs.
+ */
+static bool drm_sched_entity_is_idle(struct drm_sched_entity *entity)
+{
+	rmb();
+
+	if (list_empty(&entity->list) ||
+	    spsc_queue_peek(&entity->job_queue) == NULL)
+		return true;
+
+	return false;
+}
+
+/**
+ * drm_sched_entity_is_ready - Check if entity is ready
+ *
+ * @entity: scheduler entity
+ *
+ * Return true if entity could provide a job.
+ */
+bool drm_sched_entity_is_ready(struct drm_sched_entity *entity)
+{
+	if (spsc_queue_peek(&entity->job_queue) == NULL)
+		return false;
+
+	if (READ_ONCE(entity->dependency))
+		return false;
+
+	return true;
+}
+
+/**
+ * drm_sched_entity_get_free_sched - Get the rq from rq_list with least load
+ *
+ * @entity: scheduler entity
+ *
+ * Return the pointer to the rq with least load.
+ */
+static struct drm_sched_rq *
+drm_sched_entity_get_free_sched(struct drm_sched_entity *entity)
+{
+	struct drm_sched_rq *rq = NULL;
+	unsigned int min_jobs = UINT_MAX, num_jobs;
+	int i;
+
+	for (i = 0; i < entity->num_rq_list; ++i) {
+		num_jobs = atomic_read(&entity->rq_list[i]->sched->num_jobs);
+		if (num_jobs < min_jobs) {
+			min_jobs = num_jobs;
+			rq = entity->rq_list[i];
+		}
+	}
+
+	return rq;
+}
+
+static void drm_sched_entity_kill_jobs_cb(struct dma_fence *f,
+				    struct dma_fence_cb *cb)
+{
+	struct drm_sched_job *job = container_of(cb, struct drm_sched_job,
+						 finish_cb);
+	drm_sched_fence_finished(job->s_fence);
+	WARN_ON(job->s_fence->parent);
+	dma_fence_put(&job->s_fence->finished);
+	job->sched->ops->free_job(job);
+}
+
+
+/**
+ * drm_sched_entity_flush - Flush a context entity
+ *
+ * @entity: scheduler entity
+ * @timeout: time to wait in for Q to become empty in jiffies.
+ *
+ * Splitting drm_sched_entity_fini() into two functions, The first one does the waiting,
+ * removes the entity from the runqueue and returns an error when the process was killed.
+ *
+ * Returns the remaining time in jiffies left from the input timeout
+ */
+long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout)
+{
+	struct drm_gpu_scheduler *sched;
+	struct task_struct *last_user;
+	long ret = timeout;
+
+	sched = entity->rq->sched;
+	/**
+	 * The client will not queue more IBs during this fini, consume existing
+	 * queued IBs or discard them on SIGKILL
+	*/
+	if (current->flags & PF_EXITING) {
+		if (timeout)
+			ret = wait_event_timeout(
+					sched->job_scheduled,
+					drm_sched_entity_is_idle(entity),
+					timeout);
+	} else {
+		wait_event_killable(sched->job_scheduled,
+				    drm_sched_entity_is_idle(entity));
+	}
+
+	/* For killed process disable any more IBs enqueue right now */
+	last_user = cmpxchg(&entity->last_user, current->group_leader, NULL);
+	if ((!last_user || last_user == current->group_leader) &&
+	    (current->flags & PF_EXITING) && (current->exit_code == SIGKILL))
+		drm_sched_rq_remove_entity(entity->rq, entity);
+
+	return ret;
+}
+EXPORT_SYMBOL(drm_sched_entity_flush);
+
+/**
+ * drm_sched_entity_cleanup - Destroy a context entity
+ *
+ * @entity: scheduler entity
+ *
+ * This should be called after @drm_sched_entity_do_release. It goes over the
+ * entity and signals all jobs with an error code if the process was killed.
+ *
+ */
+void drm_sched_entity_fini(struct drm_sched_entity *entity)
+{
+	struct drm_gpu_scheduler *sched;
+
+	sched = entity->rq->sched;
+	drm_sched_rq_remove_entity(entity->rq, entity);
+
+	/* Consumption of existing IBs wasn't completed. Forcefully
+	 * remove them here.
+	 */
+	if (spsc_queue_peek(&entity->job_queue)) {
+		struct drm_sched_job *job;
+		int r;
+
+		/* Park the kernel for a moment to make sure it isn't processing
+		 * our enity.
+		 */
+		kthread_park(sched->thread);
+		kthread_unpark(sched->thread);
+		if (entity->dependency) {
+			dma_fence_remove_callback(entity->dependency,
+						  &entity->cb);
+			dma_fence_put(entity->dependency);
+			entity->dependency = NULL;
+		}
+
+		while ((job = to_drm_sched_job(spsc_queue_pop(&entity->job_queue)))) {
+			struct drm_sched_fence *s_fence = job->s_fence;
+			drm_sched_fence_scheduled(s_fence);
+			dma_fence_set_error(&s_fence->finished, -ESRCH);
+
+			/*
+			 * When pipe is hanged by older entity, new entity might
+			 * not even have chance to submit it's first job to HW
+			 * and so entity->last_scheduled will remain NULL
+			 */
+			if (!entity->last_scheduled) {
+				drm_sched_entity_kill_jobs_cb(NULL, &job->finish_cb);
+			} else {
+				r = dma_fence_add_callback(entity->last_scheduled, &job->finish_cb,
+								drm_sched_entity_kill_jobs_cb);
+				if (r == -ENOENT)
+					drm_sched_entity_kill_jobs_cb(NULL, &job->finish_cb);
+				else if (r)
+					DRM_ERROR("fence add callback failed (%d)\n", r);
+			}
+		}
+	}
+
+	dma_fence_put(entity->last_scheduled);
+	entity->last_scheduled = NULL;
+	kfree(entity->rq_list);
+}
+EXPORT_SYMBOL(drm_sched_entity_fini);
+
+/**
+ * drm_sched_entity_fini - Destroy a context entity
+ *
+ * @entity: scheduler entity
+ *
+ * Calls drm_sched_entity_do_release() and drm_sched_entity_cleanup()
+ */
+void drm_sched_entity_destroy(struct drm_sched_entity *entity)
+{
+	drm_sched_entity_flush(entity, MAX_WAIT_SCHED_ENTITY_Q_EMPTY);
+	drm_sched_entity_fini(entity);
+}
+EXPORT_SYMBOL(drm_sched_entity_destroy);
+
+static void drm_sched_entity_wakeup(struct dma_fence *f, struct dma_fence_cb *cb)
+{
+	struct drm_sched_entity *entity =
+		container_of(cb, struct drm_sched_entity, cb);
+	entity->dependency = NULL;
+	dma_fence_put(f);
+	drm_sched_wakeup(entity->rq->sched);
+}
+
+static void drm_sched_entity_clear_dep(struct dma_fence *f, struct dma_fence_cb *cb)
+{
+	struct drm_sched_entity *entity =
+		container_of(cb, struct drm_sched_entity, cb);
+	entity->dependency = NULL;
+	dma_fence_put(f);
+}
+
+/**
+ * drm_sched_entity_set_rq_priority - helper for drm_sched_entity_set_priority
+ */
+static void drm_sched_entity_set_rq_priority(struct drm_sched_rq **rq,
+					     enum drm_sched_priority priority)
+{
+	*rq = &(*rq)->sched->sched_rq[priority];
+}
+
+/**
+ * drm_sched_entity_set_priority - Sets priority of the entity
+ *
+ * @entity: scheduler entity
+ * @priority: scheduler priority
+ *
+ * Update the priority of runqueus used for the entity.
+ */
+void drm_sched_entity_set_priority(struct drm_sched_entity *entity,
+				   enum drm_sched_priority priority)
+{
+	unsigned int i;
+
+	spin_lock(&entity->rq_lock);
+
+	for (i = 0; i < entity->num_rq_list; ++i)
+		drm_sched_entity_set_rq_priority(&entity->rq_list[i], priority);
+
+	drm_sched_rq_remove_entity(entity->rq, entity);
+	drm_sched_entity_set_rq_priority(&entity->rq, priority);
+	drm_sched_rq_add_entity(entity->rq, entity);
+
+	spin_unlock(&entity->rq_lock);
+}
+EXPORT_SYMBOL(drm_sched_entity_set_priority);
+
+static bool drm_sched_entity_add_dependency_cb(struct drm_sched_entity *entity)
+{
+	struct drm_gpu_scheduler *sched = entity->rq->sched;
+	struct dma_fence * fence = entity->dependency;
+	struct drm_sched_fence *s_fence;
+
+	if (fence->context == entity->fence_context ||
+            fence->context == entity->fence_context + 1) {
+                /*
+                 * Fence is a scheduled/finished fence from a job
+                 * which belongs to the same entity, we can ignore
+                 * fences from ourself
+                 */
+		dma_fence_put(entity->dependency);
+		return false;
+	}
+
+	s_fence = to_drm_sched_fence(fence);
+	if (s_fence && s_fence->sched == sched) {
+
+		/*
+		 * Fence is from the same scheduler, only need to wait for
+		 * it to be scheduled
+		 */
+		fence = dma_fence_get(&s_fence->scheduled);
+		dma_fence_put(entity->dependency);
+		entity->dependency = fence;
+		if (!dma_fence_add_callback(fence, &entity->cb,
+					    drm_sched_entity_clear_dep))
+			return true;
+
+		/* Ignore it when it is already scheduled */
+		dma_fence_put(fence);
+		return false;
+	}
+
+	if (!dma_fence_add_callback(entity->dependency, &entity->cb,
+				    drm_sched_entity_wakeup))
+		return true;
+
+	dma_fence_put(entity->dependency);
+	return false;
+}
+
+struct drm_sched_job *drm_sched_entity_pop_job(struct drm_sched_entity *entity)
+{
+	struct drm_gpu_scheduler *sched = entity->rq->sched;
+	struct drm_sched_job *sched_job = to_drm_sched_job(
+						spsc_queue_peek(&entity->job_queue));
+
+	if (!sched_job)
+		return NULL;
+
+	while ((entity->dependency = sched->ops->dependency(sched_job, entity))) {
+		if (drm_sched_entity_add_dependency_cb(entity)) {
+
+			trace_drm_sched_job_wait_dep(sched_job, entity->dependency);
+			return NULL;
+		}
+	}
+
+	/* skip jobs from entity that marked guilty */
+	if (entity->guilty && atomic_read(entity->guilty))
+		dma_fence_set_error(&sched_job->s_fence->finished, -ECANCELED);
+
+	dma_fence_put(entity->last_scheduled);
+	entity->last_scheduled = dma_fence_get(&sched_job->s_fence->finished);
+
+	spsc_queue_pop(&entity->job_queue);
+	return sched_job;
+}
+
+/**
+ * drm_sched_entity_select_rq - select a new rq for the entity
+ *
+ * @entity: scheduler entity
+ *
+ * Check all prerequisites and select a new rq for the entity for load
+ * balancing.
+ */
+void drm_sched_entity_select_rq(struct drm_sched_entity *entity)
+{
+	struct dma_fence *fence;
+	struct drm_sched_rq *rq;
+
+	if (!spsc_queue_count(&entity->job_queue) == 0 ||
+	    entity->num_rq_list <= 1)
+		return;
+
+	fence = READ_ONCE(entity->last_scheduled);
+	if (fence && !dma_fence_is_signaled(fence))
+		return;
+
+	rq = drm_sched_entity_get_free_sched(entity);
+	spin_lock(&entity->rq_lock);
+	drm_sched_rq_remove_entity(entity->rq, entity);
+	entity->rq = rq;
+	spin_unlock(&entity->rq_lock);
+}
+
+/**
+ * drm_sched_entity_push_job - Submit a job to the entity's job queue
+ *
+ * @sched_job: job to submit
+ * @entity: scheduler entity
+ *
+ * Note: To guarantee that the order of insertion to queue matches
+ * the job's fence sequence number this function should be
+ * called with drm_sched_job_init under common lock.
+ *
+ * Returns 0 for success, negative error code otherwise.
+ */
+void drm_sched_entity_push_job(struct drm_sched_job *sched_job,
+			       struct drm_sched_entity *entity)
+{
+	bool first;
+
+	trace_drm_sched_job(sched_job, entity);
+	atomic_inc(&entity->rq->sched->num_jobs);
+	WRITE_ONCE(entity->last_user, current->group_leader);
+	first = spsc_queue_push(&entity->job_queue, &sched_job->queue_node);
+
+	/* first job wakes up scheduler */
+	if (first) {
+		/* Add the entity to the run queue */
+		spin_lock(&entity->rq_lock);
+		drm_sched_rq_add_entity(entity->rq, entity);
+		spin_unlock(&entity->rq_lock);
+		drm_sched_wakeup(entity->rq->sched);
+	}
+}
+EXPORT_SYMBOL(drm_sched_entity_push_job);
diff --git a/include/drm/gpu_scheduler.h b/include/drm/gpu_scheduler.h
index 22c0f88f7d8f..919ae572f775 100644
--- a/include/drm/gpu_scheduler.h
+++ b/include/drm/gpu_scheduler.h
@@ -288,6 +288,21 @@ int drm_sched_init(struct drm_gpu_scheduler *sched,
 		   uint32_t hw_submission, unsigned hang_limit, long timeout,
 		   const char *name);
 void drm_sched_fini(struct drm_gpu_scheduler *sched);
+int drm_sched_job_init(struct drm_sched_job *job,
+		       struct drm_sched_entity *entity,
+		       void *owner);
+void drm_sched_wakeup(struct drm_gpu_scheduler *sched);
+void drm_sched_hw_job_reset(struct drm_gpu_scheduler *sched,
+			    struct drm_sched_job *job);
+void drm_sched_job_recovery(struct drm_gpu_scheduler *sched);
+bool drm_sched_dependency_optimized(struct dma_fence* fence,
+				    struct drm_sched_entity *entity);
+void drm_sched_job_kickout(struct drm_sched_job *s_job);
+
+void drm_sched_rq_add_entity(struct drm_sched_rq *rq,
+			     struct drm_sched_entity *entity);
+void drm_sched_rq_remove_entity(struct drm_sched_rq *rq,
+				struct drm_sched_entity *entity);
 
 int drm_sched_entity_init(struct drm_sched_entity *entity,
 			  struct drm_sched_rq **rq_list,
@@ -296,22 +311,17 @@ int drm_sched_entity_init(struct drm_sched_entity *entity,
 long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout);
 void drm_sched_entity_fini(struct drm_sched_entity *entity);
 void drm_sched_entity_destroy(struct drm_sched_entity *entity);
+void drm_sched_entity_select_rq(struct drm_sched_entity *entity);
+struct drm_sched_job *drm_sched_entity_pop_job(struct drm_sched_entity *entity);
 void drm_sched_entity_push_job(struct drm_sched_job *sched_job,
 			       struct drm_sched_entity *entity);
 void drm_sched_entity_set_priority(struct drm_sched_entity *entity,
 				   enum drm_sched_priority priority);
+bool drm_sched_entity_is_ready(struct drm_sched_entity *entity);
+
 struct drm_sched_fence *drm_sched_fence_create(
 	struct drm_sched_entity *s_entity, void *owner);
 void drm_sched_fence_scheduled(struct drm_sched_fence *fence);
 void drm_sched_fence_finished(struct drm_sched_fence *fence);
-int drm_sched_job_init(struct drm_sched_job *job,
-		       struct drm_sched_entity *entity,
-		       void *owner);
-void drm_sched_hw_job_reset(struct drm_gpu_scheduler *sched,
-			    struct drm_sched_job *job);
-void drm_sched_job_recovery(struct drm_gpu_scheduler *sched);
-bool drm_sched_dependency_optimized(struct dma_fence* fence,
-				    struct drm_sched_entity *entity);
-void drm_sched_job_kickout(struct drm_sched_job *s_job);
 
 #endif
-- 
2.14.1

_______________________________________________
amd-gfx mailing list
amd-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

[PATCH 3/4] drm/scheduler: cleanup entity coding style

[Christian König]

Cleanup coding style in sched_entity.c

Signed-off-by: Christian König <christian.koenig@amd.com>
---
 drivers/gpu/drm/scheduler/sched_entity.c | 167 ++++++++++++++++++++-----------
 1 file changed, 110 insertions(+), 57 deletions(-)

diff --git a/drivers/gpu/drm/scheduler/sched_entity.c b/drivers/gpu/drm/scheduler/sched_entity.c
index 1053f27af9df..1416edb2642a 100644
--- a/drivers/gpu/drm/scheduler/sched_entity.c
+++ b/drivers/gpu/drm/scheduler/sched_entity.c
@@ -44,7 +44,7 @@
  *       the entity
  *
  * Returns 0 on success or a negative error code on failure.
-*/
+ */
 int drm_sched_entity_init(struct drm_sched_entity *entity,
 			  struct drm_sched_rq **rq_list,
 			  unsigned int num_rq_list,
@@ -88,7 +88,7 @@ EXPORT_SYMBOL(drm_sched_entity_init);
  */
 static bool drm_sched_entity_is_idle(struct drm_sched_entity *entity)
 {
-	rmb();
+	rmb(); /* for list_empty to work without lock */
 
 	if (list_empty(&entity->list) ||
 	    spsc_queue_peek(&entity->job_queue) == NULL)
@@ -140,26 +140,15 @@ drm_sched_entity_get_free_sched(struct drm_sched_entity *entity)
 	return rq;
 }
 
-static void drm_sched_entity_kill_jobs_cb(struct dma_fence *f,
-				    struct dma_fence_cb *cb)
-{
-	struct drm_sched_job *job = container_of(cb, struct drm_sched_job,
-						 finish_cb);
-	drm_sched_fence_finished(job->s_fence);
-	WARN_ON(job->s_fence->parent);
-	dma_fence_put(&job->s_fence->finished);
-	job->sched->ops->free_job(job);
-}
-
-
 /**
  * drm_sched_entity_flush - Flush a context entity
  *
  * @entity: scheduler entity
  * @timeout: time to wait in for Q to become empty in jiffies.
  *
- * Splitting drm_sched_entity_fini() into two functions, The first one does the waiting,
- * removes the entity from the runqueue and returns an error when the process was killed.
+ * Splitting drm_sched_entity_fini() into two functions, The first one does the
+ * waiting, removes the entity from the runqueue and returns an error when the
+ * process was killed.
  *
  * Returns the remaining time in jiffies left from the input timeout
  */
@@ -173,7 +162,7 @@ long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout)
 	/**
 	 * The client will not queue more IBs during this fini, consume existing
 	 * queued IBs or discard them on SIGKILL
-	*/
+	 */
 	if (current->flags & PF_EXITING) {
 		if (timeout)
 			ret = wait_event_timeout(
@@ -195,6 +184,65 @@ long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout)
 }
 EXPORT_SYMBOL(drm_sched_entity_flush);
 
+/**
+ * drm_sched_entity_kill_jobs - helper for drm_sched_entity_kill_jobs
+ *
+ * @f: signaled fence
+ * @cb: our callback structure
+ *
+ * Signal the scheduler finished fence when the entity in question is killed.
+ */
+static void drm_sched_entity_kill_jobs_cb(struct dma_fence *f,
+					  struct dma_fence_cb *cb)
+{
+	struct drm_sched_job *job = container_of(cb, struct drm_sched_job,
+						 finish_cb);
+
+	drm_sched_fence_finished(job->s_fence);
+	WARN_ON(job->s_fence->parent);
+	dma_fence_put(&job->s_fence->finished);
+	job->sched->ops->free_job(job);
+}
+
+/**
+ * drm_sched_entity_kill_jobs - Make sure all remaining jobs are killed
+ *
+ * @entity: entity which is cleaned up
+ *
+ * Makes sure that all remaining jobs in an entity are killed before it is
+ * destroyed.
+ */
+static void drm_sched_entity_kill_jobs(struct drm_sched_entity *entity)
+{
+	struct drm_sched_job *job;
+	int r;
+
+	while ((job = to_drm_sched_job(spsc_queue_pop(&entity->job_queue)))) {
+		struct drm_sched_fence *s_fence = job->s_fence;
+
+		drm_sched_fence_scheduled(s_fence);
+		dma_fence_set_error(&s_fence->finished, -ESRCH);
+
+		/*
+		 * When pipe is hanged by older entity, new entity might
+		 * not even have chance to submit it's first job to HW
+		 * and so entity->last_scheduled will remain NULL
+		 */
+		if (!entity->last_scheduled) {
+			drm_sched_entity_kill_jobs_cb(NULL, &job->finish_cb);
+			continue;
+		}
+
+		r = dma_fence_add_callback(entity->last_scheduled,
+					   &job->finish_cb,
+					   drm_sched_entity_kill_jobs_cb);
+		if (r == -ENOENT)
+			drm_sched_entity_kill_jobs_cb(NULL, &job->finish_cb);
+		else if (r)
+			DRM_ERROR("fence add callback failed (%d)\n", r);
+	}
+}
+
 /**
  * drm_sched_entity_cleanup - Destroy a context entity
  *
@@ -215,9 +263,6 @@ void drm_sched_entity_fini(struct drm_sched_entity *entity)
 	 * remove them here.
 	 */
 	if (spsc_queue_peek(&entity->job_queue)) {
-		struct drm_sched_job *job;
-		int r;
-
 		/* Park the kernel for a moment to make sure it isn't processing
 		 * our enity.
 		 */
@@ -230,27 +275,7 @@ void drm_sched_entity_fini(struct drm_sched_entity *entity)
 			entity->dependency = NULL;
 		}
 
-		while ((job = to_drm_sched_job(spsc_queue_pop(&entity->job_queue)))) {
-			struct drm_sched_fence *s_fence = job->s_fence;
-			drm_sched_fence_scheduled(s_fence);
-			dma_fence_set_error(&s_fence->finished, -ESRCH);
-
-			/*
-			 * When pipe is hanged by older entity, new entity might
-			 * not even have chance to submit it's first job to HW
-			 * and so entity->last_scheduled will remain NULL
-			 */
-			if (!entity->last_scheduled) {
-				drm_sched_entity_kill_jobs_cb(NULL, &job->finish_cb);
-			} else {
-				r = dma_fence_add_callback(entity->last_scheduled, &job->finish_cb,
-								drm_sched_entity_kill_jobs_cb);
-				if (r == -ENOENT)
-					drm_sched_entity_kill_jobs_cb(NULL, &job->finish_cb);
-				else if (r)
-					DRM_ERROR("fence add callback failed (%d)\n", r);
-			}
-		}
+		drm_sched_entity_kill_jobs(entity);
 	}
 
 	dma_fence_put(entity->last_scheduled);
@@ -273,21 +298,31 @@ void drm_sched_entity_destroy(struct drm_sched_entity *entity)
 }
 EXPORT_SYMBOL(drm_sched_entity_destroy);
 
-static void drm_sched_entity_wakeup(struct dma_fence *f, struct dma_fence_cb *cb)
+/**
+ * drm_sched_entity_clear_dep - callback to clear the entities dependency
+ */
+static void drm_sched_entity_clear_dep(struct dma_fence *f,
+				       struct dma_fence_cb *cb)
 {
 	struct drm_sched_entity *entity =
 		container_of(cb, struct drm_sched_entity, cb);
+
 	entity->dependency = NULL;
 	dma_fence_put(f);
-	drm_sched_wakeup(entity->rq->sched);
 }
 
-static void drm_sched_entity_clear_dep(struct dma_fence *f, struct dma_fence_cb *cb)
+/**
+ * drm_sched_entity_clear_dep - callback to clear the entities dependency and
+ * wake up scheduler
+ */
+static void drm_sched_entity_wakeup(struct dma_fence *f,
+				    struct dma_fence_cb *cb)
 {
 	struct drm_sched_entity *entity =
 		container_of(cb, struct drm_sched_entity, cb);
-	entity->dependency = NULL;
-	dma_fence_put(f);
+
+	drm_sched_entity_clear_dep(f, cb);
+	drm_sched_wakeup(entity->rq->sched);
 }
 
 /**
@@ -325,19 +360,27 @@ void drm_sched_entity_set_priority(struct drm_sched_entity *entity,
 }
 EXPORT_SYMBOL(drm_sched_entity_set_priority);
 
+/**
+ * drm_sched_entity_add_dependency_cb - add callback for the entities dependency
+ *
+ * @entity: entity with dependency
+ *
+ * Add a callback to the current dependency of the entity to wake up the
+ * scheduler when the entity becomes available.
+ */
 static bool drm_sched_entity_add_dependency_cb(struct drm_sched_entity *entity)
 {
 	struct drm_gpu_scheduler *sched = entity->rq->sched;
-	struct dma_fence * fence = entity->dependency;
+	struct dma_fence *fence = entity->dependency;
 	struct drm_sched_fence *s_fence;
 
 	if (fence->context == entity->fence_context ||
-            fence->context == entity->fence_context + 1) {
-                /*
-                 * Fence is a scheduled/finished fence from a job
-                 * which belongs to the same entity, we can ignore
-                 * fences from ourself
-                 */
+	    fence->context == entity->fence_context + 1) {
+		/*
+		 * Fence is a scheduled/finished fence from a job
+		 * which belongs to the same entity, we can ignore
+		 * fences from ourself
+		 */
 		dma_fence_put(entity->dependency);
 		return false;
 	}
@@ -369,19 +412,29 @@ static bool drm_sched_entity_add_dependency_cb(struct drm_sched_entity *entity)
 	return false;
 }
 
+/**
+ * drm_sched_entity_pop_job - get a ready to be scheduled job from the entity
+ *
+ * @entity: entity to get the job from
+ *
+ * Process all dependencies and try to get one job from the entities queue.
+ */
 struct drm_sched_job *drm_sched_entity_pop_job(struct drm_sched_entity *entity)
 {
 	struct drm_gpu_scheduler *sched = entity->rq->sched;
-	struct drm_sched_job *sched_job = to_drm_sched_job(
-						spsc_queue_peek(&entity->job_queue));
+	struct drm_sched_job *sched_job;
 
+	sched_job = to_drm_sched_job(spsc_queue_peek(&entity->job_queue));
 	if (!sched_job)
 		return NULL;
 
-	while ((entity->dependency = sched->ops->dependency(sched_job, entity))) {
+	while ((entity->dependency =
+			sched->ops->dependency(sched_job, entity))) {
+
 		if (drm_sched_entity_add_dependency_cb(entity)) {
 
-			trace_drm_sched_job_wait_dep(sched_job, entity->dependency);
+			trace_drm_sched_job_wait_dep(sched_job,
+						     entity->dependency);
 			return NULL;
 		}
 	}
-- 
2.14.1

_______________________________________________
amd-gfx mailing list
amd-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

[PATCH 4/4] drm/scheduler: rename gpu_scheduler.c to sched_main.c

[Christian König]

Better match the naming of the other components.

Signed-off-by: Christian König <christian.koenig@amd.com>
---
 drivers/gpu/drm/scheduler/Makefile                          | 2 +-
 drivers/gpu/drm/scheduler/{gpu_scheduler.c => sched_main.c} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename drivers/gpu/drm/scheduler/{gpu_scheduler.c => sched_main.c} (100%)

diff --git a/drivers/gpu/drm/scheduler/Makefile b/drivers/gpu/drm/scheduler/Makefile
index f23785d4b3c8..53863621829f 100644
--- a/drivers/gpu/drm/scheduler/Makefile
+++ b/drivers/gpu/drm/scheduler/Makefile
@@ -20,6 +20,6 @@
 # OTHER DEALINGS IN THE SOFTWARE.
 #
 #
-gpu-sched-y := gpu_scheduler.o sched_fence.o sched_entity.o
+gpu-sched-y := sched_main.o sched_fence.o sched_entity.o
 
 obj-$(CONFIG_DRM_SCHED) += gpu-sched.o
diff --git a/drivers/gpu/drm/scheduler/gpu_scheduler.c b/drivers/gpu/drm/scheduler/sched_main.c
similarity index 100%
rename from drivers/gpu/drm/scheduler/gpu_scheduler.c
rename to drivers/gpu/drm/scheduler/sched_main.c
-- 
2.14.1

_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel

Re: [PATCH 1/4] drm/scheduler: trivial error handling fix

[Huang Rui]

On Tue, Aug 14, 2018 at 10:12:23AM +0200, Christian König wrote:
> Return -ENOMEM when allocating the rq_list fails.
> 
> Signed-off-by: Christian König <christian.koenig@amd.com>

Reviewed-by: Huang Rui <ray.huang@amd.com>

> ---
>  drivers/gpu/drm/scheduler/gpu_scheduler.c | 3 +++
>  1 file changed, 3 insertions(+)
> 
> diff --git a/drivers/gpu/drm/scheduler/gpu_scheduler.c b/drivers/gpu/drm/scheduler/gpu_scheduler.c
> index f566405f49e3..85c1f95752cc 100644
> --- a/drivers/gpu/drm/scheduler/gpu_scheduler.c
> +++ b/drivers/gpu/drm/scheduler/gpu_scheduler.c
> @@ -191,6 +191,9 @@ int drm_sched_entity_init(struct drm_sched_entity *entity,
>  	entity->num_rq_list = num_rq_list;
>  	entity->rq_list = kcalloc(num_rq_list, sizeof(struct drm_sched_rq *),
>  				GFP_KERNEL);
> +	if (!entity->rq_list)
> +		return -ENOMEM;
> +
>  	for (i = 0; i < num_rq_list; ++i)
>  		entity->rq_list[i] = rq_list[i];
>  	entity->last_scheduled = NULL;
> -- 
> 2.14.1
> 
> _______________________________________________
> amd-gfx mailing list
> amd-gfx@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/amd-gfx
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel

Re: [PATCH 2/4] drm/scheduler: move entity handling into separate file

[Huang Rui]

On Tue, Aug 14, 2018 at 10:12:24AM +0200, Christian König wrote:
> This is complex enough on it's own. Move it into a separate C file.
> 
> Signed-off-by: Christian König <christian.koenig@amd.com>

For series:
Reviewed-by: Huang Rui <ray.huang@amd.com>

> ---
>  drivers/gpu/drm/scheduler/Makefile        |   2 +-
>  drivers/gpu/drm/scheduler/gpu_scheduler.c | 441 +---------------------------
>  drivers/gpu/drm/scheduler/sched_entity.c  | 459 ++++++++++++++++++++++++++++++
>  include/drm/gpu_scheduler.h               |  28 +-
>  4 files changed, 484 insertions(+), 446 deletions(-)
>  create mode 100644 drivers/gpu/drm/scheduler/sched_entity.c
> 
> diff --git a/drivers/gpu/drm/scheduler/Makefile b/drivers/gpu/drm/scheduler/Makefile
> index 7665883f81d4..f23785d4b3c8 100644
> --- a/drivers/gpu/drm/scheduler/Makefile
> +++ b/drivers/gpu/drm/scheduler/Makefile
> @@ -20,6 +20,6 @@
>  # OTHER DEALINGS IN THE SOFTWARE.
>  #
>  #
> -gpu-sched-y := gpu_scheduler.o sched_fence.o
> +gpu-sched-y := gpu_scheduler.o sched_fence.o sched_entity.o
>  
>  obj-$(CONFIG_DRM_SCHED) += gpu-sched.o
> diff --git a/drivers/gpu/drm/scheduler/gpu_scheduler.c b/drivers/gpu/drm/scheduler/gpu_scheduler.c
> index 85c1f95752cc..9ca741f3a0bc 100644
> --- a/drivers/gpu/drm/scheduler/gpu_scheduler.c
> +++ b/drivers/gpu/drm/scheduler/gpu_scheduler.c
> @@ -58,8 +58,6 @@
>  #define to_drm_sched_job(sched_job)		\
>  		container_of((sched_job), struct drm_sched_job, queue_node)
>  
> -static bool drm_sched_entity_is_ready(struct drm_sched_entity *entity);
> -static void drm_sched_wakeup(struct drm_gpu_scheduler *sched);
>  static void drm_sched_process_job(struct dma_fence *f, struct dma_fence_cb *cb);
>  
>  /**
> @@ -86,8 +84,8 @@ static void drm_sched_rq_init(struct drm_gpu_scheduler *sched,
>   *
>   * Adds a scheduler entity to the run queue.
>   */
> -static void drm_sched_rq_add_entity(struct drm_sched_rq *rq,
> -				    struct drm_sched_entity *entity)
> +void drm_sched_rq_add_entity(struct drm_sched_rq *rq,
> +			     struct drm_sched_entity *entity)
>  {
>  	if (!list_empty(&entity->list))
>  		return;
> @@ -104,8 +102,8 @@ static void drm_sched_rq_add_entity(struct drm_sched_rq *rq,
>   *
>   * Removes a scheduler entity from the run queue.
>   */
> -static void drm_sched_rq_remove_entity(struct drm_sched_rq *rq,
> -				       struct drm_sched_entity *entity)
> +void drm_sched_rq_remove_entity(struct drm_sched_rq *rq,
> +				struct drm_sched_entity *entity)
>  {
>  	if (list_empty(&entity->list))
>  		return;
> @@ -158,301 +156,6 @@ drm_sched_rq_select_entity(struct drm_sched_rq *rq)
>  	return NULL;
>  }
>  
> -/**
> - * drm_sched_entity_init - Init a context entity used by scheduler when
> - * submit to HW ring.
> - *
> - * @entity: scheduler entity to init
> - * @rq_list: the list of run queue on which jobs from this
> - *           entity can be submitted
> - * @num_rq_list: number of run queue in rq_list
> - * @guilty: atomic_t set to 1 when a job on this queue
> - *          is found to be guilty causing a timeout
> - *
> - * Note: the rq_list should have atleast one element to schedule
> - *       the entity
> - *
> - * Returns 0 on success or a negative error code on failure.
> -*/
> -int drm_sched_entity_init(struct drm_sched_entity *entity,
> -			  struct drm_sched_rq **rq_list,
> -			  unsigned int num_rq_list,
> -			  atomic_t *guilty)
> -{
> -	int i;
> -
> -	if (!(entity && rq_list && num_rq_list > 0 && rq_list[0]))
> -		return -EINVAL;
> -
> -	memset(entity, 0, sizeof(struct drm_sched_entity));
> -	INIT_LIST_HEAD(&entity->list);
> -	entity->rq = rq_list[0];
> -	entity->guilty = guilty;
> -	entity->num_rq_list = num_rq_list;
> -	entity->rq_list = kcalloc(num_rq_list, sizeof(struct drm_sched_rq *),
> -				GFP_KERNEL);
> -	if (!entity->rq_list)
> -		return -ENOMEM;
> -
> -	for (i = 0; i < num_rq_list; ++i)
> -		entity->rq_list[i] = rq_list[i];
> -	entity->last_scheduled = NULL;
> -
> -	spin_lock_init(&entity->rq_lock);
> -	spsc_queue_init(&entity->job_queue);
> -
> -	atomic_set(&entity->fence_seq, 0);
> -	entity->fence_context = dma_fence_context_alloc(2);
> -
> -	return 0;
> -}
> -EXPORT_SYMBOL(drm_sched_entity_init);
> -
> -/**
> - * drm_sched_entity_is_idle - Check if entity is idle
> - *
> - * @entity: scheduler entity
> - *
> - * Returns true if the entity does not have any unscheduled jobs.
> - */
> -static bool drm_sched_entity_is_idle(struct drm_sched_entity *entity)
> -{
> -	rmb();
> -
> -	if (list_empty(&entity->list) ||
> -	    spsc_queue_peek(&entity->job_queue) == NULL)
> -		return true;
> -
> -	return false;
> -}
> -
> -/**
> - * drm_sched_entity_is_ready - Check if entity is ready
> - *
> - * @entity: scheduler entity
> - *
> - * Return true if entity could provide a job.
> - */
> -static bool drm_sched_entity_is_ready(struct drm_sched_entity *entity)
> -{
> -	if (spsc_queue_peek(&entity->job_queue) == NULL)
> -		return false;
> -
> -	if (READ_ONCE(entity->dependency))
> -		return false;
> -
> -	return true;
> -}
> -
> -/**
> - * drm_sched_entity_get_free_sched - Get the rq from rq_list with least load
> - *
> - * @entity: scheduler entity
> - *
> - * Return the pointer to the rq with least load.
> - */
> -static struct drm_sched_rq *
> -drm_sched_entity_get_free_sched(struct drm_sched_entity *entity)
> -{
> -	struct drm_sched_rq *rq = NULL;
> -	unsigned int min_jobs = UINT_MAX, num_jobs;
> -	int i;
> -
> -	for (i = 0; i < entity->num_rq_list; ++i) {
> -		num_jobs = atomic_read(&entity->rq_list[i]->sched->num_jobs);
> -		if (num_jobs < min_jobs) {
> -			min_jobs = num_jobs;
> -			rq = entity->rq_list[i];
> -		}
> -	}
> -
> -	return rq;
> -}
> -
> -static void drm_sched_entity_kill_jobs_cb(struct dma_fence *f,
> -				    struct dma_fence_cb *cb)
> -{
> -	struct drm_sched_job *job = container_of(cb, struct drm_sched_job,
> -						 finish_cb);
> -	drm_sched_fence_finished(job->s_fence);
> -	WARN_ON(job->s_fence->parent);
> -	dma_fence_put(&job->s_fence->finished);
> -	job->sched->ops->free_job(job);
> -}
> -
> -
> -/**
> - * drm_sched_entity_flush - Flush a context entity
> - *
> - * @entity: scheduler entity
> - * @timeout: time to wait in for Q to become empty in jiffies.
> - *
> - * Splitting drm_sched_entity_fini() into two functions, The first one does the waiting,
> - * removes the entity from the runqueue and returns an error when the process was killed.
> - *
> - * Returns the remaining time in jiffies left from the input timeout
> - */
> -long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout)
> -{
> -	struct drm_gpu_scheduler *sched;
> -	struct task_struct *last_user;
> -	long ret = timeout;
> -
> -	sched = entity->rq->sched;
> -	/**
> -	 * The client will not queue more IBs during this fini, consume existing
> -	 * queued IBs or discard them on SIGKILL
> -	*/
> -	if (current->flags & PF_EXITING) {
> -		if (timeout)
> -			ret = wait_event_timeout(
> -					sched->job_scheduled,
> -					drm_sched_entity_is_idle(entity),
> -					timeout);
> -	} else
> -		wait_event_killable(sched->job_scheduled, drm_sched_entity_is_idle(entity));
> -
> -
> -	/* For killed process disable any more IBs enqueue right now */
> -	last_user = cmpxchg(&entity->last_user, current->group_leader, NULL);
> -	if ((!last_user || last_user == current->group_leader) &&
> -	    (current->flags & PF_EXITING) && (current->exit_code == SIGKILL))
> -		drm_sched_rq_remove_entity(entity->rq, entity);
> -
> -	return ret;
> -}
> -EXPORT_SYMBOL(drm_sched_entity_flush);
> -
> -/**
> - * drm_sched_entity_cleanup - Destroy a context entity
> - *
> - * @entity: scheduler entity
> - *
> - * This should be called after @drm_sched_entity_do_release. It goes over the
> - * entity and signals all jobs with an error code if the process was killed.
> - *
> - */
> -void drm_sched_entity_fini(struct drm_sched_entity *entity)
> -{
> -	struct drm_gpu_scheduler *sched;
> -
> -	sched = entity->rq->sched;
> -	drm_sched_rq_remove_entity(entity->rq, entity);
> -
> -	/* Consumption of existing IBs wasn't completed. Forcefully
> -	 * remove them here.
> -	 */
> -	if (spsc_queue_peek(&entity->job_queue)) {
> -		struct drm_sched_job *job;
> -		int r;
> -
> -		/* Park the kernel for a moment to make sure it isn't processing
> -		 * our enity.
> -		 */
> -		kthread_park(sched->thread);
> -		kthread_unpark(sched->thread);
> -		if (entity->dependency) {
> -			dma_fence_remove_callback(entity->dependency,
> -						  &entity->cb);
> -			dma_fence_put(entity->dependency);
> -			entity->dependency = NULL;
> -		}
> -
> -		while ((job = to_drm_sched_job(spsc_queue_pop(&entity->job_queue)))) {
> -			struct drm_sched_fence *s_fence = job->s_fence;
> -			drm_sched_fence_scheduled(s_fence);
> -			dma_fence_set_error(&s_fence->finished, -ESRCH);
> -
> -			/*
> -			 * When pipe is hanged by older entity, new entity might
> -			 * not even have chance to submit it's first job to HW
> -			 * and so entity->last_scheduled will remain NULL
> -			 */
> -			if (!entity->last_scheduled) {
> -				drm_sched_entity_kill_jobs_cb(NULL, &job->finish_cb);
> -			} else {
> -				r = dma_fence_add_callback(entity->last_scheduled, &job->finish_cb,
> -								drm_sched_entity_kill_jobs_cb);
> -				if (r == -ENOENT)
> -					drm_sched_entity_kill_jobs_cb(NULL, &job->finish_cb);
> -				else if (r)
> -					DRM_ERROR("fence add callback failed (%d)\n", r);
> -			}
> -		}
> -	}
> -
> -	dma_fence_put(entity->last_scheduled);
> -	entity->last_scheduled = NULL;
> -	kfree(entity->rq_list);
> -}
> -EXPORT_SYMBOL(drm_sched_entity_fini);
> -
> -/**
> - * drm_sched_entity_fini - Destroy a context entity
> - *
> - * @entity: scheduler entity
> - *
> - * Calls drm_sched_entity_do_release() and drm_sched_entity_cleanup()
> - */
> -void drm_sched_entity_destroy(struct drm_sched_entity *entity)
> -{
> -	drm_sched_entity_flush(entity, MAX_WAIT_SCHED_ENTITY_Q_EMPTY);
> -	drm_sched_entity_fini(entity);
> -}
> -EXPORT_SYMBOL(drm_sched_entity_destroy);
> -
> -static void drm_sched_entity_wakeup(struct dma_fence *f, struct dma_fence_cb *cb)
> -{
> -	struct drm_sched_entity *entity =
> -		container_of(cb, struct drm_sched_entity, cb);
> -	entity->dependency = NULL;
> -	dma_fence_put(f);
> -	drm_sched_wakeup(entity->rq->sched);
> -}
> -
> -static void drm_sched_entity_clear_dep(struct dma_fence *f, struct dma_fence_cb *cb)
> -{
> -	struct drm_sched_entity *entity =
> -		container_of(cb, struct drm_sched_entity, cb);
> -	entity->dependency = NULL;
> -	dma_fence_put(f);
> -}
> -
> -/**
> - * drm_sched_entity_set_rq_priority - helper for drm_sched_entity_set_priority
> - */
> -static void drm_sched_entity_set_rq_priority(struct drm_sched_rq **rq,
> -					     enum drm_sched_priority priority)
> -{
> -	*rq = &(*rq)->sched->sched_rq[priority];
> -}
> -
> -/**
> - * drm_sched_entity_set_priority - Sets priority of the entity
> - *
> - * @entity: scheduler entity
> - * @priority: scheduler priority
> - *
> - * Update the priority of runqueus used for the entity.
> - */
> -void drm_sched_entity_set_priority(struct drm_sched_entity *entity,
> -				   enum drm_sched_priority priority)
> -{
> -	unsigned int i;
> -
> -	spin_lock(&entity->rq_lock);
> -
> -	for (i = 0; i < entity->num_rq_list; ++i)
> -		drm_sched_entity_set_rq_priority(&entity->rq_list[i], priority);
> -
> -	drm_sched_rq_remove_entity(entity->rq, entity);
> -	drm_sched_entity_set_rq_priority(&entity->rq, priority);
> -	drm_sched_rq_add_entity(entity->rq, entity);
> -
> -	spin_unlock(&entity->rq_lock);
> -}
> -EXPORT_SYMBOL(drm_sched_entity_set_priority);
> -
>  /**
>   * drm_sched_dependency_optimized
>   *
> @@ -479,140 +182,6 @@ bool drm_sched_dependency_optimized(struct dma_fence* fence,
>  }
>  EXPORT_SYMBOL(drm_sched_dependency_optimized);
>  
> -static bool drm_sched_entity_add_dependency_cb(struct drm_sched_entity *entity)
> -{
> -	struct drm_gpu_scheduler *sched = entity->rq->sched;
> -	struct dma_fence * fence = entity->dependency;
> -	struct drm_sched_fence *s_fence;
> -
> -	if (fence->context == entity->fence_context ||
> -            fence->context == entity->fence_context + 1) {
> -                /*
> -                 * Fence is a scheduled/finished fence from a job
> -                 * which belongs to the same entity, we can ignore
> -                 * fences from ourself
> -                 */
> -		dma_fence_put(entity->dependency);
> -		return false;
> -	}
> -
> -	s_fence = to_drm_sched_fence(fence);
> -	if (s_fence && s_fence->sched == sched) {
> -
> -		/*
> -		 * Fence is from the same scheduler, only need to wait for
> -		 * it to be scheduled
> -		 */
> -		fence = dma_fence_get(&s_fence->scheduled);
> -		dma_fence_put(entity->dependency);
> -		entity->dependency = fence;
> -		if (!dma_fence_add_callback(fence, &entity->cb,
> -					    drm_sched_entity_clear_dep))
> -			return true;
> -
> -		/* Ignore it when it is already scheduled */
> -		dma_fence_put(fence);
> -		return false;
> -	}
> -
> -	if (!dma_fence_add_callback(entity->dependency, &entity->cb,
> -				    drm_sched_entity_wakeup))
> -		return true;
> -
> -	dma_fence_put(entity->dependency);
> -	return false;
> -}
> -
> -static struct drm_sched_job *
> -drm_sched_entity_pop_job(struct drm_sched_entity *entity)
> -{
> -	struct drm_gpu_scheduler *sched = entity->rq->sched;
> -	struct drm_sched_job *sched_job = to_drm_sched_job(
> -						spsc_queue_peek(&entity->job_queue));
> -
> -	if (!sched_job)
> -		return NULL;
> -
> -	while ((entity->dependency = sched->ops->dependency(sched_job, entity))) {
> -		if (drm_sched_entity_add_dependency_cb(entity)) {
> -
> -			trace_drm_sched_job_wait_dep(sched_job, entity->dependency);
> -			return NULL;
> -		}
> -	}
> -
> -	/* skip jobs from entity that marked guilty */
> -	if (entity->guilty && atomic_read(entity->guilty))
> -		dma_fence_set_error(&sched_job->s_fence->finished, -ECANCELED);
> -
> -	dma_fence_put(entity->last_scheduled);
> -	entity->last_scheduled = dma_fence_get(&sched_job->s_fence->finished);
> -
> -	spsc_queue_pop(&entity->job_queue);
> -	return sched_job;
> -}
> -
> -/**
> - * drm_sched_entity_select_rq - select a new rq for the entity
> - *
> - * @entity: scheduler entity
> - *
> - * Check all prerequisites and select a new rq for the entity for load
> - * balancing.
> - */
> -static void drm_sched_entity_select_rq(struct drm_sched_entity *entity)
> -{
> -	struct dma_fence *fence;
> -	struct drm_sched_rq *rq;
> -
> -	if (!spsc_queue_count(&entity->job_queue) == 0 ||
> -	    entity->num_rq_list <= 1)
> -		return;
> -
> -	fence = READ_ONCE(entity->last_scheduled);
> -	if (fence && !dma_fence_is_signaled(fence))
> -		return;
> -
> -	rq = drm_sched_entity_get_free_sched(entity);
> -	spin_lock(&entity->rq_lock);
> -	drm_sched_rq_remove_entity(entity->rq, entity);
> -	entity->rq = rq;
> -	spin_unlock(&entity->rq_lock);
> -}
> -
> -/**
> - * drm_sched_entity_push_job - Submit a job to the entity's job queue
> - *
> - * @sched_job: job to submit
> - * @entity: scheduler entity
> - *
> - * Note: To guarantee that the order of insertion to queue matches
> - * the job's fence sequence number this function should be
> - * called with drm_sched_job_init under common lock.
> - *
> - * Returns 0 for success, negative error code otherwise.
> - */
> -void drm_sched_entity_push_job(struct drm_sched_job *sched_job,
> -			       struct drm_sched_entity *entity)
> -{
> -	bool first;
> -
> -	trace_drm_sched_job(sched_job, entity);
> -	atomic_inc(&entity->rq->sched->num_jobs);
> -	WRITE_ONCE(entity->last_user, current->group_leader);
> -	first = spsc_queue_push(&entity->job_queue, &sched_job->queue_node);
> -
> -	/* first job wakes up scheduler */
> -	if (first) {
> -		/* Add the entity to the run queue */
> -		spin_lock(&entity->rq_lock);
> -		drm_sched_rq_add_entity(entity->rq, entity);
> -		spin_unlock(&entity->rq_lock);
> -		drm_sched_wakeup(entity->rq->sched);
> -	}
> -}
> -EXPORT_SYMBOL(drm_sched_entity_push_job);
> -
>  /* job_finish is called after hw fence signaled
>   */
>  static void drm_sched_job_finish(struct work_struct *work)
> @@ -840,7 +409,7 @@ static bool drm_sched_ready(struct drm_gpu_scheduler *sched)
>   * @sched: scheduler instance
>   *
>   */
> -static void drm_sched_wakeup(struct drm_gpu_scheduler *sched)
> +void drm_sched_wakeup(struct drm_gpu_scheduler *sched)
>  {
>  	if (drm_sched_ready(sched))
>  		wake_up_interruptible(&sched->wake_up_worker);
> diff --git a/drivers/gpu/drm/scheduler/sched_entity.c b/drivers/gpu/drm/scheduler/sched_entity.c
> new file mode 100644
> index 000000000000..1053f27af9df
> --- /dev/null
> +++ b/drivers/gpu/drm/scheduler/sched_entity.c
> @@ -0,0 +1,459 @@
> +/*
> + * Copyright 2015 Advanced Micro Devices, Inc.
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the "Software"),
> + * to deal in the Software without restriction, including without limitation
> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> + * and/or sell copies of the Software, and to permit persons to whom the
> + * Software is furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice shall be included in
> + * all copies or substantial portions of the Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
> + * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
> + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
> + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
> + * OTHER DEALINGS IN THE SOFTWARE.
> + *
> + */
> +
> +#include <linux/kthread.h>
> +#include <drm/gpu_scheduler.h>
> +
> +#include "gpu_scheduler_trace.h"
> +
> +#define to_drm_sched_job(sched_job)		\
> +		container_of((sched_job), struct drm_sched_job, queue_node)
> +
> +/**
> + * drm_sched_entity_init - Init a context entity used by scheduler when
> + * submit to HW ring.
> + *
> + * @entity: scheduler entity to init
> + * @rq_list: the list of run queue on which jobs from this
> + *           entity can be submitted
> + * @num_rq_list: number of run queue in rq_list
> + * @guilty: atomic_t set to 1 when a job on this queue
> + *          is found to be guilty causing a timeout
> + *
> + * Note: the rq_list should have atleast one element to schedule
> + *       the entity
> + *
> + * Returns 0 on success or a negative error code on failure.
> +*/
> +int drm_sched_entity_init(struct drm_sched_entity *entity,
> +			  struct drm_sched_rq **rq_list,
> +			  unsigned int num_rq_list,
> +			  atomic_t *guilty)
> +{
> +	int i;
> +
> +	if (!(entity && rq_list && num_rq_list > 0 && rq_list[0]))
> +		return -EINVAL;
> +
> +	memset(entity, 0, sizeof(struct drm_sched_entity));
> +	INIT_LIST_HEAD(&entity->list);
> +	entity->rq = rq_list[0];
> +	entity->guilty = guilty;
> +	entity->num_rq_list = num_rq_list;
> +	entity->rq_list = kcalloc(num_rq_list, sizeof(struct drm_sched_rq *),
> +				GFP_KERNEL);
> +	if (!entity->rq_list)
> +		return -ENOMEM;
> +
> +	for (i = 0; i < num_rq_list; ++i)
> +		entity->rq_list[i] = rq_list[i];
> +	entity->last_scheduled = NULL;
> +
> +	spin_lock_init(&entity->rq_lock);
> +	spsc_queue_init(&entity->job_queue);
> +
> +	atomic_set(&entity->fence_seq, 0);
> +	entity->fence_context = dma_fence_context_alloc(2);
> +
> +	return 0;
> +}
> +EXPORT_SYMBOL(drm_sched_entity_init);
> +
> +/**
> + * drm_sched_entity_is_idle - Check if entity is idle
> + *
> + * @entity: scheduler entity
> + *
> + * Returns true if the entity does not have any unscheduled jobs.
> + */
> +static bool drm_sched_entity_is_idle(struct drm_sched_entity *entity)
> +{
> +	rmb();
> +
> +	if (list_empty(&entity->list) ||
> +	    spsc_queue_peek(&entity->job_queue) == NULL)
> +		return true;
> +
> +	return false;
> +}
> +
> +/**
> + * drm_sched_entity_is_ready - Check if entity is ready
> + *
> + * @entity: scheduler entity
> + *
> + * Return true if entity could provide a job.
> + */
> +bool drm_sched_entity_is_ready(struct drm_sched_entity *entity)
> +{
> +	if (spsc_queue_peek(&entity->job_queue) == NULL)
> +		return false;
> +
> +	if (READ_ONCE(entity->dependency))
> +		return false;
> +
> +	return true;
> +}
> +
> +/**
> + * drm_sched_entity_get_free_sched - Get the rq from rq_list with least load
> + *
> + * @entity: scheduler entity
> + *
> + * Return the pointer to the rq with least load.
> + */
> +static struct drm_sched_rq *
> +drm_sched_entity_get_free_sched(struct drm_sched_entity *entity)
> +{
> +	struct drm_sched_rq *rq = NULL;
> +	unsigned int min_jobs = UINT_MAX, num_jobs;
> +	int i;
> +
> +	for (i = 0; i < entity->num_rq_list; ++i) {
> +		num_jobs = atomic_read(&entity->rq_list[i]->sched->num_jobs);
> +		if (num_jobs < min_jobs) {
> +			min_jobs = num_jobs;
> +			rq = entity->rq_list[i];
> +		}
> +	}
> +
> +	return rq;
> +}
> +
> +static void drm_sched_entity_kill_jobs_cb(struct dma_fence *f,
> +				    struct dma_fence_cb *cb)
> +{
> +	struct drm_sched_job *job = container_of(cb, struct drm_sched_job,
> +						 finish_cb);
> +	drm_sched_fence_finished(job->s_fence);
> +	WARN_ON(job->s_fence->parent);
> +	dma_fence_put(&job->s_fence->finished);
> +	job->sched->ops->free_job(job);
> +}
> +
> +
> +/**
> + * drm_sched_entity_flush - Flush a context entity
> + *
> + * @entity: scheduler entity
> + * @timeout: time to wait in for Q to become empty in jiffies.
> + *
> + * Splitting drm_sched_entity_fini() into two functions, The first one does the waiting,
> + * removes the entity from the runqueue and returns an error when the process was killed.
> + *
> + * Returns the remaining time in jiffies left from the input timeout
> + */
> +long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout)
> +{
> +	struct drm_gpu_scheduler *sched;
> +	struct task_struct *last_user;
> +	long ret = timeout;
> +
> +	sched = entity->rq->sched;
> +	/**
> +	 * The client will not queue more IBs during this fini, consume existing
> +	 * queued IBs or discard them on SIGKILL
> +	*/
> +	if (current->flags & PF_EXITING) {
> +		if (timeout)
> +			ret = wait_event_timeout(
> +					sched->job_scheduled,
> +					drm_sched_entity_is_idle(entity),
> +					timeout);
> +	} else {
> +		wait_event_killable(sched->job_scheduled,
> +				    drm_sched_entity_is_idle(entity));
> +	}
> +
> +	/* For killed process disable any more IBs enqueue right now */
> +	last_user = cmpxchg(&entity->last_user, current->group_leader, NULL);
> +	if ((!last_user || last_user == current->group_leader) &&
> +	    (current->flags & PF_EXITING) && (current->exit_code == SIGKILL))
> +		drm_sched_rq_remove_entity(entity->rq, entity);
> +
> +	return ret;
> +}
> +EXPORT_SYMBOL(drm_sched_entity_flush);
> +
> +/**
> + * drm_sched_entity_cleanup - Destroy a context entity
> + *
> + * @entity: scheduler entity
> + *
> + * This should be called after @drm_sched_entity_do_release. It goes over the
> + * entity and signals all jobs with an error code if the process was killed.
> + *
> + */
> +void drm_sched_entity_fini(struct drm_sched_entity *entity)
> +{
> +	struct drm_gpu_scheduler *sched;
> +
> +	sched = entity->rq->sched;
> +	drm_sched_rq_remove_entity(entity->rq, entity);
> +
> +	/* Consumption of existing IBs wasn't completed. Forcefully
> +	 * remove them here.
> +	 */
> +	if (spsc_queue_peek(&entity->job_queue)) {
> +		struct drm_sched_job *job;
> +		int r;
> +
> +		/* Park the kernel for a moment to make sure it isn't processing
> +		 * our enity.
> +		 */
> +		kthread_park(sched->thread);
> +		kthread_unpark(sched->thread);
> +		if (entity->dependency) {
> +			dma_fence_remove_callback(entity->dependency,
> +						  &entity->cb);
> +			dma_fence_put(entity->dependency);
> +			entity->dependency = NULL;
> +		}
> +
> +		while ((job = to_drm_sched_job(spsc_queue_pop(&entity->job_queue)))) {
> +			struct drm_sched_fence *s_fence = job->s_fence;
> +			drm_sched_fence_scheduled(s_fence);
> +			dma_fence_set_error(&s_fence->finished, -ESRCH);
> +
> +			/*
> +			 * When pipe is hanged by older entity, new entity might
> +			 * not even have chance to submit it's first job to HW
> +			 * and so entity->last_scheduled will remain NULL
> +			 */
> +			if (!entity->last_scheduled) {
> +				drm_sched_entity_kill_jobs_cb(NULL, &job->finish_cb);
> +			} else {
> +				r = dma_fence_add_callback(entity->last_scheduled, &job->finish_cb,
> +								drm_sched_entity_kill_jobs_cb);
> +				if (r == -ENOENT)
> +					drm_sched_entity_kill_jobs_cb(NULL, &job->finish_cb);
> +				else if (r)
> +					DRM_ERROR("fence add callback failed (%d)\n", r);
> +			}
> +		}
> +	}
> +
> +	dma_fence_put(entity->last_scheduled);
> +	entity->last_scheduled = NULL;
> +	kfree(entity->rq_list);
> +}
> +EXPORT_SYMBOL(drm_sched_entity_fini);
> +
> +/**
> + * drm_sched_entity_fini - Destroy a context entity
> + *
> + * @entity: scheduler entity
> + *
> + * Calls drm_sched_entity_do_release() and drm_sched_entity_cleanup()
> + */
> +void drm_sched_entity_destroy(struct drm_sched_entity *entity)
> +{
> +	drm_sched_entity_flush(entity, MAX_WAIT_SCHED_ENTITY_Q_EMPTY);
> +	drm_sched_entity_fini(entity);
> +}
> +EXPORT_SYMBOL(drm_sched_entity_destroy);
> +
> +static void drm_sched_entity_wakeup(struct dma_fence *f, struct dma_fence_cb *cb)
> +{
> +	struct drm_sched_entity *entity =
> +		container_of(cb, struct drm_sched_entity, cb);
> +	entity->dependency = NULL;
> +	dma_fence_put(f);
> +	drm_sched_wakeup(entity->rq->sched);
> +}
> +
> +static void drm_sched_entity_clear_dep(struct dma_fence *f, struct dma_fence_cb *cb)
> +{
> +	struct drm_sched_entity *entity =
> +		container_of(cb, struct drm_sched_entity, cb);
> +	entity->dependency = NULL;
> +	dma_fence_put(f);
> +}
> +
> +/**
> + * drm_sched_entity_set_rq_priority - helper for drm_sched_entity_set_priority
> + */
> +static void drm_sched_entity_set_rq_priority(struct drm_sched_rq **rq,
> +					     enum drm_sched_priority priority)
> +{
> +	*rq = &(*rq)->sched->sched_rq[priority];
> +}
> +
> +/**
> + * drm_sched_entity_set_priority - Sets priority of the entity
> + *
> + * @entity: scheduler entity
> + * @priority: scheduler priority
> + *
> + * Update the priority of runqueus used for the entity.
> + */
> +void drm_sched_entity_set_priority(struct drm_sched_entity *entity,
> +				   enum drm_sched_priority priority)
> +{
> +	unsigned int i;
> +
> +	spin_lock(&entity->rq_lock);
> +
> +	for (i = 0; i < entity->num_rq_list; ++i)
> +		drm_sched_entity_set_rq_priority(&entity->rq_list[i], priority);
> +
> +	drm_sched_rq_remove_entity(entity->rq, entity);
> +	drm_sched_entity_set_rq_priority(&entity->rq, priority);
> +	drm_sched_rq_add_entity(entity->rq, entity);
> +
> +	spin_unlock(&entity->rq_lock);
> +}
> +EXPORT_SYMBOL(drm_sched_entity_set_priority);
> +
> +static bool drm_sched_entity_add_dependency_cb(struct drm_sched_entity *entity)
> +{
> +	struct drm_gpu_scheduler *sched = entity->rq->sched;
> +	struct dma_fence * fence = entity->dependency;
> +	struct drm_sched_fence *s_fence;
> +
> +	if (fence->context == entity->fence_context ||
> +            fence->context == entity->fence_context + 1) {
> +                /*
> +                 * Fence is a scheduled/finished fence from a job
> +                 * which belongs to the same entity, we can ignore
> +                 * fences from ourself
> +                 */
> +		dma_fence_put(entity->dependency);
> +		return false;
> +	}
> +
> +	s_fence = to_drm_sched_fence(fence);
> +	if (s_fence && s_fence->sched == sched) {
> +
> +		/*
> +		 * Fence is from the same scheduler, only need to wait for
> +		 * it to be scheduled
> +		 */
> +		fence = dma_fence_get(&s_fence->scheduled);
> +		dma_fence_put(entity->dependency);
> +		entity->dependency = fence;
> +		if (!dma_fence_add_callback(fence, &entity->cb,
> +					    drm_sched_entity_clear_dep))
> +			return true;
> +
> +		/* Ignore it when it is already scheduled */
> +		dma_fence_put(fence);
> +		return false;
> +	}
> +
> +	if (!dma_fence_add_callback(entity->dependency, &entity->cb,
> +				    drm_sched_entity_wakeup))
> +		return true;
> +
> +	dma_fence_put(entity->dependency);
> +	return false;
> +}
> +
> +struct drm_sched_job *drm_sched_entity_pop_job(struct drm_sched_entity *entity)
> +{
> +	struct drm_gpu_scheduler *sched = entity->rq->sched;
> +	struct drm_sched_job *sched_job = to_drm_sched_job(
> +						spsc_queue_peek(&entity->job_queue));
> +
> +	if (!sched_job)
> +		return NULL;
> +
> +	while ((entity->dependency = sched->ops->dependency(sched_job, entity))) {
> +		if (drm_sched_entity_add_dependency_cb(entity)) {
> +
> +			trace_drm_sched_job_wait_dep(sched_job, entity->dependency);
> +			return NULL;
> +		}
> +	}
> +
> +	/* skip jobs from entity that marked guilty */
> +	if (entity->guilty && atomic_read(entity->guilty))
> +		dma_fence_set_error(&sched_job->s_fence->finished, -ECANCELED);
> +
> +	dma_fence_put(entity->last_scheduled);
> +	entity->last_scheduled = dma_fence_get(&sched_job->s_fence->finished);
> +
> +	spsc_queue_pop(&entity->job_queue);
> +	return sched_job;
> +}
> +
> +/**
> + * drm_sched_entity_select_rq - select a new rq for the entity
> + *
> + * @entity: scheduler entity
> + *
> + * Check all prerequisites and select a new rq for the entity for load
> + * balancing.
> + */
> +void drm_sched_entity_select_rq(struct drm_sched_entity *entity)
> +{
> +	struct dma_fence *fence;
> +	struct drm_sched_rq *rq;
> +
> +	if (!spsc_queue_count(&entity->job_queue) == 0 ||
> +	    entity->num_rq_list <= 1)
> +		return;
> +
> +	fence = READ_ONCE(entity->last_scheduled);
> +	if (fence && !dma_fence_is_signaled(fence))
> +		return;
> +
> +	rq = drm_sched_entity_get_free_sched(entity);
> +	spin_lock(&entity->rq_lock);
> +	drm_sched_rq_remove_entity(entity->rq, entity);
> +	entity->rq = rq;
> +	spin_unlock(&entity->rq_lock);
> +}
> +
> +/**
> + * drm_sched_entity_push_job - Submit a job to the entity's job queue
> + *
> + * @sched_job: job to submit
> + * @entity: scheduler entity
> + *
> + * Note: To guarantee that the order of insertion to queue matches
> + * the job's fence sequence number this function should be
> + * called with drm_sched_job_init under common lock.
> + *
> + * Returns 0 for success, negative error code otherwise.
> + */
> +void drm_sched_entity_push_job(struct drm_sched_job *sched_job,
> +			       struct drm_sched_entity *entity)
> +{
> +	bool first;
> +
> +	trace_drm_sched_job(sched_job, entity);
> +	atomic_inc(&entity->rq->sched->num_jobs);
> +	WRITE_ONCE(entity->last_user, current->group_leader);
> +	first = spsc_queue_push(&entity->job_queue, &sched_job->queue_node);
> +
> +	/* first job wakes up scheduler */
> +	if (first) {
> +		/* Add the entity to the run queue */
> +		spin_lock(&entity->rq_lock);
> +		drm_sched_rq_add_entity(entity->rq, entity);
> +		spin_unlock(&entity->rq_lock);
> +		drm_sched_wakeup(entity->rq->sched);
> +	}
> +}
> +EXPORT_SYMBOL(drm_sched_entity_push_job);
> diff --git a/include/drm/gpu_scheduler.h b/include/drm/gpu_scheduler.h
> index 22c0f88f7d8f..919ae572f775 100644
> --- a/include/drm/gpu_scheduler.h
> +++ b/include/drm/gpu_scheduler.h
> @@ -288,6 +288,21 @@ int drm_sched_init(struct drm_gpu_scheduler *sched,
>  		   uint32_t hw_submission, unsigned hang_limit, long timeout,
>  		   const char *name);
>  void drm_sched_fini(struct drm_gpu_scheduler *sched);
> +int drm_sched_job_init(struct drm_sched_job *job,
> +		       struct drm_sched_entity *entity,
> +		       void *owner);
> +void drm_sched_wakeup(struct drm_gpu_scheduler *sched);
> +void drm_sched_hw_job_reset(struct drm_gpu_scheduler *sched,
> +			    struct drm_sched_job *job);
> +void drm_sched_job_recovery(struct drm_gpu_scheduler *sched);
> +bool drm_sched_dependency_optimized(struct dma_fence* fence,
> +				    struct drm_sched_entity *entity);
> +void drm_sched_job_kickout(struct drm_sched_job *s_job);
> +
> +void drm_sched_rq_add_entity(struct drm_sched_rq *rq,
> +			     struct drm_sched_entity *entity);
> +void drm_sched_rq_remove_entity(struct drm_sched_rq *rq,
> +				struct drm_sched_entity *entity);
>  
>  int drm_sched_entity_init(struct drm_sched_entity *entity,
>  			  struct drm_sched_rq **rq_list,
> @@ -296,22 +311,17 @@ int drm_sched_entity_init(struct drm_sched_entity *entity,
>  long drm_sched_entity_flush(struct drm_sched_entity *entity, long timeout);
>  void drm_sched_entity_fini(struct drm_sched_entity *entity);
>  void drm_sched_entity_destroy(struct drm_sched_entity *entity);
> +void drm_sched_entity_select_rq(struct drm_sched_entity *entity);
> +struct drm_sched_job *drm_sched_entity_pop_job(struct drm_sched_entity *entity);
>  void drm_sched_entity_push_job(struct drm_sched_job *sched_job,
>  			       struct drm_sched_entity *entity);
>  void drm_sched_entity_set_priority(struct drm_sched_entity *entity,
>  				   enum drm_sched_priority priority);
> +bool drm_sched_entity_is_ready(struct drm_sched_entity *entity);
> +
>  struct drm_sched_fence *drm_sched_fence_create(
>  	struct drm_sched_entity *s_entity, void *owner);
>  void drm_sched_fence_scheduled(struct drm_sched_fence *fence);
>  void drm_sched_fence_finished(struct drm_sched_fence *fence);
> -int drm_sched_job_init(struct drm_sched_job *job,
> -		       struct drm_sched_entity *entity,
> -		       void *owner);
> -void drm_sched_hw_job_reset(struct drm_gpu_scheduler *sched,
> -			    struct drm_sched_job *job);
> -void drm_sched_job_recovery(struct drm_gpu_scheduler *sched);
> -bool drm_sched_dependency_optimized(struct dma_fence* fence,
> -				    struct drm_sched_entity *entity);
> -void drm_sched_job_kickout(struct drm_sched_job *s_job);
>  
>  #endif
> -- 
> 2.14.1
> 
> _______________________________________________
> amd-gfx mailing list
> amd-gfx@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/amd-gfx
_______________________________________________
amd-gfx mailing list
amd-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

Re: [PATCH 1/4] drm/scheduler: trivial error handling fix

[Andrey Grodzovsky]

Reviewed-by: Andrey Grodzovsky <andrey.grodzovsky@amd.com>

Andrey


On 08/14/2018 04:23 AM, Huang Rui wrote:
> On Tue, Aug 14, 2018 at 10:12:23AM +0200, Christian König wrote:
>> Return -ENOMEM when allocating the rq_list fails.
>>
>> Signed-off-by: Christian König <christian.koenig@amd.com>
> Reviewed-by: Huang Rui <ray.huang@amd.com>
>
>> ---
>>   drivers/gpu/drm/scheduler/gpu_scheduler.c | 3 +++
>>   1 file changed, 3 insertions(+)
>>
>> diff --git a/drivers/gpu/drm/scheduler/gpu_scheduler.c b/drivers/gpu/drm/scheduler/gpu_scheduler.c
>> index f566405f49e3..85c1f95752cc 100644
>> --- a/drivers/gpu/drm/scheduler/gpu_scheduler.c
>> +++ b/drivers/gpu/drm/scheduler/gpu_scheduler.c
>> @@ -191,6 +191,9 @@ int drm_sched_entity_init(struct drm_sched_entity *entity,
>>   	entity->num_rq_list = num_rq_list;
>>   	entity->rq_list = kcalloc(num_rq_list, sizeof(struct drm_sched_rq *),
>>   				GFP_KERNEL);
>> +	if (!entity->rq_list)
>> +		return -ENOMEM;
>> +
>>   	for (i = 0; i < num_rq_list; ++i)
>>   		entity->rq_list[i] = rq_list[i];
>>   	entity->last_scheduled = NULL;
>> -- 
>> 2.14.1
>>
>> _______________________________________________
>> amd-gfx mailing list
>> amd-gfx@lists.freedesktop.org
>> https://lists.freedesktop.org/mailman/listinfo/amd-gfx
> _______________________________________________
> dri-devel mailing list
> dri-devel@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/dri-devel

_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel