From 9051fb1885df913eecfa9072155797bdaf05d278 Mon Sep 17 00:00:00 2001 From: Vishnu Nair Date: Fri, 5 Nov 2021 16:21:06 -0700 Subject: BBQ: Clean up acquire states on BQ disconnect When the producer disconnects, all buffers in the queue will be freed. So clean up the bbq acquire state and handle any pending release callbacks. If we do get a release callback for a pending buffer for a disconnected queue, we cannot release the buffer back to the queue. So track these separately and drop the release callbacks as they come. Transaction callbacks are still expected to come in the order they were submitted regardless of buffer queue state. So we can continue to handle the pending transactions and transaction complete callbacks. When the queue is reconnected, the queue will increment the framenumbers starting from the last queued framenumber. Bug: 201482894 Test: atest BLASTBufferQueueTest Change-Id: I110530c2135804fc7b9545602dd6430014cad85c --- libs/gui/BLASTBufferQueue.cpp | 73 +++++++++++++++++++++++++++++---- libs/gui/include/gui/BLASTBufferQueue.h | 12 ++++++ 2 files changed, 78 insertions(+), 7 deletions(-) (limited to 'libs') diff --git a/libs/gui/BLASTBufferQueue.cpp b/libs/gui/BLASTBufferQueue.cpp index 9080822f92..9cb7c88956 100644 --- a/libs/gui/BLASTBufferQueue.cpp +++ b/libs/gui/BLASTBufferQueue.cpp @@ -58,13 +58,22 @@ namespace android { ALOGE("[%s](f:%u,a:%u) " x, mName.c_str(), mNumFrameAvailable, mNumAcquired, ##__VA_ARGS__) void BLASTBufferItemConsumer::onDisconnect() { - Mutex::Autolock lock(mMutex); - mPreviouslyConnected = mCurrentlyConnected; - mCurrentlyConnected = false; - if (mPreviouslyConnected) { - mDisconnectEvents.push(mCurrentFrameNumber); + { + Mutex::Autolock lock(mMutex); + mPreviouslyConnected = mCurrentlyConnected; + mCurrentlyConnected = false; + if (mPreviouslyConnected) { + mDisconnectEvents.push(mCurrentFrameNumber); + } + mFrameEventHistory.onDisconnect(); + } + + { + std::scoped_lock lock(mBufferQueueMutex); + if (mBLASTBufferQueue != nullptr) { + mBLASTBufferQueue->onProducerDisconnect(); + } } - mFrameEventHistory.onDisconnect(); } void BLASTBufferItemConsumer::addAndGetFrameTimestamps(const NewFrameEventsEntry* newTimestamps, @@ -202,7 +211,11 @@ void BLASTBufferQueue::update(const sp& surface, uint32_t width, } SurfaceComposerClient::Transaction t; - const bool setBackpressureFlag = !SurfaceControl::isSameSurface(mSurfaceControl, surface); + bool setBackpressureFlag = false; + if (!SurfaceControl::isSameSurface(mSurfaceControl, surface)) { + mSurfaceControlSwapCount++; + setBackpressureFlag = true; + } bool applyTransaction = false; // Always update the native object even though they might have the same layer handle, so we can @@ -388,6 +401,19 @@ void BLASTBufferQueue::releaseBufferCallback( std::unique_lock _lock{mMutex}; BQA_LOGV("releaseBufferCallback %s", id.to_string().c_str()); + const auto it = mFreedBuffers.find(id); + if (it != mFreedBuffers.end()) { + mFreedBuffers.erase(it); + BQA_LOGV("releaseBufferCallback ignoring freed buffer %s", id.to_string().c_str()); + return; + } + + if (mFreedBuffers.size() != 0 && mLogMissingReleaseCallback) { + BQA_LOGD("Unexpected out of order buffer release. mFreedBuffer count=%d", + static_cast(mFreedBuffers.size())); + mLogMissingReleaseCallback = false; + } + // Calculate how many buffers we need to hold before we release them back // to the buffer queue. This will prevent higher latency when we are running // on a lower refresh rate than the max supported. We only do that for EGL @@ -593,6 +619,12 @@ void BLASTBufferQueue::onFrameAvailable(const BufferItem& item) { ATRACE_CALL(); std::unique_lock _lock{mMutex}; + if ((mSurfaceControlSwapCount > mProducerDisconnectCount) && mLogScSwap) { + BQA_LOGD("Expected producer disconnect sc swap count=%d bq disconnect count=%d", + mSurfaceControlSwapCount, mProducerDisconnectCount); + mLogScSwap = false; + } + const bool nextTransactionSet = mNextTransaction != nullptr; BQA_LOGV("onFrameAvailable-start nextTransactionSet=%s", boolToString(nextTransactionSet)); if (nextTransactionSet) { @@ -959,4 +991,31 @@ uint64_t BLASTBufferQueue::getLastAcquiredFrameNum() { return mLastAcquiredFrameNumber; } +// When the producer disconnects, all buffers in the queue will be freed. So clean up the bbq +// acquire state and handle any pending release callbacks. If we do get a release callback for a +// pending buffer for a disconnected queue, we cannot release the buffer back to the queue. So track +// these separately and drop the release callbacks as they come. + +// Transaction callbacks are still expected to come in the order they were submitted regardless of +// buffer queue state. So we can continue to handles the pending transactions and transaction +// complete callbacks. When the queue is reconnected, the queue will increment the framenumbers +// starting from the last queued framenumber. +void BLASTBufferQueue::onProducerDisconnect() { + BQA_LOGV("onProducerDisconnect"); + std::scoped_lock _lock{mMutex}; + // reset counts since the queue has been disconnected and all buffers have been freed. + mNumFrameAvailable = 0; + mNumAcquired = 0; + + // Track submitted buffers in a different container so we can handle any pending release buffer + // callbacks without affecting the BBQ acquire state. + mFreedBuffers.insert(mSubmitted.begin(), mSubmitted.end()); + mSubmitted.clear(); + mPendingRelease.clear(); + mProducerDisconnectCount++; + mCallbackCV.notify_all(); + mLogMissingReleaseCallback = true; + mLogScSwap = true; +} + } // namespace android diff --git a/libs/gui/include/gui/BLASTBufferQueue.h b/libs/gui/include/gui/BLASTBufferQueue.h index 3881620f3d..72567e3f93 100644 --- a/libs/gui/include/gui/BLASTBufferQueue.h +++ b/libs/gui/include/gui/BLASTBufferQueue.h @@ -109,6 +109,8 @@ public: uint32_t getLastTransformHint() const; uint64_t getLastAcquiredFrameNum(); + void onProducerDisconnect(); + virtual ~BLASTBufferQueue(); private: @@ -156,6 +158,12 @@ private: std::unordered_map mSubmitted GUARDED_BY(mMutex); + // Keep a reference to the submitted buffers that were freed so we can drop the buffer quietly + // when we get the release callback from flinger. This can happen if the client had disconnected + // from the queue. + std::unordered_map mFreedBuffers + GUARDED_BY(mMutex); + // Keep a queue of the released buffers instead of immediately releasing // the buffers back to the buffer queue. This would be controlled by SF // setting the max acquired buffer count. @@ -240,6 +248,10 @@ private: uint32_t mCurrentMaxAcquiredBufferCount; bool mWaitForTransactionCallback = false; + bool mLogScSwap = true; + bool mLogMissingReleaseCallback = true; + uint32_t mSurfaceControlSwapCount = 0; + uint32_t mProducerDisconnectCount = 0; }; } // namespace android -- cgit v1.2.3-59-g8ed1b