1b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross/* 2b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** Copyright 2011, The Android Open Source Project 3b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** 4b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** Licensed under the Apache License, Version 2.0 (the "License"); 5b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** you may not use this file except in compliance with the License. 6b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** You may obtain a copy of the License at 7b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** 8b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** http://www.apache.org/licenses/LICENSE-2.0 9b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** 10b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** Unless required by applicable law or agreed to in writing, software 11b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** distributed under the License is distributed on an "AS IS" BASIS, 12b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** See the License for the specific language governing permissions and 14b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** limitations under the License. 15b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross */ 16b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 17b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross//#define LOG_NDEBUG 0 18b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 19b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#include "BlobCache.h" 20b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 2159572bdc906880f9b03aa8abd4e2d2095a012538David Gross#include <errno.h> 22b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#include <inttypes.h> 23b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 2459572bdc906880f9b03aa8abd4e2d2095a012538David Gross#if defined(__ANDROID__) 25b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#include <cutils/properties.h> 2659572bdc906880f9b03aa8abd4e2d2095a012538David Gross#else 2759572bdc906880f9b03aa8abd4e2d2095a012538David Gross#include <string.h> 2859572bdc906880f9b03aa8abd4e2d2095a012538David Gross#include <algorithm> 2959572bdc906880f9b03aa8abd4e2d2095a012538David Grossstatic const char property_value[] = "[HOST]"; 3059572bdc906880f9b03aa8abd4e2d2095a012538David Gross#define PROPERTY_VALUE_MAX (sizeof(property_value) - 1) 3159572bdc906880f9b03aa8abd4e2d2095a012538David Grossstatic int property_get(const char *key, char *value, const char *default_value) { 32341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross if (!strcmp(key, "ro.build.id")) { 33341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross memcpy(value, property_value, PROPERTY_VALUE_MAX); 34341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return PROPERTY_VALUE_MAX; 35341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross } 36341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross if (default_value) { 37341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross const size_t len = std::max(strlen(default_value) + 1, size_t(PROPERTY_VALUE_MAX)); 38341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross memcpy(value, default_value, len); 39341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross } 40341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return 0; 4159572bdc906880f9b03aa8abd4e2d2095a012538David Gross} 4259572bdc906880f9b03aa8abd4e2d2095a012538David Gross#endif 4359572bdc906880f9b03aa8abd4e2d2095a012538David Gross 44b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#include <log/log.h> 45341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross 46341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross#include <algorithm> 47b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#include <chrono> 48b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 49b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossnamespace android { 50b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 51b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross// BlobCache::Header::mMagicNumber value 52b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstatic const uint32_t blobCacheMagic = ('_' << 24) + ('B' << 16) + ('b' << 8) + '$'; 53b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 54b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross// BlobCache::Header::mBlobCacheVersion value 55b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstatic const uint32_t blobCacheVersion = 3; 56b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 57b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross// BlobCache::Header::mDeviceVersion value 58b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstatic const uint32_t blobCacheDeviceVersion = 1; 59b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 60341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David GrossBlobCache::BlobCache(size_t maxKeySize, size_t maxValueSize, size_t maxTotalSize, Policy policy): 61b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mMaxKeySize(maxKeySize), 62b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mMaxValueSize(maxValueSize), 63b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mMaxTotalSize(maxTotalSize), 64341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross mPolicySelect(policy.first), 65341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross mPolicyCapacity(policy.second), 66341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross mTotalSize(0), 67341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross mAccessCount(0) { 68b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross int64_t now = std::chrono::steady_clock::now().time_since_epoch().count(); 69b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#ifdef _WIN32 70b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross srand(now); 71b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#else 72b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mRandState[0] = (now >> 0) & 0xFFFF; 73b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mRandState[1] = (now >> 16) & 0xFFFF; 74b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mRandState[2] = (now >> 32) & 0xFFFF; 75b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#endif 76b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("initializing random seed using %lld", (unsigned long long)now); 77b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 78b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 79b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossvoid BlobCache::set(const void* key, size_t keySize, const void* value, 80b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t valueSize) { 81b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mMaxKeySize < keySize) { 82b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("set: not caching because the key is too large: %zu (limit: %zu)", 83b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross keySize, mMaxKeySize); 84b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return; 85b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 86b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mMaxValueSize < valueSize) { 87b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("set: not caching because the value is too large: %zu (limit: %zu)", 88b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross valueSize, mMaxValueSize); 89b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return; 90b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 91b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mMaxTotalSize < keySize + valueSize) { 92b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("set: not caching because the combined key/value size is too " 93b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross "large: %zu (limit: %zu)", keySize + valueSize, mMaxTotalSize); 94b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return; 95b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 96b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (keySize == 0) { 97b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGW("set: not caching because keySize is 0"); 98b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return; 99b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 100b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (valueSize <= 0) { 101b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGW("set: not caching because valueSize is 0"); 102b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return; 103b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 104b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 105b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> dummyKey(new Blob(key, keySize, false)); 106341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross CacheEntry dummyEntry(dummyKey, NULL, 0); 107b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 108b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross while (true) { 109b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross auto index = std::lower_bound(mCacheEntries.begin(), mCacheEntries.end(), dummyEntry); 110b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (index == mCacheEntries.end() || dummyEntry < *index) { 111b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Create a new cache entry. 112b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> keyBlob(new Blob(key, keySize, true)); 113b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> valueBlob(new Blob(value, valueSize, true)); 114341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross size_t newEntrySize = keySize + valueSize; 115341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross size_t newTotalSize = mTotalSize + newEntrySize; 116b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mMaxTotalSize < newTotalSize) { 117b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (isCleanable()) { 118b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Clean the cache and try again. 119341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross if (!clean(newEntrySize, NoEntry)) { 120341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross // We have some kind of logic error -- perhaps 121341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross // an inconsistency between isCleanable() and 122341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross // findDownTo(). 123341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross ALOGE("set: not caching new key/value pair because " 124341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross "cleaning failed"); 125341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross break; 126341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross } 127b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross continue; 128b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } else { 129b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("set: not caching new key/value pair because the " 130b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross "total cache size limit would be exceeded: %zu " 131b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross "(limit: %zu)", 132b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross keySize + valueSize, mMaxTotalSize); 133b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross break; 134b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 135b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 136341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross mCacheEntries.insert(index, CacheEntry(keyBlob, valueBlob, ++mAccessCount)); 137b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mTotalSize = newTotalSize; 138b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("set: created new cache entry with %zu byte key and %zu byte value", 139b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross keySize, valueSize); 140b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } else { 141b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Update the existing cache entry. 142b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> valueBlob(new Blob(value, valueSize, true)); 143b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> oldValueBlob(index->getValue()); 144b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t newTotalSize = mTotalSize + valueSize - oldValueBlob->getSize(); 145b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mMaxTotalSize < newTotalSize) { 146b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (isCleanable()) { 147b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Clean the cache and try again. 148341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross if (!clean(index->getKey()->getSize() + valueSize, 149341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross index - mCacheEntries.begin())) { 150341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross // We have some kind of logic error -- perhaps 151341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross // an inconsistency between isCleanable() and 152341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross // findDownTo(). 153341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross ALOGE("set: not caching new value because " 154341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross "cleaning failed"); 155341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross break; 156341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross } 157b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross continue; 158b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } else { 159b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("set: not caching new value because the total cache " 160b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross "size limit would be exceeded: %zu (limit: %zu)", 161b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross keySize + valueSize, mMaxTotalSize); 162b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross break; 163b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 164b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 165b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross index->setValue(valueBlob); 166341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross index->setRecency(++mAccessCount); 167b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mTotalSize = newTotalSize; 168b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("set: updated existing cache entry with %zu byte key and %zu byte " 169b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross "value", keySize, valueSize); 170b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 171b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross break; 172b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 173b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 174b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 175b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grosssize_t BlobCache::get(const void* key, size_t keySize, void* value, 176b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t valueSize) { 17779c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross void *dummy; 17879c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross return get(key, keySize, &dummy, 17979c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross [value, valueSize](size_t allocSize) { 18079c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross return (allocSize <= valueSize ? value : nullptr); 18179c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross }); 18279c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross} 18379c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross 18479c0b79406117a800ed4dd965b3d329cdc8903ffDavid Grosssize_t BlobCache::get(const void* key, size_t keySize, void** value, 18579c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross std::function<void*(size_t)> alloc) { 186b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mMaxKeySize < keySize) { 187b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("get: not searching because the key is too large: %zu (limit %zu)", 188b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross keySize, mMaxKeySize); 18979c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross *value = nullptr; 190b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 191b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 192b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> dummyKey(new Blob(key, keySize, false)); 193341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross CacheEntry dummyEntry(dummyKey, NULL, 0); 194b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross auto index = std::lower_bound(mCacheEntries.begin(), mCacheEntries.end(), dummyEntry); 195b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (index == mCacheEntries.end() || dummyEntry < *index) { 196b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("get: no cache entry found for key of size %zu", keySize); 19779c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross *value = nullptr; 198b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 199b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 200b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 20179c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross // The key was found. Return the value if we can allocate a buffer. 202b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> valueBlob(index->getValue()); 203b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t valueBlobSize = valueBlob->getSize(); 20479c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross void *buf = alloc(valueBlobSize); 20579c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross if (buf != nullptr) { 206b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("get: copying %zu bytes to caller's buffer", valueBlobSize); 20779c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross memcpy(buf, valueBlob->getData(), valueBlobSize); 20879c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross *value = buf; 209341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross index->setRecency(++mAccessCount); 210b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } else { 21179c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross ALOGV("get: cannot allocate caller's buffer: needs %zu", valueBlobSize); 21279c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross *value = nullptr; 213b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 214b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return valueBlobSize; 215b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 216b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 217b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstatic inline size_t align4(size_t size) { 218b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return (size + 3) & ~3; 219b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 220b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 221b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grosssize_t BlobCache::getFlattenedSize() const { 222b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t size = align4(sizeof(Header) + PROPERTY_VALUE_MAX); 223b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross for (const CacheEntry& e : mCacheEntries) { 224b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> const& keyBlob = e.getKey(); 225b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> const& valueBlob = e.getValue(); 226b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size += align4(sizeof(EntryHeader) + keyBlob->getSize() + valueBlob->getSize()); 227b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 228b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return size; 229b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 230b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 231b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossint BlobCache::flatten(void* buffer, size_t size) const { 232b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Write the cache header 233b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (size < sizeof(Header)) { 234b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGE("flatten: not enough room for cache header"); 235b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 236b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 237b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross Header* header = reinterpret_cast<Header*>(buffer); 238b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mMagicNumber = blobCacheMagic; 239b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mBlobCacheVersion = blobCacheVersion; 240b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mDeviceVersion = blobCacheDeviceVersion; 241b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mNumEntries = mCacheEntries.size(); 242b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross char buildId[PROPERTY_VALUE_MAX]; 243b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mBuildIdLength = property_get("ro.build.id", buildId, ""); 244b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memcpy(header->mBuildId, buildId, header->mBuildIdLength); 245b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 246b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Write cache entries 247b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross uint8_t* byteBuffer = reinterpret_cast<uint8_t*>(buffer); 248b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross off_t byteOffset = align4(sizeof(Header) + header->mBuildIdLength); 249b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross for (const CacheEntry& e : mCacheEntries) { 250b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> const& keyBlob = e.getKey(); 251b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> const& valueBlob = e.getValue(); 252b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t keySize = keyBlob->getSize(); 253b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t valueSize = valueBlob->getSize(); 254b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 255b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t entrySize = sizeof(EntryHeader) + keySize + valueSize; 256b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t totalSize = align4(entrySize); 257b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (byteOffset + totalSize > size) { 258b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGE("flatten: not enough room for cache entries"); 259b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 260b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 261b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 262b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross EntryHeader* eheader = reinterpret_cast<EntryHeader*>(&byteBuffer[byteOffset]); 263b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross eheader->mKeySize = keySize; 264b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross eheader->mValueSize = valueSize; 265b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 266b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memcpy(eheader->mData, keyBlob->getData(), keySize); 267b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memcpy(eheader->mData + keySize, valueBlob->getData(), valueSize); 268b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 269b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (totalSize > entrySize) { 270b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // We have padding bytes. Those will get written to storage, and contribute to the CRC, 271b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // so make sure we zero-them to have reproducible results. 272b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memset(eheader->mData + keySize + valueSize, 0, totalSize - entrySize); 273b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 274b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 275b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross byteOffset += totalSize; 276b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 277b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 278b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 279b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 280b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 281b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossint BlobCache::unflatten(void const* buffer, size_t size) { 282b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // All errors should result in the BlobCache being in an empty state. 283b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mCacheEntries.clear(); 284b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 285b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Read the cache header 286b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (size < sizeof(Header)) { 287b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGE("unflatten: not enough room for cache header"); 288b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 289b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 290b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const Header* header = reinterpret_cast<const Header*>(buffer); 291b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (header->mMagicNumber != blobCacheMagic) { 292b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGE("unflatten: bad magic number: %" PRIu32, header->mMagicNumber); 293b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 294b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 295b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross char buildId[PROPERTY_VALUE_MAX]; 296b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross int len = property_get("ro.build.id", buildId, ""); 297b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (header->mBlobCacheVersion != blobCacheVersion || 298b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mDeviceVersion != blobCacheDeviceVersion || 299b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross len != header->mBuildIdLength || 300b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross strncmp(buildId, header->mBuildId, len)) { 301b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // We treat version mismatches as an empty cache. 302b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 303b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 304b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 305b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Read cache entries 306b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const uint8_t* byteBuffer = reinterpret_cast<const uint8_t*>(buffer); 307b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross off_t byteOffset = align4(sizeof(Header) + header->mBuildIdLength); 308b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t numEntries = header->mNumEntries; 309b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross for (size_t i = 0; i < numEntries; i++) { 310b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (byteOffset + sizeof(EntryHeader) > size) { 311b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mCacheEntries.clear(); 31259572bdc906880f9b03aa8abd4e2d2095a012538David Gross ALOGE("unflatten: not enough room for cache entry header"); 313b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 314b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 315b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 316b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const EntryHeader* eheader = reinterpret_cast<const EntryHeader*>( 317b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross &byteBuffer[byteOffset]); 318b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t keySize = eheader->mKeySize; 319b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t valueSize = eheader->mValueSize; 320b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t entrySize = sizeof(EntryHeader) + keySize + valueSize; 321b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 322b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t totalSize = align4(entrySize); 323b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (byteOffset + totalSize > size) { 324b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mCacheEntries.clear(); 32559572bdc906880f9b03aa8abd4e2d2095a012538David Gross ALOGE("unflatten: not enough room for cache entry"); 326b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 327b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 328b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 329b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const uint8_t* data = eheader->mData; 330b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross set(data, keySize, data + keySize, valueSize); 331b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 332b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross byteOffset += totalSize; 333b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 334b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 335b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 336b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 337b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 338b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grosslong int BlobCache::blob_random() { 339b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#ifdef _WIN32 340b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return rand(); 341b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#else 342b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return nrand48(mRandState); 343b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#endif 344b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 345b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 346341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Grosssize_t BlobCache::findVictim() { 347341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross switch (mPolicySelect) { 348341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross case Select::RANDOM: 349341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return size_t(blob_random() % (mCacheEntries.size())); 350341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross case Select::LRU: 351341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return std::min_element(mCacheEntries.begin(), mCacheEntries.end(), 352341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross [](const CacheEntry &a, const CacheEntry &b) { 353341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return a.getRecency() < b.getRecency(); 354341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross }) - mCacheEntries.begin(); 355341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross default: 356341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross ALOGE("findVictim: unknown mPolicySelect: %d", mPolicySelect); 357341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return 0; 358341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross } 359341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross} 360341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross 361341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Grosssize_t BlobCache::findDownTo(size_t newEntrySize, size_t onBehalfOf) { 362341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross auto oldEntrySize = [this, onBehalfOf]() -> size_t { 363341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross if (onBehalfOf == NoEntry) 364341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return 0; 365341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross const auto &entry = mCacheEntries[onBehalfOf]; 366341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return entry.getKey()->getSize() + entry.getValue()->getSize(); 367341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross }; 368341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross switch (mPolicyCapacity) { 369341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross case Capacity::HALVE: 370341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return mMaxTotalSize / 2; 371341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross case Capacity::FIT: 372341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return mMaxTotalSize - (newEntrySize - oldEntrySize()); 373341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross case Capacity::FIT_HALVE: 374341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return std::min(mMaxTotalSize - (newEntrySize - oldEntrySize()), mMaxTotalSize / 2); 375341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross default: 376341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross ALOGE("findDownTo: unknown mPolicyCapacity: %d", mPolicyCapacity); 377341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return 0; 378341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross } 379341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross} 380341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross 381341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Grossbool BlobCache::isFit(Capacity capacity) { 382341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross switch (capacity) { 383341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross case Capacity::HALVE: 384341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return false; 385341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross case Capacity::FIT: 386341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross case Capacity::FIT_HALVE: 387341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return true; 388341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross default: 389341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross ALOGE("isFit: unknown capacity: %d", capacity); 390341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return false; 391341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross } 392341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross} 393341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross 394341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Grossbool BlobCache::clean(size_t newEntrySize, size_t onBehalfOf) { 395341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross // Remove a selected cache entry until the total cache size does 396341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross // not exceed downTo. 397341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross const size_t downTo = findDownTo(newEntrySize, onBehalfOf); 398341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross 399341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross bool cleaned = false; 400341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross while (mTotalSize > downTo) { 401341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross const size_t i = findVictim(); 402b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const CacheEntry& entry(mCacheEntries[i]); 403341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross const size_t entrySize = entry.getKey()->getSize() + entry.getValue()->getSize(); 404341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross mTotalSize -= entrySize; 405b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mCacheEntries.erase(mCacheEntries.begin() + i); 406341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross cleaned = true; 407b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 408341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return cleaned; 409b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 410b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 411b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossbool BlobCache::isCleanable() const { 412341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross switch (mPolicyCapacity) { 413341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross case Capacity::HALVE: 414341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return mTotalSize > mMaxTotalSize / 2; 415341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross default: 416341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross ALOGE("isCleanable: unknown mPolicyCapacity: %d", mPolicyCapacity); 417341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross // and fall through 418341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross case Capacity::FIT: 419341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross case Capacity::FIT_HALVE: 420341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return mTotalSize > 0; 421341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross } 422b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 423b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 424b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::Blob::Blob(const void* data, size_t size, bool copyData) : 425b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mData(copyData ? malloc(size) : data), 426b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mSize(size), 427b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mOwnsData(copyData) { 428b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (data != NULL && copyData) { 429b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memcpy(const_cast<void*>(mData), data, size); 430b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 431b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 432b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 433b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::Blob::~Blob() { 434b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mOwnsData) { 435b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross free(const_cast<void*>(mData)); 436b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 437b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 438b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 439b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossbool BlobCache::Blob::operator<(const Blob& rhs) const { 440b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mSize == rhs.mSize) { 441b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return memcmp(mData, rhs.mData, mSize) < 0; 442b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } else { 443b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mSize < rhs.mSize; 444b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 445b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 446b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 447b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossconst void* BlobCache::Blob::getData() const { 448b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mData; 449b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 450b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 451b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grosssize_t BlobCache::Blob::getSize() const { 452b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mSize; 453b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 454b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 455341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David GrossBlobCache::CacheEntry::CacheEntry(): mRecency(0) { 456b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 457b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 458b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::CacheEntry::CacheEntry( 459341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross const std::shared_ptr<Blob>& key, const std::shared_ptr<Blob>& value, uint32_t recency): 460b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mKey(key), 461341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross mValue(value), 462341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross mRecency(recency) { 463b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 464b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 465b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::CacheEntry::CacheEntry(const CacheEntry& ce): 466b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mKey(ce.mKey), 467341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross mValue(ce.mValue), 468341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross mRecency(ce.mRecency) { 469b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 470b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 471b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossbool BlobCache::CacheEntry::operator<(const CacheEntry& rhs) const { 472b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return *mKey < *rhs.mKey; 473b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 474b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 475b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossconst BlobCache::CacheEntry& BlobCache::CacheEntry::operator=(const CacheEntry& rhs) { 476b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mKey = rhs.mKey; 477b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mValue = rhs.mValue; 478341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross mRecency = rhs.mRecency; 479b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return *this; 480b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 481b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 482b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstd::shared_ptr<BlobCache::Blob> BlobCache::CacheEntry::getKey() const { 483b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mKey; 484b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 485b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 486b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstd::shared_ptr<BlobCache::Blob> BlobCache::CacheEntry::getValue() const { 487b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mValue; 488b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 489b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 490b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossvoid BlobCache::CacheEntry::setValue(const std::shared_ptr<Blob>& value) { 491b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mValue = value; 492b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 493b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 494341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Grossuint32_t BlobCache::CacheEntry::getRecency() const { 495341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross return mRecency; 496341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross} 497341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross 498341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Grossvoid BlobCache::CacheEntry::setRecency(uint32_t recency) { 499341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross mRecency = recency; 500341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross} 501341dfdb8e78fdbaca6e2f9aa11d31107c635fc80David Gross 502b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} // namespace android 503