Merge "SF: Simplify layer tracing" (0287549a) · Commits · e / devices / smdk4412 / android_frameworks_native

services/surfaceflinger/Android.bp

+1 −1

Original line number	Diff line number	Diff line
		@@ -201,7 +201,7 @@ filegroup {
		"SurfaceFlinger.cpp",
		"SurfaceFlingerDefaultFactory.cpp",
		"SurfaceInterceptor.cpp",
		"SurfaceTracing.cpp",
		"Tracing/LayerTracing.cpp",
		"Tracing/TransactionProtoParser.cpp",
		"TransactionCallbackInvoker.cpp",
		"TunnelModeEnabledReporter.cpp",

services/surfaceflinger/Layer.cpp

+77 −86

Original line number	Diff line number	Diff line
		@@ -2005,7 +2005,7 @@ LayerProto* Layer::writeToProto(LayersProto& layersProto, uint32_t traceFlags,
		writeToProtoDrawingState(layerProto, traceFlags, display);
		writeToProtoCommonState(layerProto, LayerVector::StateSet::Drawing, traceFlags);

		if (traceFlags & SurfaceTracing::TRACE_COMPOSITION) {
		if (traceFlags & LayerTracing::TRACE_COMPOSITION) {
		// Only populate for the primary display.
		if (display) {
		const Hwc2::IComposerClient::Composition compositionType = getCompositionType(*display);
		@@ -2023,9 +2023,6 @@ LayerProto* Layer::writeToProto(LayersProto& layersProto, uint32_t traceFlags,
		void Layer::writeToProtoDrawingState(LayerProto* layerInfo, uint32_t traceFlags,
		const DisplayDevice* display) {
		const ui::Transform transform = getTransform();

		if (traceFlags & SurfaceTracing::TRACE_CRITICAL) {

		auto buffer = getBuffer();
		if (buffer != nullptr) {
		LayerProtoHelper::writeToProto(buffer,
		@@ -2049,7 +2046,7 @@ void Layer::writeToProtoDrawingState(LayerProto* layerInfo, uint32_t traceFlags,
		LayerProtoHelper::writePositionToProto(transform.tx(), transform.ty(),
		[&]() { return layerInfo->mutable_position(); });
		LayerProtoHelper::writeToProto(mBounds, [&]() { return layerInfo->mutable_bounds(); });
		if (traceFlags & SurfaceTracing::TRACE_COMPOSITION) {
		if (traceFlags & LayerTracing::TRACE_COMPOSITION) {
		LayerProtoHelper::writeToProto(getVisibleRegion(display),
		[&]() { return layerInfo->mutable_visible_region(); });
		}
		@@ -2057,9 +2054,7 @@ void Layer::writeToProtoDrawingState(LayerProto* layerInfo, uint32_t traceFlags,
		[&]() { return layerInfo->mutable_damage_region(); });

		if (hasColorTransform()) {
		LayerProtoHelper::writeToProto(getColorTransform(),
		layerInfo->mutable_color_transform());
		}
		LayerProtoHelper::writeToProto(getColorTransform(), layerInfo->mutable_color_transform());
		}

		LayerProtoHelper::writeToProto(mSourceBounds,
		@@ -2079,7 +2074,6 @@ void Layer::writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet

		ui::Transform requestedTransform = state.transform;

		if (traceFlags & SurfaceTracing::TRACE_CRITICAL) {
		layerInfo->set_id(sequence);
		layerInfo->set_name(getName().c_str());
		layerInfo->set_type(getType());
		@@ -2101,8 +2095,7 @@ void Layer::writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet
		layerInfo->set_layer_stack(getLayerStack().id);
		layerInfo->set_z(state.z);

		LayerProtoHelper::writePositionToProto(requestedTransform.tx(), requestedTransform.ty(),
		[&]() {
		LayerProtoHelper::writePositionToProto(requestedTransform.tx(), requestedTransform.ty(), [&]() {
		return layerInfo->mutable_requested_position();
		});

		@@ -2113,7 +2106,6 @@ void Layer::writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet

		layerInfo->set_is_opaque(isOpaque(state));


		layerInfo->set_pixel_format(decodePixelFormat(getPixelFormat()));
		LayerProtoHelper::writeToProto(getColor(), [&]() { return layerInfo->mutable_color(); });
		LayerProtoHelper::writeToProto(state.color,
		@@ -2140,9 +2132,8 @@ void Layer::writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet
		layerInfo->set_is_relative_of(state.isRelativeOf);

		layerInfo->set_owner_uid(mOwnerUid);
		}

		if (traceFlags & SurfaceTracing::TRACE_INPUT) {
		if (traceFlags & LayerTracing::TRACE_INPUT) {
		WindowInfo info;
		if (useDrawing) {
		info = fillInputInfo(ui::Transform(), /* displayIsSecure */ true);
		@@ -2154,7 +2145,7 @@ void Layer::writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet
		[&]() { return layerInfo->mutable_input_window_info(); });
		}

		if (traceFlags & SurfaceTracing::TRACE_EXTRA) {
		if (traceFlags & LayerTracing::TRACE_EXTRA) {
		auto protoMap = layerInfo->mutable_metadata();
		for (const auto& entry : state.metadata.mMap) {
		(*protoMap)[entry.first] = std::string(entry.second.cbegin(), entry.second.cend());

services/surfaceflinger/Layer.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -57,7 +57,7 @@
		#include "Scheduler/LayerInfo.h"
		#include "Scheduler/Seamlessness.h"
		#include "SurfaceFlinger.h"
		#include "SurfaceTracing.h"
		#include "Tracing/LayerTracing.h"
		#include "TransactionCallbackInvoker.h"

		using namespace android::surfaceflinger;
		@@ -693,7 +693,7 @@ public:
		// external mStateLock. If writing drawing state, this function should be called on the
		// main or tracing thread.
		void writeToProtoCommonState(LayerProto* layerInfo, LayerVector::StateSet,
		uint32_t traceFlags = SurfaceTracing::TRACE_ALL);
		uint32_t traceFlags = LayerTracing::TRACE_ALL);

		gui::WindowInfo::Type getWindowType() const { return mWindowType; }

services/surfaceflinger/SurfaceFlinger.cpp

+16 −28

Original line number	Diff line number	Diff line
		@@ -1948,7 +1948,7 @@ bool SurfaceFlinger::commit(nsecs_t frameTime, int64_t vsyncId, nsecs_t expected
		}

		if (mTracingEnabledChanged) {
		mTracingEnabled = mTracing.isEnabled();
		mTracingEnabled = mLayerTracing.isEnabled();
		mTracingEnabledChanged = false;
		}

		@@ -1962,12 +1962,6 @@ bool SurfaceFlinger::commit(nsecs_t frameTime, int64_t vsyncId, nsecs_t expected
		// Composite if transactions were committed, or if requested by HWC.
		bool mustComposite = mMustComposite.exchange(false);
		{
		mTracePostComposition = mTracing.flagIsSet(SurfaceTracing::TRACE_COMPOSITION) \|\|
		mTracing.flagIsSet(SurfaceTracing::TRACE_SYNC) \|\|
		mTracing.flagIsSet(SurfaceTracing::TRACE_BUFFERS);
		const bool tracePreComposition = mTracingEnabled && !mTracePostComposition;
		ConditionalLockGuard<std::mutex> lock(mTracingLock, tracePreComposition);

		mFrameTimeline->setSfWakeUp(vsyncId, frameTime, Fps::fromPeriodNsecs(stats.vsyncPeriod));

		bool needsTraversal = false;
		@@ -1999,12 +1993,6 @@ bool SurfaceFlinger::commit(nsecs_t frameTime, int64_t vsyncId, nsecs_t expected
		}

		updateLayerGeometry();

		if (tracePreComposition) {
		if (mVisibleRegionsDirty) {
		mTracing.notifyLocked("visibleRegionsDirty");
		}
		}
		}

		// Layers need to get updated (in the previous line) before we can use them for
		@@ -2109,12 +2097,12 @@ void SurfaceFlinger::composite(nsecs_t frameTime) {
		modulateVsync(&VsyncModulator::onDisplayRefresh, usedGpuComposition);

		mLayersWithQueuedFrames.clear();
		if (mTracingEnabled && mTracePostComposition) {
		// This may block if SurfaceTracing is running in sync mode.
		if (mTracingEnabled) {
		// This will block and should only be used for debugging.
		if (mVisibleRegionsDirty) {
		mTracing.notify("visibleRegionsDirty");
		} else if (mTracing.flagIsSet(SurfaceTracing::TRACE_BUFFERS)) {
		mTracing.notify("bufferLatched");
		mLayerTracing.notify("visibleRegionsDirty");
		} else if (mLayerTracing.flagIsSet(LayerTracing::TRACE_BUFFERS)) {
		mLayerTracing.notify("bufferLatched");
		}
		}

		@@ -4639,7 +4627,7 @@ status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args, bool asProto) {
		}

		if (dumpLayers) {
		LayersTraceFileProto traceFileProto = SurfaceTracing::createLayersTraceFileProto();
		LayersTraceFileProto traceFileProto = mLayerTracing.createTraceFileProto();
		LayersTraceProto* layersTrace = traceFileProto.add_entry();
		LayersProto layersProto = dumpProtoFromMainThread();
		layersTrace->mutable_layers()->Swap(&layersProto);
		@@ -4661,8 +4649,8 @@ status_t SurfaceFlinger::doDump(int fd, const DumpArgs& args, bool asProto) {
		}

		status_t SurfaceFlinger::dumpCritical(int fd, const DumpArgs&, bool asProto) {
		if (asProto && mTracing.isEnabled()) {
		mTracing.writeToFile();
		if (asProto && mLayerTracing.isEnabled()) {
		mLayerTracing.writeToFile();
		}

		return doDump(fd, DumpArgs(), asProto);
		@@ -5058,7 +5046,7 @@ void SurfaceFlinger::dumpAllLocked(const DumpArgs& args, std::string& result) co
		/*
		* Tracing state
		*/
		mTracing.dump(result);
		mLayerTracing.dump(result);
		result.append("\n");

		/*
		@@ -5485,20 +5473,20 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r
		bool tracingEnabledChanged;
		if (n) {
		ALOGD("LayerTracing enabled");
		tracingEnabledChanged = mTracing.enable();
		tracingEnabledChanged = mLayerTracing.enable();
		if (tracingEnabledChanged) {
		schedule([&]() MAIN_THREAD { mTracing.notify("start"); }).wait();
		schedule([&]() MAIN_THREAD { mLayerTracing.notify("start"); }).wait();
		}
		} else {
		ALOGD("LayerTracing disabled");
		tracingEnabledChanged = mTracing.disable();
		tracingEnabledChanged = mLayerTracing.disable();
		}
		mTracingEnabledChanged = tracingEnabledChanged;
		reply->writeInt32(NO_ERROR);
		return NO_ERROR;
		}
		case 1026: { // Get layer tracing status
		reply->writeBool(mTracing.isEnabled());
		reply->writeBool(mLayerTracing.isEnabled());
		return NO_ERROR;
		}
		// Is a DisplayColorSetting supported?
		@@ -5539,7 +5527,7 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r
		}

		ALOGD("Updating trace buffer to %d KB", n);
		mTracing.setBufferSize(n * 1024);
		mLayerTracing.setBufferSize(n * 1024);
		reply->writeInt32(NO_ERROR);
		return NO_ERROR;
		}
		@@ -5584,7 +5572,7 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r
		case 1033: {
		n = data.readUint32();
		ALOGD("Updating trace flags to 0x%x", n);
		mTracing.setTraceFlags(n);
		mLayerTracing.setTraceFlags(n);
		reply->writeInt32(NO_ERROR);
		return NO_ERROR;
		}

services/surfaceflinger/SurfaceFlinger.h

+5 −6

Original line number	Diff line number	Diff line
		@@ -62,8 +62,8 @@
		#include "Scheduler/Scheduler.h"
		#include "Scheduler/VsyncModulator.h"
		#include "SurfaceFlingerFactory.h"
		#include "SurfaceTracing.h"
		#include "TracedOrdinal.h"
		#include "Tracing/LayerTracing.h"
		#include "TransactionCallbackInvoker.h"
		#include "TransactionState.h"

		@@ -353,7 +353,7 @@ private:
		friend class MonitoredProducer;
		friend class RefreshRateOverlay;
		friend class RegionSamplingThread;
		friend class SurfaceTracing;
		friend class LayerTracing;

		// For unit tests
		friend class TestableSurfaceFlinger;
		@@ -1039,12 +1039,12 @@ private:
		void dumpWideColorInfo(std::string& result) const REQUIRES(mStateLock);
		LayersProto dumpDrawingStateProto(uint32_t traceFlags) const;
		void dumpOffscreenLayersProto(LayersProto& layersProto,
		uint32_t traceFlags = SurfaceTracing::TRACE_ALL) const;
		uint32_t traceFlags = LayerTracing::TRACE_ALL) const;
		void dumpDisplayProto(LayersTraceProto& layersTraceProto) const;

		// Dumps state from HW Composer
		void dumpHwc(std::string& result) const;
		LayersProto dumpProtoFromMainThread(uint32_t traceFlags = SurfaceTracing::TRACE_ALL)
		LayersProto dumpProtoFromMainThread(uint32_t traceFlags = LayerTracing::TRACE_ALL)
		EXCLUDES(mStateLock);
		void dumpOffscreenLayers(std::string& result) EXCLUDES(mStateLock);
		void dumpPlannerInfo(const DumpArgs& args, std::string& result) const REQUIRES(mStateLock);
		@@ -1187,10 +1187,9 @@ private:
		bool mPropagateBackpressureClientComposition = false;
		sp<SurfaceInterceptor> mInterceptor;

		SurfaceTracing mTracing{*this};
		LayerTracing mLayerTracing{*this};
		std::mutex mTracingLock;
		bool mTracingEnabled = false;
		bool mTracePostComposition = false;
		std::atomic<bool> mTracingEnabledChanged = false;

		const std::shared_ptr<TimeStats> mTimeStats;