| Message ID | 20180918161710.2669-1-nayan26deshmukh@gmail.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | [1/2] drm/scheduler: add a current job field to scheduler | expand |
Am 18.09.2018 um 18:17 schrieb Nayan Deshmukh: > Which points to the job running on the hardware. This is > useful when we need to access the currently executing job > from the scheduler. That should be identical to list_first_entry_or_null(&sched->ring_mirror_list), doesn't it? Regards, Christian. > > Signed-off-by: Nayan Deshmukh <nayan26deshmukh@gmail.com> > ---list_first_entry_or_null(&sched->ring_mirror_list > > drivers/gpu/drm/scheduler/sched_main.c | 17 +++++++++++------ > include/drm/gpu_scheduler.h | 2 ++ > 2 files changed, 13 insertions(+), 6 deletions(-) > > diff --git a/drivers/gpu/drm/scheduler/sched_main.c b/drivers/gpu/drm/scheduler/sched_main.c > index 9ca741f3a0bc..0e6ccc8243db 100644 > --- a/drivers/gpu/drm/scheduler/sched_main.c > +++ b/drivers/gpu/drm/scheduler/sched_main.c > @@ -189,6 +189,7 @@ static void drm_sched_job_finish(struct work_struct *work) > struct drm_sched_job *s_job = container_of(work, struct drm_sched_job, > finish_work); > struct drm_gpu_scheduler *sched = s_job->sched; > + struct drm_sched_job *next; > > /* > * Canceling the timeout without removing our job from the ring mirror > @@ -201,10 +202,10 @@ static void drm_sched_job_finish(struct work_struct *work) > > spin_lock(&sched->job_list_lock); > /* queue TDR for next job */ > + next = list_next_entry(s_job, node); > + sched->curr_job = next; > if (sched->timeout != MAX_SCHEDULE_TIMEOUT && > !list_is_last(&s_job->node, &sched->ring_mirror_list)) { > - struct drm_sched_job *next = list_next_entry(s_job, node); > - > if (!dma_fence_is_signaled(&next->s_fence->finished)) > schedule_delayed_work(&next->work_tdr, sched->timeout); > } > @@ -233,10 +234,12 @@ static void drm_sched_job_begin(struct drm_sched_job *s_job) > > spin_lock(&sched->job_list_lock); > list_add_tail(&s_job->node, &sched->ring_mirror_list); > - if (sched->timeout != MAX_SCHEDULE_TIMEOUT && > - list_first_entry_or_null(&sched->ring_mirror_list, > - struct drm_sched_job, node) == s_job) > - schedule_delayed_work(&s_job->work_tdr, sched->timeout); > + if (list_first_entry_or_null(&sched->ring_mirror_list, > + struct drm_sched_job, node) == s_job) { > + if (sched->timeout != MAX_SCHEDULE_TIMEOUT) > + schedule_delayed_work(&s_job->work_tdr, sched->timeout); > + sched->curr_job = s_job; > + } > spin_unlock(&sched->job_list_lock); > } > > @@ -316,6 +319,8 @@ void drm_sched_job_recovery(struct drm_gpu_scheduler *sched) > struct drm_sched_job, node); > if (s_job && sched->timeout != MAX_SCHEDULE_TIMEOUT) > schedule_delayed_work(&s_job->work_tdr, sched->timeout); > + if (s_job) > + sched->curr_job = s_job; > > list_for_each_entry_safe(s_job, tmp, &sched->ring_mirror_list, node) { > struct drm_sched_fence *s_fence = s_job->s_fence; > diff --git a/include/drm/gpu_scheduler.h b/include/drm/gpu_scheduler.h > index daec50f887b3..07e776b1ca42 100644 > --- a/include/drm/gpu_scheduler.h > +++ b/include/drm/gpu_scheduler.h > @@ -252,6 +252,7 @@ struct drm_sched_backend_ops { > * @timeout: the time after which a job is removed from the scheduler. > * @name: name of the ring for which this scheduler is being used. > * @sched_rq: priority wise array of run queues. > + * @curr_job: points to the job currently running on the hardware > * @wake_up_worker: the wait queue on which the scheduler sleeps until a job > * is ready to be scheduled. > * @job_scheduled: once @drm_sched_entity_do_release is called the scheduler > @@ -274,6 +275,7 @@ struct drm_gpu_scheduler { > long timeout; > const char *name; > struct drm_sched_rq sched_rq[DRM_SCHED_PRIORITY_MAX]; > + struct drm_sched_job *curr_job; > wait_queue_head_t wake_up_worker; > wait_queue_head_t job_scheduled; > atomic_t hw_rq_count;
Hi Christian, Yes you are correct. My bad. Do you have any comments on the second patch? I will drop this patch and rebase the second one. Regards, Nayan On Wed, Sep 19, 2018, 2:09 AM Koenig, Christian <Christian.Koenig@amd.com> wrote: > Am 18.09.2018 um 18:17 schrieb Nayan Deshmukh: > > Which points to the job running on the hardware. This is > > useful when we need to access the currently executing job > > from the scheduler. > > That should be identical to > list_first_entry_or_null(&sched->ring_mirror_list), doesn't it? > > Regards, > Christian. > > > > > Signed-off-by: Nayan Deshmukh <nayan26deshmukh@gmail.com> > > ---list_first_entry_or_null(&sched->ring_mirror_list > > > > drivers/gpu/drm/scheduler/sched_main.c | 17 +++++++++++------ > > include/drm/gpu_scheduler.h | 2 ++ > > 2 files changed, 13 insertions(+), 6 deletions(-) > > > > diff --git a/drivers/gpu/drm/scheduler/sched_main.c > b/drivers/gpu/drm/scheduler/sched_main.c > > index 9ca741f3a0bc..0e6ccc8243db 100644 > > --- a/drivers/gpu/drm/scheduler/sched_main.c > > +++ b/drivers/gpu/drm/scheduler/sched_main.c > > @@ -189,6 +189,7 @@ static void drm_sched_job_finish(struct work_struct > *work) > > struct drm_sched_job *s_job = container_of(work, struct > drm_sched_job, > > finish_work); > > struct drm_gpu_scheduler *sched = s_job->sched; > > + struct drm_sched_job *next; > > > > /* > > * Canceling the timeout without removing our job from the ring > mirror > > @@ -201,10 +202,10 @@ static void drm_sched_job_finish(struct > work_struct *work) > > > > spin_lock(&sched->job_list_lock); > > /* queue TDR for next job */ > > + next = list_next_entry(s_job, node); > > + sched->curr_job = next; > > if (sched->timeout != MAX_SCHEDULE_TIMEOUT && > > !list_is_last(&s_job->node, &sched->ring_mirror_list)) { > > - struct drm_sched_job *next = list_next_entry(s_job, node); > > - > > if (!dma_fence_is_signaled(&next->s_fence->finished)) > > schedule_delayed_work(&next->work_tdr, > sched->timeout); > > } > > @@ -233,10 +234,12 @@ static void drm_sched_job_begin(struct > drm_sched_job *s_job) > > > > spin_lock(&sched->job_list_lock); > > list_add_tail(&s_job->node, &sched->ring_mirror_list); > > - if (sched->timeout != MAX_SCHEDULE_TIMEOUT && > > - list_first_entry_or_null(&sched->ring_mirror_list, > > - struct drm_sched_job, node) == s_job) > > - schedule_delayed_work(&s_job->work_tdr, sched->timeout); > > + if (list_first_entry_or_null(&sched->ring_mirror_list, > > + struct drm_sched_job, node) == s_job) { > > + if (sched->timeout != MAX_SCHEDULE_TIMEOUT) > > + schedule_delayed_work(&s_job->work_tdr, > sched->timeout); > > + sched->curr_job = s_job; > > + } > > spin_unlock(&sched->job_list_lock); > > } > > > > @@ -316,6 +319,8 @@ void drm_sched_job_recovery(struct drm_gpu_scheduler > *sched) > > struct drm_sched_job, node); > > if (s_job && sched->timeout != MAX_SCHEDULE_TIMEOUT) > > schedule_delayed_work(&s_job->work_tdr, sched->timeout); > > + if (s_job) > > + sched->curr_job = s_job; > > > > list_for_each_entry_safe(s_job, tmp, &sched->ring_mirror_list, > node) { > > struct drm_sched_fence *s_fence = s_job->s_fence; > > diff --git a/include/drm/gpu_scheduler.h b/include/drm/gpu_scheduler.h > > index daec50f887b3..07e776b1ca42 100644 > > --- a/include/drm/gpu_scheduler.h > > +++ b/include/drm/gpu_scheduler.h > > @@ -252,6 +252,7 @@ struct drm_sched_backend_ops { > > * @timeout: the time after which a job is removed from the scheduler. > > * @name: name of the ring for which this scheduler is being used. > > * @sched_rq: priority wise array of run queues. > > + * @curr_job: points to the job currently running on the hardware > > * @wake_up_worker: the wait queue on which the scheduler sleeps until > a job > > * is ready to be scheduled. > > * @job_scheduled: once @drm_sched_entity_do_release is called the > scheduler > > @@ -274,6 +275,7 @@ struct drm_gpu_scheduler { > > long timeout; > > const char *name; > > struct drm_sched_rq sched_rq[DRM_SCHED_PRIORITY_MAX]; > > + struct drm_sched_job *curr_job; > > wait_queue_head_t wake_up_worker; > > wait_queue_head_t job_scheduled; > > atomic_t hw_rq_count; > > <div dir="auto"><div><div dir="ltr" style="font-family:sans-serif">Hi Christian,<br></div><div dir="auto" style="font-family:sans-serif"><div dir="auto"><br></div><div dir="auto">Yes you are correct. My bad. </div><div dir="auto"><br></div><div dir="auto">Do you have any comments on the second patch? I will drop this patch and rebase the second one.</div><div dir="auto"><br></div><div dir="auto">Regards,</div><div dir="auto">Nayan</div></div><br><br><div class="gmail_quote"><div dir="ltr">On Wed, Sep 19, 2018, 2:09 AM Koenig, Christian <<a href="mailto:Christian.Koenig@amd.com">Christian.Koenig@amd.com</a>> wrote:<br></div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Am 18.09.2018 um 18:17 schrieb Nayan Deshmukh:<br> > Which points to the job running on the hardware. This is<br> > useful when we need to access the currently executing job<br> > from the scheduler.<br> <br> That should be identical to <br> list_first_entry_or_null(&sched->ring_mirror_list), doesn't it?<br> <br> Regards,<br> Christian.<br> <br> ><br> > Signed-off-by: Nayan Deshmukh <<a href="mailto:nayan26deshmukh@gmail.com" target="_blank" rel="noreferrer">nayan26deshmukh@gmail.com</a>><br> > ---list_first_entry_or_null(&sched->ring_mirror_list<br> ><br> > drivers/gpu/drm/scheduler/sched_main.c | 17 +++++++++++------<br> > include/drm/gpu_scheduler.h | 2 ++<br> > 2 files changed, 13 insertions(+), 6 deletions(-)<br> ><br> > diff --git a/drivers/gpu/drm/scheduler/sched_main.c b/drivers/gpu/drm/scheduler/sched_main.c<br> > index 9ca741f3a0bc..0e6ccc8243db 100644<br> > --- a/drivers/gpu/drm/scheduler/sched_main.c<br> > +++ b/drivers/gpu/drm/scheduler/sched_main.c<br> > @@ -189,6 +189,7 @@ static void drm_sched_job_finish(struct work_struct *work)<br> > struct drm_sched_job *s_job = container_of(work, struct drm_sched_job,<br> > finish_work);<br> > struct drm_gpu_scheduler *sched = s_job->sched;<br> > + struct drm_sched_job *next;<br> > <br> > /*<br> > * Canceling the timeout without removing our job from the ring mirror<br> > @@ -201,10 +202,10 @@ static void drm_sched_job_finish(struct work_struct *work)<br> > <br> > spin_lock(&sched->job_list_lock);<br> > /* queue TDR for next job */<br> > + next = list_next_entry(s_job, node);<br> > + sched->curr_job = next;<br> > if (sched->timeout != MAX_SCHEDULE_TIMEOUT &&<br> > !list_is_last(&s_job->node, &sched->ring_mirror_list)) {<br> > - struct drm_sched_job *next = list_next_entry(s_job, node);<br> > -<br> > if (!dma_fence_is_signaled(&next->s_fence->finished))<br> > schedule_delayed_work(&next->work_tdr, sched->timeout);<br> > }<br> > @@ -233,10 +234,12 @@ static void drm_sched_job_begin(struct drm_sched_job *s_job)<br> > <br> > spin_lock(&sched->job_list_lock);<br> > list_add_tail(&s_job->node, &sched->ring_mirror_list);<br> > - if (sched->timeout != MAX_SCHEDULE_TIMEOUT &&<br> > - list_first_entry_or_null(&sched->ring_mirror_list,<br> > - struct drm_sched_job, node) == s_job)<br> > - schedule_delayed_work(&s_job->work_tdr, sched->timeout);<br> > + if (list_first_entry_or_null(&sched->ring_mirror_list,<br> > + struct drm_sched_job, node) == s_job) {<br> > + if (sched->timeout != MAX_SCHEDULE_TIMEOUT)<br> > + schedule_delayed_work(&s_job->work_tdr, sched->timeout);<br> > + sched->curr_job = s_job;<br> > + }<br> > spin_unlock(&sched->job_list_lock);<br> > }<br> > <br> > @@ -316,6 +319,8 @@ void drm_sched_job_recovery(struct drm_gpu_scheduler *sched)<br> > struct drm_sched_job, node);<br> > if (s_job && sched->timeout != MAX_SCHEDULE_TIMEOUT)<br> > schedule_delayed_work(&s_job->work_tdr, sched->timeout);<br> > + if (s_job)<br> > + sched->curr_job = s_job;<br> > <br> > list_for_each_entry_safe(s_job, tmp, &sched->ring_mirror_list, node) {<br> > struct drm_sched_fence *s_fence = s_job->s_fence;<br> > diff --git a/include/drm/gpu_scheduler.h b/include/drm/gpu_scheduler.h<br> > index daec50f887b3..07e776b1ca42 100644<br> > --- a/include/drm/gpu_scheduler.h<br> > +++ b/include/drm/gpu_scheduler.h<br> > @@ -252,6 +252,7 @@ struct drm_sched_backend_ops {<br> > * @timeout: the time after which a job is removed from the scheduler.<br> > * @name: name of the ring for which this scheduler is being used.<br> > * @sched_rq: priority wise array of run queues.<br> > + * @curr_job: points to the job currently running on the hardware<br> > * @wake_up_worker: the wait queue on which the scheduler sleeps until a job<br> > * is ready to be scheduled.<br> > * @job_scheduled: once @drm_sched_entity_do_release is called the scheduler<br> > @@ -274,6 +275,7 @@ struct drm_gpu_scheduler {<br> > long timeout;<br> > const char *name;<br> > struct drm_sched_rq sched_rq[DRM_SCHED_PRIORITY_MAX];<br> > + struct drm_sched_job *curr_job;<br> > wait_queue_head_t wake_up_worker;<br> > wait_queue_head_t job_scheduled;<br> > atomic_t hw_rq_count;<br> <br> </blockquote></div></div></div>
diff --git a/drivers/gpu/drm/scheduler/sched_main.c b/drivers/gpu/drm/scheduler/sched_main.c index 9ca741f3a0bc..0e6ccc8243db 100644 --- a/drivers/gpu/drm/scheduler/sched_main.c +++ b/drivers/gpu/drm/scheduler/sched_main.c @@ -189,6 +189,7 @@ static void drm_sched_job_finish(struct work_struct *work) struct drm_sched_job *s_job = container_of(work, struct drm_sched_job, finish_work); struct drm_gpu_scheduler *sched = s_job->sched; + struct drm_sched_job *next; /* * Canceling the timeout without removing our job from the ring mirror @@ -201,10 +202,10 @@ static void drm_sched_job_finish(struct work_struct *work) spin_lock(&sched->job_list_lock); /* queue TDR for next job */ + next = list_next_entry(s_job, node); + sched->curr_job = next; if (sched->timeout != MAX_SCHEDULE_TIMEOUT && !list_is_last(&s_job->node, &sched->ring_mirror_list)) { - struct drm_sched_job *next = list_next_entry(s_job, node); - if (!dma_fence_is_signaled(&next->s_fence->finished)) schedule_delayed_work(&next->work_tdr, sched->timeout); } @@ -233,10 +234,12 @@ static void drm_sched_job_begin(struct drm_sched_job *s_job) spin_lock(&sched->job_list_lock); list_add_tail(&s_job->node, &sched->ring_mirror_list); - if (sched->timeout != MAX_SCHEDULE_TIMEOUT && - list_first_entry_or_null(&sched->ring_mirror_list, - struct drm_sched_job, node) == s_job) - schedule_delayed_work(&s_job->work_tdr, sched->timeout); + if (list_first_entry_or_null(&sched->ring_mirror_list, + struct drm_sched_job, node) == s_job) { + if (sched->timeout != MAX_SCHEDULE_TIMEOUT) + schedule_delayed_work(&s_job->work_tdr, sched->timeout); + sched->curr_job = s_job; + } spin_unlock(&sched->job_list_lock); } @@ -316,6 +319,8 @@ void drm_sched_job_recovery(struct drm_gpu_scheduler *sched) struct drm_sched_job, node); if (s_job && sched->timeout != MAX_SCHEDULE_TIMEOUT) schedule_delayed_work(&s_job->work_tdr, sched->timeout); + if (s_job) + sched->curr_job = s_job; list_for_each_entry_safe(s_job, tmp, &sched->ring_mirror_list, node) { struct drm_sched_fence *s_fence = s_job->s_fence; diff --git a/include/drm/gpu_scheduler.h b/include/drm/gpu_scheduler.h index daec50f887b3..07e776b1ca42 100644 --- a/include/drm/gpu_scheduler.h +++ b/include/drm/gpu_scheduler.h @@ -252,6 +252,7 @@ struct drm_sched_backend_ops { * @timeout: the time after which a job is removed from the scheduler. * @name: name of the ring for which this scheduler is being used. * @sched_rq: priority wise array of run queues. + * @curr_job: points to the job currently running on the hardware * @wake_up_worker: the wait queue on which the scheduler sleeps until a job * is ready to be scheduled. * @job_scheduled: once @drm_sched_entity_do_release is called the scheduler @@ -274,6 +275,7 @@ struct drm_gpu_scheduler { long timeout; const char *name; struct drm_sched_rq sched_rq[DRM_SCHED_PRIORITY_MAX]; + struct drm_sched_job *curr_job; wait_queue_head_t wake_up_worker; wait_queue_head_t job_scheduled; atomic_t hw_rq_count;
Which points to the job running on the hardware. This is useful when we need to access the currently executing job from the scheduler. Signed-off-by: Nayan Deshmukh <nayan26deshmukh@gmail.com> --- drivers/gpu/drm/scheduler/sched_main.c | 17 +++++++++++------ include/drm/gpu_scheduler.h | 2 ++ 2 files changed, 13 insertions(+), 6 deletions(-)