[PATCH 1/2] drm/scheduler: add a current job field to scheduler

[Nayan Deshmukh]

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 at 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 at 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;
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.freedesktop.org/archives/dri-devel/attachments/20180919/b69b4f96/attachment-0001.html>