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

Commit d98aa2de authored by Chet Haase's avatar Chet Haase
Browse files

DisplayList optimizations and fixes. 

We now use a copy of SkPaint objects to avoid having it changed from under us.
We reuse copies that have not changed. We also copy the SkMatrix every time to
avoid the same problem.

Change-Id: If3fd80698f2d43ea16d23302063e0fd8d0549027
parent 9bb12786

core/jni/android/graphics/Matrix.cpp

+0 −6
Original line number Diff line number Diff line
@@ -32,12 +32,6 @@ class SkMatrixGlue { 
public:



    static void finalizer(JNIEnv* env, jobject clazz, SkMatrix* obj) {

#ifdef USE_OPENGL_RENDERER

        if (android::uirenderer::Caches::hasInstance()) {

            android::uirenderer::Caches::getInstance().resourceCache.destructor(obj);

            return;

        }

#endif // USE_OPENGL_RENDERER

        delete obj;

    }

core/jni/android/graphics/Paint.cpp

+0 −6
Original line number Diff line number Diff line
@@ -63,12 +63,6 @@ public: 
    };



    static void finalizer(JNIEnv* env, jobject clazz, SkPaint* obj) {

#ifdef USE_OPENGL_RENDERER

        if (android::uirenderer::Caches::hasInstance()) {

            android::uirenderer::Caches::getInstance().resourceCache.destructor(obj);

            return;

        }

#endif // USE_OPENGL_RENDERER

        delete obj;

    }

libs/hwui/DisplayListRenderer.cpp

+30 −36
Original line number Diff line number Diff line
@@ -108,18 +108,7 @@ DisplayList::DisplayList(const DisplayListRenderer& recorder) { 
        mBitmapResources.add(resource);

        caches.resourceCache.incrementRefcount(resource);

    }

    const Vector<SkMatrix*> &matrixResources = recorder.getMatrixResources();

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

        SkMatrix* resource = matrixResources.itemAt(i);

        mMatrixResources.add(resource);

        caches.resourceCache.incrementRefcount(resource);

    }

    const Vector<SkPaint*> &paintResources = recorder.getPaintResources();

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

        SkPaint* resource = paintResources.itemAt(i);

        mPaintResources.add(resource);

        caches.resourceCache.incrementRefcount(resource);

    }



    const Vector<SkiaShader*> &shaderResources = recorder.getShaderResources();

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

        SkiaShader* resource = shaderResources.itemAt(i);
@@ -127,6 +116,16 @@ DisplayList::DisplayList(const DisplayListRenderer& recorder) { 
        caches.resourceCache.incrementRefcount(resource);

    }



    const Vector<SkPaint*> &paints = recorder.getPaints();

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

        mPaints.add(paints.itemAt(i));

    }



    const Vector<SkMatrix*> &matrices = recorder.getMatrices();

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

        mMatrices.add(matrices.itemAt(i));

    }



    mPathHeap = recorder.mPathHeap;

    mPathHeap->safeRef();

}
@@ -137,25 +136,25 @@ DisplayList::~DisplayList() { 
    Caches& caches = Caches::getInstance();



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

        SkBitmap* resource = mBitmapResources.itemAt(i);

        caches.resourceCache.decrementRefcount(resource);

        caches.resourceCache.decrementRefcount(mBitmapResources.itemAt(i));

    }

    mBitmapResources.clear();

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

        SkMatrix* resource = mMatrixResources.itemAt(i);

        caches.resourceCache.decrementRefcount(resource);

    }

    mMatrixResources.clear();

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

        SkPaint* resource = mPaintResources.itemAt(i);

        caches.resourceCache.decrementRefcount(resource);

    }

    mPaintResources.clear();



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

        SkiaShader* resource = mShaderResources.itemAt(i);

        caches.resourceCache.decrementRefcount(resource);

        caches.resourceCache.decrementRefcount(mShaderResources.itemAt(i));

    }

    mShaderResources.clear();



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

        delete mPaints.itemAt(i);

    }

    mPaints.clear();



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

        delete  mMatrices.itemAt(i);

    }

    mMatrices.clear();



    mPathHeap->safeUnref();

}
@@ -335,21 +334,16 @@ void DisplayListRenderer::reset() { 
        caches.resourceCache.decrementRefcount(resource);

    }

    mBitmapResources.clear();

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

        SkMatrix* resource = mMatrixResources.itemAt(i);

        caches.resourceCache.decrementRefcount(resource);

    }

    mMatrixResources.clear();

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

        SkPaint* resource = mPaintResources.itemAt(i);

        caches.resourceCache.decrementRefcount(resource);

    }

    mPaintResources.clear();



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

        SkiaShader* resource = mShaderResources.itemAt(i);

        caches.resourceCache.decrementRefcount(resource);

    }

    mShaderResources.clear();



    mPaints.clear();

    mPaintMap.clear();

    mMatrices.clear();

}



///////////////////////////////////////////////////////////////////////////////

libs/hwui/DisplayListRenderer.h

+31 −18
Original line number Diff line number Diff line
@@ -182,10 +182,11 @@ private: 
    PathHeap* mPathHeap;



    Vector<SkBitmap*> mBitmapResources;

    Vector<SkMatrix*> mMatrixResources;

    Vector<SkPaint*> mPaintResources;

    Vector<SkiaShader*> mShaderResources;



    Vector<SkPaint*> mPaints;

    Vector<SkMatrix*> mMatrices;



    mutable SkFlattenableReadBuffer mReader;



    SkRefCntPlayback mRCPlayback;
