2 * Copyright © 2013 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
21 * DEALINGS IN THE SOFTWARE.
27 * State atom for client-programmable geometry shaders, and support code.
31 #include "brw_context.h"
32 #include "brw_vec4_gs_visitor.h"
33 #include "brw_state.h"
34 #include "brw_ff_gs.h"
37 brw_compile_gs_prog(struct brw_context
*brw
,
38 struct gl_shader_program
*prog
,
39 struct brw_geometry_program
*gp
,
40 struct brw_gs_prog_key
*key
,
41 struct brw_gs_compile_output
*output
)
43 struct brw_gs_compile c
;
44 memset(&c
, 0, sizeof(c
));
48 /* We get the bind map as input in the output struct...*/
49 c
.prog_data
.base
.base
.map_entries
= output
->prog_data
.base
.base
.map_entries
;
50 memcpy(c
.prog_data
.base
.base
.bind_map
, output
->prog_data
.base
.base
.bind_map
,
51 sizeof(c
.prog_data
.base
.base
.bind_map
));
53 c
.prog_data
.include_primitive_id
=
54 (gp
->program
.Base
.InputsRead
& VARYING_BIT_PRIMITIVE_ID
) != 0;
56 c
.prog_data
.invocations
= gp
->program
.Invocations
;
58 /* Allocate the references to the uniforms that will end up in the
59 * prog_data associated with the compiled program, and which will be freed
62 * Note: param_count needs to be num_uniform_components * 4, since we add
63 * padding around uniform values below vec4 size, so the worst case is that
64 * every uniform is a float which gets padded to the size of a vec4.
66 struct gl_shader
*gs
= prog
->_LinkedShaders
[MESA_SHADER_GEOMETRY
];
67 int param_count
= gs
->num_uniform_components
* 4;
69 /* We also upload clip plane data as uniforms */
70 param_count
+= MAX_CLIP_PLANES
* 4;
71 param_count
+= gs
->NumImages
* BRW_IMAGE_PARAM_SIZE
;
73 c
.prog_data
.base
.base
.param
=
74 rzalloc_array(NULL
, const gl_constant_value
*, param_count
);
75 c
.prog_data
.base
.base
.pull_param
=
76 rzalloc_array(NULL
, const gl_constant_value
*, param_count
);
77 c
.prog_data
.base
.base
.image_param
=
78 rzalloc_array(NULL
, struct brw_image_param
, gs
->NumImages
);
79 c
.prog_data
.base
.base
.nr_params
= param_count
;
80 c
.prog_data
.base
.base
.nr_image_params
= gs
->NumImages
;
83 if (gp
->program
.OutputType
== GL_POINTS
) {
84 /* When the output type is points, the geometry shader may output data
85 * to multiple streams, and EndPrimitive() has no effect. So we
86 * configure the hardware to interpret the control data as stream ID.
88 c
.prog_data
.control_data_format
= GEN7_GS_CONTROL_DATA_FORMAT_GSCTL_SID
;
90 /* We only have to emit control bits if we are using streams */
91 if (prog
->Geom
.UsesStreams
)
92 c
.control_data_bits_per_vertex
= 2;
94 c
.control_data_bits_per_vertex
= 0;
96 /* When the output type is triangle_strip or line_strip, EndPrimitive()
97 * may be used to terminate the current strip and start a new one
98 * (similar to primitive restart), and outputting data to multiple
99 * streams is not supported. So we configure the hardware to interpret
100 * the control data as EndPrimitive information (a.k.a. "cut bits").
102 c
.prog_data
.control_data_format
= GEN7_GS_CONTROL_DATA_FORMAT_GSCTL_CUT
;
104 /* We only need to output control data if the shader actually calls
107 c
.control_data_bits_per_vertex
= gp
->program
.UsesEndPrimitive
? 1 : 0;
110 /* There are no control data bits in gen6. */
111 c
.control_data_bits_per_vertex
= 0;
113 /* If it is using transform feedback, enable it */
114 if (prog
->TransformFeedback
.NumVarying
)
115 c
.prog_data
.gen6_xfb_enabled
= true;
117 c
.prog_data
.gen6_xfb_enabled
= false;
119 c
.control_data_header_size_bits
=
120 gp
->program
.VerticesOut
* c
.control_data_bits_per_vertex
;
122 /* 1 HWORD = 32 bytes = 256 bits */
123 c
.prog_data
.control_data_header_size_hwords
=
124 ALIGN(c
.control_data_header_size_bits
, 256) / 256;
126 GLbitfield64 outputs_written
= gp
->program
.Base
.OutputsWritten
;
128 /* In order for legacy clipping to work, we need to populate the clip
129 * distance varying slots whenever clipping is enabled, even if the vertex
130 * shader doesn't write to gl_ClipDistance.
132 if (c
.key
.base
.userclip_active
) {
133 outputs_written
|= BITFIELD64_BIT(VARYING_SLOT_CLIP_DIST0
);
134 outputs_written
|= BITFIELD64_BIT(VARYING_SLOT_CLIP_DIST1
);
137 brw_compute_vue_map(brw
->intelScreen
->devinfo
,
138 &c
.prog_data
.base
.vue_map
, outputs_written
);
140 /* Compute the output vertex size.
142 * From the Ivy Bridge PRM, Vol2 Part1 7.2.1.1 STATE_GS - Output Vertex
145 * [0,62] indicating [1,63] 16B units
147 * Specifies the size of each vertex stored in the GS output entry
148 * (following any Control Header data) as a number of 128-bit units
151 * Programming Restrictions: The vertex size must be programmed as a
152 * multiple of 32B units with the following exception: Rendering is
153 * disabled (as per SOL stage state) and the vertex size output by the
156 * If rendering is enabled (as per SOL state) the vertex size must be
157 * programmed as a multiple of 32B units. In other words, the only time
158 * software can program a vertex size with an odd number of 16B units
159 * is when rendering is disabled.
161 * Note: B=bytes in the above text.
163 * It doesn't seem worth the extra trouble to optimize the case where the
164 * vertex size is 16B (especially since this would require special-casing
165 * the GEN assembly that writes to the URB). So we just set the vertex
166 * size to a multiple of 32B (2 vec4's) in all cases.
168 * The maximum output vertex size is 62*16 = 992 bytes (31 hwords). We
169 * budget that as follows:
171 * 512 bytes for varyings (a varying component is 4 bytes and
172 * gl_MaxGeometryOutputComponents = 128)
173 * 16 bytes overhead for VARYING_SLOT_PSIZ (each varying slot is 16
175 * 16 bytes overhead for gl_Position (we allocate it a slot in the VUE
176 * even if it's not used)
177 * 32 bytes overhead for gl_ClipDistance (we allocate it 2 VUE slots
178 * whenever clip planes are enabled, even if the shader doesn't
179 * write to gl_ClipDistance)
180 * 16 bytes overhead since the VUE size must be a multiple of 32 bytes
181 * (see below)--this causes up to 1 VUE slot to be wasted
182 * 400 bytes available for varying packing overhead
184 * Worst-case varying packing overhead is 3/4 of a varying slot (12 bytes)
185 * per interpolation type, so this is plenty.
188 unsigned output_vertex_size_bytes
= c
.prog_data
.base
.vue_map
.num_slots
* 16;
189 assert(brw
->gen
== 6 ||
190 output_vertex_size_bytes
<= GEN7_MAX_GS_OUTPUT_VERTEX_SIZE_BYTES
);
191 c
.prog_data
.output_vertex_size_hwords
=
192 ALIGN(output_vertex_size_bytes
, 32) / 32;
194 /* Compute URB entry size. The maximum allowed URB entry size is 32k.
195 * That divides up as follows:
197 * 64 bytes for the control data header (cut indices or StreamID bits)
198 * 4096 bytes for varyings (a varying component is 4 bytes and
199 * gl_MaxGeometryTotalOutputComponents = 1024)
200 * 4096 bytes overhead for VARYING_SLOT_PSIZ (each varying slot is 16
201 * bytes/vertex and gl_MaxGeometryOutputVertices is 256)
202 * 4096 bytes overhead for gl_Position (we allocate it a slot in the VUE
203 * even if it's not used)
204 * 8192 bytes overhead for gl_ClipDistance (we allocate it 2 VUE slots
205 * whenever clip planes are enabled, even if the shader doesn't
206 * write to gl_ClipDistance)
207 * 4096 bytes overhead since the VUE size must be a multiple of 32
208 * bytes (see above)--this causes up to 1 VUE slot to be wasted
209 * 8128 bytes available for varying packing overhead
211 * Worst-case varying packing overhead is 3/4 of a varying slot per
212 * interpolation type, which works out to 3072 bytes, so this would allow
213 * us to accommodate 2 interpolation types without any danger of running
216 * In practice, the risk of running out of URB space is very small, since
217 * the above figures are all worst-case, and most of them scale with the
218 * number of output vertices. So we'll just calculate the amount of space
219 * we need, and if it's too large, fail to compile.
221 * The above is for gen7+ where we have a single URB entry that will hold
222 * all the output. In gen6, we will have to allocate URB entries for every
223 * vertex we emit, so our URB entries only need to be large enough to hold
224 * a single vertex. Also, gen6 does not have a control data header.
226 unsigned output_size_bytes
;
229 c
.prog_data
.output_vertex_size_hwords
* 32 * gp
->program
.VerticesOut
;
230 output_size_bytes
+= 32 * c
.prog_data
.control_data_header_size_hwords
;
232 output_size_bytes
= c
.prog_data
.output_vertex_size_hwords
* 32;
235 /* Broadwell stores "Vertex Count" as a full 8 DWord (32 byte) URB output,
236 * which comes before the control header.
239 output_size_bytes
+= 32;
241 assert(output_size_bytes
>= 1);
242 int max_output_size_bytes
= GEN7_MAX_GS_URB_ENTRY_SIZE_BYTES
;
244 max_output_size_bytes
= GEN6_MAX_GS_URB_ENTRY_SIZE_BYTES
;
245 if (output_size_bytes
> max_output_size_bytes
)
249 /* URB entry sizes are stored as a multiple of 64 bytes in gen7+ and
250 * a multiple of 128 bytes in gen6.
253 c
.prog_data
.base
.urb_entry_size
= ALIGN(output_size_bytes
, 64) / 64;
255 c
.prog_data
.base
.urb_entry_size
= ALIGN(output_size_bytes
, 128) / 128;
257 c
.prog_data
.output_topology
=
258 get_hw_prim_for_gl_prim(gp
->program
.OutputType
);
260 brw_compute_vue_map(brw
->intelScreen
->devinfo
,
261 &c
.input_vue_map
, c
.key
.input_varyings
);
263 /* GS inputs are read from the VUE 256 bits (2 vec4's) at a time, so we
264 * need to program a URB read length of ceiling(num_slots / 2).
266 c
.prog_data
.base
.urb_read_length
= (c
.input_vue_map
.num_slots
+ 1) / 2;
268 void *mem_ctx
= ralloc_context(NULL
);
269 unsigned program_size
;
270 const unsigned *program
=
271 brw_gs_emit(brw
, prog
, &c
, mem_ctx
, &program_size
);
272 if (program
== NULL
) {
273 ralloc_free(mem_ctx
);
277 output
->mem_ctx
= mem_ctx
;
278 output
->program
= program
;
279 output
->program_size
= program_size
;
280 memcpy(&output
->prog_data
, &c
.prog_data
,
281 sizeof(output
->prog_data
));
287 brw_codegen_gs_prog(struct brw_context
*brw
,
288 struct gl_shader_program
*prog
,
289 struct brw_geometry_program
*gp
,
290 struct brw_gs_prog_key
*key
)
292 struct brw_gs_compile_output output
;
293 struct brw_stage_state
*stage_state
= &brw
->gs
.base
;
295 if (brw_compile_gs_prog(brw
, prog
, gp
, key
, &output
))
298 if (output
.prog_data
.base
.base
.total_scratch
) {
299 brw_get_scratch_bo(brw
, &stage_state
->scratch_bo
,
300 output
.prog_data
.base
.base
.total_scratch
*
301 brw
->max_gs_threads
);
304 brw_upload_cache(&brw
->cache
, BRW_CACHE_GS_PROG
,
306 output
.program
, output
.program_size
,
307 &output
.prog_data
, sizeof(output
.prog_data
),
308 &stage_state
->prog_offset
, &brw
->gs
.prog_data
);
309 ralloc_free(output
.mem_ctx
);
315 brw_gs_state_dirty(struct brw_context
*brw
)
317 return brw_state_dirty(brw
,
319 BRW_NEW_GEOMETRY_PROGRAM
|
320 BRW_NEW_TRANSFORM_FEEDBACK
|
325 brw_gs_populate_key(struct brw_context
*brw
,
326 struct brw_gs_prog_key
*key
)
328 struct gl_context
*ctx
= &brw
->ctx
;
329 struct brw_stage_state
*stage_state
= &brw
->gs
.base
;
330 struct brw_geometry_program
*gp
=
331 (struct brw_geometry_program
*) brw
->geometry_program
;
332 struct gl_program
*prog
= &gp
->program
.Base
;
334 memset(key
, 0, sizeof(*key
));
336 key
->base
.program_string_id
= gp
->id
;
337 brw_setup_vue_key_clip_info(brw
, &key
->base
,
338 gp
->program
.Base
.UsesClipDistanceOut
);
341 brw_populate_sampler_prog_key_data(ctx
, prog
, stage_state
->sampler_count
,
344 /* BRW_NEW_VUE_MAP_VS */
345 key
->input_varyings
= brw
->vue_map_vs
.slots_valid
;
349 brw_upload_gs_prog(struct brw_context
*brw
)
351 struct gl_context
*ctx
= &brw
->ctx
;
352 struct gl_shader_program
**current
= ctx
->_Shader
->CurrentProgram
;
353 struct brw_stage_state
*stage_state
= &brw
->gs
.base
;
354 struct brw_gs_prog_key key
;
355 /* BRW_NEW_GEOMETRY_PROGRAM */
356 struct brw_geometry_program
*gp
=
357 (struct brw_geometry_program
*) brw
->geometry_program
;
359 if (!brw_gs_state_dirty(brw
))
363 /* No geometry shader. Vertex data just passes straight through. */
364 if (brw
->ctx
.NewDriverState
& BRW_NEW_VUE_MAP_VS
) {
365 brw
->vue_map_geom_out
= brw
->vue_map_vs
;
366 brw
->ctx
.NewDriverState
|= BRW_NEW_VUE_MAP_GEOM_OUT
;
370 (brw
->ctx
.NewDriverState
& BRW_NEW_TRANSFORM_FEEDBACK
)) {
371 gen6_brw_upload_ff_gs_prog(brw
);
375 /* Other state atoms had better not try to access prog_data, since
376 * there's no GS program.
378 brw
->gs
.prog_data
= NULL
;
379 brw
->gs
.base
.prog_data
= NULL
;
384 brw_gs_populate_key(brw
, &key
);
386 if (!brw_search_cache(&brw
->cache
, BRW_CACHE_GS_PROG
,
388 &stage_state
->prog_offset
, &brw
->gs
.prog_data
)) {
389 bool success
= brw_codegen_gs_prog(brw
, current
[MESA_SHADER_GEOMETRY
],
394 brw
->gs
.base
.prog_data
= &brw
->gs
.prog_data
->base
.base
;
396 if (memcmp(&brw
->gs
.prog_data
->base
.vue_map
, &brw
->vue_map_geom_out
,
397 sizeof(brw
->vue_map_geom_out
)) != 0) {
398 brw
->vue_map_geom_out
= brw
->gs
.prog_data
->base
.vue_map
;
399 brw
->ctx
.NewDriverState
|= BRW_NEW_VUE_MAP_GEOM_OUT
;
404 brw_gs_precompile(struct gl_context
*ctx
,
405 struct gl_shader_program
*shader_prog
,
406 struct gl_program
*prog
)
408 struct brw_context
*brw
= brw_context(ctx
);
409 struct brw_gs_prog_key key
;
410 uint32_t old_prog_offset
= brw
->gs
.base
.prog_offset
;
411 struct brw_gs_prog_data
*old_prog_data
= brw
->gs
.prog_data
;
414 struct gl_geometry_program
*gp
= (struct gl_geometry_program
*) prog
;
415 struct brw_geometry_program
*bgp
= brw_geometry_program(gp
);
417 memset(&key
, 0, sizeof(key
));
419 brw_vue_setup_prog_key_for_precompile(ctx
, &key
.base
, bgp
->id
, &gp
->Base
);
421 /* Assume that the set of varyings coming in from the vertex shader exactly
422 * matches what the geometry shader requires.
424 key
.input_varyings
= gp
->Base
.InputsRead
;
426 success
= brw_codegen_gs_prog(brw
, shader_prog
, bgp
, &key
);
428 brw
->gs
.base
.prog_offset
= old_prog_offset
;
429 brw
->gs
.prog_data
= old_prog_data
;
436 brw_gs_prog_data_compare(const void *in_a
, const void *in_b
)
438 const struct brw_gs_prog_data
*a
= in_a
;
439 const struct brw_gs_prog_data
*b
= in_b
;
441 /* Compare the base structure. */
442 if (!brw_stage_prog_data_compare(&a
->base
.base
, &b
->base
.base
))
445 /* Compare the rest of the struct. */
446 const unsigned offset
= sizeof(struct brw_stage_prog_data
);
447 if (memcmp(((char *) a
) + offset
, ((char *) b
) + offset
,
448 sizeof(struct brw_gs_prog_data
) - offset
)) {