1 /*
2 * Copyright (c) 2014 - 2015 Intel Corporation
3 *
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:
10 *
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
13 * Software.
14 *
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.
22 */
23
24 #include "util/ralloc.h"
25 #include "brw_context.h"
26 #include "brw_cs.h"
27 #include "brw_eu.h"
28 #include "brw_wm.h"
29 #include "brw_shader.h"
30 #include "intel_mipmap_tree.h"
31 #include "brw_state.h"
32 #include "intel_batchbuffer.h"
33 #include "brw_nir.h"
34 #include "brw_program.h"
35 #include "compiler/glsl/ir_uniform.h"
36
37 static void
assign_cs_binding_table_offsets(const struct gen_device_info * devinfo,const struct gl_program * prog,struct brw_cs_prog_data * prog_data)38 assign_cs_binding_table_offsets(const struct gen_device_info *devinfo,
39 const struct gl_program *prog,
40 struct brw_cs_prog_data *prog_data)
41 {
42 uint32_t next_binding_table_offset = 0;
43
44 /* May not be used if the gl_NumWorkGroups variable is not accessed. */
45 prog_data->binding_table.work_groups_start = next_binding_table_offset;
46 next_binding_table_offset++;
47
48 brw_assign_common_binding_table_offsets(devinfo, prog, &prog_data->base,
49 next_binding_table_offset);
50 }
51
52 static bool
brw_codegen_cs_prog(struct brw_context * brw,struct brw_program * cp,struct brw_cs_prog_key * key)53 brw_codegen_cs_prog(struct brw_context *brw,
54 struct brw_program *cp,
55 struct brw_cs_prog_key *key)
56 {
57 const struct gen_device_info *devinfo = &brw->screen->devinfo;
58 struct gl_context *ctx = &brw->ctx;
59 const GLuint *program;
60 void *mem_ctx = ralloc_context(NULL);
61 GLuint program_size;
62 struct brw_cs_prog_data prog_data;
63 bool start_busy = false;
64 double start_time = 0;
65
66 memset(&prog_data, 0, sizeof(prog_data));
67
68 if (cp->program.info.cs.shared_size > 64 * 1024) {
69 cp->program.sh.data->LinkStatus = false;
70 const char *error_str =
71 "Compute shader used more than 64KB of shared variables";
72 ralloc_strcat(&cp->program.sh.data->InfoLog, error_str);
73 _mesa_problem(NULL, "Failed to link compute shader: %s\n", error_str);
74
75 ralloc_free(mem_ctx);
76 return false;
77 } else {
78 prog_data.base.total_shared = cp->program.info.cs.shared_size;
79 }
80
81 assign_cs_binding_table_offsets(devinfo, &cp->program, &prog_data);
82
83 /* Allocate the references to the uniforms that will end up in the
84 * prog_data associated with the compiled program, and which will be freed
85 * by the state cache.
86 */
87 int param_count = cp->program.nir->num_uniforms / 4;
88
89 /* The backend also sometimes add a param for the thread local id. */
90 prog_data.thread_local_id_index = param_count++;
91
92 /* The backend also sometimes adds params for texture size. */
93 param_count += 2 * ctx->Const.Program[MESA_SHADER_COMPUTE].MaxTextureImageUnits;
94 prog_data.base.param =
95 rzalloc_array(NULL, const gl_constant_value *, param_count);
96 prog_data.base.pull_param =
97 rzalloc_array(NULL, const gl_constant_value *, param_count);
98 prog_data.base.image_param =
99 rzalloc_array(NULL, struct brw_image_param,
100 cp->program.info.num_images);
101 prog_data.base.nr_params = param_count;
102 prog_data.base.nr_image_params = cp->program.info.num_images;
103
104 brw_nir_setup_glsl_uniforms(cp->program.nir, &cp->program,&prog_data.base,
105 true);
106
107 if (unlikely(brw->perf_debug)) {
108 start_busy = (brw->batch.last_bo &&
109 drm_intel_bo_busy(brw->batch.last_bo));
110 start_time = get_time();
111 }
112
113 int st_index = -1;
114 if (INTEL_DEBUG & DEBUG_SHADER_TIME)
115 st_index = brw_get_shader_time_index(brw, &cp->program, ST_CS, true);
116
117 char *error_str;
118 program = brw_compile_cs(brw->screen->compiler, brw, mem_ctx, key,
119 &prog_data, cp->program.nir, st_index,
120 &program_size, &error_str);
121 if (program == NULL) {
122 cp->program.sh.data->LinkStatus = false;
123 ralloc_strcat(&cp->program.sh.data->InfoLog, error_str);
124 _mesa_problem(NULL, "Failed to compile compute shader: %s\n", error_str);
125
126 ralloc_free(mem_ctx);
127 return false;
128 }
129
130 if (unlikely(brw->perf_debug)) {
131 if (cp->compiled_once) {
132 _mesa_problem(&brw->ctx, "CS programs shouldn't need recompiles");
133 }
134 cp->compiled_once = true;
135
136 if (start_busy && !drm_intel_bo_busy(brw->batch.last_bo)) {
137 perf_debug("CS compile took %.03f ms and stalled the GPU\n",
138 (get_time() - start_time) * 1000);
139 }
140 }
141
142 const unsigned subslices = MAX2(brw->screen->subslice_total, 1);
143
144 /* WaCSScratchSize:hsw
145 *
146 * Haswell's scratch space address calculation appears to be sparse
147 * rather than tightly packed. The Thread ID has bits indicating
148 * which subslice, EU within a subslice, and thread within an EU
149 * it is. There's a maximum of two slices and two subslices, so these
150 * can be stored with a single bit. Even though there are only 10 EUs
151 * per subslice, this is stored in 4 bits, so there's an effective
152 * maximum value of 16 EUs. Similarly, although there are only 7
153 * threads per EU, this is stored in a 3 bit number, giving an effective
154 * maximum value of 8 threads per EU.
155 *
156 * This means that we need to use 16 * 8 instead of 10 * 7 for the
157 * number of threads per subslice.
158 */
159 const unsigned scratch_ids_per_subslice =
160 brw->is_haswell ? 16 * 8 : devinfo->max_cs_threads;
161
162 brw_alloc_stage_scratch(brw, &brw->cs.base,
163 prog_data.base.total_scratch,
164 scratch_ids_per_subslice * subslices);
165
166 brw_upload_cache(&brw->cache, BRW_CACHE_CS_PROG,
167 key, sizeof(*key),
168 program, program_size,
169 &prog_data, sizeof(prog_data),
170 &brw->cs.base.prog_offset, &brw->cs.base.prog_data);
171 ralloc_free(mem_ctx);
172
173 return true;
174 }
175
176
177 static void
brw_cs_populate_key(struct brw_context * brw,struct brw_cs_prog_key * key)178 brw_cs_populate_key(struct brw_context *brw, struct brw_cs_prog_key *key)
179 {
180 struct gl_context *ctx = &brw->ctx;
181 /* BRW_NEW_COMPUTE_PROGRAM */
182 const struct brw_program *cp = (struct brw_program *) brw->compute_program;
183 const struct gl_program *prog = (struct gl_program *) cp;
184
185 memset(key, 0, sizeof(*key));
186
187 /* _NEW_TEXTURE */
188 brw_populate_sampler_prog_key_data(ctx, prog, &key->tex);
189
190 /* The unique compute program ID */
191 key->program_string_id = cp->id;
192 }
193
194
195 void
brw_upload_cs_prog(struct brw_context * brw)196 brw_upload_cs_prog(struct brw_context *brw)
197 {
198 struct gl_context *ctx = &brw->ctx;
199 struct brw_cs_prog_key key;
200 struct brw_program *cp = (struct brw_program *) brw->compute_program;
201
202 if (!cp)
203 return;
204
205 if (!brw_state_dirty(brw, _NEW_TEXTURE, BRW_NEW_COMPUTE_PROGRAM))
206 return;
207
208 brw->cs.base.sampler_count =
209 util_last_bit(ctx->ComputeProgram._Current->SamplersUsed);
210
211 brw_cs_populate_key(brw, &key);
212
213 if (!brw_search_cache(&brw->cache, BRW_CACHE_CS_PROG,
214 &key, sizeof(key),
215 &brw->cs.base.prog_offset,
216 &brw->cs.base.prog_data)) {
217 bool success = brw_codegen_cs_prog(brw, cp, &key);
218 (void) success;
219 assert(success);
220 }
221 }
222
223
224 bool
brw_cs_precompile(struct gl_context * ctx,struct gl_program * prog)225 brw_cs_precompile(struct gl_context *ctx, struct gl_program *prog)
226 {
227 struct brw_context *brw = brw_context(ctx);
228 struct brw_cs_prog_key key;
229
230 struct brw_program *bcp = brw_program(prog);
231
232 memset(&key, 0, sizeof(key));
233 key.program_string_id = bcp->id;
234
235 brw_setup_tex_for_precompile(brw, &key.tex, prog);
236
237 uint32_t old_prog_offset = brw->cs.base.prog_offset;
238 struct brw_stage_prog_data *old_prog_data = brw->cs.base.prog_data;
239
240 bool success = brw_codegen_cs_prog(brw, bcp, &key);
241
242 brw->cs.base.prog_offset = old_prog_offset;
243 brw->cs.base.prog_data = old_prog_data;
244
245 return success;
246 }
247