99c3d700d2
This change causes any insertions into the EGL cache to trigger an attempt to save the cache contents to disk. The save operation is deferred to allow multiple cache insertions to be batched up. Change-Id: I6cfec9c0dbbef94d3f8880860e2a365dccc296c7
343 lines
11 KiB
C++
343 lines
11 KiB
C++
/*
|
|
** Copyright 2011, The Android Open Source Project
|
|
**
|
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
|
** you may not use this file except in compliance with the License.
|
|
** You may obtain a copy of the License at
|
|
**
|
|
** http://www.apache.org/licenses/LICENSE-2.0
|
|
**
|
|
** Unless required by applicable law or agreed to in writing, software
|
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
** See the License for the specific language governing permissions and
|
|
** limitations under the License.
|
|
*/
|
|
|
|
#include "egl_cache.h"
|
|
#include "egl_display.h"
|
|
#include "egl_impl.h"
|
|
#include "egldefs.h"
|
|
|
|
#include <fcntl.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
// Cache size limits.
|
|
static const size_t maxKeySize = 1024;
|
|
static const size_t maxValueSize = 4096;
|
|
static const size_t maxTotalSize = 64 * 1024;
|
|
|
|
// Cache file header
|
|
static const char* cacheFileMagic = "EGL$";
|
|
static const size_t cacheFileHeaderSize = 8;
|
|
|
|
// The time in seconds to wait before saving newly inserted cache entries.
|
|
static const unsigned int deferredSaveDelay = 4;
|
|
|
|
// ----------------------------------------------------------------------------
|
|
namespace android {
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#define BC_EXT_STR "EGL_ANDROID_blob_cache"
|
|
|
|
//
|
|
// Callback functions passed to EGL.
|
|
//
|
|
static void setBlob(const void* key, EGLsizei keySize, const void* value,
|
|
EGLsizei valueSize) {
|
|
egl_cache_t::get()->setBlob(key, keySize, value, valueSize);
|
|
}
|
|
|
|
static EGLsizei getBlob(const void* key, EGLsizei keySize, void* value,
|
|
EGLsizei valueSize) {
|
|
return egl_cache_t::get()->getBlob(key, keySize, value, valueSize);
|
|
}
|
|
|
|
//
|
|
// egl_cache_t definition
|
|
//
|
|
egl_cache_t::egl_cache_t() :
|
|
mInitialized(false),
|
|
mBlobCache(NULL) {
|
|
}
|
|
|
|
egl_cache_t::~egl_cache_t() {
|
|
}
|
|
|
|
egl_cache_t egl_cache_t::sCache;
|
|
|
|
egl_cache_t* egl_cache_t::get() {
|
|
return &sCache;
|
|
}
|
|
|
|
void egl_cache_t::initialize(egl_display_t *display) {
|
|
Mutex::Autolock lock(mMutex);
|
|
for (int i = 0; i < IMPL_NUM_IMPLEMENTATIONS; i++) {
|
|
egl_connection_t* const cnx = &gEGLImpl[i];
|
|
if (cnx->dso && cnx->major >= 0 && cnx->minor >= 0) {
|
|
const char* exts = display->disp[i].queryString.extensions;
|
|
size_t bcExtLen = strlen(BC_EXT_STR);
|
|
size_t extsLen = strlen(exts);
|
|
bool equal = !strcmp(BC_EXT_STR, exts);
|
|
bool atStart = !strncmp(BC_EXT_STR " ", exts, bcExtLen+1);
|
|
bool atEnd = (bcExtLen+1) < extsLen &&
|
|
!strcmp(" " BC_EXT_STR, exts + extsLen - (bcExtLen+1));
|
|
bool inMiddle = strstr(" " BC_EXT_STR " ", exts);
|
|
if (equal || atStart || atEnd || inMiddle) {
|
|
PFNEGLSETBLOBCACHEFUNCSPROC eglSetBlobCacheFuncs;
|
|
eglSetBlobCacheFuncs =
|
|
reinterpret_cast<PFNEGLSETBLOBCACHEFUNCSPROC>(
|
|
cnx->egl.eglGetProcAddress("eglSetBlobCacheFuncs"));
|
|
if (eglSetBlobCacheFuncs == NULL) {
|
|
LOGE("EGL_ANDROID_blob_cache advertised by display %d, "
|
|
"but unable to get eglSetBlobCacheFuncs", i);
|
|
continue;
|
|
}
|
|
|
|
eglSetBlobCacheFuncs(display->disp[i].dpy, android::setBlob,
|
|
android::getBlob);
|
|
EGLint err = cnx->egl.eglGetError();
|
|
if (err != EGL_SUCCESS) {
|
|
LOGE("eglSetBlobCacheFuncs resulted in an error: %#x",
|
|
err);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
mInitialized = true;
|
|
}
|
|
|
|
void egl_cache_t::terminate() {
|
|
Mutex::Autolock lock(mMutex);
|
|
if (mBlobCache != NULL) {
|
|
saveBlobCacheLocked();
|
|
mBlobCache = NULL;
|
|
}
|
|
mInitialized = false;
|
|
}
|
|
|
|
void egl_cache_t::setBlob(const void* key, EGLsizei keySize, const void* value,
|
|
EGLsizei valueSize) {
|
|
Mutex::Autolock lock(mMutex);
|
|
|
|
if (keySize < 0 || valueSize < 0) {
|
|
LOGW("EGL_ANDROID_blob_cache set: negative sizes are not allowed");
|
|
return;
|
|
}
|
|
|
|
if (mInitialized) {
|
|
sp<BlobCache> bc = getBlobCacheLocked();
|
|
bc->set(key, keySize, value, valueSize);
|
|
|
|
if (!mSavePending) {
|
|
class DeferredSaveThread : public Thread {
|
|
public:
|
|
DeferredSaveThread() : Thread(false) {}
|
|
|
|
virtual bool threadLoop() {
|
|
sleep(deferredSaveDelay);
|
|
egl_cache_t* c = egl_cache_t::get();
|
|
Mutex::Autolock lock(c->mMutex);
|
|
if (c->mInitialized) {
|
|
c->saveBlobCacheLocked();
|
|
}
|
|
c->mSavePending = false;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// The thread will hold a strong ref to itself until it has finished
|
|
// running, so there's no need to keep a ref around.
|
|
sp<Thread> deferredSaveThread(new DeferredSaveThread());
|
|
mSavePending = true;
|
|
deferredSaveThread->run();
|
|
}
|
|
}
|
|
}
|
|
|
|
EGLsizei egl_cache_t::getBlob(const void* key, EGLsizei keySize, void* value,
|
|
EGLsizei valueSize) {
|
|
Mutex::Autolock lock(mMutex);
|
|
|
|
if (keySize < 0 || valueSize < 0) {
|
|
LOGW("EGL_ANDROID_blob_cache set: negative sizes are not allowed");
|
|
return 0;
|
|
}
|
|
|
|
if (mInitialized) {
|
|
sp<BlobCache> bc = getBlobCacheLocked();
|
|
return bc->get(key, keySize, value, valueSize);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void egl_cache_t::setCacheFilename(const char* filename) {
|
|
Mutex::Autolock lock(mMutex);
|
|
mFilename = filename;
|
|
}
|
|
|
|
sp<BlobCache> egl_cache_t::getBlobCacheLocked() {
|
|
if (mBlobCache == NULL) {
|
|
mBlobCache = new BlobCache(maxKeySize, maxValueSize, maxTotalSize);
|
|
loadBlobCacheLocked();
|
|
}
|
|
return mBlobCache;
|
|
}
|
|
|
|
static uint32_t crc32c(const uint8_t* buf, size_t len) {
|
|
const uint32_t polyBits = 0x82F63B78;
|
|
uint32_t r = 0;
|
|
for (size_t i = 0; i < len; i++) {
|
|
r ^= buf[i];
|
|
for (int j = 0; j < 8; j++) {
|
|
if (r & 1) {
|
|
r = (r >> 1) ^ polyBits;
|
|
} else {
|
|
r >>= 1;
|
|
}
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
void egl_cache_t::saveBlobCacheLocked() {
|
|
if (mFilename.length() > 0) {
|
|
size_t cacheSize = mBlobCache->getFlattenedSize();
|
|
size_t headerSize = cacheFileHeaderSize;
|
|
const char* fname = mFilename.string();
|
|
|
|
// Try to create the file with no permissions so we can write it
|
|
// without anyone trying to read it.
|
|
int fd = open(fname, O_CREAT | O_EXCL | O_RDWR, 0);
|
|
if (fd == -1) {
|
|
if (errno == EEXIST) {
|
|
// The file exists, delete it and try again.
|
|
if (unlink(fname) == -1) {
|
|
// No point in retrying if the unlink failed.
|
|
LOGE("error unlinking cache file %s: %s (%d)", fname,
|
|
strerror(errno), errno);
|
|
return;
|
|
}
|
|
// Retry now that we've unlinked the file.
|
|
fd = open(fname, O_CREAT | O_EXCL | O_RDWR, 0);
|
|
}
|
|
if (fd == -1) {
|
|
LOGE("error creating cache file %s: %s (%d)", fname,
|
|
strerror(errno), errno);
|
|
return;
|
|
}
|
|
}
|
|
|
|
size_t fileSize = headerSize + cacheSize;
|
|
if (ftruncate(fd, fileSize) == -1) {
|
|
LOGE("error setting cache file size: %s (%d)", strerror(errno),
|
|
errno);
|
|
close(fd);
|
|
unlink(fname);
|
|
return;
|
|
}
|
|
|
|
uint8_t* buf = reinterpret_cast<uint8_t*>(mmap(NULL, fileSize,
|
|
PROT_WRITE, MAP_SHARED, fd, 0));
|
|
if (buf == MAP_FAILED) {
|
|
LOGE("error mmaping cache file: %s (%d)", strerror(errno),
|
|
errno);
|
|
close(fd);
|
|
unlink(fname);
|
|
return;
|
|
}
|
|
|
|
status_t err = mBlobCache->flatten(buf + headerSize, cacheSize, NULL,
|
|
0);
|
|
if (err != OK) {
|
|
LOGE("error writing cache contents: %s (%d)", strerror(-err),
|
|
-err);
|
|
munmap(buf, fileSize);
|
|
close(fd);
|
|
unlink(fname);
|
|
return;
|
|
}
|
|
|
|
// Write the file magic and CRC
|
|
memcpy(buf, cacheFileMagic, 4);
|
|
uint32_t* crc = reinterpret_cast<uint32_t*>(buf + 4);
|
|
*crc = crc32c(buf + headerSize, cacheSize);
|
|
|
|
munmap(buf, fileSize);
|
|
fchmod(fd, S_IRUSR);
|
|
close(fd);
|
|
}
|
|
}
|
|
|
|
void egl_cache_t::loadBlobCacheLocked() {
|
|
if (mFilename.length() > 0) {
|
|
size_t headerSize = cacheFileHeaderSize;
|
|
|
|
int fd = open(mFilename.string(), O_RDONLY, 0);
|
|
if (fd == -1) {
|
|
if (errno != ENOENT) {
|
|
LOGE("error opening cache file %s: %s (%d)", mFilename.string(),
|
|
strerror(errno), errno);
|
|
}
|
|
return;
|
|
}
|
|
|
|
struct stat statBuf;
|
|
if (fstat(fd, &statBuf) == -1) {
|
|
LOGE("error stat'ing cache file: %s (%d)", strerror(errno), errno);
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
// Sanity check the size before trying to mmap it.
|
|
size_t fileSize = statBuf.st_size;
|
|
if (fileSize > maxTotalSize * 2) {
|
|
LOGE("cache file is too large: %#llx", statBuf.st_size);
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
uint8_t* buf = reinterpret_cast<uint8_t*>(mmap(NULL, fileSize,
|
|
PROT_READ, MAP_PRIVATE, fd, 0));
|
|
if (buf == MAP_FAILED) {
|
|
LOGE("error mmaping cache file: %s (%d)", strerror(errno),
|
|
errno);
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
// Check the file magic and CRC
|
|
size_t cacheSize = fileSize - headerSize;
|
|
if (memcmp(buf, cacheFileMagic, 4) != 0) {
|
|
LOGE("cache file has bad mojo");
|
|
close(fd);
|
|
return;
|
|
}
|
|
uint32_t* crc = reinterpret_cast<uint32_t*>(buf + 4);
|
|
if (crc32c(buf + headerSize, cacheSize) != *crc) {
|
|
LOGE("cache file failed CRC check");
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
status_t err = mBlobCache->unflatten(buf + headerSize, cacheSize, NULL, 0);
|
|
if (err != OK) {
|
|
LOGE("error reading cache contents: %s (%d)", strerror(-err),
|
|
-err);
|
|
munmap(buf, fileSize);
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
munmap(buf, fileSize);
|
|
close(fd);
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
}; // namespace android
|
|
// ----------------------------------------------------------------------------
|