7847f1f5589f10cad04ee6c0d7e4b689a5176bed
[mesa.git] / src / gallium / drivers / zink / zink_program.c
1 /*
2 * Copyright 2018 Collabora Ltd.
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 * on the rights to use, copy, modify, merge, publish, distribute, sub
8 * license, and/or sell copies of the Software, and to permit persons to whom
9 * the 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 NON-INFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
21 * USE OR OTHER DEALINGS IN THE SOFTWARE.
22 */
23
24 #include "zink_program.h"
25
26 #include "zink_compiler.h"
27 #include "zink_context.h"
28 #include "zink_render_pass.h"
29 #include "zink_screen.h"
30
31 #include "util/hash_table.h"
32 #include "util/set.h"
33 #include "util/u_debug.h"
34 #include "util/u_memory.h"
35 #include "tgsi/tgsi_from_mesa.h"
36
37 struct pipeline_cache_entry {
38 struct zink_gfx_pipeline_state state;
39 VkPipeline pipeline;
40 };
41
42 void
43 debug_describe_zink_gfx_program(char *buf, const struct zink_gfx_program *ptr)
44 {
45 sprintf(buf, "zink_gfx_program");
46 }
47
48 static void
49 debug_describe_zink_shader_module(char *buf, const struct zink_shader_module *ptr)
50 {
51 sprintf(buf, "zink_shader_module");
52 }
53
54 static VkDescriptorSetLayout
55 create_desc_set_layout(VkDevice dev,
56 struct zink_shader *stages[ZINK_SHADER_COUNT],
57 unsigned *num_descriptors)
58 {
59 VkDescriptorSetLayoutBinding bindings[PIPE_SHADER_TYPES * PIPE_MAX_CONSTANT_BUFFERS];
60 int num_bindings = 0;
61
62 for (int i = 0; i < ZINK_SHADER_COUNT; i++) {
63 struct zink_shader *shader = stages[i];
64 if (!shader)
65 continue;
66
67 VkShaderStageFlagBits stage_flags = zink_shader_stage(i);
68 for (int j = 0; j < shader->num_bindings; j++) {
69 assert(num_bindings < ARRAY_SIZE(bindings));
70 bindings[num_bindings].binding = shader->bindings[j].binding;
71 bindings[num_bindings].descriptorType = shader->bindings[j].type;
72 bindings[num_bindings].descriptorCount = 1;
73 bindings[num_bindings].stageFlags = stage_flags;
74 bindings[num_bindings].pImmutableSamplers = NULL;
75 ++num_bindings;
76 }
77 }
78
79 VkDescriptorSetLayoutCreateInfo dcslci = {};
80 dcslci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
81 dcslci.pNext = NULL;
82 dcslci.flags = 0;
83 dcslci.bindingCount = num_bindings;
84 dcslci.pBindings = bindings;
85
86 VkDescriptorSetLayout dsl;
87 if (vkCreateDescriptorSetLayout(dev, &dcslci, 0, &dsl) != VK_SUCCESS) {
88 debug_printf("vkCreateDescriptorSetLayout failed\n");
89 return VK_NULL_HANDLE;
90 }
91
92 *num_descriptors = num_bindings;
93 return dsl;
94 }
95
96 static VkPipelineLayout
97 create_pipeline_layout(VkDevice dev, VkDescriptorSetLayout dsl)
98 {
99 assert(dsl != VK_NULL_HANDLE);
100
101 VkPipelineLayoutCreateInfo plci = {};
102 plci.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
103
104 plci.pSetLayouts = &dsl;
105 plci.setLayoutCount = 1;
106
107 VkPipelineLayout layout;
108 if (vkCreatePipelineLayout(dev, &plci, NULL, &layout) != VK_SUCCESS) {
109 debug_printf("vkCreatePipelineLayout failed!\n");
110 return VK_NULL_HANDLE;
111 }
112
113 return layout;
114 }
115
116 static void
117 zink_destroy_shader_module(struct zink_screen *screen, struct zink_shader_module *zm)
118 {
119 vkDestroyShaderModule(screen->dev, zm->shader, NULL);
120 free(zm);
121 }
122
123 static inline void
124 zink_shader_module_reference(struct zink_screen *screen,
125 struct zink_shader_module **dst,
126 struct zink_shader_module *src)
127 {
128 struct zink_shader_module *old_dst = dst ? *dst : NULL;
129
130 if (pipe_reference_described(old_dst ? &old_dst->reference : NULL, &src->reference,
131 (debug_reference_descriptor)debug_describe_zink_shader_module))
132 zink_destroy_shader_module(screen, old_dst);
133 if (dst) *dst = src;
134 }
135
136 static void
137 update_shader_modules(struct zink_context *ctx, struct zink_shader *stages[ZINK_SHADER_COUNT], struct zink_gfx_program *prog)
138 {
139 struct zink_shader *dirty[ZINK_SHADER_COUNT] = {NULL};
140
141 /* we need to map pipe_shader_type -> gl_shader_stage so we can ensure that we're compiling
142 * the shaders in pipeline order and have builtin input/output locations match up after being compacted
143 */
144 unsigned dirty_shader_stages = ctx->dirty_shader_stages;
145 while (dirty_shader_stages) {
146 unsigned type = u_bit_scan(&dirty_shader_stages);
147 dirty[tgsi_processor_to_shader_stage(type)] = stages[type];
148 }
149 for (int i = 0; i < ZINK_SHADER_COUNT; ++i) {
150 enum pipe_shader_type type = pipe_shader_type_from_mesa(i);
151 if (dirty[i]) {
152 prog->modules[type] = CALLOC_STRUCT(zink_shader_module);
153 assert(prog->modules[type]);
154 pipe_reference_init(&prog->modules[type]->reference, 1);
155 prog->modules[type]->shader = zink_shader_compile(zink_screen(ctx->base.screen), dirty[i]);
156 } else if (stages[type]) /* reuse existing shader module */
157 zink_shader_module_reference(zink_screen(ctx->base.screen), &prog->modules[type], ctx->curr_program->modules[type]);
158 prog->shaders[type] = stages[type];
159 }
160 ctx->dirty_shader_stages = 0;
161 }
162
163 static uint32_t
164 hash_gfx_pipeline_state(const void *key)
165 {
166 return _mesa_hash_data(key, offsetof(struct zink_gfx_pipeline_state, hash));
167 }
168
169 static bool
170 equals_gfx_pipeline_state(const void *a, const void *b)
171 {
172 return memcmp(a, b, offsetof(struct zink_gfx_pipeline_state, hash)) == 0;
173 }
174
175 struct zink_gfx_program *
176 zink_create_gfx_program(struct zink_context *ctx,
177 struct zink_shader *stages[ZINK_SHADER_COUNT])
178 {
179 struct zink_screen *screen = zink_screen(ctx->base.screen);
180 struct zink_gfx_program *prog = CALLOC_STRUCT(zink_gfx_program);
181 if (!prog)
182 goto fail;
183
184 pipe_reference_init(&prog->reference, 1);
185
186 update_shader_modules(ctx, stages, prog);
187
188 for (int i = 0; i < ARRAY_SIZE(prog->pipelines); ++i) {
189 prog->pipelines[i] = _mesa_hash_table_create(NULL,
190 hash_gfx_pipeline_state,
191 equals_gfx_pipeline_state);
192 if (!prog->pipelines[i])
193 goto fail;
194 }
195
196 for (int i = 0; i < ZINK_SHADER_COUNT; ++i) {
197 if (prog->modules[i]) {
198 _mesa_set_add(stages[i]->programs, prog);
199 zink_gfx_program_reference(screen, NULL, prog);
200 }
201 }
202
203 prog->dsl = create_desc_set_layout(screen->dev, stages,
204 &prog->num_descriptors);
205 if (!prog->dsl)
206 goto fail;
207
208 prog->layout = create_pipeline_layout(screen->dev, prog->dsl);
209 if (!prog->layout)
210 goto fail;
211
212 prog->render_passes = _mesa_set_create(NULL, _mesa_hash_pointer,
213 _mesa_key_pointer_equal);
214 if (!prog->render_passes)
215 goto fail;
216
217 return prog;
218
219 fail:
220 if (prog)
221 zink_destroy_gfx_program(screen, prog);
222 return NULL;
223 }
224
225 static void
226 gfx_program_remove_shader(struct zink_gfx_program *prog, struct zink_shader *shader)
227 {
228 enum pipe_shader_type p_stage = pipe_shader_type_from_mesa(shader->nir->info.stage);
229
230 assert(prog->shaders[p_stage] == shader);
231 prog->shaders[p_stage] = NULL;
232 _mesa_set_remove_key(shader->programs, prog);
233 }
234
235 void
236 zink_destroy_gfx_program(struct zink_screen *screen,
237 struct zink_gfx_program *prog)
238 {
239 if (prog->layout)
240 vkDestroyPipelineLayout(screen->dev, prog->layout, NULL);
241
242 if (prog->dsl)
243 vkDestroyDescriptorSetLayout(screen->dev, prog->dsl, NULL);
244
245 for (int i = 0; i < ZINK_SHADER_COUNT; ++i) {
246 if (prog->shaders[i])
247 gfx_program_remove_shader(prog, prog->shaders[i]);
248 if (prog->modules[i])
249 zink_shader_module_reference(screen, &prog->modules[i], NULL);
250 }
251
252 /* unref all used render-passes */
253 if (prog->render_passes) {
254 set_foreach(prog->render_passes, entry) {
255 struct zink_render_pass *pres = (struct zink_render_pass *)entry->key;
256 zink_render_pass_reference(screen, &pres, NULL);
257 }
258 _mesa_set_destroy(prog->render_passes, NULL);
259 }
260
261 for (int i = 0; i < ARRAY_SIZE(prog->pipelines); ++i) {
262 hash_table_foreach(prog->pipelines[i], entry) {
263 struct pipeline_cache_entry *pc_entry = entry->data;
264
265 vkDestroyPipeline(screen->dev, pc_entry->pipeline, NULL);
266 free(pc_entry);
267 }
268 _mesa_hash_table_destroy(prog->pipelines[i], NULL);
269 }
270
271 FREE(prog);
272 }
273
274 static VkPrimitiveTopology
275 primitive_topology(enum pipe_prim_type mode)
276 {
277 switch (mode) {
278 case PIPE_PRIM_POINTS:
279 return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
280
281 case PIPE_PRIM_LINES:
282 return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
283
284 case PIPE_PRIM_LINE_STRIP:
285 return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
286
287 case PIPE_PRIM_TRIANGLES:
288 return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
289
290 case PIPE_PRIM_TRIANGLE_STRIP:
291 return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
292
293 case PIPE_PRIM_TRIANGLE_FAN:
294 return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
295
296 default:
297 unreachable("unexpected enum pipe_prim_type");
298 }
299 }
300
301 static void
302 reference_render_pass(struct zink_screen *screen,
303 struct zink_gfx_program *prog,
304 struct zink_render_pass *render_pass)
305 {
306 struct set_entry *entry = _mesa_set_search(prog->render_passes,
307 render_pass);
308 if (!entry) {
309 entry = _mesa_set_add(prog->render_passes, render_pass);
310 pipe_reference(NULL, &render_pass->reference);
311 }
312 }
313
314 VkPipeline
315 zink_get_gfx_pipeline(struct zink_screen *screen,
316 struct zink_gfx_program *prog,
317 struct zink_gfx_pipeline_state *state,
318 enum pipe_prim_type mode)
319 {
320 VkPrimitiveTopology vkmode = primitive_topology(mode);
321 assert(vkmode <= ARRAY_SIZE(prog->pipelines));
322
323 struct hash_entry *entry = NULL;
324
325 if (!state->hash) {
326 state->hash = hash_gfx_pipeline_state(state);
327 /* make sure the hash is not zero, as we take it as invalid.
328 * TODO: rework this using a separate dirty-bit */
329 assert(state->hash != 0);
330 }
331 entry = _mesa_hash_table_search_pre_hashed(prog->pipelines[vkmode], state->hash, state);
332
333 if (!entry) {
334 VkPipeline pipeline = zink_create_gfx_pipeline(screen, prog,
335 state, vkmode);
336 if (pipeline == VK_NULL_HANDLE)
337 return VK_NULL_HANDLE;
338
339 struct pipeline_cache_entry *pc_entry = CALLOC_STRUCT(pipeline_cache_entry);
340 if (!pc_entry)
341 return VK_NULL_HANDLE;
342
343 memcpy(&pc_entry->state, state, sizeof(*state));
344 pc_entry->pipeline = pipeline;
345
346 assert(state->hash);
347 entry = _mesa_hash_table_insert_pre_hashed(prog->pipelines[vkmode], state->hash, state, pc_entry);
348 assert(entry);
349
350 reference_render_pass(screen, prog, state->render_pass);
351 }
352
353 return ((struct pipeline_cache_entry *)(entry->data))->pipeline;
354 }
355
356
357 static void *
358 zink_create_vs_state(struct pipe_context *pctx,
359 const struct pipe_shader_state *shader)
360 {
361 struct nir_shader *nir;
362 if (shader->type != PIPE_SHADER_IR_NIR)
363 nir = zink_tgsi_to_nir(pctx->screen, shader->tokens);
364 else
365 nir = (struct nir_shader *)shader->ir.nir;
366
367 return zink_shader_create(zink_screen(pctx->screen), nir, &shader->stream_output);
368 }
369
370 static void
371 bind_stage(struct zink_context *ctx, enum pipe_shader_type stage,
372 struct zink_shader *shader)
373 {
374 assert(stage < PIPE_SHADER_COMPUTE);
375 ctx->gfx_stages[stage] = shader;
376 ctx->dirty_shader_stages |= 1 << stage;
377 }
378
379 static void
380 zink_bind_vs_state(struct pipe_context *pctx,
381 void *cso)
382 {
383 bind_stage(zink_context(pctx), PIPE_SHADER_VERTEX, cso);
384 }
385
386 static void
387 zink_delete_vs_state(struct pipe_context *pctx,
388 void *cso)
389 {
390 zink_shader_free(zink_context(pctx), cso);
391 }
392
393 static void *
394 zink_create_fs_state(struct pipe_context *pctx,
395 const struct pipe_shader_state *shader)
396 {
397 struct nir_shader *nir;
398 if (shader->type != PIPE_SHADER_IR_NIR)
399 nir = zink_tgsi_to_nir(pctx->screen, shader->tokens);
400 else
401 nir = (struct nir_shader *)shader->ir.nir;
402
403 return zink_shader_create(zink_screen(pctx->screen), nir, NULL);
404 }
405
406 static void
407 zink_bind_fs_state(struct pipe_context *pctx,
408 void *cso)
409 {
410 bind_stage(zink_context(pctx), PIPE_SHADER_FRAGMENT, cso);
411 }
412
413 static void
414 zink_delete_fs_state(struct pipe_context *pctx,
415 void *cso)
416 {
417 zink_shader_free(zink_context(pctx), cso);
418 }
419
420
421 void
422 zink_program_init(struct zink_context *ctx)
423 {
424 ctx->base.create_vs_state = zink_create_vs_state;
425 ctx->base.bind_vs_state = zink_bind_vs_state;
426 ctx->base.delete_vs_state = zink_delete_vs_state;
427
428 ctx->base.create_fs_state = zink_create_fs_state;
429 ctx->base.bind_fs_state = zink_bind_fs_state;
430 ctx->base.delete_fs_state = zink_delete_fs_state;
431 }