Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b9e296e1 authored by Derek Sollenberger's avatar Derek Sollenberger
Browse files

Update the CPU text cache sizes to be the same as their GPU equivalents 

Bug: 130684261
Test: uibench jank tests
Change-Id: Ieb837afd76d1990c796baa9794ba54a83b8cd46f
parent f96a3cba

libs/hwui/renderthread/CacheManager.cpp

+20 −15
Original line number Diff line number Diff line
@@ -43,7 +43,21 @@ namespace renderthread { 
#define SURFACE_SIZE_MULTIPLIER (12.0f * 4.0f)

#define BACKGROUND_RETENTION_PERCENTAGE (0.5f)



CacheManager::CacheManager(const DisplayInfo& display) : mMaxSurfaceArea(display.w * display.h) {

CacheManager::CacheManager(const DisplayInfo& display)

        : mMaxSurfaceArea(display.w * display.h)

        , mMaxResourceBytes(mMaxSurfaceArea * SURFACE_SIZE_MULTIPLIER)

        , mBackgroundResourceBytes(mMaxResourceBytes * BACKGROUND_RETENTION_PERCENTAGE)

        // This sets the maximum size for a single texture atlas in the GPU font cache. If

        // necessary, the cache can allocate additional textures that are counted against the

        // total cache limits provided to Skia.

        , mMaxGpuFontAtlasBytes(GrNextSizePow2(mMaxSurfaceArea))

        // This sets the maximum size of the CPU font cache to be at least the same size as the

        // total number of GPU font caches (i.e. 4 separate GPU atlases).

        , mMaxCpuFontCacheBytes(std::max(mMaxGpuFontAtlasBytes*4, SkGraphics::GetFontCacheLimit()))

        , mBackgroundCpuFontCacheBytes(mMaxCpuFontCacheBytes * BACKGROUND_RETENTION_PERCENTAGE) {



    SkGraphics::SetFontCacheLimit(mMaxCpuFontCacheBytes);



    mVectorDrawableAtlas = new skiapipeline::VectorDrawableAtlas(

            mMaxSurfaceArea / 2,

            skiapipeline::VectorDrawableAtlas::StorageMode::disallowSharedSurface);
@@ -57,7 +71,7 @@ void CacheManager::reset(sk_sp<GrContext> context) { 
    if (context) {

        mGrContext = std::move(context);

        mGrContext->getResourceCacheLimits(&mMaxResources, nullptr);

        updateContextCacheSizes();

        mGrContext->setResourceCacheLimits(mMaxResources, mMaxResourceBytes);

    }

}
@@ -69,13 +83,6 @@ void CacheManager::destroy() { 
            skiapipeline::VectorDrawableAtlas::StorageMode::disallowSharedSurface);

}



void CacheManager::updateContextCacheSizes() {

    mMaxResourceBytes = mMaxSurfaceArea * SURFACE_SIZE_MULTIPLIER;

    mBackgroundResourceBytes = mMaxResourceBytes * BACKGROUND_RETENTION_PERCENTAGE;



    mGrContext->setResourceCacheLimits(mMaxResources, mMaxResourceBytes);

}



class CommonPoolExecutor : public SkExecutor {

public:

    virtual void add(std::function<void(void)> func) override { CommonPool::post(std::move(func)); }
@@ -86,12 +93,7 @@ static CommonPoolExecutor sDefaultExecutor; 
void CacheManager::configureContext(GrContextOptions* contextOptions, const void* identity,

                                    ssize_t size) {

    contextOptions->fAllowPathMaskCaching = true;



    // This sets the maximum size for a single texture atlas in the GPU font cache.  If necessary,

    // the cache can allocate additional textures that are counted against the total cache limits

    // provided to Skia.

    contextOptions->fGlyphCacheTextureMaximumBytes = GrNextSizePow2(mMaxSurfaceArea);



    contextOptions->fGlyphCacheTextureMaximumBytes = mMaxGpuFontAtlasBytes;

    contextOptions->fExecutor = &sDefaultExecutor;



    auto& cache = skiapipeline::ShaderCache::get();
@@ -111,6 +113,7 @@ void CacheManager::trimMemory(TrimMemoryMode mode) { 
        case TrimMemoryMode::Complete:

            mVectorDrawableAtlas = new skiapipeline::VectorDrawableAtlas(mMaxSurfaceArea / 2);

            mGrContext->freeGpuResources();

            SkGraphics::PurgeAllCaches();

            break;

        case TrimMemoryMode::UiHidden:

            // Here we purge all the unlocked scratch resources and then toggle the resources cache
@@ -119,6 +122,8 @@ void CacheManager::trimMemory(TrimMemoryMode mode) { 
            mGrContext->purgeUnlockedResources(true);

            mGrContext->setResourceCacheLimits(mMaxResources, mBackgroundResourceBytes);

            mGrContext->setResourceCacheLimits(mMaxResources, mMaxResourceBytes);

            SkGraphics::SetFontCacheLimit(mBackgroundCpuFontCacheBytes);

            SkGraphics::SetFontCacheLimit(mMaxCpuFontCacheBytes);

            break;

    }

}

libs/hwui/renderthread/CacheManager.h

+6 −3
Original line number Diff line number Diff line
@@ -59,14 +59,17 @@ private: 


    void reset(sk_sp<GrContext> grContext);

    void destroy();

    void updateContextCacheSizes();



    const size_t mMaxSurfaceArea;

    sk_sp<GrContext> mGrContext;



    int mMaxResources = 0;

    size_t mMaxResourceBytes = 0;

    size_t mBackgroundResourceBytes = 0;

    const size_t mMaxResourceBytes;

    const size_t mBackgroundResourceBytes;



    const size_t mMaxGpuFontAtlasBytes;

    const size_t mMaxCpuFontCacheBytes;

    const size_t mBackgroundCpuFontCacheBytes;



    struct PipelineProps {

        const void* pipelineKey = nullptr;