Switch HWUI to use native performance hint API am: 6a3fc60f43 (4333a837) · Commits · e / os / android_frameworks_base

graphics/java/android/graphics/HardwareRenderer.java

+0 −45

Original line number	Diff line number	Diff line
		@@ -28,7 +28,6 @@ import android.content.res.Configuration;
		import android.hardware.display.DisplayManager;
		import android.os.IBinder;
		import android.os.ParcelFileDescriptor;
		import android.os.PerformanceHintManager;
		import android.os.RemoteException;
		import android.os.ServiceManager;
		import android.util.Log;
		@@ -856,36 +855,6 @@ public class HardwareRenderer {
		callback.onPictureCaptured(picture);
		}

		/** called by native */
		static PerformanceHintManager.Session createHintSession(int[] tids) {
		PerformanceHintManager performanceHintManager =
		ProcessInitializer.sInstance.getHintManager();
		if (performanceHintManager == null) {
		return null;
		}
		// Native code will always set a target duration before reporting actual durations.
		// So this is just a placeholder value that's never used.
		long targetDurationNanos = 16666667;
		return performanceHintManager.createHintSession(tids, targetDurationNanos);
		}

		/** called by native */
		static void updateTargetWorkDuration(PerformanceHintManager.Session session,
		long targetDurationNanos) {
		session.updateTargetWorkDuration(targetDurationNanos);
		}

		/** called by native */
		static void reportActualWorkDuration(PerformanceHintManager.Session session,
		long actualDurationNanos) {
		session.reportActualWorkDuration(actualDurationNanos);
		}

		/** called by native */
		static void closeHintSession(PerformanceHintManager.Session session) {
		session.close();
		}

		/**
		* Interface used to receive callbacks when Webview requests a surface control.
		*
		@@ -1152,7 +1121,6 @@ public class HardwareRenderer {
		private boolean mIsolated = false;
		private Context mContext;
		private String mPackageName;
		private PerformanceHintManager mPerformanceHintManager;
		private IGraphicsStats mGraphicsStatsService;
		private IGraphicsStatsCallback mGraphicsStatsCallback = new IGraphicsStatsCallback.Stub() {
		@Override
		@@ -1164,10 +1132,6 @@ public class HardwareRenderer {
		private ProcessInitializer() {
		}

		synchronized PerformanceHintManager getHintManager() {
		return mPerformanceHintManager;
		}

		synchronized void setPackageName(String name) {
		if (mInitialized) return;
		mPackageName = name;
		@@ -1218,10 +1182,6 @@ public class HardwareRenderer {

		initDisplayInfo();

		// HintManager and HintSession are designed to be accessible from isoalted processes
		// so not checking for isolated process here.
		initHintSession();

		nSetIsHighEndGfx(ActivityManager.isHighEndGfx());
		// Defensively clear out the context in case we were passed a context that can leak
		// if we live longer than it, e.g. an activity context.
		@@ -1265,11 +1225,6 @@ public class HardwareRenderer {
		mDisplayInitialized = true;
		}

		private void initHintSession() {
		if (mContext == null) return;
		mPerformanceHintManager = mContext.getSystemService(PerformanceHintManager.class);
		}

		private void rotateBuffer() {
		nRotateProcessStatsBuffer();
		requestBuffer();

libs/hwui/jni/android_graphics_HardwareRenderer.cpp

+0 −93

Original line number	Diff line number	Diff line
		@@ -44,8 +44,6 @@
		#include <utils/StrongPointer.h>
		#include <utils/Timers.h>

		#include <pthread.h>

		#include <algorithm>
		#include <atomic>
		#include <vector>
		@@ -60,10 +58,6 @@ using namespace android::uirenderer::renderthread;
		struct {
		jclass clazz;
		jmethodID invokePictureCapturedCallback;
		jmethodID createHintSession;
		jmethodID updateTargetWorkDuration;
		jmethodID reportActualWorkDuration;
		jmethodID closeHintSession;
		} gHardwareRenderer;

		struct {
		@@ -90,14 +84,6 @@ static JNIEnv* getenv(JavaVM* vm) {
		return env;
		}

		static bool hasExceptionAndClear(JNIEnv* env) {
		if (GraphicsJNI::hasException(env)) {
		env->ExceptionClear();
		return true;
		}
		return false;
		}

		typedef ANativeWindow* (ANW_fromSurface)(JNIEnv env, jobject surface);
		ANW_fromSurface fromSurface;

		@@ -147,67 +133,6 @@ private:
		}
		};

		class HintSessionWrapper : public LightRefBase<HintSessionWrapper> {
		public:
		static sp<HintSessionWrapper> create(JNIEnv* env, RenderProxy* proxy) {
		if (!Properties::useHintManager) return nullptr;

		// Include UI thread (self), render thread, and thread pool.
		std::vector<int> tids = CommonPool::getThreadIds();
		tids.push_back(proxy->getRenderThreadTid());
		tids.push_back(pthread_gettid_np(pthread_self()));

		jintArray tidsArray = env->NewIntArray(tids.size());
		if (hasExceptionAndClear(env)) return nullptr;
		env->SetIntArrayRegion(tidsArray, 0, tids.size(), reinterpret_cast<jint*>(tids.data()));
		if (hasExceptionAndClear(env)) return nullptr;
		jobject session = env->CallStaticObjectMethod(
		gHardwareRenderer.clazz, gHardwareRenderer.createHintSession, tidsArray);
		if (hasExceptionAndClear(env) \|\| !session) return nullptr;
		return new HintSessionWrapper(env, session);
		}

		~HintSessionWrapper() {
		if (!mSession) return;
		JNIEnv* env = getenv(mVm);
		env->CallStaticVoidMethod(gHardwareRenderer.clazz, gHardwareRenderer.closeHintSession,
		mSession);
		hasExceptionAndClear(env);
		env->DeleteGlobalRef(mSession);
		mSession = nullptr;
		}

		void updateTargetWorkDuration(long targetDurationNanos) {
		if (!mSession) return;
		JNIEnv* env = getenv(mVm);
		env->CallStaticVoidMethod(gHardwareRenderer.clazz,
		gHardwareRenderer.updateTargetWorkDuration, mSession,
		static_cast<jlong>(targetDurationNanos));
		hasExceptionAndClear(env);
		}

		void reportActualWorkDuration(long actualDurationNanos) {
		if (!mSession) return;
		JNIEnv* env = getenv(mVm);
		env->CallStaticVoidMethod(gHardwareRenderer.clazz,
		gHardwareRenderer.reportActualWorkDuration, mSession,
		static_cast<jlong>(actualDurationNanos));
		hasExceptionAndClear(env);
		}

		private:
		HintSessionWrapper(JNIEnv* env, jobject jobject) {
		env->GetJavaVM(&mVm);
		if (jobject) {
		mSession = env->NewGlobalRef(jobject);
		LOG_ALWAYS_FATAL_IF(!mSession, "Failed to make global ref");
		}
		}

		JavaVM* mVm = nullptr;
		jobject mSession = nullptr;
		};

		static void android_view_ThreadedRenderer_rotateProcessStatsBuffer(JNIEnv* env, jobject clazz) {
		RenderProxy::rotateProcessStatsBuffer();
		}
		@@ -235,12 +160,6 @@ static jlong android_view_ThreadedRenderer_createProxy(JNIEnv* env, jobject claz
		RootRenderNode* rootRenderNode = reinterpret_cast<RootRenderNode*>(rootRenderNodePtr);
		ContextFactoryImpl factory(rootRenderNode);
		RenderProxy* proxy = new RenderProxy(translucent, rootRenderNode, &factory);
		sp<HintSessionWrapper> wrapper = HintSessionWrapper::create(env, proxy);
		if (wrapper) {
		proxy->setHintSessionCallbacks(
		[wrapper](int64_t nanos) { wrapper->updateTargetWorkDuration(nanos); },
		[wrapper](int64_t nanos) { wrapper->reportActualWorkDuration(nanos); });
		}
		return (jlong) proxy;
		}

		@@ -1059,18 +978,6 @@ int register_android_view_ThreadedRenderer(JNIEnv* env) {
		gHardwareRenderer.invokePictureCapturedCallback = GetStaticMethodIDOrDie(env, hardwareRenderer,
		"invokePictureCapturedCallback",
		"(JLandroid/graphics/HardwareRenderer$PictureCapturedCallback;)V");
		gHardwareRenderer.createHintSession =
		GetStaticMethodIDOrDie(env, hardwareRenderer, "createHintSession",
		"([I)Landroid/os/PerformanceHintManager$Session;");
		gHardwareRenderer.updateTargetWorkDuration =
		GetStaticMethodIDOrDie(env, hardwareRenderer, "updateTargetWorkDuration",
		"(Landroid/os/PerformanceHintManager$Session;J)V");
		gHardwareRenderer.reportActualWorkDuration =
		GetStaticMethodIDOrDie(env, hardwareRenderer, "reportActualWorkDuration",
		"(Landroid/os/PerformanceHintManager$Session;J)V");
		gHardwareRenderer.closeHintSession =
		GetStaticMethodIDOrDie(env, hardwareRenderer, "closeHintSession",
		"(Landroid/os/PerformanceHintManager$Session;)V");

		jclass aSurfaceTransactionCallbackClass =
		FindClassOrDie(env, "android/graphics/HardwareRenderer$ASurfaceTransactionCallback");

libs/hwui/renderthread/DrawFrameTask.cpp

+113 −28

Original line number	Diff line number	Diff line
		@@ -16,6 +16,7 @@

		#include "DrawFrameTask.h"

		#include <dlfcn.h>
		#include <gui/TraceUtils.h>
		#include <utils/Log.h>
		#include <algorithm>
		@@ -26,11 +27,63 @@
		#include "../RenderNode.h"
		#include "CanvasContext.h"
		#include "RenderThread.h"
		#include "thread/CommonPool.h"

		namespace android {
		namespace uirenderer {
		namespace renderthread {

		namespace {

		typedef APerformanceHintManager* (*APH_getManager)();
		typedef APerformanceHintSession* (APH_createSession)(APerformanceHintManager, const int32_t*,
		size_t, int64_t);
		typedef void (APH_updateTargetWorkDuration)(APerformanceHintSession, int64_t);
		typedef void (APH_reportActualWorkDuration)(APerformanceHintSession, int64_t);
		typedef void (APH_closeSession)(APerformanceHintSession session);

		bool gAPerformanceHintBindingInitialized = false;
		APH_getManager gAPH_getManagerFn = nullptr;
		APH_createSession gAPH_createSessionFn = nullptr;
		APH_updateTargetWorkDuration gAPH_updateTargetWorkDurationFn = nullptr;
		APH_reportActualWorkDuration gAPH_reportActualWorkDurationFn = nullptr;
		APH_closeSession gAPH_closeSessionFn = nullptr;

		void ensureAPerformanceHintBindingInitialized() {
		if (gAPerformanceHintBindingInitialized) return;

		void* handle_ = dlopen("libandroid.so", RTLD_NOW \| RTLD_NODELETE);
		LOG_ALWAYS_FATAL_IF(handle_ == nullptr, "Failed to dlopen libandroid.so!");

		gAPH_getManagerFn = (APH_getManager)dlsym(handle_, "APerformanceHint_getManager");
		LOG_ALWAYS_FATAL_IF(gAPH_getManagerFn == nullptr,
		"Failed to find required symbol APerformanceHint_getManager!");

		gAPH_createSessionFn = (APH_createSession)dlsym(handle_, "APerformanceHint_createSession");
		LOG_ALWAYS_FATAL_IF(gAPH_createSessionFn == nullptr,
		"Failed to find required symbol APerformanceHint_createSession!");

		gAPH_updateTargetWorkDurationFn = (APH_updateTargetWorkDuration)dlsym(
		handle_, "APerformanceHint_updateTargetWorkDuration");
		LOG_ALWAYS_FATAL_IF(
		gAPH_updateTargetWorkDurationFn == nullptr,
		"Failed to find required symbol APerformanceHint_updateTargetWorkDuration!");

		gAPH_reportActualWorkDurationFn = (APH_reportActualWorkDuration)dlsym(
		handle_, "APerformanceHint_reportActualWorkDuration");
		LOG_ALWAYS_FATAL_IF(
		gAPH_reportActualWorkDurationFn == nullptr,
		"Failed to find required symbol APerformanceHint_reportActualWorkDuration!");

		gAPH_closeSessionFn = (APH_closeSession)dlsym(handle_, "APerformanceHint_closeSession");
		LOG_ALWAYS_FATAL_IF(gAPH_closeSessionFn == nullptr,
		"Failed to find required symbol APerformanceHint_closeSession!");

		gAPerformanceHintBindingInitialized = true;
		}

		} // namespace

		DrawFrameTask::DrawFrameTask()
		: mRenderThread(nullptr)
		, mContext(nullptr)
		@@ -39,17 +92,13 @@ DrawFrameTask::DrawFrameTask()

		DrawFrameTask::~DrawFrameTask() {}

		void DrawFrameTask::setContext(RenderThread* thread, CanvasContext* context,
		RenderNode* targetNode) {
		void DrawFrameTask::setContext(RenderThread* thread, CanvasContext* context, RenderNode* targetNode,
		int32_t uiThreadId, int32_t renderThreadId) {
		mRenderThread = thread;
		mContext = context;
		mTargetNode = targetNode;
		}

		void DrawFrameTask::setHintSessionCallbacks(std::function<void(int64_t)> updateTargetWorkDuration,
		std::function<void(int64_t)> reportActualWorkDuration) {
		mUpdateTargetWorkDuration = std::move(updateTargetWorkDuration);
		mReportActualWorkDuration = std::move(reportActualWorkDuration);
		mUiThreadId = uiThreadId;
		mRenderThreadId = renderThreadId;
		}

		void DrawFrameTask::pushLayerUpdate(DeferredLayerUpdater* layer) {
		@@ -144,9 +193,7 @@ void DrawFrameTask::run() {
		unblockUiThread();
		}

		// These member callbacks are effectively const as they are set once during init, so it's safe
		// to use these directly instead of making local copies.
		if (mUpdateTargetWorkDuration && mReportActualWorkDuration) {
		if (!mHintSessionWrapper) mHintSessionWrapper.emplace(mUiThreadId, mRenderThreadId);
		constexpr int64_t kSanityCheckLowerBound = 100000; // 0.1ms
		constexpr int64_t kSanityCheckUpperBound = 10000000000; // 10s
		int64_t targetWorkDuration = frameDeadline - intendedVsync;
		@@ -155,16 +202,16 @@ void DrawFrameTask::run() {
		targetWorkDuration < kSanityCheckUpperBound &&
		targetWorkDuration != mLastTargetWorkDuration) {
		mLastTargetWorkDuration = targetWorkDuration;
		mUpdateTargetWorkDuration(targetWorkDuration);
		mHintSessionWrapper->updateTargetWorkDuration(targetWorkDuration);
		}
		int64_t frameDuration = systemTime(SYSTEM_TIME_MONOTONIC) - frameStartTime;
		int64_t actualDuration = frameDuration -
		(std::min(syncDelayDuration, mLastDequeueBufferDuration)) -
		dequeueBufferDuration;
		if (actualDuration > kSanityCheckLowerBound && actualDuration < kSanityCheckUpperBound) {
		mReportActualWorkDuration(actualDuration);
		}
		mHintSessionWrapper->reportActualWorkDuration(actualDuration);
		}

		mLastDequeueBufferDuration = dequeueBufferDuration;
		}

		@@ -216,6 +263,44 @@ void DrawFrameTask::unblockUiThread() {
		mSignal.signal();
		}

		DrawFrameTask::HintSessionWrapper::HintSessionWrapper(int32_t uiThreadId, int32_t renderThreadId) {
		if (!Properties::useHintManager) return;
		if (uiThreadId < 0 \|\| renderThreadId < 0) return;

		ensureAPerformanceHintBindingInitialized();

		APerformanceHintManager* manager = gAPH_getManagerFn();
		if (!manager) return;

		std::vector<int32_t> tids = CommonPool::getThreadIds();
		tids.push_back(uiThreadId);
		tids.push_back(renderThreadId);

		// DrawFrameTask code will always set a target duration before reporting actual durations.
		// So this is just a placeholder value that's never used.
		int64_t dummyTargetDurationNanos = 16666667;
		mHintSession =
		gAPH_createSessionFn(manager, tids.data(), tids.size(), dummyTargetDurationNanos);
		}

		DrawFrameTask::HintSessionWrapper::~HintSessionWrapper() {
		if (mHintSession) {
		gAPH_closeSessionFn(mHintSession);
		}
		}

		void DrawFrameTask::HintSessionWrapper::updateTargetWorkDuration(long targetDurationNanos) {
		if (mHintSession) {
		gAPH_updateTargetWorkDurationFn(mHintSession, targetDurationNanos);
		}
		}

		void DrawFrameTask::HintSessionWrapper::reportActualWorkDuration(long actualDurationNanos) {
		if (mHintSession) {
		gAPH_reportActualWorkDurationFn(mHintSession, actualDurationNanos);
		}
		}

		} /* namespace renderthread */
		} /* namespace uirenderer */
		} /* namespace android */

