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

Commit 677ce2cb authored by Chia-I Wu's avatar Chia-I Wu Committed by Android (Google) Code Review
Browse files

Merge "surfaceflinger: simplify memory management for layerproto"

parents f7aba597 2f884135

services/surfaceflinger/LayerStats.cpp

+3 −3
Original line number Diff line number Diff line
@@ -57,7 +57,7 @@ bool LayerStats::isEnabled() { 
}



void LayerStats::traverseLayerTreeStatsLocked(

        const std::vector<std::unique_ptr<LayerProtoParser::Layer>>& layerTree,

        const std::vector<LayerProtoParser::Layer*>& layerTree,

        const LayerProtoParser::LayerGlobal& layerGlobal,

        std::vector<std::string>* const outLayerShapeVec) {

    for (const auto& layer : layerTree) {
@@ -82,7 +82,7 @@ void LayerStats::traverseLayerTreeStatsLocked( 
        base::StringAppendF(&key, ",%s",

                            destinationSize(layer->hwcFrame.bottom - layer->hwcFrame.top,

                                            layerGlobal.resolution[1], false));

        base::StringAppendF(&key, ",%s", scaleRatioWH(layer.get()).c_str());

        base::StringAppendF(&key, ",%s", scaleRatioWH(layer).c_str());

        base::StringAppendF(&key, ",%s", alpha(static_cast<float>(layer->color.a)));



        outLayerShapeVec->push_back(key);
@@ -98,7 +98,7 @@ void LayerStats::logLayerStats(const LayersProto& layersProto) { 
    std::vector<std::string> layerShapeVec;



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

    traverseLayerTreeStatsLocked(layerTree, layerGlobal, &layerShapeVec);

    traverseLayerTreeStatsLocked(layerTree.topLevelLayers, layerGlobal, &layerShapeVec);



    std::string layerShapeKey =

            base::StringPrintf("%d,%s,%s,%s", static_cast<int32_t>(layerShapeVec.size()),

services/surfaceflinger/LayerStats.h

+1 −1
Original line number Diff line number Diff line
@@ -38,7 +38,7 @@ public: 
private:

    // Traverse layer tree to get all visible layers' stats

    void traverseLayerTreeStatsLocked(

            const std::vector<std::unique_ptr<LayerProtoParser::Layer>>& layerTree,

            const std::vector<LayerProtoParser::Layer*>& layerTree,

            const LayerProtoParser::LayerGlobal& layerGlobal,

            std::vector<std::string>* const outLayerShapeVec);

    // Convert layer's top-left position into 8x8 percentage of the display

services/surfaceflinger/SurfaceFlinger.cpp

+6 −4
Original line number Diff line number Diff line
@@ -4620,10 +4620,12 @@ void SurfaceFlinger::dumpAllLocked(const Vector<String16>& args, size_t& index, 
                        mGraphicBufferProducerList.size(), mMaxGraphicBufferProducerListSize);

    colorizer.reset(result);



    {

        LayersProto layersProto = dumpProtoInfo(LayerVector::StateSet::Current);

        auto layerTree = LayerProtoParser::generateLayerTree(layersProto);

    result.append(LayerProtoParser::layersToString(std::move(layerTree)).c_str());

        result.append(LayerProtoParser::layerTreeToString(layerTree).c_str());

        result.append("\n");

    }



    result.append("\nFrame-Composition information:\n");

    dumpFrameCompositionInfo(result);

services/surfaceflinger/layerproto/LayerProtoParser.cpp

+65 −70
Original line number Diff line number Diff line
@@ -37,11 +37,6 @@ bool sortLayers(LayerProtoParser::Layer* lhs, const LayerProtoParser::Layer* rhs 
    return lhs->id < rhs->id;

}



bool sortLayerUniquePtrs(const std::unique_ptr<LayerProtoParser::Layer>& lhs,

                   const std::unique_ptr<LayerProtoParser::Layer>& rhs) {

    return sortLayers(lhs.get(), rhs.get());

}



const LayerProtoParser::LayerGlobal LayerProtoParser::generateLayerGlobalInfo(

        const LayersProto& layersProto) {

    LayerGlobal layerGlobal;
@@ -52,77 +47,80 @@ const LayerProtoParser::LayerGlobal LayerProtoParser::generateLayerGlobalInfo( 
    return layerGlobal;

}



std::vector<std::unique_ptr<LayerProtoParser::Layer>> LayerProtoParser::generateLayerTree(

        const LayersProto& layersProto) {

    std::unordered_map<int32_t, LayerProtoParser::Layer*> layerMap = generateMap(layersProto);

    std::vector<std::unique_ptr<LayerProtoParser::Layer>> layers;

LayerProtoParser::LayerTree LayerProtoParser::generateLayerTree(const LayersProto& layersProto) {

    LayerTree layerTree;

    layerTree.allLayers = generateLayerList(layersProto);



    for (std::pair<int32_t, Layer*> kv : layerMap) {

        if (kv.second->parent == nullptr) {

            // Make unique_ptr for top level layers since they are not children. This ensures there

            // will only be one unique_ptr made for each layer.

            layers.push_back(std::unique_ptr<Layer>(kv.second));

    // find and sort the top-level layers

    for (Layer& layer : layerTree.allLayers) {

        if (layer.parent == nullptr) {

            layerTree.topLevelLayers.push_back(&layer);

        }

    }

    std::sort(layerTree.topLevelLayers.begin(), layerTree.topLevelLayers.end(), sortLayers);



    std::sort(layers.begin(), layers.end(), sortLayerUniquePtrs);

    return layers;

    return layerTree;

}



std::unordered_map<int32_t, LayerProtoParser::Layer*> LayerProtoParser::generateMap(

std::vector<LayerProtoParser::Layer> LayerProtoParser::generateLayerList(

        const LayersProto& layersProto) {

    std::vector<Layer> layerList;

    std::unordered_map<int32_t, Layer*> layerMap;



    // build the layer list and the layer map

    layerList.reserve(layersProto.layers_size());

    layerMap.reserve(layersProto.layers_size());

    for (int i = 0; i < layersProto.layers_size(); i++) {

        const LayerProto& layerProto = layersProto.layers(i);

        layerMap[layerProto.id()] = generateLayer(layerProto);

        layerList.emplace_back(generateLayer(layersProto.layers(i)));

        // this works because layerList never changes capacity

        layerMap[layerList.back().id] = &layerList.back();

    }



    // fix up children and relatives

    for (int i = 0; i < layersProto.layers_size(); i++) {

        const LayerProto& layerProto = layersProto.layers(i);

        updateChildrenAndRelative(layerProto, layerMap);

        updateChildrenAndRelative(layersProto.layers(i), layerMap);

    }



    return layerMap;

    return layerList;

}



LayerProtoParser::Layer* LayerProtoParser::generateLayer(const LayerProto& layerProto) {

    Layer* layer = new Layer();

    layer->id = layerProto.id();

    layer->name = layerProto.name();

    layer->type = layerProto.type();

    layer->transparentRegion = generateRegion(layerProto.transparent_region());

    layer->visibleRegion = generateRegion(layerProto.visible_region());

    layer->damageRegion = generateRegion(layerProto.damage_region());

    layer->layerStack = layerProto.layer_stack();

    layer->z = layerProto.z();

    layer->position = {layerProto.position().x(), layerProto.position().y()};

    layer->requestedPosition = {layerProto.requested_position().x(),

LayerProtoParser::Layer LayerProtoParser::generateLayer(const LayerProto& layerProto) {

    Layer layer;

    layer.id = layerProto.id();

    layer.name = layerProto.name();

    layer.type = layerProto.type();

    layer.transparentRegion = generateRegion(layerProto.transparent_region());

    layer.visibleRegion = generateRegion(layerProto.visible_region());

    layer.damageRegion = generateRegion(layerProto.damage_region());

    layer.layerStack = layerProto.layer_stack();

    layer.z = layerProto.z();

    layer.position = {layerProto.position().x(), layerProto.position().y()};

    layer.requestedPosition = {layerProto.requested_position().x(),

                                layerProto.requested_position().y()};

    layer->size = {layerProto.size().w(), layerProto.size().h()};

    layer->crop = generateRect(layerProto.crop());

    layer->isOpaque = layerProto.is_opaque();

    layer->invalidate = layerProto.invalidate();

    layer->dataspace = layerProto.dataspace();

    layer->pixelFormat = layerProto.pixel_format();

    layer->color = {layerProto.color().r(), layerProto.color().g(), layerProto.color().b(),

    layer.size = {layerProto.size().w(), layerProto.size().h()};

    layer.crop = generateRect(layerProto.crop());

    layer.isOpaque = layerProto.is_opaque();

    layer.invalidate = layerProto.invalidate();

    layer.dataspace = layerProto.dataspace();

    layer.pixelFormat = layerProto.pixel_format();

    layer.color = {layerProto.color().r(), layerProto.color().g(), layerProto.color().b(),

                    layerProto.color().a()};

    layer->requestedColor = {layerProto.requested_color().r(), layerProto.requested_color().g(),

    layer.requestedColor = {layerProto.requested_color().r(), layerProto.requested_color().g(),

                             layerProto.requested_color().b(), layerProto.requested_color().a()};

    layer->flags = layerProto.flags();

    layer->transform = generateTransform(layerProto.transform());

    layer->requestedTransform = generateTransform(layerProto.requested_transform());

    layer->activeBuffer = generateActiveBuffer(layerProto.active_buffer());

    layer->bufferTransform = generateTransform(layerProto.buffer_transform());

    layer->queuedFrames = layerProto.queued_frames();

    layer->refreshPending = layerProto.refresh_pending();

    layer->hwcFrame = generateRect(layerProto.hwc_frame());

    layer->hwcCrop = generateFloatRect(layerProto.hwc_crop());

    layer->hwcTransform = layerProto.hwc_transform();

    layer->windowType = layerProto.window_type();

    layer->appId = layerProto.app_id();

    layer->hwcCompositionType = layerProto.hwc_composition_type();

    layer->isProtected = layerProto.is_protected();

    layer.flags = layerProto.flags();

    layer.transform = generateTransform(layerProto.transform());

    layer.requestedTransform = generateTransform(layerProto.requested_transform());

    layer.activeBuffer = generateActiveBuffer(layerProto.active_buffer());

    layer.bufferTransform = generateTransform(layerProto.buffer_transform());

    layer.queuedFrames = layerProto.queued_frames();

    layer.refreshPending = layerProto.refresh_pending();

    layer.hwcFrame = generateRect(layerProto.hwc_frame());

    layer.hwcCrop = generateFloatRect(layerProto.hwc_crop());

    layer.hwcTransform = layerProto.hwc_transform();

    layer.windowType = layerProto.window_type();

    layer.appId = layerProto.app_id();

    layer.hwcCompositionType = layerProto.hwc_composition_type();

    layer.isProtected = layerProto.is_protected();



    return layer;

}
@@ -186,9 +184,7 @@ void LayerProtoParser::updateChildrenAndRelative(const LayerProto& layerProto, 


    for (int i = 0; i < layerProto.children_size(); i++) {

        if (layerMap.count(layerProto.children(i)) > 0) {

            // Only make unique_ptrs for children since they are guaranteed to be unique, only one

            // parent per child. This ensures there will only be one unique_ptr made for each layer.

            currLayer->children.push_back(std::unique_ptr<Layer>(layerMap[layerProto.children(i)]));

            currLayer->children.push_back(layerMap[layerProto.children(i)]);

        }

    }
@@ -211,29 +207,28 @@ void LayerProtoParser::updateChildrenAndRelative(const LayerProto& layerProto, 
    }

}



std::string LayerProtoParser::layersToString(

        std::vector<std::unique_ptr<LayerProtoParser::Layer>> layers) {

std::string LayerProtoParser::layerTreeToString(const LayerTree& layerTree) {

    std::string result;

    for (std::unique_ptr<LayerProtoParser::Layer>& layer : layers) {

    for (const LayerProtoParser::Layer* layer : layerTree.topLevelLayers) {

        if (layer->zOrderRelativeOf != nullptr) {

            continue;

        }

        result.append(layerToString(layer.get()).c_str());

        result.append(layerToString(layer));

    }



    return result;

}



std::string LayerProtoParser::layerToString(LayerProtoParser::Layer* layer) {

std::string LayerProtoParser::layerToString(const LayerProtoParser::Layer* layer) {

    std::string result;



    std::vector<Layer*> traverse(layer->relatives);

    for (std::unique_ptr<LayerProtoParser::Layer>& child : layer->children) {

    for (LayerProtoParser::Layer* child : layer->children) {

        if (child->zOrderRelativeOf != nullptr) {

            continue;

        }



        traverse.push_back(child.get());

        traverse.push_back(child);

    }



    std::sort(traverse.begin(), traverse.end(), sortLayers);
@@ -244,13 +239,13 @@ std::string LayerProtoParser::layerToString(LayerProtoParser::Layer* layer) { 
        if (relative->z >= 0) {

            break;

        }

        result.append(layerToString(relative).c_str());

        result.append(layerToString(relative));

    }

    result.append(layer->to_string().c_str());

    result.append(layer->to_string());

    result.append("\n");

    for (; i < traverse.size(); i++) {

        auto& relative = traverse[i];

        result.append(layerToString(relative).c_str());

        result.append(layerToString(relative));

    }



    return result;

services/surfaceflinger/layerproto/include/layerproto/LayerProtoParser.h

+15 −6
Original line number Diff line number Diff line
@@ -80,7 +80,7 @@ public: 
    public:

        int32_t id;

        std::string name;

        std::vector<std::unique_ptr<Layer>> children;

        std::vector<Layer*> children;

        std::vector<Layer*> relatives;

        std::string type;

        LayerProtoParser::Region transparentRegion;
@@ -126,13 +126,22 @@ public: 
        int32_t globalTransform;

    };



    class LayerTree {

    public:

        // all layers in LayersProto and in the original order

        std::vector<Layer> allLayers;



        // pointers to top-level layers in allLayers

        std::vector<Layer*> topLevelLayers;

    };



    static const LayerGlobal generateLayerGlobalInfo(const LayersProto& layersProto);

    static std::vector<std::unique_ptr<Layer>> generateLayerTree(const LayersProto& layersProto);

    static std::string layersToString(std::vector<std::unique_ptr<LayerProtoParser::Layer>> layers);

    static LayerTree generateLayerTree(const LayersProto& layersProto);

    static std::string layerTreeToString(const LayerTree& layerTree);



private:

    static std::unordered_map<int32_t, Layer*> generateMap(const LayersProto& layersProto);

    static LayerProtoParser::Layer* generateLayer(const LayerProto& layerProto);

    static std::vector<Layer> generateLayerList(const LayersProto& layersProto);

    static LayerProtoParser::Layer generateLayer(const LayerProto& layerProto);

    static LayerProtoParser::Region generateRegion(const RegionProto& regionProto);

    static LayerProtoParser::Rect generateRect(const RectProto& rectProto);

    static LayerProtoParser::FloatRect generateFloatRect(const FloatRectProto& rectProto);
@@ -142,7 +151,7 @@ private: 
    static void updateChildrenAndRelative(const LayerProto& layerProto,

                                          std::unordered_map<int32_t, Layer*>& layerMap);



    static std::string layerToString(LayerProtoParser::Layer* layer);

    static std::string layerToString(const LayerProtoParser::Layer* layer);

};



} // namespace surfaceflinger