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 "util/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 get_struct_type_field_and_pointer_sizes(size_t *s_field_size
,
81 *s_field_size
= sizeof(glsl_struct_field
);
83 sizeof(((glsl_struct_field
*)0)->type
) +
84 sizeof(((glsl_struct_field
*)0)->name
);
88 encode_type_to_blob(struct blob
*blob
, const glsl_type
*type
)
93 blob_write_uint32(blob
, 0);
97 switch (type
->base_type
) {
100 case GLSL_TYPE_FLOAT
:
102 case GLSL_TYPE_DOUBLE
:
103 case GLSL_TYPE_UINT64
:
104 case GLSL_TYPE_INT64
:
105 encoding
= (type
->base_type
<< 24) |
106 (type
->vector_elements
<< 4) |
107 (type
->matrix_columns
);
109 case GLSL_TYPE_SAMPLER
:
110 encoding
= (type
->base_type
) << 24 |
111 (type
->sampler_dimensionality
<< 4) |
112 (type
->sampler_shadow
<< 3) |
113 (type
->sampler_array
<< 2) |
114 (type
->sampled_type
);
116 case GLSL_TYPE_SUBROUTINE
:
117 encoding
= type
->base_type
<< 24;
118 blob_write_uint32(blob
, encoding
);
119 blob_write_string(blob
, type
->name
);
121 case GLSL_TYPE_IMAGE
:
122 encoding
= (type
->base_type
) << 24 |
123 (type
->sampler_dimensionality
<< 3) |
124 (type
->sampler_array
<< 2) |
125 (type
->sampled_type
);
127 case GLSL_TYPE_ATOMIC_UINT
:
128 encoding
= (type
->base_type
<< 24);
130 case GLSL_TYPE_ARRAY
:
131 blob_write_uint32(blob
, (type
->base_type
) << 24);
132 blob_write_uint32(blob
, type
->length
);
133 encode_type_to_blob(blob
, type
->fields
.array
);
135 case GLSL_TYPE_STRUCT
:
136 case GLSL_TYPE_INTERFACE
:
137 blob_write_uint32(blob
, (type
->base_type
) << 24);
138 blob_write_string(blob
, type
->name
);
139 blob_write_uint32(blob
, type
->length
);
141 size_t s_field_size
, s_field_ptrs
;
142 get_struct_type_field_and_pointer_sizes(&s_field_size
, &s_field_ptrs
);
144 for (unsigned i
= 0; i
< type
->length
; i
++) {
145 encode_type_to_blob(blob
, type
->fields
.structure
[i
].type
);
146 blob_write_string(blob
, type
->fields
.structure
[i
].name
);
148 /* Write the struct field skipping the pointers */
149 blob_write_bytes(blob
,
150 ((char *)&type
->fields
.structure
[i
]) + s_field_ptrs
,
151 s_field_size
- s_field_ptrs
);
154 if (type
->is_interface()) {
155 blob_write_uint32(blob
, type
->interface_packing
);
156 blob_write_uint32(blob
, type
->interface_row_major
);
160 case GLSL_TYPE_ERROR
:
162 assert(!"Cannot encode type!");
167 blob_write_uint32(blob
, encoding
);
170 static const glsl_type
*
171 decode_type_from_blob(struct blob_reader
*blob
)
173 uint32_t u
= blob_read_uint32(blob
);
179 glsl_base_type base_type
= (glsl_base_type
) (u
>> 24);
184 case GLSL_TYPE_FLOAT
:
186 case GLSL_TYPE_DOUBLE
:
187 case GLSL_TYPE_UINT64
:
188 case GLSL_TYPE_INT64
:
189 return glsl_type::get_instance(base_type
, (u
>> 4) & 0x0f, u
& 0x0f);
190 case GLSL_TYPE_SAMPLER
:
191 return glsl_type::get_sampler_instance((enum glsl_sampler_dim
) ((u
>> 4) & 0x07),
194 (glsl_base_type
) ((u
>> 0) & 0x03));
195 case GLSL_TYPE_SUBROUTINE
:
196 return glsl_type::get_subroutine_instance(blob_read_string(blob
));
197 case GLSL_TYPE_IMAGE
:
198 return glsl_type::get_image_instance((enum glsl_sampler_dim
) ((u
>> 3) & 0x07),
200 (glsl_base_type
) ((u
>> 0) & 0x03));
201 case GLSL_TYPE_ATOMIC_UINT
:
202 return glsl_type::atomic_uint_type
;
203 case GLSL_TYPE_ARRAY
: {
204 unsigned length
= blob_read_uint32(blob
);
205 return glsl_type::get_array_instance(decode_type_from_blob(blob
),
208 case GLSL_TYPE_STRUCT
:
209 case GLSL_TYPE_INTERFACE
: {
210 char *name
= blob_read_string(blob
);
211 unsigned num_fields
= blob_read_uint32(blob
);
213 size_t s_field_size
, s_field_ptrs
;
214 get_struct_type_field_and_pointer_sizes(&s_field_size
, &s_field_ptrs
);
216 glsl_struct_field
*fields
=
217 (glsl_struct_field
*) malloc(s_field_size
* num_fields
);
218 for (unsigned i
= 0; i
< num_fields
; i
++) {
219 fields
[i
].type
= decode_type_from_blob(blob
);
220 fields
[i
].name
= blob_read_string(blob
);
222 blob_copy_bytes(blob
, ((uint8_t *) &fields
[i
]) + s_field_ptrs
,
223 s_field_size
- s_field_ptrs
);
227 if (base_type
== GLSL_TYPE_INTERFACE
) {
228 enum glsl_interface_packing packing
=
229 (glsl_interface_packing
) blob_read_uint32(blob
);
230 bool row_major
= blob_read_uint32(blob
);
231 t
= glsl_type::get_interface_instance(fields
, num_fields
, packing
,
234 t
= glsl_type::get_record_instance(fields
, num_fields
, name
);
241 case GLSL_TYPE_ERROR
:
243 assert(!"Cannot decode type!");
249 write_subroutines(struct blob
*metadata
, struct gl_shader_program
*prog
)
251 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
252 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
256 struct gl_program
*glprog
= sh
->Program
;
258 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineUniforms
);
259 blob_write_uint32(metadata
, glprog
->sh
.MaxSubroutineFunctionIndex
);
260 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineFunctions
);
261 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineFunctions
; j
++) {
262 int num_types
= glprog
->sh
.SubroutineFunctions
[j
].num_compat_types
;
264 blob_write_string(metadata
, glprog
->sh
.SubroutineFunctions
[j
].name
);
265 blob_write_uint32(metadata
, glprog
->sh
.SubroutineFunctions
[j
].index
);
266 blob_write_uint32(metadata
, num_types
);
268 for (int k
= 0; k
< num_types
; k
++) {
269 encode_type_to_blob(metadata
,
270 glprog
->sh
.SubroutineFunctions
[j
].types
[k
]);
277 read_subroutines(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
279 struct gl_subroutine_function
*subs
;
281 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
282 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
286 struct gl_program
*glprog
= sh
->Program
;
288 glprog
->sh
.NumSubroutineUniforms
= blob_read_uint32(metadata
);
289 glprog
->sh
.MaxSubroutineFunctionIndex
= blob_read_uint32(metadata
);
290 glprog
->sh
.NumSubroutineFunctions
= blob_read_uint32(metadata
);
292 subs
= rzalloc_array(prog
, struct gl_subroutine_function
,
293 glprog
->sh
.NumSubroutineFunctions
);
294 glprog
->sh
.SubroutineFunctions
= subs
;
296 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineFunctions
; j
++) {
297 subs
[j
].name
= ralloc_strdup(prog
, blob_read_string (metadata
));
298 subs
[j
].index
= (int) blob_read_uint32(metadata
);
299 subs
[j
].num_compat_types
= (int) blob_read_uint32(metadata
);
301 subs
[j
].types
= rzalloc_array(prog
, const struct glsl_type
*,
302 subs
[j
].num_compat_types
);
303 for (int k
= 0; k
< subs
[j
].num_compat_types
; k
++) {
304 subs
[j
].types
[k
] = decode_type_from_blob(metadata
);
311 write_buffer_block(struct blob
*metadata
, struct gl_uniform_block
*b
)
313 blob_write_string(metadata
, b
->Name
);
314 blob_write_uint32(metadata
, b
->NumUniforms
);
315 blob_write_uint32(metadata
, b
->Binding
);
316 blob_write_uint32(metadata
, b
->UniformBufferSize
);
317 blob_write_uint32(metadata
, b
->stageref
);
319 for (unsigned j
= 0; j
< b
->NumUniforms
; j
++) {
320 blob_write_string(metadata
, b
->Uniforms
[j
].Name
);
321 blob_write_string(metadata
, b
->Uniforms
[j
].IndexName
);
322 encode_type_to_blob(metadata
, b
->Uniforms
[j
].Type
);
323 blob_write_uint32(metadata
, b
->Uniforms
[j
].Offset
);
328 write_buffer_blocks(struct blob
*metadata
, struct gl_shader_program
*prog
)
330 blob_write_uint32(metadata
, prog
->data
->NumUniformBlocks
);
331 blob_write_uint32(metadata
, prog
->data
->NumShaderStorageBlocks
);
333 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
334 write_buffer_block(metadata
, &prog
->data
->UniformBlocks
[i
]);
337 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
338 write_buffer_block(metadata
, &prog
->data
->ShaderStorageBlocks
[i
]);
341 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
342 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
346 struct gl_program
*glprog
= sh
->Program
;
348 blob_write_uint32(metadata
, glprog
->info
.num_ubos
);
349 blob_write_uint32(metadata
, glprog
->info
.num_ssbos
);
351 for (unsigned j
= 0; j
< glprog
->info
.num_ubos
; j
++) {
353 glprog
->sh
.UniformBlocks
[j
] - prog
->data
->UniformBlocks
;
354 blob_write_uint32(metadata
, offset
);
357 for (unsigned j
= 0; j
< glprog
->info
.num_ssbos
; j
++) {
358 uint32_t offset
= glprog
->sh
.ShaderStorageBlocks
[j
] -
359 prog
->data
->ShaderStorageBlocks
;
360 blob_write_uint32(metadata
, offset
);
366 read_buffer_block(struct blob_reader
*metadata
, struct gl_uniform_block
*b
,
367 struct gl_shader_program
*prog
)
369 b
->Name
= ralloc_strdup(prog
->data
, blob_read_string (metadata
));
370 b
->NumUniforms
= blob_read_uint32(metadata
);
371 b
->Binding
= blob_read_uint32(metadata
);
372 b
->UniformBufferSize
= blob_read_uint32(metadata
);
373 b
->stageref
= blob_read_uint32(metadata
);
376 rzalloc_array(prog
->data
, struct gl_uniform_buffer_variable
,
378 for (unsigned j
= 0; j
< b
->NumUniforms
; j
++) {
379 b
->Uniforms
[j
].Name
= ralloc_strdup(prog
->data
,
380 blob_read_string (metadata
));
382 char *index_name
= blob_read_string(metadata
);
383 if (strcmp(b
->Uniforms
[j
].Name
, index_name
) == 0) {
384 b
->Uniforms
[j
].IndexName
= b
->Uniforms
[j
].Name
;
386 b
->Uniforms
[j
].IndexName
= ralloc_strdup(prog
->data
, index_name
);
389 b
->Uniforms
[j
].Type
= decode_type_from_blob(metadata
);
390 b
->Uniforms
[j
].Offset
= blob_read_uint32(metadata
);
395 read_buffer_blocks(struct blob_reader
*metadata
,
396 struct gl_shader_program
*prog
)
398 prog
->data
->NumUniformBlocks
= blob_read_uint32(metadata
);
399 prog
->data
->NumShaderStorageBlocks
= blob_read_uint32(metadata
);
401 prog
->data
->UniformBlocks
=
402 rzalloc_array(prog
->data
, struct gl_uniform_block
,
403 prog
->data
->NumUniformBlocks
);
405 prog
->data
->ShaderStorageBlocks
=
406 rzalloc_array(prog
->data
, struct gl_uniform_block
,
407 prog
->data
->NumShaderStorageBlocks
);
409 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
410 read_buffer_block(metadata
, &prog
->data
->UniformBlocks
[i
], prog
);
413 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
414 read_buffer_block(metadata
, &prog
->data
->ShaderStorageBlocks
[i
], prog
);
417 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
418 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
422 struct gl_program
*glprog
= sh
->Program
;
424 glprog
->info
.num_ubos
= blob_read_uint32(metadata
);
425 glprog
->info
.num_ssbos
= blob_read_uint32(metadata
);
427 glprog
->sh
.UniformBlocks
=
428 rzalloc_array(glprog
, gl_uniform_block
*, glprog
->info
.num_ubos
);
429 glprog
->sh
.ShaderStorageBlocks
=
430 rzalloc_array(glprog
, gl_uniform_block
*, glprog
->info
.num_ssbos
);
432 for (unsigned j
= 0; j
< glprog
->info
.num_ubos
; j
++) {
433 uint32_t offset
= blob_read_uint32(metadata
);
434 glprog
->sh
.UniformBlocks
[j
] = prog
->data
->UniformBlocks
+ offset
;
437 for (unsigned j
= 0; j
< glprog
->info
.num_ssbos
; j
++) {
438 uint32_t offset
= blob_read_uint32(metadata
);
439 glprog
->sh
.ShaderStorageBlocks
[j
] =
440 prog
->data
->ShaderStorageBlocks
+ offset
;
446 write_atomic_buffers(struct blob
*metadata
, struct gl_shader_program
*prog
)
448 blob_write_uint32(metadata
, prog
->data
->NumAtomicBuffers
);
450 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
451 if (prog
->_LinkedShaders
[i
]) {
452 struct gl_program
*glprog
= prog
->_LinkedShaders
[i
]->Program
;
453 blob_write_uint32(metadata
, glprog
->info
.num_abos
);
457 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
458 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].Binding
);
459 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].MinimumSize
);
460 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].NumUniforms
);
462 blob_write_bytes(metadata
, prog
->data
->AtomicBuffers
[i
].StageReferences
,
463 sizeof(prog
->data
->AtomicBuffers
[i
].StageReferences
));
465 for (unsigned j
= 0; j
< prog
->data
->AtomicBuffers
[i
].NumUniforms
; j
++) {
466 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].Uniforms
[j
]);
472 read_atomic_buffers(struct blob_reader
*metadata
,
473 struct gl_shader_program
*prog
)
475 prog
->data
->NumAtomicBuffers
= blob_read_uint32(metadata
);
476 prog
->data
->AtomicBuffers
=
477 rzalloc_array(prog
, gl_active_atomic_buffer
,
478 prog
->data
->NumAtomicBuffers
);
480 struct gl_active_atomic_buffer
**stage_buff_list
[MESA_SHADER_STAGES
];
481 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
482 if (prog
->_LinkedShaders
[i
]) {
483 struct gl_program
*glprog
= prog
->_LinkedShaders
[i
]->Program
;
485 glprog
->info
.num_abos
= blob_read_uint32(metadata
);
486 glprog
->sh
.AtomicBuffers
=
487 rzalloc_array(glprog
, gl_active_atomic_buffer
*,
488 glprog
->info
.num_abos
);
489 stage_buff_list
[i
] = glprog
->sh
.AtomicBuffers
;
493 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
494 prog
->data
->AtomicBuffers
[i
].Binding
= blob_read_uint32(metadata
);
495 prog
->data
->AtomicBuffers
[i
].MinimumSize
= blob_read_uint32(metadata
);
496 prog
->data
->AtomicBuffers
[i
].NumUniforms
= blob_read_uint32(metadata
);
498 blob_copy_bytes(metadata
,
499 (uint8_t *) &prog
->data
->AtomicBuffers
[i
].StageReferences
,
500 sizeof(prog
->data
->AtomicBuffers
[i
].StageReferences
));
502 prog
->data
->AtomicBuffers
[i
].Uniforms
= rzalloc_array(prog
, unsigned,
503 prog
->data
->AtomicBuffers
[i
].NumUniforms
);
505 for (unsigned j
= 0; j
< prog
->data
->AtomicBuffers
[i
].NumUniforms
; j
++) {
506 prog
->data
->AtomicBuffers
[i
].Uniforms
[j
] = blob_read_uint32(metadata
);
509 for (unsigned j
= 0; j
< MESA_SHADER_STAGES
; j
++) {
510 if (prog
->data
->AtomicBuffers
[i
].StageReferences
[j
]) {
511 *stage_buff_list
[j
] = &prog
->data
->AtomicBuffers
[i
];
512 stage_buff_list
[j
]++;
519 write_xfb(struct blob
*metadata
, struct gl_shader_program
*shProg
)
521 struct gl_program
*prog
= shProg
->last_vert_prog
;
524 blob_write_uint32(metadata
, ~0u);
528 struct gl_transform_feedback_info
*ltf
= prog
->sh
.LinkedTransformFeedback
;
530 blob_write_uint32(metadata
, prog
->info
.stage
);
532 blob_write_uint32(metadata
, ltf
->NumOutputs
);
533 blob_write_uint32(metadata
, ltf
->ActiveBuffers
);
534 blob_write_uint32(metadata
, ltf
->NumVarying
);
536 blob_write_bytes(metadata
, ltf
->Outputs
,
537 sizeof(struct gl_transform_feedback_output
) *
540 for (int i
= 0; i
< ltf
->NumVarying
; i
++) {
541 blob_write_string(metadata
, ltf
->Varyings
[i
].Name
);
542 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Type
);
543 blob_write_uint32(metadata
, ltf
->Varyings
[i
].BufferIndex
);
544 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Size
);
545 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Offset
);
548 blob_write_bytes(metadata
, ltf
->Buffers
,
549 sizeof(struct gl_transform_feedback_buffer
) *
550 MAX_FEEDBACK_BUFFERS
);
554 read_xfb(struct blob_reader
*metadata
, struct gl_shader_program
*shProg
)
556 unsigned xfb_stage
= blob_read_uint32(metadata
);
558 if (xfb_stage
== ~0u)
561 struct gl_program
*prog
= shProg
->_LinkedShaders
[xfb_stage
]->Program
;
562 struct gl_transform_feedback_info
*ltf
=
563 rzalloc(prog
, struct gl_transform_feedback_info
);
565 prog
->sh
.LinkedTransformFeedback
= ltf
;
566 shProg
->last_vert_prog
= prog
;
568 ltf
->NumOutputs
= blob_read_uint32(metadata
);
569 ltf
->ActiveBuffers
= blob_read_uint32(metadata
);
570 ltf
->NumVarying
= blob_read_uint32(metadata
);
572 ltf
->Outputs
= rzalloc_array(prog
, struct gl_transform_feedback_output
,
575 blob_copy_bytes(metadata
, (uint8_t *) ltf
->Outputs
,
576 sizeof(struct gl_transform_feedback_output
) *
579 ltf
->Varyings
= rzalloc_array(prog
,
580 struct gl_transform_feedback_varying_info
,
583 for (int i
= 0; i
< ltf
->NumVarying
; i
++) {
584 ltf
->Varyings
[i
].Name
= ralloc_strdup(prog
, blob_read_string(metadata
));
585 ltf
->Varyings
[i
].Type
= blob_read_uint32(metadata
);
586 ltf
->Varyings
[i
].BufferIndex
= blob_read_uint32(metadata
);
587 ltf
->Varyings
[i
].Size
= blob_read_uint32(metadata
);
588 ltf
->Varyings
[i
].Offset
= blob_read_uint32(metadata
);
591 blob_copy_bytes(metadata
, (uint8_t *) ltf
->Buffers
,
592 sizeof(struct gl_transform_feedback_buffer
) *
593 MAX_FEEDBACK_BUFFERS
);
597 has_uniform_storage(struct gl_shader_program
*prog
, unsigned idx
)
599 if (!prog
->data
->UniformStorage
[idx
].builtin
&&
600 !prog
->data
->UniformStorage
[idx
].is_shader_storage
&&
601 prog
->data
->UniformStorage
[idx
].block_index
== -1)
608 write_uniforms(struct blob
*metadata
, struct gl_shader_program
*prog
)
610 blob_write_uint32(metadata
, prog
->SamplersValidated
);
611 blob_write_uint32(metadata
, prog
->data
->NumUniformStorage
);
612 blob_write_uint32(metadata
, prog
->data
->NumUniformDataSlots
);
614 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
615 encode_type_to_blob(metadata
, prog
->data
->UniformStorage
[i
].type
);
616 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].array_elements
);
617 blob_write_string(metadata
, prog
->data
->UniformStorage
[i
].name
);
618 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].builtin
);
619 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].remap_location
);
620 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].block_index
);
621 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].atomic_buffer_index
);
622 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].offset
);
623 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].array_stride
);
624 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].hidden
);
625 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].is_shader_storage
);
626 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].active_shader_mask
);
627 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].matrix_stride
);
628 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].row_major
);
629 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].is_bindless
);
630 blob_write_uint32(metadata
,
631 prog
->data
->UniformStorage
[i
].num_compatible_subroutines
);
632 blob_write_uint32(metadata
,
633 prog
->data
->UniformStorage
[i
].top_level_array_size
);
634 blob_write_uint32(metadata
,
635 prog
->data
->UniformStorage
[i
].top_level_array_stride
);
637 if (has_uniform_storage(prog
, i
)) {
638 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].storage
-
639 prog
->data
->UniformDataSlots
);
642 blob_write_bytes(metadata
, prog
->data
->UniformStorage
[i
].opaque
,
643 sizeof(prog
->data
->UniformStorage
[i
].opaque
));
646 /* Here we cache all uniform values. We do this to retain values for
647 * uniforms with initialisers and also hidden uniforms that may be lowered
648 * constant arrays. We could possibly just store the values we need but for
649 * now we just store everything.
651 blob_write_uint32(metadata
, prog
->data
->NumHiddenUniforms
);
652 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
653 if (has_uniform_storage(prog
, i
)) {
655 prog
->data
->UniformStorage
[i
].type
->component_slots() *
656 MAX2(prog
->data
->UniformStorage
[i
].array_elements
, 1);
657 blob_write_bytes(metadata
, prog
->data
->UniformStorage
[i
].storage
,
658 sizeof(union gl_constant_value
) * vec_size
);
664 read_uniforms(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
666 struct gl_uniform_storage
*uniforms
;
667 union gl_constant_value
*data
;
669 prog
->SamplersValidated
= blob_read_uint32(metadata
);
670 prog
->data
->NumUniformStorage
= blob_read_uint32(metadata
);
671 prog
->data
->NumUniformDataSlots
= blob_read_uint32(metadata
);
673 uniforms
= rzalloc_array(prog
, struct gl_uniform_storage
,
674 prog
->data
->NumUniformStorage
);
675 prog
->data
->UniformStorage
= uniforms
;
677 data
= rzalloc_array(uniforms
, union gl_constant_value
,
678 prog
->data
->NumUniformDataSlots
);
679 prog
->data
->UniformDataSlots
= data
;
681 prog
->UniformHash
= new string_to_uint_map
;
683 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
684 uniforms
[i
].type
= decode_type_from_blob(metadata
);
685 uniforms
[i
].array_elements
= blob_read_uint32(metadata
);
686 uniforms
[i
].name
= ralloc_strdup(prog
, blob_read_string (metadata
));
687 uniforms
[i
].builtin
= blob_read_uint32(metadata
);
688 uniforms
[i
].remap_location
= blob_read_uint32(metadata
);
689 uniforms
[i
].block_index
= blob_read_uint32(metadata
);
690 uniforms
[i
].atomic_buffer_index
= blob_read_uint32(metadata
);
691 uniforms
[i
].offset
= blob_read_uint32(metadata
);
692 uniforms
[i
].array_stride
= blob_read_uint32(metadata
);
693 uniforms
[i
].hidden
= blob_read_uint32(metadata
);
694 uniforms
[i
].is_shader_storage
= blob_read_uint32(metadata
);
695 uniforms
[i
].active_shader_mask
= blob_read_uint32(metadata
);
696 uniforms
[i
].matrix_stride
= blob_read_uint32(metadata
);
697 uniforms
[i
].row_major
= blob_read_uint32(metadata
);
698 uniforms
[i
].is_bindless
= blob_read_uint32(metadata
);
699 uniforms
[i
].num_compatible_subroutines
= blob_read_uint32(metadata
);
700 uniforms
[i
].top_level_array_size
= blob_read_uint32(metadata
);
701 uniforms
[i
].top_level_array_stride
= blob_read_uint32(metadata
);
702 prog
->UniformHash
->put(i
, uniforms
[i
].name
);
704 if (has_uniform_storage(prog
, i
)) {
705 uniforms
[i
].storage
= data
+ blob_read_uint32(metadata
);
708 memcpy(uniforms
[i
].opaque
,
709 blob_read_bytes(metadata
, sizeof(uniforms
[i
].opaque
)),
710 sizeof(uniforms
[i
].opaque
));
713 /* Restore uniform values. */
714 prog
->data
->NumHiddenUniforms
= blob_read_uint32(metadata
);
715 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
716 if (has_uniform_storage(prog
, i
)) {
718 prog
->data
->UniformStorage
[i
].type
->component_slots() *
719 MAX2(prog
->data
->UniformStorage
[i
].array_elements
, 1);
720 blob_copy_bytes(metadata
,
721 (uint8_t *) prog
->data
->UniformStorage
[i
].storage
,
722 sizeof(union gl_constant_value
) * vec_size
);
724 assert(vec_size
+ prog
->data
->UniformStorage
[i
].storage
<=
725 data
+ prog
->data
->NumUniformDataSlots
);
730 enum uniform_remap_type
732 remap_type_inactive_explicit_location
,
734 remap_type_uniform_offset
738 write_uniform_remap_table_entry(struct blob
*metadata
,
739 gl_uniform_storage
*uniform_storage
,
740 gl_uniform_storage
*entry
)
742 if (entry
== INACTIVE_UNIFORM_EXPLICIT_LOCATION
) {
743 blob_write_uint32(metadata
, remap_type_inactive_explicit_location
);
744 } else if (entry
== NULL
) {
745 blob_write_uint32(metadata
, remap_type_null_ptr
);
747 blob_write_uint32(metadata
, remap_type_uniform_offset
);
749 uint32_t offset
= entry
- uniform_storage
;
750 blob_write_uint32(metadata
, offset
);
755 write_uniform_remap_tables(struct blob
*metadata
,
756 struct gl_shader_program
*prog
)
758 blob_write_uint32(metadata
, prog
->NumUniformRemapTable
);
760 for (unsigned i
= 0; i
< prog
->NumUniformRemapTable
; i
++) {
761 write_uniform_remap_table_entry(metadata
, prog
->data
->UniformStorage
,
762 prog
->UniformRemapTable
[i
]);
765 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
766 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
768 struct gl_program
*glprog
= sh
->Program
;
769 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineUniformRemapTable
);
771 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineUniformRemapTable
; j
++) {
772 write_uniform_remap_table_entry(metadata
,
773 prog
->data
->UniformStorage
,
774 glprog
->sh
.SubroutineUniformRemapTable
[j
]);
781 read_uniform_remap_table_entry(struct blob_reader
*metadata
,
782 gl_uniform_storage
*uniform_storage
,
783 gl_uniform_storage
**entry
,
784 enum uniform_remap_type type
)
786 if (type
== remap_type_inactive_explicit_location
) {
787 *entry
= INACTIVE_UNIFORM_EXPLICIT_LOCATION
;
788 } else if (type
== remap_type_null_ptr
) {
791 uint32_t uni_offset
= blob_read_uint32(metadata
);
792 *entry
= uniform_storage
+ uni_offset
;
797 read_uniform_remap_tables(struct blob_reader
*metadata
,
798 struct gl_shader_program
*prog
)
800 prog
->NumUniformRemapTable
= blob_read_uint32(metadata
);
802 prog
->UniformRemapTable
= rzalloc_array(prog
, struct gl_uniform_storage
*,
803 prog
->NumUniformRemapTable
);
805 for (unsigned i
= 0; i
< prog
->NumUniformRemapTable
; i
++) {
806 enum uniform_remap_type type
=
807 (enum uniform_remap_type
) blob_read_uint32(metadata
);
809 read_uniform_remap_table_entry(metadata
, prog
->data
->UniformStorage
,
810 &prog
->UniformRemapTable
[i
], type
);
813 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
814 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
816 struct gl_program
*glprog
= sh
->Program
;
817 glprog
->sh
.NumSubroutineUniformRemapTable
= blob_read_uint32(metadata
);
819 glprog
->sh
.SubroutineUniformRemapTable
=
820 rzalloc_array(glprog
, struct gl_uniform_storage
*,
821 glprog
->sh
.NumSubroutineUniformRemapTable
);
823 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineUniformRemapTable
; j
++) {
824 enum uniform_remap_type type
=
825 (enum uniform_remap_type
) blob_read_uint32(metadata
);
827 read_uniform_remap_table_entry(metadata
,
828 prog
->data
->UniformStorage
,
829 &glprog
->sh
.SubroutineUniformRemapTable
[j
],
843 write_hash_table_entry(const char *key
, unsigned value
, void *closure
)
845 struct whte_closure
*whte
= (struct whte_closure
*) closure
;
847 blob_write_string(whte
->blob
, key
);
848 blob_write_uint32(whte
->blob
, value
);
854 write_hash_table(struct blob
*metadata
, struct string_to_uint_map
*hash
)
857 struct whte_closure whte
;
859 whte
.blob
= metadata
;
860 whte
.num_entries
= 0;
862 offset
= metadata
->size
;
864 /* Write a placeholder for the hashtable size. */
865 blob_write_uint32 (metadata
, 0);
867 hash
->iterate(write_hash_table_entry
, &whte
);
869 /* Overwrite with the computed number of entries written. */
870 blob_overwrite_uint32 (metadata
, offset
, whte
.num_entries
);
874 read_hash_table(struct blob_reader
*metadata
, struct string_to_uint_map
*hash
)
876 size_t i
, num_entries
;
880 num_entries
= blob_read_uint32 (metadata
);
882 for (i
= 0; i
< num_entries
; i
++) {
883 key
= blob_read_string(metadata
);
884 value
= blob_read_uint32(metadata
);
886 hash
->put(value
, key
);
891 write_hash_tables(struct blob
*metadata
, struct gl_shader_program
*prog
)
893 write_hash_table(metadata
, prog
->AttributeBindings
);
894 write_hash_table(metadata
, prog
->FragDataBindings
);
895 write_hash_table(metadata
, prog
->FragDataIndexBindings
);
899 read_hash_tables(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
901 read_hash_table(metadata
, prog
->AttributeBindings
);
902 read_hash_table(metadata
, prog
->FragDataBindings
);
903 read_hash_table(metadata
, prog
->FragDataIndexBindings
);
907 write_shader_subroutine_index(struct blob
*metadata
,
908 struct gl_linked_shader
*sh
,
909 struct gl_program_resource
*res
)
913 for (unsigned j
= 0; j
< sh
->Program
->sh
.NumSubroutineFunctions
; j
++) {
914 if (strcmp(((gl_subroutine_function
*)res
->Data
)->name
,
915 sh
->Program
->sh
.SubroutineFunctions
[j
].name
) == 0) {
916 blob_write_uint32(metadata
, j
);
923 get_shader_var_and_pointer_sizes(size_t *s_var_size
, size_t *s_var_ptrs
,
924 const gl_shader_variable
*var
)
926 *s_var_size
= sizeof(gl_shader_variable
);
929 sizeof(var
->interface_type
) +
930 sizeof(var
->outermost_struct_type
) +
935 write_program_resource_data(struct blob
*metadata
,
936 struct gl_shader_program
*prog
,
937 struct gl_program_resource
*res
)
939 struct gl_linked_shader
*sh
;
942 case GL_PROGRAM_INPUT
:
943 case GL_PROGRAM_OUTPUT
: {
944 const gl_shader_variable
*var
= (gl_shader_variable
*)res
->Data
;
946 encode_type_to_blob(metadata
, var
->type
);
947 encode_type_to_blob(metadata
, var
->interface_type
);
948 encode_type_to_blob(metadata
, var
->outermost_struct_type
);
950 blob_write_string(metadata
, var
->name
);
952 size_t s_var_size
, s_var_ptrs
;
953 get_shader_var_and_pointer_sizes(&s_var_size
, &s_var_ptrs
, var
);
955 /* Write gl_shader_variable skipping over the pointers */
956 blob_write_bytes(metadata
, ((char *)var
) + s_var_ptrs
,
957 s_var_size
- s_var_ptrs
);
960 case GL_UNIFORM_BLOCK
:
961 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
962 if (strcmp(((gl_uniform_block
*)res
->Data
)->Name
,
963 prog
->data
->UniformBlocks
[i
].Name
) == 0) {
964 blob_write_uint32(metadata
, i
);
969 case GL_SHADER_STORAGE_BLOCK
:
970 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
971 if (strcmp(((gl_uniform_block
*)res
->Data
)->Name
,
972 prog
->data
->ShaderStorageBlocks
[i
].Name
) == 0) {
973 blob_write_uint32(metadata
, i
);
978 case GL_BUFFER_VARIABLE
:
979 case GL_VERTEX_SUBROUTINE_UNIFORM
:
980 case GL_GEOMETRY_SUBROUTINE_UNIFORM
:
981 case GL_FRAGMENT_SUBROUTINE_UNIFORM
:
982 case GL_COMPUTE_SUBROUTINE_UNIFORM
:
983 case GL_TESS_CONTROL_SUBROUTINE_UNIFORM
:
984 case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM
:
986 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
987 if (strcmp(((gl_uniform_storage
*)res
->Data
)->name
,
988 prog
->data
->UniformStorage
[i
].name
) == 0) {
989 blob_write_uint32(metadata
, i
);
994 case GL_ATOMIC_COUNTER_BUFFER
:
995 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
996 if (((gl_active_atomic_buffer
*)res
->Data
)->Binding
==
997 prog
->data
->AtomicBuffers
[i
].Binding
) {
998 blob_write_uint32(metadata
, i
);
1003 case GL_TRANSFORM_FEEDBACK_BUFFER
:
1004 for (unsigned i
= 0; i
< MAX_FEEDBACK_BUFFERS
; i
++) {
1005 if (((gl_transform_feedback_buffer
*)res
->Data
)->Binding
==
1006 prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->Buffers
[i
].Binding
) {
1007 blob_write_uint32(metadata
, i
);
1012 case GL_TRANSFORM_FEEDBACK_VARYING
:
1013 for (int i
= 0; i
< prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->NumVarying
; i
++) {
1014 if (strcmp(((gl_transform_feedback_varying_info
*)res
->Data
)->Name
,
1015 prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->Varyings
[i
].Name
) == 0) {
1016 blob_write_uint32(metadata
, i
);
1021 case GL_VERTEX_SUBROUTINE
:
1022 case GL_TESS_CONTROL_SUBROUTINE
:
1023 case GL_TESS_EVALUATION_SUBROUTINE
:
1024 case GL_GEOMETRY_SUBROUTINE
:
1025 case GL_FRAGMENT_SUBROUTINE
:
1026 case GL_COMPUTE_SUBROUTINE
:
1028 prog
->_LinkedShaders
[_mesa_shader_stage_from_subroutine(res
->Type
)];
1029 write_shader_subroutine_index(metadata
, sh
, res
);
1032 assert(!"Support for writing resource not yet implemented.");
1037 read_program_resource_data(struct blob_reader
*metadata
,
1038 struct gl_shader_program
*prog
,
1039 struct gl_program_resource
*res
)
1041 struct gl_linked_shader
*sh
;
1044 case GL_PROGRAM_INPUT
:
1045 case GL_PROGRAM_OUTPUT
: {
1046 gl_shader_variable
*var
= ralloc(prog
, struct gl_shader_variable
);
1048 var
->type
= decode_type_from_blob(metadata
);
1049 var
->interface_type
= decode_type_from_blob(metadata
);
1050 var
->outermost_struct_type
= decode_type_from_blob(metadata
);
1052 var
->name
= ralloc_strdup(prog
, blob_read_string(metadata
));
1054 size_t s_var_size
, s_var_ptrs
;
1055 get_shader_var_and_pointer_sizes(&s_var_size
, &s_var_ptrs
, var
);
1057 blob_copy_bytes(metadata
, ((uint8_t *) var
) + s_var_ptrs
,
1058 s_var_size
- s_var_ptrs
);
1063 case GL_UNIFORM_BLOCK
:
1064 res
->Data
= &prog
->data
->UniformBlocks
[blob_read_uint32(metadata
)];
1066 case GL_SHADER_STORAGE_BLOCK
:
1067 res
->Data
= &prog
->data
->ShaderStorageBlocks
[blob_read_uint32(metadata
)];
1069 case GL_BUFFER_VARIABLE
:
1070 case GL_VERTEX_SUBROUTINE_UNIFORM
:
1071 case GL_GEOMETRY_SUBROUTINE_UNIFORM
:
1072 case GL_FRAGMENT_SUBROUTINE_UNIFORM
:
1073 case GL_COMPUTE_SUBROUTINE_UNIFORM
:
1074 case GL_TESS_CONTROL_SUBROUTINE_UNIFORM
:
1075 case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM
:
1077 res
->Data
= &prog
->data
->UniformStorage
[blob_read_uint32(metadata
)];
1079 case GL_ATOMIC_COUNTER_BUFFER
:
1080 res
->Data
= &prog
->data
->AtomicBuffers
[blob_read_uint32(metadata
)];
1082 case GL_TRANSFORM_FEEDBACK_BUFFER
:
1083 res
->Data
= &prog
->last_vert_prog
->
1084 sh
.LinkedTransformFeedback
->Buffers
[blob_read_uint32(metadata
)];
1086 case GL_TRANSFORM_FEEDBACK_VARYING
:
1087 res
->Data
= &prog
->last_vert_prog
->
1088 sh
.LinkedTransformFeedback
->Varyings
[blob_read_uint32(metadata
)];
1090 case GL_VERTEX_SUBROUTINE
:
1091 case GL_TESS_CONTROL_SUBROUTINE
:
1092 case GL_TESS_EVALUATION_SUBROUTINE
:
1093 case GL_GEOMETRY_SUBROUTINE
:
1094 case GL_FRAGMENT_SUBROUTINE
:
1095 case GL_COMPUTE_SUBROUTINE
:
1097 prog
->_LinkedShaders
[_mesa_shader_stage_from_subroutine(res
->Type
)];
1099 &sh
->Program
->sh
.SubroutineFunctions
[blob_read_uint32(metadata
)];
1102 assert(!"Support for reading resource not yet implemented.");
1107 write_program_resource_list(struct blob
*metadata
,
1108 struct gl_shader_program
*prog
)
1110 blob_write_uint32(metadata
, prog
->data
->NumProgramResourceList
);
1112 for (unsigned i
= 0; i
< prog
->data
->NumProgramResourceList
; i
++) {
1113 blob_write_uint32(metadata
, prog
->data
->ProgramResourceList
[i
].Type
);
1114 write_program_resource_data(metadata
, prog
,
1115 &prog
->data
->ProgramResourceList
[i
]);
1116 blob_write_bytes(metadata
,
1117 &prog
->data
->ProgramResourceList
[i
].StageReferences
,
1118 sizeof(prog
->data
->ProgramResourceList
[i
].StageReferences
));
1123 read_program_resource_list(struct blob_reader
*metadata
,
1124 struct gl_shader_program
*prog
)
1126 prog
->data
->NumProgramResourceList
= blob_read_uint32(metadata
);
1128 prog
->data
->ProgramResourceList
=
1129 ralloc_array(prog
, gl_program_resource
,
1130 prog
->data
->NumProgramResourceList
);
1132 for (unsigned i
= 0; i
< prog
->data
->NumProgramResourceList
; i
++) {
1133 prog
->data
->ProgramResourceList
[i
].Type
= blob_read_uint32(metadata
);
1134 read_program_resource_data(metadata
, prog
,
1135 &prog
->data
->ProgramResourceList
[i
]);
1136 blob_copy_bytes(metadata
,
1137 (uint8_t *) &prog
->data
->ProgramResourceList
[i
].StageReferences
,
1138 sizeof(prog
->data
->ProgramResourceList
[i
].StageReferences
));
1143 write_shader_parameters(struct blob
*metadata
,
1144 struct gl_program_parameter_list
*params
)
1146 blob_write_uint32(metadata
, params
->NumParameters
);
1149 while (i
< params
->NumParameters
) {
1150 struct gl_program_parameter
*param
= ¶ms
->Parameters
[i
];
1152 blob_write_uint32(metadata
, param
->Type
);
1153 blob_write_string(metadata
, param
->Name
);
1154 blob_write_uint32(metadata
, param
->Size
);
1155 blob_write_uint32(metadata
, param
->DataType
);
1156 blob_write_bytes(metadata
, param
->StateIndexes
,
1157 sizeof(param
->StateIndexes
));
1159 i
+= (param
->Size
+ 3) / 4;
1162 blob_write_bytes(metadata
, params
->ParameterValues
,
1163 sizeof(gl_constant_value
) * 4 * params
->NumParameters
);
1165 blob_write_uint32(metadata
, params
->StateFlags
);
1169 read_shader_parameters(struct blob_reader
*metadata
,
1170 struct gl_program_parameter_list
*params
)
1172 gl_state_index state_indexes
[STATE_LENGTH
];
1174 uint32_t num_parameters
= blob_read_uint32(metadata
);
1176 _mesa_reserve_parameter_storage(params
, num_parameters
);
1177 while (i
< num_parameters
) {
1178 gl_register_file type
= (gl_register_file
) blob_read_uint32(metadata
);
1179 const char *name
= blob_read_string(metadata
);
1180 unsigned size
= blob_read_uint32(metadata
);
1181 unsigned data_type
= blob_read_uint32(metadata
);
1182 blob_copy_bytes(metadata
, (uint8_t *) state_indexes
,
1183 sizeof(state_indexes
));
1185 _mesa_add_parameter(params
, type
, name
, size
, data_type
,
1186 NULL
, state_indexes
);
1188 i
+= (size
+ 3) / 4;
1191 blob_copy_bytes(metadata
, (uint8_t *) params
->ParameterValues
,
1192 sizeof(gl_constant_value
) * 4 * params
->NumParameters
);
1194 params
->StateFlags
= blob_read_uint32(metadata
);
1198 write_shader_metadata(struct blob
*metadata
, gl_linked_shader
*shader
)
1200 assert(shader
->Program
);
1201 struct gl_program
*glprog
= shader
->Program
;
1204 blob_write_bytes(metadata
, glprog
->TexturesUsed
,
1205 sizeof(glprog
->TexturesUsed
));
1206 blob_write_uint64(metadata
, glprog
->SamplersUsed
);
1208 blob_write_bytes(metadata
, glprog
->SamplerUnits
,
1209 sizeof(glprog
->SamplerUnits
));
1210 blob_write_bytes(metadata
, glprog
->sh
.SamplerTargets
,
1211 sizeof(glprog
->sh
.SamplerTargets
));
1212 blob_write_uint32(metadata
, glprog
->ShadowSamplers
);
1214 blob_write_bytes(metadata
, glprog
->sh
.ImageAccess
,
1215 sizeof(glprog
->sh
.ImageAccess
));
1216 blob_write_bytes(metadata
, glprog
->sh
.ImageUnits
,
1217 sizeof(glprog
->sh
.ImageUnits
));
1219 size_t ptr_size
= sizeof(GLvoid
*);
1221 blob_write_uint32(metadata
, glprog
->sh
.NumBindlessSamplers
);
1222 blob_write_uint32(metadata
, glprog
->sh
.HasBoundBindlessSampler
);
1223 for (i
= 0; i
< glprog
->sh
.NumBindlessSamplers
; i
++) {
1224 blob_write_bytes(metadata
, &glprog
->sh
.BindlessSamplers
[i
],
1225 sizeof(struct gl_bindless_sampler
) - ptr_size
);
1228 blob_write_uint32(metadata
, glprog
->sh
.NumBindlessImages
);
1229 blob_write_uint32(metadata
, glprog
->sh
.HasBoundBindlessImage
);
1230 for (i
= 0; i
< glprog
->sh
.NumBindlessImages
; i
++) {
1231 blob_write_bytes(metadata
, &glprog
->sh
.BindlessImages
[i
],
1232 sizeof(struct gl_bindless_image
) - ptr_size
);
1235 write_shader_parameters(metadata
, glprog
->Parameters
);
1239 read_shader_metadata(struct blob_reader
*metadata
,
1240 struct gl_program
*glprog
,
1241 gl_linked_shader
*linked
)
1245 blob_copy_bytes(metadata
, (uint8_t *) glprog
->TexturesUsed
,
1246 sizeof(glprog
->TexturesUsed
));
1247 glprog
->SamplersUsed
= blob_read_uint64(metadata
);
1249 blob_copy_bytes(metadata
, (uint8_t *) glprog
->SamplerUnits
,
1250 sizeof(glprog
->SamplerUnits
));
1251 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.SamplerTargets
,
1252 sizeof(glprog
->sh
.SamplerTargets
));
1253 glprog
->ShadowSamplers
= blob_read_uint32(metadata
);
1255 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.ImageAccess
,
1256 sizeof(glprog
->sh
.ImageAccess
));
1257 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.ImageUnits
,
1258 sizeof(glprog
->sh
.ImageUnits
));
1260 size_t ptr_size
= sizeof(GLvoid
*);
1262 glprog
->sh
.NumBindlessSamplers
= blob_read_uint32(metadata
);
1263 glprog
->sh
.HasBoundBindlessSampler
= blob_read_uint32(metadata
);
1264 if (glprog
->sh
.NumBindlessSamplers
> 0) {
1265 glprog
->sh
.BindlessSamplers
=
1266 rzalloc_array(glprog
, gl_bindless_sampler
,
1267 glprog
->sh
.NumBindlessSamplers
);
1269 for (i
= 0; i
< glprog
->sh
.NumBindlessSamplers
; i
++) {
1270 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->sh
.BindlessSamplers
[i
],
1271 sizeof(struct gl_bindless_sampler
) - ptr_size
);
1275 glprog
->sh
.NumBindlessImages
= blob_read_uint32(metadata
);
1276 glprog
->sh
.HasBoundBindlessImage
= blob_read_uint32(metadata
);
1277 if (glprog
->sh
.NumBindlessImages
> 0) {
1278 glprog
->sh
.BindlessImages
=
1279 rzalloc_array(glprog
, gl_bindless_image
,
1280 glprog
->sh
.NumBindlessImages
);
1282 for (i
= 0; i
< glprog
->sh
.NumBindlessImages
; i
++) {
1283 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->sh
.BindlessImages
[i
],
1284 sizeof(struct gl_bindless_image
) - ptr_size
);
1288 glprog
->Parameters
= _mesa_new_parameter_list();
1289 read_shader_parameters(metadata
, glprog
->Parameters
);
1293 create_binding_str(const char *key
, unsigned value
, void *closure
)
1295 char **bindings_str
= (char **) closure
;
1296 ralloc_asprintf_append(bindings_str
, "%s:%u,", key
, value
);
1300 get_shader_info_and_pointer_sizes(size_t *s_info_size
, size_t *s_info_ptrs
,
1303 *s_info_size
= sizeof(shader_info
);
1304 *s_info_ptrs
= sizeof(info
->name
) + sizeof(info
->label
);
1308 create_linked_shader_and_program(struct gl_context
*ctx
,
1309 gl_shader_stage stage
,
1310 struct gl_shader_program
*prog
,
1311 struct blob_reader
*metadata
)
1313 struct gl_program
*glprog
;
1315 struct gl_linked_shader
*linked
= rzalloc(NULL
, struct gl_linked_shader
);
1316 linked
->Stage
= stage
;
1318 glprog
= ctx
->Driver
.NewProgram(ctx
, _mesa_shader_stage_to_program(stage
),
1320 glprog
->info
.stage
= stage
;
1321 linked
->Program
= glprog
;
1323 read_shader_metadata(metadata
, glprog
, linked
);
1325 glprog
->info
.name
= ralloc_strdup(glprog
, blob_read_string(metadata
));
1326 glprog
->info
.label
= ralloc_strdup(glprog
, blob_read_string(metadata
));
1328 size_t s_info_size
, s_info_ptrs
;
1329 get_shader_info_and_pointer_sizes(&s_info_size
, &s_info_ptrs
,
1332 /* Restore shader info */
1333 blob_copy_bytes(metadata
, ((uint8_t *) &glprog
->info
) + s_info_ptrs
,
1334 s_info_size
- s_info_ptrs
);
1336 _mesa_reference_shader_program_data(ctx
, &glprog
->sh
.data
, prog
->data
);
1337 _mesa_reference_program(ctx
, &linked
->Program
, glprog
);
1338 prog
->_LinkedShaders
[stage
] = linked
;
1342 shader_cache_write_program_metadata(struct gl_context
*ctx
,
1343 struct gl_shader_program
*prog
)
1345 struct disk_cache
*cache
= ctx
->Cache
;
1349 /* Exit early when we are dealing with a ff shader with no source file to
1350 * generate a source from.
1352 * TODO: In future we should use another method to generate a key for ff
1355 static const char zero
[sizeof(prog
->data
->sha1
)] = {0};
1356 if (memcmp(prog
->data
->sha1
, zero
, sizeof(prog
->data
->sha1
)) == 0)
1359 struct blob
*metadata
= blob_create();
1361 write_uniforms(metadata
, prog
);
1363 write_hash_tables(metadata
, prog
);
1365 blob_write_uint32(metadata
, prog
->data
->Version
);
1366 blob_write_uint32(metadata
, prog
->data
->linked_stages
);
1368 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1369 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
1371 write_shader_metadata(metadata
, sh
);
1373 if (sh
->Program
->info
.name
)
1374 blob_write_string(metadata
, sh
->Program
->info
.name
);
1376 blob_write_string(metadata
, "");
1378 if (sh
->Program
->info
.label
)
1379 blob_write_string(metadata
, sh
->Program
->info
.label
);
1381 blob_write_string(metadata
, "");
1383 size_t s_info_size
, s_info_ptrs
;
1384 get_shader_info_and_pointer_sizes(&s_info_size
, &s_info_ptrs
,
1385 &sh
->Program
->info
);
1387 /* Store shader info */
1388 blob_write_bytes(metadata
,
1389 ((char *) &sh
->Program
->info
) + s_info_ptrs
,
1390 s_info_size
- s_info_ptrs
);
1394 write_xfb(metadata
, prog
);
1396 write_uniform_remap_tables(metadata
, prog
);
1398 write_atomic_buffers(metadata
, prog
);
1400 write_buffer_blocks(metadata
, prog
);
1402 write_subroutines(metadata
, prog
);
1404 write_program_resource_list(metadata
, prog
);
1406 struct cache_item_metadata cache_item_metadata
;
1407 cache_item_metadata
.type
= CACHE_ITEM_TYPE_GLSL
;
1408 cache_item_metadata
.keys
=
1409 (cache_key
*) malloc(prog
->NumShaders
* sizeof(cache_key
));
1410 cache_item_metadata
.num_keys
= prog
->NumShaders
;
1412 if (!cache_item_metadata
.keys
)
1416 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
1417 disk_cache_put_key(cache
, prog
->Shaders
[i
]->sha1
);
1418 memcpy(cache_item_metadata
.keys
[i
], prog
->Shaders
[i
]->sha1
,
1420 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1421 _mesa_sha1_format(sha1_buf
, prog
->Shaders
[i
]->sha1
);
1422 fprintf(stderr
, "marking shader: %s\n", sha1_buf
);
1426 disk_cache_put(cache
, prog
->data
->sha1
, metadata
->data
, metadata
->size
,
1427 &cache_item_metadata
);
1429 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1430 _mesa_sha1_format(sha1_buf
, prog
->data
->sha1
);
1431 fprintf(stderr
, "putting program metadata in cache: %s\n", sha1_buf
);
1435 free(cache_item_metadata
.keys
);
1436 blob_destroy(metadata
);
1440 shader_cache_read_program_metadata(struct gl_context
*ctx
,
1441 struct gl_shader_program
*prog
)
1443 /* Fixed function programs generated by Mesa are not cached. So don't
1444 * try to read metadata for them from the cache.
1446 if (prog
->Name
== 0)
1449 struct disk_cache
*cache
= ctx
->Cache
;
1450 if (!cache
|| prog
->data
->cache_fallback
|| prog
->data
->skip_cache
)
1453 /* Include bindings when creating sha1. These bindings change the resulting
1454 * binary so they are just as important as the shader source.
1456 char *buf
= ralloc_strdup(NULL
, "vb: ");
1457 prog
->AttributeBindings
->iterate(create_binding_str
, &buf
);
1458 ralloc_strcat(&buf
, "fb: ");
1459 prog
->FragDataBindings
->iterate(create_binding_str
, &buf
);
1460 ralloc_strcat(&buf
, "fbi: ");
1461 prog
->FragDataIndexBindings
->iterate(create_binding_str
, &buf
);
1463 /* SSO has an effect on the linked program so include this when generating
1466 ralloc_asprintf_append(&buf
, "sso: %s\n",
1467 prog
->SeparateShader
? "T" : "F");
1469 /* A shader might end up producing different output depending on the glsl
1470 * version supported by the compiler. For example a different path might be
1471 * taken by the preprocessor, so add the version to the hash input.
1473 ralloc_asprintf_append(&buf
, "api: %d glsl: %d fglsl: %d\n",
1474 ctx
->API
, ctx
->Const
.GLSLVersion
,
1475 ctx
->Const
.ForceGLSLVersion
);
1477 /* We run the preprocessor on shaders after hashing them, so we need to
1478 * add any extension override vars to the hash. If we don't do this the
1479 * preprocessor could result in different output and we could load the
1482 char *ext_override
= getenv("MESA_EXTENSION_OVERRIDE");
1484 ralloc_asprintf_append(&buf
, "ext:%s", ext_override
);
1487 /* DRI config options may also change the output from the compiler so
1488 * include them as an input to sha1 creation.
1491 _mesa_sha1_format(sha1buf
, ctx
->Const
.dri_config_options_sha1
);
1492 ralloc_strcat(&buf
, sha1buf
);
1494 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
1495 struct gl_shader
*sh
= prog
->Shaders
[i
];
1496 _mesa_sha1_format(sha1buf
, sh
->sha1
);
1497 ralloc_asprintf_append(&buf
, "%s: %s\n",
1498 _mesa_shader_stage_to_abbrev(sh
->Stage
), sha1buf
);
1500 disk_cache_compute_key(cache
, buf
, strlen(buf
), prog
->data
->sha1
);
1504 uint8_t *buffer
= (uint8_t *) disk_cache_get(cache
, prog
->data
->sha1
,
1506 if (buffer
== NULL
) {
1507 /* Cached program not found. We may have seen the individual shaders
1508 * before and skipped compiling but they may not have been used together
1509 * in this combination before. Fall back to linking shaders but first
1510 * re-compile the shaders.
1512 * We could probably only compile the shaders which were skipped here
1513 * but we need to be careful because the source may also have been
1514 * changed since the last compile so for now we just recompile
1517 compile_shaders(ctx
, prog
);
1521 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1522 _mesa_sha1_format(sha1buf
, prog
->data
->sha1
);
1523 fprintf(stderr
, "loading shader program meta data from cache: %s\n",
1527 struct blob_reader metadata
;
1528 blob_reader_init(&metadata
, buffer
, size
);
1530 assert(prog
->data
->UniformStorage
== NULL
);
1532 read_uniforms(&metadata
, prog
);
1534 read_hash_tables(&metadata
, prog
);
1536 prog
->data
->Version
= blob_read_uint32(&metadata
);
1537 prog
->data
->linked_stages
= blob_read_uint32(&metadata
);
1539 unsigned mask
= prog
->data
->linked_stages
;
1541 const int j
= u_bit_scan(&mask
);
1542 create_linked_shader_and_program(ctx
, (gl_shader_stage
) j
, prog
,
1546 read_xfb(&metadata
, prog
);
1548 read_uniform_remap_tables(&metadata
, prog
);
1550 read_atomic_buffers(&metadata
, prog
);
1552 read_buffer_blocks(&metadata
, prog
);
1554 read_subroutines(&metadata
, prog
);
1556 read_program_resource_list(&metadata
, prog
);
1558 if (metadata
.current
!= metadata
.end
|| metadata
.overrun
) {
1559 /* Something has gone wrong discard the item from the cache and rebuild
1562 assert(!"Invalid GLSL shader disk cache item!");
1564 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1565 fprintf(stderr
, "Error reading program from cache (invalid GLSL "
1569 disk_cache_remove(cache
, prog
->data
->sha1
);
1570 compile_shaders(ctx
, prog
);
1575 /* This is used to flag a shader retrieved from cache */
1576 prog
->data
->LinkStatus
= linking_skipped
;
1578 /* Since the program load was successful, CompileStatus of all shaders at
1579 * this point should normally be compile_skipped. However because of how
1580 * the eviction works, it may happen that some of the individual shader keys
1581 * have been evicted, resulting in unnecessary recompiles on this load, so
1582 * mark them again to skip such recompiles next time.
1585 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
1586 if (prog
->Shaders
[i
]->CompileStatus
== compiled_no_opts
) {
1587 disk_cache_put_key(cache
, prog
->Shaders
[i
]->sha1
);
1588 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1589 _mesa_sha1_format(sha1_buf
, prog
->Shaders
[i
]->sha1
);
1590 fprintf(stderr
, "re-marking shader: %s\n", sha1_buf
);