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

Commit 0e89e2b7 authored by John Reck's avatar John Reck
Browse files

Layer changes 

Bug: 17208461

* Switch Layer to be VirtualLightRefBase instead of
  Caches' side-channel ref-counting
* Include active layers in gfxinfo dump
* Run gfxinfo dump on the correct thread
* Dump gfxinfo on Layer creation failure

Change-Id: I28d195699e2334518e215ab28c7a17355aee9678
parent 141823ec

core/jni/android_view_GLES20Canvas.cpp

+2 −1
Original line number Diff line number Diff line
@@ -43,6 +43,7 @@ 
#include <RenderNode.h>

#include <CanvasProperty.h>

#include <Paint.h>

#include <renderthread/RenderProxy.h>



#include "MinikinUtils.h"
@@ -861,7 +862,7 @@ static void 
android_app_ActivityThread_dumpGraphics(JNIEnv* env, jobject clazz, jobject javaFileDescriptor) {

#ifdef USE_OPENGL_RENDERER

    int fd = jniGetFDFromFileDescriptor(env, javaFileDescriptor);

    android::uirenderer::RenderNode::outputLogBuffer(fd);

    android::uirenderer::renderthread::RenderProxy::outputLogBuffer(fd);

#endif // USE_OPENGL_RENDERER

}

libs/hwui/Caches.cpp

+16 −26
Original line number Diff line number Diff line
@@ -265,14 +265,27 @@ void Caches::dumpMemoryUsage() { 
}



void Caches::dumpMemoryUsage(String8 &log) {

    uint32_t total = 0;

    log.appendFormat("Current memory usage / total memory usage (bytes):\n");

    log.appendFormat("  TextureCache         %8d / %8d\n",

            textureCache.getSize(), textureCache.getMaxSize());

    log.appendFormat("  LayerCache           %8d / %8d (numLayers = %zu)\n",

            layerCache.getSize(), layerCache.getMaxSize(), layerCache.getCount());

    log.appendFormat("  Garbage layers       %8zu\n", mLayerGarbage.size());

    log.appendFormat("  Active layers        %8zu\n",

            mRenderState ? mRenderState->mActiveLayers.size() : 0);

    if (mRenderState) {

        int memused = 0;

        for (std::set<const Layer*>::iterator it = mRenderState->mActiveLayers.begin();

                it != mRenderState->mActiveLayers.end(); it++) {

            const Layer* layer = *it;

            log.appendFormat("    Layer size %dx%d; isTextureLayer()=%d; texid=%u fbo=%u; refs=%d\n",

                    layer->getWidth(), layer->getHeight(),

                    layer->isTextureLayer(), layer->getTexture(),

                    layer->getFbo(), layer->getStrongCount());

            memused = layer->getWidth() * layer->getHeight() * 4;

        }

        log.appendFormat("  Layers total   %8d (numLayers = %zu)\n",

                memused, mRenderState->mActiveLayers.size());

        total += memused;

    }

    log.appendFormat("  RenderBufferCache    %8d / %8d\n",

            renderBufferCache.getSize(), renderBufferCache.getMaxSize());

    log.appendFormat("  GradientCache        %8d / %8d\n",
@@ -297,9 +310,7 @@ void Caches::dumpMemoryUsage(String8 &log) { 
    log.appendFormat("  FboCache             %8d / %8d\n",

            fboCache.getSize(), fboCache.getMaxSize());



    uint32_t total = 0;

    total += textureCache.getSize();

    total += layerCache.getSize();

    total += renderBufferCache.getSize();

    total += gradientCache.getSize();

    total += pathCache.getSize();
@@ -323,27 +334,6 @@ void Caches::clearGarbage() { 
    textureCache.clearGarbage();

    pathCache.clearGarbage();

    patchCache.clearGarbage();



    Vector<Layer*> layers;



    { // scope for the lock

        Mutex::Autolock _l(mGarbageLock);

        layers = mLayerGarbage;

        mLayerGarbage.clear();

    }



    size_t count = layers.size();

    for (size_t i = 0; i < count; i++) {

        Layer* layer = layers.itemAt(i);

        delete layer;

    }

    layers.clear();

}



void Caches::deleteLayerDeferred(Layer* layer) {

    Mutex::Autolock _l(mGarbageLock);

    layer->state = Layer::kState_InGarbageList;

    mLayerGarbage.push(layer);

}



void Caches::flush(FlushMode mode) {

libs/hwui/DeferredLayerUpdater.cpp

+1 −20
Original line number Diff line number Diff line
@@ -24,25 +24,6 @@ 
namespace android {

namespace uirenderer {



class DeleteLayerTask : public renderthread::RenderTask {

public:

    DeleteLayerTask(renderthread::EglManager& eglManager, Layer* layer)

        : mEglManager(eglManager)

        , mLayer(layer)

    {}



    virtual void run() {

        mEglManager.requireGlContext();

        LayerRenderer::destroyLayer(mLayer);

        mLayer = 0;

        delete this;

    }



private:

    renderthread::EglManager& mEglManager;

    Layer* mLayer;

};



DeferredLayerUpdater::DeferredLayerUpdater(renderthread::RenderThread& thread, Layer* layer)

        : mSurfaceTexture(0)

        , mTransform(0)
@@ -62,7 +43,7 @@ DeferredLayerUpdater::DeferredLayerUpdater(renderthread::RenderThread& thread, L 
DeferredLayerUpdater::~DeferredLayerUpdater() {

    SkSafeUnref(mColorFilter);

    setTransform(0);

    mRenderThread.queue(new DeleteLayerTask(mRenderThread.eglManager(), mLayer));

    mLayer->postDecStrong();

    mLayer = 0;

}

libs/hwui/DisplayList.cpp

+0 −5
Original line number Diff line number Diff line
@@ -61,10 +61,6 @@ void DisplayListData::cleanupResources() { 
        caches.resourceCache.decrementRefcountLocked(sourcePaths.itemAt(i));

    }



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

        caches.resourceCache.decrementRefcountLocked(layers.itemAt(i));

    }



    caches.resourceCache.unlock();



    for (size_t i = 0; i < paints.size(); i++) {
@@ -86,7 +82,6 @@ void DisplayListData::cleanupResources() { 
    paints.clear();

    regions.clear();

    paths.clear();

    layers.clear();

}



size_t DisplayListData::addChild(DrawRenderNodeOp* op) {

libs/hwui/DisplayList.h

+1 −6
Original line number Diff line number Diff line
@@ -147,7 +147,6 @@ public: 
    Vector<const SkPath*> paths;

    SortedVector<const SkPath*> sourcePaths;

    Vector<const SkRegion*> regions;

    Vector<Layer*> layers;

    Vector<Functor*> functors;



    const Vector<Chunk>& getChunks() const {
@@ -157,11 +156,7 @@ public: 
    size_t addChild(DrawRenderNodeOp* childOp);

    const Vector<DrawRenderNodeOp*>& children() { return mChildren; }



    void refProperty(CanvasPropertyPrimitive* prop) {

        mReferenceHolders.push(prop);

    }



    void refProperty(CanvasPropertyPaint* prop) {

    void ref(VirtualLightRefBase* prop) {

        mReferenceHolders.push(prop);

    }