1 /*
2 * Copyright © 2019 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 * DEALINGS IN THE SOFTWARE.
21 */
22
23 #include "iris_monitor.h"
24
25 #include <xf86drm.h>
26
27 #include "iris_screen.h"
28 #include "iris_context.h"
29 #include "iris_perf.h"
30
31 struct iris_monitor_object {
32 int num_active_counters;
33 int *active_counters;
34
35 size_t result_size;
36 unsigned char *result_buffer;
37
38 struct intel_perf_query_object *query;
39 };
40
41 int
iris_get_monitor_info(struct pipe_screen * pscreen,unsigned index,struct pipe_driver_query_info * info)42 iris_get_monitor_info(struct pipe_screen *pscreen, unsigned index,
43 struct pipe_driver_query_info *info)
44 {
45 const struct iris_screen *screen = (struct iris_screen *)pscreen;
46 const struct intel_perf_config *perf_cfg = screen->perf_cfg;
47 assert(perf_cfg);
48 if (!perf_cfg)
49 return 0;
50
51 if (!info) {
52 /* return the number of metrics */
53 return perf_cfg->n_counters;
54 }
55
56 struct intel_perf_query_counter_info *counter_info = &perf_cfg->counter_infos[index];
57 struct intel_perf_query_counter *counter = counter_info->counter;
58
59 info->group_id = counter_info->location.group_idx;
60 info->name = counter->name;
61 info->query_type = PIPE_QUERY_DRIVER_SPECIFIC + index;
62
63 if (counter->type == INTEL_PERF_COUNTER_TYPE_THROUGHPUT)
64 info->result_type = PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE;
65 else
66 info->result_type = PIPE_DRIVER_QUERY_RESULT_TYPE_CUMULATIVE;
67 switch (counter->data_type) {
68 case INTEL_PERF_COUNTER_DATA_TYPE_BOOL32:
69 case INTEL_PERF_COUNTER_DATA_TYPE_UINT32:
70 info->type = PIPE_DRIVER_QUERY_TYPE_UINT;
71 assert(counter->raw_max <= UINT32_MAX);
72 info->max_value.u32 = (uint32_t)counter->raw_max;
73 break;
74 case INTEL_PERF_COUNTER_DATA_TYPE_UINT64:
75 info->type = PIPE_DRIVER_QUERY_TYPE_UINT64;
76 info->max_value.u64 = counter->raw_max;
77 break;
78 case INTEL_PERF_COUNTER_DATA_TYPE_FLOAT:
79 case INTEL_PERF_COUNTER_DATA_TYPE_DOUBLE:
80 info->type = PIPE_DRIVER_QUERY_TYPE_FLOAT;
81 info->max_value.f = counter->raw_max;
82 break;
83 default:
84 assert(false);
85 break;
86 }
87
88 /* indicates that this is an OA query, not a pipeline statistics query */
89 info->flags = PIPE_DRIVER_QUERY_FLAG_BATCH;
90 return 1;
91 }
92
93 static bool
iris_monitor_init_metrics(struct iris_screen * screen)94 iris_monitor_init_metrics(struct iris_screen *screen)
95 {
96 struct intel_perf_config *perf_cfg = intel_perf_new(screen);
97 if (unlikely(!perf_cfg))
98 return false;
99
100 screen->perf_cfg = perf_cfg;
101
102 iris_perf_init_vtbl(perf_cfg);
103
104 intel_perf_init_metrics(perf_cfg, &screen->devinfo, screen->fd,
105 true /* pipeline stats*/,
106 true /* register snapshots */);
107
108 return perf_cfg->n_counters > 0;
109 }
110
111 int
iris_get_monitor_group_info(struct pipe_screen * pscreen,unsigned group_index,struct pipe_driver_query_group_info * info)112 iris_get_monitor_group_info(struct pipe_screen *pscreen,
113 unsigned group_index,
114 struct pipe_driver_query_group_info *info)
115 {
116 struct iris_screen *screen = (struct iris_screen *)pscreen;
117 if (!screen->perf_cfg) {
118 if (!iris_monitor_init_metrics(screen))
119 return 0;
120 }
121
122 const struct intel_perf_config *perf_cfg = screen->perf_cfg;
123
124 if (!info) {
125 /* return the count that can be queried */
126 return perf_cfg->n_queries;
127 }
128
129 if (group_index >= perf_cfg->n_queries) {
130 /* out of range */
131 return 0;
132 }
133
134 struct intel_perf_query_info *query = &perf_cfg->queries[group_index];
135
136 info->name = query->name;
137 info->max_active_queries = query->n_counters;
138 info->num_queries = query->n_counters;
139
140 return 1;
141 }
142
143 static void
iris_init_monitor_ctx(struct iris_context * ice)144 iris_init_monitor_ctx(struct iris_context *ice)
145 {
146 struct iris_screen *screen = (struct iris_screen *) ice->ctx.screen;
147
148 ice->perf_ctx = intel_perf_new_context(ice);
149 if (unlikely(!ice->perf_ctx))
150 return;
151
152 struct intel_perf_context *perf_ctx = ice->perf_ctx;
153 struct intel_perf_config *perf_cfg = screen->perf_cfg;
154 intel_perf_init_context(perf_ctx,
155 perf_cfg,
156 ice,
157 ice,
158 screen->bufmgr,
159 &screen->devinfo,
160 ice->batches[IRIS_BATCH_RENDER].hw_ctx_id,
161 screen->fd);
162 }
163
164 /* entry point for GenPerfMonitorsAMD */
165 struct iris_monitor_object *
iris_create_monitor_object(struct iris_context * ice,unsigned num_queries,unsigned * query_types)166 iris_create_monitor_object(struct iris_context *ice,
167 unsigned num_queries,
168 unsigned *query_types)
169 {
170 struct iris_screen *screen = (struct iris_screen *) ice->ctx.screen;
171 struct intel_perf_config *perf_cfg = screen->perf_cfg;
172 struct intel_perf_query_object *query_obj = NULL;
173
174 /* initialize perf context if this has not already been done. This
175 * function is the first entry point that carries the gl context.
176 */
177 if (ice->perf_ctx == NULL) {
178 iris_init_monitor_ctx(ice);
179 }
180 struct intel_perf_context *perf_ctx = ice->perf_ctx;
181
182 assert(num_queries > 0);
183 int query_index = query_types[0] - PIPE_QUERY_DRIVER_SPECIFIC;
184 assert(query_index <= perf_cfg->n_counters);
185 const int group = perf_cfg->counter_infos[query_index].location.group_idx;
186
187 struct iris_monitor_object *monitor =
188 calloc(1, sizeof(struct iris_monitor_object));
189 if (unlikely(!monitor))
190 goto allocation_failure;
191
192 monitor->num_active_counters = num_queries;
193 monitor->active_counters = calloc(num_queries, sizeof(int));
194 if (unlikely(!monitor->active_counters))
195 goto allocation_failure;
196
197 for (int i = 0; i < num_queries; ++i) {
198 unsigned current_query = query_types[i];
199 unsigned current_query_index = current_query - PIPE_QUERY_DRIVER_SPECIFIC;
200
201 /* all queries must be in the same group */
202 assert(current_query_index <= perf_cfg->n_counters);
203 assert(perf_cfg->counter_infos[current_query_index].location.group_idx == group);
204 monitor->active_counters[i] =
205 perf_cfg->counter_infos[current_query_index].location.counter_idx;
206 }
207
208 /* create the intel_perf_query */
209 query_obj = intel_perf_new_query(perf_ctx, group);
210 if (unlikely(!query_obj))
211 goto allocation_failure;
212
213 monitor->query = query_obj;
214 monitor->result_size = perf_cfg->queries[group].data_size;
215 monitor->result_buffer = calloc(1, monitor->result_size);
216 if (unlikely(!monitor->result_buffer))
217 goto allocation_failure;
218
219 return monitor;
220
221 allocation_failure:
222 if (monitor) {
223 free(monitor->active_counters);
224 free(monitor->result_buffer);
225 }
226 free(query_obj);
227 free(monitor);
228 return NULL;
229 }
230
231 void
iris_destroy_monitor_object(struct pipe_context * ctx,struct iris_monitor_object * monitor)232 iris_destroy_monitor_object(struct pipe_context *ctx,
233 struct iris_monitor_object *monitor)
234 {
235 struct iris_context *ice = (struct iris_context *)ctx;
236
237 intel_perf_delete_query(ice->perf_ctx, monitor->query);
238 free(monitor->result_buffer);
239 monitor->result_buffer = NULL;
240 free(monitor->active_counters);
241 monitor->active_counters = NULL;
242 free(monitor);
243 }
244
245 bool
iris_begin_monitor(struct pipe_context * ctx,struct iris_monitor_object * monitor)246 iris_begin_monitor(struct pipe_context *ctx,
247 struct iris_monitor_object *monitor)
248 {
249 struct iris_context *ice = (void *) ctx;
250 struct intel_perf_context *perf_ctx = ice->perf_ctx;
251
252 return intel_perf_begin_query(perf_ctx, monitor->query);
253 }
254
255 bool
iris_end_monitor(struct pipe_context * ctx,struct iris_monitor_object * monitor)256 iris_end_monitor(struct pipe_context *ctx,
257 struct iris_monitor_object *monitor)
258 {
259 struct iris_context *ice = (void *) ctx;
260 struct intel_perf_context *perf_ctx = ice->perf_ctx;
261
262 intel_perf_end_query(perf_ctx, monitor->query);
263 return true;
264 }
265
266 bool
iris_get_monitor_result(struct pipe_context * ctx,struct iris_monitor_object * monitor,bool wait,union pipe_numeric_type_union * result)267 iris_get_monitor_result(struct pipe_context *ctx,
268 struct iris_monitor_object *monitor,
269 bool wait,
270 union pipe_numeric_type_union *result)
271 {
272 struct iris_context *ice = (void *) ctx;
273 struct intel_perf_context *perf_ctx = ice->perf_ctx;
274 struct iris_batch *batch = &ice->batches[IRIS_BATCH_RENDER];
275
276 bool monitor_ready =
277 intel_perf_is_query_ready(perf_ctx, monitor->query, batch);
278
279 if (!monitor_ready) {
280 if (!wait)
281 return false;
282 intel_perf_wait_query(perf_ctx, monitor->query, batch);
283 }
284
285 assert(intel_perf_is_query_ready(perf_ctx, monitor->query, batch));
286
287 unsigned bytes_written;
288 intel_perf_get_query_data(perf_ctx, monitor->query, batch,
289 monitor->result_size,
290 (unsigned*) monitor->result_buffer,
291 &bytes_written);
292 if (bytes_written != monitor->result_size)
293 return false;
294
295 /* copy metrics into the batch result */
296 for (int i = 0; i < monitor->num_active_counters; ++i) {
297 int current_counter = monitor->active_counters[i];
298 const struct intel_perf_query_info *info =
299 intel_perf_query_info(monitor->query);
300 const struct intel_perf_query_counter *counter =
301 &info->counters[current_counter];
302 assert(intel_perf_query_counter_get_size(counter));
303 switch (counter->data_type) {
304 case INTEL_PERF_COUNTER_DATA_TYPE_UINT64:
305 result[i].u64 = *(uint64_t*)(monitor->result_buffer + counter->offset);
306 break;
307 case INTEL_PERF_COUNTER_DATA_TYPE_FLOAT:
308 result[i].f = *(float*)(monitor->result_buffer + counter->offset);
309 break;
310 case INTEL_PERF_COUNTER_DATA_TYPE_UINT32:
311 case INTEL_PERF_COUNTER_DATA_TYPE_BOOL32:
312 result[i].u64 = *(uint32_t*)(monitor->result_buffer + counter->offset);
313 break;
314 case INTEL_PERF_COUNTER_DATA_TYPE_DOUBLE: {
315 double v = *(double*)(monitor->result_buffer + counter->offset);
316 result[i].f = v;
317 break;
318 }
319 default:
320 unreachable("unexpected counter data type");
321 }
322 }
323 return true;
324 }
325