Snap for 5749680 from 74d87f731e55d0241b0b6d098ac5161ca42887d1 to qt-qpr1-release (9c8dc61f) · Commits · e / os / platform_frameworks_native

libs/gui/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -34,6 +34,7 @@ cc_library_shared {
		"BufferItemConsumer.cpp",
		"ConsumerBase.cpp",
		"CpuConsumer.cpp",
		"DebugEGLImageTracker.cpp",
		"DisplayEventReceiver.cpp",
		"GLConsumer.cpp",
		"GuiConfig.cpp",

libs/gui/DebugEGLImageTracker.cpp

0 → 100644

+98 −0

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

		#include <android-base/stringprintf.h>
		#include <cutils/properties.h>
		#include <gui/DebugEGLImageTracker.h>

		#include <cinttypes>
		#include <unordered_map>

		using android::base::StringAppendF;

		std::mutex DebugEGLImageTracker::mInstanceLock;
		std::atomic<DebugEGLImageTracker *> DebugEGLImageTracker::mInstance;

		class DebugEGLImageTrackerNoOp : public DebugEGLImageTracker {
		public:
		DebugEGLImageTrackerNoOp() = default;
		~DebugEGLImageTrackerNoOp() override = default;
		void create(const char * /from/) override {}
		void destroy(const char * /from/) override {}

		void dump(std::string & /result/) override {}
		};

		class DebugEGLImageTrackerImpl : public DebugEGLImageTracker {
		public:
		DebugEGLImageTrackerImpl() = default;
		~DebugEGLImageTrackerImpl() override = default;
		void create(const char * /from/) override;
		void destroy(const char * /from/) override;

		void dump(std::string & /result/) override;

		private:
		std::mutex mLock;
		std::unordered_map<std::string, int64_t> mCreateTracker;
		std::unordered_map<std::string, int64_t> mDestroyTracker;

		int64_t mTotalCreated = 0;
		int64_t mTotalDestroyed = 0;
		};

		DebugEGLImageTracker *DebugEGLImageTracker::getInstance() {
		std::lock_guard lock(mInstanceLock);
		if (mInstance == nullptr) {
		char value[PROPERTY_VALUE_MAX];
		property_get("debug.sf.enable_egl_image_tracker", value, "0");
		const bool enabled = static_cast<bool>(atoi(value));

		if (enabled) {
		mInstance = new DebugEGLImageTrackerImpl();
		} else {
		mInstance = new DebugEGLImageTrackerNoOp();
		}
		}

		return mInstance;
		}

		void DebugEGLImageTrackerImpl::create(const char *from) {
		std::lock_guard lock(mLock);
		mCreateTracker[from]++;
		mTotalCreated++;
		}

		void DebugEGLImageTrackerImpl::destroy(const char *from) {
		std::lock_guard lock(mLock);
		mDestroyTracker[from]++;
		mTotalDestroyed++;
		}

		void DebugEGLImageTrackerImpl::dump(std::string &result) {
		std::lock_guard lock(mLock);
		StringAppendF(&result, "Live EGL Image objects: %" PRIi64 "\n",
		mTotalCreated - mTotalDestroyed);
		StringAppendF(&result, "Total EGL Image created: %" PRIi64 "\n", mTotalCreated);
		for (const auto &[from, count] : mCreateTracker) {
		StringAppendF(&result, "\t%s: %" PRIi64 "\n", from.c_str(), count);
		}
		StringAppendF(&result, "Total EGL Image destroyed: %" PRIi64 "\n", mTotalDestroyed);
		for (const auto &[from, count] : mDestroyTracker) {
		StringAppendF(&result, "\t%s: %" PRIi64 "\n", from.c_str(), count);
		}
		}

libs/gui/GLConsumer.cpp

+6 −0

Original line number	Diff line number	Diff line
		@@ -34,6 +34,7 @@
		#include <math/mat4.h>

		#include <gui/BufferItem.h>
		#include <gui/DebugEGLImageTracker.h>
		#include <gui/GLConsumer.h>
		#include <gui/ISurfaceComposer.h>
		#include <gui/SurfaceComposerClient.h>
		@@ -944,6 +945,7 @@ GLConsumer::EglImage::~EglImage() {
		if (!eglDestroyImageKHR(mEglDisplay, mEglImage)) {
		ALOGE("~EglImage: eglDestroyImageKHR failed");
		}
		DEBUG_EGL_IMAGE_TRACKER_DESTROY();
		eglTerminate(mEglDisplay);
		}
		}
		@@ -957,6 +959,7 @@ status_t GLConsumer::EglImage::createIfNeeded(EGLDisplay eglDisplay,
		if (!eglDestroyImageKHR(mEglDisplay, mEglImage)) {
		ALOGE("createIfNeeded: eglDestroyImageKHR failed");
		}
		DEBUG_EGL_IMAGE_TRACKER_DESTROY();
		eglTerminate(mEglDisplay);
		mEglImage = EGL_NO_IMAGE_KHR;
		mEglDisplay = EGL_NO_DISPLAY;
		@@ -1006,7 +1009,10 @@ EGLImageKHR GLConsumer::EglImage::createImage(EGLDisplay dpy,
		EGLint error = eglGetError();
		ALOGE("error creating EGLImage: %#x", error);
		eglTerminate(dpy);
		} else {
		DEBUG_EGL_IMAGE_TRACKER_CREATE();
		}

		return image;
		}

