Improve logging around performance critical events (70850ea2) · Commits · e / os / android_frameworks_base

core/java/android/view/ThreadedRenderer.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -274,7 +274,7 @@ public class ThreadedRenderer extends HardwareRenderer {
		}

		private void updateRootDisplayList(View view, HardwareDrawCallbacks callbacks) {
		Trace.traceBegin(Trace.TRACE_TAG_VIEW, "getDisplayList");
		Trace.traceBegin(Trace.TRACE_TAG_VIEW, "Record View#draw()");
		updateViewTreeDisplayList(view);

		if (mRootNodeNeedsUpdate \|\| !mRootNode.isValid()) {

core/java/android/view/View.java

+135 −124

Original line number	Diff line number	Diff line
		@@ -56,6 +56,7 @@ import android.os.Parcelable;
		import android.os.RemoteException;
		import android.os.SystemClock;
		import android.os.SystemProperties;
		import android.os.Trace;
		import android.text.TextUtils;
		import android.util.AttributeSet;
		import android.util.FloatProperty;
		@@ -14397,6 +14398,22 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		public void buildDrawingCache(boolean autoScale) {
		if ((mPrivateFlags & PFLAG_DRAWING_CACHE_VALID) == 0 \|\| (autoScale ?
		mDrawingCache == null : mUnscaledDrawingCache == null)) {
		if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) {
		Trace.traceBegin(Trace.TRACE_TAG_VIEW,
		"buildDrawingCache/SW Layer for " + getClass().getSimpleName());
		}
		try {
		buildDrawingCacheImpl(autoScale);
		} finally {
		Trace.traceEnd(Trace.TRACE_TAG_VIEW);
		}
		}
		}

		/**
		* private, internal implementation of buildDrawingCache, used to enable tracing
		*/
		private void buildDrawingCacheImpl(boolean autoScale) {
		mCachingFailed = false;

		int width = mRight - mLeft;
		@@ -14535,7 +14552,6 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		attachInfo.mCanvas = canvas;
		}
		}
		}

		/**
		* Create a snapshot of the view into a bitmap. We should probably make
		@@ -15472,10 +15488,10 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		&& mAttachInfo.mHardwareRenderer != null) {
		mBackgroundRenderNode = getDrawableRenderNode(background, mBackgroundRenderNode);

		final RenderNode displayList = mBackgroundRenderNode;
		if (displayList != null && displayList.isValid()) {
		setBackgroundDisplayListProperties(displayList);
		((HardwareCanvas) canvas).drawRenderNode(displayList);
		final RenderNode renderNode = mBackgroundRenderNode;
		if (renderNode != null && renderNode.isValid()) {
		setBackgroundRenderNodeProperties(renderNode);
		((HardwareCanvas) canvas).drawRenderNode(renderNode);
		return;
		}
		}
		@@ -15491,14 +15507,9 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		}
		}

		/**
		* Set up background drawable display list properties.
		*
		* @param displayList Valid display list for the background drawable
		*/
		private void setBackgroundDisplayListProperties(RenderNode displayList) {
		displayList.setTranslationX(mScrollX);
		displayList.setTranslationY(mScrollY);
		private void setBackgroundRenderNodeProperties(RenderNode renderNode) {
		renderNode.setTranslationX(mScrollX);
		renderNode.setTranslationY(mScrollY);
		}

		/**

libs/hwui/Layer.cpp

+17 −1

Original line number	Diff line number	Diff line
		@@ -20,11 +20,18 @@

		#include "Caches.h"
		#include "DeferredDisplayList.h"
		#include "RenderState.h"
		#include "Layer.h"
		#include "LayerRenderer.h"
		#include "OpenGLRenderer.h"
		#include "RenderNode.h"
		#include "RenderState.h"
		#include "utils/TraceUtils.h"

		#define ATRACE_LAYER_WORK(label) \
		ATRACE_FORMAT("%s HW Layer DisplayList %s %ux%u", \
		label, \
		(renderNode.get() != NULL) ? renderNode->getName() : "", \
		getWidth(), getHeight())

		namespace android {
		namespace uirenderer {
		@@ -223,6 +230,8 @@ void Layer::allocateTexture() {
		}

		void Layer::defer(const OpenGLRenderer& rootRenderer) {
		ATRACE_LAYER_WORK("Optimize");

		updateLightPosFromRenderer(rootRenderer);
		const float width = layer.getWidth();
		const float height = layer.getHeight();
		@@ -260,6 +269,9 @@ void Layer::cancelDefer() {
		void Layer::flush() {
		// renderer is checked as layer may be destroyed/put in layer cache with flush scheduled
		if (deferredList && renderer) {
		ATRACE_LAYER_WORK("Issue");
		renderer->startMark((renderNode.get() != NULL) ? renderNode->getName() : "Layer");

		renderer->setViewport(layer.getWidth(), layer.getHeight());
		renderer->prepareDirty(dirtyRect.left, dirtyRect.top, dirtyRect.right, dirtyRect.bottom,
		!isBlend());
		@@ -270,10 +282,14 @@ void Layer::flush() {

		dirtyRect.setEmpty();
		renderNode = NULL;

		renderer->endMark();
		}
		}

		void Layer::render(const OpenGLRenderer& rootRenderer) {
		ATRACE_LAYER_WORK("Direct-Issue");

		updateLightPosFromRenderer(rootRenderer);
		renderer->setViewport(layer.getWidth(), layer.getHeight());
		renderer->prepareDirty(dirtyRect.left, dirtyRect.top, dirtyRect.right, dirtyRect.bottom,

libs/hwui/LayerRenderer.cpp

+3 −2

Original line number	Diff line number	Diff line
		@@ -27,6 +27,7 @@
		#include "Matrix.h"
		#include "Properties.h"
		#include "Rect.h"
		#include "utils/TraceUtils.h"

		namespace android {
		namespace uirenderer {
		@@ -185,7 +186,7 @@ void LayerRenderer::generateMesh() {
		///////////////////////////////////////////////////////////////////////////////

		Layer* LayerRenderer::createRenderLayer(RenderState& renderState, uint32_t width, uint32_t height) {
		ATRACE_CALL();
		ATRACE_FORMAT("Allocate %ux%u HW Layer", width, height);
		LAYER_RENDERER_LOGD("Requesting new render layer %dx%d", width, height);

		Caches& caches = Caches::getInstance();
		@@ -310,7 +311,7 @@ void LayerRenderer::updateTextureLayer(Layer* layer, uint32_t width, uint32_t he

		void LayerRenderer::destroyLayer(Layer* layer) {
		if (layer) {
		ATRACE_CALL();
		ATRACE_FORMAT("Destroy %ux%u HW Layer", layer->getWidth(), layer->getHeight());
		LAYER_RENDERER_LOGD("Recycling layer, %dx%d fbo = %d",
		layer->getWidth(), layer->getHeight(), layer->getFbo());

libs/hwui/OpenGLRenderer.cpp

+3 −29

Original line number	Diff line number	Diff line
		@@ -42,6 +42,7 @@
		#include "ShadowTessellator.h"
		#include "SkiaShader.h"
		#include "utils/GLUtils.h"
		#include "utils/TraceUtils.h"
		#include "Vector.h"
		#include "VertexBuffer.h"

		@@ -51,21 +52,6 @@
		#define EVENT_LOGD(...)
		#endif

		static void atraceFormatBegin(const char* fmt, ...) {
		const int BUFFER_SIZE = 256;
		va_list ap;
		char buf[BUFFER_SIZE];

		va_start(ap, fmt);
		vsnprintf(buf, BUFFER_SIZE, fmt, ap);
		va_end(ap);

		ATRACE_BEGIN(buf);
		}

		#define ATRACE_FORMAT_BEGIN(fmt, ...) \
		if (CC_UNLIKELY(ATRACE_ENABLED())) atraceFormatBegin(fmt, ##__VA_ARGS__)

		namespace android {
		namespace uirenderer {

		@@ -466,8 +452,6 @@ void OpenGLRenderer::renderOverdraw() {
		bool OpenGLRenderer::updateLayer(Layer* layer, bool inFrame) {
		if (layer->deferredUpdateScheduled && layer->renderer
		&& layer->renderNode.get() && layer->renderNode->isRenderable()) {
		ATRACE_CALL();

		Rect& dirty = layer->dirtyRect;

		if (inFrame) {
		@@ -525,20 +509,10 @@ void OpenGLRenderer::flushLayers() {
		int count = mLayerUpdates.size();
		if (count > 0) {
		startMark("Apply Layer Updates");
		char layerName[12];

		// Note: it is very important to update the layers in order
		for (int i = 0; i < count; i++) {
		Layer* layer = mLayerUpdates.itemAt(i).get();

		sprintf(layerName, "Layer #%d", i);
		startMark(layerName);
		ATRACE_FORMAT_BEGIN("flushLayer %ux%u", layer->getWidth(), layer->getHeight());

		layer->flush();

		ATRACE_END();
		endMark();
		mLayerUpdates.itemAt(i)->flush();
		}

		mLayerUpdates.clear();
		@@ -575,7 +549,7 @@ void OpenGLRenderer::cancelLayerUpdate(Layer* layer) {
		}

		void OpenGLRenderer::flushLayerUpdates() {
		ATRACE_CALL();
		ATRACE_NAME("Update HW Layers");
		syncState();
		updateLayers();
		flushLayers();