[SurfaceFlinger] Allow DispSync to be GMock'd (41be5d28) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/BufferQueueLayer.cpp

+3 −2

Original line number	Diff line number	Diff line
		@@ -245,8 +245,9 @@ status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t
		LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions,
		getProducerStickyTransform() != 0, mName.string(), mOverrideScalingMode,
		getTransformToDisplayInverse(), mFreezeGeometryUpdates);
		status_t updateResult = mConsumer->updateTexImage(&r, mFlinger->mPrimaryDispSync, &mAutoRefresh,
		&queuedBuffer, mLastFrameNumberReceived);
		status_t updateResult =
		mConsumer->updateTexImage(&r, *mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer,
		mLastFrameNumberReceived);
		if (updateResult == BufferQueue::PRESENT_LATER) {
		// Producer doesn't want buffer to be displayed yet. Signal a
		// layer update so we check again at the next opportunity.

services/surfaceflinger/DispSync.cpp

+6 −0

Original line number	Diff line number	Diff line
		@@ -40,6 +40,10 @@ using std::min;

		namespace android {

		DispSync::~DispSync() = default;

		namespace impl {

		// Setting this to true enables verbose tracing that can be used to debug
		// vsync event model or phase issues.
		static const bool kTraceDetailedInfo = false;
		@@ -707,4 +711,6 @@ void DispSync::dump(String8& result) const {
		result.appendFormat("current monotonic time: %" PRId64 "\n", now);
		}

		} // namespace impl

		} // namespace android

services/surfaceflinger/DispSync.h

+48 −22

Original line number	Diff line number	Diff line
		@@ -31,6 +31,36 @@ namespace android {

		class String8;
		class FenceTime;

		class DispSync {
		public:
		class Callback {
		public:
		virtual ~Callback() = default;
		virtual void onDispSyncEvent(nsecs_t when) = 0;
		};

		virtual ~DispSync();

		virtual void reset() = 0;
		virtual bool addPresentFence(const std::shared_ptr<FenceTime>&) = 0;
		virtual void beginResync() = 0;
		virtual bool addResyncSample(nsecs_t timestamp) = 0;
		virtual void endResync() = 0;
		virtual void setPeriod(nsecs_t period) = 0;
		virtual nsecs_t getPeriod() = 0;
		virtual void setRefreshSkipCount(int count) = 0;
		virtual status_t addEventListener(const char* name, nsecs_t phase, Callback* callback) = 0;
		virtual status_t removeEventListener(Callback* callback) = 0;
		virtual status_t changePhaseOffset(Callback* callback, nsecs_t phase) = 0;
		virtual nsecs_t computeNextRefresh(int periodOffset) const = 0;
		virtual void setIgnorePresentFences(bool ignore) = 0;

		virtual void dump(String8& result) const = 0;
		};

		namespace impl {

		class DispSyncThread;

		// DispSync maintains a model of the periodic hardware-based vsync events of a
		@@ -46,21 +76,15 @@ class DispSyncThread;
		// current model accurately represents the hardware event times it will return
		// false to indicate that a resynchronization (via addResyncSample) is not
		// needed.
		class DispSync {
		public:
		class Callback {
		class DispSync : public android::DispSync {
		public:
		virtual ~Callback(){};
		virtual void onDispSyncEvent(nsecs_t when) = 0;
		};

		explicit DispSync(const char* name);
		~DispSync();
		~DispSync() override;

		void init(bool hasSyncFramework, int64_t dispSyncPresentTimeOffset);

		// reset clears the resync samples and error value.
		void reset();
		void reset() override;

		// addPresentFence adds a fence for use in validating the current vsync
		// event model. The fence need not be signaled at the time
		@@ -71,7 +95,7 @@ public:
		//
		// This method should be called with the retire fence from each HWComposer
		// set call that affects the display.
		bool addPresentFence(const std::shared_ptr<FenceTime>& fenceTime);
		bool addPresentFence(const std::shared_ptr<FenceTime>& fenceTime) override;

		// The beginResync, addResyncSample, and endResync methods are used to re-
		// synchronize the DispSync's model to the hardware vsync events. The re-
		@@ -84,45 +108,45 @@ public:
		// is turned on (i.e. once immediately after it's turned on) and whenever
		// addPresentFence returns true indicating that the model has drifted away
		// from the hardware vsync events.
		void beginResync();
		bool addResyncSample(nsecs_t timestamp);
		void endResync();
		void beginResync() override;
		bool addResyncSample(nsecs_t timestamp) override;
		void endResync() override;

		// The setPeriod method sets the vsync event model's period to a specific
		// value. This should be used to prime the model when a display is first
		// turned on. It should NOT be used after that.
		void setPeriod(nsecs_t period);
		void setPeriod(nsecs_t period) override;

		// The getPeriod method returns the current vsync period.
		nsecs_t getPeriod();
		nsecs_t getPeriod() override;

		// setRefreshSkipCount specifies an additional number of refresh
		// cycles to skip. For example, on a 60Hz display, a skip count of 1
		// will result in events happening at 30Hz. Default is zero. The idea
		// is to sacrifice smoothness for battery life.
		void setRefreshSkipCount(int count);
		void setRefreshSkipCount(int count) override;

		// addEventListener registers a callback to be called repeatedly at the
		// given phase offset from the hardware vsync events. The callback is
		// called from a separate thread and it should return reasonably quickly
		// (i.e. within a few hundred microseconds).
		status_t addEventListener(const char* name, nsecs_t phase, Callback* callback);
		status_t addEventListener(const char* name, nsecs_t phase, Callback* callback) override;

		// removeEventListener removes an already-registered event callback. Once
		// this method returns that callback will no longer be called by the
		// DispSync object.
		status_t removeEventListener(Callback* callback);
		status_t removeEventListener(Callback* callback) override;

		// changePhaseOffset changes the phase offset of an already-registered event callback. The
		// method will make sure that there is no skipping or double-firing on the listener per frame,
		// even when changing the offsets multiple times.
		status_t changePhaseOffset(Callback* callback, nsecs_t phase);
		status_t changePhaseOffset(Callback* callback, nsecs_t phase) override;

		// computeNextRefresh computes when the next refresh is expected to begin.
		// The periodOffset value can be used to move forward or backward; an
		// offset of zero is the next refresh, -1 is the previous refresh, 1 is
		// the refresh after next. etc.
		nsecs_t computeNextRefresh(int periodOffset) const;
		nsecs_t computeNextRefresh(int periodOffset) const override;

		// In certain situations the present fences aren't a good indicator of vsync
		// time, e.g. when vr flinger is active, or simply aren't available,
		@@ -130,10 +154,10 @@ public:
		// whether or not DispSync ignores present fences. If present fences are
		// ignored, DispSync will always ask for hardware vsync events by returning
		// true from addPresentFence() and addResyncSample().
		void setIgnorePresentFences(bool ignore);
		void setIgnorePresentFences(bool ignore) override;

		// dump appends human-readable debug info to the result string.
		void dump(String8& result) const;
		void dump(String8& result) const override;

		private:
		void updateModelLocked();
		@@ -206,6 +230,8 @@ private:
		std::unique_ptr<Callback> mZeroPhaseTracer;
		};

		} // namespace impl

		} // namespace android

		#endif // ANDROID_DISPSYNC_H

services/surfaceflinger/SurfaceFlinger.cpp

+26 −21

Original line number	Diff line number	Diff line
		@@ -264,7 +264,6 @@ SurfaceFlinger::SurfaceFlinger(SurfaceFlinger::SkipInitializationTag)
		mDebugInTransaction(0),
		mLastTransactionTime(0),
		mForceFullDamage(false),
		mPrimaryDispSync("PrimaryDispSync"),
		mPrimaryHWVsyncEnabled(false),
		mHWVsyncAvailable(false),
		mHasPoweredOff(false),
		@@ -325,7 +324,13 @@ SurfaceFlinger::SurfaceFlinger() : SurfaceFlinger(SkipInitialization) {
		}
		ALOGV("Primary Display Orientation is set to %2d.", mPrimaryDisplayOrientation);

		mPrimaryDispSync.init(SurfaceFlinger::hasSyncFramework, SurfaceFlinger::dispSyncPresentTimeOffset);
		// Note: We create a local temporary with the real DispSync implementation
		// type temporarily so we can initialize it with the configured values,
		// before storing it for more generic use using the interface type.
		auto primaryDispSync = std::make_unique<impl::DispSync>("PrimaryDispSync");
		primaryDispSync->init(SurfaceFlinger::hasSyncFramework,
		SurfaceFlinger::dispSyncPresentTimeOffset);
		mPrimaryDispSync = std::move(primaryDispSync);

		// debugging stuff...
		char value[PROPERTY_VALUE_MAX];
		@@ -703,14 +708,14 @@ void SurfaceFlinger::init() {

		// start the EventThread
		mEventThreadSource =
		std::make_unique<DispSyncSource>(&mPrimaryDispSync, SurfaceFlinger::vsyncPhaseOffsetNs,
		true, "app");
		std::make_unique<DispSyncSource>(mPrimaryDispSync.get(),
		SurfaceFlinger::vsyncPhaseOffsetNs, true, "app");
		mEventThread = std::make_unique<impl::EventThread>(mEventThreadSource.get(),
		[this] { resyncWithRateLimit(); },
		impl::EventThread::InterceptVSyncsCallback(),
		"appEventThread");
		mSfEventThreadSource =
		std::make_unique<DispSyncSource>(&mPrimaryDispSync,
		std::make_unique<DispSyncSource>(mPrimaryDispSync.get(),
		SurfaceFlinger::sfVsyncPhaseOffsetNs, true, "sf");

		mSFEventThread =
		@@ -996,8 +1001,8 @@ status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>&, DisplayStatInfo* st

		// FIXME for now we always return stats for the primary display
		memset(stats, 0, sizeof(*stats));
		stats->vsyncTime = mPrimaryDispSync.computeNextRefresh(0);
		stats->vsyncPeriod = mPrimaryDispSync.getPeriod();
		stats->vsyncTime = mPrimaryDispSync->computeNextRefresh(0);
		stats->vsyncPeriod = mPrimaryDispSync->getPeriod();
		return NO_ERROR;
		}

		@@ -1295,7 +1300,7 @@ void SurfaceFlinger::run() {
		void SurfaceFlinger::enableHardwareVsync() {
		Mutex::Autolock _l(mHWVsyncLock);
		if (!mPrimaryHWVsyncEnabled && mHWVsyncAvailable) {
		mPrimaryDispSync.beginResync();
		mPrimaryDispSync->beginResync();
		mEventControlThread->setVsyncEnabled(true);
		mPrimaryHWVsyncEnabled = true;
		}
		@@ -1320,11 +1325,11 @@ void SurfaceFlinger::resyncToHardwareVsync(bool makeAvailable) {
		const auto activeConfig = getHwComposer().getActiveConfig(displayId);
		const nsecs_t period = activeConfig->getVsyncPeriod();

		mPrimaryDispSync.reset();
		mPrimaryDispSync.setPeriod(period);
		mPrimaryDispSync->reset();
		mPrimaryDispSync->setPeriod(period);

		if (!mPrimaryHWVsyncEnabled) {
		mPrimaryDispSync.beginResync();
		mPrimaryDispSync->beginResync();
		mEventControlThread->setVsyncEnabled(true);
		mPrimaryHWVsyncEnabled = true;
		}
		@@ -1334,7 +1339,7 @@ void SurfaceFlinger::disableHardwareVsync(bool makeUnavailable) {
		Mutex::Autolock _l(mHWVsyncLock);
		if (mPrimaryHWVsyncEnabled) {
		mEventControlThread->setVsyncEnabled(false);
		mPrimaryDispSync.endResync();
		mPrimaryDispSync->endResync();
		mPrimaryHWVsyncEnabled = false;
		}
		if (makeUnavailable) {
		@@ -1379,7 +1384,7 @@ void SurfaceFlinger::onVsyncReceived(int32_t sequenceId, hwc2_display_t hwcDispl
		{ // Scope for the lock
		Mutex::Autolock _l(mHWVsyncLock);
		if (mPrimaryHWVsyncEnabled) {
		needsHwVsync = mPrimaryDispSync.addResyncSample(timestamp);
		needsHwVsync = mPrimaryDispSync->addResyncSample(timestamp);
		}
		}

		@@ -1506,8 +1511,8 @@ void SurfaceFlinger::updateVrFlinger() {

		// The present fences returned from vr_hwc are not an accurate
		// representation of vsync times.
		mPrimaryDispSync.setIgnorePresentFences(
		getBE().mHwc->isUsingVrComposer() \|\| !hasSyncFramework);
		mPrimaryDispSync->setIgnorePresentFences(getBE().mHwc->isUsingVrComposer() \|\|
		!hasSyncFramework);

		// Use phase of 0 since phase is not known.
		// Use latency of 0, which will snap to the ideal latency.
		@@ -1770,8 +1775,8 @@ void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)
		auto presentFenceTime = std::make_shared<FenceTime>(mPreviousPresentFence);
		getBE().mDisplayTimeline.push(presentFenceTime);

		nsecs_t vsyncPhase = mPrimaryDispSync.computeNextRefresh(0);
		nsecs_t vsyncInterval = mPrimaryDispSync.getPeriod();
		nsecs_t vsyncPhase = mPrimaryDispSync->computeNextRefresh(0);
		nsecs_t vsyncInterval = mPrimaryDispSync->getPeriod();

		// We use the refreshStartTime which might be sampled a little later than
		// when we started doing work for this frame, but that should be okay
		@@ -1794,7 +1799,7 @@ void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)
		});

		if (presentFenceTime->isValid()) {
		if (mPrimaryDispSync.addPresentFence(presentFenceTime)) {
		if (mPrimaryDispSync->addPresentFence(presentFenceTime)) {
		enableHardwareVsync();
		} else {
		disableHardwareVsync(false);
		@@ -2873,7 +2878,7 @@ bool SurfaceFlinger::handlePageFlip()
		mDrawingState.traverseInZOrder([&](Layer* layer) {
		if (layer->hasReadyFrame()) {
		frameQueued = true;
		if (layer->shouldPresentNow(mPrimaryDispSync)) {
		if (layer->shouldPresentNow(*mPrimaryDispSync)) {
		mLayersWithQueuedFrames.push_back(layer);
		} else {
		layer->useEmptyDamage();
		@@ -3966,7 +3971,7 @@ status_t SurfaceFlinger::doDump(int fd, const Vector<String16>& args, bool asPro
		if ((index < numArgs) &&
		(args[index] == String16("--dispsync"))) {
		index++;
		mPrimaryDispSync.dump(result);
		mPrimaryDispSync->dump(result);
		dumpAll = false;
		}

		@@ -4749,7 +4754,7 @@ status_t SurfaceFlinger::onTransact(
		// Needs to be shifted to proper binder interface when we productize
		case 1016: {
		n = data.readInt32();
		mPrimaryDispSync.setRefreshSkipCount(n);
		mPrimaryDispSync->setRefreshSkipCount(n);
		return NO_ERROR;
		}
		case 1017: {

services/surfaceflinger/SurfaceFlinger.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -853,7 +853,7 @@ private:
		// these are thread safe
		mutable std::unique_ptr<MessageQueue> mEventQueue{std::make_unique<impl::MessageQueue>()};
		FrameTracker mAnimFrameTracker;
		DispSync mPrimaryDispSync;
		std::unique_ptr<DispSync> mPrimaryDispSync;
		int mPrimaryDisplayOrientation = DisplayState::eOrientationDefault;

		// protected by mDestroyedLayerLock;