Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 46e9976b authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "TimeStats & FrameTracer: refactor layerID to layerId"

parents 607abb64 1a88c40d

services/surfaceflinger/BufferLayer.cpp

+9 −9
Original line number Diff line number Diff line
@@ -77,9 +77,9 @@ BufferLayer::~BufferLayer() { 
        // with the clone layer trying to use the deleted texture.

        mFlinger->deleteTextureAsync(mTextureName);

    }

    const int32_t layerID = getSequence();

    mFlinger->mTimeStats->onDestroy(layerID);

    mFlinger->mFrameTracer->onDestroy(layerID);

    const int32_t layerId = getSequence();

    mFlinger->mTimeStats->onDestroy(layerId);

    mFlinger->mFrameTracer->onDestroy(layerId);

}



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

    mFrameTracker.setDesiredPresentTime(desiredPresentTime);



    const int32_t layerID = getSequence();

    mFlinger->mTimeStats->setDesiredTime(layerID, mCurrentFrameNumber, desiredPresentTime);

    const int32_t layerId = getSequence();

    mFlinger->mTimeStats->setDesiredTime(layerId, mCurrentFrameNumber, desiredPresentTime);



    std::shared_ptr<FenceTime> frameReadyFence = mBufferInfo.mFenceTime;

    if (frameReadyFence->isValid()) {
@@ -318,16 +318,16 @@ bool BufferLayer::onPostComposition(const std::optional<DisplayId>& displayId, 
    }



    if (presentFence->isValid()) {

        mFlinger->mTimeStats->setPresentFence(layerID, mCurrentFrameNumber, presentFence);

        mFlinger->mFrameTracer->traceFence(layerID, getCurrentBufferId(), mCurrentFrameNumber,

        mFlinger->mTimeStats->setPresentFence(layerId, mCurrentFrameNumber, presentFence);

        mFlinger->mFrameTracer->traceFence(layerId, getCurrentBufferId(), mCurrentFrameNumber,

                                           presentFence, FrameTracer::FrameEvent::PRESENT_FENCE);

        mFrameTracker.setActualPresentFence(std::shared_ptr<FenceTime>(presentFence));

    } else if (displayId && mFlinger->getHwComposer().isConnected(*displayId)) {

        // The HWC doesn't support present fences, so use the refresh

        // timestamp instead.

        const nsecs_t actualPresentTime = mFlinger->getHwComposer().getRefreshTimestamp(*displayId);

        mFlinger->mTimeStats->setPresentTime(layerID, mCurrentFrameNumber, actualPresentTime);

        mFlinger->mFrameTracer->traceTimestamp(layerID, getCurrentBufferId(), mCurrentFrameNumber,

        mFlinger->mTimeStats->setPresentTime(layerId, mCurrentFrameNumber, actualPresentTime);

        mFlinger->mFrameTracer->traceTimestamp(layerId, getCurrentBufferId(), mCurrentFrameNumber,

                                               actualPresentTime,

                                               FrameTracer::FrameEvent::PRESENT_FENCE);

        mFrameTracker.setActualPresentTime(actualPresentTime);

services/surfaceflinger/BufferQueueLayer.cpp

+19 −19
Original line number 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

    // buffer mode.

    bool queuedBuffer = false;

    const int32_t layerID = getSequence();

    const int32_t layerId = getSequence();

    LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions,

                    getProducerStickyTransform() != 0, mName, mOverrideScalingMode,

                    getTransformToDisplayInverse());
@@ -264,7 +264,7 @@ status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t 
        if (queuedBuffer) {

            Mutex::Autolock lock(mQueueItemLock);

            mConsumer->mergeSurfaceDamage(mQueueItems[0].mSurfaceDamage);

            mFlinger->mTimeStats->removeTimeRecord(layerID, mQueueItems[0].mFrameNumber);

            mFlinger->mTimeStats->removeTimeRecord(layerId, mQueueItems[0].mFrameNumber);

            mQueueItems.removeAt(0);

            mQueuedFrames--;

        }
@@ -278,8 +278,8 @@ status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t 
            Mutex::Autolock lock(mQueueItemLock);

            mQueueItems.clear();

            mQueuedFrames = 0;

            mFlinger->mTimeStats->onDestroy(layerID);

            mFlinger->mFrameTracer->onDestroy(layerID);

            mFlinger->mTimeStats->onDestroy(layerId);

            mFlinger->mFrameTracer->onDestroy(layerId);

        }



        // 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

        while (mQueueItems[0].mFrameNumber != currentFrameNumber) {

            mConsumer->mergeSurfaceDamage(mQueueItems[0].mSurfaceDamage);

            mFlinger->mTimeStats->removeTimeRecord(layerID, mQueueItems[0].mFrameNumber);

            mFlinger->mTimeStats->removeTimeRecord(layerId, mQueueItems[0].mFrameNumber);

            mQueueItems.removeAt(0);

            mQueuedFrames--;

        }



        uint64_t bufferID = mQueueItems[0].mGraphicBuffer->getId();

        mFlinger->mTimeStats->setAcquireFence(layerID, currentFrameNumber,

        mFlinger->mTimeStats->setAcquireFence(layerId, currentFrameNumber,

                                              mQueueItems[0].mFenceTime);

        mFlinger->mFrameTracer->traceFence(layerID, bufferID, currentFrameNumber,

        mFlinger->mFrameTracer->traceFence(layerId, bufferID, currentFrameNumber,

                                           mQueueItems[0].mFenceTime,

                                           FrameTracer::FrameEvent::ACQUIRE_FENCE);

        mFlinger->mTimeStats->setLatchTime(layerID, currentFrameNumber, latchTime);

        mFlinger->mFrameTracer->traceTimestamp(layerID, bufferID, currentFrameNumber, latchTime,

        mFlinger->mTimeStats->setLatchTime(layerId, currentFrameNumber, latchTime);

        mFlinger->mFrameTracer->traceTimestamp(layerId, bufferID, currentFrameNumber, latchTime,

                                               FrameTracer::FrameEvent::LATCH);



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



void BufferQueueLayer::onFrameDequeued(const uint64_t bufferId) {

    const int32_t layerID = getSequence();

    mFlinger->mFrameTracer->traceNewLayer(layerID, getName().c_str());

    mFlinger->mFrameTracer->traceTimestamp(layerID, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,

    const int32_t layerId = getSequence();

    mFlinger->mFrameTracer->traceNewLayer(layerId, getName().c_str());

    mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,

                                           systemTime(), FrameTracer::FrameEvent::DEQUEUE);

}



void BufferQueueLayer::onFrameDetached(const uint64_t bufferId) {

    const int32_t layerID = getSequence();

    mFlinger->mFrameTracer->traceNewLayer(layerID, getName().c_str());

    mFlinger->mFrameTracer->traceTimestamp(layerID, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,

    const int32_t layerId = getSequence();

    mFlinger->mFrameTracer->traceNewLayer(layerId, getName().c_str());

    mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,

                                           systemTime(), FrameTracer::FrameEvent::DETACH);

}



void BufferQueueLayer::onFrameCancelled(const uint64_t bufferId) {

    const int32_t layerID = getSequence();

    mFlinger->mFrameTracer->traceTimestamp(layerID, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,

    const int32_t layerId = getSequence();

    mFlinger->mFrameTracer->traceTimestamp(layerId, bufferId, FrameTracer::UNSPECIFIED_FRAME_NUMBER,

                                           systemTime(), FrameTracer::FrameEvent::CANCEL);

}



void BufferQueueLayer::onFrameAvailable(const BufferItem& item) {

    const int32_t layerID = getSequence();

    mFlinger->mFrameTracer->traceTimestamp(layerID, item.mGraphicBuffer->getId(), item.mFrameNumber,

    const int32_t layerId = getSequence();

    mFlinger->mFrameTracer->traceTimestamp(layerId, item.mGraphicBuffer->getId(), item.mFrameNumber,

                                           systemTime(), FrameTracer::FrameEvent::QUEUE);



    ATRACE_CALL();

services/surfaceflinger/BufferStateLayer.cpp

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

    setTransactionFlags(eTransactionNeeded);



    const int32_t layerID = getSequence();

    mFlinger->mTimeStats->setPostTime(layerID, mFrameNumber, getName().c_str(), postTime);

    mFlinger->mFrameTracer->traceNewLayer(layerID, getName().c_str());

    mFlinger->mFrameTracer->traceTimestamp(layerID, buffer->getId(), mFrameNumber, postTime,

    const int32_t layerId = getSequence();

    mFlinger->mTimeStats->setPostTime(layerId, mFrameNumber, getName().c_str(), postTime);

    mFlinger->mFrameTracer->traceNewLayer(layerId, getName().c_str());

    mFlinger->mFrameTracer->traceTimestamp(layerId, buffer->getId(), mFrameNumber, postTime,

                                           FrameTracer::FrameEvent::POST);

    mCurrentState.desiredPresentTime = desiredPresentTime;
@@ -458,7 +458,7 @@ status_t BufferStateLayer::updateTexImage(bool& /*recomputeVisibleRegions*/, nse 
        return NO_ERROR;

    }



    const int32_t layerID = getSequence();

    const int32_t layerId = getSequence();



    // Reject if the layer is invalid

    uint32_t bufferWidth = s.buffer->width;
@@ -480,7 +480,7 @@ status_t BufferStateLayer::updateTexImage(bool& /*recomputeVisibleRegions*/, nse 
        ALOGE("[%s] rejecting buffer: "

              "bufferWidth=%d, bufferHeight=%d, front.active.{w=%d, h=%d}",

              getDebugName(), bufferWidth, bufferHeight, s.active.w, s.active.h);

        mFlinger->mTimeStats->removeTimeRecord(layerID, mFrameNumber);

        mFlinger->mTimeStats->removeTimeRecord(layerId, mFrameNumber);

        return BAD_VALUE;

    }
@@ -497,18 +497,18 @@ status_t BufferStateLayer::updateTexImage(bool& /*recomputeVisibleRegions*/, nse 
        // a GL-composited layer) not at all.

        status_t err = bindTextureImage();

        if (err != NO_ERROR) {

            mFlinger->mTimeStats->onDestroy(layerID);

            mFlinger->mFrameTracer->onDestroy(layerID);

            mFlinger->mTimeStats->onDestroy(layerId);

            mFlinger->mFrameTracer->onDestroy(layerId);

            return BAD_VALUE;

        }

    }



    const uint64_t bufferID = getCurrentBufferId();

    mFlinger->mTimeStats->setAcquireFence(layerID, mFrameNumber, mBufferInfo.mFenceTime);

    mFlinger->mFrameTracer->traceFence(layerID, bufferID, mFrameNumber, mBufferInfo.mFenceTime,

    mFlinger->mTimeStats->setAcquireFence(layerId, mFrameNumber, mBufferInfo.mFenceTime);

    mFlinger->mFrameTracer->traceFence(layerId, bufferID, mFrameNumber, mBufferInfo.mFenceTime,

                                       FrameTracer::FrameEvent::ACQUIRE_FENCE);

    mFlinger->mTimeStats->setLatchTime(layerID, mFrameNumber, latchTime);

    mFlinger->mFrameTracer->traceTimestamp(layerID, bufferID, mFrameNumber, latchTime,

    mFlinger->mTimeStats->setLatchTime(layerId, mFrameNumber, latchTime);

    mFlinger->mFrameTracer->traceTimestamp(layerId, bufferID, mFrameNumber, latchTime,

                                           FrameTracer::FrameEvent::LATCH);



    mCurrentStateModified = false;

services/surfaceflinger/FrameTracer/FrameTracer.cpp

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

}



void FrameTracer::traceNewLayer(int32_t layerID, const std::string& layerName) {

    FrameTracerDataSource::Trace([this, layerID, &layerName](FrameTracerDataSource::TraceContext) {

        if (mTraceTracker.find(layerID) == mTraceTracker.end()) {

void FrameTracer::traceNewLayer(int32_t layerId, const std::string& layerName) {

    FrameTracerDataSource::Trace([this, layerId, &layerName](FrameTracerDataSource::TraceContext) {

        if (mTraceTracker.find(layerId) == mTraceTracker.end()) {

            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 duration) {

    FrameTracerDataSource::Trace([this, layerID, bufferID, frameNumber, timestamp, type,

    FrameTracerDataSource::Trace([this, layerId, bufferID, frameNumber, timestamp, type,

                                  duration](FrameTracerDataSource::TraceContext ctx) {

        std::lock_guard<std::mutex> lock(mTraceMutex);

        if (mTraceTracker.find(layerID) == mTraceTracker.end()) {

        if (mTraceTracker.find(layerId) == mTraceTracker.end()) {

            return;

        }



        // Handle any pending fences for this buffer.

        tracePendingFencesLocked(ctx, layerID, bufferID);

        tracePendingFencesLocked(ctx, layerId, bufferID);



        // 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,

                             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) {

        const nsecs_t signalTime = fence->getSignalTime();

        if (signalTime != Fence::SIGNAL_TIME_INVALID) {

            std::lock_guard<std::mutex> lock(mTraceMutex);

            if (mTraceTracker.find(layerID) == mTraceTracker.end()) {

            if (mTraceTracker.find(layerId) == mTraceTracker.end()) {

                return;

            }



            // Handle any pending fences for this buffer.

            tracePendingFencesLocked(ctx, layerID, bufferID);

            tracePendingFencesLocked(ctx, layerId, bufferID);



            if (signalTime != Fence::SIGNAL_TIME_PENDING) {

                traceSpanLocked(ctx, layerID, bufferID, frameNumber, type, startTime, signalTime);

                traceSpanLocked(ctx, layerId, bufferID, frameNumber, type, startTime, signalTime);

            } else {

                mTraceTracker[layerID].pendingFences[bufferID].push_back(

                mTraceTracker[layerId].pendingFences[bufferID].push_back(

                        {.frameNumber = frameNumber,

                         .type = type,

                         .fence = fence,
@@ -100,9 +100,9 @@ void FrameTracer::traceFence(int32_t layerID, uint64_t bufferID, uint64_t frameN 
}



void FrameTracer::tracePendingFencesLocked(FrameTracerDataSource::TraceContext& ctx,

                                           int32_t layerID, uint64_t bufferID) {

    if (mTraceTracker[layerID].pendingFences.count(bufferID)) {

        auto& pendingFences = mTraceTracker[layerID].pendingFences[bufferID];

                                           int32_t layerId, uint64_t bufferID) {

    if (mTraceTracker[layerId].pendingFences.count(bufferID)) {

        auto& pendingFences = mTraceTracker[layerId].pendingFences[bufferID];

        for (size_t i = 0; i < pendingFences.size(); ++i) {

            auto& pendingFence = pendingFences[i];
@@ -116,7 +116,7 @@ void FrameTracer::tracePendingFencesLocked(FrameTracerDataSource::TraceContext& 


            if (signalTime != Fence::SIGNAL_TIME_INVALID &&

                systemTime() - signalTime < kFenceSignallingDeadline) {

                traceSpanLocked(ctx, layerID, bufferID, pendingFence.frameNumber, pendingFence.type,

                traceSpanLocked(ctx, layerId, bufferID, pendingFence.frameNumber, pendingFence.type,

                                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,

                              FrameEvent::BufferEventType type, nsecs_t duration) {

    auto packet = ctx.NewTracePacket();
@@ -138,9 +138,9 @@ void FrameTracer::traceLocked(FrameTracerDataSource::TraceContext& ctx, int32_t 
    }

    event->set_type(type);



    if (mTraceTracker.find(layerID) != mTraceTracker.end() &&

        !mTraceTracker[layerID].layerName.empty()) {

        const std::string& layerName = mTraceTracker[layerID].layerName;

    if (mTraceTracker.find(layerId) != mTraceTracker.end() &&

        !mTraceTracker[layerId].layerName.empty()) {

        const std::string& layerName = mTraceTracker[layerId].layerName;

        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,

                                  FrameEvent::BufferEventType type, nsecs_t startTime,

                                  nsecs_t endTime) {
@@ -159,12 +159,12 @@ void FrameTracer::traceSpanLocked(FrameTracerDataSource::TraceContext& ctx, int3 
        timestamp = 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);

    mTraceTracker.erase(layerID);

    mTraceTracker.erase(layerId);

}



std::string FrameTracer::miniDump() {

services/surfaceflinger/FrameTracer/FrameTracer.h

+7 −7
Original line number Diff line number Diff line
@@ -47,21 +47,21 @@ public: 
    void registerDataSource();

    // Starts tracking a new layer for tracing. Needs to be called once before traceTimestamp() or

    // 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.

    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);

    // 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

    // 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

    // 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,

                    nsecs_t startTime = 0);



    // Takes care of cleanup when a layer is destroyed.

    void onDestroy(int32_t layerID);

    void onDestroy(int32_t layerId);



    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

    // trace points for them.

    void tracePendingFencesLocked(FrameTracerDataSource::TraceContext& ctx, int32_t layerID,

    void tracePendingFencesLocked(FrameTracerDataSource::TraceContext& ctx, int32_t layerId,

                                  uint64_t bufferID);

    // 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 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,

                         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,

                     nsecs_t duration = 0);