libs/hwui/renderthread/DrawFrameTask.h

+19 −5

Original line number	Diff line number	Diff line
		@@ -16,8 +16,10 @@
		#ifndef DRAWFRAMETASK_H
		#define DRAWFRAMETASK_H

		#include <optional>
		#include <vector>

		#include <performance_hint_private.h>
		#include <utils/Condition.h>
		#include <utils/Mutex.h>
		#include <utils/StrongPointer.h>
		@@ -60,9 +62,8 @@ public:
		DrawFrameTask();
		virtual ~DrawFrameTask();

		void setContext(RenderThread* thread, CanvasContext* context, RenderNode* targetNode);
		void setHintSessionCallbacks(std::function<void(int64_t)> updateTargetWorkDuration,
		std::function<void(int64_t)> reportActualWorkDuration);
		void setContext(RenderThread* thread, CanvasContext* context, RenderNode* targetNode,
		int32_t uiThreadId, int32_t renderThreadId);
		void setContentDrawBounds(int left, int top, int right, int bottom) {
		mContentDrawBounds.set(left, top, right, bottom);
		}
		@@ -85,6 +86,18 @@ public:
		}

		private:
		class HintSessionWrapper {
		public:
		HintSessionWrapper(int32_t uiThreadId, int32_t renderThreadId);
		~HintSessionWrapper();

		void updateTargetWorkDuration(long targetDurationNanos);
		void reportActualWorkDuration(long actualDurationNanos);

		private:
		APerformanceHintSession* mHintSession = nullptr;
		};

		void postAndWait();
		bool syncFrameState(TreeInfo& info);
		void unblockUiThread();
		@@ -95,6 +108,8 @@ private:
		RenderThread* mRenderThread;
		CanvasContext* mContext;
		RenderNode* mTargetNode = nullptr;
		int32_t mUiThreadId = -1;
		int32_t mRenderThreadId = -1;
		Rect mContentDrawBounds;

		/*********************************************
		@@ -112,8 +127,7 @@ private:

		nsecs_t mLastDequeueBufferDuration = 0;
		nsecs_t mLastTargetWorkDuration = 0;
		std::function<void(int64_t)> mUpdateTargetWorkDuration;
		std::function<void(int64_t)> mReportActualWorkDuration;
		std::optional<HintSessionWrapper> mHintSessionWrapper;
		};

		} /* namespace renderthread */

