X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_cb_queryobj.c;h=69e6004c3f1f26837128da1c823c40229b87fe37;hb=0b3e9564bdda575c3956f338454f4f632041e151;hp=b10fd9335eda1ae0ed33ed948595be553a4bbb31;hpb=25ee9617ff0b537bb30de92983baa745e49556b6;p=mesa.git diff --git a/src/mesa/state_tracker/st_cb_queryobj.c b/src/mesa/state_tracker/st_cb_queryobj.c index b10fd9335ed..69e6004c3f1 100644 --- a/src/mesa/state_tracker/st_cb_queryobj.c +++ b/src/mesa/state_tracker/st_cb_queryobj.c @@ -1,6 +1,6 @@ /************************************************************************** * - * 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 @@ -18,7 +18,7 @@ * 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. @@ -34,15 +34,17 @@ #include "main/imports.h" +#include "main/compiler.h" #include "main/context.h" -#include "main/mfeatures.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" static struct gl_query_object * @@ -60,6 +62,20 @@ st_NewQueryObject(struct gl_context *ctx, GLuint id) } +static void +free_queries(struct pipe_context *pipe, struct st_query_object *stq) +{ + 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; + } +} + static void st_DeleteQuery(struct gl_context *ctx, struct gl_query_object *q) @@ -67,10 +83,7 @@ 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); - if (stq->pq) { - pipe->destroy_query(pipe, stq->pq); - stq->pq = NULL; - } + free_queries(pipe, stq); free(stq); } @@ -79,16 +92,22 @@ st_DeleteQuery(struct gl_context *ctx, struct gl_query_object *q) static void st_BeginQuery(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); 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: - /* fall-through */ + type = PIPE_QUERY_OCCLUSION_PREDICATE; + break; + case GL_ANY_SAMPLES_PASSED_CONSERVATIVE: + type = PIPE_QUERY_OCCLUSION_PREDICATE_CONSERVATIVE; + break; case GL_SAMPLES_PASSED_ARB: type = PIPE_QUERY_OCCLUSION_COUNTER; break; @@ -98,29 +117,69 @@ 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_TIME_ELAPSED_EXT: - type = PIPE_QUERY_TIME_ELAPSED; + 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 = PIPE_QUERY_PIPELINE_STATISTICS; break; default: assert(0 && "unexpected query target in st_BeginQuery()"); return; } - if (stq->pq && stq->type != type) { + if (stq->type != type) { /* free old query of different type */ - pipe->destroy_query(pipe, stq->pq); - stq->pq = NULL; + free_queries(pipe, stq); stq->type = PIPE_QUERY_TYPES; /* an invalid value */ } - if (!stq->pq) { - stq->pq = pipe->create_query(pipe, type); - stq->type = type; + 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, q->Stream); + stq->type = type; + } + if (stq->pq) + ret = pipe->begin_query(pipe, stq->pq); } - assert(stq->type == type); + if (!ret) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBeginQuery"); + + free_queries(pipe, stq); + q->Active = GL_FALSE; + return; + } - pipe->begin_query(pipe, stq->pq); + assert(stq->type == type); } @@ -129,15 +188,105 @@ st_EndQuery(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); + bool ret = false; st_flush_bitmap_cache(st_context(ctx)); - if (q->Target == GL_TIMESTAMP && !stq->pq) { - stq->pq = pipe->create_query(pipe, PIPE_QUERY_TIMESTAMP); + 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; } - pipe->end_query(pipe, stq->pq); + if (stq->pq) + ret = pipe->end_query(pipe, stq->pq); + + if (!ret) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glEndQuery"); + return; + } +} + + +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->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: + switch (stq->type) { + 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; + } + 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); + } + + return TRUE; } @@ -151,14 +300,11 @@ st_WaitQuery(struct gl_context *ctx, struct gl_query_object *q) assert(!stq->base.Ready); while (!stq->base.Ready && - !pipe->get_query_result(pipe, - stq->pq, - TRUE, - (void*)&q->Result)) + !get_query_result(pipe, stq, TRUE)) { /* nothing */ } - + q->Ready = GL_TRUE; } @@ -169,18 +315,119 @@ st_CheckQuery(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); assert(!q->Ready); /* we should not get called if Ready is TRUE */ - q->Ready = pipe->get_query_result(pipe, stq->pq, FALSE, (void*)&q->Result); + q->Ready = get_query_result(pipe, stq, FALSE); } 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 = 0; + break; + case GL_PRIMITIVES_SUBMITTED_ARB: + index = 1; + break; + case GL_VERTEX_SHADER_INVOCATIONS_ARB: + index = 2; + break; + case GL_GEOMETRY_SHADER_INVOCATIONS: + index = 3; + break; + case GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB: + index = 4; + break; + case GL_CLIPPING_INPUT_PRIMITIVES_ARB: + index = 5; + break; + case GL_CLIPPING_OUTPUT_PRIMITIVES_ARB: + index = 6; + break; + case GL_FRAGMENT_SHADER_INVOCATIONS_ARB: + index = 7; + break; + case GL_TESS_CONTROL_SHADER_PATCHES_ARB: + index = 8; + break; + case GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB: + index = 9; + break; + case GL_COMPUTE_SHADER_INVOCATIONS_ARB: + index = 10; + 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) { @@ -191,4 +438,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; }