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 encode_type_to_blob(struct blob
*blob
, const glsl_type
*type
)
83 blob_write_uint32(blob
, 0);
87 switch (type
->base_type
) {
92 case GLSL_TYPE_DOUBLE
:
93 case GLSL_TYPE_UINT64
:
95 encoding
= (type
->base_type
<< 24) |
96 (type
->vector_elements
<< 4) |
97 (type
->matrix_columns
);
99 case GLSL_TYPE_SAMPLER
:
100 encoding
= (type
->base_type
) << 24 |
101 (type
->sampler_dimensionality
<< 4) |
102 (type
->sampler_shadow
<< 3) |
103 (type
->sampler_array
<< 2) |
104 (type
->sampled_type
);
106 case GLSL_TYPE_SUBROUTINE
:
107 encoding
= type
->base_type
<< 24;
108 blob_write_uint32(blob
, encoding
);
109 blob_write_string(blob
, type
->name
);
111 case GLSL_TYPE_IMAGE
:
112 encoding
= (type
->base_type
) << 24 |
113 (type
->sampler_dimensionality
<< 3) |
114 (type
->sampler_array
<< 2) |
115 (type
->sampled_type
);
117 case GLSL_TYPE_ATOMIC_UINT
:
118 encoding
= (type
->base_type
<< 24);
120 case GLSL_TYPE_ARRAY
:
121 blob_write_uint32(blob
, (type
->base_type
) << 24);
122 blob_write_uint32(blob
, type
->length
);
123 encode_type_to_blob(blob
, type
->fields
.array
);
125 case GLSL_TYPE_STRUCT
:
126 case GLSL_TYPE_INTERFACE
:
127 blob_write_uint32(blob
, (type
->base_type
) << 24);
128 blob_write_string(blob
, type
->name
);
129 blob_write_uint32(blob
, type
->length
);
130 blob_write_bytes(blob
, type
->fields
.structure
,
131 sizeof(glsl_struct_field
) * type
->length
);
132 for (unsigned i
= 0; i
< type
->length
; i
++) {
133 encode_type_to_blob(blob
, type
->fields
.structure
[i
].type
);
134 blob_write_string(blob
, type
->fields
.structure
[i
].name
);
137 if (type
->is_interface()) {
138 blob_write_uint32(blob
, type
->interface_packing
);
139 blob_write_uint32(blob
, type
->interface_row_major
);
143 case GLSL_TYPE_ERROR
:
145 assert(!"Cannot encode type!");
150 blob_write_uint32(blob
, encoding
);
153 static const glsl_type
*
154 decode_type_from_blob(struct blob_reader
*blob
)
156 uint32_t u
= blob_read_uint32(blob
);
162 glsl_base_type base_type
= (glsl_base_type
) (u
>> 24);
167 case GLSL_TYPE_FLOAT
:
169 case GLSL_TYPE_DOUBLE
:
170 case GLSL_TYPE_UINT64
:
171 case GLSL_TYPE_INT64
:
172 return glsl_type::get_instance(base_type
, (u
>> 4) & 0x0f, u
& 0x0f);
173 case GLSL_TYPE_SAMPLER
:
174 return glsl_type::get_sampler_instance((enum glsl_sampler_dim
) ((u
>> 4) & 0x07),
177 (glsl_base_type
) ((u
>> 0) & 0x03));
178 case GLSL_TYPE_SUBROUTINE
:
179 return glsl_type::get_subroutine_instance(blob_read_string(blob
));
180 case GLSL_TYPE_IMAGE
:
181 return glsl_type::get_image_instance((enum glsl_sampler_dim
) ((u
>> 3) & 0x07),
183 (glsl_base_type
) ((u
>> 0) & 0x03));
184 case GLSL_TYPE_ATOMIC_UINT
:
185 return glsl_type::atomic_uint_type
;
186 case GLSL_TYPE_ARRAY
: {
187 unsigned length
= blob_read_uint32(blob
);
188 return glsl_type::get_array_instance(decode_type_from_blob(blob
),
191 case GLSL_TYPE_STRUCT
:
192 case GLSL_TYPE_INTERFACE
: {
193 char *name
= blob_read_string(blob
);
194 unsigned num_fields
= blob_read_uint32(blob
);
195 glsl_struct_field
*fields
= (glsl_struct_field
*)
196 blob_read_bytes(blob
, sizeof(glsl_struct_field
) * num_fields
);
197 for (unsigned i
= 0; i
< num_fields
; i
++) {
198 fields
[i
].type
= decode_type_from_blob(blob
);
199 fields
[i
].name
= blob_read_string(blob
);
202 if (base_type
== GLSL_TYPE_INTERFACE
) {
203 enum glsl_interface_packing packing
=
204 (glsl_interface_packing
) blob_read_uint32(blob
);
205 bool row_major
= blob_read_uint32(blob
);
206 return glsl_type::get_interface_instance(fields
, num_fields
,
207 packing
, row_major
, name
);
209 return glsl_type::get_record_instance(fields
, num_fields
, name
);
213 case GLSL_TYPE_ERROR
:
215 assert(!"Cannot decode type!");
221 write_subroutines(struct blob
*metadata
, struct gl_shader_program
*prog
)
223 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
224 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
228 struct gl_program
*glprog
= sh
->Program
;
230 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineUniforms
);
231 blob_write_uint32(metadata
, glprog
->sh
.MaxSubroutineFunctionIndex
);
232 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineFunctions
);
233 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineFunctions
; j
++) {
234 int num_types
= glprog
->sh
.SubroutineFunctions
[j
].num_compat_types
;
236 blob_write_string(metadata
, glprog
->sh
.SubroutineFunctions
[j
].name
);
237 blob_write_uint32(metadata
, glprog
->sh
.SubroutineFunctions
[j
].index
);
238 blob_write_uint32(metadata
, num_types
);
240 for (int k
= 0; k
< num_types
; k
++) {
241 encode_type_to_blob(metadata
,
242 glprog
->sh
.SubroutineFunctions
[j
].types
[k
]);
249 read_subroutines(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
251 struct gl_subroutine_function
*subs
;
253 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
254 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
258 struct gl_program
*glprog
= sh
->Program
;
260 glprog
->sh
.NumSubroutineUniforms
= blob_read_uint32(metadata
);
261 glprog
->sh
.MaxSubroutineFunctionIndex
= blob_read_uint32(metadata
);
262 glprog
->sh
.NumSubroutineFunctions
= blob_read_uint32(metadata
);
264 subs
= rzalloc_array(prog
, struct gl_subroutine_function
,
265 glprog
->sh
.NumSubroutineFunctions
);
266 glprog
->sh
.SubroutineFunctions
= subs
;
268 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineFunctions
; j
++) {
269 subs
[j
].name
= ralloc_strdup(prog
, blob_read_string (metadata
));
270 subs
[j
].index
= (int) blob_read_uint32(metadata
);
271 subs
[j
].num_compat_types
= (int) blob_read_uint32(metadata
);
273 subs
[j
].types
= rzalloc_array(prog
, const struct glsl_type
*,
274 subs
[j
].num_compat_types
);
275 for (int k
= 0; k
< subs
[j
].num_compat_types
; k
++) {
276 subs
[j
].types
[k
] = decode_type_from_blob(metadata
);
283 write_buffer_block(struct blob
*metadata
, struct gl_uniform_block
*b
)
285 blob_write_string(metadata
, b
->Name
);
286 blob_write_uint32(metadata
, b
->NumUniforms
);
287 blob_write_uint32(metadata
, b
->Binding
);
288 blob_write_uint32(metadata
, b
->UniformBufferSize
);
289 blob_write_uint32(metadata
, b
->stageref
);
291 for (unsigned j
= 0; j
< b
->NumUniforms
; j
++) {
292 blob_write_string(metadata
, b
->Uniforms
[j
].Name
);
293 blob_write_string(metadata
, b
->Uniforms
[j
].IndexName
);
294 encode_type_to_blob(metadata
, b
->Uniforms
[j
].Type
);
295 blob_write_uint32(metadata
, b
->Uniforms
[j
].Offset
);
300 write_buffer_blocks(struct blob
*metadata
, struct gl_shader_program
*prog
)
302 blob_write_uint32(metadata
, prog
->data
->NumUniformBlocks
);
303 blob_write_uint32(metadata
, prog
->data
->NumShaderStorageBlocks
);
305 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
306 write_buffer_block(metadata
, &prog
->data
->UniformBlocks
[i
]);
309 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
310 write_buffer_block(metadata
, &prog
->data
->ShaderStorageBlocks
[i
]);
313 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
314 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
318 struct gl_program
*glprog
= sh
->Program
;
320 blob_write_uint32(metadata
, glprog
->info
.num_ubos
);
321 blob_write_uint32(metadata
, glprog
->info
.num_ssbos
);
323 for (unsigned j
= 0; j
< glprog
->info
.num_ubos
; j
++) {
325 glprog
->sh
.UniformBlocks
[j
] - prog
->data
->UniformBlocks
;
326 blob_write_uint32(metadata
, offset
);
329 for (unsigned j
= 0; j
< glprog
->info
.num_ssbos
; j
++) {
330 uint32_t offset
= glprog
->sh
.ShaderStorageBlocks
[j
] -
331 prog
->data
->ShaderStorageBlocks
;
332 blob_write_uint32(metadata
, offset
);
338 read_buffer_block(struct blob_reader
*metadata
, struct gl_uniform_block
*b
,
339 struct gl_shader_program
*prog
)
341 b
->Name
= ralloc_strdup(prog
->data
, blob_read_string (metadata
));
342 b
->NumUniforms
= blob_read_uint32(metadata
);
343 b
->Binding
= blob_read_uint32(metadata
);
344 b
->UniformBufferSize
= blob_read_uint32(metadata
);
345 b
->stageref
= blob_read_uint32(metadata
);
348 rzalloc_array(prog
->data
, struct gl_uniform_buffer_variable
,
350 for (unsigned j
= 0; j
< b
->NumUniforms
; j
++) {
351 b
->Uniforms
[j
].Name
= ralloc_strdup(prog
->data
,
352 blob_read_string (metadata
));
354 char *index_name
= blob_read_string(metadata
);
355 if (strcmp(b
->Uniforms
[j
].Name
, index_name
) == 0) {
356 b
->Uniforms
[j
].IndexName
= b
->Uniforms
[j
].Name
;
358 b
->Uniforms
[j
].IndexName
= ralloc_strdup(prog
->data
, index_name
);
361 b
->Uniforms
[j
].Type
= decode_type_from_blob(metadata
);
362 b
->Uniforms
[j
].Offset
= blob_read_uint32(metadata
);
367 read_buffer_blocks(struct blob_reader
*metadata
,
368 struct gl_shader_program
*prog
)
370 prog
->data
->NumUniformBlocks
= blob_read_uint32(metadata
);
371 prog
->data
->NumShaderStorageBlocks
= blob_read_uint32(metadata
);
373 prog
->data
->UniformBlocks
=
374 rzalloc_array(prog
->data
, struct gl_uniform_block
,
375 prog
->data
->NumUniformBlocks
);
377 prog
->data
->ShaderStorageBlocks
=
378 rzalloc_array(prog
->data
, struct gl_uniform_block
,
379 prog
->data
->NumShaderStorageBlocks
);
381 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
382 read_buffer_block(metadata
, &prog
->data
->UniformBlocks
[i
], prog
);
385 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
386 read_buffer_block(metadata
, &prog
->data
->ShaderStorageBlocks
[i
], prog
);
389 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
390 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
394 struct gl_program
*glprog
= sh
->Program
;
396 glprog
->info
.num_ubos
= blob_read_uint32(metadata
);
397 glprog
->info
.num_ssbos
= blob_read_uint32(metadata
);
399 glprog
->sh
.UniformBlocks
=
400 rzalloc_array(glprog
, gl_uniform_block
*, glprog
->info
.num_ubos
);
401 glprog
->sh
.ShaderStorageBlocks
=
402 rzalloc_array(glprog
, gl_uniform_block
*, glprog
->info
.num_ssbos
);
404 for (unsigned j
= 0; j
< glprog
->info
.num_ubos
; j
++) {
405 uint32_t offset
= blob_read_uint32(metadata
);
406 glprog
->sh
.UniformBlocks
[j
] = prog
->data
->UniformBlocks
+ offset
;
409 for (unsigned j
= 0; j
< glprog
->info
.num_ssbos
; j
++) {
410 uint32_t offset
= blob_read_uint32(metadata
);
411 glprog
->sh
.ShaderStorageBlocks
[j
] =
412 prog
->data
->ShaderStorageBlocks
+ offset
;
418 write_atomic_buffers(struct blob
*metadata
, struct gl_shader_program
*prog
)
420 blob_write_uint32(metadata
, prog
->data
->NumAtomicBuffers
);
422 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
423 if (prog
->_LinkedShaders
[i
]) {
424 struct gl_program
*glprog
= prog
->_LinkedShaders
[i
]->Program
;
425 blob_write_uint32(metadata
, glprog
->info
.num_abos
);
429 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
430 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].Binding
);
431 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].MinimumSize
);
432 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].NumUniforms
);
434 blob_write_bytes(metadata
, prog
->data
->AtomicBuffers
[i
].StageReferences
,
435 sizeof(prog
->data
->AtomicBuffers
[i
].StageReferences
));
437 for (unsigned j
= 0; j
< prog
->data
->AtomicBuffers
[i
].NumUniforms
; j
++) {
438 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].Uniforms
[j
]);
444 read_atomic_buffers(struct blob_reader
*metadata
,
445 struct gl_shader_program
*prog
)
447 prog
->data
->NumAtomicBuffers
= blob_read_uint32(metadata
);
448 prog
->data
->AtomicBuffers
=
449 rzalloc_array(prog
, gl_active_atomic_buffer
,
450 prog
->data
->NumAtomicBuffers
);
452 struct gl_active_atomic_buffer
**stage_buff_list
[MESA_SHADER_STAGES
];
453 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
454 if (prog
->_LinkedShaders
[i
]) {
455 struct gl_program
*glprog
= prog
->_LinkedShaders
[i
]->Program
;
457 glprog
->info
.num_abos
= blob_read_uint32(metadata
);
458 glprog
->sh
.AtomicBuffers
=
459 rzalloc_array(glprog
, gl_active_atomic_buffer
*,
460 glprog
->info
.num_abos
);
461 stage_buff_list
[i
] = glprog
->sh
.AtomicBuffers
;
465 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
466 prog
->data
->AtomicBuffers
[i
].Binding
= blob_read_uint32(metadata
);
467 prog
->data
->AtomicBuffers
[i
].MinimumSize
= blob_read_uint32(metadata
);
468 prog
->data
->AtomicBuffers
[i
].NumUniforms
= blob_read_uint32(metadata
);
470 blob_copy_bytes(metadata
,
471 (uint8_t *) &prog
->data
->AtomicBuffers
[i
].StageReferences
,
472 sizeof(prog
->data
->AtomicBuffers
[i
].StageReferences
));
474 prog
->data
->AtomicBuffers
[i
].Uniforms
= rzalloc_array(prog
, unsigned,
475 prog
->data
->AtomicBuffers
[i
].NumUniforms
);
477 for (unsigned j
= 0; j
< prog
->data
->AtomicBuffers
[i
].NumUniforms
; j
++) {
478 prog
->data
->AtomicBuffers
[i
].Uniforms
[j
] = blob_read_uint32(metadata
);
481 for (unsigned j
= 0; j
< MESA_SHADER_STAGES
; j
++) {
482 if (prog
->data
->AtomicBuffers
[i
].StageReferences
[j
]) {
483 *stage_buff_list
[j
] = &prog
->data
->AtomicBuffers
[i
];
484 stage_buff_list
[j
]++;
491 write_xfb(struct blob
*metadata
, struct gl_shader_program
*shProg
)
493 struct gl_program
*prog
= shProg
->last_vert_prog
;
496 blob_write_uint32(metadata
, ~0u);
500 struct gl_transform_feedback_info
*ltf
= prog
->sh
.LinkedTransformFeedback
;
502 blob_write_uint32(metadata
, prog
->info
.stage
);
504 blob_write_uint32(metadata
, ltf
->NumOutputs
);
505 blob_write_uint32(metadata
, ltf
->ActiveBuffers
);
506 blob_write_uint32(metadata
, ltf
->NumVarying
);
508 blob_write_bytes(metadata
, ltf
->Outputs
,
509 sizeof(struct gl_transform_feedback_output
) *
512 for (int i
= 0; i
< ltf
->NumVarying
; i
++) {
513 blob_write_string(metadata
, ltf
->Varyings
[i
].Name
);
514 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Type
);
515 blob_write_uint32(metadata
, ltf
->Varyings
[i
].BufferIndex
);
516 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Size
);
517 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Offset
);
520 blob_write_bytes(metadata
, ltf
->Buffers
,
521 sizeof(struct gl_transform_feedback_buffer
) *
522 MAX_FEEDBACK_BUFFERS
);
526 read_xfb(struct blob_reader
*metadata
, struct gl_shader_program
*shProg
)
528 unsigned xfb_stage
= blob_read_uint32(metadata
);
530 if (xfb_stage
== ~0u)
533 struct gl_program
*prog
= shProg
->_LinkedShaders
[xfb_stage
]->Program
;
534 struct gl_transform_feedback_info
*ltf
=
535 rzalloc(prog
, struct gl_transform_feedback_info
);
537 prog
->sh
.LinkedTransformFeedback
= ltf
;
538 shProg
->last_vert_prog
= prog
;
540 ltf
->NumOutputs
= blob_read_uint32(metadata
);
541 ltf
->ActiveBuffers
= blob_read_uint32(metadata
);
542 ltf
->NumVarying
= blob_read_uint32(metadata
);
544 ltf
->Outputs
= rzalloc_array(prog
, struct gl_transform_feedback_output
,
547 blob_copy_bytes(metadata
, (uint8_t *) ltf
->Outputs
,
548 sizeof(struct gl_transform_feedback_output
) *
551 ltf
->Varyings
= rzalloc_array(prog
,
552 struct gl_transform_feedback_varying_info
,
555 for (int i
= 0; i
< ltf
->NumVarying
; i
++) {
556 ltf
->Varyings
[i
].Name
= ralloc_strdup(prog
, blob_read_string(metadata
));
557 ltf
->Varyings
[i
].Type
= blob_read_uint32(metadata
);
558 ltf
->Varyings
[i
].BufferIndex
= blob_read_uint32(metadata
);
559 ltf
->Varyings
[i
].Size
= blob_read_uint32(metadata
);
560 ltf
->Varyings
[i
].Offset
= blob_read_uint32(metadata
);
563 blob_copy_bytes(metadata
, (uint8_t *) ltf
->Buffers
,
564 sizeof(struct gl_transform_feedback_buffer
) *
565 MAX_FEEDBACK_BUFFERS
);
569 write_uniforms(struct blob
*metadata
, struct gl_shader_program
*prog
)
571 blob_write_uint32(metadata
, prog
->SamplersValidated
);
572 blob_write_uint32(metadata
, prog
->data
->NumUniformStorage
);
573 blob_write_uint32(metadata
, prog
->data
->NumUniformDataSlots
);
575 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
576 encode_type_to_blob(metadata
, prog
->data
->UniformStorage
[i
].type
);
577 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].array_elements
);
578 blob_write_string(metadata
, prog
->data
->UniformStorage
[i
].name
);
579 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].storage
-
580 prog
->data
->UniformDataSlots
);
581 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].builtin
);
582 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].remap_location
);
583 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].block_index
);
584 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].atomic_buffer_index
);
585 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].offset
);
586 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].array_stride
);
587 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].hidden
);
588 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].is_shader_storage
);
589 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].active_shader_mask
);
590 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].matrix_stride
);
591 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].row_major
);
592 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].is_bindless
);
593 blob_write_uint32(metadata
,
594 prog
->data
->UniformStorage
[i
].num_compatible_subroutines
);
595 blob_write_uint32(metadata
,
596 prog
->data
->UniformStorage
[i
].top_level_array_size
);
597 blob_write_uint32(metadata
,
598 prog
->data
->UniformStorage
[i
].top_level_array_stride
);
599 blob_write_bytes(metadata
, prog
->data
->UniformStorage
[i
].opaque
,
600 sizeof(prog
->data
->UniformStorage
[i
].opaque
));
603 /* Here we cache all uniform values. We do this to retain values for
604 * uniforms with initialisers and also hidden uniforms that may be lowered
605 * constant arrays. We could possibly just store the values we need but for
606 * now we just store everything.
608 blob_write_uint32(metadata
, prog
->data
->NumHiddenUniforms
);
609 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
610 if (!prog
->data
->UniformStorage
[i
].builtin
&&
611 !prog
->data
->UniformStorage
[i
].is_shader_storage
&&
612 prog
->data
->UniformStorage
[i
].block_index
== -1) {
614 prog
->data
->UniformStorage
[i
].type
->component_slots() *
615 MAX2(prog
->data
->UniformStorage
[i
].array_elements
, 1);
616 blob_write_bytes(metadata
, prog
->data
->UniformStorage
[i
].storage
,
617 sizeof(union gl_constant_value
) * vec_size
);
623 read_uniforms(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
625 struct gl_uniform_storage
*uniforms
;
626 union gl_constant_value
*data
;
628 prog
->SamplersValidated
= blob_read_uint32(metadata
);
629 prog
->data
->NumUniformStorage
= blob_read_uint32(metadata
);
630 prog
->data
->NumUniformDataSlots
= blob_read_uint32(metadata
);
632 uniforms
= rzalloc_array(prog
, struct gl_uniform_storage
,
633 prog
->data
->NumUniformStorage
);
634 prog
->data
->UniformStorage
= uniforms
;
636 data
= rzalloc_array(uniforms
, union gl_constant_value
,
637 prog
->data
->NumUniformDataSlots
);
638 prog
->data
->UniformDataSlots
= data
;
640 prog
->UniformHash
= new string_to_uint_map
;
642 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
643 uniforms
[i
].type
= decode_type_from_blob(metadata
);
644 uniforms
[i
].array_elements
= blob_read_uint32(metadata
);
645 uniforms
[i
].name
= ralloc_strdup(prog
, blob_read_string (metadata
));
646 uniforms
[i
].storage
= data
+ blob_read_uint32(metadata
);
647 uniforms
[i
].builtin
= blob_read_uint32(metadata
);
648 uniforms
[i
].remap_location
= blob_read_uint32(metadata
);
649 uniforms
[i
].block_index
= blob_read_uint32(metadata
);
650 uniforms
[i
].atomic_buffer_index
= blob_read_uint32(metadata
);
651 uniforms
[i
].offset
= blob_read_uint32(metadata
);
652 uniforms
[i
].array_stride
= blob_read_uint32(metadata
);
653 uniforms
[i
].hidden
= blob_read_uint32(metadata
);
654 uniforms
[i
].is_shader_storage
= blob_read_uint32(metadata
);
655 uniforms
[i
].active_shader_mask
= blob_read_uint32(metadata
);
656 uniforms
[i
].matrix_stride
= blob_read_uint32(metadata
);
657 uniforms
[i
].row_major
= blob_read_uint32(metadata
);
658 uniforms
[i
].is_bindless
= blob_read_uint32(metadata
);
659 uniforms
[i
].num_compatible_subroutines
= blob_read_uint32(metadata
);
660 uniforms
[i
].top_level_array_size
= blob_read_uint32(metadata
);
661 uniforms
[i
].top_level_array_stride
= blob_read_uint32(metadata
);
662 prog
->UniformHash
->put(i
, uniforms
[i
].name
);
664 memcpy(uniforms
[i
].opaque
,
665 blob_read_bytes(metadata
, sizeof(uniforms
[i
].opaque
)),
666 sizeof(uniforms
[i
].opaque
));
669 /* Restore uniform values. */
670 prog
->data
->NumHiddenUniforms
= blob_read_uint32(metadata
);
671 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
672 if (!prog
->data
->UniformStorage
[i
].builtin
&&
673 !prog
->data
->UniformStorage
[i
].is_shader_storage
&&
674 prog
->data
->UniformStorage
[i
].block_index
== -1) {
676 prog
->data
->UniformStorage
[i
].type
->component_slots() *
677 MAX2(prog
->data
->UniformStorage
[i
].array_elements
, 1);
678 blob_copy_bytes(metadata
,
679 (uint8_t *) prog
->data
->UniformStorage
[i
].storage
,
680 sizeof(union gl_constant_value
) * vec_size
);
682 assert(vec_size
+ prog
->data
->UniformStorage
[i
].storage
<=
683 data
+ prog
->data
->NumUniformDataSlots
);
688 enum uniform_remap_type
690 remap_type_inactive_explicit_location
,
692 remap_type_uniform_offset
696 write_uniform_remap_table_entry(struct blob
*metadata
,
697 gl_uniform_storage
*uniform_storage
,
698 gl_uniform_storage
*entry
)
700 if (entry
== INACTIVE_UNIFORM_EXPLICIT_LOCATION
) {
701 blob_write_uint32(metadata
, remap_type_inactive_explicit_location
);
702 } else if (entry
== NULL
) {
703 blob_write_uint32(metadata
, remap_type_null_ptr
);
705 blob_write_uint32(metadata
, remap_type_uniform_offset
);
707 uint32_t offset
= entry
- uniform_storage
;
708 blob_write_uint32(metadata
, offset
);
713 write_uniform_remap_tables(struct blob
*metadata
,
714 struct gl_shader_program
*prog
)
716 blob_write_uint32(metadata
, prog
->NumUniformRemapTable
);
718 for (unsigned i
= 0; i
< prog
->NumUniformRemapTable
; i
++) {
719 write_uniform_remap_table_entry(metadata
, prog
->data
->UniformStorage
,
720 prog
->UniformRemapTable
[i
]);
723 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
724 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
726 struct gl_program
*glprog
= sh
->Program
;
727 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineUniformRemapTable
);
729 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineUniformRemapTable
; j
++) {
730 write_uniform_remap_table_entry(metadata
,
731 prog
->data
->UniformStorage
,
732 glprog
->sh
.SubroutineUniformRemapTable
[j
]);
739 read_uniform_remap_table_entry(struct blob_reader
*metadata
,
740 gl_uniform_storage
*uniform_storage
,
741 gl_uniform_storage
**entry
,
742 enum uniform_remap_type type
)
744 if (type
== remap_type_inactive_explicit_location
) {
745 *entry
= INACTIVE_UNIFORM_EXPLICIT_LOCATION
;
746 } else if (type
== remap_type_null_ptr
) {
749 uint32_t uni_offset
= blob_read_uint32(metadata
);
750 *entry
= uniform_storage
+ uni_offset
;
755 read_uniform_remap_tables(struct blob_reader
*metadata
,
756 struct gl_shader_program
*prog
)
758 prog
->NumUniformRemapTable
= blob_read_uint32(metadata
);
760 prog
->UniformRemapTable
= rzalloc_array(prog
, struct gl_uniform_storage
*,
761 prog
->NumUniformRemapTable
);
763 for (unsigned i
= 0; i
< prog
->NumUniformRemapTable
; i
++) {
764 enum uniform_remap_type type
=
765 (enum uniform_remap_type
) blob_read_uint32(metadata
);
767 read_uniform_remap_table_entry(metadata
, prog
->data
->UniformStorage
,
768 &prog
->UniformRemapTable
[i
], type
);
771 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
772 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
774 struct gl_program
*glprog
= sh
->Program
;
775 glprog
->sh
.NumSubroutineUniformRemapTable
= blob_read_uint32(metadata
);
777 glprog
->sh
.SubroutineUniformRemapTable
=
778 rzalloc_array(glprog
, struct gl_uniform_storage
*,
779 glprog
->sh
.NumSubroutineUniformRemapTable
);
781 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineUniformRemapTable
; j
++) {
782 enum uniform_remap_type type
=
783 (enum uniform_remap_type
) blob_read_uint32(metadata
);
785 read_uniform_remap_table_entry(metadata
,
786 prog
->data
->UniformStorage
,
787 &glprog
->sh
.SubroutineUniformRemapTable
[j
],
801 write_hash_table_entry(const char *key
, unsigned value
, void *closure
)
803 struct whte_closure
*whte
= (struct whte_closure
*) closure
;
805 blob_write_string(whte
->blob
, key
);
806 blob_write_uint32(whte
->blob
, value
);
812 write_hash_table(struct blob
*metadata
, struct string_to_uint_map
*hash
)
815 struct whte_closure whte
;
817 whte
.blob
= metadata
;
818 whte
.num_entries
= 0;
820 offset
= metadata
->size
;
822 /* Write a placeholder for the hashtable size. */
823 blob_write_uint32 (metadata
, 0);
825 hash
->iterate(write_hash_table_entry
, &whte
);
827 /* Overwrite with the computed number of entries written. */
828 blob_overwrite_uint32 (metadata
, offset
, whte
.num_entries
);
832 read_hash_table(struct blob_reader
*metadata
, struct string_to_uint_map
*hash
)
834 size_t i
, num_entries
;
838 num_entries
= blob_read_uint32 (metadata
);
840 for (i
= 0; i
< num_entries
; i
++) {
841 key
= blob_read_string(metadata
);
842 value
= blob_read_uint32(metadata
);
844 hash
->put(value
, key
);
849 write_hash_tables(struct blob
*metadata
, struct gl_shader_program
*prog
)
851 write_hash_table(metadata
, prog
->AttributeBindings
);
852 write_hash_table(metadata
, prog
->FragDataBindings
);
853 write_hash_table(metadata
, prog
->FragDataIndexBindings
);
857 read_hash_tables(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
859 read_hash_table(metadata
, prog
->AttributeBindings
);
860 read_hash_table(metadata
, prog
->FragDataBindings
);
861 read_hash_table(metadata
, prog
->FragDataIndexBindings
);
865 write_shader_subroutine_index(struct blob
*metadata
,
866 struct gl_linked_shader
*sh
,
867 struct gl_program_resource
*res
)
871 for (unsigned j
= 0; j
< sh
->Program
->sh
.NumSubroutineFunctions
; j
++) {
872 if (strcmp(((gl_subroutine_function
*)res
->Data
)->name
,
873 sh
->Program
->sh
.SubroutineFunctions
[j
].name
) == 0) {
874 blob_write_uint32(metadata
, j
);
881 write_program_resource_data(struct blob
*metadata
,
882 struct gl_shader_program
*prog
,
883 struct gl_program_resource
*res
)
885 struct gl_linked_shader
*sh
;
888 case GL_PROGRAM_INPUT
:
889 case GL_PROGRAM_OUTPUT
: {
890 const gl_shader_variable
*var
= (gl_shader_variable
*)res
->Data
;
891 blob_write_bytes(metadata
, var
, sizeof(gl_shader_variable
));
892 encode_type_to_blob(metadata
, var
->type
);
894 if (var
->interface_type
)
895 encode_type_to_blob(metadata
, var
->interface_type
);
897 if (var
->outermost_struct_type
)
898 encode_type_to_blob(metadata
, var
->outermost_struct_type
);
900 blob_write_string(metadata
, var
->name
);
903 case GL_UNIFORM_BLOCK
:
904 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
905 if (strcmp(((gl_uniform_block
*)res
->Data
)->Name
,
906 prog
->data
->UniformBlocks
[i
].Name
) == 0) {
907 blob_write_uint32(metadata
, i
);
912 case GL_SHADER_STORAGE_BLOCK
:
913 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
914 if (strcmp(((gl_uniform_block
*)res
->Data
)->Name
,
915 prog
->data
->ShaderStorageBlocks
[i
].Name
) == 0) {
916 blob_write_uint32(metadata
, i
);
921 case GL_BUFFER_VARIABLE
:
922 case GL_VERTEX_SUBROUTINE_UNIFORM
:
923 case GL_GEOMETRY_SUBROUTINE_UNIFORM
:
924 case GL_FRAGMENT_SUBROUTINE_UNIFORM
:
925 case GL_COMPUTE_SUBROUTINE_UNIFORM
:
926 case GL_TESS_CONTROL_SUBROUTINE_UNIFORM
:
927 case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM
:
929 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
930 if (strcmp(((gl_uniform_storage
*)res
->Data
)->name
,
931 prog
->data
->UniformStorage
[i
].name
) == 0) {
932 blob_write_uint32(metadata
, i
);
937 case GL_ATOMIC_COUNTER_BUFFER
:
938 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
939 if (((gl_active_atomic_buffer
*)res
->Data
)->Binding
==
940 prog
->data
->AtomicBuffers
[i
].Binding
) {
941 blob_write_uint32(metadata
, i
);
946 case GL_TRANSFORM_FEEDBACK_BUFFER
:
947 for (unsigned i
= 0; i
< MAX_FEEDBACK_BUFFERS
; i
++) {
948 if (((gl_transform_feedback_buffer
*)res
->Data
)->Binding
==
949 prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->Buffers
[i
].Binding
) {
950 blob_write_uint32(metadata
, i
);
955 case GL_TRANSFORM_FEEDBACK_VARYING
:
956 for (int i
= 0; i
< prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->NumVarying
; i
++) {
957 if (strcmp(((gl_transform_feedback_varying_info
*)res
->Data
)->Name
,
958 prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->Varyings
[i
].Name
) == 0) {
959 blob_write_uint32(metadata
, i
);
964 case GL_VERTEX_SUBROUTINE
:
965 case GL_TESS_CONTROL_SUBROUTINE
:
966 case GL_TESS_EVALUATION_SUBROUTINE
:
967 case GL_GEOMETRY_SUBROUTINE
:
968 case GL_FRAGMENT_SUBROUTINE
:
969 case GL_COMPUTE_SUBROUTINE
:
971 prog
->_LinkedShaders
[_mesa_shader_stage_from_subroutine(res
->Type
)];
972 write_shader_subroutine_index(metadata
, sh
, res
);
975 assert(!"Support for writing resource not yet implemented.");
980 read_program_resource_data(struct blob_reader
*metadata
,
981 struct gl_shader_program
*prog
,
982 struct gl_program_resource
*res
)
984 struct gl_linked_shader
*sh
;
987 case GL_PROGRAM_INPUT
:
988 case GL_PROGRAM_OUTPUT
: {
989 gl_shader_variable
*var
= ralloc(prog
, struct gl_shader_variable
);
991 blob_copy_bytes(metadata
, (uint8_t *) var
, sizeof(gl_shader_variable
));
992 var
->type
= decode_type_from_blob(metadata
);
994 if (var
->interface_type
)
995 var
->interface_type
= decode_type_from_blob(metadata
);
997 if (var
->outermost_struct_type
)
998 var
->outermost_struct_type
= decode_type_from_blob(metadata
);
1000 var
->name
= ralloc_strdup(prog
, blob_read_string(metadata
));
1005 case GL_UNIFORM_BLOCK
:
1006 res
->Data
= &prog
->data
->UniformBlocks
[blob_read_uint32(metadata
)];
1008 case GL_SHADER_STORAGE_BLOCK
:
1009 res
->Data
= &prog
->data
->ShaderStorageBlocks
[blob_read_uint32(metadata
)];
1011 case GL_BUFFER_VARIABLE
:
1012 case GL_VERTEX_SUBROUTINE_UNIFORM
:
1013 case GL_GEOMETRY_SUBROUTINE_UNIFORM
:
1014 case GL_FRAGMENT_SUBROUTINE_UNIFORM
:
1015 case GL_COMPUTE_SUBROUTINE_UNIFORM
:
1016 case GL_TESS_CONTROL_SUBROUTINE_UNIFORM
:
1017 case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM
:
1019 res
->Data
= &prog
->data
->UniformStorage
[blob_read_uint32(metadata
)];
1021 case GL_ATOMIC_COUNTER_BUFFER
:
1022 res
->Data
= &prog
->data
->AtomicBuffers
[blob_read_uint32(metadata
)];
1024 case GL_TRANSFORM_FEEDBACK_BUFFER
:
1025 res
->Data
= &prog
->last_vert_prog
->
1026 sh
.LinkedTransformFeedback
->Buffers
[blob_read_uint32(metadata
)];
1028 case GL_TRANSFORM_FEEDBACK_VARYING
:
1029 res
->Data
= &prog
->last_vert_prog
->
1030 sh
.LinkedTransformFeedback
->Varyings
[blob_read_uint32(metadata
)];
1032 case GL_VERTEX_SUBROUTINE
:
1033 case GL_TESS_CONTROL_SUBROUTINE
:
1034 case GL_TESS_EVALUATION_SUBROUTINE
:
1035 case GL_GEOMETRY_SUBROUTINE
:
1036 case GL_FRAGMENT_SUBROUTINE
:
1037 case GL_COMPUTE_SUBROUTINE
:
1039 prog
->_LinkedShaders
[_mesa_shader_stage_from_subroutine(res
->Type
)];
1041 &sh
->Program
->sh
.SubroutineFunctions
[blob_read_uint32(metadata
)];
1044 assert(!"Support for reading resource not yet implemented.");
1049 write_program_resource_list(struct blob
*metadata
,
1050 struct gl_shader_program
*prog
)
1052 blob_write_uint32(metadata
, prog
->data
->NumProgramResourceList
);
1054 for (unsigned i
= 0; i
< prog
->data
->NumProgramResourceList
; i
++) {
1055 blob_write_uint32(metadata
, prog
->data
->ProgramResourceList
[i
].Type
);
1056 write_program_resource_data(metadata
, prog
,
1057 &prog
->data
->ProgramResourceList
[i
]);
1058 blob_write_bytes(metadata
,
1059 &prog
->data
->ProgramResourceList
[i
].StageReferences
,
1060 sizeof(prog
->data
->ProgramResourceList
[i
].StageReferences
));
1065 read_program_resource_list(struct blob_reader
*metadata
,
1066 struct gl_shader_program
*prog
)
1068 prog
->data
->NumProgramResourceList
= blob_read_uint32(metadata
);
1070 prog
->data
->ProgramResourceList
=
1071 ralloc_array(prog
, gl_program_resource
,
1072 prog
->data
->NumProgramResourceList
);
1074 for (unsigned i
= 0; i
< prog
->data
->NumProgramResourceList
; i
++) {
1075 prog
->data
->ProgramResourceList
[i
].Type
= blob_read_uint32(metadata
);
1076 read_program_resource_data(metadata
, prog
,
1077 &prog
->data
->ProgramResourceList
[i
]);
1078 blob_copy_bytes(metadata
,
1079 (uint8_t *) &prog
->data
->ProgramResourceList
[i
].StageReferences
,
1080 sizeof(prog
->data
->ProgramResourceList
[i
].StageReferences
));
1085 write_shader_parameters(struct blob
*metadata
,
1086 struct gl_program_parameter_list
*params
)
1088 blob_write_uint32(metadata
, params
->NumParameters
);
1091 while (i
< params
->NumParameters
) {
1092 struct gl_program_parameter
*param
= ¶ms
->Parameters
[i
];
1094 blob_write_uint32(metadata
, param
->Type
);
1095 blob_write_string(metadata
, param
->Name
);
1096 blob_write_uint32(metadata
, param
->Size
);
1097 blob_write_uint32(metadata
, param
->DataType
);
1098 blob_write_bytes(metadata
, param
->StateIndexes
,
1099 sizeof(param
->StateIndexes
));
1101 i
+= (param
->Size
+ 3) / 4;
1104 blob_write_bytes(metadata
, params
->ParameterValues
,
1105 sizeof(gl_constant_value
) * 4 * params
->NumParameters
);
1107 blob_write_uint32(metadata
, params
->StateFlags
);
1111 read_shader_parameters(struct blob_reader
*metadata
,
1112 struct gl_program_parameter_list
*params
)
1114 gl_state_index state_indexes
[STATE_LENGTH
];
1116 uint32_t num_parameters
= blob_read_uint32(metadata
);
1118 _mesa_reserve_parameter_storage(params
, num_parameters
);
1119 while (i
< num_parameters
) {
1120 gl_register_file type
= (gl_register_file
) blob_read_uint32(metadata
);
1121 const char *name
= blob_read_string(metadata
);
1122 unsigned size
= blob_read_uint32(metadata
);
1123 unsigned data_type
= blob_read_uint32(metadata
);
1124 blob_copy_bytes(metadata
, (uint8_t *) state_indexes
,
1125 sizeof(state_indexes
));
1127 _mesa_add_parameter(params
, type
, name
, size
, data_type
,
1128 NULL
, state_indexes
);
1130 i
+= (size
+ 3) / 4;
1133 blob_copy_bytes(metadata
, (uint8_t *) params
->ParameterValues
,
1134 sizeof(gl_constant_value
) * 4 * params
->NumParameters
);
1136 params
->StateFlags
= blob_read_uint32(metadata
);
1140 write_shader_metadata(struct blob
*metadata
, gl_linked_shader
*shader
)
1142 assert(shader
->Program
);
1143 struct gl_program
*glprog
= shader
->Program
;
1146 blob_write_bytes(metadata
, glprog
->TexturesUsed
,
1147 sizeof(glprog
->TexturesUsed
));
1148 blob_write_uint64(metadata
, glprog
->SamplersUsed
);
1150 blob_write_bytes(metadata
, glprog
->SamplerUnits
,
1151 sizeof(glprog
->SamplerUnits
));
1152 blob_write_bytes(metadata
, glprog
->sh
.SamplerTargets
,
1153 sizeof(glprog
->sh
.SamplerTargets
));
1154 blob_write_uint32(metadata
, glprog
->ShadowSamplers
);
1156 blob_write_bytes(metadata
, glprog
->sh
.ImageAccess
,
1157 sizeof(glprog
->sh
.ImageAccess
));
1158 blob_write_bytes(metadata
, glprog
->sh
.ImageUnits
,
1159 sizeof(glprog
->sh
.ImageUnits
));
1161 blob_write_uint32(metadata
, glprog
->sh
.NumBindlessSamplers
);
1162 blob_write_uint32(metadata
, glprog
->sh
.HasBoundBindlessSampler
);
1163 for (i
= 0; i
< glprog
->sh
.NumBindlessSamplers
; i
++) {
1164 blob_write_bytes(metadata
, &glprog
->sh
.BindlessSamplers
[i
],
1165 sizeof(struct gl_bindless_sampler
));
1168 blob_write_uint32(metadata
, glprog
->sh
.NumBindlessImages
);
1169 blob_write_uint32(metadata
, glprog
->sh
.HasBoundBindlessImage
);
1170 for (i
= 0; i
< glprog
->sh
.NumBindlessImages
; i
++) {
1171 blob_write_bytes(metadata
, &glprog
->sh
.BindlessImages
[i
],
1172 sizeof(struct gl_bindless_image
));
1175 write_shader_parameters(metadata
, glprog
->Parameters
);
1179 read_shader_metadata(struct blob_reader
*metadata
,
1180 struct gl_program
*glprog
,
1181 gl_linked_shader
*linked
)
1185 blob_copy_bytes(metadata
, (uint8_t *) glprog
->TexturesUsed
,
1186 sizeof(glprog
->TexturesUsed
));
1187 glprog
->SamplersUsed
= blob_read_uint64(metadata
);
1189 blob_copy_bytes(metadata
, (uint8_t *) glprog
->SamplerUnits
,
1190 sizeof(glprog
->SamplerUnits
));
1191 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.SamplerTargets
,
1192 sizeof(glprog
->sh
.SamplerTargets
));
1193 glprog
->ShadowSamplers
= blob_read_uint32(metadata
);
1195 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.ImageAccess
,
1196 sizeof(glprog
->sh
.ImageAccess
));
1197 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.ImageUnits
,
1198 sizeof(glprog
->sh
.ImageUnits
));
1200 glprog
->sh
.NumBindlessSamplers
= blob_read_uint32(metadata
);
1201 glprog
->sh
.HasBoundBindlessSampler
= blob_read_uint32(metadata
);
1202 if (glprog
->sh
.NumBindlessSamplers
> 0) {
1203 glprog
->sh
.BindlessSamplers
=
1204 rzalloc_array(glprog
, gl_bindless_sampler
,
1205 glprog
->sh
.NumBindlessSamplers
);
1207 for (i
= 0; i
< glprog
->sh
.NumBindlessSamplers
; i
++) {
1208 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->sh
.BindlessSamplers
[i
],
1209 sizeof(struct gl_bindless_sampler
));
1213 glprog
->sh
.NumBindlessImages
= blob_read_uint32(metadata
);
1214 glprog
->sh
.HasBoundBindlessImage
= blob_read_uint32(metadata
);
1215 if (glprog
->sh
.NumBindlessImages
> 0) {
1216 glprog
->sh
.BindlessImages
=
1217 rzalloc_array(glprog
, gl_bindless_image
,
1218 glprog
->sh
.NumBindlessImages
);
1220 for (i
= 0; i
< glprog
->sh
.NumBindlessImages
; i
++) {
1221 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->sh
.BindlessImages
[i
],
1222 sizeof(struct gl_bindless_image
));
1226 glprog
->Parameters
= _mesa_new_parameter_list();
1227 read_shader_parameters(metadata
, glprog
->Parameters
);
1231 create_binding_str(const char *key
, unsigned value
, void *closure
)
1233 char **bindings_str
= (char **) closure
;
1234 ralloc_asprintf_append(bindings_str
, "%s:%u,", key
, value
);
1238 create_linked_shader_and_program(struct gl_context
*ctx
,
1239 gl_shader_stage stage
,
1240 struct gl_shader_program
*prog
,
1241 struct blob_reader
*metadata
)
1243 struct gl_program
*glprog
;
1245 struct gl_linked_shader
*linked
= rzalloc(NULL
, struct gl_linked_shader
);
1246 linked
->Stage
= stage
;
1248 glprog
= ctx
->Driver
.NewProgram(ctx
, _mesa_shader_stage_to_program(stage
),
1250 glprog
->info
.stage
= stage
;
1251 linked
->Program
= glprog
;
1253 read_shader_metadata(metadata
, glprog
, linked
);
1255 /* Restore shader info */
1256 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->info
, sizeof(shader_info
));
1257 if (glprog
->info
.name
)
1258 glprog
->info
.name
= ralloc_strdup(glprog
, blob_read_string(metadata
));
1259 if (glprog
->info
.label
)
1260 glprog
->info
.label
= ralloc_strdup(glprog
, blob_read_string(metadata
));
1262 _mesa_reference_shader_program_data(ctx
, &glprog
->sh
.data
, prog
->data
);
1263 _mesa_reference_program(ctx
, &linked
->Program
, glprog
);
1264 prog
->_LinkedShaders
[stage
] = linked
;
1268 shader_cache_write_program_metadata(struct gl_context
*ctx
,
1269 struct gl_shader_program
*prog
)
1271 struct disk_cache
*cache
= ctx
->Cache
;
1275 /* Exit early when we are dealing with a ff shader with no source file to
1276 * generate a source from.
1278 * TODO: In future we should use another method to generate a key for ff
1281 static const char zero
[sizeof(prog
->data
->sha1
)] = {0};
1282 if (memcmp(prog
->data
->sha1
, zero
, sizeof(prog
->data
->sha1
)) == 0)
1285 struct blob
*metadata
= blob_create();
1287 write_uniforms(metadata
, prog
);
1289 write_hash_tables(metadata
, prog
);
1291 blob_write_uint32(metadata
, prog
->data
->Version
);
1292 blob_write_uint32(metadata
, prog
->data
->linked_stages
);
1294 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1295 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
1297 write_shader_metadata(metadata
, sh
);
1299 /* Store nir shader info */
1300 blob_write_bytes(metadata
, &sh
->Program
->info
, sizeof(shader_info
));
1302 if (sh
->Program
->info
.name
)
1303 blob_write_string(metadata
, sh
->Program
->info
.name
);
1305 if (sh
->Program
->info
.label
)
1306 blob_write_string(metadata
, sh
->Program
->info
.label
);
1310 write_xfb(metadata
, prog
);
1312 write_uniform_remap_tables(metadata
, prog
);
1314 write_atomic_buffers(metadata
, prog
);
1316 write_buffer_blocks(metadata
, prog
);
1318 write_subroutines(metadata
, prog
);
1320 write_program_resource_list(metadata
, prog
);
1323 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
1324 disk_cache_put_key(cache
, prog
->Shaders
[i
]->sha1
);
1325 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1326 _mesa_sha1_format(sha1_buf
, prog
->Shaders
[i
]->sha1
);
1327 fprintf(stderr
, "marking shader: %s\n", sha1_buf
);
1331 disk_cache_put(cache
, prog
->data
->sha1
, metadata
->data
, metadata
->size
);
1333 blob_destroy(metadata
);
1335 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1336 _mesa_sha1_format(sha1_buf
, prog
->data
->sha1
);
1337 fprintf(stderr
, "putting program metadata in cache: %s\n", sha1_buf
);
1342 shader_cache_read_program_metadata(struct gl_context
*ctx
,
1343 struct gl_shader_program
*prog
)
1345 /* Fixed function programs generated by Mesa are not cached. So don't
1346 * try to read metadata for them from the cache.
1348 if (prog
->Name
== 0)
1351 struct disk_cache
*cache
= ctx
->Cache
;
1352 if (!cache
|| prog
->data
->cache_fallback
|| prog
->data
->skip_cache
)
1355 /* Include bindings when creating sha1. These bindings change the resulting
1356 * binary so they are just as important as the shader source.
1358 char *buf
= ralloc_strdup(NULL
, "vb: ");
1359 prog
->AttributeBindings
->iterate(create_binding_str
, &buf
);
1360 ralloc_strcat(&buf
, "fb: ");
1361 prog
->FragDataBindings
->iterate(create_binding_str
, &buf
);
1362 ralloc_strcat(&buf
, "fbi: ");
1363 prog
->FragDataIndexBindings
->iterate(create_binding_str
, &buf
);
1365 /* SSO has an effect on the linked program so include this when generating
1368 ralloc_asprintf_append(&buf
, "sso: %s\n",
1369 prog
->SeparateShader
? "T" : "F");
1371 /* A shader might end up producing different output depending on the glsl
1372 * version supported by the compiler. For example a different path might be
1373 * taken by the preprocessor, so add the version to the hash input.
1375 ralloc_asprintf_append(&buf
, "api: %d glsl: %d fglsl: %d\n",
1376 ctx
->API
, ctx
->Const
.GLSLVersion
,
1377 ctx
->Const
.ForceGLSLVersion
);
1379 /* We run the preprocessor on shaders after hashing them, so we need to
1380 * add any extension override vars to the hash. If we don't do this the
1381 * preprocessor could result in different output and we could load the
1384 char *ext_override
= getenv("MESA_EXTENSION_OVERRIDE");
1386 ralloc_asprintf_append(&buf
, "ext:%s", ext_override
);
1389 /* DRI config options may also change the output from the compiler so
1390 * include them as an input to sha1 creation.
1393 _mesa_sha1_format(sha1buf
, ctx
->Const
.dri_config_options_sha1
);
1394 ralloc_strcat(&buf
, sha1buf
);
1396 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
1397 struct gl_shader
*sh
= prog
->Shaders
[i
];
1398 _mesa_sha1_format(sha1buf
, sh
->sha1
);
1399 ralloc_asprintf_append(&buf
, "%s: %s\n",
1400 _mesa_shader_stage_to_abbrev(sh
->Stage
), sha1buf
);
1402 disk_cache_compute_key(cache
, buf
, strlen(buf
), prog
->data
->sha1
);
1406 uint8_t *buffer
= (uint8_t *) disk_cache_get(cache
, prog
->data
->sha1
,
1408 if (buffer
== NULL
) {
1409 /* Cached program not found. We may have seen the individual shaders
1410 * before and skipped compiling but they may not have been used together
1411 * in this combination before. Fall back to linking shaders but first
1412 * re-compile the shaders.
1414 * We could probably only compile the shaders which were skipped here
1415 * but we need to be careful because the source may also have been
1416 * changed since the last compile so for now we just recompile
1419 compile_shaders(ctx
, prog
);
1423 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1424 _mesa_sha1_format(sha1buf
, prog
->data
->sha1
);
1425 fprintf(stderr
, "loading shader program meta data from cache: %s\n",
1429 struct blob_reader metadata
;
1430 blob_reader_init(&metadata
, buffer
, size
);
1432 assert(prog
->data
->UniformStorage
== NULL
);
1434 read_uniforms(&metadata
, prog
);
1436 read_hash_tables(&metadata
, prog
);
1438 prog
->data
->Version
= blob_read_uint32(&metadata
);
1439 prog
->data
->linked_stages
= blob_read_uint32(&metadata
);
1441 unsigned mask
= prog
->data
->linked_stages
;
1443 const int j
= u_bit_scan(&mask
);
1444 create_linked_shader_and_program(ctx
, (gl_shader_stage
) j
, prog
,
1448 read_xfb(&metadata
, prog
);
1450 read_uniform_remap_tables(&metadata
, prog
);
1452 read_atomic_buffers(&metadata
, prog
);
1454 read_buffer_blocks(&metadata
, prog
);
1456 read_subroutines(&metadata
, prog
);
1458 read_program_resource_list(&metadata
, prog
);
1460 if (metadata
.current
!= metadata
.end
|| metadata
.overrun
) {
1461 /* Something has gone wrong discard the item from the cache and rebuild
1464 assert(!"Invalid GLSL shader disk cache item!");
1466 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1467 fprintf(stderr
, "Error reading program from cache (invalid GLSL "
1471 disk_cache_remove(cache
, prog
->data
->sha1
);
1472 compile_shaders(ctx
, prog
);
1477 /* This is used to flag a shader retrieved from cache */
1478 prog
->data
->LinkStatus
= linking_skipped
;
1480 /* Since the program load was successful, CompileStatus of all shaders at
1481 * this point should normally be compile_skipped. However because of how
1482 * the eviction works, it may happen that some of the individual shader keys
1483 * have been evicted, resulting in unnecessary recompiles on this load, so
1484 * mark them again to skip such recompiles next time.
1487 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
1488 if (prog
->Shaders
[i
]->CompileStatus
== compiled_no_opts
) {
1489 disk_cache_put_key(cache
, prog
->Shaders
[i
]->sha1
);
1490 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1491 _mesa_sha1_format(sha1_buf
, prog
->Shaders
[i
]->sha1
);
1492 fprintf(stderr
, "re-marking shader: %s\n", sha1_buf
);