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

Commit 5dbcfa78 authored by Cody Northrop's avatar Cody Northrop
Browse files

EGL BlobCache: Update multifile key and value size 

Make it clearer what the key and value size limits are.
Base the hot cache on those values, rather than the
other way around.

Test: pubg_mobile_launch ANGLE trace
Test: /data/nativetest64/EGL_test/EGL_test
Test: /data/nativetest64/libEGL_test/libEGL_test
Bug: b/266725576
Change-Id: I337beaf0e01c6497f619c29c01f94242c7b5c959
parent f2588a81

opengl/libs/EGL/MultifileBlobCache.cpp

+9 −7
Original line number Original line Diff line number Diff line
@@ -62,12 +62,14 @@ void freeHotCacheEntry(android::MultifileHotCache& entry) { 




namespace android {

namespace android {





MultifileBlobCache::MultifileBlobCache(size_t maxTotalSize, size_t maxHotCacheSize,

MultifileBlobCache::MultifileBlobCache(size_t maxKeySize, size_t maxValueSize, size_t maxTotalSize,

                                       const std::string& baseDir)

                                       const std::string& baseDir)

      : mInitialized(false),

      : mInitialized(false),

        mMaxKeySize(maxKeySize),

        mMaxValueSize(maxValueSize),

        mMaxTotalSize(maxTotalSize),

        mMaxTotalSize(maxTotalSize),

        mTotalCacheSize(0),

        mTotalCacheSize(0),

        mHotCacheLimit(maxHotCacheSize),

        mHotCacheLimit(0),

        mHotCacheSize(0),

        mHotCacheSize(0),

        mWorkerThreadIdle(true) {

        mWorkerThreadIdle(true) {

    if (baseDir.empty()) {

    if (baseDir.empty()) {
@@ -78,9 +80,9 @@ MultifileBlobCache::MultifileBlobCache(size_t maxTotalSize, size_t maxHotCacheSi 
    // Establish the name of our multifile directory

    // Establish the name of our multifile directory

    mMultifileDirName = baseDir + ".multifile";

    mMultifileDirName = baseDir + ".multifile";





    // Set a limit for max key and value, ensuring at least one entry can always fit in hot cache

    // Set the hotcache limit to be large enough to contain one max entry

    mMaxKeySize = mHotCacheLimit / 4;

    // This ensure the hot cache is always large enough for single entry

    mMaxValueSize = mHotCacheLimit / 2;

    mHotCacheLimit = mMaxKeySize + mMaxValueSize + sizeof(MultifileHeader);





    ALOGV("INIT: Initializing multifile blobcache with maxKeySize=%zu and maxValueSize=%zu",

    ALOGV("INIT: Initializing multifile blobcache with maxKeySize=%zu and maxValueSize=%zu",

          mMaxKeySize, mMaxValueSize);

          mMaxKeySize, mMaxValueSize);
@@ -254,7 +256,7 @@ void MultifileBlobCache::set(const void* key, EGLsizeiANDROID keySize, const voi 




    // Ensure key and value are under their limits

    // Ensure key and value are under their limits

    if (keySize > mMaxKeySize || valueSize > mMaxValueSize) {

    if (keySize > mMaxKeySize || valueSize > mMaxValueSize) {

        ALOGV("SET: keySize (%lu vs %zu) or valueSize (%lu vs %zu) too large", keySize, mMaxKeySize,

        ALOGW("SET: keySize (%lu vs %zu) or valueSize (%lu vs %zu) too large", keySize, mMaxKeySize,

              valueSize, mMaxValueSize);

              valueSize, mMaxValueSize);

        return;

        return;

    }

    }
@@ -326,7 +328,7 @@ EGLsizeiANDROID MultifileBlobCache::get(const void* key, EGLsizeiANDROID keySize 




    // Ensure key and value are under their limits

    // Ensure key and value are under their limits

    if (keySize > mMaxKeySize || valueSize > mMaxValueSize) {

    if (keySize > mMaxKeySize || valueSize > mMaxValueSize) {

        ALOGV("GET: keySize (%lu vs %zu) or valueSize (%lu vs %zu) too large", keySize, mMaxKeySize,

        ALOGW("GET: keySize (%lu vs %zu) or valueSize (%lu vs %zu) too large", keySize, mMaxKeySize,

              valueSize, mMaxValueSize);

              valueSize, mMaxValueSize);

        return 0;

        return 0;

    }

    }

opengl/libs/EGL/MultifileBlobCache.h

+2 −1
Original line number Original line Diff line number Diff line
@@ -91,7 +91,8 @@ private: 




class MultifileBlobCache {

class MultifileBlobCache {

public:

public:

    MultifileBlobCache(size_t maxTotalSize, size_t maxHotCacheSize, const std::string& baseDir);

    MultifileBlobCache(size_t maxKeySize, size_t maxValueSize, size_t maxTotalSize,

                       const std::string& baseDir);

    ~MultifileBlobCache();

    ~MultifileBlobCache();





    void set(const void* key, EGLsizeiANDROID keySize, const void* value,

    void set(const void* key, EGLsizeiANDROID keySize, const void* value,

opengl/libs/EGL/MultifileBlobCache_test.cpp

+4 −5
Original line number Original line Diff line number Diff line
@@ -28,17 +28,16 @@ namespace android { 
template <typename T>

template <typename T>

using sp = std::shared_ptr<T>;

using sp = std::shared_ptr<T>;





constexpr size_t kMaxKeySize = 2 * 1024;

constexpr size_t kMaxValueSize = 6 * 1024;

constexpr size_t kMaxTotalSize = 32 * 1024;

constexpr size_t kMaxTotalSize = 32 * 1024;

constexpr size_t kMaxPreloadSize = 8 * 1024;



constexpr size_t kMaxKeySize = kMaxPreloadSize / 4;

constexpr size_t kMaxValueSize = kMaxPreloadSize / 2;





class MultifileBlobCacheTest : public ::testing::Test {

class MultifileBlobCacheTest : public ::testing::Test {

protected:

protected:

    virtual void SetUp() {

    virtual void SetUp() {

        mTempFile.reset(new TemporaryFile());

        mTempFile.reset(new TemporaryFile());

        mMBC.reset(new MultifileBlobCache(kMaxTotalSize, kMaxPreloadSize, &mTempFile->path[0]));

        mMBC.reset(new MultifileBlobCache(kMaxKeySize, kMaxValueSize, kMaxTotalSize,

                                          &mTempFile->path[0]));

    }

    }





    virtual void TearDown() { mMBC.reset(); }

    virtual void TearDown() { mMBC.reset(); }

opengl/libs/EGL/egl_cache.cpp

+7 −5
Original line number Original line Diff line number Diff line
@@ -38,8 +38,9 @@ static const size_t kMaxMonolithicTotalSize = 2 * 1024 * 1024; 
static const unsigned int kDeferredMonolithicSaveDelay = 4;

static const unsigned int kDeferredMonolithicSaveDelay = 4;





// Multifile cache size limits

// Multifile cache size limits

constexpr uint32_t kMultifileHotCacheLimit = 8 * 1024 * 1024;

constexpr uint32_t kMaxMultifileKeySize = 1 * 1024 * 1024;

constexpr uint32_t kMultifileCacheByteLimit = 32 * 1024 * 1024;

constexpr uint32_t kMaxMultifileValueSize = 8 * 1024 * 1024;

constexpr uint32_t kMaxMultifileTotalSize = 32 * 1024 * 1024;





namespace android {

namespace android {
@@ -250,7 +251,7 @@ void egl_cache_t::updateMode() { 
    if (mMultifileMode) {

    if (mMultifileMode) {

        mCacheByteLimit = static_cast<size_t>(

        mCacheByteLimit = static_cast<size_t>(

                base::GetUintProperty<uint32_t>("ro.egl.blobcache.multifile_limit",

                base::GetUintProperty<uint32_t>("ro.egl.blobcache.multifile_limit",

                                                kMultifileCacheByteLimit));

                                                kMaxMultifileTotalSize));





        // Check for a debug value

        // Check for a debug value

        int debugCacheSize = base::GetIntProperty("debug.egl.blobcache.multifile_limit", -1);

        int debugCacheSize = base::GetIntProperty("debug.egl.blobcache.multifile_limit", -1);
@@ -274,8 +275,9 @@ BlobCache* egl_cache_t::getBlobCacheLocked() { 




MultifileBlobCache* egl_cache_t::getMultifileBlobCacheLocked() {

MultifileBlobCache* egl_cache_t::getMultifileBlobCacheLocked() {

    if (mMultifileBlobCache == nullptr) {

    if (mMultifileBlobCache == nullptr) {

        mMultifileBlobCache.reset(

        mMultifileBlobCache.reset(new MultifileBlobCache(kMaxMultifileKeySize,

                new MultifileBlobCache(mCacheByteLimit, kMultifileHotCacheLimit, mFilename));

                                                         kMaxMultifileValueSize, mCacheByteLimit,

                                                         mFilename));

    }

    }

    return mMultifileBlobCache.get();

    return mMultifileBlobCache.get();

}

}