more debugging tools around BufferMapper (af9a5152) · Commits · e / os / android_frameworks_base

include/ui/BufferMapper.h

+14 −0

Original line number	Diff line number	Diff line
		@@ -19,8 +19,11 @@

		#include <stdint.h>
		#include <sys/types.h>

		#include <utils/CallStack.h>
		#include <utils/threads.h>
		#include <utils/Singleton.h>
		#include <utils/KeyedVector.h>

		#include <hardware/gralloc.h>

		@@ -42,11 +45,22 @@ public:
		status_t lock(buffer_handle_t handle, int usage, const Rect& bounds);
		status_t unlock(buffer_handle_t handle);

		// dumps information about the mapping of this handle
		void dump(buffer_handle_t handle);

		private:
		friend class Singleton<BufferMapper>;
		BufferMapper();
		mutable Mutex mLock;
		gralloc_module_t const *mAllocMod;

		struct map_info_t {
		int count;
		KeyedVector<CallStack, int> callstacks;
		};
		KeyedVector<buffer_handle_t, map_info_t> mMapInfo;
		void logMapLocked(buffer_handle_t handle);
		void logUnmapLocked(buffer_handle_t handle);
		};

		// ---------------------------------------------------------------------------

libs/surfaceflinger/BufferAllocator.cpp

+8 −8

Original line number	Diff line number	Diff line
		@@ -105,10 +105,12 @@ status_t BufferAllocator::free(buffer_handle_t handle)
		Mutex::Autolock _l(mLock);

		#if ANDROID_GRALLOC_DEBUG
		if (handle->data[2]) {
		void* base = (void*)(handle->data[2]);
		if (base) {
		CallStack s;
		s.update();
		s.dump("");
		BufferMapper::get().dump(handle);
		}
		#endif

		@@ -143,9 +145,7 @@ status_t BufferAllocator::unmap(buffer_handle_t handle)
		{
		Mutex::Autolock _l(mLock);
		gralloc_module_t* mod = (gralloc_module_t*)mAllocDev->common.module;
		status_t err = mod->unmap(mod, handle);
		LOGW_IF(err, "unmap(...) failed %d (%s)", err, strerror(-err));

		status_t err = BufferMapper::get().unmap(handle);
		if (err == NO_ERROR) {
		Mutex::Autolock _l(sLock);
		KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList);

libs/surfaceflinger/LayerBitmap.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -81,7 +81,7 @@ public:
		private:
		friend class LightRefBase<Buffer>;
		Buffer(const Buffer& rhs);
		~Buffer();
		virtual ~Buffer();
		Buffer& operator = (const Buffer& rhs);
		const Buffer& operator = (const Buffer& rhs) const;

libs/ui/BufferMapper.cpp

+78 −0

Original line number	Diff line number	Diff line
		@@ -34,6 +34,13 @@

		#include <hardware/gralloc.h>

		// ---------------------------------------------------------------------------
		// enable mapping debugging
		#define DEBUG_MAPPINGS 1
		// never remove mappings from the list
		#define DEBUG_MAPPINGS_KEEP_ALL 1
		// ---------------------------------------------------------------------------

		namespace android {
		// ---------------------------------------------------------------------------

		@@ -53,6 +60,10 @@ status_t BufferMapper::map(buffer_handle_t handle, void** addr)
		Mutex::Autolock _l(mLock);
		status_t err = mAllocMod->map(mAllocMod, handle, addr);
		LOGW_IF(err, "map(...) failed %d (%s)", err, strerror(-err));
		#if DEBUG_MAPPINGS
		if (err == NO_ERROR)
		logMapLocked(handle);
		#endif
		return err;
		}

		@@ -61,6 +72,10 @@ status_t BufferMapper::unmap(buffer_handle_t handle)
		Mutex::Autolock _l(mLock);
		status_t err = mAllocMod->unmap(mAllocMod, handle);
		LOGW_IF(err, "unmap(...) failed %d (%s)", err, strerror(-err));
		#if DEBUG_MAPPINGS
		if (err == NO_ERROR)
		logUnmapLocked(handle);
		#endif
		return err;
		}

		@@ -79,5 +94,68 @@ status_t BufferMapper::unlock(buffer_handle_t handle)
		return err;
		}

		void BufferMapper::logMapLocked(buffer_handle_t handle)
		{
		CallStack stack;
		stack.update(2);

		map_info_t info;
		ssize_t index = mMapInfo.indexOfKey(handle);
		if (index >= 0) {
		info = mMapInfo.valueAt(index);
		}

		ssize_t stackIndex = info.callstacks.indexOfKey(stack);
		if (stackIndex >= 0) {
		info.callstacks.editValueAt(stackIndex) += 1;
		} else {
		info.callstacks.add(stack, 1);
		}

		if (index < 0) {
		info.count = 1;
		mMapInfo.add(handle, info);
		} else {
		info.count++;
		mMapInfo.replaceValueAt(index, info);
		}
		}

		void BufferMapper::logUnmapLocked(buffer_handle_t handle)
		{
		ssize_t index = mMapInfo.indexOfKey(handle);
		if (index < 0) {
		LOGE("unmapping %p which doesn't exist!", handle);
		return;
		}

		map_info_t& info = mMapInfo.editValueAt(index);
		info.count--;
		if (info.count == 0) {
		#if DEBUG_MAPPINGS_KEEP_ALL
		info.callstacks.clear();
		#else
		mMapInfo.removeItemsAt(index, 1);
		#endif
		}
		}

		void BufferMapper::dump(buffer_handle_t handle)
		{
		Mutex::Autolock _l(mLock);
		ssize_t index = mMapInfo.indexOfKey(handle);
		if (index < 0) {
		LOGD("handle %p is not mapped through BufferMapper", handle);
		return;
		}

		const map_info_t& info = mMapInfo.valueAt(index);
		LOGD("dumping buffer_handle_t %p mappings (count=%d)", handle, info.count);
		for (size_t i=0 ; i<info.callstacks.size() ; i++) {
		LOGD("#%d, count=%d", i, info.callstacks.valueAt(i));
		info.callstacks.keyAt(i).dump();
		}
		}

		// ---------------------------------------------------------------------------
		}; // namespace android

opengl/libagl/egl.cpp

+9 −4

Original line number	Diff line number	Diff line
		@@ -1699,8 +1699,11 @@ EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target,
		reinterpret_cast<gralloc_module_t const*>(pModule);
		if (native_buffer->getHandle(native_buffer, &bufferHandle) < 0)
		return setError(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
		if (module->map(module, bufferHandle, &native_buffer->bits) < 0)
		int err = module->map(module, bufferHandle, &native_buffer->bits);
		if (err < 0) {
		LOGW_IF(err, "map(...) failed %d (%s)", err, strerror(-err));
		return setError(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
		}

		native_buffer->common.incRef(&native_buffer->common);
		return (EGLImageKHR)native_buffer;
		@@ -1725,8 +1728,10 @@ EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img)
		buffer_handle_t bufferHandle;
		gralloc_module_t const* module =
		reinterpret_cast<gralloc_module_t const*>(pModule);
		if (native_buffer->getHandle(native_buffer, &bufferHandle) == 0) {
		module->unmap(module, bufferHandle);
		int err = native_buffer->getHandle(native_buffer, &bufferHandle);
		if (err == 0) {
		int err = module->unmap(module, bufferHandle);
		LOGW_IF(err, "unmap(...) failed %d (%s)", err, strerror(-err));
		}
		}