From 947d34ecad84bdaf496748eeb9f6e35b33deb339 Mon Sep 17 00:00:00 2001 From: Marissa Wall Date: Fri, 29 Mar 2019 14:03:53 -0700 Subject: Change slot generation for BufferState BufferState layers now do slot generation with buffer death considered appropriately. When a buffer dies, the slot will be pushed onto a stack of available slots to be reused at the next opportunity. This should mimic BufferQueue slot behavior and prevent Composer Resources from growing too large. Test: build, boot, manual Bug: 129351223 Change-Id: Icef9592593cacb0b5c6b12f6679fc2c4dabdcd19 --- services/surfaceflinger/ClientCache.cpp | 202 ++++++++++++++++++++++++++++++++ 1 file changed, 202 insertions(+) create mode 100644 services/surfaceflinger/ClientCache.cpp (limited to 'services/surfaceflinger/ClientCache.cpp') diff --git a/services/surfaceflinger/ClientCache.cpp b/services/surfaceflinger/ClientCache.cpp new file mode 100644 index 0000000000..77f2f5765c --- /dev/null +++ b/services/surfaceflinger/ClientCache.cpp @@ -0,0 +1,202 @@ +/* + * Copyright 2019 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 +#undef LOG_TAG +#define LOG_TAG "ClientCache" +#define ATRACE_TAG ATRACE_TAG_GRAPHICS + +#include + +#include "ClientCache.h" + +namespace android { + +ANDROID_SINGLETON_STATIC_INSTANCE(ClientCache); + +ClientCache::ClientCache() : mDeathRecipient(new CacheDeathRecipient) {} + +bool ClientCache::getBuffer(const client_cache_t& cacheId, + ClientCacheBuffer** outClientCacheBuffer) { + auto& [processToken, id] = cacheId; + if (processToken == nullptr) { + ALOGE("failed to get buffer, invalid (nullptr) process token"); + return false; + } + auto it = mBuffers.find(processToken); + if (it == mBuffers.end()) { + ALOGE("failed to get buffer, invalid process token"); + return false; + } + + auto& processBuffers = it->second; + + auto bufItr = processBuffers.find(id); + if (bufItr == processBuffers.end()) { + ALOGE("failed to get buffer, invalid buffer id"); + return false; + } + + ClientCacheBuffer& buf = bufItr->second; + *outClientCacheBuffer = &buf; + return true; +} + +void ClientCache::add(const client_cache_t& cacheId, const sp& buffer) { + auto& [processToken, id] = cacheId; + if (processToken == nullptr) { + ALOGE("failed to cache buffer: invalid process token"); + return; + } + + if (!buffer) { + ALOGE("failed to cache buffer: invalid buffer"); + return; + } + + std::lock_guard lock(mMutex); + sp token; + + // If this is a new process token, set a death recipient. If the client process dies, we will + // get a callback through binderDied. + auto it = mBuffers.find(processToken); + if (it == mBuffers.end()) { + token = processToken.promote(); + if (!token) { + ALOGE("failed to cache buffer: invalid token"); + return; + } + + status_t err = token->linkToDeath(mDeathRecipient); + if (err != NO_ERROR) { + ALOGE("failed to cache buffer: could not link to death"); + return; + } + auto [itr, success] = + mBuffers.emplace(processToken, std::unordered_map()); + LOG_ALWAYS_FATAL_IF(!success, "failed to insert new process into client cache"); + it = itr; + } + + auto& processBuffers = it->second; + + if (processBuffers.size() > BUFFER_CACHE_MAX_SIZE) { + ALOGE("failed to cache buffer: cache is full"); + return; + } + + processBuffers[id].buffer = buffer; +} + +void ClientCache::erase(const client_cache_t& cacheId) { + auto& [processToken, id] = cacheId; + std::vector> pendingErase; + { + std::lock_guard lock(mMutex); + ClientCacheBuffer* buf = nullptr; + if (!getBuffer(cacheId, &buf)) { + ALOGE("failed to erase buffer, could not retrieve buffer"); + return; + } + + for (auto& recipient : buf->recipients) { + sp erasedRecipient = recipient.promote(); + if (erasedRecipient) { + pendingErase.push_back(erasedRecipient); + } + } + + mBuffers[processToken].erase(id); + } + + for (auto& recipient : pendingErase) { + recipient->bufferErased(cacheId); + } +} + +sp ClientCache::get(const client_cache_t& cacheId) { + std::lock_guard lock(mMutex); + + ClientCacheBuffer* buf = nullptr; + if (!getBuffer(cacheId, &buf)) { + ALOGE("failed to get buffer, could not retrieve buffer"); + return nullptr; + } + + return buf->buffer; +} + +void ClientCache::registerErasedRecipient(const client_cache_t& cacheId, + const wp& recipient) { + std::lock_guard lock(mMutex); + + ClientCacheBuffer* buf = nullptr; + if (!getBuffer(cacheId, &buf)) { + ALOGE("failed to register erased recipient, could not retrieve buffer"); + return; + } + buf->recipients.insert(recipient); +} + +void ClientCache::unregisterErasedRecipient(const client_cache_t& cacheId, + const wp& recipient) { + std::lock_guard lock(mMutex); + + ClientCacheBuffer* buf = nullptr; + if (!getBuffer(cacheId, &buf)) { + ALOGE("failed to unregister erased recipient"); + return; + } + + buf->recipients.erase(recipient); +} + +void ClientCache::removeProcess(const wp& processToken) { + std::vector, client_cache_t>> pendingErase; + { + if (processToken == nullptr) { + ALOGE("failed to remove process, invalid (nullptr) process token"); + return; + } + std::lock_guard lock(mMutex); + auto itr = mBuffers.find(processToken); + if (itr == mBuffers.end()) { + ALOGE("failed to remove process, could not find process"); + return; + } + + for (auto& [id, clientCacheBuffer] : itr->second) { + client_cache_t cacheId = {processToken, id}; + for (auto& recipient : clientCacheBuffer.recipients) { + sp erasedRecipient = recipient.promote(); + if (erasedRecipient) { + pendingErase.emplace_back(erasedRecipient, cacheId); + } + } + } + mBuffers.erase(itr); + } + + for (auto& [recipient, cacheId] : pendingErase) { + recipient->bufferErased(cacheId); + } +} + +void ClientCache::CacheDeathRecipient::binderDied(const wp& who) { + ClientCache::getInstance().removeProcess(who); +} + +}; // namespace android -- cgit v1.2.3-59-g8ed1b