Lines Matching refs:query
56 /* Everytime the gallium query needs
57 * another vulkan query, add a new start.
66 bool active; /* query is considered active by vk */
67 bool needs_reset; /* query is considered active by vk and cannot be destroyed */
68 bool dead; /* query should be destroyed when its fence finishes */
69 bool needs_update; /* query needs to update its qbos */
70 bool needs_rast_discard_workaround; /* query needs discard disabled */
77 struct zink_batch_usage *batch_uses; //batch that the query was started in
236 debug_printf("unknown query: %s\n",
238 unreachable("zink: unknown query type");
304 debug_printf("unknown query: %s\n",
306 unreachable("zink: unknown query type");
311 needs_stats_list(struct zink_query *query)
313 return is_emulated_primgen(query) ||
314 query->type == PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE ||
315 query->type == PIPE_QUERY_SO_OVERFLOW_PREDICATE;
319 is_time_query(struct zink_query *query)
321 return query->type == PIPE_QUERY_TIMESTAMP || query->type == PIPE_QUERY_TIME_ELAPSED;
325 is_so_overflow_query(struct zink_query *query)
327 return query->type == PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE || query->type == PIPE_QUERY_SO_OVERFLOW_PREDICATE;
331 is_bool_query(struct zink_query *query)
333 return is_so_overflow_query(query) ||
334 query->type == PIPE_QUERY_OCCLUSION_PREDICATE ||
335 query->type == PIPE_QUERY_OCCLUSION_PREDICATE_CONSERVATIVE ||
336 query->type == PIPE_QUERY_GPU_FINISHED;
340 qbo_append(struct pipe_screen *screen, struct zink_query *query)
342 if (query->curr_qbo && query->curr_qbo->list.next)
347 int num_buffers = get_num_queries(query);
353 NUM_QUERIES * get_num_results(query) * sizeof(uint64_t));
357 list_addtail(&qbo->list, &query->buffers);
368 destroy_query(struct zink_screen *screen, struct zink_query *query)
370 assert(zink_screen_usage_check_completion(screen, query->batch_uses));
373 util_dynarray_foreach(&query->starts, struct zink_query_start, start) {
383 util_dynarray_fini(&query->starts);
384 LIST_FOR_EACH_ENTRY_SAFE(qbo, next, &query->buffers, list) {
389 pipe_resource_reference((struct pipe_resource**)&query->predicate, NULL);
390 FREE(query);
415 /* try and find the active query for this */
447 struct zink_query *query = CALLOC_STRUCT(zink_query);
449 if (!query)
451 list_inithead(&query->buffers);
453 query->index = index;
454 query->type = query_type;
455 if (query->type == PIPE_QUERY_GPU_FINISHED)
456 return (struct pipe_query *)query;
457 query->vkqtype = convert_query_type(screen, query_type, &query->precise);
458 if (query->vkqtype == -1)
461 util_dynarray_init(&query->starts, NULL);
463 assert(!query->precise || query->vkqtype == VK_QUERY_TYPE_OCCLUSION);
466 if (query->vkqtype == VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT && index &&
468 query->vkqtype = VK_QUERY_TYPE_PIPELINE_STATISTICS;
471 if (query->vkqtype == VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT) {
472 query->needs_rast_discard_workaround = !screen->info.primgen_feats.primitivesGeneratedQueryWithRasterizerDiscard;
476 query->needs_rast_discard_workaround = true;
480 int num_pools = get_num_query_pools(query);
482 VkQueryType vkqtype = query->vkqtype;
483 /* if xfb is active, we need to use an xfb query, otherwise we need pipeline statistics */
488 query->pool[i] = find_or_allocate_qp(zink_context(pctx),
491 if (!query->pool[i])
495 if (!qbo_append(pctx->screen, query))
499 query->needs_reset = true;
500 if (query->type == PIPE_QUERY_TIMESTAMP) {
501 query->active = true;
503 reset_qbo(query);
505 return (struct pipe_query *)query;
507 destroy_query(screen, query);
516 struct zink_query *query = (struct zink_query *)q;
518 /* only destroy if this query isn't active on any batches,
521 if (query->batch_uses) {
522 p_atomic_set(&query->dead, true);
526 destroy_query(screen, query);
530 zink_prune_query(struct zink_screen *screen, struct zink_batch_state *bs, struct zink_query *query)
532 if (!zink_batch_usage_matches(query->batch_uses, bs))
534 query->batch_uses = NULL;
535 if (p_atomic_read(&query->dead))
536 destroy_query(screen, query);
540 check_query_results(struct zink_query *query, union pipe_query_result *result,
544 int result_size = get_num_results(query);
546 util_dynarray_foreach(&query->starts, struct zink_query_start, start) {
549 switch (query->type) {
561 if (query->type != PIPE_QUERY_TIME_ELAPSED || i)
569 if (query->vkqtype == VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT)
571 else if (start->have_xfb || query->index)
578 /* A query pool created with this type will capture 2 integers -
587 /* A query pool created with this type will capture 2 integers -
596 switch (query->index) {
607 debug_printf("unhandled query type: %s\n",
608 util_str_query_type(query->type, true));
609 unreachable("unexpected query type");
621 struct zink_query *query = (struct zink_query *)q;
626 if (query->base.flushed)
630 util_query_clear_result(result, query->type);
632 int num_starts = get_num_starts(query);
633 int result_size = get_num_results(query) * sizeof(uint64_t);
634 int num_maps = get_num_queries(query);
638 LIST_FOR_EACH_ENTRY(qbo, &query->buffers, list) {
640 bool is_timestamp = query->type == PIPE_QUERY_TIMESTAMP || query->type == PIPE_QUERY_TIMESTAMP_DISJOINT;
653 if (query->type == PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE) {
655 check_query_results(query, result, num_starts, results[i], NULL);
658 check_query_results(query, result, num_starts, results[0], results[1]);
664 if (query->type == PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE && result->b)
668 if (is_time_query(query))
684 struct zink_query *query = (struct zink_query*)pquery;
687 if (query->needs_update)
688 update_qbo(ctx, query);
692 debug_printf("zink: getting query result failed\n");
703 if (is_bool_query(query))
710 if (is_bool_query(query))
719 copy_pool_results_to_buffer(struct zink_context *ctx, struct zink_query *query, VkQueryPool pool,
725 unsigned base_result_size = get_num_results(query) * type_size;
730 /* if it's a single query that doesn't need special handling, we can copy it and be done */
741 copy_results_to_buffer(struct zink_context *ctx, struct zink_query *query, struct zink_resource *res, unsigned offset, int num_results, VkQueryResultFlags flags)
743 struct zink_query_start *start = util_dynarray_top_ptr(&query->starts, struct zink_query_start);
744 copy_pool_results_to_buffer(ctx, query, start->vkq[0]->pool->query_pool, start->vkq[0]->query_id, res, offset, num_results, flags);
799 each such query command to all query commands previously submitted to the same queue. There
881 struct zink_query *query = (struct zink_query *)q;
886 reset_qbo(query);
888 util_dynarray_clear(&query->starts);
890 query->last_start_idx = get_num_starts(query);
892 /* A query must either begin and end inside the same subpass of a render pass
901 begin_query(ctx, batch, query);
971 struct zink_query *query = (struct zink_query *)q;
974 if (query->type == PIPE_QUERY_GPU_FINISHED) {
975 pctx->flush(pctx, &query->fence, PIPE_FLUSH_DEFERRED);
983 if (needs_stats_list(query))
984 list_delinit(&query->stats_list);
985 if (is_time_query(query)) {
986 update_query_id(ctx, query);
987 if (query->needs_reset)
988 reset_qbos(ctx, query);
989 reset_query_range(ctx, query);
990 struct zink_query_start *start = util_dynarray_top_ptr(&query->starts, struct zink_query_start);
993 zink_batch_usage_set(&query->batch_uses, batch->state);
994 _mesa_set_add(batch->state->active_queries, query);
995 check_update(ctx, query);
996 } else if (query->active)
997 end_query(ctx, batch, query);
1008 struct zink_query *query = (void*)q;
1011 if (query->type == PIPE_QUERY_GPU_FINISHED) {
1014 result->b = screen->fence_finish(screen, query->base.flushed ? NULL : pctx,
1015 query->fence, wait ? PIPE_TIMEOUT_INFINITE : 0);
1019 if (query->needs_update)
1020 update_qbo(ctx, query);
1022 if (zink_batch_usage_is_unflushed(query->batch_uses)) {
1033 suspend_query(struct zink_context *ctx, struct zink_query *query)
1035 /* if a query isn't active here then we don't need to reactivate it on the next batch */
1036 if (query->active && !is_time_query(query))
1037 end_query(ctx, &ctx->batch, query);
1038 if (query->needs_update)
1039 update_qbo(ctx, query);
1046 struct zink_query *query = (void*)entry->key;
1047 if (query->active && !is_time_query(query))
1051 list_addtail(&query->active_list, &ctx->suspended_queries);
1052 suspend_query(ctx, query);
1059 struct zink_query *query, *next;
1060 LIST_FOR_EACH_ENTRY_SAFE(query, next, &ctx->suspended_queries, active_list) {
1061 begin_query(ctx, batch, query);
1062 list_delinit(&query->active_list);
1069 struct zink_query *query;
1074 LIST_FOR_EACH_ENTRY(query, &ctx->primitives_generated_queries, stats_list) {
1075 struct zink_query_start *last_start = util_dynarray_top_ptr(&query->starts, struct zink_query_start);
1076 assert(query->active);
1077 if (query->has_draws) {
1086 query = ctx->vertices_query;
1087 struct zink_query_start *last_start = util_dynarray_top_ptr(&query->starts, struct zink_query_start);
1088 assert(query->active);
1098 LIST_FOR_EACH_ENTRY(query, &ctx->primitives_generated_queries, stats_list) {
1099 struct zink_query_start *last_start = util_dynarray_top_ptr(&query->starts, struct zink_query_start);
1102 query->has_draws = true;
1105 query = ctx->vertices_query;
1106 struct zink_query_start *last_start = util_dynarray_top_ptr(&query->starts, struct zink_query_start);
1108 query->has_draws = true;
1136 begin_info.buffer = ctx->render_condition.query->predicate->obj->buffer;
1138 ctx->render_condition.query->predicate->obj->unordered_read = false;
1140 zink_batch_reference_resource_rw(batch, ctx->render_condition.query->predicate, false);
1160 assert(ctx->render_condition.query);
1163 zink_get_query_result(&ctx->base, (struct pipe_query*)ctx->render_condition.query, true, &result);
1164 return is_bool_query(ctx->render_condition.query) ?
1176 struct zink_query *query = (struct zink_query *)pquery;
1180 if (query == NULL) {
1186 ctx->render_condition.query = NULL;
1190 if (!query->predicate) {
1198 query->predicate = zink_resource(pres);
1200 if (query->predicate_dirty) {
1201 struct zink_resource *res = query->predicate;
1207 int num_results = get_num_starts(query);
1208 if (!is_emulated_primgen(query) &&
1209 !is_so_overflow_query(query)) {
1210 copy_results_to_buffer(ctx, query, res, 0, num_results, flags);
1216 query->predicate_dirty = false;
1220 ctx->render_condition.query = query;
1236 struct zink_query *query = (struct zink_query*)pquery;
1240 unsigned num_queries = (get_num_starts(query) - query->last_start_idx);
1241 struct zink_query_start *start = util_dynarray_top_ptr(&query->starts, struct zink_query_start);
1253 VkQueryResultFlags flag = is_time_query(query) ? 0 : VK_QUERY_RESULT_PARTIAL_BIT;
1254 unsigned src_offset = result_size * get_num_results(query);
1255 if (zink_batch_usage_check_completion(ctx, query->batch_uses)) {
1267 copy_results_to_buffer(ctx, query, zink_resource(staging), 0, 1, size_flags | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT | flag);
1268 zink_copy_buffer(ctx, res, zink_resource(staging), offset, result_size * get_num_results(query), result_size);
1275 each such query command to all query commands previously submitted to the same queue. There
1283 if (!is_time_query(query) && !is_bool_query(query)) {
1284 if (num_queries == 1 && !is_emulated_primgen(query) &&
1285 query->type != PIPE_QUERY_PRIMITIVES_EMITTED &&
1286 !is_bool_query(query)) {
1288 if (query->needs_update)
1289 update_qbo(ctx, query);
1291 zink_copy_buffer(ctx, res, zink_resource(query->curr_qbo->buffers[0]), offset,
1292 get_buffer_offset(query),
1296 copy_results_to_buffer(ctx, query, res, offset, 1, size_flags);