X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_cb_queryobj.c;h=50a776df74566a8bcc2433fb167e5cfd57a7c961;hb=493fdcf44647ee471e934de3e63d193c6a3b6ff0;hp=1aaa322f6150b61427a7578e3ff8524b1032d3d6;hpb=43e4b3e311df3bede930229380a7aa389ac7019a;p=mesa.git diff --git a/src/mesa/state_tracker/st_cb_queryobj.c b/src/mesa/state_tracker/st_cb_queryobj.c index 1aaa322f615..50a776df745 100644 --- a/src/mesa/state_tracker/st_cb_queryobj.c +++ b/src/mesa/state_tracker/st_cb_queryobj.c @@ -1,8 +1,8 @@ /************************************************************************** - * + * * Copyright 2007 VMware, Inc. * All Rights Reserved. - * + * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including @@ -10,11 +10,11 @@ * distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: - * + * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. @@ -22,7 +22,7 @@ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - * + * **************************************************************************/ @@ -33,15 +33,19 @@ */ -#include "main/imports.h" +#include "util/compiler.h" #include "main/context.h" +#include "main/queryobj.h" #include "pipe/p_context.h" #include "pipe/p_defines.h" #include "pipe/p_screen.h" +#include "util/u_inlines.h" #include "st_context.h" #include "st_cb_queryobj.h" #include "st_cb_bitmap.h" +#include "st_cb_bufferobjects.h" +#include "st_util.h" static struct gl_query_object * @@ -59,13 +63,9 @@ st_NewQueryObject(struct gl_context *ctx, GLuint id) } - static void -st_DeleteQuery(struct gl_context *ctx, struct gl_query_object *q) +free_queries(struct pipe_context *pipe, struct st_query_object *stq) { - struct pipe_context *pipe = st_context(ctx)->pipe; - struct st_query_object *stq = st_query_object(q); - if (stq->pq) { pipe->destroy_query(pipe, stq->pq); stq->pq = NULL; @@ -75,10 +75,59 @@ st_DeleteQuery(struct gl_context *ctx, struct gl_query_object *q) pipe->destroy_query(pipe, stq->pq_begin); stq->pq_begin = NULL; } +} + + +static void +st_DeleteQuery(struct gl_context *ctx, struct gl_query_object *q) +{ + struct pipe_context *pipe = st_context(ctx)->pipe; + struct st_query_object *stq = st_query_object(q); - free(stq); + free_queries(pipe, stq); + + _mesa_delete_query(ctx, q); } +static int +target_to_index(const struct st_context *st, const struct gl_query_object *q) +{ + if (q->Target == GL_PRIMITIVES_GENERATED || + q->Target == GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN || + q->Target == GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB) + return q->Stream; + + if (st->has_single_pipe_stat) { + switch (q->Target) { + case GL_VERTICES_SUBMITTED_ARB: + return PIPE_STAT_QUERY_IA_VERTICES; + case GL_PRIMITIVES_SUBMITTED_ARB: + return PIPE_STAT_QUERY_IA_PRIMITIVES; + case GL_VERTEX_SHADER_INVOCATIONS_ARB: + return PIPE_STAT_QUERY_VS_INVOCATIONS; + case GL_GEOMETRY_SHADER_INVOCATIONS: + return PIPE_STAT_QUERY_GS_INVOCATIONS; + case GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB: + return PIPE_STAT_QUERY_GS_PRIMITIVES; + case GL_CLIPPING_INPUT_PRIMITIVES_ARB: + return PIPE_STAT_QUERY_C_INVOCATIONS; + case GL_CLIPPING_OUTPUT_PRIMITIVES_ARB: + return PIPE_STAT_QUERY_C_PRIMITIVES; + case GL_FRAGMENT_SHADER_INVOCATIONS_ARB: + return PIPE_STAT_QUERY_PS_INVOCATIONS; + case GL_TESS_CONTROL_SHADER_PATCHES_ARB: + return PIPE_STAT_QUERY_HS_INVOCATIONS; + case GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB: + return PIPE_STAT_QUERY_DS_INVOCATIONS; + case GL_COMPUTE_SHADER_INVOCATIONS_ARB: + return PIPE_STAT_QUERY_CS_INVOCATIONS; + default: + break; + } + } + + return 0; +} static void st_BeginQuery(struct gl_context *ctx, struct gl_query_object *q) @@ -87,14 +136,18 @@ st_BeginQuery(struct gl_context *ctx, struct gl_query_object *q) struct pipe_context *pipe = st->pipe; struct st_query_object *stq = st_query_object(q); unsigned type; + bool ret = false; st_flush_bitmap_cache(st_context(ctx)); /* convert GL query type to Gallium query type */ switch (q->Target) { case GL_ANY_SAMPLES_PASSED: + type = PIPE_QUERY_OCCLUSION_PREDICATE; + break; case GL_ANY_SAMPLES_PASSED_CONSERVATIVE: - /* fall-through */ + type = PIPE_QUERY_OCCLUSION_PREDICATE_CONSERVATIVE; + break; case GL_SAMPLES_PASSED_ARB: type = PIPE_QUERY_OCCLUSION_COUNTER; break; @@ -104,12 +157,32 @@ st_BeginQuery(struct gl_context *ctx, struct gl_query_object *q) case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN: type = PIPE_QUERY_PRIMITIVES_EMITTED; break; + case GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB: + type = PIPE_QUERY_SO_OVERFLOW_PREDICATE; + break; + case GL_TRANSFORM_FEEDBACK_OVERFLOW_ARB: + type = PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE; + break; case GL_TIME_ELAPSED: if (st->has_time_elapsed) type = PIPE_QUERY_TIME_ELAPSED; else type = PIPE_QUERY_TIMESTAMP; break; + case GL_VERTICES_SUBMITTED_ARB: + case GL_PRIMITIVES_SUBMITTED_ARB: + case GL_VERTEX_SHADER_INVOCATIONS_ARB: + case GL_TESS_CONTROL_SHADER_PATCHES_ARB: + case GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB: + case GL_GEOMETRY_SHADER_INVOCATIONS: + case GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB: + case GL_FRAGMENT_SHADER_INVOCATIONS_ARB: + case GL_COMPUTE_SHADER_INVOCATIONS_ARB: + case GL_CLIPPING_INPUT_PRIMITIVES_ARB: + case GL_CLIPPING_OUTPUT_PRIMITIVES_ARB: + type = st->has_single_pipe_stat ? PIPE_QUERY_PIPELINE_STATISTICS_SINGLE + : PIPE_QUERY_PIPELINE_STATISTICS; + break; default: assert(0 && "unexpected query target in st_BeginQuery()"); return; @@ -117,14 +190,7 @@ st_BeginQuery(struct gl_context *ctx, struct gl_query_object *q) if (stq->type != type) { /* free old query of different type */ - if (stq->pq) { - pipe->destroy_query(pipe, stq->pq); - stq->pq = NULL; - } - if (stq->pq_begin) { - pipe->destroy_query(pipe, stq->pq_begin); - stq->pq_begin = NULL; - } + free_queries(pipe, stq); stq->type = PIPE_QUERY_TYPES; /* an invalid value */ } @@ -135,20 +201,28 @@ st_BeginQuery(struct gl_context *ctx, struct gl_query_object *q) stq->pq_begin = pipe->create_query(pipe, type, 0); stq->type = type; } - pipe->end_query(pipe, stq->pq_begin); + if (stq->pq_begin) + ret = pipe->end_query(pipe, stq->pq_begin); } else { if (!stq->pq) { - stq->pq = pipe->create_query(pipe, type, 0); + stq->pq = pipe->create_query(pipe, type, target_to_index(st, q)); stq->type = type; } - if (stq->pq) { - pipe->begin_query(pipe, stq->pq); - } - else { - _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBeginQuery"); - return; - } + if (stq->pq) + ret = pipe->begin_query(pipe, stq->pq); } + + if (!ret) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBeginQuery"); + + free_queries(pipe, stq); + q->Active = GL_FALSE; + return; + } + + if (stq->type != PIPE_QUERY_TIMESTAMP) + st->active_queries++; + assert(stq->type == type); } @@ -156,8 +230,10 @@ st_BeginQuery(struct gl_context *ctx, struct gl_query_object *q) static void st_EndQuery(struct gl_context *ctx, struct gl_query_object *q) { - struct pipe_context *pipe = st_context(ctx)->pipe; + struct st_context *st = st_context(ctx); + struct pipe_context *pipe = st->pipe; struct st_query_object *stq = st_query_object(q); + bool ret = false; st_flush_bitmap_cache(st_context(ctx)); @@ -169,7 +245,15 @@ st_EndQuery(struct gl_context *ctx, struct gl_query_object *q) } if (stq->pq) - pipe->end_query(pipe, stq->pq); + ret = pipe->end_query(pipe, stq->pq); + + if (!ret) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glEndQuery"); + return; + } + + if (stq->type != PIPE_QUERY_TIMESTAMP) + st->active_queries--; } @@ -178,6 +262,8 @@ get_query_result(struct pipe_context *pipe, struct st_query_object *stq, boolean wait) { + union pipe_query_result data; + if (!stq->pq) { /* Only needed in case we failed to allocate the gallium query earlier. * Return TRUE so we don't spin on this forever. @@ -185,11 +271,58 @@ get_query_result(struct pipe_context *pipe, return TRUE; } - if (!pipe->get_query_result(pipe, - stq->pq, - wait, - (void *)&stq->base.Result)) { + if (!pipe->get_query_result(pipe, stq->pq, wait, &data)) return FALSE; + + switch (stq->type) { + case PIPE_QUERY_PIPELINE_STATISTICS: + switch (stq->base.Target) { + case GL_VERTICES_SUBMITTED_ARB: + stq->base.Result = data.pipeline_statistics.ia_vertices; + break; + case GL_PRIMITIVES_SUBMITTED_ARB: + stq->base.Result = data.pipeline_statistics.ia_primitives; + break; + case GL_VERTEX_SHADER_INVOCATIONS_ARB: + stq->base.Result = data.pipeline_statistics.vs_invocations; + break; + case GL_TESS_CONTROL_SHADER_PATCHES_ARB: + stq->base.Result = data.pipeline_statistics.hs_invocations; + break; + case GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB: + stq->base.Result = data.pipeline_statistics.ds_invocations; + break; + case GL_GEOMETRY_SHADER_INVOCATIONS: + stq->base.Result = data.pipeline_statistics.gs_invocations; + break; + case GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB: + stq->base.Result = data.pipeline_statistics.gs_primitives; + break; + case GL_FRAGMENT_SHADER_INVOCATIONS_ARB: + stq->base.Result = data.pipeline_statistics.ps_invocations; + break; + case GL_COMPUTE_SHADER_INVOCATIONS_ARB: + stq->base.Result = data.pipeline_statistics.cs_invocations; + break; + case GL_CLIPPING_INPUT_PRIMITIVES_ARB: + stq->base.Result = data.pipeline_statistics.c_invocations; + break; + case GL_CLIPPING_OUTPUT_PRIMITIVES_ARB: + stq->base.Result = data.pipeline_statistics.c_primitives; + break; + default: + unreachable("invalid pipeline statistics counter"); + } + break; + case PIPE_QUERY_OCCLUSION_PREDICATE: + case PIPE_QUERY_OCCLUSION_PREDICATE_CONSERVATIVE: + case PIPE_QUERY_SO_OVERFLOW_PREDICATE: + case PIPE_QUERY_SO_OVERFLOW_ANY_PREDICATE: + stq->base.Result = !!data.b; + break; + default: + stq->base.Result = data.u64; + break; } if (stq->base.Target == GL_TIME_ELAPSED && @@ -221,7 +354,7 @@ st_WaitQuery(struct gl_context *ctx, struct gl_query_object *q) { /* nothing */ } - + q->Ready = GL_TRUE; } @@ -239,11 +372,112 @@ st_CheckQuery(struct gl_context *ctx, struct gl_query_object *q) static uint64_t st_GetTimestamp(struct gl_context *ctx) { - struct pipe_screen *screen = st_context(ctx)->pipe->screen; + struct pipe_context *pipe = st_context(ctx)->pipe; + struct pipe_screen *screen = pipe->screen; - return screen->get_timestamp(screen); + /* Prefer the per-screen function */ + if (screen->get_timestamp) { + return screen->get_timestamp(screen); + } + else { + /* Fall back to the per-context function */ + assert(pipe->get_timestamp); + return pipe->get_timestamp(pipe); + } } +static void +st_StoreQueryResult(struct gl_context *ctx, struct gl_query_object *q, + struct gl_buffer_object *buf, intptr_t offset, + GLenum pname, GLenum ptype) +{ + struct pipe_context *pipe = st_context(ctx)->pipe; + struct st_query_object *stq = st_query_object(q); + struct st_buffer_object *stObj = st_buffer_object(buf); + boolean wait = pname == GL_QUERY_RESULT; + enum pipe_query_value_type result_type; + int index; + + /* GL_QUERY_TARGET is a bit of an extension since it has nothing to + * do with the GPU end of the query. Write it in "by hand". + */ + if (pname == GL_QUERY_TARGET) { + /* Assume that the data must be LE. The endianness situation wrt CPU and + * GPU is incredibly confusing, but the vast majority of GPUs are + * LE. When a BE one comes along, this needs some form of resolution. + */ + unsigned data[2] = { CPU_TO_LE32(q->Target), 0 }; + pipe_buffer_write(pipe, stObj->buffer, offset, + (ptype == GL_INT64_ARB || + ptype == GL_UNSIGNED_INT64_ARB) ? 8 : 4, + data); + return; + } + + switch (ptype) { + case GL_INT: + result_type = PIPE_QUERY_TYPE_I32; + break; + case GL_UNSIGNED_INT: + result_type = PIPE_QUERY_TYPE_U32; + break; + case GL_INT64_ARB: + result_type = PIPE_QUERY_TYPE_I64; + break; + case GL_UNSIGNED_INT64_ARB: + result_type = PIPE_QUERY_TYPE_U64; + break; + default: + unreachable("Unexpected result type"); + } + + if (pname == GL_QUERY_RESULT_AVAILABLE) { + index = -1; + } else if (stq->type == PIPE_QUERY_PIPELINE_STATISTICS) { + switch (q->Target) { + case GL_VERTICES_SUBMITTED_ARB: + index = PIPE_STAT_QUERY_IA_VERTICES; + break; + case GL_PRIMITIVES_SUBMITTED_ARB: + index = PIPE_STAT_QUERY_IA_PRIMITIVES; + break; + case GL_VERTEX_SHADER_INVOCATIONS_ARB: + index = PIPE_STAT_QUERY_VS_INVOCATIONS; + break; + case GL_GEOMETRY_SHADER_INVOCATIONS: + index = PIPE_STAT_QUERY_GS_INVOCATIONS; + break; + case GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB: + index = PIPE_STAT_QUERY_GS_PRIMITIVES; + break; + case GL_CLIPPING_INPUT_PRIMITIVES_ARB: + index = PIPE_STAT_QUERY_C_INVOCATIONS; + break; + case GL_CLIPPING_OUTPUT_PRIMITIVES_ARB: + index = PIPE_STAT_QUERY_C_PRIMITIVES; + break; + case GL_FRAGMENT_SHADER_INVOCATIONS_ARB: + index = PIPE_STAT_QUERY_PS_INVOCATIONS; + break; + case GL_TESS_CONTROL_SHADER_PATCHES_ARB: + index = PIPE_STAT_QUERY_HS_INVOCATIONS; + break; + case GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB: + index = PIPE_STAT_QUERY_DS_INVOCATIONS; + break; + case GL_COMPUTE_SHADER_INVOCATIONS_ARB: + index = PIPE_STAT_QUERY_CS_INVOCATIONS; + break; + default: + unreachable("Unexpected target"); + } + } else { + index = 0; + } + + pipe->get_query_result_resource(pipe, stq->pq, wait, result_type, index, + stObj->buffer, offset); +} void st_init_query_functions(struct dd_function_table *functions) { @@ -254,4 +488,5 @@ void st_init_query_functions(struct dd_function_table *functions) functions->WaitQuery = st_WaitQuery; functions->CheckQuery = st_CheckQuery; functions->GetTimestamp = st_GetTimestamp; + functions->StoreQueryResult = st_StoreQueryResult; }