1 /* 2 * Copyright (C) 2013 Christoph Bumiller 3 * Copyright (C) 2015 Samuel Pitoiset 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be included in 13 * all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 21 * OTHER DEALINGS IN THE SOFTWARE. 22 */ 23 24 /** 25 * Performance monitoring counters interface to gallium. 26 */ 27 28 #include "st_debug.h" 29 #include "st_context.h" 30 #include "st_cb_bitmap.h" 31 #include "st_cb_perfmon.h" 32 33 #include "util/bitset.h" 34 35 #include "pipe/p_context.h" 36 #include "pipe/p_screen.h" 37 #include "util/u_memory.h" 38 39 static bool 40 init_perf_monitor(struct gl_context *ctx, struct gl_perf_monitor_object *m) 41 { 42 struct st_context *st = st_context(ctx); 43 struct st_perf_monitor_object *stm = st_perf_monitor_object(m); 44 struct pipe_context *pipe = st->pipe; 45 unsigned *batch = NULL; 46 unsigned num_active_counters = 0; 47 unsigned max_batch_counters = 0; 48 unsigned num_batch_counters = 0; 49 int gid, cid; 50 51 st_flush_bitmap_cache(st); 52 53 /* Determine the number of active counters. */ 54 for (gid = 0; gid < ctx->PerfMonitor.NumGroups; gid++) { 55 const struct gl_perf_monitor_group *g = &ctx->PerfMonitor.Groups[gid]; 56 const struct st_perf_monitor_group *stg = &st->perfmon[gid]; 57 58 if (m->ActiveGroups[gid] > g->MaxActiveCounters) { 59 /* Maximum number of counters reached. Cannot start the session. */ 60 if (ST_DEBUG & DEBUG_MESA) { 61 debug_printf("Maximum number of counters reached. " 62 "Cannot start the session!\n"); 63 } 64 return false; 65 } 66 67 num_active_counters += m->ActiveGroups[gid]; 68 if (stg->has_batch) 69 max_batch_counters += m->ActiveGroups[gid]; 70 } 71 72 if (!num_active_counters) 73 return true; 74 75 stm->active_counters = CALLOC(num_active_counters, 76 sizeof(*stm->active_counters)); 77 if (!stm->active_counters) 78 return false; 79 80 if (max_batch_counters) { 81 batch = CALLOC(max_batch_counters, sizeof(*batch)); 82 if (!batch) 83 return false; 84 } 85 86 /* Create a query for each active counter. */ 87 for (gid = 0; gid < ctx->PerfMonitor.NumGroups; gid++) { 88 const struct gl_perf_monitor_group *g = &ctx->PerfMonitor.Groups[gid]; 89 const struct st_perf_monitor_group *stg = &st->perfmon[gid]; 90 BITSET_WORD tmp; 91 92 BITSET_FOREACH_SET(cid, tmp, m->ActiveCounters[gid], g->NumCounters) { 93 const struct st_perf_monitor_counter *stc = &stg->counters[cid]; 94 struct st_perf_counter_object *cntr = 95 &stm->active_counters[stm->num_active_counters]; 96 97 cntr->id = cid; 98 cntr->group_id = gid; 99 if (stc->flags & PIPE_DRIVER_QUERY_FLAG_BATCH) { 100 cntr->batch_index = num_batch_counters; 101 batch[num_batch_counters++] = stc->query_type; 102 } else { 103 cntr->query = pipe->create_query(pipe, stc->query_type, 0); 104 if (!cntr->query) 105 goto fail; 106 } 107 ++stm->num_active_counters; 108 } 109 } 110 111 /* Create the batch query. */ 112 if (num_batch_counters) { 113 stm->batch_query = pipe->create_batch_query(pipe, num_batch_counters, 114 batch); 115 stm->batch_result = CALLOC(num_batch_counters, sizeof(stm->batch_result->batch[0])); 116 if (!stm->batch_query || !stm->batch_result) 117 goto fail; 118 } 119 120 FREE(batch); 121 return true; 122 123 fail: 124 FREE(batch); 125 return false; 126 } 127 128 static void 129 reset_perf_monitor(struct st_perf_monitor_object *stm, 130 struct pipe_context *pipe) 131 { 132 unsigned i; 133 134 for (i = 0; i < stm->num_active_counters; ++i) { 135 struct pipe_query *query = stm->active_counters[i].query; 136 if (query) 137 pipe->destroy_query(pipe, query); 138 } 139 FREE(stm->active_counters); 140 stm->active_counters = NULL; 141 stm->num_active_counters = 0; 142 143 if (stm->batch_query) { 144 pipe->destroy_query(pipe, stm->batch_query); 145 stm->batch_query = NULL; 146 } 147 FREE(stm->batch_result); 148 stm->batch_result = NULL; 149 } 150 151 static struct gl_perf_monitor_object * 152 st_NewPerfMonitor(struct gl_context *ctx) 153 { 154 struct st_perf_monitor_object *stq = ST_CALLOC_STRUCT(st_perf_monitor_object); 155 if (stq) 156 return &stq->base; 157 return NULL; 158 } 159 160 static void 161 st_DeletePerfMonitor(struct gl_context *ctx, struct gl_perf_monitor_object *m) 162 { 163 struct st_perf_monitor_object *stm = st_perf_monitor_object(m); 164 struct pipe_context *pipe = st_context(ctx)->pipe; 165 166 reset_perf_monitor(stm, pipe); 167 FREE(stm); 168 } 169 170 static GLboolean 171 st_BeginPerfMonitor(struct gl_context *ctx, struct gl_perf_monitor_object *m) 172 { 173 struct st_perf_monitor_object *stm = st_perf_monitor_object(m); 174 struct pipe_context *pipe = st_context(ctx)->pipe; 175 unsigned i; 176 177 if (!stm->num_active_counters) { 178 /* Create a query for each active counter before starting 179 * a new monitoring session. */ 180 if (!init_perf_monitor(ctx, m)) 181 goto fail; 182 } 183 184 /* Start the query for each active counter. */ 185 for (i = 0; i < stm->num_active_counters; ++i) { 186 struct pipe_query *query = stm->active_counters[i].query; 187 if (query && !pipe->begin_query(pipe, query)) 188 goto fail; 189 } 190 191 if (stm->batch_query && !pipe->begin_query(pipe, stm->batch_query)) 192 goto fail; 193 194 return true; 195 196 fail: 197 /* Failed to start the monitoring session. */ 198 reset_perf_monitor(stm, pipe); 199 return false; 200 } 201 202 static void 203 st_EndPerfMonitor(struct gl_context *ctx, struct gl_perf_monitor_object *m) 204 { 205 struct st_perf_monitor_object *stm = st_perf_monitor_object(m); 206 struct pipe_context *pipe = st_context(ctx)->pipe; 207 unsigned i; 208 209 /* Stop the query for each active counter. */ 210 for (i = 0; i < stm->num_active_counters; ++i) { 211 struct pipe_query *query = stm->active_counters[i].query; 212 if (query) 213 pipe->end_query(pipe, query); 214 } 215 216 if (stm->batch_query) 217 pipe->end_query(pipe, stm->batch_query); 218 } 219 220 static void 221 st_ResetPerfMonitor(struct gl_context *ctx, struct gl_perf_monitor_object *m) 222 { 223 struct st_perf_monitor_object *stm = st_perf_monitor_object(m); 224 struct pipe_context *pipe = st_context(ctx)->pipe; 225 226 if (!m->Ended) 227 st_EndPerfMonitor(ctx, m); 228 229 reset_perf_monitor(stm, pipe); 230 231 if (m->Active) 232 st_BeginPerfMonitor(ctx, m); 233 } 234 235 static GLboolean 236 st_IsPerfMonitorResultAvailable(struct gl_context *ctx, 237 struct gl_perf_monitor_object *m) 238 { 239 struct st_perf_monitor_object *stm = st_perf_monitor_object(m); 240 struct pipe_context *pipe = st_context(ctx)->pipe; 241 unsigned i; 242 243 if (!stm->num_active_counters) 244 return false; 245 246 /* The result of a monitoring session is only available if the query of 247 * each active counter is idle. */ 248 for (i = 0; i < stm->num_active_counters; ++i) { 249 struct pipe_query *query = stm->active_counters[i].query; 250 union pipe_query_result result; 251 if (query && !pipe->get_query_result(pipe, query, FALSE, &result)) { 252 /* The query is busy. */ 253 return false; 254 } 255 } 256 257 if (stm->batch_query && 258 !pipe->get_query_result(pipe, stm->batch_query, FALSE, stm->batch_result)) 259 return false; 260 261 return true; 262 } 263 264 static void 265 st_GetPerfMonitorResult(struct gl_context *ctx, 266 struct gl_perf_monitor_object *m, 267 GLsizei dataSize, 268 GLuint *data, 269 GLint *bytesWritten) 270 { 271 struct st_perf_monitor_object *stm = st_perf_monitor_object(m); 272 struct pipe_context *pipe = st_context(ctx)->pipe; 273 unsigned i; 274 275 /* Copy data to the supplied array (data). 276 * 277 * The output data format is: <group ID, counter ID, value> for each 278 * active counter. The API allows counters to appear in any order. 279 */ 280 GLsizei offset = 0; 281 bool have_batch_query = false; 282 283 if (stm->batch_query) 284 have_batch_query = pipe->get_query_result(pipe, stm->batch_query, TRUE, 285 stm->batch_result); 286 287 /* Read query results for each active counter. */ 288 for (i = 0; i < stm->num_active_counters; ++i) { 289 struct st_perf_counter_object *cntr = &stm->active_counters[i]; 290 union pipe_query_result result = { 0 }; 291 int gid, cid; 292 GLenum type; 293 294 cid = cntr->id; 295 gid = cntr->group_id; 296 type = ctx->PerfMonitor.Groups[gid].Counters[cid].Type; 297 298 if (cntr->query) { 299 if (!pipe->get_query_result(pipe, cntr->query, TRUE, &result)) 300 continue; 301 } else { 302 if (!have_batch_query) 303 continue; 304 result.batch[0] = stm->batch_result->batch[cntr->batch_index]; 305 } 306 307 data[offset++] = gid; 308 data[offset++] = cid; 309 switch (type) { 310 case GL_UNSIGNED_INT64_AMD: 311 *(uint64_t *)&data[offset] = result.u64; 312 offset += sizeof(uint64_t) / sizeof(GLuint); 313 break; 314 case GL_UNSIGNED_INT: 315 *(uint32_t *)&data[offset] = result.u32; 316 offset += sizeof(uint32_t) / sizeof(GLuint); 317 break; 318 case GL_FLOAT: 319 case GL_PERCENTAGE_AMD: 320 *(GLfloat *)&data[offset] = result.f; 321 offset += sizeof(GLfloat) / sizeof(GLuint); 322 break; 323 } 324 } 325 326 if (bytesWritten) 327 *bytesWritten = offset * sizeof(GLuint); 328 } 329 330 331 bool 332 st_have_perfmon(struct st_context *st) 333 { 334 struct pipe_screen *screen = st->pipe->screen; 335 336 if (!screen->get_driver_query_info || !screen->get_driver_query_group_info) 337 return false; 338 339 return screen->get_driver_query_group_info(screen, 0, NULL) != 0; 340 } 341 342 static void 343 st_InitPerfMonitorGroups(struct gl_context *ctx) 344 { 345 struct st_context *st = st_context(ctx); 346 struct gl_perf_monitor_state *perfmon = &st->ctx->PerfMonitor; 347 struct pipe_screen *screen = st->pipe->screen; 348 struct gl_perf_monitor_group *groups = NULL; 349 struct st_perf_monitor_group *stgroups = NULL; 350 int num_counters, num_groups; 351 int gid, cid; 352 353 /* Get the number of available queries. */ 354 num_counters = screen->get_driver_query_info(screen, 0, NULL); 355 356 /* Get the number of available groups. */ 357 num_groups = screen->get_driver_query_group_info(screen, 0, NULL); 358 groups = CALLOC(num_groups, sizeof(*groups)); 359 if (!groups) 360 return; 361 362 stgroups = CALLOC(num_groups, sizeof(*stgroups)); 363 if (!stgroups) 364 goto fail_only_groups; 365 366 for (gid = 0; gid < num_groups; gid++) { 367 struct gl_perf_monitor_group *g = &groups[perfmon->NumGroups]; 368 struct st_perf_monitor_group *stg = &stgroups[perfmon->NumGroups]; 369 struct pipe_driver_query_group_info group_info; 370 struct gl_perf_monitor_counter *counters = NULL; 371 struct st_perf_monitor_counter *stcounters = NULL; 372 373 if (!screen->get_driver_query_group_info(screen, gid, &group_info)) 374 continue; 375 376 g->Name = group_info.name; 377 g->MaxActiveCounters = group_info.max_active_queries; 378 379 if (group_info.num_queries) 380 counters = CALLOC(group_info.num_queries, sizeof(*counters)); 381 if (!counters) 382 goto fail; 383 g->Counters = counters; 384 385 stcounters = CALLOC(group_info.num_queries, sizeof(*stcounters)); 386 if (!stcounters) 387 goto fail; 388 stg->counters = stcounters; 389 390 for (cid = 0; cid < num_counters; cid++) { 391 struct gl_perf_monitor_counter *c = &counters[g->NumCounters]; 392 struct st_perf_monitor_counter *stc = &stcounters[g->NumCounters]; 393 struct pipe_driver_query_info info; 394 395 if (!screen->get_driver_query_info(screen, cid, &info)) 396 continue; 397 if (info.group_id != gid) 398 continue; 399 400 c->Name = info.name; 401 switch (info.type) { 402 case PIPE_DRIVER_QUERY_TYPE_UINT64: 403 case PIPE_DRIVER_QUERY_TYPE_BYTES: 404 case PIPE_DRIVER_QUERY_TYPE_MICROSECONDS: 405 case PIPE_DRIVER_QUERY_TYPE_HZ: 406 c->Minimum.u64 = 0; 407 c->Maximum.u64 = info.max_value.u64 ? info.max_value.u64 : -1; 408 c->Type = GL_UNSIGNED_INT64_AMD; 409 break; 410 case PIPE_DRIVER_QUERY_TYPE_UINT: 411 c->Minimum.u32 = 0; 412 c->Maximum.u32 = info.max_value.u32 ? info.max_value.u32 : -1; 413 c->Type = GL_UNSIGNED_INT; 414 break; 415 case PIPE_DRIVER_QUERY_TYPE_FLOAT: 416 c->Minimum.f = 0.0; 417 c->Maximum.f = info.max_value.f ? info.max_value.f : -1; 418 c->Type = GL_FLOAT; 419 break; 420 case PIPE_DRIVER_QUERY_TYPE_PERCENTAGE: 421 c->Minimum.f = 0.0f; 422 c->Maximum.f = 100.0f; 423 c->Type = GL_PERCENTAGE_AMD; 424 break; 425 default: 426 unreachable("Invalid driver query type!"); 427 } 428 429 stc->query_type = info.query_type; 430 stc->flags = info.flags; 431 if (stc->flags & PIPE_DRIVER_QUERY_FLAG_BATCH) 432 stg->has_batch = true; 433 434 g->NumCounters++; 435 } 436 perfmon->NumGroups++; 437 } 438 perfmon->Groups = groups; 439 st->perfmon = stgroups; 440 441 return; 442 443 fail: 444 for (gid = 0; gid < num_groups; gid++) { 445 FREE(stgroups[gid].counters); 446 FREE((void *)groups[gid].Counters); 447 } 448 FREE(stgroups); 449 fail_only_groups: 450 FREE(groups); 451 } 452 453 void 454 st_destroy_perfmon(struct st_context *st) 455 { 456 struct gl_perf_monitor_state *perfmon = &st->ctx->PerfMonitor; 457 int gid; 458 459 for (gid = 0; gid < perfmon->NumGroups; gid++) { 460 FREE(st->perfmon[gid].counters); 461 FREE((void *)perfmon->Groups[gid].Counters); 462 } 463 FREE(st->perfmon); 464 FREE((void *)perfmon->Groups); 465 } 466 467 void st_init_perfmon_functions(struct dd_function_table *functions) 468 { 469 functions->InitPerfMonitorGroups = st_InitPerfMonitorGroups; 470 functions->NewPerfMonitor = st_NewPerfMonitor; 471 functions->DeletePerfMonitor = st_DeletePerfMonitor; 472 functions->BeginPerfMonitor = st_BeginPerfMonitor; 473 functions->EndPerfMonitor = st_EndPerfMonitor; 474 functions->ResetPerfMonitor = st_ResetPerfMonitor; 475 functions->IsPerfMonitorResultAvailable = st_IsPerfMonitorResultAvailable; 476 functions->GetPerfMonitorResult = st_GetPerfMonitorResult; 477 } 478