1/*
2 * SPDX-License-Identifier: MIT
3 *
4 * Copyright © 2018 Intel Corporation
5 */
6
7#ifndef _I915_SCHEDULER_TYPES_H_
8#define _I915_SCHEDULER_TYPES_H_
9
10#include <linux/list.h>
11
12#include "gt/intel_engine_types.h"
13#include "i915_priolist_types.h"
14
15struct drm_i915_private;
16struct i915_request;
17struct intel_engine_cs;
18
19struct i915_sched_attr {
20 /**
21 * @priority: execution and service priority
22 *
23 * All clients are equal, but some are more equal than others!
24 *
25 * Requests from a context with a greater (more positive) value of
26 * @priority will be executed before those with a lower @priority
27 * value, forming a simple QoS.
28 *
29 * The &drm_i915_private.kernel_context is assigned the lowest priority.
30 */
31 int priority;
32};
33
34/*
35 * "People assume that time is a strict progression of cause to effect, but
36 * actually, from a nonlinear, non-subjective viewpoint, it's more like a big
37 * ball of wibbly-wobbly, timey-wimey ... stuff." -The Doctor, 2015
38 *
39 * Requests exist in a complex web of interdependencies. Each request
40 * has to wait for some other request to complete before it is ready to be run
41 * (e.g. we have to wait until the pixels have been rendering into a texture
42 * before we can copy from it). We track the readiness of a request in terms
43 * of fences, but we also need to keep the dependency tree for the lifetime
44 * of the request (beyond the life of an individual fence). We use the tree
45 * at various points to reorder the requests whilst keeping the requests
46 * in order with respect to their various dependencies.
47 *
48 * There is no active component to the "scheduler". As we know the dependency
49 * DAG of each request, we are able to insert it into a sorted queue when it
50 * is ready, and are able to reorder its portion of the graph to accommodate
51 * dynamic priority changes.
52 *
53 * Ok, there is now one active element to the "scheduler" in the backends.
54 * We let a new context run for a small amount of time before re-evaluating
55 * the run order. As we re-evaluate, we maintain the strict ordering of
56 * dependencies, but attempt to rotate the active contexts (the current context
57 * is put to the back of its priority queue, then reshuffling its dependents).
58 * This provides minimal timeslicing and prevents a userspace hog (e.g.
59 * something waiting on a user semaphore [VkEvent]) from denying service to
60 * others.
61 */
62struct i915_sched_node {
63 struct list_head signalers_list; /* those before us, we depend upon */
64 struct list_head waiters_list; /* those after us, they depend upon us */
65 struct list_head link;
66 struct i915_sched_attr attr;
67 unsigned int flags;
68#define I915_SCHED_HAS_EXTERNAL_CHAIN BIT(0)
69 intel_engine_mask_t semaphores;
70};
71
72struct i915_dependency {
73 struct i915_sched_node *signaler;
74 struct i915_sched_node *waiter;
75 struct list_head signal_link;
76 struct list_head wait_link;
77 struct list_head dfs_link;
78 unsigned long flags;
79#define I915_DEPENDENCY_ALLOC BIT(0)
80#define I915_DEPENDENCY_EXTERNAL BIT(1)
81#define I915_DEPENDENCY_WEAK BIT(2)
82};
83
84#define for_each_waiter(p__, rq__) \
85 list_for_each_entry_lockless(p__, \
86 &(rq__)->sched.waiters_list, \
87 wait_link)
88
89#define for_each_signaler(p__, rq__) \
90 list_for_each_entry_rcu(p__, \
91 &(rq__)->sched.signalers_list, \
92 signal_link)
93
94/**
95 * struct i915_sched_engine - scheduler engine
96 *
97 * A schedule engine represents a submission queue with different priority
98 * bands. It contains all the common state (relative to the backend) to queue,
99 * track, and submit a request.
100 *
101 * This object at the moment is quite i915 specific but will transition into a
102 * container for the drm_gpu_scheduler plus a few other variables once the i915
103 * is integrated with the DRM scheduler.
104 */
105struct i915_sched_engine {
106 /**
107 * @ref: reference count of schedule engine object
108 */
109 struct kref ref;
110
111 /**
112 * @lock: protects requests in priority lists, requests, hold and
113 * tasklet while running
114 */
115 spinlock_t lock;
116
117 /**
118 * @requests: list of requests inflight on this schedule engine
119 */
120 struct list_head requests;
121
122 /**
123 * @hold: list of ready requests, but on hold
124 */
125 struct list_head hold;
126
127 /**
128 * @tasklet: softirq tasklet for submission
129 */
130 struct tasklet_struct tasklet;
131
132 /**
133 * @default_priolist: priority list for I915_PRIORITY_NORMAL
134 */
135 struct i915_priolist default_priolist;
136
137 /**
138 * @queue_priority_hint: Highest pending priority.
139 *
140 * When we add requests into the queue, or adjust the priority of
141 * executing requests, we compute the maximum priority of those
142 * pending requests. We can then use this value to determine if
143 * we need to preempt the executing requests to service the queue.
144 * However, since the we may have recorded the priority of an inflight
145 * request we wanted to preempt but since completed, at the time of
146 * dequeuing the priority hint may no longer may match the highest
147 * available request priority.
148 */
149 int queue_priority_hint;
150
151 /**
152 * @queue: queue of requests, in priority lists
153 */
154 struct rb_root_cached queue;
155
156 /**
157 * @no_priolist: priority lists disabled
158 */
159 bool no_priolist;
160
161 /**
162 * @private_data: private data of the submission backend
163 */
164 void *private_data;
165
166 /**
167 * @destroy: destroy schedule engine / cleanup in backend
168 */
169 void (*destroy)(struct kref *kref);
170
171 /**
172 * @disabled: check if backend has disabled submission
173 */
174 bool (*disabled)(struct i915_sched_engine *sched_engine);
175
176 /**
177 * @kick_backend: kick backend after a request's priority has changed
178 */
179 void (*kick_backend)(const struct i915_request *rq,
180 int prio);
181
182 /**
183 * @bump_inflight_request_prio: update priority of an inflight request
184 */
185 void (*bump_inflight_request_prio)(struct i915_request *rq,
186 int prio);
187
188 /**
189 * @retire_inflight_request_prio: indicate request is retired to
190 * priority tracking
191 */
192 void (*retire_inflight_request_prio)(struct i915_request *rq);
193
194 /**
195 * @schedule: adjust priority of request
196 *
197 * Call when the priority on a request has changed and it and its
198 * dependencies may need rescheduling. Note the request itself may
199 * not be ready to run!
200 */
201 void (*schedule)(struct i915_request *request,
202 const struct i915_sched_attr *attr);
203};
204
205#endif /* _I915_SCHEDULER_TYPES_H_ */
206

source code of linux/drivers/gpu/drm/i915/i915_scheduler_types.h