Merge "TimeStats & FrameTracer: refactor layerID to layerId" (46e9976b) · Commits · e / os / android_frameworks_native-old

services/surfaceflinger/BufferLayer.cpp

+9 −9

services/surfaceflinger/BufferQueueLayer.cpp

+19 −19

Original line number	Original line	Diff line number	Diff line
	@@ -223,7 +223,7 @@ status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t
	// BufferItem's that weren't actually queued. This can happen in shared		// BufferItem's that weren't actually queued. This can happen in shared
	// buffer mode.		// buffer mode.
	bool queuedBuffer = false;		bool queuedBuffer = false;
	const int32_t layerID = getSequence();		const int32_t layerId = getSequence();
	LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions,		LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions,
	getProducerStickyTransform() != 0, mName, mOverrideScalingMode,		getProducerStickyTransform() != 0, mName, mOverrideScalingMode,
	getTransformToDisplayInverse());		getTransformToDisplayInverse());
	@@ -264,7 +264,7 @@ status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t
	if (queuedBuffer) {		if (queuedBuffer) {
	Mutex::Autolock lock(mQueueItemLock);		Mutex::Autolock lock(mQueueItemLock);
	mConsumer->mergeSurfaceDamage(mQueueItems[0].mSurfaceDamage);		mConsumer->mergeSurfaceDamage(mQueueItems[0].mSurfaceDamage);
	mFlinger->mTimeStats->removeTimeRecord(layerID, mQueueItems[0].mFrameNumber);		mFlinger->mTimeStats->removeTimeRecord(layerId, mQueueItems[0].mFrameNumber);
	mQueueItems.removeAt(0);		mQueueItems.removeAt(0);
	mQueuedFrames--;		mQueuedFrames--;
	}		}
	@@ -278,8 +278,8 @@ status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t
	Mutex::Autolock lock(mQueueItemLock);		Mutex::Autolock lock(mQueueItemLock);
	mQueueItems.clear();		mQueueItems.clear();
	mQueuedFrames = 0;		mQueuedFrames = 0;
	mFlinger->mTimeStats->onDestroy(layerID);		mFlinger->mTimeStats->onDestroy(layerId);
	mFlinger->mFrameTracer->onDestroy(layerID);		mFlinger->mFrameTracer->onDestroy(layerId);
	}		}

	// Once we have hit this state, the shadow queue may no longer		// Once we have hit this state, the shadow queue may no longer
	@@ -301,19 +301,19 @@ status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t
	// updateTexImage		// updateTexImage
	while (mQueueItems[0].mFrameNumber != currentFrameNumber) {		while (mQueueItems[0].mFrameNumber != currentFrameNumber) {
	mConsumer->mergeSurfaceDamage(mQueueItems[0].mSurfaceDamage);		mConsumer->mergeSurfaceDamage(mQueueItems[0].mSurfaceDamage);
	mFlinger->mTimeStats->removeTimeRecord(layerID, mQueueItems[0].mFrameNumber);		mFlinger->mTimeStats->removeTimeRecord(layerId, mQueueItems[0].mFrameNumber);
	mQueueItems.removeAt(0);		mQueueItems.removeAt(0);
	mQueuedFrames--;		mQueuedFrames--;
	}		}

	uint64_t bufferID = mQueueItems[0].mGraphicBuffer->getId();		uint64_t bufferID = mQueueItems[0].mGraphicBuffer->getId();
	mFlinger->mTimeStats->setAcquireFence(layerID, currentFrameNumber,		mFlinger->mTimeStats->setAcquireFence(layerId, currentFrameNumber,
	mQueueItems[0].mFenceTime);		mQueueItems[0].mFenceTime);
	mFlinger->mFrameTracer->traceFence(layerID, bufferID, currentFrameNumber,		mFlinger->mFrameTracer->traceFence(layerId, bufferID, currentFrameNumber,
	mQueueItems[0].mFenceTime,		mQueueItems[0].mFenceTime,
	FrameTracer::FrameEvent::ACQUIRE_FENCE);		FrameTracer::FrameEvent::ACQUIRE_FENCE);
	mFlinger->mTimeStats->setLatchTime(layerID, currentFrameNumber, latchTime);		mFlinger->mTimeStats->setLatchTime(layerId, currentFrameNumber, latchTime);
	mFlinger->mFrameTracer->traceTimestamp(layerID, bufferID, currentFrameNumber, latchTime,		mFlinger->mFrameTracer->traceTimestamp(layerId, bufferID, currentFrameNumber, latchTime,
	FrameTracer::FrameEvent::LATCH);		FrameTracer::FrameEvent::LATCH);

	mQueueItems.removeAt(0);		mQueueItems.removeAt(0);
	@@ -373,28 +373,28 @@ void BufferQueueLayer::latchPerFrameState(
	// -----------------------------------------------------------------------		// -----------------------------------------------------------------------

	void BufferQueueLayer::onFrameDequeued(const uint64_t bufferId) {		void BufferQueueLayer::onFrameDequeued(const uint64_t bufferId) {
	const int32_t layerID = getSequence();		const int32_t layerId = getSequence();
	mFlinger->mFrameTracer->traceNewLayer(layerID, getName().c_str());		mFlinger->mFrameTracer->traceNewLayer(layerId, getName().c_str());
	mFlinger->mFrameTracer->traceTimestamp(layerID, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,		mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,
	systemTime(), FrameTracer::FrameEvent::DEQUEUE);		systemTime(), FrameTracer::FrameEvent::DEQUEUE);
	}		}

	void BufferQueueLayer::onFrameDetached(const uint64_t bufferId) {		void BufferQueueLayer::onFrameDetached(const uint64_t bufferId) {
	const int32_t layerID = getSequence();		const int32_t layerId = getSequence();
	mFlinger->mFrameTracer->traceNewLayer(layerID, getName().c_str());		mFlinger->mFrameTracer->traceNewLayer(layerId, getName().c_str());
	mFlinger->mFrameTracer->traceTimestamp(layerID, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,		mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,
	systemTime(), FrameTracer::FrameEvent::DETACH);		systemTime(), FrameTracer::FrameEvent::DETACH);
	}		}

	void BufferQueueLayer::onFrameCancelled(const uint64_t bufferId) {		void BufferQueueLayer::onFrameCancelled(const uint64_t bufferId) {
	const int32_t layerID = getSequence();		const int32_t layerId = getSequence();
	mFlinger->mFrameTracer->traceTimestamp(layerID, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,		mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,
	systemTime(), FrameTracer::FrameEvent::CANCEL);		systemTime(), FrameTracer::FrameEvent::CANCEL);
	}		}

	void BufferQueueLayer::onFrameAvailable(const BufferItem& item) {		void BufferQueueLayer::onFrameAvailable(const BufferItem& item) {
	const int32_t layerID = getSequence();		const int32_t layerId = getSequence();
	mFlinger->mFrameTracer->traceTimestamp(layerID, item.mGraphicBuffer->getId(), item.mFrameNumber,		mFlinger->mFrameTracer->traceTimestamp(layerId, item.mGraphicBuffer->getId(), item.mFrameNumber,
	systemTime(), FrameTracer::FrameEvent::QUEUE);		systemTime(), FrameTracer::FrameEvent::QUEUE);

	ATRACE_CALL();		ATRACE_CALL();

services/surfaceflinger/BufferStateLayer.cpp

+12 −12

services/surfaceflinger/FrameTracer/FrameTracer.cpp

+27 −27

Original line number	Original line	Diff line number	Diff line
	@@ -44,52 +44,52 @@ void FrameTracer::registerDataSource() {
	FrameTracerDataSource::Register(dsd);		FrameTracerDataSource::Register(dsd);
	}		}

	void FrameTracer::traceNewLayer(int32_t layerID, const std::string& layerName) {		void FrameTracer::traceNewLayer(int32_t layerId, const std::string& layerName) {
	FrameTracerDataSource::Trace([this, layerID, &layerName](FrameTracerDataSource::TraceContext) {		FrameTracerDataSource::Trace([this, layerId, &layerName](FrameTracerDataSource::TraceContext) {
	if (mTraceTracker.find(layerID) == mTraceTracker.end()) {		if (mTraceTracker.find(layerId) == mTraceTracker.end()) {
	std::lock_guard<std::mutex> lock(mTraceMutex);		std::lock_guard<std::mutex> lock(mTraceMutex);
	mTraceTracker[layerID].layerName = layerName;		mTraceTracker[layerId].layerName = layerName;
	}		}
	});		});
	}		}

	void FrameTracer::traceTimestamp(int32_t layerID, uint64_t bufferID, uint64_t frameNumber,		void FrameTracer::traceTimestamp(int32_t layerId, uint64_t bufferID, uint64_t frameNumber,
	nsecs_t timestamp, FrameEvent::BufferEventType type,		nsecs_t timestamp, FrameEvent::BufferEventType type,
	nsecs_t duration) {		nsecs_t duration) {
	FrameTracerDataSource::Trace([this, layerID, bufferID, frameNumber, timestamp, type,		FrameTracerDataSource::Trace([this, layerId, bufferID, frameNumber, timestamp, type,
	duration](FrameTracerDataSource::TraceContext ctx) {		duration](FrameTracerDataSource::TraceContext ctx) {
	std::lock_guard<std::mutex> lock(mTraceMutex);		std::lock_guard<std::mutex> lock(mTraceMutex);
	if (mTraceTracker.find(layerID) == mTraceTracker.end()) {		if (mTraceTracker.find(layerId) == mTraceTracker.end()) {
	return;		return;
	}		}

	// Handle any pending fences for this buffer.		// Handle any pending fences for this buffer.
	tracePendingFencesLocked(ctx, layerID, bufferID);		tracePendingFencesLocked(ctx, layerId, bufferID);

	// Complete current trace.		// Complete current trace.
	traceLocked(ctx, layerID, bufferID, frameNumber, timestamp, type, duration);		traceLocked(ctx, layerId, bufferID, frameNumber, timestamp, type, duration);
	});		});
	}		}

	void FrameTracer::traceFence(int32_t layerID, uint64_t bufferID, uint64_t frameNumber,		void FrameTracer::traceFence(int32_t layerId, uint64_t bufferID, uint64_t frameNumber,
	const std::shared_ptr<FenceTime>& fence,		const std::shared_ptr<FenceTime>& fence,
	FrameEvent::BufferEventType type, nsecs_t startTime) {		FrameEvent::BufferEventType type, nsecs_t startTime) {
	FrameTracerDataSource::Trace([this, layerID, bufferID, frameNumber, &fence, type,		FrameTracerDataSource::Trace([this, layerId, bufferID, frameNumber, &fence, type,
	startTime](FrameTracerDataSource::TraceContext ctx) {		startTime](FrameTracerDataSource::TraceContext ctx) {
	const nsecs_t signalTime = fence->getSignalTime();		const nsecs_t signalTime = fence->getSignalTime();
	if (signalTime != Fence::SIGNAL_TIME_INVALID) {		if (signalTime != Fence::SIGNAL_TIME_INVALID) {
	std::lock_guard<std::mutex> lock(mTraceMutex);		std::lock_guard<std::mutex> lock(mTraceMutex);
	if (mTraceTracker.find(layerID) == mTraceTracker.end()) {		if (mTraceTracker.find(layerId) == mTraceTracker.end()) {
	return;		return;
	}		}

	// Handle any pending fences for this buffer.		// Handle any pending fences for this buffer.
	tracePendingFencesLocked(ctx, layerID, bufferID);		tracePendingFencesLocked(ctx, layerId, bufferID);

	if (signalTime != Fence::SIGNAL_TIME_PENDING) {		if (signalTime != Fence::SIGNAL_TIME_PENDING) {
	traceSpanLocked(ctx, layerID, bufferID, frameNumber, type, startTime, signalTime);		traceSpanLocked(ctx, layerId, bufferID, frameNumber, type, startTime, signalTime);
	} else {		} else {
	mTraceTracker[layerID].pendingFences[bufferID].push_back(		mTraceTracker[layerId].pendingFences[bufferID].push_back(
	{.frameNumber = frameNumber,		{.frameNumber = frameNumber,
	.type = type,		.type = type,
	.fence = fence,		.fence = fence,
	@@ -100,9 +100,9 @@ void FrameTracer::traceFence(int32_t layerID, uint64_t bufferID, uint64_t frameN
	}		}

	void FrameTracer::tracePendingFencesLocked(FrameTracerDataSource::TraceContext& ctx,		void FrameTracer::tracePendingFencesLocked(FrameTracerDataSource::TraceContext& ctx,
	int32_t layerID, uint64_t bufferID) {		int32_t layerId, uint64_t bufferID) {
	if (mTraceTracker[layerID].pendingFences.count(bufferID)) {		if (mTraceTracker[layerId].pendingFences.count(bufferID)) {
	auto& pendingFences = mTraceTracker[layerID].pendingFences[bufferID];		auto& pendingFences = mTraceTracker[layerId].pendingFences[bufferID];
	for (size_t i = 0; i < pendingFences.size(); ++i) {		for (size_t i = 0; i < pendingFences.size(); ++i) {
	auto& pendingFence = pendingFences[i];		auto& pendingFence = pendingFences[i];

	@@ -116,7 +116,7 @@ void FrameTracer::tracePendingFencesLocked(FrameTracerDataSource::TraceContext&

	if (signalTime != Fence::SIGNAL_TIME_INVALID &&		if (signalTime != Fence::SIGNAL_TIME_INVALID &&
	systemTime() - signalTime < kFenceSignallingDeadline) {		systemTime() - signalTime < kFenceSignallingDeadline) {
	traceSpanLocked(ctx, layerID, bufferID, pendingFence.frameNumber, pendingFence.type,		traceSpanLocked(ctx, layerId, bufferID, pendingFence.frameNumber, pendingFence.type,
	pendingFence.startTime, signalTime);		pendingFence.startTime, signalTime);
	}		}

	@@ -126,7 +126,7 @@ void FrameTracer::tracePendingFencesLocked(FrameTracerDataSource::TraceContext&
	}		}
	}		}

	void FrameTracer::traceLocked(FrameTracerDataSource::TraceContext& ctx, int32_t layerID,		void FrameTracer::traceLocked(FrameTracerDataSource::TraceContext& ctx, int32_t layerId,
	uint64_t bufferID, uint64_t frameNumber, nsecs_t timestamp,		uint64_t bufferID, uint64_t frameNumber, nsecs_t timestamp,
	FrameEvent::BufferEventType type, nsecs_t duration) {		FrameEvent::BufferEventType type, nsecs_t duration) {
	auto packet = ctx.NewTracePacket();		auto packet = ctx.NewTracePacket();
	@@ -138,9 +138,9 @@ void FrameTracer::traceLocked(FrameTracerDataSource::TraceContext& ctx, int32_t
	}		}
	event->set_type(type);		event->set_type(type);

	if (mTraceTracker.find(layerID) != mTraceTracker.end() &&		if (mTraceTracker.find(layerId) != mTraceTracker.end() &&
	!mTraceTracker[layerID].layerName.empty()) {		!mTraceTracker[layerId].layerName.empty()) {
	const std::string& layerName = mTraceTracker[layerID].layerName;		const std::string& layerName = mTraceTracker[layerId].layerName;
	event->set_layer_name(layerName.c_str(), layerName.size());		event->set_layer_name(layerName.c_str(), layerName.size());
	}		}

	@@ -149,7 +149,7 @@ void FrameTracer::traceLocked(FrameTracerDataSource::TraceContext& ctx, int32_t
	}		}
	}		}

	void FrameTracer::traceSpanLocked(FrameTracerDataSource::TraceContext& ctx, int32_t layerID,		void FrameTracer::traceSpanLocked(FrameTracerDataSource::TraceContext& ctx, int32_t layerId,
	uint64_t bufferID, uint64_t frameNumber,		uint64_t bufferID, uint64_t frameNumber,
	FrameEvent::BufferEventType type, nsecs_t startTime,		FrameEvent::BufferEventType type, nsecs_t startTime,
	nsecs_t endTime) {		nsecs_t endTime) {
	@@ -159,12 +159,12 @@ void FrameTracer::traceSpanLocked(FrameTracerDataSource::TraceContext& ctx, int3
	timestamp = startTime;		timestamp = startTime;
	duration = endTime - startTime;		duration = endTime - startTime;
	}		}
	traceLocked(ctx, layerID, bufferID, frameNumber, timestamp, type, duration);		traceLocked(ctx, layerId, bufferID, frameNumber, timestamp, type, duration);
	}		}

	void FrameTracer::onDestroy(int32_t layerID) {		void FrameTracer::onDestroy(int32_t layerId) {
	std::lock_guard<std::mutex> traceLock(mTraceMutex);		std::lock_guard<std::mutex> traceLock(mTraceMutex);
	mTraceTracker.erase(layerID);		mTraceTracker.erase(layerId);
	}		}

	std::string FrameTracer::miniDump() {		std::string FrameTracer::miniDump() {

services/surfaceflinger/FrameTracer/FrameTracer.h

+7 −7

Original line number	Original line	Diff line number	Diff line
	@@ -77,9 +77,9 @@ BufferLayer::~BufferLayer() {
	// with the clone layer trying to use the deleted texture.		// with the clone layer trying to use the deleted texture.
	mFlinger->deleteTextureAsync(mTextureName);		mFlinger->deleteTextureAsync(mTextureName);
	}		}
	const int32_t layerID = getSequence();		const int32_t layerId = getSequence();
	mFlinger->mTimeStats->onDestroy(layerID);		mFlinger->mTimeStats->onDestroy(layerId);
	mFlinger->mFrameTracer->onDestroy(layerID);		mFlinger->mFrameTracer->onDestroy(layerId);
	}		}

	void BufferLayer::useSurfaceDamage() {		void BufferLayer::useSurfaceDamage() {
	@@ -305,8 +305,8 @@ bool BufferLayer::onPostComposition(const std::optional<DisplayId>& displayId,
	nsecs_t desiredPresentTime = mBufferInfo.mDesiredPresentTime;		nsecs_t desiredPresentTime = mBufferInfo.mDesiredPresentTime;
	mFrameTracker.setDesiredPresentTime(desiredPresentTime);		mFrameTracker.setDesiredPresentTime(desiredPresentTime);

	const int32_t layerID = getSequence();		const int32_t layerId = getSequence();
	mFlinger->mTimeStats->setDesiredTime(layerID, mCurrentFrameNumber, desiredPresentTime);		mFlinger->mTimeStats->setDesiredTime(layerId, mCurrentFrameNumber, desiredPresentTime);

	std::shared_ptr<FenceTime> frameReadyFence = mBufferInfo.mFenceTime;		std::shared_ptr<FenceTime> frameReadyFence = mBufferInfo.mFenceTime;
	if (frameReadyFence->isValid()) {		if (frameReadyFence->isValid()) {
	@@ -318,16 +318,16 @@ bool BufferLayer::onPostComposition(const std::optional<DisplayId>& displayId,
	}		}

	if (presentFence->isValid()) {		if (presentFence->isValid()) {
	mFlinger->mTimeStats->setPresentFence(layerID, mCurrentFrameNumber, presentFence);		mFlinger->mTimeStats->setPresentFence(layerId, mCurrentFrameNumber, presentFence);
	mFlinger->mFrameTracer->traceFence(layerID, getCurrentBufferId(), mCurrentFrameNumber,		mFlinger->mFrameTracer->traceFence(layerId, getCurrentBufferId(), mCurrentFrameNumber,
	presentFence, FrameTracer::FrameEvent::PRESENT_FENCE);		presentFence, FrameTracer::FrameEvent::PRESENT_FENCE);
	mFrameTracker.setActualPresentFence(std::shared_ptr<FenceTime>(presentFence));		mFrameTracker.setActualPresentFence(std::shared_ptr<FenceTime>(presentFence));
	} else if (displayId && mFlinger->getHwComposer().isConnected(*displayId)) {		} else if (displayId && mFlinger->getHwComposer().isConnected(*displayId)) {
	// The HWC doesn't support present fences, so use the refresh		// The HWC doesn't support present fences, so use the refresh
	// timestamp instead.		// timestamp instead.
	const nsecs_t actualPresentTime = mFlinger->getHwComposer().getRefreshTimestamp(*displayId);		const nsecs_t actualPresentTime = mFlinger->getHwComposer().getRefreshTimestamp(*displayId);
	mFlinger->mTimeStats->setPresentTime(layerID, mCurrentFrameNumber, actualPresentTime);		mFlinger->mTimeStats->setPresentTime(layerId, mCurrentFrameNumber, actualPresentTime);
	mFlinger->mFrameTracer->traceTimestamp(layerID, getCurrentBufferId(), mCurrentFrameNumber,		mFlinger->mFrameTracer->traceTimestamp(layerId, getCurrentBufferId(), mCurrentFrameNumber,
	actualPresentTime,		actualPresentTime,
	FrameTracer::FrameEvent::PRESENT_FENCE);		FrameTracer::FrameEvent::PRESENT_FENCE);
	mFrameTracker.setActualPresentTime(actualPresentTime);		mFrameTracker.setActualPresentTime(actualPresentTime);

Original line number	Original line	Diff line number	Diff line
	@@ -240,10 +240,10 @@ bool BufferStateLayer::setBuffer(const sp<GraphicBuffer>& buffer, nsecs_t postTi
	mCurrentState.modified = true;		mCurrentState.modified = true;
	setTransactionFlags(eTransactionNeeded);		setTransactionFlags(eTransactionNeeded);

	const int32_t layerID = getSequence();		const int32_t layerId = getSequence();
	mFlinger->mTimeStats->setPostTime(layerID, mFrameNumber, getName().c_str(), postTime);		mFlinger->mTimeStats->setPostTime(layerId, mFrameNumber, getName().c_str(), postTime);
	mFlinger->mFrameTracer->traceNewLayer(layerID, getName().c_str());		mFlinger->mFrameTracer->traceNewLayer(layerId, getName().c_str());
	mFlinger->mFrameTracer->traceTimestamp(layerID, buffer->getId(), mFrameNumber, postTime,		mFlinger->mFrameTracer->traceTimestamp(layerId, buffer->getId(), mFrameNumber, postTime,
	FrameTracer::FrameEvent::POST);		FrameTracer::FrameEvent::POST);
	mCurrentState.desiredPresentTime = desiredPresentTime;		mCurrentState.desiredPresentTime = desiredPresentTime;

	@@ -458,7 +458,7 @@ status_t BufferStateLayer::updateTexImage(bool& /recomputeVisibleRegions/, nse
	return NO_ERROR;		return NO_ERROR;
	}		}

	const int32_t layerID = getSequence();		const int32_t layerId = getSequence();

	// Reject if the layer is invalid		// Reject if the layer is invalid
	uint32_t bufferWidth = s.buffer->width;		uint32_t bufferWidth = s.buffer->width;
	@@ -480,7 +480,7 @@ status_t BufferStateLayer::updateTexImage(bool& /recomputeVisibleRegions/, nse
	ALOGE("[%s] rejecting buffer: "		ALOGE("[%s] rejecting buffer: "
	"bufferWidth=%d, bufferHeight=%d, front.active.{w=%d, h=%d}",		"bufferWidth=%d, bufferHeight=%d, front.active.{w=%d, h=%d}",
	getDebugName(), bufferWidth, bufferHeight, s.active.w, s.active.h);		getDebugName(), bufferWidth, bufferHeight, s.active.w, s.active.h);
	mFlinger->mTimeStats->removeTimeRecord(layerID, mFrameNumber);		mFlinger->mTimeStats->removeTimeRecord(layerId, mFrameNumber);
	return BAD_VALUE;		return BAD_VALUE;
	}		}

	@@ -497,18 +497,18 @@ status_t BufferStateLayer::updateTexImage(bool& /recomputeVisibleRegions/, nse
	// a GL-composited layer) not at all.		// a GL-composited layer) not at all.
	status_t err = bindTextureImage();		status_t err = bindTextureImage();
	if (err != NO_ERROR) {		if (err != NO_ERROR) {
	mFlinger->mTimeStats->onDestroy(layerID);		mFlinger->mTimeStats->onDestroy(layerId);
	mFlinger->mFrameTracer->onDestroy(layerID);		mFlinger->mFrameTracer->onDestroy(layerId);
	return BAD_VALUE;		return BAD_VALUE;
	}		}
	}		}

	const uint64_t bufferID = getCurrentBufferId();		const uint64_t bufferID = getCurrentBufferId();
	mFlinger->mTimeStats->setAcquireFence(layerID, mFrameNumber, mBufferInfo.mFenceTime);		mFlinger->mTimeStats->setAcquireFence(layerId, mFrameNumber, mBufferInfo.mFenceTime);
	mFlinger->mFrameTracer->traceFence(layerID, bufferID, mFrameNumber, mBufferInfo.mFenceTime,		mFlinger->mFrameTracer->traceFence(layerId, bufferID, mFrameNumber, mBufferInfo.mFenceTime,

Original line number	Original line	Diff line number	Diff line
	@@ -47,21 +47,21 @@ public:
	void registerDataSource();		void registerDataSource();
	// Starts tracking a new layer for tracing. Needs to be called once before traceTimestamp() or		// Starts tracking a new layer for tracing. Needs to be called once before traceTimestamp() or
	// traceFence() for each layer.		// traceFence() for each layer.
	void traceNewLayer(int32_t layerID, const std::string& layerName);		void traceNewLayer(int32_t layerId, const std::string& layerName);
	// Creates a trace point at the timestamp provided.		// Creates a trace point at the timestamp provided.
	void traceTimestamp(int32_t layerID, uint64_t bufferID, uint64_t frameNumber, nsecs_t timestamp,		void traceTimestamp(int32_t layerId, uint64_t bufferID, uint64_t frameNumber, nsecs_t timestamp,
	FrameEvent::BufferEventType type, nsecs_t duration = 0);		FrameEvent::BufferEventType type, nsecs_t duration = 0);
	// Creates a trace point after the provided fence has been signalled. If a startTime is provided		// Creates a trace point after the provided fence has been signalled. If a startTime is provided
	// the trace will have be timestamped from startTime until fence signalling time. If no		// the trace will have be timestamped from startTime until fence signalling time. If no
	// startTime is provided, a durationless trace point will be created timestamped at fence		// startTime is provided, a durationless trace point will be created timestamped at fence
	// signalling time. If the fence hasn't signalled yet, the trace point will be created the next		// signalling time. If the fence hasn't signalled yet, the trace point will be created the next
	// time after signalling a trace call for this buffer occurs.		// time after signalling a trace call for this buffer occurs.
	void traceFence(int32_t layerID, uint64_t bufferID, uint64_t frameNumber,		void traceFence(int32_t layerId, uint64_t bufferID, uint64_t frameNumber,
	const std::shared_ptr<FenceTime>& fence, FrameEvent::BufferEventType type,		const std::shared_ptr<FenceTime>& fence, FrameEvent::BufferEventType type,
	nsecs_t startTime = 0);		nsecs_t startTime = 0);

	// Takes care of cleanup when a layer is destroyed.		// Takes care of cleanup when a layer is destroyed.
	void onDestroy(int32_t layerID);		void onDestroy(int32_t layerId);

	std::string miniDump();		std::string miniDump();

	@@ -88,15 +88,15 @@ private:

	// Checks if any pending fences for a layer and buffer have signalled and, if they have, creates		// Checks if any pending fences for a layer and buffer have signalled and, if they have, creates
	// trace points for them.		// trace points for them.
	void tracePendingFencesLocked(FrameTracerDataSource::TraceContext& ctx, int32_t layerID,		void tracePendingFencesLocked(FrameTracerDataSource::TraceContext& ctx, int32_t layerId,
	uint64_t bufferID);		uint64_t bufferID);
	// Creates a trace point by translating a start time and an end time to a timestamp and		// Creates a trace point by translating a start time and an end time to a timestamp and
	// duration. If startTime is later than end time it sets end time as the timestamp and the		// duration. If startTime is later than end time it sets end time as the timestamp and the
	// duration to 0. Used by traceFence().		// duration to 0. Used by traceFence().
	void traceSpanLocked(FrameTracerDataSource::TraceContext& ctx, int32_t layerID,		void traceSpanLocked(FrameTracerDataSource::TraceContext& ctx, int32_t layerId,
	uint64_t bufferID, uint64_t frameNumber, FrameEvent::BufferEventType type,		uint64_t bufferID, uint64_t frameNumber, FrameEvent::BufferEventType type,
	nsecs_t startTime, nsecs_t endTime);		nsecs_t startTime, nsecs_t endTime);
	void traceLocked(FrameTracerDataSource::TraceContext& ctx, int32_t layerID, uint64_t bufferID,		void traceLocked(FrameTracerDataSource::TraceContext& ctx, int32_t layerId, uint64_t bufferID,
	uint64_t frameNumber, nsecs_t timestamp, FrameEvent::BufferEventType type,		uint64_t frameNumber, nsecs_t timestamp, FrameEvent::BufferEventType type,
	nsecs_t duration = 0);		nsecs_t duration = 0);