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 #include "CacheManager.h"
18 
19 #include "Layer.h"
20 #include "Properties.h"
21 #include "RenderThread.h"
22 #include "pipeline/skia/ShaderCache.h"
23 #include "pipeline/skia/SkiaMemoryTracer.h"
24 #include "renderstate/RenderState.h"
25 #include "thread/CommonPool.h"
26 
27 #include <GrContextOptions.h>
28 #include <SkExecutor.h>
29 #include <SkGraphics.h>
30 #include <SkMathPriv.h>
31 #include <gui/Surface.h>
32 #include <math.h>
33 #include <set>
34 
35 namespace android {
36 namespace uirenderer {
37 namespace renderthread {
38 
39 // This multiplier was selected based on historical review of cache sizes relative
40 // to the screen resolution. This is meant to be a conservative default based on
41 // that analysis. The 4.0f is used because the default pixel format is assumed to
42 // be ARGB_8888.
43 #define SURFACE_SIZE_MULTIPLIER (12.0f * 4.0f)
44 #define BACKGROUND_RETENTION_PERCENTAGE (0.5f)
45 
CacheManager(const DisplayInfo & display)46 CacheManager::CacheManager(const DisplayInfo& display)
47         : mMaxSurfaceArea(display.w * display.h)
48         , mMaxResourceBytes(mMaxSurfaceArea * SURFACE_SIZE_MULTIPLIER)
49         , mBackgroundResourceBytes(mMaxResourceBytes * BACKGROUND_RETENTION_PERCENTAGE)
50         // This sets the maximum size for a single texture atlas in the GPU font cache. If
51         // necessary, the cache can allocate additional textures that are counted against the
52         // total cache limits provided to Skia.
53         , mMaxGpuFontAtlasBytes(GrNextSizePow2(mMaxSurfaceArea))
54         // This sets the maximum size of the CPU font cache to be at least the same size as the
55         // total number of GPU font caches (i.e. 4 separate GPU atlases).
56         , mMaxCpuFontCacheBytes(std::max(mMaxGpuFontAtlasBytes*4, SkGraphics::GetFontCacheLimit()))
57         , mBackgroundCpuFontCacheBytes(mMaxCpuFontCacheBytes * BACKGROUND_RETENTION_PERCENTAGE) {
58 
59     SkGraphics::SetFontCacheLimit(mMaxCpuFontCacheBytes);
60 
61     mVectorDrawableAtlas = new skiapipeline::VectorDrawableAtlas(
62             mMaxSurfaceArea / 2,
63             skiapipeline::VectorDrawableAtlas::StorageMode::disallowSharedSurface);
64 }
65 
reset(sk_sp<GrContext> context)66 void CacheManager::reset(sk_sp<GrContext> context) {
67     if (context != mGrContext) {
68         destroy();
69     }
70 
71     if (context) {
72         mGrContext = std::move(context);
73         mGrContext->getResourceCacheLimits(&mMaxResources, nullptr);
74         mGrContext->setResourceCacheLimits(mMaxResources, mMaxResourceBytes);
75     }
76 }
77 
destroy()78 void CacheManager::destroy() {
79     // cleanup any caches here as the GrContext is about to go away...
80     mGrContext.reset(nullptr);
81     mVectorDrawableAtlas = new skiapipeline::VectorDrawableAtlas(
82             mMaxSurfaceArea / 2,
83             skiapipeline::VectorDrawableAtlas::StorageMode::disallowSharedSurface);
84 }
85 
86 class CommonPoolExecutor : public SkExecutor {
87 public:
add(std::function<void (void)> func)88     virtual void add(std::function<void(void)> func) override { CommonPool::post(std::move(func)); }
89 };
90 
91 static CommonPoolExecutor sDefaultExecutor;
92 
configureContext(GrContextOptions * contextOptions,const void * identity,ssize_t size)93 void CacheManager::configureContext(GrContextOptions* contextOptions, const void* identity,
94                                     ssize_t size) {
95     contextOptions->fAllowPathMaskCaching = true;
96     contextOptions->fGlyphCacheTextureMaximumBytes = mMaxGpuFontAtlasBytes;
97     contextOptions->fExecutor = &sDefaultExecutor;
98 
99     auto& cache = skiapipeline::ShaderCache::get();
100     cache.initShaderDiskCache(identity, size);
101     contextOptions->fPersistentCache = &cache;
102     contextOptions->fGpuPathRenderers &= ~GpuPathRenderers::kCoverageCounting;
103 }
104 
trimMemory(TrimMemoryMode mode)105 void CacheManager::trimMemory(TrimMemoryMode mode) {
106     if (!mGrContext) {
107         return;
108     }
109 
110     mGrContext->flush();
111 
112     switch (mode) {
113         case TrimMemoryMode::Complete:
114             mVectorDrawableAtlas = new skiapipeline::VectorDrawableAtlas(mMaxSurfaceArea / 2);
115             mGrContext->freeGpuResources();
116             SkGraphics::PurgeAllCaches();
117             break;
118         case TrimMemoryMode::UiHidden:
119             // Here we purge all the unlocked scratch resources and then toggle the resources cache
120             // limits between the background and max amounts. This causes the unlocked resources
121             // that have persistent data to be purged in LRU order.
122             mGrContext->purgeUnlockedResources(true);
123             mGrContext->setResourceCacheLimits(mMaxResources, mBackgroundResourceBytes);
124             mGrContext->setResourceCacheLimits(mMaxResources, mMaxResourceBytes);
125             SkGraphics::SetFontCacheLimit(mBackgroundCpuFontCacheBytes);
126             SkGraphics::SetFontCacheLimit(mMaxCpuFontCacheBytes);
127             break;
128     }
129 
130     // We must sync the cpu to make sure deletions of resources still queued up on the GPU actually
131     // happen.
132     mGrContext->flush(kSyncCpu_GrFlushFlag, 0, nullptr);
133 }
134 
trimStaleResources()135 void CacheManager::trimStaleResources() {
136     if (!mGrContext) {
137         return;
138     }
139     mGrContext->flush();
140     mGrContext->purgeResourcesNotUsedInMs(std::chrono::seconds(30));
141 }
142 
acquireVectorDrawableAtlas()143 sp<skiapipeline::VectorDrawableAtlas> CacheManager::acquireVectorDrawableAtlas() {
144     LOG_ALWAYS_FATAL_IF(mVectorDrawableAtlas.get() == nullptr);
145     LOG_ALWAYS_FATAL_IF(mGrContext == nullptr);
146 
147     /**
148      * TODO: define memory conditions where we clear the cache (e.g. surface->reset())
149      */
150     return mVectorDrawableAtlas;
151 }
152 
dumpMemoryUsage(String8 & log,const RenderState * renderState)153 void CacheManager::dumpMemoryUsage(String8& log, const RenderState* renderState) {
154     if (!mGrContext) {
155         log.appendFormat("No valid cache instance.\n");
156         return;
157     }
158 
159     log.appendFormat("Font Cache (CPU):\n");
160     log.appendFormat("  Size: %.2f kB \n", SkGraphics::GetFontCacheUsed() / 1024.0f);
161     log.appendFormat("  Glyph Count: %d \n", SkGraphics::GetFontCacheCountUsed());
162 
163     log.appendFormat("CPU Caches:\n");
164     std::vector<skiapipeline::ResourcePair> cpuResourceMap = {
165             {"skia/sk_resource_cache/bitmap_", "Bitmaps"},
166             {"skia/sk_resource_cache/rrect-blur_", "Masks"},
167             {"skia/sk_resource_cache/rects-blur_", "Masks"},
168             {"skia/sk_resource_cache/tessellated", "Shadows"},
169     };
170     skiapipeline::SkiaMemoryTracer cpuTracer(cpuResourceMap, false);
171     SkGraphics::DumpMemoryStatistics(&cpuTracer);
172     cpuTracer.logOutput(log);
173 
174     log.appendFormat("GPU Caches:\n");
175     skiapipeline::SkiaMemoryTracer gpuTracer("category", true);
176     mGrContext->dumpMemoryStatistics(&gpuTracer);
177     gpuTracer.logOutput(log);
178 
179     log.appendFormat("Other Caches:\n");
180     log.appendFormat("                         Current / Maximum\n");
181     log.appendFormat("  VectorDrawableAtlas  %6.2f kB / %6.2f KB (entries = %zu)\n", 0.0f, 0.0f,
182                      (size_t)0);
183 
184     if (renderState) {
185         if (renderState->mActiveLayers.size() > 0) {
186             log.appendFormat("  Layer Info:\n");
187         }
188 
189         const char* layerType = Properties::getRenderPipelineType() == RenderPipelineType::SkiaGL
190                                         ? "GlLayer"
191                                         : "VkLayer";
192         size_t layerMemoryTotal = 0;
193         for (std::set<Layer*>::iterator it = renderState->mActiveLayers.begin();
194              it != renderState->mActiveLayers.end(); it++) {
195             const Layer* layer = *it;
196             log.appendFormat("    %s size %dx%d\n", layerType, layer->getWidth(),
197                              layer->getHeight());
198             layerMemoryTotal += layer->getWidth() * layer->getHeight() * 4;
199         }
200         log.appendFormat("  Layers Total         %6.2f KB (numLayers = %zu)\n",
201                          layerMemoryTotal / 1024.0f, renderState->mActiveLayers.size());
202     }
203 
204     log.appendFormat("Total GPU memory usage:\n");
205     gpuTracer.logTotals(log);
206 }
207 
208 } /* namespace renderthread */
209 } /* namespace uirenderer */
210 } /* namespace android */
211