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 "util/u_thread.h"
39 #include "lp_rast.h"
40 #include "lp_debug.h"
41
42 struct lp_scene_queue;
43 struct lp_rast_state;
44
45 /* We're limited to 2K by 2K for 32bit fixed point rasterization.
46 * Will need a 64-bit version for larger framebuffers.
47 */
48 #define TILES_X (LP_MAX_WIDTH / TILE_SIZE)
49 #define TILES_Y (LP_MAX_HEIGHT / TILE_SIZE)
50
51
52 /* Commands per command block (ideally so sizeof(cmd_block) is a power of
53 * two in size.)
54 */
55 #define CMD_BLOCK_MAX 29
56
57 /* Bytes per data block. This effectively limits the maximum constant buffer
58 * size.
59 */
60 #define DATA_BLOCK_SIZE (64 * 1024)
61
62 /* Scene temporary storage is clamped to this size:
63 */
64 #define LP_SCENE_MAX_SIZE (36*1024*1024)
65
66 /* The maximum amount of texture storage referenced by a scene is
67 * clamped to this size:
68 */
69 #define LP_SCENE_MAX_RESOURCE_SIZE (64*1024*1024)
70
71
72 /* switch to a non-pointer value for this:
73 */
74 typedef void (*lp_rast_cmd_func)(struct lp_rasterizer_task *,
75 const union lp_rast_cmd_arg);
76
77
78 struct cmd_block {
79 uint8_t cmd[CMD_BLOCK_MAX]; // LP_RAST_OP_x
80 union lp_rast_cmd_arg arg[CMD_BLOCK_MAX];
81 unsigned count;
82 struct cmd_block *next;
83 };
84
85
86 struct data_block {
87 uint8_t data[DATA_BLOCK_SIZE];
88 unsigned used;
89 struct data_block *next;
90 };
91
92
93
94 /**
95 * For each screen tile we have one of these bins.
96 */
97 struct cmd_bin {
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 struct shader_ref;
122
123 struct lp_scene_surface {
124 uint8_t *map;
125 unsigned stride;
126 unsigned layer_stride;
127 unsigned format_bytes;
128 unsigned sample_stride;
129 unsigned nr_samples;
130 };
131
132
133 /**
134 * All bins and bin data are contained here.
135 * Per-bin data goes into the 'tile' bins.
136 * Shared data goes into the 'data' buffer.
137 *
138 * When there are multiple threads, will want to double-buffer between
139 * scenes:
140 */
141 struct lp_scene {
142 struct pipe_context *pipe;
143 struct lp_fence *fence;
144 struct lp_setup_context *setup;
145
146 /* The queries still active at end of scene */
147 struct llvmpipe_query *active_queries[LP_MAX_ACTIVE_BINNED_QUERIES];
148 unsigned num_active_queries;
149 /* If queries were either active or there were begin/end query commands */
150 bool had_queries;
151
152 /* Framebuffer mappings - valid only between begin_rasterization()
153 * and end_rasterization().
154 */
155 struct lp_scene_surface zsbuf, cbufs[PIPE_MAX_COLOR_BUFS];
156
157 /* The amount of layers in the fb (minimum of all attachments) */
158 unsigned fb_max_layer;
159
160 /* fixed point sample positions. */
161 int32_t fixed_sample_pos[LP_MAX_SAMPLES][2];
162
163 /* max samples for bound framebuffer */
164 unsigned fb_max_samples;
165
166 /** the framebuffer to render the scene into */
167 struct pipe_framebuffer_state fb;
168
169 /** list of resources referenced by the scene commands */
170 struct resource_ref *resources;
171
172 /** list of writable resources referenced by the scene commands */
173 struct resource_ref *writeable_resources;
174
175 /** list of frag shaders referenced by the scene commands */
176 struct shader_ref *frag_shaders;
177
178 /** Total memory used by the scene (in bytes). This sums all the
179 * data blocks and counts all bins, state, resource references and
180 * other random allocations within the scene.
181 */
182 unsigned scene_size;
183
184 /** Sum of sizes of all resources referenced by the scene. Sums
185 * all the textures read by the scene:
186 */
187 unsigned resource_reference_size;
188
189 bool alloc_failed;
190 bool permit_linear_rasterizer;
191
192 /**
193 * Number of active tiles in each dimension.
194 * This basically the framebuffer size divided by tile size
195 */
196 unsigned tiles_x, tiles_y;
197
198 int curr_x, curr_y; /**< for iterating over bins */
199 mtx_t mutex;
200
201 unsigned num_alloced_tiles;
202 struct cmd_bin *tiles;
203 struct data_block_list data;
204 };
205
206
207
208 struct lp_scene *lp_scene_create(struct lp_setup_context *setup);
209
210 void lp_scene_destroy(struct lp_scene *scene);
211
212 bool lp_scene_is_empty(struct lp_scene *scene);
213
214 bool lp_scene_is_oom(struct lp_scene *scene);
215
216 struct data_block *lp_scene_new_data_block(struct lp_scene *scene);
217
218 struct cmd_block *lp_scene_new_cmd_block(struct lp_scene *scene,
219 struct cmd_bin *bin);
220
221 bool lp_scene_add_resource_reference(struct lp_scene *scene,
222 struct pipe_resource *resource,
223 bool initializing_scene,
224 bool writeable);
225
226 unsigned lp_scene_is_resource_referenced(const struct lp_scene *scene,
227 const struct pipe_resource *resource);
228
229 bool lp_scene_add_frag_shader_reference(struct lp_scene *scene,
230 struct lp_fragment_shader_variant *variant);
231
232
233
234 /**
235 * Allocate space for a command/data in the bin's data buffer.
236 * Grow the block list if needed.
237 */
238 static inline void *
lp_scene_alloc(struct lp_scene * scene,unsigned size)239 lp_scene_alloc(struct lp_scene *scene, unsigned size)
240 {
241 struct data_block_list *list = &scene->data;
242 struct data_block *block = list->head;
243
244 assert(size <= DATA_BLOCK_SIZE);
245 assert(block != NULL);
246
247 if (LP_DEBUG & DEBUG_MEM)
248 debug_printf("alloc %u block %u/%u tot %u/%u\n",
249 size, block->used, (unsigned)DATA_BLOCK_SIZE,
250 scene->scene_size, LP_SCENE_MAX_SIZE);
251
252 if (block->used + size > DATA_BLOCK_SIZE) {
253 block = lp_scene_new_data_block(scene);
254 if (!block) {
255 /* out of memory */
256 return NULL;
257 }
258 }
259
260 {
261 uint8_t *data = block->data + block->used;
262 block->used += size;
263 return data;
264 }
265 }
266
267
268 /**
269 * As above, but with specific alignment.
270 */
271 static inline void *
lp_scene_alloc_aligned(struct lp_scene * scene,unsigned size,unsigned alignment)272 lp_scene_alloc_aligned(struct lp_scene *scene, unsigned size,
273 unsigned alignment)
274 {
275 struct data_block_list *list = &scene->data;
276 struct data_block *block = list->head;
277
278 assert(block != NULL);
279
280 if (LP_DEBUG & DEBUG_MEM)
281 debug_printf("alloc %u block %u/%u tot %u/%u\n",
282 size + alignment - 1,
283 block->used, (unsigned)DATA_BLOCK_SIZE,
284 scene->scene_size, LP_SCENE_MAX_SIZE);
285
286 if (block->used + size + alignment - 1 > DATA_BLOCK_SIZE) {
287 block = lp_scene_new_data_block(scene);
288 if (!block)
289 return NULL;
290 }
291
292 {
293 uint8_t *data = block->data + block->used;
294 unsigned offset = (((uintptr_t)data + alignment - 1) & ~(alignment - 1)) - (uintptr_t)data;
295 block->used += offset + size;
296 return data + offset;
297 }
298 }
299
300
301 /** Return pointer to a particular tile's bin. */
302 static inline struct cmd_bin *
lp_scene_get_bin(struct lp_scene * scene,unsigned x,unsigned y)303 lp_scene_get_bin(struct lp_scene *scene, unsigned x, unsigned y)
304 {
305 unsigned idx = scene->tiles_x * y + x;
306 return &scene->tiles[idx];
307 }
308
309
310 /** Remove all commands from a bin */
311 void
312 lp_scene_bin_reset(struct lp_scene *scene, unsigned x, unsigned y);
313
314
315 /* Add a command to bin[x][y].
316 */
317 static inline bool
lp_scene_bin_command(struct lp_scene * scene,unsigned x,unsigned y,enum lp_rast_op cmd,union lp_rast_cmd_arg arg)318 lp_scene_bin_command(struct lp_scene *scene,
319 unsigned x, unsigned y,
320 enum lp_rast_op cmd,
321 union lp_rast_cmd_arg arg)
322 {
323 struct cmd_bin *bin = lp_scene_get_bin(scene, x, y);
324 struct cmd_block *tail = bin->tail;
325
326 assert(x < scene->tiles_x);
327 assert(y < scene->tiles_y);
328 assert(cmd < LP_RAST_OP_MAX);
329
330 if (tail == NULL || tail->count == CMD_BLOCK_MAX) {
331 tail = lp_scene_new_cmd_block(scene, bin);
332 if (!tail) {
333 return false;
334 }
335 assert(tail->count == 0);
336 }
337
338 {
339 unsigned i = tail->count;
340 tail->cmd[i] = cmd & LP_RAST_OP_MASK;
341 tail->arg[i] = arg;
342 tail->count++;
343 }
344
345 return true;
346 }
347
348
349 static inline bool
lp_scene_bin_cmd_with_state(struct lp_scene * scene,unsigned x,unsigned y,const struct lp_rast_state * state,enum lp_rast_op cmd,union lp_rast_cmd_arg arg)350 lp_scene_bin_cmd_with_state(struct lp_scene *scene,
351 unsigned x, unsigned y,
352 const struct lp_rast_state *state,
353 enum lp_rast_op cmd,
354 union lp_rast_cmd_arg arg)
355 {
356 struct cmd_bin *bin = lp_scene_get_bin(scene, x, y);
357
358 if (state != bin->last_state) {
359 bin->last_state = state;
360 if (!lp_scene_bin_command(scene, x, y,
361 LP_RAST_OP_SET_STATE,
362 lp_rast_arg_state(state)))
363 return false;
364 }
365
366 if (!lp_scene_bin_command(scene, x, y, cmd, arg))
367 return false;
368
369 return true;
370 }
371
372
373 /* Add a command to all active bins.
374 */
375 static inline bool
lp_scene_bin_everywhere(struct lp_scene * scene,enum lp_rast_op cmd,const union lp_rast_cmd_arg arg)376 lp_scene_bin_everywhere(struct lp_scene *scene,
377 enum lp_rast_op cmd,
378 const union lp_rast_cmd_arg arg)
379 {
380 for (unsigned i = 0; i < scene->tiles_x; i++) {
381 for (unsigned j = 0; j < scene->tiles_y; j++) {
382 if (!lp_scene_bin_command(scene, i, j, cmd, arg))
383 return false;
384 }
385 }
386
387 return true;
388 }
389
390
391 static inline unsigned
lp_scene_get_num_bins(const struct lp_scene * scene)392 lp_scene_get_num_bins(const struct lp_scene *scene)
393 {
394 return scene->tiles_x * scene->tiles_y;
395 }
396
397
398 void
399 lp_scene_bin_iter_begin(struct lp_scene *scene);
400
401 struct cmd_bin *
402 lp_scene_bin_iter_next(struct lp_scene *scene, int *x, int *y);
403
404
405
406 /* Begin/end binning of a scene
407 */
408 void
409 lp_scene_begin_binning(struct lp_scene *scene,
410 struct pipe_framebuffer_state *fb);
411
412 void
413 lp_scene_end_binning(struct lp_scene *scene);
414
415
416 /* Begin/end rasterization of a scene
417 */
418 void
419 lp_scene_begin_rasterization(struct lp_scene *scene);
420
421 void
422 lp_scene_end_rasterization(struct lp_scene *scene);
423
424
425 #endif /* LP_SCENE_H */
426