1 /* 2 * Copyright (C) 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #pragma once 18 19 #include <cutils/compiler.h> 20 #include <memory> 21 #include <mutex> 22 #include <string> 23 #include <vector> 24 #include <GrContextOptions.h> 25 26 namespace android { 27 28 class BlobCache; 29 class FileBlobCache; 30 31 namespace uirenderer { 32 namespace skiapipeline { 33 34 class ShaderCache : public GrContextOptions::PersistentCache { 35 public: 36 /** 37 * "get" returns a pointer to the singleton ShaderCache object. This 38 * singleton object will never be destroyed. 39 */ 40 ANDROID_API static ShaderCache& get(); 41 42 /** 43 * "initShaderDiskCache" loads the serialized cache contents from disk and puts the ShaderCache 44 * into an initialized state, such that it is able to insert and retrieve entries from the 45 * cache. This should be called when HWUI pipeline is initialized. When not in the initialized 46 * state the load and store methods will return without performing any cache operations. 47 */ 48 virtual void initShaderDiskCache(); 49 50 /** 51 * "setFilename" sets the name of the file that should be used to store 52 * cache contents from one program invocation to another. This function does not perform any 53 * disk operation and it should be invoked before "initShaderCache". 54 */ 55 virtual void setFilename(const char* filename); 56 57 /** 58 * "load" attempts to retrieve the value blob associated with a given key 59 * blob from cache. This will be called by Skia, when it needs to compile a new SKSL shader. 60 */ 61 sk_sp<SkData> load(const SkData& key) override; 62 63 /** 64 * "store" attempts to insert a new key/value blob pair into the cache. 65 * This will be called by Skia after it compiled a new SKSL shader 66 */ 67 void store(const SkData& key, const SkData& data) override; 68 69 private: 70 // Creation and (the lack of) destruction is handled internally. 71 ShaderCache(); 72 73 // Copying is disallowed. 74 ShaderCache(const ShaderCache&) = delete; 75 void operator=(const ShaderCache&) = delete; 76 77 /** 78 * "getBlobCacheLocked" returns the BlobCache object being used to store the 79 * key/value blob pairs. If the BlobCache object has not yet been created, 80 * this will do so, loading the serialized cache contents from disk if 81 * possible. 82 */ 83 BlobCache* getBlobCacheLocked(); 84 85 /** 86 * "mInitialized" indicates whether the ShaderCache is in the initialized 87 * state. It is initialized to false at construction time, and gets set to 88 * true when initialize is called. 89 * When in this state, the cache behaves as normal. When not, 90 * the load and store methods will return without performing any cache 91 * operations. 92 */ 93 bool mInitialized = false; 94 95 /** 96 * "mBlobCache" is the cache in which the key/value blob pairs are stored. It 97 * is initially NULL, and will be initialized by getBlobCacheLocked the 98 * first time it's needed. 99 * The blob cache contains the Android build number. We treat version mismatches as an empty 100 * cache (logic implemented in BlobCache::unflatten). 101 */ 102 std::unique_ptr<FileBlobCache> mBlobCache; 103 104 /** 105 * "mFilename" is the name of the file for storing cache contents in between 106 * program invocations. It is initialized to an empty string at 107 * construction time, and can be set with the setCacheFilename method. An 108 * empty string indicates that the cache should not be saved to or restored 109 * from disk. 110 */ 111 std::string mFilename; 112 113 /** 114 * "mSavePending" indicates whether or not a deferred save operation is 115 * pending. Each time a key/value pair is inserted into the cache via 116 * load, a deferred save is initiated if one is not already pending. 117 * This will wait some amount of time and then trigger a save of the cache 118 * contents to disk. 119 */ 120 bool mSavePending = false; 121 122 /** 123 * "mObservedBlobValueSize" is the maximum value size observed by the cache reading function. 124 */ 125 size_t mObservedBlobValueSize = 20*1024; 126 127 /** 128 * The time in seconds to wait before saving newly inserted cache entries. 129 */ 130 unsigned int mDeferredSaveDelay = 4; 131 132 /** 133 * "mMutex" is the mutex used to prevent concurrent access to the member 134 * variables. It must be locked whenever the member variables are accessed. 135 */ 136 mutable std::mutex mMutex; 137 138 /** 139 * "sCache" is the singleton ShaderCache object. 140 */ 141 static ShaderCache sCache; 142 143 friend class ShaderCacheTestUtils; //used for unit testing 144 }; 145 146 } /* namespace skiapipeline */ 147 } /* namespace uirenderer */ 148 } /* namespace android */ 149