libs/hwui/renderthread/RenderProxy.cpp

+5 −8

Original line number	Diff line number	Diff line
		@@ -29,6 +29,8 @@
		#include "utils/Macros.h"
		#include "utils/TimeUtils.h"

		#include <pthread.h>

		namespace android {
		namespace uirenderer {
		namespace renderthread {
		@@ -39,7 +41,8 @@ RenderProxy::RenderProxy(bool translucent, RenderNode* rootRenderNode,
		mContext = mRenderThread.queue().runSync([&]() -> CanvasContext* {
		return CanvasContext::create(mRenderThread, translucent, rootRenderNode, contextFactory);
		});
		mDrawFrameTask.setContext(&mRenderThread, mContext, rootRenderNode);
		mDrawFrameTask.setContext(&mRenderThread, mContext, rootRenderNode,
		pthread_gettid_np(pthread_self()), getRenderThreadTid());
		}

		RenderProxy::~RenderProxy() {
		@@ -48,7 +51,7 @@ RenderProxy::~RenderProxy() {

		void RenderProxy::destroyContext() {
		if (mContext) {
		mDrawFrameTask.setContext(nullptr, nullptr, nullptr);
		mDrawFrameTask.setContext(nullptr, nullptr, nullptr, -1, -1);
		// This is also a fence as we need to be certain that there are no
		// outstanding mDrawFrame tasks posted before it is destroyed
		mRenderThread.queue().runSync([this]() { delete mContext; });
		@@ -76,12 +79,6 @@ void RenderProxy::setName(const char* name) {
		mRenderThread.queue().runSync([this, name]() { mContext->setName(std::string(name)); });
		}

		void RenderProxy::setHintSessionCallbacks(std::function<void(int64_t)> updateTargetWorkDuration,
		std::function<void(int64_t)> reportActualWorkDuration) {
		mDrawFrameTask.setHintSessionCallbacks(std::move(updateTargetWorkDuration),
		std::move(reportActualWorkDuration));
		}

		void RenderProxy::setSurface(ANativeWindow* window, bool enableTimeout) {
		if (window) { ANativeWindow_acquire(window); }
		mRenderThread.queue().post([this, win = window, enableTimeout]() mutable {