2 * Copyright © 2014 Intel Corporation
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
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
25 * \file shader_cache.cpp
27 * GLSL shader cache implementation
29 * This uses disk_cache.c to write out a serialization of various
30 * state that's required in order to successfully load and use a
31 * binary written out by a drivers backend, this state is referred to as
32 * "metadata" throughout the implementation.
34 * The hash key for glsl metadata is a hash of the hashes of each GLSL
35 * source string as well as some API settings that change the final program
36 * such as SSO, attribute bindings, frag data bindings, etc.
38 * In order to avoid caching any actual IR we use the put_key/get_key support
39 * in the disk_cache to put the SHA-1 hash for each successfully compiled
40 * shader into the cache, and optimisticly return early from glCompileShader
41 * (if the identical shader had been successfully compiled in the past),
42 * in the hope that the final linked shader will be found in the cache.
43 * If anything goes wrong (shader variant not found, backend cache item is
44 * corrupt, etc) we will use a fallback path to compile and link the IR.
48 #include "compiler/shader_info.h"
49 #include "glsl_symbol_table.h"
50 #include "glsl_parser_extras.h"
52 #include "ir_optimization.h"
53 #include "ir_rvalue_visitor.h"
54 #include "ir_uniform.h"
56 #include "link_varyings.h"
57 #include "main/core.h"
60 #include "shader_cache.h"
61 #include "util/mesa-sha1.h"
62 #include "string_to_uint_map.h"
65 #include "main/enums.h"
66 #include "main/shaderobj.h"
67 #include "program/program.h"
71 compile_shaders(struct gl_context
*ctx
, struct gl_shader_program
*prog
) {
72 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
73 _mesa_glsl_compile_shader(ctx
, prog
->Shaders
[i
], false, false, true);
78 write_subroutines(struct blob
*metadata
, struct gl_shader_program
*prog
)
80 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
81 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
85 struct gl_program
*glprog
= sh
->Program
;
87 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineUniforms
);
88 blob_write_uint32(metadata
, glprog
->sh
.MaxSubroutineFunctionIndex
);
89 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineFunctions
);
90 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineFunctions
; j
++) {
91 int num_types
= glprog
->sh
.SubroutineFunctions
[j
].num_compat_types
;
93 blob_write_string(metadata
, glprog
->sh
.SubroutineFunctions
[j
].name
);
94 blob_write_uint32(metadata
, glprog
->sh
.SubroutineFunctions
[j
].index
);
95 blob_write_uint32(metadata
, num_types
);
97 for (int k
= 0; k
< num_types
; k
++) {
98 encode_type_to_blob(metadata
,
99 glprog
->sh
.SubroutineFunctions
[j
].types
[k
]);
106 read_subroutines(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
108 struct gl_subroutine_function
*subs
;
110 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
111 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
115 struct gl_program
*glprog
= sh
->Program
;
117 glprog
->sh
.NumSubroutineUniforms
= blob_read_uint32(metadata
);
118 glprog
->sh
.MaxSubroutineFunctionIndex
= blob_read_uint32(metadata
);
119 glprog
->sh
.NumSubroutineFunctions
= blob_read_uint32(metadata
);
121 subs
= rzalloc_array(prog
, struct gl_subroutine_function
,
122 glprog
->sh
.NumSubroutineFunctions
);
123 glprog
->sh
.SubroutineFunctions
= subs
;
125 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineFunctions
; j
++) {
126 subs
[j
].name
= ralloc_strdup(prog
, blob_read_string (metadata
));
127 subs
[j
].index
= (int) blob_read_uint32(metadata
);
128 subs
[j
].num_compat_types
= (int) blob_read_uint32(metadata
);
130 subs
[j
].types
= rzalloc_array(prog
, const struct glsl_type
*,
131 subs
[j
].num_compat_types
);
132 for (int k
= 0; k
< subs
[j
].num_compat_types
; k
++) {
133 subs
[j
].types
[k
] = decode_type_from_blob(metadata
);
140 write_buffer_block(struct blob
*metadata
, struct gl_uniform_block
*b
)
142 blob_write_string(metadata
, b
->Name
);
143 blob_write_uint32(metadata
, b
->NumUniforms
);
144 blob_write_uint32(metadata
, b
->Binding
);
145 blob_write_uint32(metadata
, b
->UniformBufferSize
);
146 blob_write_uint32(metadata
, b
->stageref
);
148 for (unsigned j
= 0; j
< b
->NumUniforms
; j
++) {
149 blob_write_string(metadata
, b
->Uniforms
[j
].Name
);
150 blob_write_string(metadata
, b
->Uniforms
[j
].IndexName
);
151 encode_type_to_blob(metadata
, b
->Uniforms
[j
].Type
);
152 blob_write_uint32(metadata
, b
->Uniforms
[j
].Offset
);
157 write_buffer_blocks(struct blob
*metadata
, struct gl_shader_program
*prog
)
159 blob_write_uint32(metadata
, prog
->data
->NumUniformBlocks
);
160 blob_write_uint32(metadata
, prog
->data
->NumShaderStorageBlocks
);
162 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
163 write_buffer_block(metadata
, &prog
->data
->UniformBlocks
[i
]);
166 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
167 write_buffer_block(metadata
, &prog
->data
->ShaderStorageBlocks
[i
]);
170 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
171 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
175 struct gl_program
*glprog
= sh
->Program
;
177 blob_write_uint32(metadata
, glprog
->info
.num_ubos
);
178 blob_write_uint32(metadata
, glprog
->info
.num_ssbos
);
180 for (unsigned j
= 0; j
< glprog
->info
.num_ubos
; j
++) {
182 glprog
->sh
.UniformBlocks
[j
] - prog
->data
->UniformBlocks
;
183 blob_write_uint32(metadata
, offset
);
186 for (unsigned j
= 0; j
< glprog
->info
.num_ssbos
; j
++) {
187 uint32_t offset
= glprog
->sh
.ShaderStorageBlocks
[j
] -
188 prog
->data
->ShaderStorageBlocks
;
189 blob_write_uint32(metadata
, offset
);
195 read_buffer_block(struct blob_reader
*metadata
, struct gl_uniform_block
*b
,
196 struct gl_shader_program
*prog
)
198 b
->Name
= ralloc_strdup(prog
->data
, blob_read_string (metadata
));
199 b
->NumUniforms
= blob_read_uint32(metadata
);
200 b
->Binding
= blob_read_uint32(metadata
);
201 b
->UniformBufferSize
= blob_read_uint32(metadata
);
202 b
->stageref
= blob_read_uint32(metadata
);
205 rzalloc_array(prog
->data
, struct gl_uniform_buffer_variable
,
207 for (unsigned j
= 0; j
< b
->NumUniforms
; j
++) {
208 b
->Uniforms
[j
].Name
= ralloc_strdup(prog
->data
,
209 blob_read_string (metadata
));
211 char *index_name
= blob_read_string(metadata
);
212 if (strcmp(b
->Uniforms
[j
].Name
, index_name
) == 0) {
213 b
->Uniforms
[j
].IndexName
= b
->Uniforms
[j
].Name
;
215 b
->Uniforms
[j
].IndexName
= ralloc_strdup(prog
->data
, index_name
);
218 b
->Uniforms
[j
].Type
= decode_type_from_blob(metadata
);
219 b
->Uniforms
[j
].Offset
= blob_read_uint32(metadata
);
224 read_buffer_blocks(struct blob_reader
*metadata
,
225 struct gl_shader_program
*prog
)
227 prog
->data
->NumUniformBlocks
= blob_read_uint32(metadata
);
228 prog
->data
->NumShaderStorageBlocks
= blob_read_uint32(metadata
);
230 prog
->data
->UniformBlocks
=
231 rzalloc_array(prog
->data
, struct gl_uniform_block
,
232 prog
->data
->NumUniformBlocks
);
234 prog
->data
->ShaderStorageBlocks
=
235 rzalloc_array(prog
->data
, struct gl_uniform_block
,
236 prog
->data
->NumShaderStorageBlocks
);
238 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
239 read_buffer_block(metadata
, &prog
->data
->UniformBlocks
[i
], prog
);
242 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
243 read_buffer_block(metadata
, &prog
->data
->ShaderStorageBlocks
[i
], prog
);
246 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
247 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
251 struct gl_program
*glprog
= sh
->Program
;
253 glprog
->info
.num_ubos
= blob_read_uint32(metadata
);
254 glprog
->info
.num_ssbos
= blob_read_uint32(metadata
);
256 glprog
->sh
.UniformBlocks
=
257 rzalloc_array(glprog
, gl_uniform_block
*, glprog
->info
.num_ubos
);
258 glprog
->sh
.ShaderStorageBlocks
=
259 rzalloc_array(glprog
, gl_uniform_block
*, glprog
->info
.num_ssbos
);
261 for (unsigned j
= 0; j
< glprog
->info
.num_ubos
; j
++) {
262 uint32_t offset
= blob_read_uint32(metadata
);
263 glprog
->sh
.UniformBlocks
[j
] = prog
->data
->UniformBlocks
+ offset
;
266 for (unsigned j
= 0; j
< glprog
->info
.num_ssbos
; j
++) {
267 uint32_t offset
= blob_read_uint32(metadata
);
268 glprog
->sh
.ShaderStorageBlocks
[j
] =
269 prog
->data
->ShaderStorageBlocks
+ offset
;
275 write_atomic_buffers(struct blob
*metadata
, struct gl_shader_program
*prog
)
277 blob_write_uint32(metadata
, prog
->data
->NumAtomicBuffers
);
279 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
280 if (prog
->_LinkedShaders
[i
]) {
281 struct gl_program
*glprog
= prog
->_LinkedShaders
[i
]->Program
;
282 blob_write_uint32(metadata
, glprog
->info
.num_abos
);
286 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
287 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].Binding
);
288 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].MinimumSize
);
289 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].NumUniforms
);
291 blob_write_bytes(metadata
, prog
->data
->AtomicBuffers
[i
].StageReferences
,
292 sizeof(prog
->data
->AtomicBuffers
[i
].StageReferences
));
294 for (unsigned j
= 0; j
< prog
->data
->AtomicBuffers
[i
].NumUniforms
; j
++) {
295 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].Uniforms
[j
]);
301 read_atomic_buffers(struct blob_reader
*metadata
,
302 struct gl_shader_program
*prog
)
304 prog
->data
->NumAtomicBuffers
= blob_read_uint32(metadata
);
305 prog
->data
->AtomicBuffers
=
306 rzalloc_array(prog
, gl_active_atomic_buffer
,
307 prog
->data
->NumAtomicBuffers
);
309 struct gl_active_atomic_buffer
**stage_buff_list
[MESA_SHADER_STAGES
];
310 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
311 if (prog
->_LinkedShaders
[i
]) {
312 struct gl_program
*glprog
= prog
->_LinkedShaders
[i
]->Program
;
314 glprog
->info
.num_abos
= blob_read_uint32(metadata
);
315 glprog
->sh
.AtomicBuffers
=
316 rzalloc_array(glprog
, gl_active_atomic_buffer
*,
317 glprog
->info
.num_abos
);
318 stage_buff_list
[i
] = glprog
->sh
.AtomicBuffers
;
322 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
323 prog
->data
->AtomicBuffers
[i
].Binding
= blob_read_uint32(metadata
);
324 prog
->data
->AtomicBuffers
[i
].MinimumSize
= blob_read_uint32(metadata
);
325 prog
->data
->AtomicBuffers
[i
].NumUniforms
= blob_read_uint32(metadata
);
327 blob_copy_bytes(metadata
,
328 (uint8_t *) &prog
->data
->AtomicBuffers
[i
].StageReferences
,
329 sizeof(prog
->data
->AtomicBuffers
[i
].StageReferences
));
331 prog
->data
->AtomicBuffers
[i
].Uniforms
= rzalloc_array(prog
, unsigned,
332 prog
->data
->AtomicBuffers
[i
].NumUniforms
);
334 for (unsigned j
= 0; j
< prog
->data
->AtomicBuffers
[i
].NumUniforms
; j
++) {
335 prog
->data
->AtomicBuffers
[i
].Uniforms
[j
] = blob_read_uint32(metadata
);
338 for (unsigned j
= 0; j
< MESA_SHADER_STAGES
; j
++) {
339 if (prog
->data
->AtomicBuffers
[i
].StageReferences
[j
]) {
340 *stage_buff_list
[j
] = &prog
->data
->AtomicBuffers
[i
];
341 stage_buff_list
[j
]++;
348 write_xfb(struct blob
*metadata
, struct gl_shader_program
*shProg
)
350 struct gl_program
*prog
= shProg
->last_vert_prog
;
353 blob_write_uint32(metadata
, ~0u);
357 struct gl_transform_feedback_info
*ltf
= prog
->sh
.LinkedTransformFeedback
;
359 blob_write_uint32(metadata
, prog
->info
.stage
);
361 blob_write_uint32(metadata
, ltf
->NumOutputs
);
362 blob_write_uint32(metadata
, ltf
->ActiveBuffers
);
363 blob_write_uint32(metadata
, ltf
->NumVarying
);
365 blob_write_bytes(metadata
, ltf
->Outputs
,
366 sizeof(struct gl_transform_feedback_output
) *
369 for (int i
= 0; i
< ltf
->NumVarying
; i
++) {
370 blob_write_string(metadata
, ltf
->Varyings
[i
].Name
);
371 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Type
);
372 blob_write_uint32(metadata
, ltf
->Varyings
[i
].BufferIndex
);
373 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Size
);
374 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Offset
);
377 blob_write_bytes(metadata
, ltf
->Buffers
,
378 sizeof(struct gl_transform_feedback_buffer
) *
379 MAX_FEEDBACK_BUFFERS
);
383 read_xfb(struct blob_reader
*metadata
, struct gl_shader_program
*shProg
)
385 unsigned xfb_stage
= blob_read_uint32(metadata
);
387 if (xfb_stage
== ~0u)
390 struct gl_program
*prog
= shProg
->_LinkedShaders
[xfb_stage
]->Program
;
391 struct gl_transform_feedback_info
*ltf
=
392 rzalloc(prog
, struct gl_transform_feedback_info
);
394 prog
->sh
.LinkedTransformFeedback
= ltf
;
395 shProg
->last_vert_prog
= prog
;
397 ltf
->NumOutputs
= blob_read_uint32(metadata
);
398 ltf
->ActiveBuffers
= blob_read_uint32(metadata
);
399 ltf
->NumVarying
= blob_read_uint32(metadata
);
401 ltf
->Outputs
= rzalloc_array(prog
, struct gl_transform_feedback_output
,
404 blob_copy_bytes(metadata
, (uint8_t *) ltf
->Outputs
,
405 sizeof(struct gl_transform_feedback_output
) *
408 ltf
->Varyings
= rzalloc_array(prog
,
409 struct gl_transform_feedback_varying_info
,
412 for (int i
= 0; i
< ltf
->NumVarying
; i
++) {
413 ltf
->Varyings
[i
].Name
= ralloc_strdup(prog
, blob_read_string(metadata
));
414 ltf
->Varyings
[i
].Type
= blob_read_uint32(metadata
);
415 ltf
->Varyings
[i
].BufferIndex
= blob_read_uint32(metadata
);
416 ltf
->Varyings
[i
].Size
= blob_read_uint32(metadata
);
417 ltf
->Varyings
[i
].Offset
= blob_read_uint32(metadata
);
420 blob_copy_bytes(metadata
, (uint8_t *) ltf
->Buffers
,
421 sizeof(struct gl_transform_feedback_buffer
) *
422 MAX_FEEDBACK_BUFFERS
);
426 has_uniform_storage(struct gl_shader_program
*prog
, unsigned idx
)
428 if (!prog
->data
->UniformStorage
[idx
].builtin
&&
429 !prog
->data
->UniformStorage
[idx
].is_shader_storage
&&
430 prog
->data
->UniformStorage
[idx
].block_index
== -1)
437 write_uniforms(struct blob
*metadata
, struct gl_shader_program
*prog
)
439 blob_write_uint32(metadata
, prog
->SamplersValidated
);
440 blob_write_uint32(metadata
, prog
->data
->NumUniformStorage
);
441 blob_write_uint32(metadata
, prog
->data
->NumUniformDataSlots
);
443 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
444 encode_type_to_blob(metadata
, prog
->data
->UniformStorage
[i
].type
);
445 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].array_elements
);
446 blob_write_string(metadata
, prog
->data
->UniformStorage
[i
].name
);
447 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].builtin
);
448 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].remap_location
);
449 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].block_index
);
450 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].atomic_buffer_index
);
451 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].offset
);
452 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].array_stride
);
453 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].hidden
);
454 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].is_shader_storage
);
455 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].active_shader_mask
);
456 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].matrix_stride
);
457 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].row_major
);
458 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].is_bindless
);
459 blob_write_uint32(metadata
,
460 prog
->data
->UniformStorage
[i
].num_compatible_subroutines
);
461 blob_write_uint32(metadata
,
462 prog
->data
->UniformStorage
[i
].top_level_array_size
);
463 blob_write_uint32(metadata
,
464 prog
->data
->UniformStorage
[i
].top_level_array_stride
);
466 if (has_uniform_storage(prog
, i
)) {
467 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].storage
-
468 prog
->data
->UniformDataSlots
);
471 blob_write_bytes(metadata
, prog
->data
->UniformStorage
[i
].opaque
,
472 sizeof(prog
->data
->UniformStorage
[i
].opaque
));
475 /* Here we cache all uniform values. We do this to retain values for
476 * uniforms with initialisers and also hidden uniforms that may be lowered
477 * constant arrays. We could possibly just store the values we need but for
478 * now we just store everything.
480 blob_write_uint32(metadata
, prog
->data
->NumHiddenUniforms
);
481 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
482 if (has_uniform_storage(prog
, i
)) {
484 prog
->data
->UniformStorage
[i
].type
->component_slots() *
485 MAX2(prog
->data
->UniformStorage
[i
].array_elements
, 1);
486 blob_write_bytes(metadata
, prog
->data
->UniformStorage
[i
].storage
,
487 sizeof(union gl_constant_value
) * vec_size
);
493 read_uniforms(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
495 struct gl_uniform_storage
*uniforms
;
496 union gl_constant_value
*data
;
498 prog
->SamplersValidated
= blob_read_uint32(metadata
);
499 prog
->data
->NumUniformStorage
= blob_read_uint32(metadata
);
500 prog
->data
->NumUniformDataSlots
= blob_read_uint32(metadata
);
502 uniforms
= rzalloc_array(prog
->data
, struct gl_uniform_storage
,
503 prog
->data
->NumUniformStorage
);
504 prog
->data
->UniformStorage
= uniforms
;
506 data
= rzalloc_array(uniforms
, union gl_constant_value
,
507 prog
->data
->NumUniformDataSlots
);
508 prog
->data
->UniformDataSlots
= data
;
510 prog
->UniformHash
= new string_to_uint_map
;
512 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
513 uniforms
[i
].type
= decode_type_from_blob(metadata
);
514 uniforms
[i
].array_elements
= blob_read_uint32(metadata
);
515 uniforms
[i
].name
= ralloc_strdup(prog
, blob_read_string (metadata
));
516 uniforms
[i
].builtin
= blob_read_uint32(metadata
);
517 uniforms
[i
].remap_location
= blob_read_uint32(metadata
);
518 uniforms
[i
].block_index
= blob_read_uint32(metadata
);
519 uniforms
[i
].atomic_buffer_index
= blob_read_uint32(metadata
);
520 uniforms
[i
].offset
= blob_read_uint32(metadata
);
521 uniforms
[i
].array_stride
= blob_read_uint32(metadata
);
522 uniforms
[i
].hidden
= blob_read_uint32(metadata
);
523 uniforms
[i
].is_shader_storage
= blob_read_uint32(metadata
);
524 uniforms
[i
].active_shader_mask
= blob_read_uint32(metadata
);
525 uniforms
[i
].matrix_stride
= blob_read_uint32(metadata
);
526 uniforms
[i
].row_major
= blob_read_uint32(metadata
);
527 uniforms
[i
].is_bindless
= blob_read_uint32(metadata
);
528 uniforms
[i
].num_compatible_subroutines
= blob_read_uint32(metadata
);
529 uniforms
[i
].top_level_array_size
= blob_read_uint32(metadata
);
530 uniforms
[i
].top_level_array_stride
= blob_read_uint32(metadata
);
531 prog
->UniformHash
->put(i
, uniforms
[i
].name
);
533 if (has_uniform_storage(prog
, i
)) {
534 uniforms
[i
].storage
= data
+ blob_read_uint32(metadata
);
537 memcpy(uniforms
[i
].opaque
,
538 blob_read_bytes(metadata
, sizeof(uniforms
[i
].opaque
)),
539 sizeof(uniforms
[i
].opaque
));
542 /* Restore uniform values. */
543 prog
->data
->NumHiddenUniforms
= blob_read_uint32(metadata
);
544 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
545 if (has_uniform_storage(prog
, i
)) {
547 prog
->data
->UniformStorage
[i
].type
->component_slots() *
548 MAX2(prog
->data
->UniformStorage
[i
].array_elements
, 1);
549 blob_copy_bytes(metadata
,
550 (uint8_t *) prog
->data
->UniformStorage
[i
].storage
,
551 sizeof(union gl_constant_value
) * vec_size
);
553 assert(vec_size
+ prog
->data
->UniformStorage
[i
].storage
<=
554 data
+ prog
->data
->NumUniformDataSlots
);
559 enum uniform_remap_type
561 remap_type_inactive_explicit_location
,
563 remap_type_uniform_offset
567 write_uniform_remap_table_entry(struct blob
*metadata
,
568 gl_uniform_storage
*uniform_storage
,
569 gl_uniform_storage
*entry
)
571 if (entry
== INACTIVE_UNIFORM_EXPLICIT_LOCATION
) {
572 blob_write_uint32(metadata
, remap_type_inactive_explicit_location
);
573 } else if (entry
== NULL
) {
574 blob_write_uint32(metadata
, remap_type_null_ptr
);
576 blob_write_uint32(metadata
, remap_type_uniform_offset
);
578 uint32_t offset
= entry
- uniform_storage
;
579 blob_write_uint32(metadata
, offset
);
584 write_uniform_remap_tables(struct blob
*metadata
,
585 struct gl_shader_program
*prog
)
587 blob_write_uint32(metadata
, prog
->NumUniformRemapTable
);
589 for (unsigned i
= 0; i
< prog
->NumUniformRemapTable
; i
++) {
590 write_uniform_remap_table_entry(metadata
, prog
->data
->UniformStorage
,
591 prog
->UniformRemapTable
[i
]);
594 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
595 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
597 struct gl_program
*glprog
= sh
->Program
;
598 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineUniformRemapTable
);
600 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineUniformRemapTable
; j
++) {
601 write_uniform_remap_table_entry(metadata
,
602 prog
->data
->UniformStorage
,
603 glprog
->sh
.SubroutineUniformRemapTable
[j
]);
610 read_uniform_remap_table_entry(struct blob_reader
*metadata
,
611 gl_uniform_storage
*uniform_storage
,
612 gl_uniform_storage
**entry
,
613 enum uniform_remap_type type
)
615 if (type
== remap_type_inactive_explicit_location
) {
616 *entry
= INACTIVE_UNIFORM_EXPLICIT_LOCATION
;
617 } else if (type
== remap_type_null_ptr
) {
620 uint32_t uni_offset
= blob_read_uint32(metadata
);
621 *entry
= uniform_storage
+ uni_offset
;
626 read_uniform_remap_tables(struct blob_reader
*metadata
,
627 struct gl_shader_program
*prog
)
629 prog
->NumUniformRemapTable
= blob_read_uint32(metadata
);
631 prog
->UniformRemapTable
= rzalloc_array(prog
, struct gl_uniform_storage
*,
632 prog
->NumUniformRemapTable
);
634 for (unsigned i
= 0; i
< prog
->NumUniformRemapTable
; i
++) {
635 enum uniform_remap_type type
=
636 (enum uniform_remap_type
) blob_read_uint32(metadata
);
638 read_uniform_remap_table_entry(metadata
, prog
->data
->UniformStorage
,
639 &prog
->UniformRemapTable
[i
], type
);
642 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
643 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
645 struct gl_program
*glprog
= sh
->Program
;
646 glprog
->sh
.NumSubroutineUniformRemapTable
= blob_read_uint32(metadata
);
648 glprog
->sh
.SubroutineUniformRemapTable
=
649 rzalloc_array(glprog
, struct gl_uniform_storage
*,
650 glprog
->sh
.NumSubroutineUniformRemapTable
);
652 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineUniformRemapTable
; j
++) {
653 enum uniform_remap_type type
=
654 (enum uniform_remap_type
) blob_read_uint32(metadata
);
656 read_uniform_remap_table_entry(metadata
,
657 prog
->data
->UniformStorage
,
658 &glprog
->sh
.SubroutineUniformRemapTable
[j
],
672 write_hash_table_entry(const char *key
, unsigned value
, void *closure
)
674 struct whte_closure
*whte
= (struct whte_closure
*) closure
;
676 blob_write_string(whte
->blob
, key
);
677 blob_write_uint32(whte
->blob
, value
);
683 write_hash_table(struct blob
*metadata
, struct string_to_uint_map
*hash
)
686 struct whte_closure whte
;
688 whte
.blob
= metadata
;
689 whte
.num_entries
= 0;
691 offset
= metadata
->size
;
693 /* Write a placeholder for the hashtable size. */
694 blob_write_uint32 (metadata
, 0);
696 hash
->iterate(write_hash_table_entry
, &whte
);
698 /* Overwrite with the computed number of entries written. */
699 blob_overwrite_uint32 (metadata
, offset
, whte
.num_entries
);
703 read_hash_table(struct blob_reader
*metadata
, struct string_to_uint_map
*hash
)
705 size_t i
, num_entries
;
709 num_entries
= blob_read_uint32 (metadata
);
711 for (i
= 0; i
< num_entries
; i
++) {
712 key
= blob_read_string(metadata
);
713 value
= blob_read_uint32(metadata
);
715 hash
->put(value
, key
);
720 write_hash_tables(struct blob
*metadata
, struct gl_shader_program
*prog
)
722 write_hash_table(metadata
, prog
->AttributeBindings
);
723 write_hash_table(metadata
, prog
->FragDataBindings
);
724 write_hash_table(metadata
, prog
->FragDataIndexBindings
);
728 read_hash_tables(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
730 read_hash_table(metadata
, prog
->AttributeBindings
);
731 read_hash_table(metadata
, prog
->FragDataBindings
);
732 read_hash_table(metadata
, prog
->FragDataIndexBindings
);
736 write_shader_subroutine_index(struct blob
*metadata
,
737 struct gl_linked_shader
*sh
,
738 struct gl_program_resource
*res
)
742 for (unsigned j
= 0; j
< sh
->Program
->sh
.NumSubroutineFunctions
; j
++) {
743 if (strcmp(((gl_subroutine_function
*)res
->Data
)->name
,
744 sh
->Program
->sh
.SubroutineFunctions
[j
].name
) == 0) {
745 blob_write_uint32(metadata
, j
);
752 get_shader_var_and_pointer_sizes(size_t *s_var_size
, size_t *s_var_ptrs
,
753 const gl_shader_variable
*var
)
755 *s_var_size
= sizeof(gl_shader_variable
);
758 sizeof(var
->interface_type
) +
759 sizeof(var
->outermost_struct_type
) +
764 write_program_resource_data(struct blob
*metadata
,
765 struct gl_shader_program
*prog
,
766 struct gl_program_resource
*res
)
768 struct gl_linked_shader
*sh
;
771 case GL_PROGRAM_INPUT
:
772 case GL_PROGRAM_OUTPUT
: {
773 const gl_shader_variable
*var
= (gl_shader_variable
*)res
->Data
;
775 encode_type_to_blob(metadata
, var
->type
);
776 encode_type_to_blob(metadata
, var
->interface_type
);
777 encode_type_to_blob(metadata
, var
->outermost_struct_type
);
779 blob_write_string(metadata
, var
->name
);
781 size_t s_var_size
, s_var_ptrs
;
782 get_shader_var_and_pointer_sizes(&s_var_size
, &s_var_ptrs
, var
);
784 /* Write gl_shader_variable skipping over the pointers */
785 blob_write_bytes(metadata
, ((char *)var
) + s_var_ptrs
,
786 s_var_size
- s_var_ptrs
);
789 case GL_UNIFORM_BLOCK
:
790 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
791 if (strcmp(((gl_uniform_block
*)res
->Data
)->Name
,
792 prog
->data
->UniformBlocks
[i
].Name
) == 0) {
793 blob_write_uint32(metadata
, i
);
798 case GL_SHADER_STORAGE_BLOCK
:
799 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
800 if (strcmp(((gl_uniform_block
*)res
->Data
)->Name
,
801 prog
->data
->ShaderStorageBlocks
[i
].Name
) == 0) {
802 blob_write_uint32(metadata
, i
);
807 case GL_BUFFER_VARIABLE
:
808 case GL_VERTEX_SUBROUTINE_UNIFORM
:
809 case GL_GEOMETRY_SUBROUTINE_UNIFORM
:
810 case GL_FRAGMENT_SUBROUTINE_UNIFORM
:
811 case GL_COMPUTE_SUBROUTINE_UNIFORM
:
812 case GL_TESS_CONTROL_SUBROUTINE_UNIFORM
:
813 case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM
:
815 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
816 if (strcmp(((gl_uniform_storage
*)res
->Data
)->name
,
817 prog
->data
->UniformStorage
[i
].name
) == 0) {
818 blob_write_uint32(metadata
, i
);
823 case GL_ATOMIC_COUNTER_BUFFER
:
824 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
825 if (((gl_active_atomic_buffer
*)res
->Data
)->Binding
==
826 prog
->data
->AtomicBuffers
[i
].Binding
) {
827 blob_write_uint32(metadata
, i
);
832 case GL_TRANSFORM_FEEDBACK_BUFFER
:
833 for (unsigned i
= 0; i
< MAX_FEEDBACK_BUFFERS
; i
++) {
834 if (((gl_transform_feedback_buffer
*)res
->Data
)->Binding
==
835 prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->Buffers
[i
].Binding
) {
836 blob_write_uint32(metadata
, i
);
841 case GL_TRANSFORM_FEEDBACK_VARYING
:
842 for (int i
= 0; i
< prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->NumVarying
; i
++) {
843 if (strcmp(((gl_transform_feedback_varying_info
*)res
->Data
)->Name
,
844 prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->Varyings
[i
].Name
) == 0) {
845 blob_write_uint32(metadata
, i
);
850 case GL_VERTEX_SUBROUTINE
:
851 case GL_TESS_CONTROL_SUBROUTINE
:
852 case GL_TESS_EVALUATION_SUBROUTINE
:
853 case GL_GEOMETRY_SUBROUTINE
:
854 case GL_FRAGMENT_SUBROUTINE
:
855 case GL_COMPUTE_SUBROUTINE
:
857 prog
->_LinkedShaders
[_mesa_shader_stage_from_subroutine(res
->Type
)];
858 write_shader_subroutine_index(metadata
, sh
, res
);
861 assert(!"Support for writing resource not yet implemented.");
866 read_program_resource_data(struct blob_reader
*metadata
,
867 struct gl_shader_program
*prog
,
868 struct gl_program_resource
*res
)
870 struct gl_linked_shader
*sh
;
873 case GL_PROGRAM_INPUT
:
874 case GL_PROGRAM_OUTPUT
: {
875 gl_shader_variable
*var
= ralloc(prog
, struct gl_shader_variable
);
877 var
->type
= decode_type_from_blob(metadata
);
878 var
->interface_type
= decode_type_from_blob(metadata
);
879 var
->outermost_struct_type
= decode_type_from_blob(metadata
);
881 var
->name
= ralloc_strdup(prog
, blob_read_string(metadata
));
883 size_t s_var_size
, s_var_ptrs
;
884 get_shader_var_and_pointer_sizes(&s_var_size
, &s_var_ptrs
, var
);
886 blob_copy_bytes(metadata
, ((uint8_t *) var
) + s_var_ptrs
,
887 s_var_size
- s_var_ptrs
);
892 case GL_UNIFORM_BLOCK
:
893 res
->Data
= &prog
->data
->UniformBlocks
[blob_read_uint32(metadata
)];
895 case GL_SHADER_STORAGE_BLOCK
:
896 res
->Data
= &prog
->data
->ShaderStorageBlocks
[blob_read_uint32(metadata
)];
898 case GL_BUFFER_VARIABLE
:
899 case GL_VERTEX_SUBROUTINE_UNIFORM
:
900 case GL_GEOMETRY_SUBROUTINE_UNIFORM
:
901 case GL_FRAGMENT_SUBROUTINE_UNIFORM
:
902 case GL_COMPUTE_SUBROUTINE_UNIFORM
:
903 case GL_TESS_CONTROL_SUBROUTINE_UNIFORM
:
904 case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM
:
906 res
->Data
= &prog
->data
->UniformStorage
[blob_read_uint32(metadata
)];
908 case GL_ATOMIC_COUNTER_BUFFER
:
909 res
->Data
= &prog
->data
->AtomicBuffers
[blob_read_uint32(metadata
)];
911 case GL_TRANSFORM_FEEDBACK_BUFFER
:
912 res
->Data
= &prog
->last_vert_prog
->
913 sh
.LinkedTransformFeedback
->Buffers
[blob_read_uint32(metadata
)];
915 case GL_TRANSFORM_FEEDBACK_VARYING
:
916 res
->Data
= &prog
->last_vert_prog
->
917 sh
.LinkedTransformFeedback
->Varyings
[blob_read_uint32(metadata
)];
919 case GL_VERTEX_SUBROUTINE
:
920 case GL_TESS_CONTROL_SUBROUTINE
:
921 case GL_TESS_EVALUATION_SUBROUTINE
:
922 case GL_GEOMETRY_SUBROUTINE
:
923 case GL_FRAGMENT_SUBROUTINE
:
924 case GL_COMPUTE_SUBROUTINE
:
926 prog
->_LinkedShaders
[_mesa_shader_stage_from_subroutine(res
->Type
)];
928 &sh
->Program
->sh
.SubroutineFunctions
[blob_read_uint32(metadata
)];
931 assert(!"Support for reading resource not yet implemented.");
936 write_program_resource_list(struct blob
*metadata
,
937 struct gl_shader_program
*prog
)
939 blob_write_uint32(metadata
, prog
->data
->NumProgramResourceList
);
941 for (unsigned i
= 0; i
< prog
->data
->NumProgramResourceList
; i
++) {
942 blob_write_uint32(metadata
, prog
->data
->ProgramResourceList
[i
].Type
);
943 write_program_resource_data(metadata
, prog
,
944 &prog
->data
->ProgramResourceList
[i
]);
945 blob_write_bytes(metadata
,
946 &prog
->data
->ProgramResourceList
[i
].StageReferences
,
947 sizeof(prog
->data
->ProgramResourceList
[i
].StageReferences
));
952 read_program_resource_list(struct blob_reader
*metadata
,
953 struct gl_shader_program
*prog
)
955 prog
->data
->NumProgramResourceList
= blob_read_uint32(metadata
);
957 prog
->data
->ProgramResourceList
=
958 ralloc_array(prog
->data
, gl_program_resource
,
959 prog
->data
->NumProgramResourceList
);
961 for (unsigned i
= 0; i
< prog
->data
->NumProgramResourceList
; i
++) {
962 prog
->data
->ProgramResourceList
[i
].Type
= blob_read_uint32(metadata
);
963 read_program_resource_data(metadata
, prog
,
964 &prog
->data
->ProgramResourceList
[i
]);
965 blob_copy_bytes(metadata
,
966 (uint8_t *) &prog
->data
->ProgramResourceList
[i
].StageReferences
,
967 sizeof(prog
->data
->ProgramResourceList
[i
].StageReferences
));
972 write_shader_parameters(struct blob
*metadata
,
973 struct gl_program_parameter_list
*params
)
975 blob_write_uint32(metadata
, params
->NumParameters
);
978 while (i
< params
->NumParameters
) {
979 struct gl_program_parameter
*param
= ¶ms
->Parameters
[i
];
981 blob_write_uint32(metadata
, param
->Type
);
982 blob_write_string(metadata
, param
->Name
);
983 blob_write_uint32(metadata
, param
->Size
);
984 blob_write_uint32(metadata
, param
->DataType
);
985 blob_write_bytes(metadata
, param
->StateIndexes
,
986 sizeof(param
->StateIndexes
));
988 i
+= (param
->Size
+ 3) / 4;
991 blob_write_bytes(metadata
, params
->ParameterValues
,
992 sizeof(gl_constant_value
) * 4 * params
->NumParameters
);
994 blob_write_uint32(metadata
, params
->StateFlags
);
998 read_shader_parameters(struct blob_reader
*metadata
,
999 struct gl_program_parameter_list
*params
)
1001 gl_state_index state_indexes
[STATE_LENGTH
];
1003 uint32_t num_parameters
= blob_read_uint32(metadata
);
1005 _mesa_reserve_parameter_storage(params
, num_parameters
);
1006 while (i
< num_parameters
) {
1007 gl_register_file type
= (gl_register_file
) blob_read_uint32(metadata
);
1008 const char *name
= blob_read_string(metadata
);
1009 unsigned size
= blob_read_uint32(metadata
);
1010 unsigned data_type
= blob_read_uint32(metadata
);
1011 blob_copy_bytes(metadata
, (uint8_t *) state_indexes
,
1012 sizeof(state_indexes
));
1014 _mesa_add_parameter(params
, type
, name
, size
, data_type
,
1015 NULL
, state_indexes
);
1017 i
+= (size
+ 3) / 4;
1020 blob_copy_bytes(metadata
, (uint8_t *) params
->ParameterValues
,
1021 sizeof(gl_constant_value
) * 4 * params
->NumParameters
);
1023 params
->StateFlags
= blob_read_uint32(metadata
);
1027 write_shader_metadata(struct blob
*metadata
, gl_linked_shader
*shader
)
1029 assert(shader
->Program
);
1030 struct gl_program
*glprog
= shader
->Program
;
1033 blob_write_bytes(metadata
, glprog
->TexturesUsed
,
1034 sizeof(glprog
->TexturesUsed
));
1035 blob_write_uint64(metadata
, glprog
->SamplersUsed
);
1037 blob_write_bytes(metadata
, glprog
->SamplerUnits
,
1038 sizeof(glprog
->SamplerUnits
));
1039 blob_write_bytes(metadata
, glprog
->sh
.SamplerTargets
,
1040 sizeof(glprog
->sh
.SamplerTargets
));
1041 blob_write_uint32(metadata
, glprog
->ShadowSamplers
);
1043 blob_write_bytes(metadata
, glprog
->sh
.ImageAccess
,
1044 sizeof(glprog
->sh
.ImageAccess
));
1045 blob_write_bytes(metadata
, glprog
->sh
.ImageUnits
,
1046 sizeof(glprog
->sh
.ImageUnits
));
1048 size_t ptr_size
= sizeof(GLvoid
*);
1050 blob_write_uint32(metadata
, glprog
->sh
.NumBindlessSamplers
);
1051 blob_write_uint32(metadata
, glprog
->sh
.HasBoundBindlessSampler
);
1052 for (i
= 0; i
< glprog
->sh
.NumBindlessSamplers
; i
++) {
1053 blob_write_bytes(metadata
, &glprog
->sh
.BindlessSamplers
[i
],
1054 sizeof(struct gl_bindless_sampler
) - ptr_size
);
1057 blob_write_uint32(metadata
, glprog
->sh
.NumBindlessImages
);
1058 blob_write_uint32(metadata
, glprog
->sh
.HasBoundBindlessImage
);
1059 for (i
= 0; i
< glprog
->sh
.NumBindlessImages
; i
++) {
1060 blob_write_bytes(metadata
, &glprog
->sh
.BindlessImages
[i
],
1061 sizeof(struct gl_bindless_image
) - ptr_size
);
1064 blob_write_bytes(metadata
, &glprog
->sh
.fs
.BlendSupport
,
1065 sizeof(glprog
->sh
.fs
.BlendSupport
));
1067 write_shader_parameters(metadata
, glprog
->Parameters
);
1069 assert((glprog
->driver_cache_blob
== NULL
) ==
1070 (glprog
->driver_cache_blob_size
== 0));
1071 blob_write_uint32(metadata
, (uint32_t)glprog
->driver_cache_blob_size
);
1072 if (glprog
->driver_cache_blob_size
> 0) {
1073 blob_write_bytes(metadata
, glprog
->driver_cache_blob
,
1074 glprog
->driver_cache_blob_size
);
1079 read_shader_metadata(struct blob_reader
*metadata
,
1080 struct gl_program
*glprog
,
1081 gl_linked_shader
*linked
)
1085 blob_copy_bytes(metadata
, (uint8_t *) glprog
->TexturesUsed
,
1086 sizeof(glprog
->TexturesUsed
));
1087 glprog
->SamplersUsed
= blob_read_uint64(metadata
);
1089 blob_copy_bytes(metadata
, (uint8_t *) glprog
->SamplerUnits
,
1090 sizeof(glprog
->SamplerUnits
));
1091 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.SamplerTargets
,
1092 sizeof(glprog
->sh
.SamplerTargets
));
1093 glprog
->ShadowSamplers
= blob_read_uint32(metadata
);
1095 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.ImageAccess
,
1096 sizeof(glprog
->sh
.ImageAccess
));
1097 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.ImageUnits
,
1098 sizeof(glprog
->sh
.ImageUnits
));
1100 size_t ptr_size
= sizeof(GLvoid
*);
1102 glprog
->sh
.NumBindlessSamplers
= blob_read_uint32(metadata
);
1103 glprog
->sh
.HasBoundBindlessSampler
= blob_read_uint32(metadata
);
1104 if (glprog
->sh
.NumBindlessSamplers
> 0) {
1105 glprog
->sh
.BindlessSamplers
=
1106 rzalloc_array(glprog
, gl_bindless_sampler
,
1107 glprog
->sh
.NumBindlessSamplers
);
1109 for (i
= 0; i
< glprog
->sh
.NumBindlessSamplers
; i
++) {
1110 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->sh
.BindlessSamplers
[i
],
1111 sizeof(struct gl_bindless_sampler
) - ptr_size
);
1115 glprog
->sh
.NumBindlessImages
= blob_read_uint32(metadata
);
1116 glprog
->sh
.HasBoundBindlessImage
= blob_read_uint32(metadata
);
1117 if (glprog
->sh
.NumBindlessImages
> 0) {
1118 glprog
->sh
.BindlessImages
=
1119 rzalloc_array(glprog
, gl_bindless_image
,
1120 glprog
->sh
.NumBindlessImages
);
1122 for (i
= 0; i
< glprog
->sh
.NumBindlessImages
; i
++) {
1123 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->sh
.BindlessImages
[i
],
1124 sizeof(struct gl_bindless_image
) - ptr_size
);
1128 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->sh
.fs
.BlendSupport
,
1129 sizeof(glprog
->sh
.fs
.BlendSupport
));
1131 glprog
->Parameters
= _mesa_new_parameter_list();
1132 read_shader_parameters(metadata
, glprog
->Parameters
);
1134 glprog
->driver_cache_blob_size
= (size_t)blob_read_uint32(metadata
);
1135 if (glprog
->driver_cache_blob_size
> 0) {
1136 glprog
->driver_cache_blob
=
1137 (uint8_t*)ralloc_size(glprog
, glprog
->driver_cache_blob_size
);
1138 blob_copy_bytes(metadata
, glprog
->driver_cache_blob
,
1139 glprog
->driver_cache_blob_size
);
1144 create_binding_str(const char *key
, unsigned value
, void *closure
)
1146 char **bindings_str
= (char **) closure
;
1147 ralloc_asprintf_append(bindings_str
, "%s:%u,", key
, value
);
1151 get_shader_info_and_pointer_sizes(size_t *s_info_size
, size_t *s_info_ptrs
,
1154 *s_info_size
= sizeof(shader_info
);
1155 *s_info_ptrs
= sizeof(info
->name
) + sizeof(info
->label
);
1159 create_linked_shader_and_program(struct gl_context
*ctx
,
1160 gl_shader_stage stage
,
1161 struct gl_shader_program
*prog
,
1162 struct blob_reader
*metadata
)
1164 struct gl_program
*glprog
;
1166 struct gl_linked_shader
*linked
= rzalloc(NULL
, struct gl_linked_shader
);
1167 linked
->Stage
= stage
;
1169 glprog
= ctx
->Driver
.NewProgram(ctx
, _mesa_shader_stage_to_program(stage
),
1171 glprog
->info
.stage
= stage
;
1172 linked
->Program
= glprog
;
1174 read_shader_metadata(metadata
, glprog
, linked
);
1176 glprog
->info
.name
= ralloc_strdup(glprog
, blob_read_string(metadata
));
1177 glprog
->info
.label
= ralloc_strdup(glprog
, blob_read_string(metadata
));
1179 size_t s_info_size
, s_info_ptrs
;
1180 get_shader_info_and_pointer_sizes(&s_info_size
, &s_info_ptrs
,
1183 /* Restore shader info */
1184 blob_copy_bytes(metadata
, ((uint8_t *) &glprog
->info
) + s_info_ptrs
,
1185 s_info_size
- s_info_ptrs
);
1187 _mesa_reference_shader_program_data(ctx
, &glprog
->sh
.data
, prog
->data
);
1188 _mesa_reference_program(ctx
, &linked
->Program
, glprog
);
1189 prog
->_LinkedShaders
[stage
] = linked
;
1193 shader_cache_write_program_metadata(struct gl_context
*ctx
,
1194 struct gl_shader_program
*prog
)
1196 struct disk_cache
*cache
= ctx
->Cache
;
1200 /* Exit early when we are dealing with a ff shader with no source file to
1201 * generate a source from.
1203 * TODO: In future we should use another method to generate a key for ff
1206 static const char zero
[sizeof(prog
->data
->sha1
)] = {0};
1207 if (memcmp(prog
->data
->sha1
, zero
, sizeof(prog
->data
->sha1
)) == 0)
1210 struct blob metadata
;
1211 blob_init(&metadata
);
1213 write_uniforms(&metadata
, prog
);
1215 write_hash_tables(&metadata
, prog
);
1217 blob_write_uint32(&metadata
, prog
->data
->Version
);
1218 blob_write_uint32(&metadata
, prog
->data
->linked_stages
);
1220 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1221 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
1223 write_shader_metadata(&metadata
, sh
);
1225 if (sh
->Program
->info
.name
)
1226 blob_write_string(&metadata
, sh
->Program
->info
.name
);
1228 blob_write_string(&metadata
, "");
1230 if (sh
->Program
->info
.label
)
1231 blob_write_string(&metadata
, sh
->Program
->info
.label
);
1233 blob_write_string(&metadata
, "");
1235 size_t s_info_size
, s_info_ptrs
;
1236 get_shader_info_and_pointer_sizes(&s_info_size
, &s_info_ptrs
,
1237 &sh
->Program
->info
);
1239 /* Store shader info */
1240 blob_write_bytes(&metadata
,
1241 ((char *) &sh
->Program
->info
) + s_info_ptrs
,
1242 s_info_size
- s_info_ptrs
);
1246 write_xfb(&metadata
, prog
);
1248 write_uniform_remap_tables(&metadata
, prog
);
1250 write_atomic_buffers(&metadata
, prog
);
1252 write_buffer_blocks(&metadata
, prog
);
1254 write_subroutines(&metadata
, prog
);
1256 write_program_resource_list(&metadata
, prog
);
1258 struct cache_item_metadata cache_item_metadata
;
1259 cache_item_metadata
.type
= CACHE_ITEM_TYPE_GLSL
;
1260 cache_item_metadata
.keys
=
1261 (cache_key
*) malloc(prog
->NumShaders
* sizeof(cache_key
));
1262 cache_item_metadata
.num_keys
= prog
->NumShaders
;
1264 if (!cache_item_metadata
.keys
)
1268 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
1269 disk_cache_put_key(cache
, prog
->Shaders
[i
]->sha1
);
1270 memcpy(cache_item_metadata
.keys
[i
], prog
->Shaders
[i
]->sha1
,
1272 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1273 _mesa_sha1_format(sha1_buf
, prog
->Shaders
[i
]->sha1
);
1274 fprintf(stderr
, "marking shader: %s\n", sha1_buf
);
1278 disk_cache_put(cache
, prog
->data
->sha1
, metadata
.data
, metadata
.size
,
1279 &cache_item_metadata
);
1281 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1282 _mesa_sha1_format(sha1_buf
, prog
->data
->sha1
);
1283 fprintf(stderr
, "putting program metadata in cache: %s\n", sha1_buf
);
1287 free(cache_item_metadata
.keys
);
1288 blob_finish(&metadata
);
1292 shader_cache_read_program_metadata(struct gl_context
*ctx
,
1293 struct gl_shader_program
*prog
)
1295 /* Fixed function programs generated by Mesa are not cached. So don't
1296 * try to read metadata for them from the cache.
1298 if (prog
->Name
== 0)
1301 struct disk_cache
*cache
= ctx
->Cache
;
1302 if (!cache
|| prog
->data
->skip_cache
)
1305 /* Include bindings when creating sha1. These bindings change the resulting
1306 * binary so they are just as important as the shader source.
1308 char *buf
= ralloc_strdup(NULL
, "vb: ");
1309 prog
->AttributeBindings
->iterate(create_binding_str
, &buf
);
1310 ralloc_strcat(&buf
, "fb: ");
1311 prog
->FragDataBindings
->iterate(create_binding_str
, &buf
);
1312 ralloc_strcat(&buf
, "fbi: ");
1313 prog
->FragDataIndexBindings
->iterate(create_binding_str
, &buf
);
1315 /* SSO has an effect on the linked program so include this when generating
1318 ralloc_asprintf_append(&buf
, "sso: %s\n",
1319 prog
->SeparateShader
? "T" : "F");
1321 /* A shader might end up producing different output depending on the glsl
1322 * version supported by the compiler. For example a different path might be
1323 * taken by the preprocessor, so add the version to the hash input.
1325 ralloc_asprintf_append(&buf
, "api: %d glsl: %d fglsl: %d\n",
1326 ctx
->API
, ctx
->Const
.GLSLVersion
,
1327 ctx
->Const
.ForceGLSLVersion
);
1329 /* We run the preprocessor on shaders after hashing them, so we need to
1330 * add any extension override vars to the hash. If we don't do this the
1331 * preprocessor could result in different output and we could load the
1334 char *ext_override
= getenv("MESA_EXTENSION_OVERRIDE");
1336 ralloc_asprintf_append(&buf
, "ext:%s", ext_override
);
1339 /* DRI config options may also change the output from the compiler so
1340 * include them as an input to sha1 creation.
1343 _mesa_sha1_format(sha1buf
, ctx
->Const
.dri_config_options_sha1
);
1344 ralloc_strcat(&buf
, sha1buf
);
1346 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
1347 struct gl_shader
*sh
= prog
->Shaders
[i
];
1348 _mesa_sha1_format(sha1buf
, sh
->sha1
);
1349 ralloc_asprintf_append(&buf
, "%s: %s\n",
1350 _mesa_shader_stage_to_abbrev(sh
->Stage
), sha1buf
);
1352 disk_cache_compute_key(cache
, buf
, strlen(buf
), prog
->data
->sha1
);
1356 uint8_t *buffer
= (uint8_t *) disk_cache_get(cache
, prog
->data
->sha1
,
1358 if (buffer
== NULL
) {
1359 /* Cached program not found. We may have seen the individual shaders
1360 * before and skipped compiling but they may not have been used together
1361 * in this combination before. Fall back to linking shaders but first
1362 * re-compile the shaders.
1364 * We could probably only compile the shaders which were skipped here
1365 * but we need to be careful because the source may also have been
1366 * changed since the last compile so for now we just recompile
1369 compile_shaders(ctx
, prog
);
1373 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1374 _mesa_sha1_format(sha1buf
, prog
->data
->sha1
);
1375 fprintf(stderr
, "loading shader program meta data from cache: %s\n",
1379 struct blob_reader metadata
;
1380 blob_reader_init(&metadata
, buffer
, size
);
1382 assert(prog
->data
->UniformStorage
== NULL
);
1384 read_uniforms(&metadata
, prog
);
1386 read_hash_tables(&metadata
, prog
);
1388 prog
->data
->Version
= blob_read_uint32(&metadata
);
1389 prog
->data
->linked_stages
= blob_read_uint32(&metadata
);
1391 unsigned mask
= prog
->data
->linked_stages
;
1393 const int j
= u_bit_scan(&mask
);
1394 create_linked_shader_and_program(ctx
, (gl_shader_stage
) j
, prog
,
1398 read_xfb(&metadata
, prog
);
1400 read_uniform_remap_tables(&metadata
, prog
);
1402 read_atomic_buffers(&metadata
, prog
);
1404 read_buffer_blocks(&metadata
, prog
);
1406 read_subroutines(&metadata
, prog
);
1408 read_program_resource_list(&metadata
, prog
);
1410 if (metadata
.current
!= metadata
.end
|| metadata
.overrun
) {
1411 /* Something has gone wrong discard the item from the cache and rebuild
1414 assert(!"Invalid GLSL shader disk cache item!");
1416 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1417 fprintf(stderr
, "Error reading program from cache (invalid GLSL "
1421 disk_cache_remove(cache
, prog
->data
->sha1
);
1422 compile_shaders(ctx
, prog
);
1427 /* This is used to flag a shader retrieved from cache */
1428 prog
->data
->LinkStatus
= linking_skipped
;
1430 /* Since the program load was successful, CompileStatus of all shaders at
1431 * this point should normally be compile_skipped. However because of how
1432 * the eviction works, it may happen that some of the individual shader keys
1433 * have been evicted, resulting in unnecessary recompiles on this load, so
1434 * mark them again to skip such recompiles next time.
1437 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
1438 if (prog
->Shaders
[i
]->CompileStatus
== compiled_no_opts
) {
1439 disk_cache_put_key(cache
, prog
->Shaders
[i
]->sha1
);
1440 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1441 _mesa_sha1_format(sha1_buf
, prog
->Shaders
[i
]->sha1
);
1442 fprintf(stderr
, "re-marking shader: %s\n", sha1_buf
);