Merge "Remove debug.sf.latch_unsignaled sysprop and LatchUnsignaledConfig::ALWAYS" (f75b44b6) · Commits · e / devices / smdk4412 / android_frameworks_native

services/surfaceflinger/SurfaceFlinger.cpp

+2 −15

Original line number	Diff line number	Diff line
		@@ -497,10 +497,6 @@ LatchUnsignaledConfig SurfaceFlinger::getLatchUnsignaledConfig() {
		return LatchUnsignaledConfig::AutoSingleLayer;
		}

		if (base::GetBoolProperty("debug.sf.latch_unsignaled"s, false)) {
		return LatchUnsignaledConfig::Always;
		}

		return LatchUnsignaledConfig::Disabled;
		}

		@@ -4364,12 +4360,10 @@ TransactionHandler::TransactionReadiness SurfaceFlinger::transactionReadyBufferC
		return TraverseBuffersReturnValues::STOP_TRAVERSAL;
		}

		// ignore the acquire fence if LatchUnsignaledConfig::Always is set.
		const bool checkAcquireFence = enableLatchUnsignaledConfig != LatchUnsignaledConfig::Always;
		const bool acquireFenceAvailable = s.bufferData &&
		s.bufferData->flags.test(BufferData::BufferDataChange::fenceChanged) &&
		s.bufferData->acquireFence;
		const bool fenceSignaled = !checkAcquireFence \|\| !acquireFenceAvailable \|\|
		const bool fenceSignaled = !acquireFenceAvailable \|\|
		s.bufferData->acquireFence->getStatus() != Fence::Status::Unsignaled;
		if (!fenceSignaled) {
		// check fence status
		@@ -4463,12 +4457,10 @@ TransactionHandler::TransactionReadiness SurfaceFlinger::transactionReadyBufferC
		return TraverseBuffersReturnValues::STOP_TRAVERSAL;
		}

		// ignore the acquire fence if LatchUnsignaledConfig::Always is set.
		const bool checkAcquireFence = enableLatchUnsignaledConfig != LatchUnsignaledConfig::Always;
		const bool acquireFenceAvailable = s.bufferData &&
		s.bufferData->flags.test(BufferData::BufferDataChange::fenceChanged) &&
		s.bufferData->acquireFence;
		const bool fenceSignaled = !checkAcquireFence \|\| !acquireFenceAvailable \|\|
		const bool fenceSignaled = !acquireFenceAvailable \|\|
		s.bufferData->acquireFence->getStatus() != Fence::Status::Unsignaled;
		if (!fenceSignaled) {
		// check fence status
		@@ -4574,11 +4566,6 @@ bool SurfaceFlinger::shouldLatchUnsignaled(const layer_state_t& state, size_t nu
		return false;
		}

		if (enableLatchUnsignaledConfig == LatchUnsignaledConfig::Always) {
		ATRACE_FORMAT_INSTANT("%s: true (LatchUnsignaledConfig::Always)", __func__);
		return true;
		}

		// We only want to latch unsignaled when a single layer is updated in this
		// transaction (i.e. not a blast sync transaction).
		if (numStates != 1) {

services/surfaceflinger/fuzzer/surfaceflinger_fuzzer.cpp

+0 −1

Original line number	Diff line number	Diff line
		@@ -24,7 +24,6 @@
		namespace android::fuzz {

		static constexpr LatchUnsignaledConfig kLatchUnsignaledConfig[] = {
		LatchUnsignaledConfig::Always,
		LatchUnsignaledConfig::AutoSingleLayer,
		LatchUnsignaledConfig::Disabled,
		};

services/surfaceflinger/tests/unittests/TransactionApplicationTest.cpp

+1 −222

Original line number	Diff line number	Diff line
		@@ -15,7 +15,7 @@
		*/

		#undef LOG_TAG
		#define LOG_TAG "CompositionTest"
		#define LOG_TAG "TransactionApplicationTest"

		#include <compositionengine/Display.h>
		#include <compositionengine/mock/DisplaySurface.h>
		@@ -855,227 +855,6 @@ TEST_F(LatchUnsignaledDisabledTest, Flush_KeepInTheUnsignaledTheQueue) {
		kExpectedTransactionsPending);
		}

		class LatchUnsignaledAlwaysTest : public LatchUnsignaledTest {
		public:
		void SetUp() override {
		LatchUnsignaledTest::SetUp();
		SurfaceFlinger::enableLatchUnsignaledConfig = LatchUnsignaledConfig::Always;
		}
		};

		TEST_F(LatchUnsignaledAlwaysTest, Flush_RemovesSignaledFromTheQueue) {
		const sp<IBinder> kApplyToken =
		IInterface::asBinder(TransactionCompletedListener::getIInstance());
		const auto kLayerId = 1;
		const auto kExpectedTransactionsPending = 0u;

		const auto signaledTransaction =
		createTransactionInfo(kApplyToken,
		{createComposerState(kLayerId, fence(Fence::Status::Signaled),
		layer_state_t::eBufferChanged)});
		setTransactionStates({signaledTransaction}, kExpectedTransactionsPending);
		}

		TEST_F(LatchUnsignaledAlwaysTest, Flush_RemovesFromTheQueue) {
		const sp<IBinder> kApplyToken =
		IInterface::asBinder(TransactionCompletedListener::getIInstance());
		const auto kLayerId = 1;
		const auto kExpectedTransactionsPending = 0u;

		const auto unsignaledTransaction =
		createTransactionInfo(kApplyToken,
		{createComposerState(kLayerId, fence(Fence::Status::Unsignaled),
		layer_state_t::eBufferChanged)});
		setTransactionStates({unsignaledTransaction}, kExpectedTransactionsPending);
		}

		TEST_F(LatchUnsignaledAlwaysTest, Flush_RemovesFromTheQueueSameLayerId) {
		const sp<IBinder> kApplyToken =
		IInterface::asBinder(TransactionCompletedListener::getIInstance());
		const auto kLayerId = 1;
		const auto kExpectedTransactionsPending = 0u;

		const auto mixedTransaction =
		createTransactionInfo(kApplyToken,
		{createComposerState(kLayerId, fence(Fence::Status::Unsignaled),
		layer_state_t::eBufferChanged),
		createComposerState(kLayerId, fence(Fence::Status::Signaled),
		layer_state_t::eBufferChanged)});
		setTransactionStates({mixedTransaction}, kExpectedTransactionsPending);
		}

		TEST_F(LatchUnsignaledAlwaysTest, Flush_RemovesFromTheQueueDifferentLayerId) {
		const sp<IBinder> kApplyToken =
		IInterface::asBinder(TransactionCompletedListener::getIInstance());
		const auto kLayerId1 = 1;
		const auto kLayerId2 = 2;
		const auto kExpectedTransactionsPending = 0u;

		const auto mixedTransaction =
		createTransactionInfo(kApplyToken,
		{createComposerState(kLayerId1, fence(Fence::Status::Unsignaled),
		layer_state_t::eBufferChanged),
		createComposerState(kLayerId2, fence(Fence::Status::Signaled),
		layer_state_t::eBufferChanged)});
		setTransactionStates({mixedTransaction}, kExpectedTransactionsPending);
		}

		TEST_F(LatchUnsignaledAlwaysTest, Flush_RemovesSignaledFromTheQueue_MultipleLayers) {
		const sp<IBinder> kApplyToken =
		IInterface::asBinder(TransactionCompletedListener::getIInstance());
		const auto kLayerId1 = 1;
		const auto kLayerId2 = 2;
		const auto kExpectedTransactionsPending = 0u;

		const auto signaledTransaction =
		createTransactionInfo(kApplyToken,
		{
		createComposerState(kLayerId1,
		fence(Fence::Status::Signaled),
		layer_state_t::eBufferChanged),
		});
		const auto signaledTransaction2 =
		createTransactionInfo(kApplyToken,
		{
		createComposerState(kLayerId2,
		fence(Fence::Status::Signaled),
		layer_state_t::eBufferChanged),
		});
		setTransactionStates({signaledTransaction, signaledTransaction2}, kExpectedTransactionsPending);
		}

		TEST_F(LatchUnsignaledAlwaysTest, Flush_RemovesFromTheQueueDifferentApplyToken) {
		const sp<IBinder> kApplyToken1 =
		IInterface::asBinder(TransactionCompletedListener::getIInstance());
		const sp<IBinder> kApplyToken2 = sp<BBinder>::make();
		const auto kLayerId1 = 1;
		const auto kLayerId2 = 2;
		const auto kExpectedTransactionsPending = 0u;

		const auto signaledTransaction =
		createTransactionInfo(kApplyToken1,
		{
		createComposerState(kLayerId1,
		fence(Fence::Status::Signaled),
		layer_state_t::eBufferChanged),
		});
		const auto unsignaledTransaction =
		createTransactionInfo(kApplyToken2,
		{
		createComposerState(kLayerId2,
		fence(Fence::Status::Unsignaled),
		layer_state_t::eBufferChanged),
		});
		setTransactionStates({signaledTransaction, unsignaledTransaction},
		kExpectedTransactionsPending);
		}

		TEST_F(LatchUnsignaledAlwaysTest, Flush_RemovesUnsignaledFromTheQueueSameApplyToken) {
		const sp<IBinder> kApplyToken =
		IInterface::asBinder(TransactionCompletedListener::getIInstance());
		const auto kLayerId1 = 1;
		const auto kLayerId2 = 2;
		const auto kExpectedTransactionsPending = 0u;

		const auto unsignaledTransaction =
		createTransactionInfo(kApplyToken,
		{
		createComposerState(kLayerId1,
		fence(Fence::Status::Unsignaled),
		layer_state_t::eBufferChanged),
		});
		const auto signaledTransaction =
		createTransactionInfo(kApplyToken,
		{
		createComposerState(kLayerId2,
		fence(Fence::Status::Signaled),
		layer_state_t::eBufferChanged),
		});
		setTransactionStates({unsignaledTransaction, signaledTransaction},
		kExpectedTransactionsPending);
		}

		TEST_F(LatchUnsignaledAlwaysTest, Flush_RemovesUnsignaledFromTheQueue) {
		const sp<IBinder> kApplyToken1 =
		IInterface::asBinder(TransactionCompletedListener::getIInstance());
		const sp<IBinder> kApplyToken2 = sp<BBinder>::make();
		const auto kLayerId1 = 1;
		const auto kLayerId2 = 2;
		const auto kExpectedTransactionsPending = 0u;

		const auto unsignaledTransaction =
		createTransactionInfo(kApplyToken1,
		{
		createComposerState(kLayerId1,
		fence(Fence::Status::Unsignaled),
		layer_state_t::eBufferChanged),
		});
		const auto unsignaledTransaction2 =
		createTransactionInfo(kApplyToken2,
		{
		createComposerState(kLayerId2,
		fence(Fence::Status::Unsignaled),
		layer_state_t::eBufferChanged),
		});
		setTransactionStates({unsignaledTransaction, unsignaledTransaction2},
		kExpectedTransactionsPending);
		}

		TEST_F(LatchUnsignaledAlwaysTest, RespectsBackPressureFlag) {
		const sp<IBinder> kApplyToken1 =
		IInterface::asBinder(TransactionCompletedListener::getIInstance());
		const sp<IBinder> kApplyToken2 = sp<BBinder>::make();
		const auto kLayerId1 = 1;
		const auto kExpectedTransactionsPending = 1u;
		auto layer =
		sp<Layer>::make(LayerCreationArgs(mFlinger.flinger(), nullptr, "TestLayer", 0, {}));
		auto layerHandle = layer->getHandle();
		const auto setBackPressureFlagTransaction =
		createTransactionInfo(kApplyToken1,
		{createComposerState(kLayerId1, fence(Fence::Status::Unsignaled),
		layer_state_t::eBufferChanged \|
		layer_state_t::eFlagsChanged,
		{layerHandle})});
		setTransactionStates({setBackPressureFlagTransaction}, 0u);

		const auto unsignaledTransaction =
		createTransactionInfo(kApplyToken1,
		{
		createComposerState(kLayerId1,
		fence(Fence::Status::Unsignaled),
		layer_state_t::eBufferChanged,
		{layerHandle}),
		});
		const auto unsignaledTransaction2 =
		createTransactionInfo(kApplyToken1,
		{
		createComposerState(kLayerId1,
		fence(Fence::Status::Unsignaled),
		layer_state_t::eBufferChanged,
		{layerHandle}),
		});
		setTransactionStates({unsignaledTransaction, unsignaledTransaction2},
		kExpectedTransactionsPending);
		}

		TEST_F(LatchUnsignaledAlwaysTest, LatchUnsignaledWhenEarlyOffset) {
		const sp<IBinder> kApplyToken =
		IInterface::asBinder(TransactionCompletedListener::getIInstance());
		const auto kLayerId = 1;
		const auto kExpectedTransactionsPending = 0u;

		const auto unsignaledTransaction =
		createTransactionInfo(kApplyToken,
		{
		createComposerState(kLayerId,
		fence(Fence::Status::Unsignaled),
		layer_state_t::eBufferChanged),
		});

		modulateVsync();
		setTransactionStates({unsignaledTransaction}, kExpectedTransactionsPending);
		}

		TEST(TransactionHandlerTest, QueueTransaction) {
		TransactionHandler handler;
		TransactionState transaction;