void st_get_program_binary_driver_sha1(struct gl_context *ctx, uint8_t *sha1) { disk_cache_compute_key(ctx->Cache, NULL, 0, sha1); }
bool shader_cache_read_program_metadata(struct gl_context *ctx, struct gl_shader_program *prog) { /* Fixed function programs generated by Mesa are not cached. So don't * try to read metadata for them from the cache. */ if (prog->Name == 0) return false; struct disk_cache *cache = ctx->Cache; if (!cache) return false; /* Include bindings when creating sha1. These bindings change the resulting * binary so they are just as important as the shader source. */ char *buf = ralloc_strdup(NULL, "vb: "); prog->AttributeBindings->iterate(create_binding_str, &buf); ralloc_strcat(&buf, "fb: "); prog->FragDataBindings->iterate(create_binding_str, &buf); ralloc_strcat(&buf, "fbi: "); prog->FragDataIndexBindings->iterate(create_binding_str, &buf); /* SSO has an effect on the linked program so include this when generating * the sha also. */ ralloc_asprintf_append(&buf, "sso: %s\n", prog->SeparateShader ? "T" : "F"); /* A shader might end up producing different output depending on the glsl * version supported by the compiler. For example a different path might be * taken by the preprocessor, so add the version to the hash input. */ ralloc_asprintf_append(&buf, "api: %d glsl: %d fglsl: %d\n", ctx->API, ctx->Const.GLSLVersion, ctx->Const.ForceGLSLVersion); /* We run the preprocessor on shaders after hashing them, so we need to * add any extension override vars to the hash. If we don't do this the * preprocessor could result in different output and we could load the * wrong shader. */ char *ext_override = getenv("MESA_EXTENSION_OVERRIDE"); if (ext_override) { ralloc_asprintf_append(&buf, "ext:%s", ext_override); } /* DRI config options may also change the output from the compiler so * include them as an input to sha1 creation. */ char sha1buf[41]; _mesa_sha1_format(sha1buf, ctx->Const.dri_config_options_sha1); ralloc_strcat(&buf, sha1buf); for (unsigned i = 0; i < prog->NumShaders; i++) { struct gl_shader *sh = prog->Shaders[i]; _mesa_sha1_format(sha1buf, sh->sha1); ralloc_asprintf_append(&buf, "%s: %s\n", _mesa_shader_stage_to_abbrev(sh->Stage), sha1buf); } disk_cache_compute_key(cache, buf, strlen(buf), prog->data->sha1); ralloc_free(buf); size_t size; uint8_t *buffer = (uint8_t *) disk_cache_get(cache, prog->data->sha1, &size); if (buffer == NULL) { /* Cached program not found. We may have seen the individual shaders * before and skipped compiling but they may not have been used together * in this combination before. Fall back to linking shaders but first * re-compile the shaders. * * We could probably only compile the shaders which were skipped here * but we need to be careful because the source may also have been * changed since the last compile so for now we just recompile * everything. */ compile_shaders(ctx, prog); return false; } if (ctx->_Shader->Flags & GLSL_CACHE_INFO) { _mesa_sha1_format(sha1buf, prog->data->sha1); fprintf(stderr, "loading shader program meta data from cache: %s\n", sha1buf); } struct blob_reader metadata; blob_reader_init(&metadata, buffer, size); bool deserialized = deserialize_glsl_program(&metadata, ctx, prog); if (!deserialized || metadata.current != metadata.end || metadata.overrun) { /* Something has gone wrong discard the item from the cache and rebuild * from source. */ assert(!"Invalid GLSL shader disk cache item!"); if (ctx->_Shader->Flags & GLSL_CACHE_INFO) { fprintf(stderr, "Error reading program from cache (invalid GLSL " "cache item)\n"); } disk_cache_remove(cache, prog->data->sha1); compile_shaders(ctx, prog); free(buffer); return false; } /* This is used to flag a shader retrieved from cache */ prog->data->LinkStatus = linking_skipped; /* Since the program load was successful, CompileStatus of all shaders at * this point should normally be compile_skipped. However because of how * the eviction works, it may happen that some of the individual shader keys * have been evicted, resulting in unnecessary recompiles on this load, so * mark them again to skip such recompiles next time. */ char sha1_buf[41]; for (unsigned i = 0; i < prog->NumShaders; i++) { if (prog->Shaders[i]->CompileStatus == compiled_no_opts) { disk_cache_put_key(cache, prog->Shaders[i]->sha1); if (ctx->_Shader->Flags & GLSL_CACHE_INFO) { _mesa_sha1_format(sha1_buf, prog->Shaders[i]->sha1); fprintf(stderr, "re-marking shader: %s\n", sha1_buf); } } } free (buffer); return true; }