src/gallium/drivers/llvmpipe/lp_scene.h

   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
  29 /**
  30  * Binner data structures and bin-related functions.
  31  * Note: the "setup" code is concerned with building scenes while
  32  * The "rast" code is concerned with consuming/executing scenes.
  33  */
  34
  35 #ifndef LP_SCENE_H
  36 #define LP_SCENE_H
  37
  38 #include "os/os_thread.h"
  39 #include "lp_tile_soa.h"
  40 #include "lp_rast.h"
  41 #include "lp_debug.h"
  42
  43 struct lp_scene_queue;
  44 struct lp_rast_state;
  45
  46 /* We're limited to 2K by 2K for 32bit fixed point rasterization.
  47  * Will need a 64-bit version for larger framebuffers.
  48  */
  49 #define TILES_X (LP_MAX_WIDTH / TILE_SIZE)
  50 #define TILES_Y (LP_MAX_HEIGHT / TILE_SIZE)
  51
  52
  53 #define CMD_BLOCK_MAX 128
  54 #define DATA_BLOCK_SIZE (64 * 1024)
  55
  56 /* Scene temporary storage is clamped to this size:
  57  */
  58 #define LP_SCENE_MAX_SIZE (4*1024*1024)
  59
  60 /* The maximum amount of texture storage referenced by a scene is
  61  * clamped ot this size:
  62  */
  63 #define LP_SCENE_MAX_RESOURCE_SIZE (64*1024*1024)
  64
  65
  66 /* switch to a non-pointer value for this:
  67  */
  68 typedef void (*lp_rast_cmd_func)( struct lp_rasterizer_task *,
  69                                   const union lp_rast_cmd_arg );
  70
  71
  72 struct cmd_block {
  73    uint8_t cmd[CMD_BLOCK_MAX];
  74    union lp_rast_cmd_arg arg[CMD_BLOCK_MAX];
  75    unsigned count;
  76    struct cmd_block *next;
  77 };
  78
  79 struct cmd_block_list {
  80    struct cmd_block *head;
  81    struct cmd_block *tail;
  82 };
  83
  84 struct data_block {
  85    ubyte data[DATA_BLOCK_SIZE];
  86    unsigned used;
  87    struct data_block *next;
  88 };
  89
  90
  91
  92 /**
  93  * For each screen tile we have one of these bins.
  94  */
  95 struct cmd_bin {
  96    ushort x;
  97    ushort y;
  98    const struct lp_rast_state *last_state;       /* most recent state set in bin */
  99    struct cmd_block *head;
 100    struct cmd_block *tail;
 101 };
 102
 103
 104 /**
 105  * This stores bulk data which is used for all memory allocations
 106  * within a scene.
 107  *
 108  * Examples include triangle data and state data.  The commands in
 109  * the per-tile bins will point to chunks of data in this structure.
 110  *
 111  * Include the first block of data statically to ensure we can always
 112  * initiate a scene without relying on malloc succeeding.
 113  */
 114 struct data_block_list {
 115    struct data_block first;
 116    struct data_block *head;
 117 };
 118
 119 struct resource_ref;
 120
 121 /**
 122  * All bins and bin data are contained here.
 123  * Per-bin data goes into the 'tile' bins.
 124  * Shared data goes into the 'data' buffer.
 125  *
 126  * When there are multiple threads, will want to double-buffer between
 127  * scenes:
 128  */
 129 struct lp_scene {
 130    struct pipe_context *pipe;
 131    struct lp_fence *fence;
 132
 133    /* Framebuffer mappings - valid only between begin_rasterization()
 134     * and end_rasterization().
 135     */
 136    struct {
 137       uint8_t *map;
 138       unsigned stride;
 139       unsigned blocksize;
 140    } zsbuf, cbufs[PIPE_MAX_COLOR_BUFS];
 141
 142    /** the framebuffer to render the scene into */
 143    struct pipe_framebuffer_state fb;
 144
 145    /** list of resources referenced by the scene commands */
 146    struct resource_ref *resources;
 147
 148    /** Total memory used by the scene (in bytes).  This sums all the
 149     * data blocks and counts all bins, state, resource references and
 150     * other random allocations within the scene.
 151     */
 152    unsigned scene_size;
 153
 154    /** Sum of sizes of all resources referenced by the scene.  Sums
 155     * all the textures read by the scene:
 156     */
 157    unsigned resource_reference_size;
 158
 159    boolean alloc_failed;
 160    boolean has_depthstencil_clear;
 161
 162    /**
 163     * Number of active tiles in each dimension.
 164     * This basically the framebuffer size divided by tile size
 165     */
 166    unsigned tiles_x, tiles_y;
 167
 168    int curr_x, curr_y;  /**< for iterating over bins */
 169    pipe_mutex mutex;
 170
 171    struct cmd_bin tile[TILES_X][TILES_Y];
 172    struct data_block_list data;
 173 };
 174
 175
 176
 177 struct lp_scene *lp_scene_create(struct pipe_context *pipe);
 178
 179 void lp_scene_destroy(struct lp_scene *scene);
 180
 181 boolean lp_scene_is_empty(struct lp_scene *scene );
 182 boolean lp_scene_is_oom(struct lp_scene *scene );
 183
 184
 185 struct data_block *lp_scene_new_data_block( struct lp_scene *scene );
 186
 187 struct cmd_block *lp_scene_new_cmd_block( struct lp_scene *scene,
 188                                           struct cmd_bin *bin );
 189
 190 boolean lp_scene_add_resource_reference(struct lp_scene *scene,
 191                                         struct pipe_resource *resource,
 192                                         boolean initializing_scene);
 193
 194 boolean lp_scene_is_resource_referenced(const struct lp_scene *scene,
 195                                         const struct pipe_resource *resource );
 196
 197
 198 /**
 199  * Allocate space for a command/data in the bin's data buffer.
 200  * Grow the block list if needed.
 201  */
 202 static INLINE void *
 203 lp_scene_alloc( struct lp_scene *scene, unsigned size)
 204 {
 205    struct data_block_list *list = &scene->data;
 206    struct data_block *block = list->head;
 207
 208    assert(size <= DATA_BLOCK_SIZE);
 209    assert(block != NULL);
 210
 211    if (LP_DEBUG & DEBUG_MEM)
 212       debug_printf("alloc %u block %u/%u tot %u/%u\n",
 213                    size, block->used, DATA_BLOCK_SIZE,
 214                    scene->scene_size, LP_SCENE_MAX_SIZE);
 215
 216    if (block->used + size > DATA_BLOCK_SIZE) {
 217       block = lp_scene_new_data_block( scene );
 218       if (!block) {
 219          /* out of memory */
 220          return NULL;
 221       }
 222    }
 223
 224    {
 225       ubyte *data = block->data + block->used;
 226       block->used += size;
 227       return data;
 228    }
 229 }
 230
 231
 232 /**
 233  * As above, but with specific alignment.
 234  */
 235 static INLINE void *
 236 lp_scene_alloc_aligned( struct lp_scene *scene, unsigned size,
 237                         unsigned alignment )
 238 {
 239    struct data_block_list *list = &scene->data;
 240    struct data_block *block = list->head;
 241
 242    assert(block != NULL);
 243
 244    if (LP_DEBUG & DEBUG_MEM)
 245       debug_printf("alloc %u block %u/%u tot %u/%u\n",
 246                    size + alignment - 1,
 247                    block->used, DATA_BLOCK_SIZE,
 248                    scene->scene_size, LP_SCENE_MAX_SIZE);
 249
 250    if (block->used + size + alignment - 1 > DATA_BLOCK_SIZE) {
 251       block = lp_scene_new_data_block( scene );
 252       if (!block)
 253          return NULL;
 254    }
 255
 256    {
 257       ubyte *data = block->data + block->used;
 258       unsigned offset = (((uintptr_t)data + alignment - 1) & ~(alignment - 1)) - (uintptr_t)data;
 259       block->used += offset + size;
 260       return data + offset;
 261    }
 262 }
 263
 264
 265 /* Put back data if we decide not to use it, eg. culled triangles.
 266  */
 267 static INLINE void
 268 lp_scene_putback_data( struct lp_scene *scene, unsigned size)
 269 {
 270    struct data_block_list *list = &scene->data;
 271    assert(list->head && list->head->used >= size);
 272    list->head->used -= size;
 273 }
 274
 275
 276 /** Return pointer to a particular tile's bin. */
 277 static INLINE struct cmd_bin *
 278 lp_scene_get_bin(struct lp_scene *scene, unsigned x, unsigned y)
 279 {
 280    return &scene->tile[x][y];
 281 }
 282
 283
 284 /** Remove all commands from a bin */
 285 void
 286 lp_scene_bin_reset(struct lp_scene *scene, unsigned x, unsigned y);
 287
 288
 289 /* Add a command to bin[x][y].
 290  */
 291 static INLINE boolean
 292 lp_scene_bin_command( struct lp_scene *scene,
 293                       unsigned x, unsigned y,
 294                       unsigned cmd,
 295                       union lp_rast_cmd_arg arg )
 296 {
 297    struct cmd_bin *bin = lp_scene_get_bin(scene, x, y);
 298    struct cmd_block *tail = bin->tail;
 299
 300    assert(x < scene->tiles_x);
 301    assert(y < scene->tiles_y);
 302    assert(cmd < LP_RAST_OP_MAX);
 303
 304    if (tail == NULL || tail->count == CMD_BLOCK_MAX) {
 305       tail = lp_scene_new_cmd_block( scene, bin );
 306       if (!tail) {
 307          return FALSE;
 308       }
 309       assert(tail->count == 0);
 310    }
 311
 312    {
 313       unsigned i = tail->count;
 314       tail->cmd[i] = cmd & LP_RAST_OP_MASK;
 315       tail->arg[i] = arg;
 316       tail->count++;
 317    }
 318
 319    return TRUE;
 320 }
 321
 322
 323 static INLINE boolean
 324 lp_scene_bin_cmd_with_state( struct lp_scene *scene,
 325                              unsigned x, unsigned y,
 326                              const struct lp_rast_state *state,
 327                              unsigned cmd,
 328                              union lp_rast_cmd_arg arg )
 329 {
 330    struct cmd_bin *bin = lp_scene_get_bin(scene, x, y);
 331
 332    if (state != bin->last_state) {
 333       bin->last_state = state;
 334       if (!lp_scene_bin_command(scene, x, y,
 335                                 LP_RAST_OP_SET_STATE,
 336                                 lp_rast_arg_state(state)))
 337          return FALSE;
 338    }
 339
 340    if (!lp_scene_bin_command( scene, x, y, cmd, arg ))
 341       return FALSE;
 342
 343    return TRUE;
 344 }
 345
 346
 347 /* Add a command to all active bins.
 348  */
 349 static INLINE boolean
 350 lp_scene_bin_everywhere( struct lp_scene *scene,
 351                          unsigned cmd,
 352                          const union lp_rast_cmd_arg arg )
 353 {
 354    unsigned i, j;
 355    for (i = 0; i < scene->tiles_x; i++) {
 356       for (j = 0; j < scene->tiles_y; j++) {
 357          if (!lp_scene_bin_command( scene, i, j, cmd, arg ))
 358             return FALSE;
 359       }
 360    }
 361
 362    return TRUE;
 363 }
 364
 365
 366 static INLINE unsigned
 367 lp_scene_get_num_bins( const struct lp_scene *scene )
 368 {
 369    return scene->tiles_x * scene->tiles_y;
 370 }
 371
 372
 373 void
 374 lp_scene_bin_iter_begin( struct lp_scene *scene );
 375
 376 struct cmd_bin *
 377 lp_scene_bin_iter_next( struct lp_scene *scene );
 378
 379
 380
 381 /* Begin/end binning of a scene
 382  */
 383 void
 384 lp_scene_begin_binning( struct lp_scene *scene,
 385                         struct pipe_framebuffer_state *fb );
 386
 387 void
 388 lp_scene_end_binning( struct lp_scene *scene );
 389
 390
 391 /* Begin/end rasterization of a scene
 392  */
 393 void
 394 lp_scene_begin_rasterization(struct lp_scene *scene);
 395
 396 void
 397 lp_scene_end_rasterization(struct lp_scene *scene );
 398
 399
 400
 401
 402
 403 #endif /* LP_BIN_H */