1 /**************************************************************************
3 * Copyright 2009 VMware, Inc.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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.
26 **************************************************************************/
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.
38 #include "os/os_thread.h"
42 struct lp_scene_queue;
45 /* We're limited to 2K by 2K for 32bit fixed point rasterization.
46 * Will need a 64-bit version for larger framebuffers.
48 #define TILES_X (LP_MAX_WIDTH / TILE_SIZE)
49 #define TILES_Y (LP_MAX_HEIGHT / TILE_SIZE)
52 /* Commands per command block (ideally so sizeof(cmd_block) is a power of
55 #define CMD_BLOCK_MAX 29
57 /* Bytes per data block.
59 #define DATA_BLOCK_SIZE (64 * 1024)
61 /* Scene temporary storage is clamped to this size:
63 #define LP_SCENE_MAX_SIZE (9*1024*1024)
65 /* The maximum amount of texture storage referenced by a scene is
66 * clamped ot this size:
68 #define LP_SCENE_MAX_RESOURCE_SIZE (64*1024*1024)
71 /* switch to a non-pointer value for this:
73 typedef void (*lp_rast_cmd_func)( struct lp_rasterizer_task *,
74 const union lp_rast_cmd_arg );
78 uint8_t cmd[CMD_BLOCK_MAX];
79 union lp_rast_cmd_arg arg[CMD_BLOCK_MAX];
81 struct cmd_block *next;
86 ubyte data[DATA_BLOCK_SIZE];
88 struct data_block *next;
94 * For each screen tile we have one of these bins.
97 const struct lp_rast_state *last_state; /* most recent state set in bin */
98 struct cmd_block *head;
99 struct cmd_block *tail;
104 * This stores bulk data which is used for all memory allocations
107 * Examples include triangle data and state data. The commands in
108 * the per-tile bins will point to chunks of data in this structure.
110 * Include the first block of data statically to ensure we can always
111 * initiate a scene without relying on malloc succeeding.
113 struct data_block_list {
114 struct data_block first;
115 struct data_block *head;
121 * All bins and bin data are contained here.
122 * Per-bin data goes into the 'tile' bins.
123 * Shared data goes into the 'data' buffer.
125 * When there are multiple threads, will want to double-buffer between
129 struct pipe_context *pipe;
130 struct lp_fence *fence;
132 /* Framebuffer mappings - valid only between begin_rasterization()
133 * and end_rasterization().
138 unsigned layer_stride;
139 } zsbuf, cbufs[PIPE_MAX_COLOR_BUFS];
141 /* OpenGL permits different amount of layers per rt, but rendering limited to minimum */
142 unsigned fb_max_layer;
144 /** the framebuffer to render the scene into */
145 struct pipe_framebuffer_state fb;
147 /** list of resources referenced by the scene commands */
148 struct resource_ref *resources;
150 /** Total memory used by the scene (in bytes). This sums all the
151 * data blocks and counts all bins, state, resource references and
152 * other random allocations within the scene.
156 /** Sum of sizes of all resources referenced by the scene. Sums
157 * all the textures read by the scene:
159 unsigned resource_reference_size;
161 boolean alloc_failed;
162 boolean has_depthstencil_clear;
165 * Number of active tiles in each dimension.
166 * This basically the framebuffer size divided by tile size
168 unsigned tiles_x, tiles_y;
170 int curr_x, curr_y; /**< for iterating over bins */
173 struct cmd_bin tile[TILES_X][TILES_Y];
174 struct data_block_list data;
179 struct lp_scene *lp_scene_create(struct pipe_context *pipe);
181 void lp_scene_destroy(struct lp_scene *scene);
183 boolean lp_scene_is_empty(struct lp_scene *scene );
184 boolean lp_scene_is_oom(struct lp_scene *scene );
187 struct data_block *lp_scene_new_data_block( struct lp_scene *scene );
189 struct cmd_block *lp_scene_new_cmd_block( struct lp_scene *scene,
190 struct cmd_bin *bin );
192 boolean lp_scene_add_resource_reference(struct lp_scene *scene,
193 struct pipe_resource *resource,
194 boolean initializing_scene);
196 boolean lp_scene_is_resource_referenced(const struct lp_scene *scene,
197 const struct pipe_resource *resource );
201 * Allocate space for a command/data in the bin's data buffer.
202 * Grow the block list if needed.
205 lp_scene_alloc( struct lp_scene *scene, unsigned size)
207 struct data_block_list *list = &scene->data;
208 struct data_block *block = list->head;
210 assert(size <= DATA_BLOCK_SIZE);
211 assert(block != NULL);
213 if (LP_DEBUG & DEBUG_MEM)
214 debug_printf("alloc %u block %u/%u tot %u/%u\n",
215 size, block->used, DATA_BLOCK_SIZE,
216 scene->scene_size, LP_SCENE_MAX_SIZE);
218 if (block->used + size > DATA_BLOCK_SIZE) {
219 block = lp_scene_new_data_block( scene );
227 ubyte *data = block->data + block->used;
235 * As above, but with specific alignment.
238 lp_scene_alloc_aligned( struct lp_scene *scene, unsigned size,
241 struct data_block_list *list = &scene->data;
242 struct data_block *block = list->head;
244 assert(block != NULL);
246 if (LP_DEBUG & DEBUG_MEM)
247 debug_printf("alloc %u block %u/%u tot %u/%u\n",
248 size + alignment - 1,
249 block->used, DATA_BLOCK_SIZE,
250 scene->scene_size, LP_SCENE_MAX_SIZE);
252 if (block->used + size + alignment - 1 > DATA_BLOCK_SIZE) {
253 block = lp_scene_new_data_block( scene );
259 ubyte *data = block->data + block->used;
260 unsigned offset = (((uintptr_t)data + alignment - 1) & ~(alignment - 1)) - (uintptr_t)data;
261 block->used += offset + size;
262 return data + offset;
267 /* Put back data if we decide not to use it, eg. culled triangles.
270 lp_scene_putback_data( struct lp_scene *scene, unsigned size)
272 struct data_block_list *list = &scene->data;
273 assert(list->head && list->head->used >= size);
274 list->head->used -= size;
278 /** Return pointer to a particular tile's bin. */
279 static INLINE struct cmd_bin *
280 lp_scene_get_bin(struct lp_scene *scene, unsigned x, unsigned y)
282 return &scene->tile[x][y];
286 /** Remove all commands from a bin */
288 lp_scene_bin_reset(struct lp_scene *scene, unsigned x, unsigned y);
291 /* Add a command to bin[x][y].
293 static INLINE boolean
294 lp_scene_bin_command( struct lp_scene *scene,
295 unsigned x, unsigned y,
297 union lp_rast_cmd_arg arg )
299 struct cmd_bin *bin = lp_scene_get_bin(scene, x, y);
300 struct cmd_block *tail = bin->tail;
302 assert(x < scene->tiles_x);
303 assert(y < scene->tiles_y);
304 assert(cmd < LP_RAST_OP_MAX);
306 if (tail == NULL || tail->count == CMD_BLOCK_MAX) {
307 tail = lp_scene_new_cmd_block( scene, bin );
311 assert(tail->count == 0);
315 unsigned i = tail->count;
316 tail->cmd[i] = cmd & LP_RAST_OP_MASK;
325 static INLINE boolean
326 lp_scene_bin_cmd_with_state( struct lp_scene *scene,
327 unsigned x, unsigned y,
328 const struct lp_rast_state *state,
330 union lp_rast_cmd_arg arg )
332 struct cmd_bin *bin = lp_scene_get_bin(scene, x, y);
334 if (state != bin->last_state) {
335 bin->last_state = state;
336 if (!lp_scene_bin_command(scene, x, y,
337 LP_RAST_OP_SET_STATE,
338 lp_rast_arg_state(state)))
342 if (!lp_scene_bin_command( scene, x, y, cmd, arg ))
349 /* Add a command to all active bins.
351 static INLINE boolean
352 lp_scene_bin_everywhere( struct lp_scene *scene,
354 const union lp_rast_cmd_arg arg )
357 for (i = 0; i < scene->tiles_x; i++) {
358 for (j = 0; j < scene->tiles_y; j++) {
359 if (!lp_scene_bin_command( scene, i, j, cmd, arg ))
368 static INLINE unsigned
369 lp_scene_get_num_bins( const struct lp_scene *scene )
371 return scene->tiles_x * scene->tiles_y;
376 lp_scene_bin_iter_begin( struct lp_scene *scene );
379 lp_scene_bin_iter_next( struct lp_scene *scene, int *x, int *y );
383 /* Begin/end binning of a scene
386 lp_scene_begin_binning( struct lp_scene *scene,
387 struct pipe_framebuffer_state *fb,
391 lp_scene_end_binning( struct lp_scene *scene );
394 /* Begin/end rasterization of a scene
397 lp_scene_begin_rasterization(struct lp_scene *scene);
400 lp_scene_end_rasterization(struct lp_scene *scene );
406 #endif /* LP_BIN_H */