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

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

Move DeferredDisplayState out of ops 

bug:9969358

Instead of storing DeferredDisplayState within an op (thus forcing ops
to be tied to a single state instance), associate each op with a new
state at DeferredDisplayList insertion time.

Now, DisplayLists (and the ops within) can be reused in a single
DeferredDisplayList draw call, as ops will use different state
instances at different points in the frame.

Change-Id: I525ab2abe0c3883679f2fa00b219b293e9ec53d9
parent b8b017cb

libs/hwui/DeferredDisplayList.cpp

+76 −55
Original line number Diff line number Diff line
@@ -66,23 +66,23 @@ public: 


    virtual ~DrawBatch() { mOps.clear(); }



    virtual void add(DrawOp* op, bool opaqueOverBounds) {

    virtual void add(DrawOp* op, const DeferredDisplayState* state, bool opaqueOverBounds) {

        // NOTE: ignore empty bounds special case, since we don't merge across those ops

        mBounds.unionWith(op->state.mBounds);

        mBounds.unionWith(state->mBounds);

        mAllOpsOpaque &= opaqueOverBounds;

        mOps.add(op);

        mOps.add(OpStatePair(op, state));

    }



    bool intersects(Rect& rect) {

    bool intersects(const Rect& rect) {

        if (!rect.intersects(mBounds)) return false;



        for (unsigned int i = 0; i < mOps.size(); i++) {

            if (rect.intersects(mOps[i]->state.mBounds)) {

            if (rect.intersects(mOps[i].state->mBounds)) {

#if DEBUG_DEFER

                DEFER_LOGD("op intersects with op %p with bounds %f %f %f %f:", mOps[i],

                        mOps[i]->state.mBounds.left, mOps[i]->state.mBounds.top,

                        mOps[i]->state.mBounds.right, mOps[i]->state.mBounds.bottom);

                mOps[i]->output(2);

                DEFER_LOGD("op intersects with op %p with bounds %f %f %f %f:", mOps[i].op,

                        mOps[i].state->mBounds.left, mOps[i].state->mBounds.top,

                        mOps[i].state->mBounds.right, mOps[i].state->mBounds.bottom);

                mOps[i].op->output(2);

#endif

                return true;

            }
@@ -97,9 +97,9 @@ public: 
        status_t status = DrawGlInfo::kStatusDone;

        DisplayListLogBuffer& logBuffer = DisplayListLogBuffer::getInstance();

        for (unsigned int i = 0; i < mOps.size(); i++) {

            DrawOp* op = mOps[i];



            renderer.restoreDisplayState(op->state);

            DrawOp* op = mOps[i].op;

            const DeferredDisplayState* state = mOps[i].state;

            renderer.restoreDisplayState(*state);



#if DEBUG_DISPLAY_LIST_OPS_AS_EVENTS

            renderer.eventMark(op->name());
@@ -108,7 +108,7 @@ public: 
            status |= op->applyDraw(renderer, dirty);



#if DEBUG_MERGE_BEHAVIOR

            Rect& bounds = mOps[i]->state.mBounds;

            const Rect& bounds = state->mBounds;

            int batchColor = 0x1f000000;

            if (getBatchId() & 0x1) batchColor |= 0x0000ff;

            if (getBatchId() & 0x2) batchColor |= 0x00ff00;
@@ -127,7 +127,7 @@ public: 


        Region uncovered(android::Rect(bounds.left, bounds.top, bounds.right, bounds.bottom));

        for (unsigned int i = 0; i < mOps.size(); i++) {

            Rect &r = mOps[i]->state.mBounds;

            const Rect &r = mOps[i].state->mBounds;

            uncovered.subtractSelf(android::Rect(r.left, r.top, r.right, r.bottom));

        }

        return uncovered.isEmpty();
@@ -138,7 +138,7 @@ public: 
    inline int count() const { return mOps.size(); }



protected:

    Vector<DrawOp*> mOps;

    Vector<OpStatePair> mOps;

    Rect mBounds; // union of bounds of contained ops

private:

    bool mAllOpsOpaque;
@@ -184,19 +184,19 @@ public: 
     * False positives can lead to information from the paints of subsequent merged operations being

     * dropped, so we make simplifying qualifications on the ops that can merge, per op type.

     */

    bool canMergeWith(DrawOp* op) {

    bool canMergeWith(const DrawOp* op, const DeferredDisplayState* state) {

        bool isTextBatch = getBatchId() == DeferredDisplayList::kOpBatch_Text ||

                getBatchId() == DeferredDisplayList::kOpBatch_ColorText;



        // Overlapping other operations is only allowed for text without shadow. For other ops,

        // multiDraw isn't guaranteed to overdraw correctly

        if (!isTextBatch || op->state.mDrawModifiers.mHasShadow) {

            if (intersects(op->state.mBounds)) return false;

        if (!isTextBatch || state->mDrawModifiers.mHasShadow) {

            if (intersects(state->mBounds)) return false;

        }

        const DeferredDisplayState& lhs = op->state;

        const DeferredDisplayState& rhs = mOps[0]->state;

        const DeferredDisplayState* lhs = state;

        const DeferredDisplayState* rhs = mOps[0].state;



        if (NEQ_FALPHA(lhs.mAlpha, rhs.mAlpha)) return false;

        if (NEQ_FALPHA(lhs->mAlpha, rhs->mAlpha)) return false;



        /* Clipping compatibility check

         *
@@ -204,9 +204,9 @@ public: 
         * clip for that side.

         */

        const int currentFlags = mClipSideFlags;

        const int newFlags = op->state.mClipSideFlags;

        const int newFlags = state->mClipSideFlags;

        if (currentFlags != kClipSide_None || newFlags != kClipSide_None) {

            const Rect& opBounds = op->state.mBounds;

            const Rect& opBounds = state->mBounds;

            float boundsDelta = mBounds.left - opBounds.left;

            if (!checkSide(currentFlags, newFlags, kClipSide_Left, boundsDelta)) return false;

            boundsDelta = mBounds.top - opBounds.top;
@@ -220,9 +220,9 @@ public: 
        }



        // if paints are equal, then modifiers + paint attribs don't need to be compared

        if (op->mPaint == mOps[0]->mPaint) return true;

        if (op->mPaint == mOps[0].op->mPaint) return true;



        if (op->getPaintAlpha() != mOps[0]->getPaintAlpha()) return false;

        if (op->getPaintAlpha() != mOps[0].op->getPaintAlpha()) return false;



        /* Draw Modifiers compatibility check

         *
@@ -236,8 +236,8 @@ public: 
         *

         * These ignore cases prevent us from simply memcmp'ing the drawModifiers

         */

        const DrawModifiers& lhsMod = lhs.mDrawModifiers;

        const DrawModifiers& rhsMod = rhs.mDrawModifiers;

        const DrawModifiers& lhsMod = lhs->mDrawModifiers;

        const DrawModifiers& rhsMod = rhs->mDrawModifiers;

        if (lhsMod.mShader != rhsMod.mShader) return false;

        if (lhsMod.mColorFilter != rhsMod.mColorFilter) return false;
@@ -249,15 +249,15 @@ public: 
        return true;

    }



    virtual void add(DrawOp* op, bool opaqueOverBounds) {

        DrawBatch::add(op, opaqueOverBounds);

    virtual void add(DrawOp* op, DeferredDisplayState* state, bool opaqueOverBounds) {

        DrawBatch::add(op, state, opaqueOverBounds);



        const int newClipSideFlags = op->state.mClipSideFlags;

        const int newClipSideFlags = state->mClipSideFlags;

        mClipSideFlags |= newClipSideFlags;

        if (newClipSideFlags & kClipSide_Left) mClipRect.left = op->state.mClip.left;

        if (newClipSideFlags & kClipSide_Top) mClipRect.top = op->state.mClip.top;

        if (newClipSideFlags & kClipSide_Right) mClipRect.right = op->state.mClip.right;

        if (newClipSideFlags & kClipSide_Bottom) mClipRect.bottom = op->state.mClip.bottom;

        if (newClipSideFlags & kClipSide_Left) mClipRect.left = state->mClip.left;

        if (newClipSideFlags & kClipSide_Top) mClipRect.top = state->mClip.top;

        if (newClipSideFlags & kClipSide_Right) mClipRect.right = state->mClip.right;

        if (newClipSideFlags & kClipSide_Bottom) mClipRect.bottom = state->mClip.bottom;

    }



    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
@@ -271,7 +271,7 @@ public: 
        // clipping in the merged case is done ahead of time since all ops share the clip (if any)

        renderer.setupMergedMultiDraw(mClipSideFlags ? &mClipRect : NULL);



        DrawOp* op = mOps[0];

        DrawOp* op = mOps[0].op;

        DisplayListLogBuffer& buffer = DisplayListLogBuffer::getInstance();

        buffer.writeCommand(0, "multiDraw");

        buffer.writeCommand(1, op->name());
@@ -297,11 +297,11 @@ private: 
class StateOpBatch : public Batch {

public:

    // creates a single operation batch

    StateOpBatch(StateOp* op) : mOp(op) {}

    StateOpBatch(const StateOp* op, const DeferredDisplayState* state) : mOp(op), mState(state) {}



    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {

        DEFER_LOGD("replaying state op batch %p", this);

        renderer.restoreDisplayState(mOp->state);

        renderer.restoreDisplayState(*mState);



        // use invalid save count because it won't be used at flush time - RestoreToCountOp is the

        // only one to use it, and we don't use that class at flush time, instead calling
@@ -313,16 +313,18 @@ public: 


private:

    const StateOp* mOp;

    const DeferredDisplayState* mState;

};



class RestoreToCountBatch : public Batch {

public:

    RestoreToCountBatch(StateOp* op, int restoreCount) : mOp(op), mRestoreCount(restoreCount) {}

    RestoreToCountBatch(const StateOp* op, const DeferredDisplayState* state, int restoreCount) :

            mOp(op), mState(state), mRestoreCount(restoreCount) {}



    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {

        DEFER_LOGD("batch %p restoring to count %d", this, mRestoreCount);



        renderer.restoreDisplayState(mOp->state);

        renderer.restoreDisplayState(*mState);

        renderer.restoreToCount(mRestoreCount);

        return DrawGlInfo::kStatusDone;

    }
@@ -330,6 +332,8 @@ public: 
private:

    // we use the state storage for the RestoreToCountOp, but don't replay the op itself

    const StateOp* mOp;

    const DeferredDisplayState* mState;



    /*

     * The count used here represents the flush() time saveCount. This is as opposed to the

     * DisplayList record time, or defer() time values (which are RestoreToCountOp's mCount, and
@@ -480,12 +484,27 @@ void DeferredDisplayList::addRestoreToCount(OpenGLRenderer& renderer, StateOp* o 
}



void DeferredDisplayList::addDrawOp(OpenGLRenderer& renderer, DrawOp* op) {

    if (renderer.storeDisplayState(op->state, getDrawOpDeferFlags())) {

    /* 1: op calculates local bounds */

    DeferredDisplayState* const state = createState();

    if (op->getLocalBounds(renderer.getDrawModifiers(), state->mBounds)) {

        if (state->mBounds.isEmpty()) {

            // valid empty bounds, don't bother deferring

            tryRecycleState(state);

            return;

        }

    } else {

        state->mBounds.setEmpty();

    }



    /* 2: renderer calculates global bounds + stores state */

    if (renderer.storeDisplayState(*state, getDrawOpDeferFlags())) {

        tryRecycleState(state);

        return; // quick rejected

    }



    /* 3: ask op for defer info, given renderer state */

    DeferInfo deferInfo;

    op->onDefer(renderer, deferInfo);

    op->onDefer(renderer, deferInfo, *state);



    // complex clip has a complex set of expectations on the renderer state - for now, avoid taking

    // the merge path in those cases
@@ -493,8 +512,8 @@ void DeferredDisplayList::addDrawOp(OpenGLRenderer& renderer, DrawOp* op) { 
    deferInfo.opaqueOverBounds &= !recordingComplexClip() && mSaveStack.isEmpty();



    if (CC_LIKELY(mAvoidOverdraw) && mBatches.size() &&

            op->state.mClipSideFlags != kClipSide_ConservativeFull &&

            deferInfo.opaqueOverBounds && op->state.mBounds.contains(mBounds)) {

            state->mClipSideFlags != kClipSide_ConservativeFull &&

            deferInfo.opaqueOverBounds && state->mBounds.contains(mBounds)) {

        // avoid overdraw by resetting drawing state + discarding drawing ops

        discardDrawingBatches(mBatches.size() - 1);

        resetBatchingState();
@@ -503,7 +522,7 @@ void DeferredDisplayList::addDrawOp(OpenGLRenderer& renderer, DrawOp* op) { 
    if (CC_UNLIKELY(renderer.getCaches().drawReorderDisabled)) {

        // TODO: elegant way to reuse batches?

        DrawBatch* b = new DrawBatch(deferInfo);

        b->add(op, deferInfo.opaqueOverBounds);

        b->add(op, state, deferInfo.opaqueOverBounds);

        mBatches.add(b);

        return;

    }
@@ -515,10 +534,10 @@ void DeferredDisplayList::addDrawOp(OpenGLRenderer& renderer, DrawOp* op) { 
    // (eventually, should be similar shader)

    int insertBatchIndex = mBatches.size();

    if (!mBatches.isEmpty()) {

        if (op->state.mBounds.isEmpty()) {

        if (state->mBounds.isEmpty()) {

            // don't know the bounds for op, so add to last batch and start from scratch on next op

            DrawBatch* b = new DrawBatch(deferInfo);

            b->add(op, deferInfo.opaqueOverBounds);

            b->add(op, state, deferInfo.opaqueOverBounds);

            mBatches.add(b);

            resetBatchingState();

#if DEBUG_DEFER
@@ -531,7 +550,7 @@ void DeferredDisplayList::addDrawOp(OpenGLRenderer& renderer, DrawOp* op) { 
        if (deferInfo.mergeable) {

            // Try to merge with any existing batch with same mergeId.

            if (mMergingBatches[deferInfo.batchId].get(deferInfo.mergeId, targetBatch)) {

                if (!((MergingDrawBatch*) targetBatch)->canMergeWith(op)) {

                if (!((MergingDrawBatch*) targetBatch)->canMergeWith(op, state)) {

                    targetBatch = NULL;

                }

            }
@@ -554,14 +573,14 @@ void DeferredDisplayList::addDrawOp(OpenGLRenderer& renderer, DrawOp* op) { 
                    if (!targetBatch) break; // found insert position, quit

                }



                if (overBatch->intersects(op->state.mBounds)) {

                if (overBatch->intersects(state->mBounds)) {

                    // NOTE: it may be possible to optimize for special cases where two operations

                    // of the same batch/paint could swap order, such as with a non-mergeable

                    // (clipped) and a mergeable text operation

                    targetBatch = NULL;

#if DEBUG_DEFER

                    DEFER_LOGD("op couldn't join batch %d, was intersected by batch %d",

                            targetIndex, i);

                    DEFER_LOGD("op couldn't join batch %p, was intersected by batch %d",

                            targetBatch, i);

                    op->output(2);

#endif

                    break;
@@ -586,14 +605,15 @@ void DeferredDisplayList::addDrawOp(OpenGLRenderer& renderer, DrawOp* op) { 
        mBatches.insertAt(targetBatch, insertBatchIndex);

    }



    targetBatch->add(op, deferInfo.opaqueOverBounds);

    targetBatch->add(op, state, deferInfo.opaqueOverBounds);

}



void DeferredDisplayList::storeStateOpBarrier(OpenGLRenderer& renderer, StateOp* op) {

    DEFER_LOGD("%p adding state op barrier at pos %d", this, mBatches.size());



    renderer.storeDisplayState(op->state, getStateOpDeferFlags());

    mBatches.add(new StateOpBatch(op));

    DeferredDisplayState* state = createState();

    renderer.storeDisplayState(*state, getStateOpDeferFlags());

    mBatches.add(new StateOpBatch(op, state));

    resetBatchingState();

}
@@ -604,8 +624,9 @@ void DeferredDisplayList::storeRestoreToCountBarrier(OpenGLRenderer& renderer, S 


    // store displayState for the restore operation, as it may be associated with a saveLayer that

    // doesn't have kClip_SaveFlag set

    renderer.storeDisplayState(op->state, getStateOpDeferFlags());

    mBatches.add(new RestoreToCountBatch(op, newSaveCount));

    DeferredDisplayState* state = createState();

    renderer.storeDisplayState(*state, getStateOpDeferFlags());

    mBatches.add(new RestoreToCountBatch(op, state, newSaveCount));

    resetBatchingState();

}

libs/hwui/DeferredDisplayList.h

+47 −1
Original line number Diff line number Diff line
@@ -18,11 +18,13 @@ 
#define ANDROID_HWUI_DEFERRED_DISPLAY_LIST_H



#include <utils/Errors.h>

#include <utils/LinearAllocator.h>

#include <utils/Vector.h>

#include <utils/TinyHashMap.h>



#include "Matrix.h"

#include "OpenGLRenderer.h"

#include "Rect.h"

#include "utils/TinyHashMap.h"



class SkBitmap;
@@ -34,6 +36,8 @@ class DrawOp; 
class SaveOp;

class SaveLayerOp;

class StateOp;



class DeferredDisplayState;

class OpenGLRenderer;



class Batch;
@@ -42,6 +46,38 @@ class MergingDrawBatch; 


typedef const void* mergeid_t;



class DeferredDisplayState {

public:

    /** static void* operator new(size_t size); PURPOSELY OMITTED **/

    static void* operator new(size_t size, LinearAllocator& allocator) {

        return allocator.alloc(size);

    }



    // global op bounds, mapped by mMatrix to be in screen space coordinates, clipped

    Rect mBounds;



    // the below are set and used by the OpenGLRenderer at record and deferred playback

    bool mClipValid;

    Rect mClip;

    int mClipSideFlags; // specifies which sides of the bounds are clipped, unclipped if cleared

    bool mClipped;

    mat4 mMatrix;

    DrawModifiers mDrawModifiers;

    float mAlpha;

};



class OpStatePair {

public:

    OpStatePair()

            : op(NULL), state(NULL) {}

    OpStatePair(DrawOp* newOp, const DeferredDisplayState* newState)

            : op(newOp), state(newState) {}

    OpStatePair(const OpStatePair& other)

            : op(other.op), state(other.state) {}

    DrawOp* op;

    const DeferredDisplayState* state;

};



class DeferredDisplayList {

public:

    DeferredDisplayList(const Rect& bounds, bool avoidOverdraw = true) :
@@ -84,6 +120,14 @@ public: 
    void addDrawOp(OpenGLRenderer& renderer, DrawOp* op);



private:

    DeferredDisplayState* createState() {

        return new (mAllocator) DeferredDisplayState();

    }



    void tryRecycleState(DeferredDisplayState* state) {

        mAllocator.rewindIfLastAlloc(state, sizeof(DeferredDisplayState));

    }



    /**

     * Resets the batching back-pointers, creating a barrier in the operation stream so that no ops

     * added in the future will be inserted into a batch that already exist.
@@ -131,6 +175,8 @@ private: 
     * collide, which avoids the need to resolve mergeid collisions.

     */

    TinyHashMap<mergeid_t, DrawBatch*> mMergingBatches[kOpBatch_Count];



    LinearAllocator mAllocator;

};



/**

libs/hwui/DisplayList.h

+1 −3
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 


#include <private/hwui/DrawGlInfo.h>



#include <utils/LinearAllocator.h>

#include <utils/RefBase.h>

#include <utils/SortedVector.h>

#include <utils/String8.h>
@@ -35,8 +36,6 @@ 


#include <androidfw/ResourceTypes.h>



#include "utils/LinearAllocator.h"



#include "Debug.h"



#define TRANSLATION 0x0001
@@ -114,7 +113,6 @@ public: 


    void initFromDisplayListRenderer(const DisplayListRenderer& recorder, bool reusing = false);





    void defer(DeferStateStruct& deferStruct, const int level);

    void replay(ReplayStateStruct& replayStruct, const int level);

libs/hwui/DisplayListOp.h

+67 −62

File changed.

Preview size limit exceeded, changes collapsed.

libs/hwui/DisplayListRenderer.cpp

+2 −7
Original line number Diff line number Diff line
@@ -505,17 +505,12 @@ void DisplayListRenderer::addStateOp(StateOp* op) { 


void DisplayListRenderer::addDrawOp(DrawOp* op) {

    Rect localBounds;

    if (mDrawModifiers.mHasShadow) {

        op->state.mDrawModifiers = mDrawModifiers;

    }

    if (op->getLocalBounds(localBounds)) {

    if (op->getLocalBounds(mDrawModifiers, localBounds)) {

        bool rejected = quickRejectNoScissor(localBounds.left, localBounds.top,

                localBounds.right, localBounds.bottom);

        op->setQuickRejected(rejected);

    }

    if (mDrawModifiers.mHasShadow) {

        op->state.mDrawModifiers.reset();

    }



    mHasDrawOps = true;

    addOpInternal(op);

}