1 /* 2 * Copyright 2014 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * 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: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND 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. 22 */ 23 24 /** 25 * \file shader_cache.cpp 26 * 27 * GLSL shader cache implementation 28 * 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. 33 * 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. 37 * 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. 45 */ 46 47 #include "compiler/shader_info.h" 48 #include "glsl_symbol_table.h" 49 #include "glsl_parser_extras.h" 50 #include "ir.h" 51 #include "ir_optimization.h" 52 #include "ir_rvalue_visitor.h" 53 #include "ir_uniform.h" 54 #include "linker.h" 55 #include "link_varyings.h" 56 #include "main/core.h" 57 #include "nir.h" 58 #include "program.h" 59 #include "serialize.h" 60 #include "shader_cache.h" 61 #include "util/mesa-sha1.h" 62 #include "string_to_uint_map.h" 63 64 extern "C" { 65 #include "main/enums.h" 66 #include "main/shaderobj.h" 67 #include "program/program.h" 68 } 69 70 static void 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); 74 } 75 } 76 77 static void 78 create_binding_str(const char *key, unsigned value, void *closure) 79 { 80 char **bindings_str = (char **) closure; 81 ralloc_asprintf_append(bindings_str, "%s:%u,", key, value); 82 } 83 84 void 85 shader_cache_write_program_metadata(struct gl_context *ctx, 86 struct gl_shader_program *prog) 87 { 88 struct disk_cache *cache = ctx->Cache; 89 if (!cache) 90 return; 91 92 /* Exit early when we are dealing with a ff shader with no source file to 93 * generate a source from. 94 * 95 * TODO: In future we should use another method to generate a key for ff 96 * programs. 97 */ 98 static const char zero[sizeof(prog->data->sha1)] = {0}; 99 if (memcmp(prog->data->sha1, zero, sizeof(prog->data->sha1)) == 0) 100 return; 101 102 struct blob metadata; 103 blob_init(&metadata); 104 105 serialize_glsl_program(&metadata, ctx, prog); 106 107 struct cache_item_metadata cache_item_metadata; 108 cache_item_metadata.type = CACHE_ITEM_TYPE_GLSL; 109 cache_item_metadata.keys = 110 (cache_key *) malloc(prog->NumShaders * sizeof(cache_key)); 111 cache_item_metadata.num_keys = prog->NumShaders; 112 113 if (!cache_item_metadata.keys) 114 goto fail; 115 116 char sha1_buf[41]; 117 for (unsigned i = 0; i < prog->NumShaders; i++) { 118 disk_cache_put_key(cache, prog->Shaders[i]->sha1); 119 memcpy(cache_item_metadata.keys[i], prog->Shaders[i]->sha1, 120 sizeof(cache_key)); 121 if (ctx->_Shader->Flags & GLSL_CACHE_INFO) { 122 _mesa_sha1_format(sha1_buf, prog->Shaders[i]->sha1); 123 fprintf(stderr, "marking shader: %s\n", sha1_buf); 124 } 125 } 126 127 disk_cache_put(cache, prog->data->sha1, metadata.data, metadata.size, 128 &cache_item_metadata); 129 130 if (ctx->_Shader->Flags & GLSL_CACHE_INFO) { 131 _mesa_sha1_format(sha1_buf, prog->data->sha1); 132 fprintf(stderr, "putting program metadata in cache: %s\n", sha1_buf); 133 } 134 135 fail: 136 free(cache_item_metadata.keys); 137 blob_finish(&metadata); 138 } 139 140 bool 141 shader_cache_read_program_metadata(struct gl_context *ctx, 142 struct gl_shader_program *prog) 143 { 144 /* Fixed function programs generated by Mesa are not cached. So don't 145 * try to read metadata for them from the cache. 146 */ 147 if (prog->Name == 0) 148 return false; 149 150 struct disk_cache *cache = ctx->Cache; 151 if (!cache) 152 return false; 153 154 /* Include bindings when creating sha1. These bindings change the resulting 155 * binary so they are just as important as the shader source. 156 */ 157 char *buf = ralloc_strdup(NULL, "vb: "); 158 prog->AttributeBindings->iterate(create_binding_str, &buf); 159 ralloc_strcat(&buf, "fb: "); 160 prog->FragDataBindings->iterate(create_binding_str, &buf); 161 ralloc_strcat(&buf, "fbi: "); 162 prog->FragDataIndexBindings->iterate(create_binding_str, &buf); 163 164 /* SSO has an effect on the linked program so include this when generating 165 * the sha also. 166 */ 167 ralloc_asprintf_append(&buf, "sso: %s\n", 168 prog->SeparateShader ? "T" : "F"); 169 170 /* A shader might end up producing different output depending on the glsl 171 * version supported by the compiler. For example a different path might be 172 * taken by the preprocessor, so add the version to the hash input. 173 */ 174 ralloc_asprintf_append(&buf, "api: %d glsl: %d fglsl: %d\n", 175 ctx->API, ctx->Const.GLSLVersion, 176 ctx->Const.ForceGLSLVersion); 177 178 /* We run the preprocessor on shaders after hashing them, so we need to 179 * add any extension override vars to the hash. If we don't do this the 180 * preprocessor could result in different output and we could load the 181 * wrong shader. 182 */ 183 char *ext_override = getenv("MESA_EXTENSION_OVERRIDE"); 184 if (ext_override) { 185 ralloc_asprintf_append(&buf, "ext:%s", ext_override); 186 } 187 188 /* DRI config options may also change the output from the compiler so 189 * include them as an input to sha1 creation. 190 */ 191 char sha1buf[41]; 192 _mesa_sha1_format(sha1buf, ctx->Const.dri_config_options_sha1); 193 ralloc_strcat(&buf, sha1buf); 194 195 for (unsigned i = 0; i < prog->NumShaders; i++) { 196 struct gl_shader *sh = prog->Shaders[i]; 197 _mesa_sha1_format(sha1buf, sh->sha1); 198 ralloc_asprintf_append(&buf, "%s: %s\n", 199 _mesa_shader_stage_to_abbrev(sh->Stage), sha1buf); 200 } 201 disk_cache_compute_key(cache, buf, strlen(buf), prog->data->sha1); 202 ralloc_free(buf); 203 204 size_t size; 205 uint8_t *buffer = (uint8_t *) disk_cache_get(cache, prog->data->sha1, 206 &size); 207 if (buffer == NULL) { 208 /* Cached program not found. We may have seen the individual shaders 209 * before and skipped compiling but they may not have been used together 210 * in this combination before. Fall back to linking shaders but first 211 * re-compile the shaders. 212 * 213 * We could probably only compile the shaders which were skipped here 214 * but we need to be careful because the source may also have been 215 * changed since the last compile so for now we just recompile 216 * everything. 217 */ 218 compile_shaders(ctx, prog); 219 return false; 220 } 221 222 if (ctx->_Shader->Flags & GLSL_CACHE_INFO) { 223 _mesa_sha1_format(sha1buf, prog->data->sha1); 224 fprintf(stderr, "loading shader program meta data from cache: %s\n", 225 sha1buf); 226 } 227 228 struct blob_reader metadata; 229 blob_reader_init(&metadata, buffer, size); 230 231 bool deserialized = deserialize_glsl_program(&metadata, ctx, prog); 232 233 if (!deserialized || metadata.current != metadata.end || metadata.overrun) { 234 /* Something has gone wrong discard the item from the cache and rebuild 235 * from source. 236 */ 237 assert(!"Invalid GLSL shader disk cache item!"); 238 239 if (ctx->_Shader->Flags & GLSL_CACHE_INFO) { 240 fprintf(stderr, "Error reading program from cache (invalid GLSL " 241 "cache item)\n"); 242 } 243 244 disk_cache_remove(cache, prog->data->sha1); 245 compile_shaders(ctx, prog); 246 free(buffer); 247 return false; 248 } 249 250 /* This is used to flag a shader retrieved from cache */ 251 prog->data->LinkStatus = linking_skipped; 252 253 /* Since the program load was successful, CompileStatus of all shaders at 254 * this point should normally be compile_skipped. However because of how 255 * the eviction works, it may happen that some of the individual shader keys 256 * have been evicted, resulting in unnecessary recompiles on this load, so 257 * mark them again to skip such recompiles next time. 258 */ 259 char sha1_buf[41]; 260 for (unsigned i = 0; i < prog->NumShaders; i++) { 261 if (prog->Shaders[i]->CompileStatus == compiled_no_opts) { 262 disk_cache_put_key(cache, prog->Shaders[i]->sha1); 263 if (ctx->_Shader->Flags & GLSL_CACHE_INFO) { 264 _mesa_sha1_format(sha1_buf, prog->Shaders[i]->sha1); 265 fprintf(stderr, "re-marking shader: %s\n", sha1_buf); 266 } 267 } 268 } 269 270 free (buffer); 271 272 return true; 273 } 274
