X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmesa%2Fstate_tracker%2Fst_cb_queryobj.c;h=50a776df74566a8bcc2433fb167e5cfd57a7c961;hb=95415a54c007a909f0fb9d1b2567beecbd73d403;hp=2281d10e99960c5b4c3f9f9792dac628a151ffb0;hpb=cd8614b0287dc5a69725ec4ee0208fad61f7789e;p=mesa.git diff --git a/src/mesa/state_tracker/st_cb_queryobj.c b/src/mesa/state_tracker/st_cb_queryobj.c index 2281d10e999..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 Tungsten Graphics, Inc., Cedar Park, Texas. + * + * 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,19 +10,19 @@ * 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. - * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR * 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,114 +33,451 @@ */ -#include "main/imports.h" +#include "util/compiler.h" #include "main/context.h" -#include "main/image.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 * -st_NewQueryObject(GLcontext *ctx, GLuint id) +st_NewQueryObject(struct gl_context *ctx, GLuint id) { struct st_query_object *stq = ST_CALLOC_STRUCT(st_query_object); if (stq) { stq->base.Id = id; stq->base.Ready = GL_TRUE; stq->pq = NULL; + stq->type = PIPE_QUERY_TYPES; /* an invalid value */ return &stq->base; } return NULL; } - static void -st_DeleteQuery(GLcontext *ctx, struct gl_query_object *q) +free_queries(struct pipe_context *pipe, struct st_query_object *stq) { - struct pipe_context *pipe = ctx->st->pipe; - struct st_query_object *stq = st_query_object(q); - if (stq->pq) { pipe->destroy_query(pipe, stq->pq); stq->pq = NULL; } - _mesa_free(stq); + if (stq->pq_begin) { + pipe->destroy_query(pipe, stq->pq_begin); + stq->pq_begin = NULL; + } } static void -st_BeginQuery(GLcontext *ctx, struct gl_query_object *q) +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_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) { - struct pipe_context *pipe = ctx->st->pipe; + struct st_context *st = st_context(ctx); + 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: + type = PIPE_QUERY_OCCLUSION_PREDICATE_CONSERVATIVE; + break; case GL_SAMPLES_PASSED_ARB: - if (!stq->pq) - stq->pq = pipe->create_query( pipe, PIPE_QUERY_OCCLUSION_COUNTER ); + type = PIPE_QUERY_OCCLUSION_COUNTER; + break; + case GL_PRIMITIVES_GENERATED: + type = PIPE_QUERY_PRIMITIVES_GENERATED; + break; + 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); + assert(0 && "unexpected query target in st_BeginQuery()"); return; } - pipe->begin_query(pipe, stq->pq); + if (stq->type != type) { + /* free old query of different type */ + free_queries(pipe, stq); + stq->type = PIPE_QUERY_TYPES; /* an invalid value */ + } + + if (q->Target == GL_TIME_ELAPSED && + type == PIPE_QUERY_TIMESTAMP) { + /* Determine time elapsed by emitting two timestamp queries. */ + if (!stq->pq_begin) { + stq->pq_begin = pipe->create_query(pipe, type, 0); + stq->type = type; + } + if (stq->pq_begin) + ret = pipe->end_query(pipe, stq->pq_begin); + } else { + if (!stq->pq) { + stq->pq = pipe->create_query(pipe, type, target_to_index(st, q)); + stq->type = type; + } + 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); } static void -st_EndQuery(GLcontext *ctx, struct gl_query_object *q) +st_EndQuery(struct gl_context *ctx, struct gl_query_object *q) { - struct pipe_context *pipe = ctx->st->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)); + + if ((q->Target == GL_TIMESTAMP || + q->Target == GL_TIME_ELAPSED) && + !stq->pq) { + stq->pq = pipe->create_query(pipe, PIPE_QUERY_TIMESTAMP, 0); + stq->type = PIPE_QUERY_TIMESTAMP; + } + + if (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--; +} + + +static boolean +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. + */ + return TRUE; + } + + 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 && + stq->type == PIPE_QUERY_TIMESTAMP) { + /* Calculate the elapsed time from the two timestamp queries */ + GLuint64EXT Result0 = 0; + assert(stq->pq_begin); + pipe->get_query_result(pipe, stq->pq_begin, TRUE, (void *)&Result0); + stq->base.Result -= Result0; + } else { + assert(!stq->pq_begin); + } - pipe->end_query(pipe, stq->pq); + return TRUE; } static void -st_WaitQuery(GLcontext *ctx, struct gl_query_object *q) +st_WaitQuery(struct gl_context *ctx, struct gl_query_object *q) { - struct pipe_context *pipe = ctx->st->pipe; + struct pipe_context *pipe = st_context(ctx)->pipe; struct st_query_object *stq = st_query_object(q); /* this function should only be called if we don't have a ready result */ assert(!stq->base.Ready); while (!stq->base.Ready && - !pipe->get_query_result(pipe, - stq->pq, - TRUE, - &q->Result)) + !get_query_result(pipe, stq, TRUE)) { /* nothing */ } - + q->Ready = GL_TRUE; } static void -st_CheckQuery(GLcontext *ctx, struct gl_query_object *q) +st_CheckQuery(struct gl_context *ctx, struct gl_query_object *q) { - struct pipe_context *pipe = ctx->st->pipe; + struct pipe_context *pipe = st_context(ctx)->pipe; struct st_query_object *stq = st_query_object(q); + assert(!q->Ready); /* we should not get called if Ready is TRUE */ + q->Ready = get_query_result(pipe, stq, FALSE); +} + - if (!q->Ready) { - q->Ready = pipe->get_query_result(pipe, - stq->pq, - FALSE, - &q->Result); +static uint64_t +st_GetTimestamp(struct gl_context *ctx) +{ + struct pipe_context *pipe = st_context(ctx)->pipe; + struct pipe_screen *screen = pipe->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) { @@ -150,4 +487,6 @@ void st_init_query_functions(struct dd_function_table *functions) functions->EndQuery = st_EndQuery; functions->WaitQuery = st_WaitQuery; functions->CheckQuery = st_CheckQuery; + functions->GetTimestamp = st_GetTimestamp; + functions->StoreQueryResult = st_StoreQueryResult; }