2 * Copyright © 2011 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
24 #include "main/macros.h"
25 #include "intel_batchbuffer.h"
26 #include "brw_context.h"
27 #include "brw_state.h"
28 #include "brw_defines.h"
31 * The following diagram shows how we partition the URB:
33 * 16kB or 32kB Rest of the URB space
34 * __________-__________ _________________-_________________
36 * +-------------------------------------------------------------+
37 * | VS/FS/GS Push | VS/GS URB |
38 * | Constants | Entries |
39 * +-------------------------------------------------------------+
41 * Notably, push constants must be stored at the beginning of the URB
42 * space, while entries can be stored anywhere. Ivybridge and Haswell
43 * GT1/GT2 have a maximum constant buffer size of 16kB, while Haswell GT3
44 * doubles this (32kB).
46 * Ivybridge and Haswell GT1/GT2 allow push constants to be located (and
47 * sized) in increments of 1kB. Haswell GT3 requires them to be located and
48 * sized in increments of 2kB.
50 * Currently we split the constant buffer space evenly among whatever stages
51 * are active. This is probably not ideal, but simple.
53 * Ivybridge GT1 and Haswell GT1 have 128kB of URB space.
54 * Ivybridge GT2 and Haswell GT2 have 256kB of URB space.
55 * Haswell GT3 has 512kB of URB space.
57 * See "Volume 2a: 3D Pipeline," section 1.8, "Volume 1b: Configurations",
58 * and the documentation for 3DSTATE_PUSH_CONSTANT_ALLOC_xS.
61 gen7_allocate_push_constants(struct brw_context
*brw
)
63 unsigned avail_size
= 16;
65 (brw
->gen
>= 8 || (brw
->is_haswell
&& brw
->gt
== 3)) ? 2 : 1;
67 /* BRW_NEW_GEOMETRY_PROGRAM */
68 bool gs_present
= brw
->geometry_program
;
70 unsigned vs_size
, gs_size
;
72 vs_size
= avail_size
/ 3;
73 avail_size
-= vs_size
;
74 gs_size
= avail_size
/ 2;
75 avail_size
-= gs_size
;
77 vs_size
= avail_size
/ 2;
78 avail_size
-= vs_size
;
81 unsigned fs_size
= avail_size
;
83 gen7_emit_push_constant_state(brw
, multiplier
* vs_size
,
84 multiplier
* gs_size
, multiplier
* fs_size
);
86 /* From p115 of the Ivy Bridge PRM (3.2.1.4 3DSTATE_PUSH_CONSTANT_ALLOC_VS):
88 * Programming Restriction:
90 * The 3DSTATE_CONSTANT_VS must be reprogrammed prior to the next
91 * 3DPRIMITIVE command after programming the
92 * 3DSTATE_PUSH_CONSTANT_ALLOC_VS.
94 * Similar text exists for the other 3DSTATE_PUSH_CONSTANT_ALLOC_*
97 brw
->state
.dirty
.brw
|= BRW_NEW_PUSH_CONSTANT_ALLOCATION
;
101 gen7_emit_push_constant_state(struct brw_context
*brw
, unsigned vs_size
,
102 unsigned gs_size
, unsigned fs_size
)
107 OUT_BATCH(_3DSTATE_PUSH_CONSTANT_ALLOC_VS
<< 16 | (2 - 2));
108 OUT_BATCH(vs_size
| offset
<< GEN7_PUSH_CONSTANT_BUFFER_OFFSET_SHIFT
);
111 OUT_BATCH(_3DSTATE_PUSH_CONSTANT_ALLOC_GS
<< 16 | (2 - 2));
112 OUT_BATCH(gs_size
| offset
<< GEN7_PUSH_CONSTANT_BUFFER_OFFSET_SHIFT
);
115 OUT_BATCH(_3DSTATE_PUSH_CONSTANT_ALLOC_PS
<< 16 | (2 - 2));
116 OUT_BATCH(fs_size
| offset
<< GEN7_PUSH_CONSTANT_BUFFER_OFFSET_SHIFT
);
119 /* From p292 of the Ivy Bridge PRM (11.2.4 3DSTATE_PUSH_CONSTANT_ALLOC_PS):
121 * A PIPE_CONTOL command with the CS Stall bit set must be programmed
122 * in the ring after this instruction.
124 * No such restriction exists for Haswell.
126 if (brw
->gen
< 8 && !brw
->is_haswell
)
127 gen7_emit_cs_stall_flush(brw
);
130 const struct brw_tracked_state gen7_push_constant_space
= {
133 .brw
= BRW_NEW_CONTEXT
| BRW_NEW_GEOMETRY_PROGRAM
,
136 .emit
= gen7_allocate_push_constants
,
140 gen7_upload_urb(struct brw_context
*brw
)
142 const int push_size_kB
=
143 (brw
->gen
>= 8 || (brw
->is_haswell
&& brw
->gt
== 3)) ? 32 : 16;
145 /* CACHE_NEW_VS_PROG */
146 unsigned vs_size
= MAX2(brw
->vs
.prog_data
->base
.urb_entry_size
, 1);
147 unsigned vs_entry_size_bytes
= vs_size
* 64;
148 /* BRW_NEW_GEOMETRY_PROGRAM, CACHE_NEW_GS_PROG */
149 bool gs_present
= brw
->geometry_program
;
150 unsigned gs_size
= gs_present
? brw
->gs
.prog_data
->base
.urb_entry_size
: 1;
151 unsigned gs_entry_size_bytes
= gs_size
* 64;
153 /* From p35 of the Ivy Bridge PRM (section 1.7.1: 3DSTATE_URB_GS):
155 * VS Number of URB Entries must be divisible by 8 if the VS URB Entry
156 * Allocation Size is less than 9 512-bit URB entries.
158 * Similar text exists for GS.
160 unsigned vs_granularity
= (vs_size
< 9) ? 8 : 1;
161 unsigned gs_granularity
= (gs_size
< 9) ? 8 : 1;
163 /* URB allocations must be done in 8k chunks. */
164 unsigned chunk_size_bytes
= 8192;
166 /* Determine the size of the URB in chunks.
168 unsigned urb_chunks
= brw
->urb
.size
* 1024 / chunk_size_bytes
;
170 /* Reserve space for push constants */
171 unsigned push_constant_bytes
= 1024 * push_size_kB
;
172 unsigned push_constant_chunks
=
173 push_constant_bytes
/ chunk_size_bytes
;
175 /* Initially, assign each stage the minimum amount of URB space it needs,
176 * and make a note of how much additional space it "wants" (the amount of
177 * additional space it could actually make use of).
180 /* VS has a lower limit on the number of URB entries */
182 ALIGN(brw
->urb
.min_vs_entries
* vs_entry_size_bytes
, chunk_size_bytes
) /
185 ALIGN(brw
->urb
.max_vs_entries
* vs_entry_size_bytes
,
186 chunk_size_bytes
) / chunk_size_bytes
- vs_chunks
;
188 unsigned gs_chunks
= 0;
189 unsigned gs_wants
= 0;
191 /* There are two constraints on the minimum amount of URB space we can
194 * (1) We need room for at least 2 URB entries, since we always operate
195 * the GS in DUAL_OBJECT mode.
197 * (2) We can't allocate less than nr_gs_entries_granularity.
199 gs_chunks
= ALIGN(MAX2(gs_granularity
, 2) * gs_entry_size_bytes
,
200 chunk_size_bytes
) / chunk_size_bytes
;
202 ALIGN(brw
->urb
.max_gs_entries
* gs_entry_size_bytes
,
203 chunk_size_bytes
) / chunk_size_bytes
- gs_chunks
;
206 /* There should always be enough URB space to satisfy the minimum
207 * requirements of each stage.
209 unsigned total_needs
= push_constant_chunks
+ vs_chunks
+ gs_chunks
;
210 assert(total_needs
<= urb_chunks
);
212 /* Mete out remaining space (if any) in proportion to "wants". */
213 unsigned total_wants
= vs_wants
+ gs_wants
;
214 unsigned remaining_space
= urb_chunks
- total_needs
;
215 if (remaining_space
> total_wants
)
216 remaining_space
= total_wants
;
217 if (remaining_space
> 0) {
218 unsigned vs_additional
= (unsigned)
219 round(vs_wants
* (((double) remaining_space
) / total_wants
));
220 vs_chunks
+= vs_additional
;
221 remaining_space
-= vs_additional
;
222 gs_chunks
+= remaining_space
;
225 /* Sanity check that we haven't over-allocated. */
226 assert(push_constant_chunks
+ vs_chunks
+ gs_chunks
<= urb_chunks
);
228 /* Finally, compute the number of entries that can fit in the space
229 * allocated to each stage.
231 unsigned nr_vs_entries
= vs_chunks
* chunk_size_bytes
/ vs_entry_size_bytes
;
232 unsigned nr_gs_entries
= gs_chunks
* chunk_size_bytes
/ gs_entry_size_bytes
;
234 /* Since we rounded up when computing *_wants, this may be slightly more
235 * than the maximum allowed amount, so correct for that.
237 nr_vs_entries
= MIN2(nr_vs_entries
, brw
->urb
.max_vs_entries
);
238 nr_gs_entries
= MIN2(nr_gs_entries
, brw
->urb
.max_gs_entries
);
240 /* Ensure that we program a multiple of the granularity. */
241 nr_vs_entries
= ROUND_DOWN_TO(nr_vs_entries
, vs_granularity
);
242 nr_gs_entries
= ROUND_DOWN_TO(nr_gs_entries
, gs_granularity
);
244 /* Finally, sanity check to make sure we have at least the minimum number
245 * of entries needed for each stage.
247 assert(nr_vs_entries
>= brw
->urb
.min_vs_entries
);
249 assert(nr_gs_entries
>= 2);
251 /* Gen7 doesn't actually use brw->urb.nr_{vs,gs}_entries, but it seems
252 * better to put reasonable data in there rather than leave them
255 brw
->urb
.nr_vs_entries
= nr_vs_entries
;
256 brw
->urb
.nr_gs_entries
= nr_gs_entries
;
258 /* Lay out the URB in the following order:
263 brw
->urb
.vs_start
= push_constant_chunks
;
264 brw
->urb
.gs_start
= push_constant_chunks
+ vs_chunks
;
266 if (brw
->gen
== 7 && !brw
->is_haswell
)
267 gen7_emit_vs_workaround_flush(brw
);
268 gen7_emit_urb_state(brw
,
269 brw
->urb
.nr_vs_entries
, vs_size
, brw
->urb
.vs_start
,
270 brw
->urb
.nr_gs_entries
, gs_size
, brw
->urb
.gs_start
);
274 gen7_emit_urb_state(struct brw_context
*brw
,
275 unsigned nr_vs_entries
, unsigned vs_size
,
276 unsigned vs_start
, unsigned nr_gs_entries
,
277 unsigned gs_size
, unsigned gs_start
)
280 OUT_BATCH(_3DSTATE_URB_VS
<< 16 | (2 - 2));
281 OUT_BATCH(nr_vs_entries
|
282 ((vs_size
- 1) << GEN7_URB_ENTRY_SIZE_SHIFT
) |
283 (vs_start
<< GEN7_URB_STARTING_ADDRESS_SHIFT
));
285 OUT_BATCH(_3DSTATE_URB_GS
<< 16 | (2 - 2));
286 OUT_BATCH(nr_gs_entries
|
287 ((gs_size
- 1) << GEN7_URB_ENTRY_SIZE_SHIFT
) |
288 (gs_start
<< GEN7_URB_STARTING_ADDRESS_SHIFT
));
290 /* Allocate the HS and DS zero space - we don't use them. */
291 OUT_BATCH(_3DSTATE_URB_HS
<< 16 | (2 - 2));
292 OUT_BATCH((0 << GEN7_URB_ENTRY_SIZE_SHIFT
) |
293 (vs_start
<< GEN7_URB_STARTING_ADDRESS_SHIFT
));
295 OUT_BATCH(_3DSTATE_URB_DS
<< 16 | (2 - 2));
296 OUT_BATCH((0 << GEN7_URB_ENTRY_SIZE_SHIFT
) |
297 (vs_start
<< GEN7_URB_STARTING_ADDRESS_SHIFT
));
301 const struct brw_tracked_state gen7_urb
= {
304 .brw
= BRW_NEW_CONTEXT
| BRW_NEW_GEOMETRY_PROGRAM
,
305 .cache
= (CACHE_NEW_VS_PROG
| CACHE_NEW_GS_PROG
),
307 .emit
= gen7_upload_urb
,