brw_cs.c revision ee0f0108c8e87b9cfec25bade66670bbc4254139 
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
35static void
36assign_cs_binding_table_offsets(const struct brw_device_info *devinfo,
37                                const struct gl_shader_program *shader_prog,
38                                const struct gl_program *prog,
39                                struct brw_cs_prog_data *prog_data)
40{
41   uint32_t next_binding_table_offset = 0;
42
43   /* May not be used if the gl_NumWorkGroups variable is not accessed. */
44   prog_data->binding_table.work_groups_start = next_binding_table_offset;
45   next_binding_table_offset++;
46
47   brw_assign_common_binding_table_offsets(MESA_SHADER_COMPUTE, devinfo,
48                                           shader_prog, prog, &prog_data->base,
49                                           next_binding_table_offset);
50}
51
52static bool
53brw_codegen_cs_prog(struct brw_context *brw,
54                    struct gl_shader_program *prog,
55                    struct brw_compute_program *cp,
56                    struct brw_cs_prog_key *key)
57{
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   struct brw_shader *cs =
67      (struct brw_shader *) prog->_LinkedShaders[MESA_SHADER_COMPUTE];
68   assert (cs);
69
70   memset(&prog_data, 0, sizeof(prog_data));
71
72   assign_cs_binding_table_offsets(brw->intelScreen->devinfo, prog,
73                                   &cp->program.Base, &prog_data);
74
75   /* Allocate the references to the uniforms that will end up in the
76    * prog_data associated with the compiled program, and which will be freed
77    * by the state cache.
78    */
79   int param_count = cp->program.Base.nir->num_uniforms;
80
81   /* The backend also sometimes adds params for texture size. */
82   param_count += 2 * ctx->Const.Program[MESA_SHADER_COMPUTE].MaxTextureImageUnits;
83   prog_data.base.param =
84      rzalloc_array(NULL, const gl_constant_value *, param_count);
85   prog_data.base.pull_param =
86      rzalloc_array(NULL, const gl_constant_value *, param_count);
87   prog_data.base.image_param =
88      rzalloc_array(NULL, struct brw_image_param, cs->base.NumImages);
89   prog_data.base.nr_params = param_count;
90   prog_data.base.nr_image_params = cs->base.NumImages;
91
92   brw_nir_setup_glsl_uniforms(cp->program.Base.nir, prog, &cp->program.Base,
93                               &prog_data.base, true);
94
95   if (unlikely(brw->perf_debug)) {
96      start_busy = (brw->batch.last_bo &&
97                    drm_intel_bo_busy(brw->batch.last_bo));
98      start_time = get_time();
99   }
100
101   if (unlikely(INTEL_DEBUG & DEBUG_CS))
102      brw_dump_ir("compute", prog, &cs->base, &cp->program.Base);
103
104   int st_index = -1;
105   if (INTEL_DEBUG & DEBUG_SHADER_TIME)
106      st_index = brw_get_shader_time_index(brw, prog, &cp->program.Base, ST_CS);
107
108   program = brw_cs_emit(brw, mem_ctx, key, &prog_data,
109                         &cp->program, prog, st_index, &program_size);
110   if (program == NULL) {
111      ralloc_free(mem_ctx);
112      return false;
113   }
114
115   if (unlikely(brw->perf_debug) && cs) {
116      if (cs->compiled_once) {
117         _mesa_problem(&brw->ctx, "CS programs shouldn't need recompiles");
118      }
119      cs->compiled_once = true;
120
121      if (start_busy && !drm_intel_bo_busy(brw->batch.last_bo)) {
122         perf_debug("CS compile took %.03f ms and stalled the GPU\n",
123                    (get_time() - start_time) * 1000);
124      }
125   }
126
127   if (prog_data.base.total_scratch) {
128      brw_get_scratch_bo(brw, &brw->cs.base.scratch_bo,
129                         prog_data.base.total_scratch * brw->max_cs_threads);
130   }
131
132   if (unlikely(INTEL_DEBUG & DEBUG_CS))
133      fprintf(stderr, "\n");
134
135   brw_upload_cache(&brw->cache, BRW_CACHE_CS_PROG,
136                    key, sizeof(*key),
137                    program, program_size,
138                    &prog_data, sizeof(prog_data),
139                    &brw->cs.base.prog_offset, &brw->cs.prog_data);
140   ralloc_free(mem_ctx);
141
142   return true;
143}
144
145
146static void
147brw_cs_populate_key(struct brw_context *brw, struct brw_cs_prog_key *key)
148{
149   struct gl_context *ctx = &brw->ctx;
150   /* BRW_NEW_COMPUTE_PROGRAM */
151   const struct brw_compute_program *cp =
152      (struct brw_compute_program *) brw->compute_program;
153   const struct gl_program *prog = (struct gl_program *) cp;
154
155   memset(key, 0, sizeof(*key));
156
157   /* _NEW_TEXTURE */
158   brw_populate_sampler_prog_key_data(ctx, prog, brw->cs.base.sampler_count,
159                                      &key->tex);
160
161   /* The unique compute program ID */
162   key->program_string_id = cp->id;
163}
164
165
166void
167brw_upload_cs_prog(struct brw_context *brw)
168{
169   struct gl_context *ctx = &brw->ctx;
170   struct brw_cs_prog_key key;
171   struct brw_compute_program *cp = (struct brw_compute_program *)
172      brw->compute_program;
173
174   if (!cp)
175      return;
176
177   if (!brw_state_dirty(brw, _NEW_TEXTURE, BRW_NEW_COMPUTE_PROGRAM))
178      return;
179
180   brw->cs.base.sampler_count =
181      _mesa_fls(ctx->ComputeProgram._Current->Base.SamplersUsed);
182
183   brw_cs_populate_key(brw, &key);
184
185   if (!brw_search_cache(&brw->cache, BRW_CACHE_CS_PROG,
186                         &key, sizeof(key),
187                         &brw->cs.base.prog_offset, &brw->cs.prog_data)) {
188      bool success =
189         brw_codegen_cs_prog(brw,
190                             ctx->Shader.CurrentProgram[MESA_SHADER_COMPUTE],
191                             cp, &key);
192      (void) success;
193      assert(success);
194   }
195   brw->cs.base.prog_data = &brw->cs.prog_data->base;
196}
197
198
199bool
200brw_cs_precompile(struct gl_context *ctx,
201                  struct gl_shader_program *shader_prog,
202                  struct gl_program *prog)
203{
204   struct brw_context *brw = brw_context(ctx);
205   struct brw_cs_prog_key key;
206
207   struct gl_compute_program *cp = (struct gl_compute_program *) prog;
208   struct brw_compute_program *bcp = brw_compute_program(cp);
209
210   memset(&key, 0, sizeof(key));
211   key.program_string_id = bcp->id;
212
213   brw_setup_tex_for_precompile(brw, &key.tex, prog);
214
215   uint32_t old_prog_offset = brw->cs.base.prog_offset;
216   struct brw_cs_prog_data *old_prog_data = brw->cs.prog_data;
217
218   bool success = brw_codegen_cs_prog(brw, shader_prog, bcp, &key);
219
220   brw->cs.base.prog_offset = old_prog_offset;
221   brw->cs.prog_data = old_prog_data;
222
223   return success;
224}
225