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

Commit 5cf3a94b authored by Vishnu Nair's avatar Vishnu Nair Committed by Android (Google) Code Review
Browse files

Merge changes I021be9a3,Ia11839d1 

* changes:
  LayerTraceGenerator: Fix layer deletion
  LayerTraceGenerator: Fix duplicate layer ids
parents 9a1eac79 3e40cddb

services/surfaceflinger/SurfaceFlinger.cpp

+12 −10
Original line number Diff line number Diff line
@@ -2056,6 +2056,11 @@ bool SurfaceFlinger::commit(nsecs_t frameTime, int64_t vsyncId, nsecs_t expected 
        mGpuFrameMissedCount++;

    }



    if (mTracingEnabledChanged) {

        mLayerTracingEnabled = mLayerTracing.isEnabled();

        mTracingEnabledChanged = false;

    }



    // If we are in the middle of a mode change and the fence hasn't

    // fired yet just wait for the next commit.

    if (mSetActiveModePending) {
@@ -2104,11 +2109,6 @@ bool SurfaceFlinger::commit(nsecs_t frameTime, int64_t vsyncId, nsecs_t expected 
        }

    }



    if (mTracingEnabledChanged) {

        mLayerTracingEnabled = mLayerTracing.isEnabled();

        mTracingEnabledChanged = false;

    }



    if (mRefreshRateOverlaySpinner) {

        Mutex::Autolock lock(mStateLock);

        if (const auto display = getDefaultDisplayDeviceLocked()) {
@@ -2123,7 +2123,7 @@ bool SurfaceFlinger::commit(nsecs_t frameTime, int64_t vsyncId, nsecs_t expected 


        bool needsTraversal = false;

        if (clearTransactionFlags(eTransactionFlushNeeded)) {

            needsTraversal |= commitCreatedLayers();

            needsTraversal |= commitCreatedLayers(vsyncId);

            needsTraversal |= flushTransactionQueues(vsyncId);

        }
@@ -7153,7 +7153,7 @@ int SurfaceFlinger::getMaxAcquiredBufferCountForRefreshRate(Fps refreshRate) con 
    return calculateMaxAcquiredBufferCount(refreshRate, presentLatency);

}



void SurfaceFlinger::handleLayerCreatedLocked(const LayerCreatedState& state) {

void SurfaceFlinger::handleLayerCreatedLocked(const LayerCreatedState& state, int64_t vsyncId) {

    sp<Layer> layer = state.layer.promote();

    if (!layer) {

        ALOGD("Layer was destroyed soon after creation %p", state.layer.unsafe_get());
@@ -7183,7 +7183,9 @@ void SurfaceFlinger::handleLayerCreatedLocked(const LayerCreatedState& state) { 
    }



    layer->updateTransformHint(mActiveDisplayTransformHint);



    if (mTransactionTracing) {

        mTransactionTracing->onLayerAddedToDrawingState(layer->getSequence(), vsyncId);

    }

    mInterceptor->saveSurfaceCreation(layer);

}
@@ -7267,7 +7269,7 @@ std::shared_ptr<renderengine::ExternalTexture> SurfaceFlinger::getExternalTextur 
    return buffer;

}



bool SurfaceFlinger::commitCreatedLayers() {

bool SurfaceFlinger::commitCreatedLayers(int64_t vsyncId) {

    std::vector<LayerCreatedState> createdLayers;

    {

        std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
@@ -7280,7 +7282,7 @@ bool SurfaceFlinger::commitCreatedLayers() { 


    Mutex::Autolock _l(mStateLock);

    for (const auto& createdLayer : createdLayers) {

        handleLayerCreatedLocked(createdLayer);

        handleLayerCreatedLocked(createdLayer, vsyncId);

    }

    createdLayers.clear();

    mLayersAdded = true;

services/surfaceflinger/SurfaceFlinger.h

+3 −2
Original line number Diff line number Diff line
@@ -1405,8 +1405,9 @@ private: 
    // A temporay pool that store the created layers and will be added to current state in main

    // thread.

    std::vector<LayerCreatedState> mCreatedLayers GUARDED_BY(mCreatedLayersLock);

    bool commitCreatedLayers();

    void handleLayerCreatedLocked(const LayerCreatedState& state) REQUIRES(mStateLock);

    bool commitCreatedLayers(int64_t vsyncId);

    void handleLayerCreatedLocked(const LayerCreatedState& state, int64_t vsyncId)

            REQUIRES(mStateLock);



    std::atomic<ui::Transform::RotationFlags> mActiveDisplayTransformHint;

services/surfaceflinger/Tracing/TransactionProtoParser.cpp

+7 −2
Original line number Diff line number Diff line
@@ -498,8 +498,13 @@ void TransactionProtoParser::fromProto(const proto::LayerState& proto, layer_sta 
        inputInfo.replaceTouchableRegionWithCrop =

                windowInfoProto.replace_touchable_region_with_crop();

        int64_t layerId = windowInfoProto.crop_layer_id();

        if (layerId != -1) {

            inputInfo.touchableRegionCropHandle =

                    mMapper->getLayerHandle(static_cast<int32_t>(layerId));

        } else {

            inputInfo.touchableRegionCropHandle = nullptr;

        }



        layer.windowInfoHandle = sp<gui::WindowInfoHandle>::make(inputInfo);

    }

    if (proto.what() & layer_state_t::eBackgroundColorChanged) {

services/surfaceflinger/Tracing/TransactionTracing.cpp

+55 −20
Original line number Diff line number Diff line
@@ -152,17 +152,33 @@ void TransactionTracing::addQueuedTransaction(const TransactionState& transactio 
    mTransactionQueue.push(state);

}



void TransactionTracing::addCommittedTransactions(std::vector<TransactionState>& transactions,

                                                  int64_t vsyncId) {

TransactionTracing::CommittedTransactions&

TransactionTracing::findOrCreateCommittedTransactionRecord(int64_t vsyncId) {

    for (auto& pendingTransaction : mPendingTransactions) {

        if (pendingTransaction.vsyncId == vsyncId) {

            return pendingTransaction;

        }

    }



    CommittedTransactions committedTransactions;

    committedTransactions.vsyncId = vsyncId;

    committedTransactions.timestamp = systemTime();

    mPendingTransactions.emplace_back(committedTransactions);

    return mPendingTransactions.back();

}



void TransactionTracing::onLayerAddedToDrawingState(int layerId, int64_t vsyncId) {

    CommittedTransactions& committedTransactions = findOrCreateCommittedTransactionRecord(vsyncId);

    committedTransactions.createdLayerIds.emplace_back(layerId);

}



void TransactionTracing::addCommittedTransactions(std::vector<TransactionState>& transactions,

                                                  int64_t vsyncId) {

    CommittedTransactions& committedTransactions = findOrCreateCommittedTransactionRecord(vsyncId);

    committedTransactions.transactionIds.reserve(transactions.size());

    for (const auto& transaction : transactions) {

        committedTransactions.transactionIds.emplace_back(transaction.id);

    }



    mPendingTransactions.emplace_back(committedTransactions);

    tryPushToTracingThread();

}
@@ -235,15 +251,24 @@ void TransactionTracing::addEntry(const std::vector<CommittedTransactions>& comm 
    for (const CommittedTransactions& entry : committedTransactions) {

        entryProto.set_elapsed_realtime_nanos(entry.timestamp);

        entryProto.set_vsync_id(entry.vsyncId);

        entryProto.mutable_added_layers()->Reserve(static_cast<int32_t>(mCreatedLayers.size()));

        for (auto& newLayer : mCreatedLayers) {

            entryProto.mutable_added_layers()->Add(std::move(newLayer));

        entryProto.mutable_added_layers()->Reserve(

                static_cast<int32_t>(entry.createdLayerIds.size()));



        for (const int32_t& id : entry.createdLayerIds) {

            auto it = mCreatedLayers.find(id);

            if (it != mCreatedLayers.end()) {

                entryProto.mutable_added_layers()->Add(std::move(it->second));

                mCreatedLayers.erase(it);

            } else {

                ALOGW("Could not created layer with id %d", id);

            }

        }



        entryProto.mutable_removed_layers()->Reserve(static_cast<int32_t>(removedLayers.size()));

        for (auto& removedLayer : removedLayers) {

            entryProto.mutable_removed_layers()->Add(removedLayer);

            mCreatedLayers.erase(removedLayer);

        }

        mCreatedLayers.clear();

        entryProto.mutable_transactions()->Reserve(

                static_cast<int32_t>(entry.transactionIds.size()));

        for (const uint64_t& id : entry.transactionIds) {
@@ -256,6 +281,14 @@ void TransactionTracing::addEntry(const std::vector<CommittedTransactions>& comm 
            }

        }



        entryProto.mutable_removed_layer_handles()->Reserve(

                static_cast<int32_t>(mRemovedLayerHandles.size()));

        for (auto& [handle, layerId] : mRemovedLayerHandles) {

            entryProto.mutable_removed_layer_handles()->Add(layerId);

            mLayerHandles.erase(handle);

        }

        mRemovedLayerHandles.clear();



        std::string serializedProto;

        entryProto.SerializeToString(&serializedProto);

        entryProto.Clear();
@@ -263,13 +296,6 @@ void TransactionTracing::addEntry(const std::vector<CommittedTransactions>& comm 
        removedEntries.reserve(removedEntries.size() + entries.size());

        removedEntries.insert(removedEntries.end(), std::make_move_iterator(entries.begin()),

                              std::make_move_iterator(entries.end()));



        entryProto.mutable_removed_layer_handles()->Reserve(

                static_cast<int32_t>(mRemovedLayerHandles.size()));

        for (auto& handle : mRemovedLayerHandles) {

            entryProto.mutable_removed_layer_handles()->Add(handle);

        }

        mRemovedLayerHandles.clear();

    }



    proto::TransactionTraceEntry removedEntryProto;
@@ -304,7 +330,7 @@ void TransactionTracing::onLayerAdded(BBinder* layerHandle, int layerId, const s 
        ALOGW("Duplicate handles found. %p", layerHandle);

    }

    mLayerHandles[layerHandle] = layerId;

    mCreatedLayers.push_back(mProtoParser.toProto(args));

    mCreatedLayers[layerId] = mProtoParser.toProto(args);

}



void TransactionTracing::onMirrorLayerAdded(BBinder* layerHandle, int layerId,
@@ -315,7 +341,7 @@ void TransactionTracing::onMirrorLayerAdded(BBinder* layerHandle, int layerId, 
        ALOGW("Duplicate handles found. %p", layerHandle);

    }

    mLayerHandles[layerHandle] = layerId;

    mCreatedLayers.emplace_back(mProtoParser.toProto(args));

    mCreatedLayers[layerId] = mProtoParser.toProto(args);

}



void TransactionTracing::onLayerRemoved(int32_t layerId) {
@@ -330,9 +356,7 @@ void TransactionTracing::onHandleRemoved(BBinder* layerHandle) { 
        ALOGW("handle not found. %p", layerHandle);

        return;

    }



    mRemovedLayerHandles.push_back(it->second);

    mLayerHandles.erase(it);

    mRemovedLayerHandles.emplace_back(layerHandle, it->second);

}



void TransactionTracing::tryPushToTracingThread() {
@@ -376,10 +400,15 @@ void TransactionTracing::updateStartingStateLocked( 
        }

    }



    for (const int32_t removedLayerHandleId : removedEntry.removed_layer_handles()) {

        mRemovedLayerHandlesAtStart.insert(removedLayerHandleId);

    }



    // Clean up stale starting states since the layer has been removed and the buffer does not

    // contain any references to the layer.

    for (const int32_t removedLayerId : removedEntry.removed_layers()) {

        mStartingStates.erase(removedLayerId);

        mRemovedLayerHandlesAtStart.erase(removedLayerId);

    }

}
@@ -401,6 +430,12 @@ void TransactionTracing::addStartingStateToProtoLocked(proto::TransactionTraceFi 
    transactionProto.set_vsync_id(0);

    transactionProto.set_post_time(mStartingTimestamp);

    entryProto->mutable_transactions()->Add(std::move(transactionProto));



    entryProto->mutable_removed_layer_handles()->Reserve(

            static_cast<int32_t>(mRemovedLayerHandlesAtStart.size()));

    for (const int32_t removedLayerHandleId : mRemovedLayerHandlesAtStart) {

        entryProto->mutable_removed_layer_handles()->Add(removedLayerHandleId);

    }

}



proto::TransactionTraceFile TransactionTracing::writeToProto() {

services/surfaceflinger/Tracing/TransactionTracing.h

+7 −3
Original line number Diff line number Diff line
@@ -64,6 +64,7 @@ public: 
                            int mirrorFromId);

    void onLayerRemoved(int layerId);

    void onHandleRemoved(BBinder* layerHandle);

    void onLayerAddedToDrawingState(int layerId, int64_t vsyncId);

    void dump(std::string&) const;

    static constexpr auto CONTINUOUS_TRACING_BUFFER_SIZE = 512 * 1024;

    static constexpr auto ACTIVE_TRACING_BUFFER_SIZE = 100 * 1024 * 1024;
@@ -81,11 +82,13 @@ private: 
            GUARDED_BY(mTraceLock);

    LocklessStack<proto::TransactionState> mTransactionQueue;

    nsecs_t mStartingTimestamp GUARDED_BY(mTraceLock);

    std::vector<proto::LayerCreationArgs> mCreatedLayers GUARDED_BY(mTraceLock);

    std::unordered_map<int, proto::LayerCreationArgs> mCreatedLayers GUARDED_BY(mTraceLock);

    std::unordered_map<BBinder* /* layerHandle */, int32_t /* layerId */> mLayerHandles

            GUARDED_BY(mTraceLock);

    std::vector<int32_t /* layerId */> mRemovedLayerHandles GUARDED_BY(mTraceLock);

    std::vector<std::pair<BBinder* /* layerHandle */, int32_t /* layerId */>> mRemovedLayerHandles

            GUARDED_BY(mTraceLock);

    std::map<int32_t /* layerId */, TracingLayerState> mStartingStates GUARDED_BY(mTraceLock);

    std::set<int32_t /* layerId */> mRemovedLayerHandlesAtStart GUARDED_BY(mTraceLock);

    TransactionProtoParser mProtoParser GUARDED_BY(mTraceLock);

    // Parses the transaction to proto without holding any tracing locks so we can generate proto

    // in the binder thread without any contention.
@@ -100,6 +103,7 @@ private: 
    std::condition_variable mTransactionsAddedToBufferCv;

    struct CommittedTransactions {

        std::vector<uint64_t> transactionIds;

        std::vector<int32_t> createdLayerIds;

        int64_t vsyncId;

        int64_t timestamp;

    };
@@ -117,7 +121,7 @@ private: 
    void tryPushToTracingThread() EXCLUDES(mMainThreadLock);

    void addStartingStateToProtoLocked(proto::TransactionTraceFile& proto) REQUIRES(mTraceLock);

    void updateStartingStateLocked(const proto::TransactionTraceEntry& entry) REQUIRES(mTraceLock);



    CommittedTransactions& findOrCreateCommittedTransactionRecord(int64_t vsyncId);

    // TEST

    // Wait until all the committed transactions for the specified vsync id are added to the buffer.

    void flush(int64_t vsyncId) EXCLUDES(mMainThreadLock);