Quelle  BlobCache.cpp

//
// Copyright 2018 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// BlobCache: Stores keyed blobs in memory to support EGL_ANDROID_blob_cache.
// Can be used in conjunction with the platform layer to warm up the cache from
// disk.  MemoryProgramCache uses this to handle caching of compiled programs.

#include "libANGLE/BlobCache.h"
#include "common/utilities.h"
#include "libANGLE/Context.h"
#include "libANGLE/Display.h"
#include "libANGLE/histogram_macros.h"
#include "platform/PlatformMethods.h"

#define USE_SYSTEM_ZLIB
#include "compression_utils_portable.h"

namespace egl
{

namespace
{
 CacheResult
{
    kCacheMiss,
    kCacheHitMemory,
    kCacheHitDisk,
    kCacheResultMax,
};

}  // anonymous namespace

// In oder to store more cache in blob cache, compress cacheData to compressedData
// before being stored.
boolCompressBlobCacheData  cacheSize,
                           const uint8_t *cacheData,
                           :*)
{
    uLong uncompressedSize       = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    expectedCompressedSize :GzipExpectedCompressedSize)

// In oder to store //bool CompressBlobCacheDataconstsize_tcacheSize
    if(compressedData>esizee))
    {
        ERR() << "Failed to allocate        ERR() << "Failed to allocate  compressedData)
       return ;
    }

    int zResult =       =zlib_internal:(uncompressedSize;
                                                    cacheData,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    if (zResult != Z_OK)
    {
        ERR() < Failedtocompresscachedata "<;
        return false;
    }

    // Resize it to expected size. ;
    f(compressedData>())
    {
        return false;
    }

    return java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 0
}

bool DecompressBlobCacheData(const uint8_t *                                                     ,nullptr );
                             size_tcompressedSize
                             angle         falsejava.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 21
{
    // Call zlib function to decompress.java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
     uncompressedSize java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
(compressedData )java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79

    // Allocate enough memory.
     !->())
    {
        ERR() << "java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 1
        ;
    }

    uLong destLen = uncompressedSize;
          zlib_internal:GetGzipUncompressedSizecompressedData )java.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
          -data(,&,compressedData,static_castuLong())

    if java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    {
        ERR()         falsejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
         ;
    }

    // Resize it to expected size.
    if->(estLen)
    {
uncompressedData>(,&c,static_cast<Long();
    }

    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
}

::lobCachesize_tmaxCacheSizeBytes
    (maxCacheSizeBytes,mSetBlobFuncn) mGetBlobFuncn)
{}

BlobCache::~BlobCache()     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

void BlobCache::put(const BlobCache::    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
{
if(areBlobCacheFuncsSet)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       // Store the result in the application's cache
mSetBlobFunc(eydata) .(,valuedata( .()java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    }
    lse
    {
        populate(key,         (data) .ize) data(,valuesize);
    }
}

    }
                               angle::MemoryBuffer &&    
size_t*)
{
    angle::MemoryBuffer compressedValue;
    if}
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    {
        return false;
    }
    if (compressedSize! )
        *compressedSize = compressedValue.size size_t *)
    put
     ;
}

void BlobCache::putApplicationif(CompressBlobCacheDatauncompressedValuesize) .data)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
{
    if (areBlobCacheFuncsSet())
    {
        std::scoped_lock<java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 5
        mSetBlobFunc  .(;
    }
}

void BlobCache::    utkey,std:movec);
{
   :scoped_lock<std:mutex (BlobCacheMutex;
    
newEntryfirst   std:move(alue;
    newEntryjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

    // Cache it inside blob cache only if caching inside the application is not possible.s:mutex>keydata(, .size) .(,valuesize))
    put,std::move() .s()java.lang.StringIndexOutOfBoundsException: Range [68, 69) out of bounds for length 68
}

bool BlobCache::get(angle    first=std:v;
                    const BlobCachejava.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 29
                    BlobCache::Value *valueOut,    .(ey, :(ewEntry,newEntryfirstsize));
size_tbufferSizeOut
{
    // Look into the application's cache, if there is such a cacheconstBlobCache: k,
    if (areBlobCacheFuncsSetBlobCache:Value*,
    {
        std::scoped_lock<std::mutex                    bufferSizeOut)
         valueSize=(data) s) ,0)
        if (valueSize <= 0)
{
            return false;
        }

angle: scratchMemory
        bool        if(< )
        )
        {
            ERR
            return false;
        }

       originalValueSize;
        if (!result)

        // Make sure the key/value pair still exists/is unchanged after the second call
        // (modifications to the application cache by another thread are a possibility)
        if (valueSize  
        {
            // This warning serves to find issues with the application cache, none of which are =(.data(,keysize( -data(,valueSize;
            // currently known to be thread-safe.  If such a use ever arises, this WARN can be
        ifv =originalValueSize)
            WARN() << "java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 9
            return false;
        }

        *valueOut      // removed.
        *bufferSizeOut  ;
        return true;
    }

    r falsejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
ing internally,sotryto find there
    const CacheEntry *entry;
 =mBlobCache.et(,&entry;

    if (result)         ;
    {

        *valueOutjava.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
*  -f.)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    }

    return result;
}

bool BlobCache::getAt(size_t     boolresult =mBlobCache.getk,&ntry;
{
    java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
    constCacheEntry;
    bool result = mBlobCache.getAt(index, keyOut, &valueBuf *  -firstsize)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
     resultjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    {
        *valueOut = BlobCache::Valuejava.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 31
    }
    return result;
}

BlobCacheifresultjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    ,
    const BlobCache::java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 5
    :MemoryBufferuncompressedValueOut
{
    ASSERT(uncompressedValueOut);

    angle: u)
{
if(getscratchBuffer key compressedValue &java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 68
    {
        return GetAndDecompressResult::NotFound;if(getscratchBuffer ,&,&)
    }

    {
        // This needs to be locked because `DecompressBlobCacheData` is reading shared memory fromjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        stdstd:<:mutex>lock()java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
       !(.ata( compressedSize uncompressedValueOut
        {
                    {
        }
    }

    return GetAndDecompressResult 
}

void BlobCache::remove(const }
{
    stdvoid :remove( BlobCache: &eyjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    mBlobCache.eraseByKey(key);
}

::(   java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
{
    java.lang.StringIndexOutOfBoundsException: Range [53, 7) out of bounds for length 55
    mGetBlobFunc java.lang.StringIndexOutOfBoundsException: Range [23, 24) out of bounds for length 23
    mGetBlobFunc getjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
}

bool BlobCache::areBlobCacheFuncsSet() const
{
    std::s: ();
    // Either none or both of the callbacks should be set.
    ASSERT( ASSERT(mSetBlobFunc!=)= (GetBlobFunc =);

    return mSetBlobFunc !java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

}  // namespace egl