src/gallium/drivers/llvmpipe/lp_scene.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2009 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "util/u_framebuffer.h"
  29 #include "util/u_math.h"
  30 #include "util/u_memory.h"
  31 #include "util/u_inlines.h"
  32 #include "util/u_simple_list.h"
  33 #include "lp_scene.h"
  34 #include "lp_scene_queue.h"
  35 #include "lp_fence.h"
  36
  37
  38 /** List of texture references */
  39 struct texture_ref {
  40    struct pipe_resource *texture;
  41    struct texture_ref *prev, *next;  /**< linked list w/ u_simple_list.h */
  42 };
  43
  44
  45
  46 /**
  47  * Create a new scene object.
  48  * \param queue  the queue to put newly rendered/emptied scenes into
  49  */
  50 struct lp_scene *
  51 lp_scene_create( struct pipe_context *pipe,
  52                  struct lp_scene_queue *queue )
  53 {
  54    unsigned i, j;
  55    struct lp_scene *scene = CALLOC_STRUCT(lp_scene);
  56    if (!scene)
  57       return NULL;
  58
  59    scene->pipe = pipe;
  60    scene->empty_queue = queue;
  61
  62    for (i = 0; i < TILES_X; i++) {
  63       for (j = 0; j < TILES_Y; j++) {
  64          struct cmd_bin *bin = lp_scene_get_bin(scene, i, j);
  65          bin->commands.head = bin->commands.tail = CALLOC_STRUCT(cmd_block);
  66       }
  67    }
  68
  69    scene->data.head =
  70       scene->data.tail = CALLOC_STRUCT(data_block);
  71
  72    make_empty_list(&scene->resources);
  73
  74    pipe_mutex_init(scene->mutex);
  75
  76    return scene;
  77 }
  78
  79
  80 /**
  81  * Free all data associated with the given scene, and the scene itself.
  82  */
  83 void
  84 lp_scene_destroy(struct lp_scene *scene)
  85 {
  86    unsigned i, j;
  87
  88    lp_scene_reset(scene);
  89
  90    for (i = 0; i < TILES_X; i++)
  91       for (j = 0; j < TILES_Y; j++) {
  92          struct cmd_bin *bin = lp_scene_get_bin(scene, i, j);
  93          assert(bin->commands.head == bin->commands.tail);
  94          FREE(bin->commands.head);
  95          bin->commands.head = NULL;
  96          bin->commands.tail = NULL;
  97       }
  98
  99    FREE(scene->data.head);
 100    scene->data.head = NULL;
 101
 102    pipe_mutex_destroy(scene->mutex);
 103
 104    FREE(scene);
 105 }
 106
 107
 108 /**
 109  * Check if the scene's bins are all empty.
 110  * For debugging purposes.
 111  */
 112 boolean
 113 lp_scene_is_empty(struct lp_scene *scene )
 114 {
 115    unsigned x, y;
 116
 117    for (y = 0; y < TILES_Y; y++) {
 118       for (x = 0; x < TILES_X; x++) {
 119          const struct cmd_bin *bin = lp_scene_get_bin(scene, x, y);
 120          const struct cmd_block_list *list = &bin->commands;
 121          if (list->head != list->tail || list->head->count > 0) {
 122             return FALSE;
 123          }
 124       }
 125    }
 126    return TRUE;
 127 }
 128
 129
 130 /* Free data for one particular bin.  May be called from the
 131  * rasterizer thread(s).
 132  */
 133 void
 134 lp_scene_bin_reset(struct lp_scene *scene, unsigned x, unsigned y)
 135 {
 136    struct cmd_bin *bin = lp_scene_get_bin(scene, x, y);
 137    struct cmd_block_list *list = &bin->commands;
 138    struct cmd_block *block;
 139    struct cmd_block *tmp;
 140
 141    assert(x < TILES_X);
 142    assert(y < TILES_Y);
 143
 144    for (block = list->head; block != list->tail; block = tmp) {
 145       tmp = block->next;
 146       FREE(block);
 147    }
 148
 149    assert(list->tail->next == NULL);
 150    list->head = list->tail;
 151    list->head->count = 0;
 152 }
 153
 154
 155 /**
 156  * Free all the temporary data in a scene.  May be called from the
 157  * rasterizer thread(s).
 158  */
 159 void
 160 lp_scene_reset(struct lp_scene *scene )
 161 {
 162    unsigned i, j;
 163
 164    /* Free all but last binner command lists:
 165     */
 166    for (i = 0; i < TILES_X; i++) {
 167       for (j = 0; j < TILES_Y; j++) {
 168          lp_scene_bin_reset(scene, i, j);
 169       }
 170    }
 171
 172    assert(lp_scene_is_empty(scene));
 173
 174    /* Free all but last binned data block:
 175     */
 176    {
 177       struct data_block_list *list = &scene->data;
 178       struct data_block *block, *tmp;
 179
 180       for (block = list->head; block != list->tail; block = tmp) {
 181          tmp = block->next;
 182          FREE(block);
 183       }
 184
 185       assert(list->tail->next == NULL);
 186       list->head = list->tail;
 187       list->head->used = 0;
 188    }
 189
 190    /* Release texture refs
 191     */
 192    {
 193       struct resource_ref *ref, *next, *ref_list = &scene->resources;
 194       for (ref = ref_list->next; ref != ref_list; ref = next) {
 195          next = next_elem(ref);
 196          pipe_resource_reference(&ref->resource, NULL);
 197          FREE(ref);
 198       }
 199       make_empty_list(ref_list);
 200    }
 201
 202    lp_fence_reference(&scene->fence, NULL);
 203
 204    scene->scene_size = 0;
 205
 206    scene->has_color_clear = FALSE;
 207    scene->has_depthstencil_clear = FALSE;
 208 }
 209
 210
 211
 212
 213
 214
 215 struct cmd_block *
 216 lp_bin_new_cmd_block( struct cmd_block_list *list )
 217 {
 218    struct cmd_block *block = MALLOC_STRUCT(cmd_block);
 219    if (block) {
 220       list->tail->next = block;
 221       list->tail = block;
 222       block->next = NULL;
 223       block->count = 0;
 224    }
 225    return block;
 226 }
 227
 228
 229 struct data_block *
 230 lp_bin_new_data_block( struct data_block_list *list )
 231 {
 232    struct data_block *block = MALLOC_STRUCT(data_block);
 233    if (block) {
 234       list->tail->next = block;
 235       list->tail = block;
 236       block->next = NULL;
 237       block->used = 0;
 238    }
 239    return block;
 240 }
 241
 242
 243 /**
 244  * Return number of bytes used for all bin data within a scene.
 245  * This does not include resources (textures) referenced by the scene.
 246  */
 247 unsigned
 248 lp_scene_data_size( const struct lp_scene *scene )
 249 {
 250    unsigned size = 0;
 251    const struct data_block *block;
 252    for (block = scene->data.head; block; block = block->next) {
 253       size += block->used;
 254    }
 255    return size;
 256 }
 257
 258
 259 /** Return number of bytes used for a single bin */
 260 unsigned
 261 lp_scene_bin_size( const struct lp_scene *scene, unsigned x, unsigned y )
 262 {
 263    struct cmd_bin *bin = lp_scene_get_bin((struct lp_scene *) scene, x, y);
 264    const struct cmd_block *cmd;
 265    unsigned size = 0;
 266    for (cmd = bin->commands.head; cmd; cmd = cmd->next) {
 267       size += (cmd->count *
 268                (sizeof(lp_rast_cmd) + sizeof(union lp_rast_cmd_arg)));
 269    }
 270    return size;
 271 }
 272
 273
 274 /**
 275  * Add a reference to a resource by the scene.
 276  */
 277 void
 278 lp_scene_add_resource_reference(struct lp_scene *scene,
 279                                 struct pipe_resource *resource)
 280 {
 281    struct resource_ref *ref = CALLOC_STRUCT(resource_ref);
 282    if (ref) {
 283       struct resource_ref *ref_list = &scene->resources;
 284       pipe_resource_reference(&ref->resource, resource);
 285       insert_at_tail(ref_list, ref);
 286    }
 287
 288    scene->scene_size += llvmpipe_resource_size(resource);
 289 }
 290
 291
 292 /**
 293  * Does this scene have a reference to the given resource?
 294  */
 295 boolean
 296 lp_scene_is_resource_referenced(const struct lp_scene *scene,
 297                                 const struct pipe_resource *resource)
 298 {
 299    const struct resource_ref *ref_list = &scene->resources;
 300    const struct resource_ref *ref;
 301    foreach (ref, ref_list) {
 302       if (ref->resource == resource)
 303          return TRUE;
 304    }
 305    return FALSE;
 306 }
 307
 308
 309 /**
 310  * Return last command in the bin
 311  */
 312 static lp_rast_cmd
 313 lp_get_last_command( const struct cmd_bin *bin )
 314 {
 315    const struct cmd_block *tail = bin->commands.tail;
 316    const unsigned i = tail->count;
 317    if (i > 0)
 318       return tail->cmd[i - 1];
 319    else
 320       return NULL;
 321 }
 322
 323
 324 /**
 325  * Replace the arg of the last command in the bin.
 326  */
 327 static void
 328 lp_replace_last_command_arg( struct cmd_bin *bin,
 329                              const union lp_rast_cmd_arg arg )
 330 {
 331    struct cmd_block *tail = bin->commands.tail;
 332    const unsigned i = tail->count;
 333    assert(i > 0);
 334    tail->arg[i - 1] = arg;
 335 }
 336
 337
 338
 339 /**
 340  * Put a state-change command into all bins.
 341  * If we find that the last command in a bin was also a state-change
 342  * command, we can simply replace that one with the new one.
 343  */
 344 void
 345 lp_scene_bin_state_command( struct lp_scene *scene,
 346                             lp_rast_cmd cmd,
 347                             const union lp_rast_cmd_arg arg )
 348 {
 349    unsigned i, j;
 350    for (i = 0; i < scene->tiles_x; i++) {
 351       for (j = 0; j < scene->tiles_y; j++) {
 352          struct cmd_bin *bin = lp_scene_get_bin(scene, i, j);
 353          lp_rast_cmd last_cmd = lp_get_last_command(bin);
 354          if (last_cmd == cmd) {
 355             lp_replace_last_command_arg(bin, arg);
 356          }
 357          else {
 358             lp_scene_bin_command( scene, i, j, cmd, arg );
 359          }
 360       }
 361    }
 362 }
 363
 364
 365 /** advance curr_x,y to the next bin */
 366 static boolean
 367 next_bin(struct lp_scene *scene)
 368 {
 369    scene->curr_x++;
 370    if (scene->curr_x >= scene->tiles_x) {
 371       scene->curr_x = 0;
 372       scene->curr_y++;
 373    }
 374    if (scene->curr_y >= scene->tiles_y) {
 375       /* no more bins */
 376       return FALSE;
 377    }
 378    return TRUE;
 379 }
 380
 381
 382 void
 383 lp_scene_bin_iter_begin( struct lp_scene *scene )
 384 {
 385    scene->curr_x = scene->curr_y = -1;
 386 }
 387
 388
 389 /**
 390  * Return pointer to next bin to be rendered.
 391  * The lp_scene::curr_x and ::curr_y fields will be advanced.
 392  * Multiple rendering threads will call this function to get a chunk
 393  * of work (a bin) to work on.
 394  */
 395 struct cmd_bin *
 396 lp_scene_bin_iter_next( struct lp_scene *scene, int *bin_x, int *bin_y )
 397 {
 398    struct cmd_bin *bin = NULL;
 399
 400    pipe_mutex_lock(scene->mutex);
 401
 402    if (scene->curr_x < 0) {
 403       /* first bin */
 404       scene->curr_x = 0;
 405       scene->curr_y = 0;
 406    }
 407    else if (!next_bin(scene)) {
 408       /* no more bins left */
 409       goto end;
 410    }
 411
 412    bin = lp_scene_get_bin(scene, scene->curr_x, scene->curr_y);
 413    *bin_x = scene->curr_x;
 414    *bin_y = scene->curr_y;
 415
 416 end:
 417    /*printf("return bin %p at %d, %d\n", (void *) bin, *bin_x, *bin_y);*/
 418    pipe_mutex_unlock(scene->mutex);
 419    return bin;
 420 }
 421
 422
 423 void lp_scene_begin_binning( struct lp_scene *scene,
 424                              struct pipe_framebuffer_state *fb )
 425 {
 426    assert(lp_scene_is_empty(scene));
 427
 428    util_copy_framebuffer_state(&scene->fb, fb);
 429
 430    scene->tiles_x = align(fb->width, TILE_SIZE) / TILE_SIZE;
 431    scene->tiles_y = align(fb->height, TILE_SIZE) / TILE_SIZE;
 432
 433    assert(scene->tiles_x <= TILES_X);
 434    assert(scene->tiles_y <= TILES_Y);
 435 }
 436
 437
 438 void lp_scene_rasterize( struct lp_scene *scene,
 439                          struct lp_rasterizer *rast )
 440 {
 441    if (0) {
 442       unsigned x, y;
 443       debug_printf("rasterize scene:\n");
 444       debug_printf("  data size: %u\n", lp_scene_data_size(scene));
 445       for (y = 0; y < scene->tiles_y; y++) {
 446          for (x = 0; x < scene->tiles_x; x++) {
 447             debug_printf("  bin %u, %u size: %u\n", x, y,
 448                          lp_scene_bin_size(scene, x, y));
 449          }
 450       }
 451    }
 452
 453    /* Enqueue the scene for rasterization, then immediately wait for
 454     * it to finish.
 455     */
 456    lp_rast_queue_scene( rast, scene );
 457
 458    /* Currently just wait for the rasterizer to finish.  Some
 459     * threading interactions need to be worked out, particularly once
 460     * transfers become per-context:
 461     */
 462    lp_rast_finish( rast );
 463
 464    util_unreference_framebuffer_state( &scene->fb );
 465
 466    /* put scene into the empty list */
 467    lp_scene_enqueue( scene->empty_queue, scene );
 468 }