libs/gui/include/gui/DebugEGLImageTracker.h

0 → 100644

+44 −0

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

		#pragma once

		#include <atomic>
		#include <mutex>
		#include <string>

		class DebugEGLImageTracker {
		public:
		static DebugEGLImageTracker *getInstance();

		virtual void create(const char *from) = 0;
		virtual void destroy(const char *from) = 0;

		virtual void dump(std::string &result) = 0;

		protected:
		DebugEGLImageTracker() = default;
		virtual ~DebugEGLImageTracker() = default;
		DebugEGLImageTracker(const DebugEGLImageTracker &) = delete;

		static std::mutex mInstanceLock;
		static std::atomic<DebugEGLImageTracker *> mInstance;
		};

		#define DEBUG_EGL_IMAGE_TRACKER_CREATE() \
		(DebugEGLImageTracker::getInstance()->create(__PRETTY_FUNCTION__))
		#define DEBUG_EGL_IMAGE_TRACKER_DESTROY() \
		(DebugEGLImageTracker::getInstance()->destroy(__PRETTY_FUNCTION__))
		No newline at end of file

libs/renderengine/gl/GLESRenderEngine.cpp

+27 −1

Original line number	Diff line number	Diff line
		@@ -31,6 +31,7 @@
		#include <android-base/stringprintf.h>
		#include <cutils/compiler.h>
		#include <cutils/properties.h>
		#include <gui/DebugEGLImageTracker.h>
		#include <renderengine/Mesh.h>
		#include <renderengine/Texture.h>
		#include <renderengine/private/Description.h>
		@@ -433,6 +434,7 @@ GLESRenderEngine::~GLESRenderEngine() {
		EGLImageKHR expired = mFramebufferImageCache.front().second;
		mFramebufferImageCache.pop_front();
		eglDestroyImageKHR(mEGLDisplay, expired);
		DEBUG_EGL_IMAGE_TRACKER_DESTROY();
		}
		mImageCache.clear();
		eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
		@@ -846,6 +848,7 @@ EGLImageKHR GLESRenderEngine::createFramebufferImageIfNeeded(ANativeWindowBuffer
		bool useFramebufferCache) {
		sp<GraphicBuffer> graphicBuffer = GraphicBuffer::from(nativeBuffer);
		if (useFramebufferCache) {
		std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex);
		for (const auto& image : mFramebufferImageCache) {
		if (image.first == graphicBuffer->getId()) {
		return image.second;
		@@ -861,14 +864,20 @@ EGLImageKHR GLESRenderEngine::createFramebufferImageIfNeeded(ANativeWindowBuffer
		nativeBuffer, attributes);
		if (useFramebufferCache) {
		if (image != EGL_NO_IMAGE_KHR) {
		std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex);
		if (mFramebufferImageCache.size() >= mFramebufferImageCacheSize) {
		EGLImageKHR expired = mFramebufferImageCache.front().second;
		mFramebufferImageCache.pop_front();
		eglDestroyImageKHR(mEGLDisplay, expired);
		DEBUG_EGL_IMAGE_TRACKER_DESTROY();
		}
		mFramebufferImageCache.push_back({graphicBuffer->getId(), image});
		}
		}

		if (image != EGL_NO_IMAGE_KHR) {
		DEBUG_EGL_IMAGE_TRACKER_CREATE();
		}
		return image;
		}

		@@ -1306,6 +1315,23 @@ void GLESRenderEngine::dump(std::string& result) {
		StringAppendF(&result, "RenderEngine last dataspace conversion: (%s) to (%s)\n",
		dataspaceDetails(static_cast<android_dataspace>(mDataSpace)).c_str(),
		dataspaceDetails(static_cast<android_dataspace>(mOutputDataSpace)).c_str());
		{
		std::lock_guard<std::mutex> lock(mRenderingMutex);
		StringAppendF(&result, "RenderEngine image cache size: %zu\n", mImageCache.size());
		StringAppendF(&result, "Dumping buffer ids...\n");
		for (const auto& [id, unused] : mImageCache) {
		StringAppendF(&result, "0x%" PRIx64 "\n", id);
		}
		}
		{
		std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex);
		StringAppendF(&result, "RenderEngine framebuffer image cache size: %zu\n",
		mFramebufferImageCache.size());
		StringAppendF(&result, "Dumping buffer ids...\n");
		for (const auto& [id, unused] : mFramebufferImageCache) {
		StringAppendF(&result, "0x%" PRIx64 "\n", id);
		}
		}
		}

		GLESRenderEngine::GlesVersion GLESRenderEngine::parseGlesVersion(const char* str) {
		@@ -1432,7 +1458,7 @@ bool GLESRenderEngine::isImageCachedForTesting(uint64_t bufferId) {
		}

		bool GLESRenderEngine::isFramebufferImageCachedForTesting(uint64_t bufferId) {
		std::lock_guard<std::mutex> lock(mRenderingMutex);
		std::lock_guard<std::mutex> lock(mFramebufferImageCacheMutex);
		return std::any_of(mFramebufferImageCache.cbegin(), mFramebufferImageCache.cend(),
		[=](std::pair<uint64_t, EGLImageKHR> image) {
		return image.first == bufferId;