@@ -263,16 +264,16 @@ public: 
        return mBitmapResources;

    }



    const Vector<SkMatrix*>& getMatrixResources() const {

        return mMatrixResources;

    const Vector<SkiaShader*>& getShaderResources() const {

        return mShaderResources;

    }



    const Vector<SkPaint*>& getPaintResources() const {

        return mPaintResources;

    const Vector<SkPaint*>& getPaints() const {

        return mPaints;

    }



    const Vector<SkiaShader*>& getShaderResources() const {

        return mShaderResources;

    const Vector<SkMatrix*>& getMatrices() const {

        return mMatrices;

    }



private:
@@ -334,20 +335,30 @@ private: 
    }



    inline void addPaint(SkPaint* paint) {

        addInt((int)paint);

        mPaintResources.add(paint);

        Caches& caches = Caches::getInstance();

        caches.resourceCache.incrementRefcount(paint);

        if (paint == NULL) {

            addInt((int)NULL);

            return;

        }

        SkPaint *paintCopy =  mPaintMap.valueFor(paint);

        if (paintCopy == NULL || paintCopy->getGenerationID() != paint->getGenerationID()) {

            paintCopy = new SkPaint(*paint);

            mPaintMap.add(paint, paintCopy);

            mPaints.add(paintCopy);

        }

        addInt((int)paintCopy);

    }



    inline void addMatrix(SkMatrix* matrix) {

        addInt((int)matrix);

        mMatrixResources.add(matrix);

        Caches& caches = Caches::getInstance();

        caches.resourceCache.incrementRefcount(matrix);

        // Copying the matrix is cheap and prevents against the user changing the original

        // matrix before the operation that uses it

        addInt((int) new SkMatrix(*matrix));

    }



    inline void addBitmap(SkBitmap* bitmap) {

        // Note that this assumes the bitmap is immutable. There are cases this won't handle

        // correctly, such as creating the bitmap from scratch, drawing with it, changing its

        // contents, and drawing again. The only fix would be to always copy it the first time,

        // which doesn't seem worth the extra cycles for this unlikely case.

        addInt((int)bitmap);

        mBitmapResources.add(bitmap);

        Caches& caches = Caches::getInstance();
@@ -364,10 +375,12 @@ private: 
    SkChunkAlloc mHeap;



    Vector<SkBitmap*> mBitmapResources;

    Vector<SkMatrix*> mMatrixResources;

    Vector<SkPaint*> mPaintResources;

    Vector<SkiaShader*> mShaderResources;



    Vector<SkPaint*> mPaints;

    DefaultKeyedVector<SkPaint *, SkPaint *> mPaintMap;

    Vector<SkMatrix*> mMatrices;



    PathHeap* mPathHeap;

    SkWriter32 mWriter;

libs/hwui/ResourceCache.cpp

+0 −42
Original line number Diff line number Diff line
@@ -62,14 +62,6 @@ void ResourceCache::incrementRefcount(SkBitmap* bitmapResource) { 
    incrementRefcount((void*)bitmapResource, kBitmap);

}



void ResourceCache::incrementRefcount(SkMatrix* matrixResource) {

    incrementRefcount((void*)matrixResource, kMatrix);

}



void ResourceCache::incrementRefcount(SkPaint* paintResource) {

    incrementRefcount((void*)paintResource, kPaint);

}



void ResourceCache::incrementRefcount(SkiaShader* shaderResource) {

    shaderResource->getSkShader()->safeRef();

    incrementRefcount((void*)shaderResource, kShader);
@@ -136,34 +128,6 @@ void ResourceCache::destructor(SkBitmap* resource) { 
    }

}



void ResourceCache::destructor(SkMatrix* resource) {

    ResourceReference* ref = mCache->indexOfKey(resource) >= 0 ? mCache->valueFor(resource) : NULL;

    if (ref == NULL) {

        // If we're not tracking this resource, just delete it

        delete resource;

        return;

    }

    ref->destroyed = true;

    if (ref->refCount == 0) {

        deleteResourceReference(resource, ref);

        return;

    }

}



void ResourceCache::destructor(SkPaint* resource) {

    ResourceReference* ref = mCache->indexOfKey(resource) >= 0 ? mCache->valueFor(resource) : NULL;

    if (ref == NULL) {

        // If we're not tracking this resource, just delete it

        delete resource;

        return;

    }

    ref->destroyed = true;

    if (ref->refCount == 0) {

        deleteResourceReference(resource, ref);

        return;

    }

}



void ResourceCache::destructor(SkiaShader* resource) {

    ResourceReference* ref = mCache->indexOfKey(resource) >= 0 ? mCache->valueFor(resource) : NULL;

    if (ref == NULL) {
@@ -196,12 +160,6 @@ void ResourceCache::deleteResourceReference(void* resource, ResourceReference* r 
                delete bitmap;

            }

            break;

            case kMatrix:

                delete (SkMatrix*) resource;

                break;

            case kPaint:

                delete (SkPaint*) resource;

                break;

            case kShader:

                SkiaShader* shader = (SkiaShader*)resource;

                if (Caches::hasInstance()) {