2 * Copyright (C) 2014 Rob Clark <robclark@freedesktop.org>
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 FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24 * Rob Clark <robclark@freedesktop.org>
27 #include "pipe/p_state.h"
28 #include "pipe/p_screen.h"
29 #include "util/u_string.h"
30 #include "util/u_memory.h"
31 #include "util/u_inlines.h"
32 #include "util/format/u_format.h"
33 #include "tgsi/tgsi_dump.h"
34 #include "tgsi/tgsi_parse.h"
36 #include "nir/tgsi_to_nir.h"
38 #include "freedreno_context.h"
39 #include "freedreno_util.h"
41 #include "ir3/ir3_shader.h"
42 #include "ir3/ir3_gallium.h"
43 #include "ir3/ir3_compiler.h"
44 #include "ir3/ir3_nir.h"
47 dump_shader_info(struct ir3_shader_variant
*v
, struct pipe_debug_callback
*debug
)
49 if (!unlikely(fd_mesa_debug
& FD_DBG_SHADERDB
))
52 pipe_debug_message(debug
, SHADER_INFO
,
53 "%s shader: %u inst, %u nops, %u non-nops, %u mov, %u cov, "
54 "%u dwords, %u last-baryf, %u half, %u full, %u constlen, "
55 "%u sstall, %u (ss), %u (sy), %d max_sun, %d loops\n",
59 v
->info
.instrs_count
- v
->info
.nops_count
,
64 v
->info
.max_half_reg
+ 1,
68 v
->info
.ss
, v
->info
.sy
,
69 v
->max_sun
, v
->loops
);
73 upload_shader_variant(struct ir3_shader_variant
*v
)
75 struct shader_info
*info
= &v
->shader
->nir
->info
;
76 struct ir3_compiler
*compiler
= v
->shader
->compiler
;
80 unsigned sz
= v
->info
.sizedwords
* 4;
82 v
->bo
= fd_bo_new(compiler
->dev
, sz
,
83 DRM_FREEDRENO_GEM_CACHE_WCOMBINE
|
84 DRM_FREEDRENO_GEM_TYPE_KMEM
,
85 "%s:%s", ir3_shader_stage(v
), info
->name
);
87 /* Always include shaders in kernel crash dumps. */
88 fd_bo_mark_for_dump(v
->bo
);
90 memcpy(fd_bo_map(v
->bo
), v
->bin
, sz
);
93 struct ir3_shader_variant
*
94 ir3_shader_variant(struct ir3_shader
*shader
, struct ir3_shader_key key
,
95 bool binning_pass
, struct pipe_debug_callback
*debug
)
97 struct ir3_shader_variant
*v
;
100 /* Some shader key values may not be used by a given ir3_shader (for
101 * example, fragment shader saturates in the vertex shader), so clean out
102 * those flags to avoid recompiling.
104 ir3_key_clear_unused(&key
, shader
);
106 v
= ir3_shader_get_variant(shader
, &key
, binning_pass
, &created
);
109 if (shader
->initial_variants_done
) {
110 pipe_debug_message(debug
, SHADER_INFO
,
111 "%s shader: recompiling at draw time: global 0x%08x, vsats %x/%x/%x, fsats %x/%x/%x, vfsamples %x/%x, astc %x/%x\n",
114 key
.vsaturate_s
, key
.vsaturate_t
, key
.vsaturate_r
,
115 key
.fsaturate_s
, key
.fsaturate_t
, key
.fsaturate_r
,
116 key
.vsamples
, key
.fsamples
,
117 key
.vastc_srgb
, key
.fastc_srgb
);
121 dump_shader_info(v
, debug
);
122 upload_shader_variant(v
);
125 upload_shader_variant(v
->binning
);
126 dump_shader_info(v
->binning
, debug
);
134 copy_stream_out(struct ir3_stream_output_info
*i
,
135 const struct pipe_stream_output_info
*p
)
137 STATIC_ASSERT(ARRAY_SIZE(i
->stride
) == ARRAY_SIZE(p
->stride
));
138 STATIC_ASSERT(ARRAY_SIZE(i
->output
) == ARRAY_SIZE(p
->output
));
140 i
->num_outputs
= p
->num_outputs
;
141 for (int n
= 0; n
< ARRAY_SIZE(i
->stride
); n
++)
142 i
->stride
[n
] = p
->stride
[n
];
144 for (int n
= 0; n
< ARRAY_SIZE(i
->output
); n
++) {
145 i
->output
[n
].register_index
= p
->output
[n
].register_index
;
146 i
->output
[n
].start_component
= p
->output
[n
].start_component
;
147 i
->output
[n
].num_components
= p
->output
[n
].num_components
;
148 i
->output
[n
].output_buffer
= p
->output
[n
].output_buffer
;
149 i
->output
[n
].dst_offset
= p
->output
[n
].dst_offset
;
150 i
->output
[n
].stream
= p
->output
[n
].stream
;
155 ir3_shader_create(struct ir3_compiler
*compiler
,
156 const struct pipe_shader_state
*cso
,
157 struct pipe_debug_callback
*debug
,
158 struct pipe_screen
*screen
)
161 if (cso
->type
== PIPE_SHADER_IR_NIR
) {
162 /* we take ownership of the reference: */
165 debug_assert(cso
->type
== PIPE_SHADER_IR_TGSI
);
166 if (ir3_shader_debug
& IR3_DBG_DISASM
) {
167 tgsi_dump(cso
->tokens
, 0);
169 nir
= tgsi_to_nir(cso
->tokens
, screen
, false);
172 struct ir3_stream_output_info stream_output
;
173 copy_stream_out(&stream_output
, &cso
->stream_output
);
175 struct ir3_shader
*shader
= ir3_shader_from_nir(compiler
, nir
, 0, &stream_output
);
177 /* Compile standard variants immediately to try to avoid draw-time stalls
178 * to run the compiler.
180 struct ir3_shader_key key
= {
181 .tessellation
= IR3_TESS_NONE
,
185 switch (nir
->info
.stage
) {
186 case MESA_SHADER_TESS_EVAL
:
187 key
.tessellation
= ir3_tess_mode(nir
->info
.tess
.primitive_mode
);
190 case MESA_SHADER_TESS_CTRL
:
191 /* The primitive_mode field, while it exists for TCS, is not
192 * populated (since separable shaders between TCS/TES are legal,
193 * so TCS wouldn't have access to TES's declaration). Make a
194 * guess so that we shader-db something plausible for TCS.
196 if (nir
->info
.outputs_written
& VARYING_BIT_TESS_LEVEL_INNER
)
197 key
.tessellation
= IR3_TESS_TRIANGLES
;
199 key
.tessellation
= IR3_TESS_ISOLINES
;
202 case MESA_SHADER_GEOMETRY
:
210 key
.safe_constlen
= false;
211 struct ir3_shader_variant
*v
= ir3_shader_variant(shader
, key
, false, debug
);
215 if (v
->constlen
> compiler
->max_const_safe
) {
216 key
.safe_constlen
= true;
217 ir3_shader_variant(shader
, key
, false, debug
);
220 if (nir
->info
.stage
== MESA_SHADER_VERTEX
) {
221 key
.safe_constlen
= false;
222 v
= ir3_shader_variant(shader
, key
, true, debug
);
226 if (v
->constlen
> compiler
->max_const_safe
) {
227 key
.safe_constlen
= true;
228 ir3_shader_variant(shader
, key
, true, debug
);
232 shader
->initial_variants_done
= true;
237 /* a bit annoying that compute-shader and normal shader state objects
238 * aren't a bit more aligned.
241 ir3_shader_create_compute(struct ir3_compiler
*compiler
,
242 const struct pipe_compute_state
*cso
,
243 struct pipe_debug_callback
*debug
,
244 struct pipe_screen
*screen
)
247 if (cso
->ir_type
== PIPE_SHADER_IR_NIR
) {
248 /* we take ownership of the reference: */
249 nir
= (nir_shader
*)cso
->prog
;
251 debug_assert(cso
->ir_type
== PIPE_SHADER_IR_TGSI
);
252 if (ir3_shader_debug
& IR3_DBG_DISASM
) {
253 tgsi_dump(cso
->prog
, 0);
255 nir
= tgsi_to_nir(cso
->prog
, screen
, false);
258 struct ir3_shader
*shader
= ir3_shader_from_nir(compiler
, nir
, 0, NULL
);
260 /* Immediately compile a standard variant. We have so few variants in our
261 * shaders, that doing so almost eliminates draw-time recompiles. (This
262 * is also how we get data from shader-db's ./run)
264 static struct ir3_shader_key key
; /* static is implicitly zeroed */
265 ir3_shader_variant(shader
, key
, false, debug
);
267 shader
->initial_variants_done
= true;
273 ir3_shader_state_create(struct pipe_context
*pctx
, const struct pipe_shader_state
*cso
)
275 struct fd_context
*ctx
= fd_context(pctx
);
276 struct ir3_compiler
*compiler
= ctx
->screen
->compiler
;
277 return ir3_shader_create(compiler
, cso
, &ctx
->debug
, pctx
->screen
);
281 ir3_shader_state_delete(struct pipe_context
*pctx
, void *hwcso
)
283 struct ir3_shader
*so
= hwcso
;
285 /* free the uploaded shaders, since this is handled outside of the
286 * shared ir3 code (ie. not used by turnip):
288 for (struct ir3_shader_variant
*v
= so
->variants
; v
; v
= v
->next
) {
292 if (v
->binning
&& v
->binning
->bo
) {
293 fd_bo_del(v
->binning
->bo
);
294 v
->binning
->bo
= NULL
;
298 ir3_shader_destroy(so
);
302 ir3_screen_finalize_nir(struct pipe_screen
*pscreen
, void *nir
, bool optimize
)
304 struct fd_screen
*screen
= fd_screen(pscreen
);
306 ir3_finalize_nir(screen
->compiler
, nir
);
310 ir3_prog_init(struct pipe_context
*pctx
)
312 pctx
->create_vs_state
= ir3_shader_state_create
;
313 pctx
->delete_vs_state
= ir3_shader_state_delete
;
315 pctx
->create_tcs_state
= ir3_shader_state_create
;
316 pctx
->delete_tcs_state
= ir3_shader_state_delete
;
318 pctx
->create_tes_state
= ir3_shader_state_create
;
319 pctx
->delete_tes_state
= ir3_shader_state_delete
;
321 pctx
->create_gs_state
= ir3_shader_state_create
;
322 pctx
->delete_gs_state
= ir3_shader_state_delete
;
324 pctx
->create_fs_state
= ir3_shader_state_create
;
325 pctx
->delete_fs_state
= ir3_shader_state_delete
;
329 ir3_screen_init(struct pipe_screen
*pscreen
)
331 pscreen
->finalize_nir
= ir3_screen_finalize_nir
;