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
)
82 switch (type
->base_type
) {
87 case GLSL_TYPE_DOUBLE
:
88 case GLSL_TYPE_UINT64
:
90 encoding
= (type
->base_type
<< 24) |
91 (type
->vector_elements
<< 4) |
92 (type
->matrix_columns
);
94 case GLSL_TYPE_SAMPLER
:
95 encoding
= (type
->base_type
) << 24 |
96 (type
->sampler_dimensionality
<< 4) |
97 (type
->sampler_shadow
<< 3) |
98 (type
->sampler_array
<< 2) |
101 case GLSL_TYPE_SUBROUTINE
:
102 encoding
= type
->base_type
<< 24;
103 blob_write_uint32(blob
, encoding
);
104 blob_write_string(blob
, type
->name
);
106 case GLSL_TYPE_IMAGE
:
107 encoding
= (type
->base_type
) << 24 |
108 (type
->sampler_dimensionality
<< 3) |
109 (type
->sampler_array
<< 2) |
110 (type
->sampled_type
);
112 case GLSL_TYPE_ATOMIC_UINT
:
113 encoding
= (type
->base_type
<< 24);
115 case GLSL_TYPE_ARRAY
:
116 blob_write_uint32(blob
, (type
->base_type
) << 24);
117 blob_write_uint32(blob
, type
->length
);
118 encode_type_to_blob(blob
, type
->fields
.array
);
120 case GLSL_TYPE_STRUCT
:
121 case GLSL_TYPE_INTERFACE
:
122 blob_write_uint32(blob
, (type
->base_type
) << 24);
123 blob_write_string(blob
, type
->name
);
124 blob_write_uint32(blob
, type
->length
);
125 blob_write_bytes(blob
, type
->fields
.structure
,
126 sizeof(glsl_struct_field
) * type
->length
);
127 for (unsigned i
= 0; i
< type
->length
; i
++) {
128 encode_type_to_blob(blob
, type
->fields
.structure
[i
].type
);
129 blob_write_string(blob
, type
->fields
.structure
[i
].name
);
132 if (type
->base_type
== GLSL_TYPE_INTERFACE
) {
133 blob_write_uint32(blob
, type
->interface_packing
);
134 blob_write_uint32(blob
, type
->interface_row_major
);
138 case GLSL_TYPE_ERROR
:
140 assert(!"Cannot encode type!");
145 blob_write_uint32(blob
, encoding
);
148 static const glsl_type
*
149 decode_type_from_blob(struct blob_reader
*blob
)
151 uint32_t u
= blob_read_uint32(blob
);
152 glsl_base_type base_type
= (glsl_base_type
) (u
>> 24);
157 case GLSL_TYPE_FLOAT
:
159 case GLSL_TYPE_DOUBLE
:
160 case GLSL_TYPE_UINT64
:
161 case GLSL_TYPE_INT64
:
162 return glsl_type::get_instance(base_type
, (u
>> 4) & 0x0f, u
& 0x0f);
163 case GLSL_TYPE_SAMPLER
:
164 return glsl_type::get_sampler_instance((enum glsl_sampler_dim
) ((u
>> 4) & 0x07),
167 (glsl_base_type
) ((u
>> 0) & 0x03));
168 case GLSL_TYPE_SUBROUTINE
:
169 return glsl_type::get_subroutine_instance(blob_read_string(blob
));
170 case GLSL_TYPE_IMAGE
:
171 return glsl_type::get_image_instance((enum glsl_sampler_dim
) ((u
>> 3) & 0x07),
173 (glsl_base_type
) ((u
>> 0) & 0x03));
174 case GLSL_TYPE_ATOMIC_UINT
:
175 return glsl_type::atomic_uint_type
;
176 case GLSL_TYPE_ARRAY
: {
177 unsigned length
= blob_read_uint32(blob
);
178 return glsl_type::get_array_instance(decode_type_from_blob(blob
),
181 case GLSL_TYPE_STRUCT
:
182 case GLSL_TYPE_INTERFACE
: {
183 char *name
= blob_read_string(blob
);
184 unsigned num_fields
= blob_read_uint32(blob
);
185 glsl_struct_field
*fields
= (glsl_struct_field
*)
186 blob_read_bytes(blob
, sizeof(glsl_struct_field
) * num_fields
);
187 for (unsigned i
= 0; i
< num_fields
; i
++) {
188 fields
[i
].type
= decode_type_from_blob(blob
);
189 fields
[i
].name
= blob_read_string(blob
);
192 if (base_type
== GLSL_TYPE_INTERFACE
) {
193 enum glsl_interface_packing packing
=
194 (glsl_interface_packing
) blob_read_uint32(blob
);
195 bool row_major
= blob_read_uint32(blob
);
196 return glsl_type::get_interface_instance(fields
, num_fields
,
197 packing
, row_major
, name
);
199 return glsl_type::get_record_instance(fields
, num_fields
, name
);
203 case GLSL_TYPE_ERROR
:
205 assert(!"Cannot decode type!");
211 write_subroutines(struct blob
*metadata
, struct gl_shader_program
*prog
)
213 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
214 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
218 struct gl_program
*glprog
= sh
->Program
;
220 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineUniforms
);
221 blob_write_uint32(metadata
, glprog
->sh
.MaxSubroutineFunctionIndex
);
222 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineFunctions
);
223 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineFunctions
; j
++) {
224 int num_types
= glprog
->sh
.SubroutineFunctions
[j
].num_compat_types
;
226 blob_write_string(metadata
, glprog
->sh
.SubroutineFunctions
[j
].name
);
227 blob_write_uint32(metadata
, glprog
->sh
.SubroutineFunctions
[j
].index
);
228 blob_write_uint32(metadata
, num_types
);
230 for (int k
= 0; k
< num_types
; k
++) {
231 encode_type_to_blob(metadata
,
232 glprog
->sh
.SubroutineFunctions
[j
].types
[k
]);
239 read_subroutines(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
241 struct gl_subroutine_function
*subs
;
243 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
244 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
248 struct gl_program
*glprog
= sh
->Program
;
250 glprog
->sh
.NumSubroutineUniforms
= blob_read_uint32(metadata
);
251 glprog
->sh
.MaxSubroutineFunctionIndex
= blob_read_uint32(metadata
);
252 glprog
->sh
.NumSubroutineFunctions
= blob_read_uint32(metadata
);
254 subs
= rzalloc_array(prog
, struct gl_subroutine_function
,
255 glprog
->sh
.NumSubroutineFunctions
);
256 glprog
->sh
.SubroutineFunctions
= subs
;
258 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineFunctions
; j
++) {
259 subs
[j
].name
= ralloc_strdup(prog
, blob_read_string (metadata
));
260 subs
[j
].index
= (int) blob_read_uint32(metadata
);
261 subs
[j
].num_compat_types
= (int) blob_read_uint32(metadata
);
263 subs
[j
].types
= rzalloc_array(prog
, const struct glsl_type
*,
264 subs
[j
].num_compat_types
);
265 for (int k
= 0; k
< subs
[j
].num_compat_types
; k
++) {
266 subs
[j
].types
[k
] = decode_type_from_blob(metadata
);
273 write_buffer_block(struct blob
*metadata
, struct gl_uniform_block
*b
)
275 blob_write_string(metadata
, b
->Name
);
276 blob_write_uint32(metadata
, b
->NumUniforms
);
277 blob_write_uint32(metadata
, b
->Binding
);
278 blob_write_uint32(metadata
, b
->UniformBufferSize
);
279 blob_write_uint32(metadata
, b
->stageref
);
281 for (unsigned j
= 0; j
< b
->NumUniforms
; j
++) {
282 blob_write_string(metadata
, b
->Uniforms
[j
].Name
);
283 blob_write_string(metadata
, b
->Uniforms
[j
].IndexName
);
284 encode_type_to_blob(metadata
, b
->Uniforms
[j
].Type
);
285 blob_write_uint32(metadata
, b
->Uniforms
[j
].Offset
);
290 write_buffer_blocks(struct blob
*metadata
, struct gl_shader_program
*prog
)
292 blob_write_uint32(metadata
, prog
->data
->NumUniformBlocks
);
293 blob_write_uint32(metadata
, prog
->data
->NumShaderStorageBlocks
);
295 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
296 write_buffer_block(metadata
, &prog
->data
->UniformBlocks
[i
]);
299 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
300 write_buffer_block(metadata
, &prog
->data
->ShaderStorageBlocks
[i
]);
303 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
304 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
308 struct gl_program
*glprog
= sh
->Program
;
310 blob_write_uint32(metadata
, glprog
->info
.num_ubos
);
311 blob_write_uint32(metadata
, glprog
->info
.num_ssbos
);
313 for (unsigned j
= 0; j
< glprog
->info
.num_ubos
; j
++) {
315 glprog
->sh
.UniformBlocks
[j
] - prog
->data
->UniformBlocks
;
316 blob_write_uint32(metadata
, offset
);
319 for (unsigned j
= 0; j
< glprog
->info
.num_ssbos
; j
++) {
320 uint32_t offset
= glprog
->sh
.ShaderStorageBlocks
[j
] -
321 prog
->data
->ShaderStorageBlocks
;
322 blob_write_uint32(metadata
, offset
);
328 read_buffer_block(struct blob_reader
*metadata
, struct gl_uniform_block
*b
,
329 struct gl_shader_program
*prog
)
331 b
->Name
= ralloc_strdup(prog
->data
, blob_read_string (metadata
));
332 b
->NumUniforms
= blob_read_uint32(metadata
);
333 b
->Binding
= blob_read_uint32(metadata
);
334 b
->UniformBufferSize
= blob_read_uint32(metadata
);
335 b
->stageref
= blob_read_uint32(metadata
);
338 rzalloc_array(prog
->data
, struct gl_uniform_buffer_variable
,
340 for (unsigned j
= 0; j
< b
->NumUniforms
; j
++) {
341 b
->Uniforms
[j
].Name
= ralloc_strdup(prog
->data
,
342 blob_read_string (metadata
));
344 char *index_name
= blob_read_string(metadata
);
345 if (strcmp(b
->Uniforms
[j
].Name
, index_name
) == 0) {
346 b
->Uniforms
[j
].IndexName
= b
->Uniforms
[j
].Name
;
348 b
->Uniforms
[j
].IndexName
= ralloc_strdup(prog
->data
, index_name
);
351 b
->Uniforms
[j
].Type
= decode_type_from_blob(metadata
);
352 b
->Uniforms
[j
].Offset
= blob_read_uint32(metadata
);
357 read_buffer_blocks(struct blob_reader
*metadata
,
358 struct gl_shader_program
*prog
)
360 prog
->data
->NumUniformBlocks
= blob_read_uint32(metadata
);
361 prog
->data
->NumShaderStorageBlocks
= blob_read_uint32(metadata
);
363 prog
->data
->UniformBlocks
=
364 rzalloc_array(prog
->data
, struct gl_uniform_block
,
365 prog
->data
->NumUniformBlocks
);
367 prog
->data
->ShaderStorageBlocks
=
368 rzalloc_array(prog
->data
, struct gl_uniform_block
,
369 prog
->data
->NumShaderStorageBlocks
);
371 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
372 read_buffer_block(metadata
, &prog
->data
->UniformBlocks
[i
], prog
);
375 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
376 read_buffer_block(metadata
, &prog
->data
->ShaderStorageBlocks
[i
], prog
);
379 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
380 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
384 struct gl_program
*glprog
= sh
->Program
;
386 glprog
->info
.num_ubos
= blob_read_uint32(metadata
);
387 glprog
->info
.num_ssbos
= blob_read_uint32(metadata
);
389 glprog
->sh
.UniformBlocks
=
390 rzalloc_array(glprog
, gl_uniform_block
*, glprog
->info
.num_ubos
);
391 glprog
->sh
.ShaderStorageBlocks
=
392 rzalloc_array(glprog
, gl_uniform_block
*, glprog
->info
.num_ssbos
);
394 for (unsigned j
= 0; j
< glprog
->info
.num_ubos
; j
++) {
395 uint32_t offset
= blob_read_uint32(metadata
);
396 glprog
->sh
.UniformBlocks
[j
] = prog
->data
->UniformBlocks
+ offset
;
399 for (unsigned j
= 0; j
< glprog
->info
.num_ssbos
; j
++) {
400 uint32_t offset
= blob_read_uint32(metadata
);
401 glprog
->sh
.ShaderStorageBlocks
[j
] =
402 prog
->data
->ShaderStorageBlocks
+ offset
;
408 write_atomic_buffers(struct blob
*metadata
, struct gl_shader_program
*prog
)
410 blob_write_uint32(metadata
, prog
->data
->NumAtomicBuffers
);
412 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
413 if (prog
->_LinkedShaders
[i
]) {
414 struct gl_program
*glprog
= prog
->_LinkedShaders
[i
]->Program
;
415 blob_write_uint32(metadata
, glprog
->info
.num_abos
);
419 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
420 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].Binding
);
421 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].MinimumSize
);
422 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].NumUniforms
);
424 blob_write_bytes(metadata
, prog
->data
->AtomicBuffers
[i
].StageReferences
,
425 sizeof(prog
->data
->AtomicBuffers
[i
].StageReferences
));
427 for (unsigned j
= 0; j
< prog
->data
->AtomicBuffers
[i
].NumUniforms
; j
++) {
428 blob_write_uint32(metadata
, prog
->data
->AtomicBuffers
[i
].Uniforms
[j
]);
434 read_atomic_buffers(struct blob_reader
*metadata
,
435 struct gl_shader_program
*prog
)
437 prog
->data
->NumAtomicBuffers
= blob_read_uint32(metadata
);
438 prog
->data
->AtomicBuffers
=
439 rzalloc_array(prog
, gl_active_atomic_buffer
,
440 prog
->data
->NumAtomicBuffers
);
442 struct gl_active_atomic_buffer
**stage_buff_list
[MESA_SHADER_STAGES
];
443 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
444 if (prog
->_LinkedShaders
[i
]) {
445 struct gl_program
*glprog
= prog
->_LinkedShaders
[i
]->Program
;
447 glprog
->info
.num_abos
= blob_read_uint32(metadata
);
448 glprog
->sh
.AtomicBuffers
=
449 rzalloc_array(glprog
, gl_active_atomic_buffer
*,
450 glprog
->info
.num_abos
);
451 stage_buff_list
[i
] = glprog
->sh
.AtomicBuffers
;
455 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
456 prog
->data
->AtomicBuffers
[i
].Binding
= blob_read_uint32(metadata
);
457 prog
->data
->AtomicBuffers
[i
].MinimumSize
= blob_read_uint32(metadata
);
458 prog
->data
->AtomicBuffers
[i
].NumUniforms
= blob_read_uint32(metadata
);
460 blob_copy_bytes(metadata
,
461 (uint8_t *) &prog
->data
->AtomicBuffers
[i
].StageReferences
,
462 sizeof(prog
->data
->AtomicBuffers
[i
].StageReferences
));
464 prog
->data
->AtomicBuffers
[i
].Uniforms
= rzalloc_array(prog
, unsigned,
465 prog
->data
->AtomicBuffers
[i
].NumUniforms
);
467 for (unsigned j
= 0; j
< prog
->data
->AtomicBuffers
[i
].NumUniforms
; j
++) {
468 prog
->data
->AtomicBuffers
[i
].Uniforms
[j
] = blob_read_uint32(metadata
);
471 for (unsigned j
= 0; j
< MESA_SHADER_STAGES
; j
++) {
472 if (prog
->data
->AtomicBuffers
[i
].StageReferences
[j
]) {
473 *stage_buff_list
[j
] = &prog
->data
->AtomicBuffers
[i
];
474 stage_buff_list
[j
]++;
481 write_xfb(struct blob
*metadata
, struct gl_shader_program
*shProg
)
483 struct gl_program
*prog
= shProg
->last_vert_prog
;
486 blob_write_uint32(metadata
, ~0u);
490 struct gl_transform_feedback_info
*ltf
= prog
->sh
.LinkedTransformFeedback
;
492 blob_write_uint32(metadata
, prog
->info
.stage
);
494 blob_write_uint32(metadata
, ltf
->NumOutputs
);
495 blob_write_uint32(metadata
, ltf
->ActiveBuffers
);
496 blob_write_uint32(metadata
, ltf
->NumVarying
);
498 blob_write_bytes(metadata
, ltf
->Outputs
,
499 sizeof(struct gl_transform_feedback_output
) *
502 for (int i
= 0; i
< ltf
->NumVarying
; i
++) {
503 blob_write_string(metadata
, ltf
->Varyings
[i
].Name
);
504 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Type
);
505 blob_write_uint32(metadata
, ltf
->Varyings
[i
].BufferIndex
);
506 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Size
);
507 blob_write_uint32(metadata
, ltf
->Varyings
[i
].Offset
);
510 blob_write_bytes(metadata
, ltf
->Buffers
,
511 sizeof(struct gl_transform_feedback_buffer
) *
512 MAX_FEEDBACK_BUFFERS
);
516 read_xfb(struct blob_reader
*metadata
, struct gl_shader_program
*shProg
)
518 unsigned xfb_stage
= blob_read_uint32(metadata
);
520 if (xfb_stage
== ~0u)
523 struct gl_program
*prog
= shProg
->_LinkedShaders
[xfb_stage
]->Program
;
524 struct gl_transform_feedback_info
*ltf
=
525 rzalloc(prog
, struct gl_transform_feedback_info
);
527 prog
->sh
.LinkedTransformFeedback
= ltf
;
528 shProg
->last_vert_prog
= prog
;
530 ltf
->NumOutputs
= blob_read_uint32(metadata
);
531 ltf
->ActiveBuffers
= blob_read_uint32(metadata
);
532 ltf
->NumVarying
= blob_read_uint32(metadata
);
534 ltf
->Outputs
= rzalloc_array(prog
, struct gl_transform_feedback_output
,
537 blob_copy_bytes(metadata
, (uint8_t *) ltf
->Outputs
,
538 sizeof(struct gl_transform_feedback_output
) *
541 ltf
->Varyings
= rzalloc_array(prog
,
542 struct gl_transform_feedback_varying_info
,
545 for (int i
= 0; i
< ltf
->NumVarying
; i
++) {
546 ltf
->Varyings
[i
].Name
= ralloc_strdup(prog
, blob_read_string(metadata
));
547 ltf
->Varyings
[i
].Type
= blob_read_uint32(metadata
);
548 ltf
->Varyings
[i
].BufferIndex
= blob_read_uint32(metadata
);
549 ltf
->Varyings
[i
].Size
= blob_read_uint32(metadata
);
550 ltf
->Varyings
[i
].Offset
= blob_read_uint32(metadata
);
553 blob_copy_bytes(metadata
, (uint8_t *) ltf
->Buffers
,
554 sizeof(struct gl_transform_feedback_buffer
) *
555 MAX_FEEDBACK_BUFFERS
);
559 write_uniforms(struct blob
*metadata
, struct gl_shader_program
*prog
)
561 blob_write_uint32(metadata
, prog
->SamplersValidated
);
562 blob_write_uint32(metadata
, prog
->data
->NumUniformStorage
);
563 blob_write_uint32(metadata
, prog
->data
->NumUniformDataSlots
);
565 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
566 encode_type_to_blob(metadata
, prog
->data
->UniformStorage
[i
].type
);
567 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].array_elements
);
568 blob_write_string(metadata
, prog
->data
->UniformStorage
[i
].name
);
569 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].storage
-
570 prog
->data
->UniformDataSlots
);
571 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].remap_location
);
572 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].block_index
);
573 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].atomic_buffer_index
);
574 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].offset
);
575 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].array_stride
);
576 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].matrix_stride
);
577 blob_write_uint32(metadata
, prog
->data
->UniformStorage
[i
].row_major
);
578 blob_write_uint32(metadata
,
579 prog
->data
->UniformStorage
[i
].num_compatible_subroutines
);
580 blob_write_uint32(metadata
,
581 prog
->data
->UniformStorage
[i
].top_level_array_size
);
582 blob_write_uint32(metadata
,
583 prog
->data
->UniformStorage
[i
].top_level_array_stride
);
584 blob_write_bytes(metadata
, prog
->data
->UniformStorage
[i
].opaque
,
585 sizeof(prog
->data
->UniformStorage
[i
].opaque
));
590 read_uniforms(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
592 struct gl_uniform_storage
*uniforms
;
593 union gl_constant_value
*data
;
595 prog
->SamplersValidated
= blob_read_uint32(metadata
);
596 prog
->data
->NumUniformStorage
= blob_read_uint32(metadata
);
597 prog
->data
->NumUniformDataSlots
= blob_read_uint32(metadata
);
599 uniforms
= rzalloc_array(prog
, struct gl_uniform_storage
,
600 prog
->data
->NumUniformStorage
);
601 prog
->data
->UniformStorage
= uniforms
;
603 data
= rzalloc_array(uniforms
, union gl_constant_value
,
604 prog
->data
->NumUniformDataSlots
);
605 prog
->data
->UniformDataSlots
= data
;
607 prog
->UniformHash
= new string_to_uint_map
;
609 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
610 uniforms
[i
].type
= decode_type_from_blob(metadata
);
611 uniforms
[i
].array_elements
= blob_read_uint32(metadata
);
612 uniforms
[i
].name
= ralloc_strdup(prog
, blob_read_string (metadata
));
613 uniforms
[i
].storage
= data
+ blob_read_uint32(metadata
);
614 uniforms
[i
].remap_location
= blob_read_uint32(metadata
);
615 uniforms
[i
].block_index
= blob_read_uint32(metadata
);
616 uniforms
[i
].atomic_buffer_index
= blob_read_uint32(metadata
);
617 uniforms
[i
].offset
= blob_read_uint32(metadata
);
618 uniforms
[i
].array_stride
= blob_read_uint32(metadata
);
619 uniforms
[i
].matrix_stride
= blob_read_uint32(metadata
);
620 uniforms
[i
].row_major
= blob_read_uint32(metadata
);
621 uniforms
[i
].num_compatible_subroutines
= blob_read_uint32(metadata
);
622 uniforms
[i
].top_level_array_size
= blob_read_uint32(metadata
);
623 uniforms
[i
].top_level_array_stride
= blob_read_uint32(metadata
);
624 prog
->UniformHash
->put(i
, uniforms
[i
].name
);
626 memcpy(uniforms
[i
].opaque
,
627 blob_read_bytes(metadata
, sizeof(uniforms
[i
].opaque
)),
628 sizeof(uniforms
[i
].opaque
));
632 enum uniform_remap_type
634 remap_type_inactive_explicit_location
,
636 remap_type_uniform_offset
640 write_uniform_remap_table_entry(struct blob
*metadata
,
641 gl_uniform_storage
*uniform_storage
,
642 gl_uniform_storage
*entry
)
644 if (entry
== INACTIVE_UNIFORM_EXPLICIT_LOCATION
) {
645 blob_write_uint32(metadata
, remap_type_inactive_explicit_location
);
646 } else if (entry
== NULL
) {
647 blob_write_uint32(metadata
, remap_type_null_ptr
);
649 blob_write_uint32(metadata
, remap_type_uniform_offset
);
651 uint32_t offset
= entry
- uniform_storage
;
652 blob_write_uint32(metadata
, offset
);
657 write_uniform_remap_tables(struct blob
*metadata
,
658 struct gl_shader_program
*prog
)
660 blob_write_uint32(metadata
, prog
->NumUniformRemapTable
);
662 for (unsigned i
= 0; i
< prog
->NumUniformRemapTable
; i
++) {
663 write_uniform_remap_table_entry(metadata
, prog
->data
->UniformStorage
,
664 prog
->UniformRemapTable
[i
]);
667 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
668 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
670 struct gl_program
*glprog
= sh
->Program
;
671 blob_write_uint32(metadata
, glprog
->sh
.NumSubroutineUniformRemapTable
);
673 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineUniformRemapTable
; j
++) {
674 write_uniform_remap_table_entry(metadata
,
675 prog
->data
->UniformStorage
,
676 glprog
->sh
.SubroutineUniformRemapTable
[j
]);
683 read_uniform_remap_table_entry(struct blob_reader
*metadata
,
684 gl_uniform_storage
*uniform_storage
,
685 gl_uniform_storage
**entry
,
686 enum uniform_remap_type type
)
688 if (type
== remap_type_inactive_explicit_location
) {
689 *entry
= INACTIVE_UNIFORM_EXPLICIT_LOCATION
;
690 } else if (type
== remap_type_null_ptr
) {
693 uint32_t uni_offset
= blob_read_uint32(metadata
);
694 *entry
= uniform_storage
+ uni_offset
;
699 read_uniform_remap_tables(struct blob_reader
*metadata
,
700 struct gl_shader_program
*prog
)
702 prog
->NumUniformRemapTable
= blob_read_uint32(metadata
);
704 prog
->UniformRemapTable
= rzalloc_array(prog
, struct gl_uniform_storage
*,
705 prog
->NumUniformRemapTable
);
707 for (unsigned i
= 0; i
< prog
->NumUniformRemapTable
; i
++) {
708 enum uniform_remap_type type
=
709 (enum uniform_remap_type
) blob_read_uint32(metadata
);
711 read_uniform_remap_table_entry(metadata
, prog
->data
->UniformStorage
,
712 &prog
->UniformRemapTable
[i
], type
);
715 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
716 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
718 struct gl_program
*glprog
= sh
->Program
;
719 glprog
->sh
.NumSubroutineUniformRemapTable
= blob_read_uint32(metadata
);
721 glprog
->sh
.SubroutineUniformRemapTable
=
722 rzalloc_array(glprog
, struct gl_uniform_storage
*,
723 glprog
->sh
.NumSubroutineUniformRemapTable
);
725 for (unsigned j
= 0; j
< glprog
->sh
.NumSubroutineUniformRemapTable
; j
++) {
726 enum uniform_remap_type type
=
727 (enum uniform_remap_type
) blob_read_uint32(metadata
);
729 read_uniform_remap_table_entry(metadata
,
730 prog
->data
->UniformStorage
,
731 &glprog
->sh
.SubroutineUniformRemapTable
[j
],
745 write_hash_table_entry(const char *key
, unsigned value
, void *closure
)
747 struct whte_closure
*whte
= (struct whte_closure
*) closure
;
749 blob_write_string(whte
->blob
, key
);
750 blob_write_uint32(whte
->blob
, value
);
756 write_hash_table(struct blob
*metadata
, struct string_to_uint_map
*hash
)
759 struct whte_closure whte
;
761 whte
.blob
= metadata
;
762 whte
.num_entries
= 0;
764 offset
= metadata
->size
;
766 /* Write a placeholder for the hashtable size. */
767 blob_write_uint32 (metadata
, 0);
769 hash
->iterate(write_hash_table_entry
, &whte
);
771 /* Overwrite with the computed number of entries written. */
772 blob_overwrite_uint32 (metadata
, offset
, whte
.num_entries
);
776 read_hash_table(struct blob_reader
*metadata
, struct string_to_uint_map
*hash
)
778 size_t i
, num_entries
;
782 num_entries
= blob_read_uint32 (metadata
);
784 for (i
= 0; i
< num_entries
; i
++) {
785 key
= blob_read_string(metadata
);
786 value
= blob_read_uint32(metadata
);
788 hash
->put(value
, key
);
793 write_hash_tables(struct blob
*metadata
, struct gl_shader_program
*prog
)
795 write_hash_table(metadata
, prog
->AttributeBindings
);
796 write_hash_table(metadata
, prog
->FragDataBindings
);
797 write_hash_table(metadata
, prog
->FragDataIndexBindings
);
801 read_hash_tables(struct blob_reader
*metadata
, struct gl_shader_program
*prog
)
803 read_hash_table(metadata
, prog
->AttributeBindings
);
804 read_hash_table(metadata
, prog
->FragDataBindings
);
805 read_hash_table(metadata
, prog
->FragDataIndexBindings
);
809 write_shader_subroutine_index(struct blob
*metadata
,
810 struct gl_linked_shader
*sh
,
811 struct gl_program_resource
*res
)
815 for (unsigned j
= 0; j
< sh
->Program
->sh
.NumSubroutineFunctions
; j
++) {
816 if (strcmp(((gl_subroutine_function
*)res
->Data
)->name
,
817 sh
->Program
->sh
.SubroutineFunctions
[j
].name
) == 0) {
818 blob_write_uint32(metadata
, j
);
825 write_program_resource_data(struct blob
*metadata
,
826 struct gl_shader_program
*prog
,
827 struct gl_program_resource
*res
)
829 struct gl_linked_shader
*sh
;
832 case GL_PROGRAM_INPUT
:
833 case GL_PROGRAM_OUTPUT
: {
834 const gl_shader_variable
*var
= (gl_shader_variable
*)res
->Data
;
835 blob_write_bytes(metadata
, var
, sizeof(gl_shader_variable
));
836 encode_type_to_blob(metadata
, var
->type
);
838 if (var
->interface_type
)
839 encode_type_to_blob(metadata
, var
->interface_type
);
841 if (var
->outermost_struct_type
)
842 encode_type_to_blob(metadata
, var
->outermost_struct_type
);
844 blob_write_string(metadata
, var
->name
);
847 case GL_UNIFORM_BLOCK
:
848 for (unsigned i
= 0; i
< prog
->data
->NumUniformBlocks
; i
++) {
849 if (strcmp(((gl_uniform_block
*)res
->Data
)->Name
,
850 prog
->data
->UniformBlocks
[i
].Name
) == 0) {
851 blob_write_uint32(metadata
, i
);
856 case GL_SHADER_STORAGE_BLOCK
:
857 for (unsigned i
= 0; i
< prog
->data
->NumShaderStorageBlocks
; i
++) {
858 if (strcmp(((gl_uniform_block
*)res
->Data
)->Name
,
859 prog
->data
->ShaderStorageBlocks
[i
].Name
) == 0) {
860 blob_write_uint32(metadata
, i
);
865 case GL_BUFFER_VARIABLE
:
866 case GL_VERTEX_SUBROUTINE_UNIFORM
:
867 case GL_GEOMETRY_SUBROUTINE_UNIFORM
:
868 case GL_FRAGMENT_SUBROUTINE_UNIFORM
:
869 case GL_COMPUTE_SUBROUTINE_UNIFORM
:
870 case GL_TESS_CONTROL_SUBROUTINE_UNIFORM
:
871 case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM
:
873 for (unsigned i
= 0; i
< prog
->data
->NumUniformStorage
; i
++) {
874 if (strcmp(((gl_uniform_storage
*)res
->Data
)->name
,
875 prog
->data
->UniformStorage
[i
].name
) == 0) {
876 blob_write_uint32(metadata
, i
);
881 case GL_ATOMIC_COUNTER_BUFFER
:
882 for (unsigned i
= 0; i
< prog
->data
->NumAtomicBuffers
; i
++) {
883 if (((gl_active_atomic_buffer
*)res
->Data
)->Binding
==
884 prog
->data
->AtomicBuffers
[i
].Binding
) {
885 blob_write_uint32(metadata
, i
);
890 case GL_TRANSFORM_FEEDBACK_BUFFER
:
891 for (unsigned i
= 0; i
< MAX_FEEDBACK_BUFFERS
; i
++) {
892 if (((gl_transform_feedback_buffer
*)res
->Data
)->Binding
==
893 prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->Buffers
[i
].Binding
) {
894 blob_write_uint32(metadata
, i
);
899 case GL_TRANSFORM_FEEDBACK_VARYING
:
900 for (int i
= 0; i
< prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->NumVarying
; i
++) {
901 if (strcmp(((gl_transform_feedback_varying_info
*)res
->Data
)->Name
,
902 prog
->last_vert_prog
->sh
.LinkedTransformFeedback
->Varyings
[i
].Name
) == 0) {
903 blob_write_uint32(metadata
, i
);
908 case GL_VERTEX_SUBROUTINE
:
909 case GL_TESS_CONTROL_SUBROUTINE
:
910 case GL_TESS_EVALUATION_SUBROUTINE
:
911 case GL_GEOMETRY_SUBROUTINE
:
912 case GL_FRAGMENT_SUBROUTINE
:
913 case GL_COMPUTE_SUBROUTINE
:
915 prog
->_LinkedShaders
[_mesa_shader_stage_from_subroutine(res
->Type
)];
916 write_shader_subroutine_index(metadata
, sh
, res
);
919 assert(!"Support for writing resource not yet implemented.");
924 read_program_resource_data(struct blob_reader
*metadata
,
925 struct gl_shader_program
*prog
,
926 struct gl_program_resource
*res
)
928 struct gl_linked_shader
*sh
;
931 case GL_PROGRAM_INPUT
:
932 case GL_PROGRAM_OUTPUT
: {
933 gl_shader_variable
*var
= ralloc(prog
, struct gl_shader_variable
);
935 blob_copy_bytes(metadata
, (uint8_t *) var
, sizeof(gl_shader_variable
));
936 var
->type
= decode_type_from_blob(metadata
);
938 if (var
->interface_type
)
939 var
->interface_type
= decode_type_from_blob(metadata
);
941 if (var
->outermost_struct_type
)
942 var
->outermost_struct_type
= decode_type_from_blob(metadata
);
944 var
->name
= ralloc_strdup(prog
, blob_read_string(metadata
));
949 case GL_UNIFORM_BLOCK
:
950 res
->Data
= &prog
->data
->UniformBlocks
[blob_read_uint32(metadata
)];
952 case GL_SHADER_STORAGE_BLOCK
:
953 res
->Data
= &prog
->data
->ShaderStorageBlocks
[blob_read_uint32(metadata
)];
955 case GL_BUFFER_VARIABLE
:
956 case GL_VERTEX_SUBROUTINE_UNIFORM
:
957 case GL_GEOMETRY_SUBROUTINE_UNIFORM
:
958 case GL_FRAGMENT_SUBROUTINE_UNIFORM
:
959 case GL_COMPUTE_SUBROUTINE_UNIFORM
:
960 case GL_TESS_CONTROL_SUBROUTINE_UNIFORM
:
961 case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM
:
963 res
->Data
= &prog
->data
->UniformStorage
[blob_read_uint32(metadata
)];
965 case GL_ATOMIC_COUNTER_BUFFER
:
966 res
->Data
= &prog
->data
->AtomicBuffers
[blob_read_uint32(metadata
)];
968 case GL_TRANSFORM_FEEDBACK_BUFFER
:
969 res
->Data
= &prog
->last_vert_prog
->
970 sh
.LinkedTransformFeedback
->Buffers
[blob_read_uint32(metadata
)];
972 case GL_TRANSFORM_FEEDBACK_VARYING
:
973 res
->Data
= &prog
->last_vert_prog
->
974 sh
.LinkedTransformFeedback
->Varyings
[blob_read_uint32(metadata
)];
976 case GL_VERTEX_SUBROUTINE
:
977 case GL_TESS_CONTROL_SUBROUTINE
:
978 case GL_TESS_EVALUATION_SUBROUTINE
:
979 case GL_GEOMETRY_SUBROUTINE
:
980 case GL_FRAGMENT_SUBROUTINE
:
981 case GL_COMPUTE_SUBROUTINE
:
983 prog
->_LinkedShaders
[_mesa_shader_stage_from_subroutine(res
->Type
)];
985 &sh
->Program
->sh
.SubroutineFunctions
[blob_read_uint32(metadata
)];
988 assert(!"Support for reading resource not yet implemented.");
993 write_program_resource_list(struct blob
*metadata
,
994 struct gl_shader_program
*prog
)
996 blob_write_uint32(metadata
, prog
->data
->NumProgramResourceList
);
998 for (unsigned i
= 0; i
< prog
->data
->NumProgramResourceList
; i
++) {
999 blob_write_uint32(metadata
, prog
->data
->ProgramResourceList
[i
].Type
);
1000 write_program_resource_data(metadata
, prog
,
1001 &prog
->data
->ProgramResourceList
[i
]);
1002 blob_write_bytes(metadata
,
1003 &prog
->data
->ProgramResourceList
[i
].StageReferences
,
1004 sizeof(prog
->data
->ProgramResourceList
[i
].StageReferences
));
1009 read_program_resource_list(struct blob_reader
*metadata
,
1010 struct gl_shader_program
*prog
)
1012 prog
->data
->NumProgramResourceList
= blob_read_uint32(metadata
);
1014 prog
->data
->ProgramResourceList
=
1015 ralloc_array(prog
, gl_program_resource
,
1016 prog
->data
->NumProgramResourceList
);
1018 for (unsigned i
= 0; i
< prog
->data
->NumProgramResourceList
; i
++) {
1019 prog
->data
->ProgramResourceList
[i
].Type
= blob_read_uint32(metadata
);
1020 read_program_resource_data(metadata
, prog
,
1021 &prog
->data
->ProgramResourceList
[i
]);
1022 blob_copy_bytes(metadata
,
1023 (uint8_t *) &prog
->data
->ProgramResourceList
[i
].StageReferences
,
1024 sizeof(prog
->data
->ProgramResourceList
[i
].StageReferences
));
1029 write_shader_parameters(struct blob
*metadata
,
1030 struct gl_program_parameter_list
*params
)
1032 blob_write_uint32(metadata
, params
->NumParameters
);
1035 while (i
< params
->NumParameters
) {
1036 struct gl_program_parameter
*param
= ¶ms
->Parameters
[i
];
1038 blob_write_uint32(metadata
, param
->Type
);
1039 blob_write_string(metadata
, param
->Name
);
1040 blob_write_uint32(metadata
, param
->Size
);
1041 blob_write_uint32(metadata
, param
->DataType
);
1042 blob_write_bytes(metadata
, param
->StateIndexes
,
1043 sizeof(param
->StateIndexes
));
1045 i
+= (param
->Size
+ 3) / 4;
1048 blob_write_bytes(metadata
, params
->ParameterValues
,
1049 sizeof(gl_constant_value
) * 4 * params
->NumParameters
);
1051 blob_write_uint32(metadata
, params
->StateFlags
);
1055 read_shader_parameters(struct blob_reader
*metadata
,
1056 struct gl_program_parameter_list
*params
)
1058 gl_state_index state_indexes
[STATE_LENGTH
];
1060 uint32_t num_parameters
= blob_read_uint32(metadata
);
1062 while (i
< num_parameters
) {
1063 gl_register_file type
= (gl_register_file
) blob_read_uint32(metadata
);
1064 const char *name
= blob_read_string(metadata
);
1065 unsigned size
= blob_read_uint32(metadata
);
1066 unsigned data_type
= blob_read_uint32(metadata
);
1067 blob_copy_bytes(metadata
, (uint8_t *) state_indexes
,
1068 sizeof(state_indexes
));
1070 _mesa_add_parameter(params
, type
, name
, size
, data_type
,
1071 NULL
, state_indexes
);
1073 i
+= (size
+ 3) / 4;
1076 blob_copy_bytes(metadata
, (uint8_t *) params
->ParameterValues
,
1077 sizeof(gl_constant_value
) * 4 * params
->NumParameters
);
1079 params
->StateFlags
= blob_read_uint32(metadata
);
1083 write_shader_metadata(struct blob
*metadata
, gl_linked_shader
*shader
)
1085 assert(shader
->Program
);
1086 struct gl_program
*glprog
= shader
->Program
;
1088 blob_write_bytes(metadata
, glprog
->TexturesUsed
,
1089 sizeof(glprog
->TexturesUsed
));
1090 blob_write_uint64(metadata
, glprog
->SamplersUsed
);
1092 blob_write_bytes(metadata
, glprog
->SamplerUnits
,
1093 sizeof(glprog
->SamplerUnits
));
1094 blob_write_bytes(metadata
, glprog
->sh
.SamplerTargets
,
1095 sizeof(glprog
->sh
.SamplerTargets
));
1096 blob_write_uint32(metadata
, glprog
->ShadowSamplers
);
1098 write_shader_parameters(metadata
, glprog
->Parameters
);
1102 read_shader_metadata(struct blob_reader
*metadata
,
1103 struct gl_program
*glprog
,
1104 gl_linked_shader
*linked
)
1106 blob_copy_bytes(metadata
, (uint8_t *) glprog
->TexturesUsed
,
1107 sizeof(glprog
->TexturesUsed
));
1108 glprog
->SamplersUsed
= blob_read_uint64(metadata
);
1110 blob_copy_bytes(metadata
, (uint8_t *) glprog
->SamplerUnits
,
1111 sizeof(glprog
->SamplerUnits
));
1112 blob_copy_bytes(metadata
, (uint8_t *) glprog
->sh
.SamplerTargets
,
1113 sizeof(glprog
->sh
.SamplerTargets
));
1114 glprog
->ShadowSamplers
= blob_read_uint32(metadata
);
1116 glprog
->Parameters
= _mesa_new_parameter_list();
1117 read_shader_parameters(metadata
, glprog
->Parameters
);
1121 create_binding_str(const char *key
, unsigned value
, void *closure
)
1123 char **bindings_str
= (char **) closure
;
1124 ralloc_asprintf_append(bindings_str
, "%s:%u,", key
, value
);
1128 create_linked_shader_and_program(struct gl_context
*ctx
,
1129 gl_shader_stage stage
,
1130 struct gl_shader_program
*prog
,
1131 struct blob_reader
*metadata
)
1133 struct gl_program
*glprog
;
1135 struct gl_linked_shader
*linked
= rzalloc(NULL
, struct gl_linked_shader
);
1136 linked
->Stage
= stage
;
1138 glprog
= ctx
->Driver
.NewProgram(ctx
, _mesa_shader_stage_to_program(stage
),
1140 glprog
->info
.stage
= stage
;
1141 linked
->Program
= glprog
;
1143 read_shader_metadata(metadata
, glprog
, linked
);
1145 /* Restore shader info */
1146 blob_copy_bytes(metadata
, (uint8_t *) &glprog
->info
, sizeof(shader_info
));
1147 if (glprog
->info
.name
)
1148 glprog
->info
.name
= ralloc_strdup(glprog
, blob_read_string(metadata
));
1149 if (glprog
->info
.label
)
1150 glprog
->info
.label
= ralloc_strdup(glprog
, blob_read_string(metadata
));
1152 _mesa_reference_shader_program_data(ctx
, &glprog
->sh
.data
, prog
->data
);
1153 _mesa_reference_program(ctx
, &linked
->Program
, glprog
);
1154 prog
->_LinkedShaders
[stage
] = linked
;
1158 shader_cache_write_program_metadata(struct gl_context
*ctx
,
1159 struct gl_shader_program
*prog
)
1161 struct disk_cache
*cache
= ctx
->Cache
;
1165 /* Exit early when we are dealing with a ff shader with no source file to
1166 * generate a source from.
1168 * TODO: In future we should use another method to generate a key for ff
1171 if (*prog
->data
->sha1
== 0)
1174 struct blob
*metadata
= blob_create(NULL
);
1176 write_uniforms(metadata
, prog
);
1178 write_hash_tables(metadata
, prog
);
1180 blob_write_uint32(metadata
, prog
->data
->Version
);
1181 blob_write_uint32(metadata
, prog
->data
->linked_stages
);
1183 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1184 struct gl_linked_shader
*sh
= prog
->_LinkedShaders
[i
];
1186 write_shader_metadata(metadata
, sh
);
1188 /* Store nir shader info */
1189 blob_write_bytes(metadata
, &sh
->Program
->info
, sizeof(shader_info
));
1191 if (sh
->Program
->info
.name
)
1192 blob_write_string(metadata
, sh
->Program
->info
.name
);
1194 if (sh
->Program
->info
.label
)
1195 blob_write_string(metadata
, sh
->Program
->info
.label
);
1199 write_xfb(metadata
, prog
);
1201 write_uniform_remap_tables(metadata
, prog
);
1203 write_atomic_buffers(metadata
, prog
);
1205 write_buffer_blocks(metadata
, prog
);
1207 write_subroutines(metadata
, prog
);
1209 write_program_resource_list(metadata
, prog
);
1212 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
1213 disk_cache_put_key(cache
, prog
->Shaders
[i
]->sha1
);
1214 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1215 fprintf(stderr
, "marking shader: %s\n",
1216 _mesa_sha1_format(sha1_buf
, prog
->Shaders
[i
]->sha1
));
1220 disk_cache_put(cache
, prog
->data
->sha1
, metadata
->data
, metadata
->size
);
1222 ralloc_free(metadata
);
1224 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1225 fprintf(stderr
, "putting program metadata in cache: %s\n",
1226 _mesa_sha1_format(sha1_buf
, prog
->data
->sha1
));
1231 shader_cache_read_program_metadata(struct gl_context
*ctx
,
1232 struct gl_shader_program
*prog
)
1234 /* Fixed function programs generated by Mesa are not cached. So don't
1235 * try to read metadata for them from the cache.
1237 if (prog
->Name
== 0)
1240 struct disk_cache
*cache
= ctx
->Cache
;
1244 /* Include bindings when creating sha1. These bindings change the resulting
1245 * binary so they are just as important as the shader source.
1247 char *buf
= ralloc_strdup(NULL
, "vb: ");
1248 prog
->AttributeBindings
->iterate(create_binding_str
, &buf
);
1249 ralloc_strcat(&buf
, "fb: ");
1250 prog
->FragDataBindings
->iterate(create_binding_str
, &buf
);
1251 ralloc_strcat(&buf
, "fbi: ");
1252 prog
->FragDataIndexBindings
->iterate(create_binding_str
, &buf
);
1254 /* SSO has an effect on the linked program so include this when generating
1257 ralloc_asprintf_append(&buf
, "sso: %s\n",
1258 prog
->SeparateShader
? "T" : "F");
1261 for (unsigned i
= 0; i
< prog
->NumShaders
; i
++) {
1262 struct gl_shader
*sh
= prog
->Shaders
[i
];
1263 ralloc_asprintf_append(&buf
, "%s: %s\n",
1264 _mesa_shader_stage_to_abbrev(sh
->Stage
),
1265 _mesa_sha1_format(sha1buf
, sh
->sha1
));
1267 _mesa_sha1_compute(buf
, strlen(buf
), prog
->data
->sha1
);
1271 uint8_t *buffer
= (uint8_t *) disk_cache_get(cache
, prog
->data
->sha1
,
1273 if (buffer
== NULL
) {
1274 /* Cached program not found. We may have seen the individual shaders
1275 * before and skipped compiling but they may not have been used together
1276 * in this combination before. Fall back to linking shaders but first
1277 * re-compile the shaders.
1279 * We could probably only compile the shaders which were skipped here
1280 * but we need to be careful because the source may also have been
1281 * changed since the last compile so for now we just recompile
1284 compile_shaders(ctx
, prog
);
1288 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1289 fprintf(stderr
, "loading shader program meta data from cache: %s\n",
1290 _mesa_sha1_format(sha1buf
, prog
->data
->sha1
));
1293 struct blob_reader metadata
;
1294 blob_reader_init(&metadata
, buffer
, size
);
1296 assert(prog
->data
->UniformStorage
== NULL
);
1298 read_uniforms(&metadata
, prog
);
1300 read_hash_tables(&metadata
, prog
);
1302 prog
->data
->Version
= blob_read_uint32(&metadata
);
1303 prog
->data
->linked_stages
= blob_read_uint32(&metadata
);
1305 unsigned mask
= prog
->data
->linked_stages
;
1307 const int j
= u_bit_scan(&mask
);
1308 create_linked_shader_and_program(ctx
, (gl_shader_stage
) j
, prog
,
1312 read_xfb(&metadata
, prog
);
1314 read_uniform_remap_tables(&metadata
, prog
);
1316 read_atomic_buffers(&metadata
, prog
);
1318 read_buffer_blocks(&metadata
, prog
);
1320 read_subroutines(&metadata
, prog
);
1322 read_program_resource_list(&metadata
, prog
);
1324 if (metadata
.current
!= metadata
.end
|| metadata
.overrun
) {
1325 /* Something has gone wrong discard the item from the cache and rebuild
1328 assert(!"Invalid GLSL shader disk cache item!");
1330 if (ctx
->_Shader
->Flags
& GLSL_CACHE_INFO
) {
1331 fprintf(stderr
, "Error reading program from cache (invalid GLSL "
1335 disk_cache_remove(cache
, prog
->data
->sha1
);
1336 compile_shaders(ctx
, prog
);
1341 /* This is used to flag a shader retrieved from cache */
1342 prog
->data
->LinkStatus
= linking_skipped
;