Merge changes from topic 'blobcache' (d8a7e59e) · Commits · e / os / android_frameworks_native

opengl/libs/Android.bp

+11 −0

Original line number	Diff line number	Diff line
		@@ -105,9 +105,20 @@ cc_library_shared {
		"EGL/egl.cpp",
		"EGL/eglApi.cpp",
		"EGL/Loader.cpp",
		"EGL/BlobCache.cpp",
		],
		static_libs: ["libEGL_getProcAddress"],
		ldflags: ["-Wl,--exclude-libs=ALL"],
		export_include_dirs: ["EGL/include"],
		}

		cc_test {
		name: "libEGL_test",
		defaults: ["egl_libs_defaults"],
		srcs: [
		"EGL/BlobCache.cpp",
		"EGL/BlobCache_test.cpp",
		],
		}

		cc_defaults {

opengl/libs/EGL/BlobCache.cpp

0 → 100644

+373 −0

Original line number	Diff line number	Diff line
		/*
		** 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.
		*/

		//#define LOG_NDEBUG 0

		#include "BlobCache.h"

		#include <inttypes.h>

		#include <cutils/properties.h>
		#include <log/log.h>
		#include <chrono>

		namespace android {

		// BlobCache::Header::mMagicNumber value
		static const uint32_t blobCacheMagic = ('_' << 24) + ('B' << 16) + ('b' << 8) + '$';

		// BlobCache::Header::mBlobCacheVersion value
		static const uint32_t blobCacheVersion = 3;

		// BlobCache::Header::mDeviceVersion value
		static const uint32_t blobCacheDeviceVersion = 1;

		BlobCache::BlobCache(size_t maxKeySize, size_t maxValueSize, size_t maxTotalSize):
		mMaxKeySize(maxKeySize),
		mMaxValueSize(maxValueSize),
		mMaxTotalSize(maxTotalSize),
		mTotalSize(0) {
		int64_t now = std::chrono::steady_clock::now().time_since_epoch().count();
		#ifdef _WIN32
		srand(now);
		#else
		mRandState[0] = (now >> 0) & 0xFFFF;
		mRandState[1] = (now >> 16) & 0xFFFF;
		mRandState[2] = (now >> 32) & 0xFFFF;
		#endif
		ALOGV("initializing random seed using %lld", (unsigned long long)now);
		}

		void BlobCache::set(const void* key, size_t keySize, const void* value,
		size_t valueSize) {
		if (mMaxKeySize < keySize) {
		ALOGV("set: not caching because the key is too large: %zu (limit: %zu)",
		keySize, mMaxKeySize);
		return;
		}
		if (mMaxValueSize < valueSize) {
		ALOGV("set: not caching because the value is too large: %zu (limit: %zu)",
		valueSize, mMaxValueSize);
		return;
		}
		if (mMaxTotalSize < keySize + valueSize) {
		ALOGV("set: not caching because the combined key/value size is too "
		"large: %zu (limit: %zu)", keySize + valueSize, mMaxTotalSize);
		return;
		}
		if (keySize == 0) {
		ALOGW("set: not caching because keySize is 0");
		return;
		}
		if (valueSize <= 0) {
		ALOGW("set: not caching because valueSize is 0");
		return;
		}

		std::shared_ptr<Blob> dummyKey(new Blob(key, keySize, false));
		CacheEntry dummyEntry(dummyKey, NULL);

		while (true) {
		auto index = std::lower_bound(mCacheEntries.begin(), mCacheEntries.end(), dummyEntry);
		if (index == mCacheEntries.end() \|\| dummyEntry < *index) {
		// Create a new cache entry.
		std::shared_ptr<Blob> keyBlob(new Blob(key, keySize, true));
		std::shared_ptr<Blob> valueBlob(new Blob(value, valueSize, true));
		size_t newTotalSize = mTotalSize + keySize + valueSize;
		if (mMaxTotalSize < newTotalSize) {
		if (isCleanable()) {
		// Clean the cache and try again.
		clean();
		continue;
		} else {
		ALOGV("set: not caching new key/value pair because the "
		"total cache size limit would be exceeded: %zu "
		"(limit: %zu)",
		keySize + valueSize, mMaxTotalSize);
		break;
		}
		}
		mCacheEntries.insert(index, CacheEntry(keyBlob, valueBlob));
		mTotalSize = newTotalSize;
		ALOGV("set: created new cache entry with %zu byte key and %zu byte value",
		keySize, valueSize);
		} else {
		// Update the existing cache entry.
		std::shared_ptr<Blob> valueBlob(new Blob(value, valueSize, true));
		std::shared_ptr<Blob> oldValueBlob(index->getValue());
		size_t newTotalSize = mTotalSize + valueSize - oldValueBlob->getSize();
		if (mMaxTotalSize < newTotalSize) {
		if (isCleanable()) {
		// Clean the cache and try again.
		clean();
		continue;
		} else {
		ALOGV("set: not caching new value because the total cache "
		"size limit would be exceeded: %zu (limit: %zu)",
		keySize + valueSize, mMaxTotalSize);
		break;
		}
		}
		index->setValue(valueBlob);
		mTotalSize = newTotalSize;
		ALOGV("set: updated existing cache entry with %zu byte key and %zu byte "
		"value", keySize, valueSize);
		}
		break;
		}
		}

		size_t BlobCache::get(const void* key, size_t keySize, void* value,
		size_t valueSize) {
		if (mMaxKeySize < keySize) {
		ALOGV("get: not searching because the key is too large: %zu (limit %zu)",
		keySize, mMaxKeySize);
		return 0;
		}
		std::shared_ptr<Blob> dummyKey(new Blob(key, keySize, false));
		CacheEntry dummyEntry(dummyKey, NULL);
		auto index = std::lower_bound(mCacheEntries.begin(), mCacheEntries.end(), dummyEntry);
		if (index == mCacheEntries.end() \|\| dummyEntry < *index) {
		ALOGV("get: no cache entry found for key of size %zu", keySize);
		return 0;
		}

		// The key was found. Return the value if the caller's buffer is large
		// enough.
		std::shared_ptr<Blob> valueBlob(index->getValue());
		size_t valueBlobSize = valueBlob->getSize();
		if (valueBlobSize <= valueSize) {
		ALOGV("get: copying %zu bytes to caller's buffer", valueBlobSize);
		memcpy(value, valueBlob->getData(), valueBlobSize);
		} else {
		ALOGV("get: caller's buffer is too small for value: %zu (needs %zu)",
		valueSize, valueBlobSize);
		}
		return valueBlobSize;
		}

		static inline size_t align4(size_t size) {
		return (size + 3) & ~3;
		}

		size_t BlobCache::getFlattenedSize() const {
		size_t size = align4(sizeof(Header) + PROPERTY_VALUE_MAX);
		for (const CacheEntry& e : mCacheEntries) {
		std::shared_ptr<Blob> const& keyBlob = e.getKey();
		std::shared_ptr<Blob> const& valueBlob = e.getValue();
		size += align4(sizeof(EntryHeader) + keyBlob->getSize() + valueBlob->getSize());
		}
		return size;
		}

		int BlobCache::flatten(void* buffer, size_t size) const {
		// Write the cache header
		if (size < sizeof(Header)) {
		ALOGE("flatten: not enough room for cache header");
		return 0;
		}
		Header* header = reinterpret_cast<Header*>(buffer);
		header->mMagicNumber = blobCacheMagic;
		header->mBlobCacheVersion = blobCacheVersion;
		header->mDeviceVersion = blobCacheDeviceVersion;
		header->mNumEntries = mCacheEntries.size();
		char buildId[PROPERTY_VALUE_MAX];
		header->mBuildIdLength = property_get("ro.build.id", buildId, "");
		memcpy(header->mBuildId, buildId, header->mBuildIdLength);

		// Write cache entries
		uint8_t* byteBuffer = reinterpret_cast<uint8_t*>(buffer);
		off_t byteOffset = align4(sizeof(Header) + header->mBuildIdLength);
		for (const CacheEntry& e : mCacheEntries) {
		std::shared_ptr<Blob> const& keyBlob = e.getKey();
		std::shared_ptr<Blob> const& valueBlob = e.getValue();
		size_t keySize = keyBlob->getSize();
		size_t valueSize = valueBlob->getSize();

		size_t entrySize = sizeof(EntryHeader) + keySize + valueSize;
		size_t totalSize = align4(entrySize);
		if (byteOffset + totalSize > size) {
		ALOGE("flatten: not enough room for cache entries");
		return -EINVAL;
		}

		EntryHeader* eheader = reinterpret_cast<EntryHeader*>(&byteBuffer[byteOffset]);
		eheader->mKeySize = keySize;
		eheader->mValueSize = valueSize;

		memcpy(eheader->mData, keyBlob->getData(), keySize);
		memcpy(eheader->mData + keySize, valueBlob->getData(), valueSize);

		if (totalSize > entrySize) {
		// We have padding bytes. Those will get written to storage, and contribute to the CRC,
		// so make sure we zero-them to have reproducible results.
		memset(eheader->mData + keySize + valueSize, 0, totalSize - entrySize);
		}

		byteOffset += totalSize;
		}

		return 0;
		}

		int BlobCache::unflatten(void const* buffer, size_t size) {
		// All errors should result in the BlobCache being in an empty state.
		mCacheEntries.clear();

		// Read the cache header
		if (size < sizeof(Header)) {
		ALOGE("unflatten: not enough room for cache header");
		return -EINVAL;
		}
		const Header* header = reinterpret_cast<const Header*>(buffer);
		if (header->mMagicNumber != blobCacheMagic) {
		ALOGE("unflatten: bad magic number: %" PRIu32, header->mMagicNumber);
		return -EINVAL;
		}
		char buildId[PROPERTY_VALUE_MAX];
		int len = property_get("ro.build.id", buildId, "");
		if (header->mBlobCacheVersion != blobCacheVersion \|\|
		header->mDeviceVersion != blobCacheDeviceVersion \|\|
		len != header->mBuildIdLength \|\|
		strncmp(buildId, header->mBuildId, len)) {
		// We treat version mismatches as an empty cache.
		return 0;
		}

		// Read cache entries
		const uint8_t* byteBuffer = reinterpret_cast<const uint8_t*>(buffer);
		off_t byteOffset = align4(sizeof(Header) + header->mBuildIdLength);
		size_t numEntries = header->mNumEntries;
		for (size_t i = 0; i < numEntries; i++) {
		if (byteOffset + sizeof(EntryHeader) > size) {
		mCacheEntries.clear();
		ALOGE("unflatten: not enough room for cache entry headers");
		return -EINVAL;
		}

		const EntryHeader* eheader = reinterpret_cast<const EntryHeader*>(
		&byteBuffer[byteOffset]);
		size_t keySize = eheader->mKeySize;
		size_t valueSize = eheader->mValueSize;
		size_t entrySize = sizeof(EntryHeader) + keySize + valueSize;

		size_t totalSize = align4(entrySize);
		if (byteOffset + totalSize > size) {
		mCacheEntries.clear();
		ALOGE("unflatten: not enough room for cache entry headers");
		return -EINVAL;
		}

		const uint8_t* data = eheader->mData;
		set(data, keySize, data + keySize, valueSize);

		byteOffset += totalSize;
		}

		return 0;
		}

		long int BlobCache::blob_random() {
		#ifdef _WIN32
		return rand();
		#else
		return nrand48(mRandState);
		#endif
		}

		void BlobCache::clean() {
		// Remove a random cache entry until the total cache size gets below half
		// the maximum total cache size.
		while (mTotalSize > mMaxTotalSize / 2) {
		size_t i = size_t(blob_random() % (mCacheEntries.size()));
		const CacheEntry& entry(mCacheEntries[i]);
		mTotalSize -= entry.getKey()->getSize() + entry.getValue()->getSize();
		mCacheEntries.erase(mCacheEntries.begin() + i);
		}
		}

		bool BlobCache::isCleanable() const {
		return mTotalSize > mMaxTotalSize / 2;
		}

		BlobCache::Blob::Blob(const void* data, size_t size, bool copyData) :
		mData(copyData ? malloc(size) : data),
		mSize(size),
		mOwnsData(copyData) {
		if (data != NULL && copyData) {
		memcpy(const_cast<void*>(mData), data, size);
		}
		}

		BlobCache::Blob::~Blob() {
		if (mOwnsData) {
		free(const_cast<void*>(mData));
		}
		}

		bool BlobCache::Blob::operator<(const Blob& rhs) const {
		if (mSize == rhs.mSize) {
		return memcmp(mData, rhs.mData, mSize) < 0;
		} else {
		return mSize < rhs.mSize;
		}
		}

		const void* BlobCache::Blob::getData() const {
		return mData;
		}

		size_t BlobCache::Blob::getSize() const {
		return mSize;
		}

		BlobCache::CacheEntry::CacheEntry() {
		}

		BlobCache::CacheEntry::CacheEntry(
		const std::shared_ptr<Blob>& key, const std::shared_ptr<Blob>& value):
		mKey(key),
		mValue(value) {
		}

		BlobCache::CacheEntry::CacheEntry(const CacheEntry& ce):
		mKey(ce.mKey),
		mValue(ce.mValue) {
		}

		bool BlobCache::CacheEntry::operator<(const CacheEntry& rhs) const {
		return mKey < rhs.mKey;
		}

		const BlobCache::CacheEntry& BlobCache::CacheEntry::operator=(const CacheEntry& rhs) {
		mKey = rhs.mKey;
		mValue = rhs.mValue;
		return *this;
		}

		std::shared_ptr<BlobCache::Blob> BlobCache::CacheEntry::getKey() const {
		return mKey;
		}

		std::shared_ptr<BlobCache::Blob> BlobCache::CacheEntry::getValue() const {
		return mValue;
		}

		void BlobCache::CacheEntry::setValue(const std::shared_ptr<Blob>& value) {
		mValue = value;
		}

		} // namespace android

opengl/libs/EGL/BlobCache.h

0 → 100644

+245 −0

Original line number	Diff line number	Diff line
		/*
		** 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.
		*/

		#ifndef ANDROID_BLOB_CACHE_H
		#define ANDROID_BLOB_CACHE_H

		#include <stddef.h>

		#include <memory>
		#include <vector>

		namespace android {

		// A BlobCache is an in-memory cache for binary key/value pairs. A BlobCache
		// does NOT provide any thread-safety guarantees.
		//
		// The cache contents can be serialized to an in-memory buffer or mmap'd file
		// and then reloaded in a subsequent execution of the program. This
		// serialization is non-portable and the data should only be used by the device
		// that generated it.
		class BlobCache {
		public:
		// Create an empty blob cache. The blob cache will cache key/value pairs
		// with key and value sizes less than or equal to maxKeySize and
		// maxValueSize, respectively. The total combined size of ALL cache entries
		// (key sizes plus value sizes) will not exceed maxTotalSize.
		BlobCache(size_t maxKeySize, size_t maxValueSize, size_t maxTotalSize);

		// set inserts a new binary value into the cache and associates it with the
		// given binary key. If the key or value are too large for the cache then
		// the cache remains unchanged. This includes the case where a different
		// value was previously associated with the given key - the old value will
		// remain in the cache. If the given key and value are small enough to be
		// put in the cache (based on the maxKeySize, maxValueSize, and maxTotalSize
		// values specified to the BlobCache constructor), then the key/value pair
		// will be in the cache after set returns. Note, however, that a subsequent
		// call to set may evict old key/value pairs from the cache.
		//
		// Preconditions:
		// key != NULL
		// 0 < keySize
		// value != NULL
		// 0 < valueSize
		void set(const void* key, size_t keySize, const void* value,
		size_t valueSize);

		// get retrieves from the cache the binary value associated with a given
		// binary key. If the key is present in the cache then the length of the
		// binary value associated with that key is returned. If the value argument
		// is non-NULL and the size of the cached value is less than valueSize bytes
		// then the cached value is copied into the buffer pointed to by the value
		// argument. If the key is not present in the cache then 0 is returned and
		// the buffer pointed to by the value argument is not modified.
		//
		// Note that when calling get multiple times with the same key, the later
		// calls may fail, returning 0, even if earlier calls succeeded. The return
		// value must be checked for each call.
		//
		// Preconditions:
		// key != NULL
		// 0 < keySize
		// 0 <= valueSize
		size_t get(const void* key, size_t keySize, void* value, size_t valueSize);


		// getFlattenedSize returns the number of bytes needed to store the entire
		// serialized cache.
		size_t getFlattenedSize() const;

		// flatten serializes the current contents of the cache into the memory
		// pointed to by 'buffer'. The serialized cache contents can later be
		// loaded into a BlobCache object using the unflatten method. The contents
		// of the BlobCache object will not be modified.
		//
		// Preconditions:
		// size >= this.getFlattenedSize()
		int flatten(void* buffer, size_t size) const;

		// unflatten replaces the contents of the cache with the serialized cache
		// contents in the memory pointed to by 'buffer'. The previous contents of
		// the BlobCache will be evicted from the cache. If an error occurs while
		// unflattening the serialized cache contents then the BlobCache will be
		// left in an empty state.
		//
		int unflatten(void const* buffer, size_t size);

		private:
		// Copying is disallowed.
		BlobCache(const BlobCache&);
		void operator=(const BlobCache&);

		// A random function helper to get around MinGW not having nrand48()
		long int blob_random();

		// clean evicts a randomly chosen set of entries from the cache such that
		// the total size of all remaining entries is less than mMaxTotalSize/2.
		void clean();

		// isCleanable returns true if the cache is full enough for the clean method
		// to have some effect, and false otherwise.
		bool isCleanable() const;

		// A Blob is an immutable sized unstructured data blob.
		class Blob {
		public:
		Blob(const void* data, size_t size, bool copyData);
		~Blob();

		bool operator<(const Blob& rhs) const;

		const void* getData() const;
		size_t getSize() const;

		private:
		// Copying is not allowed.
		Blob(const Blob&);
		void operator=(const Blob&);

		// mData points to the buffer containing the blob data.
		const void* mData;

		// mSize is the size of the blob data in bytes.
		size_t mSize;

		// mOwnsData indicates whether or not this Blob object should free the
		// memory pointed to by mData when the Blob gets destructed.
		bool mOwnsData;
		};

		// A CacheEntry is a single key/value pair in the cache.
		class CacheEntry {
		public:
		CacheEntry();
		CacheEntry(const std::shared_ptr<Blob>& key, const std::shared_ptr<Blob>& value);
		CacheEntry(const CacheEntry& ce);

		bool operator<(const CacheEntry& rhs) const;
		const CacheEntry& operator=(const CacheEntry&);

		std::shared_ptr<Blob> getKey() const;
		std::shared_ptr<Blob> getValue() const;

		void setValue(const std::shared_ptr<Blob>& value);

		private:

		// mKey is the key that identifies the cache entry.
		std::shared_ptr<Blob> mKey;

		// mValue is the cached data associated with the key.
		std::shared_ptr<Blob> mValue;
		};

		// A Header is the header for the entire BlobCache serialization format. No
		// need to make this portable, so we simply write the struct out.
		struct Header {
		// mMagicNumber is the magic number that identifies the data as
		// serialized BlobCache contents. It must always contain 'Blb$'.
		uint32_t mMagicNumber;

		// mBlobCacheVersion is the serialization format version.
		uint32_t mBlobCacheVersion;

		// mDeviceVersion is the device-specific version of the cache. This can
		// be used to invalidate the cache.
		uint32_t mDeviceVersion;

		// mNumEntries is number of cache entries following the header in the
		// data.
		size_t mNumEntries;

		// mBuildId is the build id of the device when the cache was created.
		// When an update to the build happens (via an OTA or other update) this
		// is used to invalidate the cache.
		int mBuildIdLength;
		char mBuildId[];
		};

		// An EntryHeader is the header for a serialized cache entry. No need to
		// make this portable, so we simply write the struct out. Each EntryHeader
		// is followed imediately by the key data and then the value data.
		//
		// The beginning of each serialized EntryHeader is 4-byte aligned, so the
		// number of bytes that a serialized cache entry will occupy is:
		//
		// ((sizeof(EntryHeader) + keySize + valueSize) + 3) & ~3
		//
		struct EntryHeader {
		// mKeySize is the size of the entry key in bytes.
		size_t mKeySize;

		// mValueSize is the size of the entry value in bytes.
		size_t mValueSize;

		// mData contains both the key and value data for the cache entry. The
		// key comes first followed immediately by the value.
		uint8_t mData[];
		};

		// mMaxKeySize is the maximum key size that will be cached. Calls to
		// BlobCache::set with a keySize parameter larger than mMaxKeySize will
		// simply not add the key/value pair to the cache.
		const size_t mMaxKeySize;

		// mMaxValueSize is the maximum value size that will be cached. Calls to
		// BlobCache::set with a valueSize parameter larger than mMaxValueSize will
		// simply not add the key/value pair to the cache.
		const size_t mMaxValueSize;

		// mMaxTotalSize is the maximum size that all cache entries can occupy. This
		// includes space for both keys and values. When a call to BlobCache::set
		// would otherwise cause this limit to be exceeded, either the key/value
		// pair passed to BlobCache::set will not be cached or other cache entries
		// will be evicted from the cache to make room for the new entry.
		const size_t mMaxTotalSize;

		// mTotalSize is the total combined size of all keys and values currently in
		// the cache.
		size_t mTotalSize;

		// mRandState is the pseudo-random number generator state. It is passed to
		// nrand48 to generate random numbers when needed.
		unsigned short mRandState[3];

		// mCacheEntries stores all the cache entries that are resident in memory.
		// Cache entries are added to it by the 'set' method.
		std::vector<CacheEntry> mCacheEntries;
		};

		}

		#endif // ANDROID_BLOB_CACHE_H

opengl/libs/EGL/BlobCache_test.cpp

0 → 100644

+434 −0

File added.

Preview size limit exceeded, changes collapsed.

opengl/libs/EGL/Loader.cpp

+30 −32

File changed.

Preview size limit exceeded, changes collapsed.