Merge "Support GPU profiling vis in new pipeline" into nyc-dev (b862f586) · Commits · e / os / android_frameworks_base

libs/hwui/BakedOpRenderer.cpp

+33 −11

Original line number	Original line	Diff line number	Diff line
	@@ -135,17 +135,7 @@ void BakedOpRenderer::endFrame(const Rect& repaintRect) {
	mRenderState.stencil().disable();		mRenderState.stencil().disable();
	}		}

	mCaches.clearGarbage();		// Note: we leave FBO 0 renderable here, for post-frame-content decoration
	mCaches.pathCache.trim();
	mCaches.tessellationCache.trim();

	#if DEBUG_MEMORY_USAGE
	mCaches.dumpMemoryUsage();
	#else
	if (Properties::debugLevel & kDebugMemory) {
	mCaches.dumpMemoryUsage();
	}
	#endif
	}		}

	void BakedOpRenderer::setViewport(uint32_t width, uint32_t height) {		void BakedOpRenderer::setViewport(uint32_t width, uint32_t height) {
	@@ -179,6 +169,38 @@ Texture* BakedOpRenderer::getTexture(const SkBitmap* bitmap) {
	return texture;		return texture;
	}		}

			void BakedOpRenderer::drawRects(const float* rects, int count, const SkPaint* paint) {
			std::vector<Vertex> vertices;
			vertices.reserve(count);
			Vertex* vertex = vertices.data();

			for (int index = 0; index < count; index += 4) {
			float l = rects[index + 0];
			float t = rects[index + 1];
			float r = rects[index + 2];
			float b = rects[index + 3];

			Vertex::set(vertex++, l, t);
			Vertex::set(vertex++, r, t);
			Vertex::set(vertex++, l, b);
			Vertex::set(vertex++, r, b);
			}

			LOG_ALWAYS_FATAL_IF(mRenderTarget.frameBufferId != 0, "decoration only supported for FBO 0");
			// TODO: Currently assume full FBO damage, due to FrameInfoVisualizer::unionDirty.
			// Should should scissor safely.
			mRenderState.scissor().setEnabled(false);
			Glop glop;
			GlopBuilder(mRenderState, mCaches, &glop)
			.setRoundRectClipState(nullptr)
			.setMeshIndexedQuads(vertices.data(), count / 4)
			.setFillPaint(*paint, 1.0f)
			.setTransform(Matrix4::identity(), TransformFlags::None)
			.setModelViewIdentityEmptyBounds()
			.build();
			mRenderState.render(glop, mRenderTarget.orthoMatrix);
			}

	// clears and re-fills stencil with provided rendertarget space quads,		// clears and re-fills stencil with provided rendertarget space quads,
	// and then put stencil into test mode		// and then put stencil into test mode
	void BakedOpRenderer::setupStencilQuads(std::vector<Vertex>& quadVertices,		void BakedOpRenderer::setupStencilQuads(std::vector<Vertex>& quadVertices,

libs/hwui/BakedOpRenderer.h

+10 −0

Original line number	Original line	Diff line number	Diff line
	@@ -85,6 +85,16 @@ public:
	bool offscreenRenderTarget() { return mRenderTarget.offscreenBuffer != nullptr; }		bool offscreenRenderTarget() { return mRenderTarget.offscreenBuffer != nullptr; }
	void dirtyRenderTarget(const Rect& dirtyRect);		void dirtyRenderTarget(const Rect& dirtyRect);
	bool didDraw() const { return mHasDrawn; }		bool didDraw() const { return mHasDrawn; }

			uint32_t getViewportWidth() const { return mRenderTarget.viewportWidth; }
			uint32_t getViewportHeight() const { return mRenderTarget.viewportHeight; }

			// simple draw methods, to be used for end frame decoration
			void drawRect(float left, float top, float right, float bottom, const SkPaint* paint) {
			float ltrb[4] = { left, top, right, bottom };
			drawRects(ltrb, 4, paint);
			}
			void drawRects(const float* rects, int count, const SkPaint* paint);
	private:		private:
	void setViewport(uint32_t width, uint32_t height);		void setViewport(uint32_t width, uint32_t height);
	void clearColorBuffer(const Rect& clearRect);		void clearColorBuffer(const Rect& clearRect);

libs/hwui/FrameInfoVisualizer.cpp

+19 −16

Original line number	Original line	Diff line number	Diff line
	@@ -15,7 +15,11 @@
	*/		*/
	#include "FrameInfoVisualizer.h"		#include "FrameInfoVisualizer.h"

			#if HWUI_NEW_OPS
			#include "BakedOpRenderer.h"
			#else
	#include "OpenGLRenderer.h"		#include "OpenGLRenderer.h"
			#endif
	#include "utils/Color.h"		#include "utils/Color.h"

	#include <cutils/compiler.h>		#include <cutils/compiler.h>
	@@ -88,7 +92,7 @@ void FrameInfoVisualizer::unionDirty(SkRect* dirty) {
	}		}
	}		}

	void FrameInfoVisualizer::draw(OpenGLRenderer* canvas) {		void FrameInfoVisualizer::draw(ContentRenderer* renderer) {
	RETURN_IF_DISABLED();		RETURN_IF_DISABLED();

	if (mShowDirtyRegions) {		if (mShowDirtyRegions) {
	@@ -96,7 +100,7 @@ void FrameInfoVisualizer::draw(OpenGLRenderer* canvas) {
	if (mFlashToggle) {		if (mFlashToggle) {
	SkPaint paint;		SkPaint paint;
	paint.setColor(0x7fff0000);		paint.setColor(0x7fff0000);
	canvas->drawRect(mDirtyRegion.fLeft, mDirtyRegion.fTop,		renderer->drawRect(mDirtyRegion.fLeft, mDirtyRegion.fTop,
	mDirtyRegion.fRight, mDirtyRegion.fBottom, &paint);		mDirtyRegion.fRight, mDirtyRegion.fBottom, &paint);
	}		}
	}		}
	@@ -111,9 +115,9 @@ void FrameInfoVisualizer::draw(OpenGLRenderer* canvas) {
	info.markSwapBuffers();		info.markSwapBuffers();
	info.markFrameCompleted();		info.markFrameCompleted();

	initializeRects(canvas->getViewportHeight(), canvas->getViewportWidth());		initializeRects(renderer->getViewportHeight(), renderer->getViewportWidth());
	drawGraph(canvas);		drawGraph(renderer);
	drawThreshold(canvas);		drawThreshold(renderer);
	}		}
	}		}

	@@ -194,27 +198,26 @@ void FrameInfoVisualizer::nextBarSegment(FrameInfoIndex start, FrameInfoIndex en
	}		}
	}		}

	void FrameInfoVisualizer::drawGraph(OpenGLRenderer* canvas) {		void FrameInfoVisualizer::drawGraph(ContentRenderer* renderer) {
	SkPaint paint;		SkPaint paint;
	for (size_t i = 0; i < Bar.size(); i++) {		for (size_t i = 0; i < Bar.size(); i++) {
	nextBarSegment(Bar[i].start, Bar[i].end);		nextBarSegment(Bar[i].start, Bar[i].end);
	paint.setColor(Bar[i].color & BAR_FAST_MASK);		paint.setColor(Bar[i].color & BAR_FAST_MASK);
	canvas->drawRects(mFastRects.get(), mNumFastRects * 4, &paint);		renderer->drawRects(mFastRects.get(), mNumFastRects * 4, &paint);
	paint.setColor(Bar[i].color & BAR_JANKY_MASK);		paint.setColor(Bar[i].color & BAR_JANKY_MASK);
	canvas->drawRects(mJankyRects.get(), mNumJankyRects * 4, &paint);		renderer->drawRects(mJankyRects.get(), mNumJankyRects * 4, &paint);
	}		}
	}		}

	void FrameInfoVisualizer::drawThreshold(OpenGLRenderer* canvas) {		void FrameInfoVisualizer::drawThreshold(ContentRenderer* renderer) {
	SkPaint paint;		SkPaint paint;
	paint.setColor(THRESHOLD_COLOR);		paint.setColor(THRESHOLD_COLOR);
	paint.setStrokeWidth(mThresholdStroke);		float yLocation = renderer->getViewportHeight() - (FRAME_THRESHOLD * mVerticalUnit);
			renderer->drawRect(0.0f,
	float pts[4];		yLocation - mThresholdStroke/2,
	pts[0] = 0.0f;		renderer->getViewportWidth(),
	pts[1] = pts[3] = canvas->getViewportHeight() - (FRAME_THRESHOLD * mVerticalUnit);		yLocation + mThresholdStroke/2,
	pts[2] = canvas->getViewportWidth();		&paint);
	canvas->drawLines(pts, 4, &paint);
	}		}

	bool FrameInfoVisualizer::consumeProperties() {		bool FrameInfoVisualizer::consumeProperties() {

libs/hwui/FrameInfoVisualizer.h

+9 −3

Original line number	Original line	Diff line number	Diff line
	@@ -28,7 +28,13 @@
	namespace android {		namespace android {
	namespace uirenderer {		namespace uirenderer {

			#if HWUI_NEW_OPS
			class BakedOpRenderer;
			typedef BakedOpRenderer ContentRenderer;
			#else
	class OpenGLRenderer;		class OpenGLRenderer;
			typedef OpenGLRenderer ContentRenderer;
			#endif

	// TODO: This is a bit awkward as it needs to match the thing in CanvasContext		// TODO: This is a bit awkward as it needs to match the thing in CanvasContext
	// A better abstraction here would be nice but iterators are painful		// A better abstraction here would be nice but iterators are painful
	@@ -46,7 +52,7 @@ public:
	void setDensity(float density);		void setDensity(float density);

	void unionDirty(SkRect* dirty);		void unionDirty(SkRect* dirty);
	void draw(OpenGLRenderer* canvas);		void draw(ContentRenderer* renderer);

	void dumpData(int fd);		void dumpData(int fd);

	@@ -56,8 +62,8 @@ private:

	void initializeRects(const int baseline, const int width);		void initializeRects(const int baseline, const int width);
	void nextBarSegment(FrameInfoIndex start, FrameInfoIndex end);		void nextBarSegment(FrameInfoIndex start, FrameInfoIndex end);
	void drawGraph(OpenGLRenderer* canvas);		void drawGraph(ContentRenderer* renderer);
	void drawThreshold(OpenGLRenderer* canvas);		void drawThreshold(ContentRenderer* renderer);

	inline float durationMS(size_t index, FrameInfoIndex start, FrameInfoIndex end) {		inline float durationMS(size_t index, FrameInfoIndex start, FrameInfoIndex end) {
	float duration = mFrameSource[index].duration(start, end) * 0.000001f;		float duration = mFrameSource[index].duration(start, end) * 0.000001f;

libs/hwui/renderthread/CanvasContext.cpp

+16 −2

Original line number	Original line	Diff line number	Diff line
	@@ -348,12 +348,26 @@ void CanvasContext::draw() {
	FrameBuilder frameBuilder(mLayerUpdateQueue, dirty, frame.width(), frame.height(),		FrameBuilder frameBuilder(mLayerUpdateQueue, dirty, frame.width(), frame.height(),
	mRenderNodes, mLightGeometry, mContentDrawBounds, &Caches::getInstance());		mRenderNodes, mLightGeometry, mContentDrawBounds, &Caches::getInstance());
	mLayerUpdateQueue.clear();		mLayerUpdateQueue.clear();
	BakedOpRenderer renderer(Caches::getInstance(), mRenderThread.renderState(),		auto&& caches = Caches::getInstance();
			BakedOpRenderer renderer(caches, mRenderThread.renderState(),
	mOpaque, mLightInfo);		mOpaque, mLightInfo);
	// TODO: profiler().draw(mCanvas);
	frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer);		frameBuilder.replayBakedOps<BakedOpDispatcher>(renderer);
			profiler().draw(&renderer);
	bool drew = renderer.didDraw();		bool drew = renderer.didDraw();

			// post frame cleanup
			caches.clearGarbage();
			caches.pathCache.trim();
			caches.tessellationCache.trim();

			#if DEBUG_MEMORY_USAGE
			mCaches.dumpMemoryUsage();
			#else
			if (CC_UNLIKELY(Properties::debugLevel & kDebugMemory)) {
			caches.dumpMemoryUsage();
			}
			#endif

	#else		#else
	mCanvas->prepareDirty(frame.width(), frame.height(),		mCanvas->prepareDirty(frame.width(), frame.height(),
	dirty.fLeft, dirty.fTop, dirty.fRight, dirty.fBottom, mOpaque);		dirty.fLeft, dirty.fTop, dirty.fRight, dirty.fBottom, mOpaque);