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_wm.h"
28#include "intel_mipmap_tree.h"
29#include "brw_state.h"
30#include "intel_batchbuffer.h"
31#include "compiler/brw_nir.h"
32#include "brw_program.h"
33#include "compiler/glsl/ir_uniform.h"
34
35static void
36assign_cs_binding_table_offsets(const struct gen_device_info *devinfo,
37                                const struct gl_program *prog,
38                                struct brw_cs_prog_data *prog_data)
39{
40   uint32_t next_binding_table_offset = 0;
41
42   /* May not be used if the gl_NumWorkGroups variable is not accessed. */
43   prog_data->binding_table.work_groups_start = next_binding_table_offset;
44   next_binding_table_offset++;
45
46   brw_assign_common_binding_table_offsets(devinfo, prog, &prog_data->base,
47                                           next_binding_table_offset);
48}
49
50static bool
51brw_codegen_cs_prog(struct brw_context *brw,
52                    struct brw_program *cp,
53                    struct brw_cs_prog_key *key)
54{
55   const struct gen_device_info *devinfo = &brw->screen->devinfo;
56   const GLuint *program;
57   void *mem_ctx = ralloc_context(NULL);
58   struct brw_cs_prog_data prog_data;
59   bool start_busy = false;
60   double start_time = 0;
61   nir_shader *nir = nir_shader_clone(mem_ctx, cp->program.nir);
62
63   memset(&prog_data, 0, sizeof(prog_data));
64
65   if (cp->program.info.cs.shared_size > 64 * 1024) {
66      cp->program.sh.data->LinkStatus = LINKING_FAILURE;
67      const char *error_str =
68         "Compute shader used more than 64KB of shared variables";
69      ralloc_strcat(&cp->program.sh.data->InfoLog, error_str);
70      _mesa_problem(NULL, "Failed to link compute shader: %s\n", error_str);
71
72      ralloc_free(mem_ctx);
73      return false;
74   } else {
75      prog_data.base.total_shared = cp->program.info.cs.shared_size;
76   }
77
78   assign_cs_binding_table_offsets(devinfo, &cp->program, &prog_data);
79
80   brw_nir_setup_glsl_uniforms(mem_ctx, nir,
81                               &cp->program, &prog_data.base, true);
82
83   if (unlikely(brw->perf_debug)) {
84      start_busy = (brw->batch.last_bo &&
85                    brw_bo_busy(brw->batch.last_bo));
86      start_time = get_time();
87   }
88
89   int st_index = -1;
90   if (INTEL_DEBUG & DEBUG_SHADER_TIME)
91      st_index = brw_get_shader_time_index(brw, &cp->program, ST_CS, true);
92
93   char *error_str;
94   program = brw_compile_cs(brw->screen->compiler, brw, mem_ctx, key,
95                            &prog_data, nir, st_index, &error_str);
96   if (program == NULL) {
97      cp->program.sh.data->LinkStatus = LINKING_FAILURE;
98      ralloc_strcat(&cp->program.sh.data->InfoLog, error_str);
99      _mesa_problem(NULL, "Failed to compile compute shader: %s\n", error_str);
100
101      ralloc_free(mem_ctx);
102      return false;
103   }
104
105   if (unlikely(brw->perf_debug)) {
106      if (cp->compiled_once) {
107         brw_debug_recompile(brw, MESA_SHADER_COMPUTE, cp->program.Id,
108                             key->program_string_id, key);
109      }
110      cp->compiled_once = true;
111
112      if (start_busy && !brw_bo_busy(brw->batch.last_bo)) {
113         perf_debug("CS compile took %.03f ms and stalled the GPU\n",
114                    (get_time() - start_time) * 1000);
115      }
116   }
117
118   brw_alloc_stage_scratch(brw, &brw->cs.base, prog_data.base.total_scratch);
119
120   /* The param and pull_param arrays will be freed by the shader cache. */
121   ralloc_steal(NULL, prog_data.base.param);
122   ralloc_steal(NULL, prog_data.base.pull_param);
123   brw_upload_cache(&brw->cache, BRW_CACHE_CS_PROG,
124                    key, sizeof(*key),
125                    program, prog_data.base.program_size,
126                    &prog_data, sizeof(prog_data),
127                    &brw->cs.base.prog_offset, &brw->cs.base.prog_data);
128   ralloc_free(mem_ctx);
129
130   return true;
131}
132
133
134void
135brw_cs_populate_key(struct brw_context *brw, struct brw_cs_prog_key *key)
136{
137   struct gl_context *ctx = &brw->ctx;
138   /* BRW_NEW_COMPUTE_PROGRAM */
139   const struct brw_program *cp =
140      (struct brw_program *) brw->programs[MESA_SHADER_COMPUTE];
141   const struct gl_program *prog = (struct gl_program *) cp;
142
143   memset(key, 0, sizeof(*key));
144
145   /* _NEW_TEXTURE */
146   brw_populate_sampler_prog_key_data(ctx, prog, &key->tex);
147
148   /* The unique compute program ID */
149   key->program_string_id = cp->id;
150}
151
152
153void
154brw_upload_cs_prog(struct brw_context *brw)
155{
156   struct gl_context *ctx = &brw->ctx;
157   struct brw_cs_prog_key key;
158   struct brw_program *cp =
159      (struct brw_program *) brw->programs[MESA_SHADER_COMPUTE];
160
161   if (!cp)
162      return;
163
164   if (!brw_state_dirty(brw, _NEW_TEXTURE, BRW_NEW_COMPUTE_PROGRAM))
165      return;
166
167   brw->cs.base.sampler_count =
168      util_last_bit(ctx->ComputeProgram._Current->SamplersUsed);
169
170   brw_cs_populate_key(brw, &key);
171
172   if (brw_search_cache(&brw->cache, BRW_CACHE_CS_PROG, &key, sizeof(key),
173                        &brw->cs.base.prog_offset, &brw->cs.base.prog_data,
174                        true))
175      return;
176
177   if (brw_disk_cache_upload_program(brw, MESA_SHADER_COMPUTE))
178      return;
179
180   cp = (struct brw_program *) brw->programs[MESA_SHADER_COMPUTE];
181   cp->id = key.program_string_id;
182
183   MAYBE_UNUSED bool success = brw_codegen_cs_prog(brw, cp, &key);
184   assert(success);
185}
186
187void
188brw_cs_populate_default_key(const struct gen_device_info *devinfo,
189                            struct brw_cs_prog_key *key,
190                            struct gl_program *prog)
191{
192   memset(key, 0, sizeof(*key));
193   key->program_string_id = brw_program(prog)->id;
194
195   brw_setup_tex_for_precompile(devinfo, &key->tex, prog);
196}
197
198bool
199brw_cs_precompile(struct gl_context *ctx, struct gl_program *prog)
200{
201   struct brw_context *brw = brw_context(ctx);
202   struct brw_cs_prog_key key;
203
204   struct brw_program *bcp = brw_program(prog);
205
206   brw_cs_populate_default_key(&brw->screen->devinfo, &key, prog);
207
208   uint32_t old_prog_offset = brw->cs.base.prog_offset;
209   struct brw_stage_prog_data *old_prog_data = brw->cs.base.prog_data;
210
211   bool success = brw_codegen_cs_prog(brw, bcp, &key);
212
213   brw->cs.base.prog_offset = old_prog_offset;
214   brw->cs.base.prog_data = old_prog_data;
215
216   return success;
217}
218