src/gallium/drivers/llvmpipe/lp_query.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * Copyright 2010 VMware, Inc.
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL THE AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29 /* Authors:
  30  *    Keith Whitwell, Qicheng Christopher Li, Brian Paul
  31  */
  32
  33 #include "draw/draw_context.h"
  34 #include "pipe/p_defines.h"
  35 #include "util/u_memory.h"
  36 #include "os/os_time.h"
  37 #include "lp_context.h"
  38 #include "lp_flush.h"
  39 #include "lp_fence.h"
  40 #include "lp_query.h"
  41 #include "lp_screen.h"
  42 #include "lp_state.h"
  43 #include "lp_rast.h"
  44
  45
  46 static struct llvmpipe_query *llvmpipe_query( struct pipe_query *p )
  47 {
  48    return (struct llvmpipe_query *)p;
  49 }
  50
  51 static struct pipe_query *
  52 llvmpipe_create_query(struct pipe_context *pipe,
  53                       unsigned type)
  54 {
  55    struct llvmpipe_query *pq;
  56
  57    assert(type < PIPE_QUERY_TYPES);
  58
  59    pq = CALLOC_STRUCT( llvmpipe_query );
  60
  61    if (pq) {
  62       pq->type = type;
  63    }
  64
  65    return (struct pipe_query *) pq;
  66 }
  67
  68
  69 static void
  70 llvmpipe_destroy_query(struct pipe_context *pipe, struct pipe_query *q)
  71 {
  72    struct llvmpipe_query *pq = llvmpipe_query(q);
  73
  74    /* Ideally we would refcount queries & not get destroyed until the
  75     * last scene had finished with us.
  76     */
  77    if (pq->fence) {
  78       if (!lp_fence_issued(pq->fence))
  79          llvmpipe_flush(pipe, NULL, __FUNCTION__);
  80
  81       if (!lp_fence_signalled(pq->fence))
  82          lp_fence_wait(pq->fence);
  83
  84       lp_fence_reference(&pq->fence, NULL);
  85    }
  86
  87    FREE(pq);
  88 }
  89
  90
  91 static boolean
  92 llvmpipe_get_query_result(struct pipe_context *pipe,
  93                           struct pipe_query *q,
  94                           boolean wait,
  95                           union pipe_query_result *vresult)
  96 {
  97    struct llvmpipe_screen *screen = llvmpipe_screen(pipe->screen);
  98    unsigned num_threads = MAX2(1, screen->num_threads);
  99    struct llvmpipe_query *pq = llvmpipe_query(q);
 100    uint64_t *result = (uint64_t *)vresult;
 101    int i;
 102
 103    if (!pq->fence) {
 104       /* no fence because there was no scene, so results is zero */
 105       *result = 0;
 106       return TRUE;
 107    }
 108
 109    if (!lp_fence_signalled(pq->fence)) {
 110       if (!lp_fence_issued(pq->fence))
 111          llvmpipe_flush(pipe, NULL, __FUNCTION__);
 112
 113       if (!wait)
 114          return FALSE;
 115
 116       lp_fence_wait(pq->fence);
 117    }
 118
 119    /* Sum the results from each of the threads:
 120     */
 121    *result = 0;
 122
 123    switch (pq->type) {
 124    case PIPE_QUERY_OCCLUSION_COUNTER:
 125       for (i = 0; i < num_threads; i++) {
 126          *result += pq->count[i];
 127       }
 128       break;
 129    case PIPE_QUERY_OCCLUSION_PREDICATE:
 130       for (i = 0; i < num_threads; i++) {
 131          /* safer (still not guaranteed) when there's an overflow */
 132          vresult->b = vresult->b || pq->count[i];
 133       }
 134       break;
 135    case PIPE_QUERY_TIMESTAMP:
 136       for (i = 0; i < num_threads; i++) {
 137          if (pq->count[i] > *result) {
 138             *result = pq->count[i];
 139          }
 140          if (*result == 0)
 141             *result = os_time_get_nano();
 142       }
 143       break;
 144    case PIPE_QUERY_TIMESTAMP_DISJOINT: {
 145       struct pipe_query_data_timestamp_disjoint *td =
 146          (struct pipe_query_data_timestamp_disjoint *)vresult;
 147       /* os_get_time_nano return nanoseconds */
 148       td->frequency = UINT64_C(1000000000);
 149       td->disjoint = FALSE;
 150    }
 151       break;
 152    case PIPE_QUERY_GPU_FINISHED:
 153       vresult->b = TRUE;
 154       break;
 155    case PIPE_QUERY_PRIMITIVES_GENERATED:
 156       *result = pq->num_primitives_generated;
 157       break;
 158    case PIPE_QUERY_PRIMITIVES_EMITTED:
 159       *result = pq->num_primitives_written;
 160       break;
 161    case PIPE_QUERY_SO_OVERFLOW_PREDICATE:
 162       vresult->b = pq->so_has_overflown;
 163       break;
 164    case PIPE_QUERY_SO_STATISTICS: {
 165       struct pipe_query_data_so_statistics *stats =
 166          (struct pipe_query_data_so_statistics *)vresult;
 167       stats->num_primitives_written = pq->num_primitives_written;
 168       stats->primitives_storage_needed = pq->num_primitives_generated;
 169    }
 170       break;
 171    case PIPE_QUERY_PIPELINE_STATISTICS: {
 172       struct pipe_query_data_pipeline_statistics *stats =
 173          (struct pipe_query_data_pipeline_statistics *)vresult;
 174       /* only ps_invocations come from binned query */
 175       for (i = 0; i < num_threads; i++) {
 176          pq->stats.ps_invocations += pq->count[i];
 177       }
 178       pq->stats.ps_invocations *= LP_RASTER_BLOCK_SIZE * LP_RASTER_BLOCK_SIZE;
 179       *stats = pq->stats;
 180    }
 181       break;
 182    default:
 183       assert(0);
 184       break;
 185    }
 186
 187    return TRUE;
 188 }
 189
 190
 191 static void
 192 llvmpipe_begin_query(struct pipe_context *pipe, struct pipe_query *q)
 193 {
 194    struct llvmpipe_context *llvmpipe = llvmpipe_context( pipe );
 195    struct llvmpipe_query *pq = llvmpipe_query(q);
 196
 197    /* Check if the query is already in the scene.  If so, we need to
 198     * flush the scene now.  Real apps shouldn't re-use a query in a
 199     * frame of rendering.
 200     */
 201    if (pq->fence && !lp_fence_issued(pq->fence)) {
 202       llvmpipe_finish(pipe, __FUNCTION__);
 203    }
 204
 205
 206    memset(pq->count, 0, sizeof(pq->count));
 207    lp_setup_begin_query(llvmpipe->setup, pq);
 208
 209    switch (pq->type) {
 210    case PIPE_QUERY_PRIMITIVES_EMITTED:
 211       pq->num_primitives_written = 0;
 212       llvmpipe->so_stats.num_primitives_written = 0;
 213       break;
 214    case PIPE_QUERY_PRIMITIVES_GENERATED:
 215       pq->num_primitives_generated = 0;
 216       llvmpipe->num_primitives_generated = 0;
 217       break;
 218    case PIPE_QUERY_SO_STATISTICS:
 219       pq->num_primitives_written = 0;
 220       llvmpipe->so_stats.num_primitives_written = 0;
 221       pq->num_primitives_generated = 0;
 222       llvmpipe->num_primitives_generated = 0;
 223       break;
 224    case PIPE_QUERY_SO_OVERFLOW_PREDICATE:
 225       pq->so_has_overflown = FALSE;
 226       break;
 227    case PIPE_QUERY_PIPELINE_STATISTICS:
 228       /* reset our cache */
 229       if (llvmpipe->active_statistics_queries == 0) {
 230          memset(&llvmpipe->pipeline_statistics, 0,
 231                 sizeof(llvmpipe->pipeline_statistics));
 232       }
 233       memcpy(&pq->stats, &llvmpipe->pipeline_statistics, sizeof(pq->stats));
 234       llvmpipe->active_statistics_queries++;
 235       break;
 236    case PIPE_QUERY_OCCLUSION_COUNTER:
 237    case PIPE_QUERY_OCCLUSION_PREDICATE:
 238       /* Both active at same time will still fail all over the place.
 239        * Then again several of each type can be active too... */
 240       llvmpipe->active_occlusion_query++;
 241       llvmpipe->dirty |= LP_NEW_OCCLUSION_QUERY;
 242       break;
 243    default:
 244       break;
 245    }
 246 }
 247
 248
 249 static void
 250 llvmpipe_end_query(struct pipe_context *pipe, struct pipe_query *q)
 251 {
 252    struct llvmpipe_context *llvmpipe = llvmpipe_context( pipe );
 253    struct llvmpipe_query *pq = llvmpipe_query(q);
 254
 255    lp_setup_end_query(llvmpipe->setup, pq);
 256
 257    switch (pq->type) {
 258
 259    case PIPE_QUERY_PRIMITIVES_EMITTED:
 260       pq->num_primitives_written = llvmpipe->so_stats.num_primitives_written;
 261       break;
 262    case PIPE_QUERY_PRIMITIVES_GENERATED:
 263       pq->num_primitives_generated = llvmpipe->num_primitives_generated;
 264       break;
 265    case PIPE_QUERY_SO_STATISTICS:
 266       pq->num_primitives_written = llvmpipe->so_stats.num_primitives_written;
 267       pq->num_primitives_generated = llvmpipe->num_primitives_generated;
 268       break;
 269    case PIPE_QUERY_SO_OVERFLOW_PREDICATE:
 270       pq->so_has_overflown = (llvmpipe->num_primitives_generated >
 271                               llvmpipe->so_stats.num_primitives_written);
 272       break;
 273    case PIPE_QUERY_PIPELINE_STATISTICS:
 274       pq->stats.ia_vertices =
 275          llvmpipe->pipeline_statistics.ia_vertices - pq->stats.ia_vertices;
 276       pq->stats.ia_primitives =
 277          llvmpipe->pipeline_statistics.ia_primitives - pq->stats.ia_primitives;
 278       pq->stats.vs_invocations =
 279          llvmpipe->pipeline_statistics.vs_invocations - pq->stats.vs_invocations;
 280       pq->stats.gs_invocations =
 281          llvmpipe->pipeline_statistics.gs_invocations - pq->stats.gs_invocations;
 282       pq->stats.gs_primitives =
 283          llvmpipe->pipeline_statistics.gs_primitives - pq->stats.gs_primitives;
 284       pq->stats.c_invocations =
 285          llvmpipe->pipeline_statistics.c_invocations - pq->stats.c_invocations;
 286       pq->stats.c_primitives =
 287          llvmpipe->pipeline_statistics.c_primitives - pq->stats.c_primitives;
 288       pq->stats.ps_invocations =
 289          llvmpipe->pipeline_statistics.ps_invocations - pq->stats.ps_invocations;
 290
 291       llvmpipe->active_statistics_queries--;
 292       break;
 293    case PIPE_QUERY_OCCLUSION_COUNTER:
 294    case PIPE_QUERY_OCCLUSION_PREDICATE:
 295       assert(llvmpipe->active_occlusion_query);
 296       llvmpipe->active_occlusion_query--;
 297       llvmpipe->dirty |= LP_NEW_OCCLUSION_QUERY;
 298       break;
 299    default:
 300       break;
 301    }
 302 }
 303
 304 boolean
 305 llvmpipe_check_render_cond(struct llvmpipe_context *lp)
 306 {
 307    struct pipe_context *pipe = &lp->pipe;
 308    boolean b, wait;
 309    uint64_t result;
 310
 311    if (!lp->render_cond_query)
 312       return TRUE; /* no query predicate, draw normally */
 313
 314    wait = (lp->render_cond_mode == PIPE_RENDER_COND_WAIT ||
 315            lp->render_cond_mode == PIPE_RENDER_COND_BY_REGION_WAIT);
 316
 317    b = pipe->get_query_result(pipe, lp->render_cond_query, wait, (void*)&result);
 318    if (b)
 319       return (!result == lp->render_cond_cond);
 320    else
 321       return TRUE;
 322 }
 323
 324 void llvmpipe_init_query_funcs(struct llvmpipe_context *llvmpipe )
 325 {
 326    llvmpipe->pipe.create_query = llvmpipe_create_query;
 327    llvmpipe->pipe.destroy_query = llvmpipe_destroy_query;
 328    llvmpipe->pipe.begin_query = llvmpipe_begin_query;
 329    llvmpipe->pipe.end_query = llvmpipe_end_query;
 330    llvmpipe->pipe.get_query_result = llvmpipe_get_query_result;
 331 }
 332
 333