MultiThreaded rendering of different renderNodes (ea7a7fb7) · Commits · e / os / android_frameworks_base

core/java/android/view/ThreadedRenderer.java

+61 −0

Original line number	Original line	Diff line number	Diff line
	@@ -108,6 +108,11 @@ public class ThreadedRenderer extends HardwareRenderer {
	private Choreographer mChoreographer;		private Choreographer mChoreographer;
	private boolean mRootNodeNeedsUpdate;		private boolean mRootNodeNeedsUpdate;

			// In case of multi threaded render nodes, these bounds indicate the content bounds against
			// which the backdrop needs to be cropped against.
			private final Rect mCurrentContentBounds = new Rect();
			private final Rect mStagedContentBounds = new Rect();

	ThreadedRenderer(Context context, boolean translucent) {		ThreadedRenderer(Context context, boolean translucent) {
	final TypedArray a = context.obtainStyledAttributes(null, R.styleable.Lighting, 0, 0);		final TypedArray a = context.obtainStyledAttributes(null, R.styleable.Lighting, 0, 0);
	mLightY = a.getDimension(R.styleable.Lighting_lightY, 0);		mLightY = a.getDimension(R.styleable.Lighting_lightY, 0);
	@@ -307,6 +312,47 @@ public class ThreadedRenderer extends HardwareRenderer {
	Trace.traceEnd(Trace.TRACE_TAG_VIEW);		Trace.traceEnd(Trace.TRACE_TAG_VIEW);
	}		}

			/**
			* Adds a rendernode to the renderer which can be drawn and changed asynchronously to the
			* rendernode of the UI thread.
			* @param node The node to add.
			* @param placeFront If true, the render node will be placed in front of the content node,
			* otherwise behind the content node.
			*/
			public void addRenderNode(RenderNode node, boolean placeFront) {
			nAddRenderNode(mNativeProxy, node.mNativeRenderNode, placeFront);
			}

			/**
			* Only especially added render nodes can be removed.
			* @param node The node which was added via addRenderNode which should get removed again.
			*/
			public void removeRenderNode(RenderNode node) {
			nRemoveRenderNode(mNativeProxy, node.mNativeRenderNode);
			}

			/**
			* Draws a particular render node. If the node is not the content node, only the additional
			* nodes will get drawn and the content remains untouched.
			* @param node The node to be drawn.
			*/
			public void drawRenderNode(RenderNode node) {
			nDrawRenderNode(mNativeProxy, node.mNativeRenderNode);
			}

			/**
			* To avoid unnecessary overdrawing of the main content all additionally passed render nodes
			* will be prevented to overdraw this area. It will be synchronized with the draw call.
			* This should be updated in the content view's draw call.
			* @param left The left side of the protected bounds.
			* @param top The top side of the protected bounds.
			* @param right The right side of the protected bounds.
			* @param bottom The bottom side of the protected bounds.
			*/
			public void setContentOverdrawProtectionBounds(int left, int top, int right, int bottom) {
			mStagedContentBounds.set(left, top, right, bottom);
			}

	@Override		@Override
	void invalidateRoot() {		void invalidateRoot() {
	mRootNodeNeedsUpdate = true;		mRootNodeNeedsUpdate = true;
	@@ -320,6 +366,14 @@ public class ThreadedRenderer extends HardwareRenderer {
	choreographer.mFrameInfo.markDrawStart();		choreographer.mFrameInfo.markDrawStart();

	updateRootDisplayList(view, callbacks);		updateRootDisplayList(view, callbacks);
			// The main content view was updating the content bounds and we transfer them to the
			// renderer.
			if (!mCurrentContentBounds.equals(mStagedContentBounds)) {
			mCurrentContentBounds.set(mStagedContentBounds);
			nSetContentOverdrawProtectionBounds(mNativeProxy, mCurrentContentBounds.left,
			mCurrentContentBounds.top, mCurrentContentBounds.right,
			mCurrentContentBounds.bottom);
			}

	attachInfo.mIgnoreDirtyState = false;		attachInfo.mIgnoreDirtyState = false;

	@@ -541,4 +595,11 @@ public class ThreadedRenderer extends HardwareRenderer {
	private static native void nDumpProfileInfo(long nativeProxy, FileDescriptor fd,		private static native void nDumpProfileInfo(long nativeProxy, FileDescriptor fd,
	@DumpFlags int dumpFlags);		@DumpFlags int dumpFlags);
	private static native void nDumpProfileData(byte[] data, FileDescriptor fd);		private static native void nDumpProfileData(byte[] data, FileDescriptor fd);

			private static native void nAddRenderNode(long nativeProxy, long rootRenderNode,
			boolean placeFront);
			private static native void nRemoveRenderNode(long nativeProxy, long rootRenderNode);
			private static native void nDrawRenderNode(long nativeProxy, long rootRenderNode);
			private static native void nSetContentOverdrawProtectionBounds(long nativeProxy, int left,
			int top, int right, int bottom);
	}		}

core/java/android/view/View.java

+17 −0

Original line number	Original line	Diff line number	Diff line
	@@ -7372,6 +7372,23 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
	}		}
	}		}

			/**
			* Compute the view's coordinate within the surface.
			*
			* <p>Computes the coordinates of this view in its surface. The argument
			* must be an array of two integers. After the method returns, the array
			* contains the x and y location in that order.</p>
			* @hide
			* @param location an array of two integers in which to hold the coordinates
			*/
			public void getLocationInSurface(@Size(2) int[] location) {
			getLocationInWindow(location);
			if (mAttachInfo != null && mAttachInfo.mViewRootImpl != null) {
			location[0] += mAttachInfo.mViewRootImpl.mWindowAttributes.surfaceInsets.left;
			location[1] += mAttachInfo.mViewRootImpl.mWindowAttributes.surfaceInsets.top;
			}
			}

	/**		/**
	* Provide original WindowInsets that are dispatched to the view hierarchy. The insets are		* Provide original WindowInsets that are dispatched to the view hierarchy. The insets are
	* only available if the view is attached.		* only available if the view is attached.

core/jni/android_view_ThreadedRenderer.cpp

+31 −1

Original line number	Original line	Diff line number	Diff line
	@@ -440,6 +440,32 @@ static void android_view_ThreadedRenderer_dumpProfileData(JNIEnv* env, jobject c
	}		}
	}		}

			static void android_view_ThreadedRenderer_addRenderNode(JNIEnv* env, jobject clazz,
			jlong proxyPtr, jlong renderNodePtr, jboolean placeFront) {
			RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
			RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
			proxy->addRenderNode(renderNode, placeFront);
			}

			static void android_view_ThreadedRenderer_removeRenderNode(JNIEnv* env, jobject clazz,
			jlong proxyPtr, jlong renderNodePtr) {
			RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
			RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
			proxy->removeRenderNode(renderNode);
			}

			static void android_view_ThreadedRendererd_drawRenderNode(JNIEnv* env, jobject clazz,
			jlong proxyPtr, jlong renderNodePtr) {
			RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
			RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
			proxy->drawRenderNode(renderNode);
			}

			static void android_view_ThreadedRenderer_setContentOverdrawProtectionBounds(JNIEnv* env,
			jobject clazz, jlong proxyPtr, jint left, jint top, jint right, jint bottom) {
			RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
			proxy->setContentOverdrawProtectionBounds(left, top, right, bottom);
			}

	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------
	// Shaders		// Shaders
	@@ -447,7 +473,6 @@ static void android_view_ThreadedRenderer_dumpProfileData(JNIEnv* env, jobject c

	static void android_view_ThreadedRenderer_setupShadersDiskCache(JNIEnv* env, jobject clazz,		static void android_view_ThreadedRenderer_setupShadersDiskCache(JNIEnv* env, jobject clazz,
	jstring diskCachePath) {		jstring diskCachePath) {

	const char* cacheArray = env->GetStringUTFChars(diskCachePath, NULL);		const char* cacheArray = env->GetStringUTFChars(diskCachePath, NULL);
	egl_cache_t::get()->setCacheFilename(cacheArray);		egl_cache_t::get()->setCacheFilename(cacheArray);
	env->ReleaseStringUTFChars(diskCachePath, cacheArray);		env->ReleaseStringUTFChars(diskCachePath, cacheArray);
	@@ -494,6 +519,11 @@ static JNINativeMethod gMethods[] = {
	{ "nDumpProfileData", "([BLjava/io/FileDescriptor;)V", (void*) android_view_ThreadedRenderer_dumpProfileData },		{ "nDumpProfileData", "([BLjava/io/FileDescriptor;)V", (void*) android_view_ThreadedRenderer_dumpProfileData },
	{ "setupShadersDiskCache", "(Ljava/lang/String;)V",		{ "setupShadersDiskCache", "(Ljava/lang/String;)V",
	(void*) android_view_ThreadedRenderer_setupShadersDiskCache },		(void*) android_view_ThreadedRenderer_setupShadersDiskCache },
			{ "nAddRenderNode", "(JJZ)V", (void*) android_view_ThreadedRenderer_addRenderNode},
			{ "nRemoveRenderNode", "(JJ)V", (void*) android_view_ThreadedRenderer_removeRenderNode},
			{ "nDrawRenderNode", "(JJ)V", (void*) android_view_ThreadedRendererd_drawRenderNode},
			{ "nSetContentOverdrawProtectionBounds", "(JIIII)V",
			(void*)android_view_ThreadedRenderer_setContentOverdrawProtectionBounds},
	};		};

	int register_android_view_ThreadedRenderer(JNIEnv* env) {		int register_android_view_ThreadedRenderer(JNIEnv* env) {

libs/hwui/TreeInfo.h

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -77,7 +77,7 @@ public:
	, canvasContext(clone.canvasContext)		, canvasContext(clone.canvasContext)
	{}		{}

	const TraversalMode mode;		TraversalMode mode;
	// TODO: Remove this? Currently this is used to signal to stop preparing		// TODO: Remove this? Currently this is used to signal to stop preparing
	// textures if we run out of cache space.		// textures if we run out of cache space.
	bool prepareTextures;		bool prepareTextures;

libs/hwui/renderthread/CanvasContext.cpp

+108 −7

Original line number	Original line	Diff line number	Diff line
	@@ -60,9 +60,10 @@ CanvasContext::CanvasContext(RenderThread& thread, bool translucent,
	, mEglManager(thread.eglManager())		, mEglManager(thread.eglManager())
	, mOpaque(!translucent)		, mOpaque(!translucent)
	, mAnimationContext(contextFactory->createAnimationContext(mRenderThread.timeLord()))		, mAnimationContext(contextFactory->createAnimationContext(mRenderThread.timeLord()))
	, mRootRenderNode(rootRenderNode)
	, mJankTracker(thread.timeLord().frameIntervalNanos())		, mJankTracker(thread.timeLord().frameIntervalNanos())
	, mProfiler(mFrames) {		, mProfiler(mFrames)
			, mContentOverdrawProtectionBounds(0, 0, 0, 0) {
			mRenderNodes.emplace_back(rootRenderNode);
	mRenderThread.renderState().registerCanvasContext(this);		mRenderThread.renderState().registerCanvasContext(this);
	mProfiler.setDensity(mRenderThread.mainDisplayInfo().density);		mProfiler.setDensity(mRenderThread.mainDisplayInfo().density);
	}		}
	@@ -172,7 +173,8 @@ static bool wasSkipped(FrameInfo* info) {
	return info && ((*info)[FrameInfoIndex::Flags] & FrameInfoFlags::SkippedFrame);		return info && ((*info)[FrameInfoIndex::Flags] & FrameInfoFlags::SkippedFrame);
	}		}

	void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo, int64_t syncQueued) {		void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo,
			int64_t syncQueued, RenderNode* target) {
	mRenderThread.removeFrameCallback(this);		mRenderThread.removeFrameCallback(this);

	// If the previous frame was dropped we don't need to hold onto it, so		// If the previous frame was dropped we don't need to hold onto it, so
	@@ -189,7 +191,13 @@ void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo, int64_t sy
	info.canvasContext = this;		info.canvasContext = this;

	mAnimationContext->startFrame(info.mode);		mAnimationContext->startFrame(info.mode);
	mRootRenderNode->prepareTree(info);		for (const sp<RenderNode>& node : mRenderNodes) {
			// Only the primary target node will be drawn full - all other nodes would get drawn in
			// real time mode. In case of a window, the primary node is the window content and the other
			// node(s) are non client / filler nodes.
			info.mode = (node.get() == target ? TreeInfo::MODE_FULL : TreeInfo::MODE_RT_ONLY);
			node->prepareTree(info);
			}
	mAnimationContext->runRemainingAnimations(info);		mAnimationContext->runRemainingAnimations(info);

	freePrefetechedLayers();		freePrefetechedLayers();
	@@ -299,7 +307,95 @@ void CanvasContext::draw() {
	dirty.fLeft, dirty.fTop, dirty.fRight, dirty.fBottom, mOpaque);		dirty.fLeft, dirty.fTop, dirty.fRight, dirty.fBottom, mOpaque);

	Rect outBounds;		Rect outBounds;
	mCanvas->drawRenderNode(mRootRenderNode.get(), outBounds);		// It there are multiple render nodes, they are as follows:
			// #0 - backdrop
			// #1 - content (with - and clipped to - bounds mContentOverdrawProtectionBounds)
			// #2 - frame
			// Usually the backdrop cannot be seen since it will be entirely covered by the content. While
			// resizing however it might become partially visible. The following render loop will crop the
			// backdrop against the content and draw the remaining part of it. It will then crop the content
			// against the backdrop (since that indicates a shrinking of the window) and then the frame
			// around everything.
			// The bounds of the backdrop against which the content should be clipped.
			Rect backdropBounds = mContentOverdrawProtectionBounds;
			// If there is no content bounds we ignore the layering as stated above and start with 2.
			int layer = mContentOverdrawProtectionBounds.isEmpty() ? 2 : 0;
			// Draw all render nodes. Note that
			for (const sp<RenderNode>& node : mRenderNodes) {
			if (layer == 0) { // Backdrop.
			// Draw the backdrop clipped to the inverse content bounds.
			const RenderProperties& properties = node->properties();
			Rect targetBounds(properties.getLeft(), properties.getTop(),
			properties.getRight(), properties.getBottom());
			// Remember the intersection of the target bounds and the intersection bounds against
			// which we have to crop the content.
			backdropBounds.intersect(targetBounds);
			// Check if we have to draw something on the left side ...
			if (targetBounds.left < mContentOverdrawProtectionBounds.left) {
			mCanvas->save(SkCanvas::kClip_SaveFlag);
			if (mCanvas->clipRect(targetBounds.left, targetBounds.top,
			mContentOverdrawProtectionBounds.left, targetBounds.bottom,
			SkRegion::kIntersect_Op)) {
			mCanvas->drawRenderNode(node.get(), outBounds);
			}
			// Reduce the target area by the area we have just painted.
			targetBounds.left = std::min(mContentOverdrawProtectionBounds.left,
			targetBounds.right);
			mCanvas->restore();
			}
			// ... or on the right side ...
			if (targetBounds.right > mContentOverdrawProtectionBounds.right &&
			!targetBounds.isEmpty()) {
			mCanvas->save(SkCanvas::kClip_SaveFlag);
			if (mCanvas->clipRect(mContentOverdrawProtectionBounds.right, targetBounds.top,
			targetBounds.right, targetBounds.bottom,
			SkRegion::kIntersect_Op)) {
			mCanvas->drawRenderNode(node.get(), outBounds);
			}
			// Reduce the target area by the area we have just painted.
			targetBounds.right = std::max(targetBounds.left,
			mContentOverdrawProtectionBounds.right);
			mCanvas->restore();
			}
			// ... or at the top ...
			if (targetBounds.top < mContentOverdrawProtectionBounds.top &&
			!targetBounds.isEmpty()) {
			mCanvas->save(SkCanvas::kClip_SaveFlag);
			if (mCanvas->clipRect(targetBounds.left, targetBounds.top, targetBounds.right,
			mContentOverdrawProtectionBounds.top,
			SkRegion::kIntersect_Op)) {
			mCanvas->drawRenderNode(node.get(), outBounds);
			}
			// Reduce the target area by the area we have just painted.
			targetBounds.top = std::min(mContentOverdrawProtectionBounds.top,
			targetBounds.bottom);
			mCanvas->restore();
			}
			// ... or at the bottom.
			if (targetBounds.bottom > mContentOverdrawProtectionBounds.bottom &&
			!targetBounds.isEmpty()) {
			mCanvas->save(SkCanvas::kClip_SaveFlag);
			if (mCanvas->clipRect(targetBounds.left,
			mContentOverdrawProtectionBounds.bottom, targetBounds.right,
			targetBounds.bottom, SkRegion::kIntersect_Op)) {
			mCanvas->drawRenderNode(node.get(), outBounds);
			}
			mCanvas->restore();
			}
			} else if (layer == 1) { // Content
			// It gets cropped against the bounds of the backdrop to stay inside.
			mCanvas->save(SkCanvas::kClip_SaveFlag);
			if (mCanvas->clipRect(backdropBounds.left, backdropBounds.top,
			backdropBounds.right, backdropBounds.bottom,
			SkRegion::kIntersect_Op)) {
			mCanvas->drawRenderNode(node.get(), outBounds);
			}
			mCanvas->restore();
			} else { // draw the rest on top at will!
			mCanvas->drawRenderNode(node.get(), outBounds);
			}
			layer++;
			}

	profiler().draw(mCanvas);		profiler().draw(mCanvas);

	@@ -343,7 +439,10 @@ void CanvasContext::doFrame() {
	if (CC_UNLIKELY(!mCanvas \|\| mEglSurface == EGL_NO_SURFACE)) {		if (CC_UNLIKELY(!mCanvas \|\| mEglSurface == EGL_NO_SURFACE)) {
	return;		return;
	}		}
			prepareAndDraw(nullptr);
			}

			void CanvasContext::prepareAndDraw(RenderNode* node) {
	ATRACE_CALL();		ATRACE_CALL();

	int64_t frameInfo[UI_THREAD_FRAME_INFO_SIZE];		int64_t frameInfo[UI_THREAD_FRAME_INFO_SIZE];
	@@ -353,7 +452,7 @@ void CanvasContext::doFrame() {
	mRenderThread.timeLord().latestVsync());		mRenderThread.timeLord().latestVsync());

	TreeInfo info(TreeInfo::MODE_RT_ONLY, mRenderThread.renderState());		TreeInfo info(TreeInfo::MODE_RT_ONLY, mRenderThread.renderState());
	prepareTree(info, frameInfo, systemTime(CLOCK_MONOTONIC));		prepareTree(info, frameInfo, systemTime(CLOCK_MONOTONIC), node);
	if (info.out.canDrawThisFrame) {		if (info.out.canDrawThisFrame) {
	draw();		draw();
	}		}
	@@ -423,7 +522,9 @@ void CanvasContext::destroyHardwareResources() {
	stopDrawing();		stopDrawing();
	if (mEglManager.hasEglContext()) {		if (mEglManager.hasEglContext()) {
	freePrefetechedLayers();		freePrefetechedLayers();
	mRootRenderNode->destroyHardwareResources();		for (const sp<RenderNode>& node : mRenderNodes) {
			node->destroyHardwareResources();
			}
	Caches& caches = Caches::getInstance();		Caches& caches = Caches::getInstance();
	// Make sure to release all the textures we were owning as there won't		// Make sure to release all the textures we were owning as there won't
	// be another draw		// be another draw