drivers/gpu/drm/i915/gem/i915_gem_throttle.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright © 2014-2016 Intel Corporation
   5  */
   6
   7 #include <linux/jiffies.h>
   8
   9 #include <drm/drm_file.h>
  10
  11 #include "i915_drv.h"
  12 #include "i915_gem_context.h"
  13 #include "i915_gem_ioctls.h"
  14 #include "i915_gem_object.h"
  15
  16 /*
  17  * 20ms is a fairly arbitrary limit (greater than the average frame time)
  18  * chosen to prevent the CPU getting more than a frame ahead of the GPU
  19  * (when using lax throttling for the frontbuffer). We also use it to
  20  * offer free GPU waitboosts for severely congested workloads.
  21  */
  22 #define DRM_I915_THROTTLE_JIFFIES msecs_to_jiffies(20)
  23
  24 /*
  25  * Throttle our rendering by waiting until the ring has completed our requests
  26  * emitted over 20 msec ago.
  27  *
  28  * Note that if we were to use the current jiffies each time around the loop,
  29  * we wouldn't escape the function with any frames outstanding if the time to
  30  * render a frame was over 20ms.
  31  *
  32  * This should get us reasonable parallelism between CPU and GPU but also
  33  * relatively low latency when blocking on a particular request to finish.
  34  */
  35 int
  36 i915_gem_throttle_ioctl(struct drm_device *dev, void *data,
  37                         struct drm_file *file)
  38 {
  39         const unsigned long recent_enough = jiffies - DRM_I915_THROTTLE_JIFFIES;
  40         struct drm_i915_file_private *file_priv = file->driver_priv;
  41         struct i915_gem_context *ctx;
  42         unsigned long idx;
  43         long ret;
  44
  45         /* ABI: return -EIO if already wedged */
  46         ret = intel_gt_terminally_wedged(&to_i915(dev)->gt);
  47         if (ret)
  48                 return ret;
  49
  50         rcu_read_lock();
  51         xa_for_each(&file_priv->context_xa, idx, ctx) {
  52                 struct i915_gem_engines_iter it;
  53                 struct intel_context *ce;
  54
  55                 if (!kref_get_unless_zero(&ctx->ref))
  56                         continue;
  57                 rcu_read_unlock();
  58
  59                 for_each_gem_engine(ce,
  60                                     i915_gem_context_lock_engines(ctx),
  61                                     it) {
  62                         struct i915_request *rq, *target = NULL;
  63
  64                         if (!ce->timeline)
  65                                 continue;
  66
  67                         mutex_lock(&ce->timeline->mutex);
  68                         list_for_each_entry_reverse(rq,
  69                                                     &ce->timeline->requests,
  70                                                     link) {
  71                                 if (i915_request_completed(rq))
  72                                         break;
  73
  74                                 if (time_after(rq->emitted_jiffies,
  75                                                recent_enough))
  76                                         continue;
  77
  78                                 target = i915_request_get(rq);
  79                                 break;
  80                         }
  81                         mutex_unlock(&ce->timeline->mutex);
  82                         if (!target)
  83                                 continue;
  84
  85                         ret = i915_request_wait(target,
  86                                                 I915_WAIT_INTERRUPTIBLE,
  87                                                 MAX_SCHEDULE_TIMEOUT);
  88                         i915_request_put(target);
  89                         if (ret < 0)
  90                                 break;
  91                 }
  92                 i915_gem_context_unlock_engines(ctx);
  93                 i915_gem_context_put(ctx);
  94
  95                 rcu_read_lock();
  96         }
  97         rcu_read_unlock();
  98
  99         return ret < 0 ? ret : 0;
 100 }