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

Commit b36af87f authored by Chris Craik's avatar Chris Craik
Browse files

Use LinearStdAllocator in DisplayList 

bug:24300128

This removes most of the remaining calls to malloc when
recording DisplayLists.

Change-Id: If928bd53dac0f145aadc436a62759086b67da0ed
parent 5419280f

libs/hwui/DisplayList.cpp

+14 −3
Original line number Diff line number Diff line
@@ -34,6 +34,17 @@ namespace uirenderer { 


DisplayList::DisplayList()

        : projectionReceiveIndex(-1)

        , stdAllocator(allocator)

        , chunks(stdAllocator)

        , ops(stdAllocator)

        , children(stdAllocator)

        , bitmapResources(stdAllocator)

        , pathResources(stdAllocator)

        , patchResources(stdAllocator)

        , paints(stdAllocator)

        , regions(stdAllocator)

        , referenceHolders(stdAllocator)

        , functors(stdAllocator)

        , hasDrawOps(false) {

}
@@ -68,9 +79,9 @@ void DisplayList::cleanupResources() { 
}



size_t DisplayList::addChild(NodeOpType* op) {

    mReferenceHolders.push_back(op->renderNode);

    size_t index = mChildren.size();

    mChildren.push_back(op);

    referenceHolders.push_back(op->renderNode);

    size_t index = children.size();

    children.push_back(op);

    return index;

}

libs/hwui/DisplayList.h

+24 −24
Original line number Diff line number Diff line
@@ -132,32 +132,22 @@ public: 
    DisplayList();

    ~DisplayList();



    // pointers to all ops within display list, pointing into allocator data

    std::vector<DisplayListOp*> displayListOps;



    // index of DisplayListOp restore, after which projected descendents should be drawn

    int projectionReceiveIndex;



    std::vector<const SkBitmap*> bitmapResources;

    std::vector<const SkPath*> pathResources;

    std::vector<const Res_png_9patch*> patchResources;

    const LsaVector<Chunk>& getChunks() const { return chunks; }

    const LsaVector<BaseOpType*>& getOps() const { return ops; }



    std::vector<std::unique_ptr<const SkPaint>> paints;

    std::vector<std::unique_ptr<const SkRegion>> regions;

    Vector<Functor*> functors;

    const LsaVector<NodeOpType*>& getChildren() const { return children; }



    const std::vector<Chunk>& getChunks() const {

            return chunks;

    }

    const std::vector<BaseOpType*>& getOps() const {

        return ops;

    }

    const LsaVector<const SkBitmap*>& getBitmapResources() const { return bitmapResources; }

    const LsaVector<Functor*>& getFunctors() const { return functors; }



    size_t addChild(NodeOpType* childOp);

    const std::vector<NodeOpType*>& children() { return mChildren; }





    void ref(VirtualLightRefBase* prop) {

        mReferenceHolders.push_back(prop);

        referenceHolders.push_back(prop);

    }



    size_t getUsedSize() {
@@ -168,17 +158,27 @@ public: 
    }



private:

    std::vector<BaseOpType*> ops;

    // allocator into which all ops and LsaVector arrays allocated

    LinearAllocator allocator;

    LinearStdAllocator<void*> stdAllocator;



    std::vector< sp<VirtualLightRefBase> > mReferenceHolders;

    LsaVector<Chunk> chunks;

    LsaVector<BaseOpType*> ops;



    // list of children display lists for quick, non-drawing traversal

    std::vector<NodeOpType*> mChildren;

    // list of Ops referring to RenderNode children for quick, non-drawing traversal

    LsaVector<NodeOpType*> children;



    std::vector<Chunk> chunks;

    // Resources - Skia objects + 9 patches referred to by this DisplayList

    LsaVector<const SkBitmap*> bitmapResources;

    LsaVector<const SkPath*> pathResources;

    LsaVector<const Res_png_9patch*> patchResources;

    LsaVector<std::unique_ptr<const SkPaint>> paints;

    LsaVector<std::unique_ptr<const SkRegion>> regions;

    LsaVector< sp<VirtualLightRefBase> > referenceHolders;



    // List of functors

    LsaVector<Functor*> functors;



    // allocator into which all ops were allocated

    LinearAllocator allocator;

    bool hasDrawOps;



    void cleanupResources();

libs/hwui/DisplayListCanvas.cpp

+2 −2
Original line number Diff line number Diff line
@@ -82,7 +82,7 @@ DisplayList* DisplayListCanvas::finishRecording() { 


void DisplayListCanvas::callDrawGLFunction(Functor *functor) {

    addDrawOp(new (alloc()) DrawFunctorOp(functor));

    mDisplayList->functors.add(functor);

    mDisplayList->functors.push_back(functor);

}



SkCanvas* DisplayListCanvas::asSkCanvas() {
@@ -528,7 +528,7 @@ size_t DisplayListCanvas::addOpAndUpdateChunk(DisplayListOp* op) { 
        newChunk.endOpIndex = insertIndex + 1;

        newChunk.reorderChildren = (mDeferredBarrierType == kBarrier_OutOfOrder);



        int nextChildIndex = mDisplayList->children().size();

        int nextChildIndex = mDisplayList->children.size();

        newChunk.beginChildIndex = newChunk.endChildIndex = nextChildIndex;

        mDeferredBarrierType = kBarrier_None;

    } else {

libs/hwui/OpReorderer.cpp

+7 −10
Original line number Diff line number Diff line
@@ -225,18 +225,17 @@ void OpReorderer::defer(const SkRect& clip, int viewportWidth, int viewportHeigh 
        if (node->applyViewProperties(mCanvasState)) {

            // not rejected do ops...

            const DisplayList& displayList = node->getDisplayList();

            deferImpl(displayList.getChunks(), displayList.getOps());

            deferImpl(displayList);

        }

        mCanvasState.restore();

    }

}



void OpReorderer::defer(int viewportWidth, int viewportHeight,

        const std::vector<DisplayList::Chunk>& chunks, const std::vector<RecordedOp*>& ops) {

void OpReorderer::defer(int viewportWidth, int viewportHeight, const DisplayList& displayList) {

    ATRACE_NAME("prepare drawing commands");

    mCanvasState.initializeSaveStack(viewportWidth, viewportHeight,

            0, 0, viewportWidth, viewportHeight, Vector3());

    deferImpl(chunks, ops);

    deferImpl(displayList);

}



/**
@@ -247,14 +246,13 @@ void OpReorderer::defer(int viewportWidth, int viewportHeight, 
 */

#define OP_RECIEVER(Type) \

        [](OpReorderer& reorderer, const RecordedOp& op) { reorderer.on##Type(static_cast<const Type&>(op)); },

void OpReorderer::deferImpl(const std::vector<DisplayList::Chunk>& chunks,

        const std::vector<RecordedOp*>& ops) {

void OpReorderer::deferImpl(const DisplayList& displayList) {

    static std::function<void(OpReorderer& reorderer, const RecordedOp&)> receivers[] = {

        MAP_OPS(OP_RECIEVER)

    };

    for (const DisplayList::Chunk& chunk : chunks) {

    for (const DisplayList::Chunk& chunk : displayList.getChunks()) {

        for (size_t opIndex = chunk.beginOpIndex; opIndex < chunk.endOpIndex; opIndex++) {

            const RecordedOp* op = ops[opIndex];

            const RecordedOp* op = displayList.getOps()[opIndex];

            receivers[op->opId](*this, *op);

        }

    }
@@ -288,8 +286,7 @@ void OpReorderer::onRenderNodeOp(const RenderNodeOp& op) { 
    // apply RenderProperties state

    if (op.renderNode->applyViewProperties(mCanvasState)) {

        // not rejected do ops...

        const DisplayList& displayList = op.renderNode->getDisplayList();

        deferImpl(displayList.getChunks(), displayList.getOps());

        deferImpl(op.renderNode->getDisplayList());

    }

    mCanvasState.restore();

}

libs/hwui/OpReorderer.h

+2 −4
Original line number Diff line number Diff line
@@ -62,8 +62,7 @@ public: 
    void defer(const SkRect& clip, int viewportWidth, int viewportHeight,

            const std::vector< sp<RenderNode> >& nodes);



    void defer(int viewportWidth, int viewportHeight,

            const std::vector<DisplayList::Chunk>& chunks, const std::vector<RecordedOp*>& ops);

    void defer(int viewportWidth, int viewportHeight, const DisplayList& displayList);

    typedef std::function<void(void*, const RecordedOp&, const BakedOpState&)> BakedOpReceiver;



    /**
@@ -92,8 +91,7 @@ public: 
private:

    BakedOpState* bakeOpState(const RecordedOp& recordedOp);



    void deferImpl(const std::vector<DisplayList::Chunk>& chunks,

            const std::vector<RecordedOp*>& ops);

    void deferImpl(const DisplayList& displayList);



    void replayBakedOpsImpl(void* arg, BakedOpReceiver* receivers);