Read from BufferReleaseChannel in background thread
Bug: 294133380
Flag: com.android.graphics.libgui.flags.buffer_release_channel
Test: BLASTBufferQueueTest
Change-Id: I18d2cf5457f615e832352ff9d03729ffe82cf4b9
diff --git a/libs/gui/BLASTBufferQueue.cpp b/libs/gui/BLASTBufferQueue.cpp
index f8e3fd0..8f6dd84 100644
--- a/libs/gui/BLASTBufferQueue.cpp
+++ b/libs/gui/BLASTBufferQueue.cpp
@@ -22,11 +22,14 @@
#include <com_android_graphics_libgui_flags.h>
#include <cutils/atomic.h>
+#include <ftl/fake_guard.h>
#include <gui/BLASTBufferQueue.h>
#include <gui/BufferItemConsumer.h>
#include <gui/BufferQueueConsumer.h>
#include <gui/BufferQueueCore.h>
#include <gui/BufferQueueProducer.h>
+#include <sys/epoll.h>
+#include <sys/eventfd.h>
#include <gui/FrameRateUtils.h>
#include <gui/GLConsumer.h>
@@ -74,6 +77,12 @@
std::unique_lock _lock{mutex}; \
base::ScopedLockAssertion assumeLocked(mutex);
+#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(BUFFER_RELEASE_CHANNEL)
+static ReleaseBufferCallback EMPTY_RELEASE_CALLBACK =
+ [](const ReleaseCallbackId&, const sp<Fence>& /*releaseFence*/,
+ std::optional<uint32_t> /*currentMaxAcquiredBufferCount*/) {};
+#endif
+
void BLASTBufferItemConsumer::onDisconnect() {
Mutex::Autolock lock(mMutex);
mPreviouslyConnected = mCurrentlyConnected;
@@ -215,6 +224,12 @@
},
this);
+#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(BUFFER_RELEASE_CHANNEL)
+ std::unique_ptr<gui::BufferReleaseChannel::ConsumerEndpoint> bufferReleaseConsumer;
+ gui::BufferReleaseChannel::open(mName, bufferReleaseConsumer, mBufferReleaseProducer);
+ mBufferReleaseReader = std::make_shared<BufferReleaseReader>(std::move(bufferReleaseConsumer));
+#endif
+
BQA_LOGV("BLASTBufferQueue created");
}
@@ -244,6 +259,9 @@
void BLASTBufferQueue::onFirstRef() {
// safe default, most producers are expected to override this
mProducer->setMaxDequeuedBufferCount(2);
+#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(BUFFER_RELEASE_CHANNEL)
+ mBufferReleaseThread.start(sp<BLASTBufferQueue>::fromExisting(this));
+#endif
}
void BLASTBufferQueue::update(const sp<SurfaceControl>& surface, uint32_t width, uint32_t height,
@@ -269,6 +287,9 @@
if (surfaceControlChanged) {
t.setFlags(mSurfaceControl, layer_state_t::eEnableBackpressure,
layer_state_t::eEnableBackpressure);
+#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(BUFFER_RELEASE_CHANNEL)
+ t.setBufferReleaseChannel(mSurfaceControl, mBufferReleaseProducer);
+#endif
applyTransaction = true;
}
mTransformHint = mSurfaceControl->getTransformHint();
@@ -386,6 +407,7 @@
stat.latchTime,
stat.frameEventStats.dequeueReadyTime);
}
+#if !COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(BUFFER_RELEASE_CHANNEL)
auto currFrameNumber = stat.frameEventStats.frameNumber;
std::vector<ReleaseCallbackId> staleReleases;
for (const auto& [key, value]: mSubmitted) {
@@ -401,6 +423,7 @@
stat.currentMaxAcquiredBufferCount,
true /* fakeRelease */);
}
+#endif
} else {
BQA_LOGE("Failed to find matching SurfaceControl in transactionCallback");
}
@@ -411,6 +434,15 @@
}
}
+void BLASTBufferQueue::flushShadowQueue() {
+ BQA_LOGV("flushShadowQueue");
+ int numFramesToFlush = mNumFrameAvailable;
+ while (numFramesToFlush > 0) {
+ acquireNextBufferLocked(std::nullopt);
+ numFramesToFlush--;
+ }
+}
+
// Unlike transactionCallbackThunk the release buffer callback does not extend the life of the
// BBQ. This is because if the BBQ is destroyed, then the buffers will be released by the client.
// So we pass in a weak pointer to the BBQ and if it still alive, then we release the buffer.
@@ -428,15 +460,6 @@
};
}
-void BLASTBufferQueue::flushShadowQueue() {
- BQA_LOGV("flushShadowQueue");
- int numFramesToFlush = mNumFrameAvailable;
- while (numFramesToFlush > 0) {
- acquireNextBufferLocked(std::nullopt);
- numFramesToFlush--;
- }
-}
-
void BLASTBufferQueue::releaseBufferCallback(
const ReleaseCallbackId& id, const sp<Fence>& releaseFence,
std::optional<uint32_t> currentMaxAcquiredBufferCount) {
@@ -617,7 +640,12 @@
bufferItem.mGraphicBuffer->getHeight(), bufferItem.mTransform,
bufferItem.mScalingMode, crop);
+#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(BUFFER_RELEASE_CHANNEL)
+ ReleaseBufferCallback releaseBufferCallback =
+ applyTransaction ? EMPTY_RELEASE_CALLBACK : makeReleaseBufferCallbackThunk();
+#else
auto releaseBufferCallback = makeReleaseBufferCallbackThunk();
+#endif
sp<Fence> fence = bufferItem.mFence ? new Fence(bufferItem.mFence->dup()) : Fence::NO_FENCE;
nsecs_t dequeueTime = -1;
@@ -1359,7 +1387,120 @@
void BLASTBufferQueue::setTransactionHangCallback(
std::function<void(const std::string&)> callback) {
std::lock_guard _lock{mMutex};
- mTransactionHangCallback = callback;
+ mTransactionHangCallback = std::move(callback);
}
+#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(BUFFER_RELEASE_CHANNEL)
+
+BLASTBufferQueue::BufferReleaseReader::BufferReleaseReader(
+ std::unique_ptr<gui::BufferReleaseChannel::ConsumerEndpoint> endpoint)
+ : mEndpoint{std::move(endpoint)} {
+ mEpollFd = android::base::unique_fd{epoll_create1(0)};
+ LOG_ALWAYS_FATAL_IF(!mEpollFd.ok(),
+ "Failed to create buffer release epoll file descriptor. errno=%d "
+ "message='%s'",
+ errno, strerror(errno));
+
+ epoll_event registerEndpointFd{};
+ registerEndpointFd.events = EPOLLIN;
+ registerEndpointFd.data.fd = mEndpoint->getFd();
+ status_t status =
+ epoll_ctl(mEpollFd.get(), EPOLL_CTL_ADD, mEndpoint->getFd(), ®isterEndpointFd);
+ LOG_ALWAYS_FATAL_IF(status == -1,
+ "Failed to register buffer release consumer file descriptor with epoll. "
+ "errno=%d message='%s'",
+ errno, strerror(errno));
+
+ mEventFd = android::base::unique_fd(eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK));
+ LOG_ALWAYS_FATAL_IF(!mEventFd.ok(),
+ "Failed to create buffer release event file descriptor. errno=%d "
+ "message='%s'",
+ errno, strerror(errno));
+
+ epoll_event registerEventFd{};
+ registerEventFd.events = EPOLLIN;
+ registerEventFd.data.fd = mEventFd.get();
+ status = epoll_ctl(mEpollFd.get(), EPOLL_CTL_ADD, mEventFd.get(), ®isterEventFd);
+ LOG_ALWAYS_FATAL_IF(status == -1,
+ "Failed to register buffer release event file descriptor with epoll. "
+ "errno=%d message='%s'",
+ errno, strerror(errno));
+}
+
+BLASTBufferQueue::BufferReleaseReader& BLASTBufferQueue::BufferReleaseReader::operator=(
+ BufferReleaseReader&& other) {
+ if (this != &other) {
+ ftl::FakeGuard guard{mMutex};
+ ftl::FakeGuard otherGuard{other.mMutex};
+ mEndpoint = std::move(other.mEndpoint);
+ mEpollFd = std::move(other.mEpollFd);
+ mEventFd = std::move(other.mEventFd);
+ }
+ return *this;
+}
+
+status_t BLASTBufferQueue::BufferReleaseReader::readBlocking(ReleaseCallbackId& outId,
+ sp<Fence>& outFence,
+ uint32_t& outMaxAcquiredBufferCount) {
+ epoll_event event{};
+ while (true) {
+ int eventCount = epoll_wait(mEpollFd.get(), &event, 1 /* maxevents */, -1 /* timeout */);
+ if (eventCount == 1) {
+ break;
+ }
+ if (eventCount == -1 && errno != EINTR) {
+ ALOGE("epoll_wait error while waiting for buffer release. errno=%d message='%s'", errno,
+ strerror(errno));
+ }
+ }
+
+ if (event.data.fd == mEventFd.get()) {
+ uint64_t value;
+ if (read(mEventFd.get(), &value, sizeof(uint64_t)) == -1 && errno != EWOULDBLOCK) {
+ ALOGE("error while reading from eventfd. errno=%d message='%s'", errno,
+ strerror(errno));
+ }
+ return WOULD_BLOCK;
+ }
+
+ std::lock_guard lock{mMutex};
+ return mEndpoint->readReleaseFence(outId, outFence, outMaxAcquiredBufferCount);
+}
+
+void BLASTBufferQueue::BufferReleaseReader::interruptBlockingRead() {
+ uint64_t value = 1;
+ if (write(mEventFd.get(), &value, sizeof(uint64_t)) == -1) {
+ ALOGE("failed to notify dequeue event. errno=%d message='%s'", errno, strerror(errno));
+ }
+}
+
+void BLASTBufferQueue::BufferReleaseThread::start(const sp<BLASTBufferQueue>& bbq) {
+ mRunning = std::make_shared<std::atomic_bool>(true);
+ mReader = bbq->mBufferReleaseReader;
+ std::thread([running = mRunning, reader = mReader, weakBbq = wp<BLASTBufferQueue>(bbq)]() {
+ pthread_setname_np(pthread_self(), "BufferReleaseThread");
+ while (*running) {
+ ReleaseCallbackId id;
+ sp<Fence> fence;
+ uint32_t maxAcquiredBufferCount;
+ if (status_t status = reader->readBlocking(id, fence, maxAcquiredBufferCount);
+ status != OK) {
+ continue;
+ }
+ sp<BLASTBufferQueue> bbq = weakBbq.promote();
+ if (!bbq) {
+ return;
+ }
+ bbq->releaseBufferCallback(id, fence, maxAcquiredBufferCount);
+ }
+ }).detach();
+}
+
+BLASTBufferQueue::BufferReleaseThread::~BufferReleaseThread() {
+ *mRunning = false;
+ mReader->interruptBlockingRead();
+}
+
+#endif
+
} // namespace android