Optimize CSS box-shadow performance by caching the SkMask of the blur effect.

src/effects/SkBlurMaskFilter.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
+#include <list>
+
 #include "SkBlurMaskFilter.h"
 #include "SkBlurMask.h"
 #include "SkGpuBlurUtils.h"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkMaskFilter.h"
 #include "SkRRect.h"
 #include "SkRTConf.h"
 #include "SkStringUtils.h"
 #include "SkStrokeRec.h"
@@ skipping 39 matching lines @@
     virtual bool filterMaskGPU(GrTexture* src,
                                const SkMatrix& ctm,
                                const SkRect& maskRect,
                                GrTexture** result,
                                bool canOverwriteSrc) const SK_OVERRIDE;
 #endif
 
     virtual void computeFastBounds(const SkRect&, SkRect*) const SK_OVERRIDE;
     virtual bool asABlur(BlurRec*) const SK_OVERRIDE;
 
+    class BlurMaskRecord {
+    public:
+        BlurMaskRecord(): fSigma(0),
+                          fRectCount(0),
+                          fRects(NULL),
+                          fMask(NULL) {}
+
+        BlurMaskRecord(SkScalar sigma, unsigned rectCount, SkRect** rects, SkMask* mask)
+            : fSigma(sigma),
+              fRectCount(rectCount),
+              fRects(rects),
+              fMask(mask) {}
+
+        ~BlurMaskRecord() {
+            if (fMask) {
+                if (fMask->fImage)
+                    SkMask::FreeImage(fMask->fImage);
+                delete fMask;
+            }
+            if (fRects) {
+                for(int i = 0; i < fRectCount; i++) {
+                    if (fRects[i])
+                        delete fRects[i];
+                }
+                delete []fRects;
+            }
+        }
+
+        SkScalar fSigma;
+        unsigned fRectCount;
+        SkRect** fRects;
+        SkMask* fMask;
+    };
+
+    static bool getBlurMaskRecord(SkScalar sigma,
+                                  unsigned rectCount,
+                                  const SkRect rects[],
+                                  SkMask** mask);
+    static bool addBlurMaskRecord(BlurMaskRecord* blurMaskRecord);
+    static void clearBlurMaskRecordList();
+    static unsigned getBlurMaskRecordsMemoryUsage() { return fCachedBlurMaskImageMemorySize; }
+    static void setBlurMaskRecordsLimit(unsigned, unsigned);
+
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkBlurMaskFilterImpl)
 
 protected:
     virtual FilterReturn filterRectsToNine(const SkRect[], int count, const SkMatrix&,
                                            const SkIRect& clipBounds,
                                            NinePatch*) const SK_OVERRIDE;
 
     virtual FilterReturn filterRRectToNine(const SkRRect&, const SkMatrix&,
                                            const SkIRect& clipBounds,
@@ skipping 22 matching lines @@
     SkBlurMaskFilterImpl(SkReadBuffer&);
     virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
 
     SkScalar computeXformedSigma(const SkMatrix& ctm) const {
         bool ignoreTransform = SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag);
 
         SkScalar xformedSigma = ignoreTransform ? fSigma : ctm.mapRadius(fSigma);
         return SkMinScalar(xformedSigma, kMAX_BLUR_SIGMA);
     }
 
+    typedef std::list<BlurMaskRecord*> BlurMaskRecordList;
+    static BlurMaskRecordList fCachedBlurMaskRecordList;
+    static unsigned fCachedBlurMaskImageMemorySize;
+    static unsigned fMaxBlurMaskListSize;
+    static unsigned fMaxImageMemorySize;
+
     typedef SkMaskFilter INHERITED;
 };
 
 const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_SIGMA = SkIntToScalar(128);
 
+SkBlurMaskFilterImpl::BlurMaskRecordList SkBlurMaskFilterImpl::fCachedBlurMaskRecordList;

[reveman, 2014/05/16 18:49:16]

I'm failing to see how the use of this is thread safe. Does it need to be
protected by a mutex?

[junj, 2014/05/19 12:54:49]

Yes, I should add a mutex to make it thread-safe. Will make the change in
updated CL. 

+unsigned SkBlurMaskFilterImpl::fCachedBlurMaskImageMemorySize = 0;
+unsigned SkBlurMaskFilterImpl::fMaxBlurMaskListSize = 50;
+unsigned SkBlurMaskFilterImpl::fMaxImageMemorySize = 2 * 1024 * 1024;

[reveman, 2014/05/16 18:49:16]

Please allow SkDiscardableMemory to be used instead. Something similar to
SkScaledImageCache as we don't want another cache that adds to chromium's total
amount of memory.

[junj, 2014/05/19 12:54:49]

I have had a look at the interface of SkScaledImageCache and it should be
feasible to adopt similar changes.

One issue is that, I found SkDiscardableMemory is not enabled for Image decoder
case for Android platform. Will SkDiscardableMemory be enabled and used for all
platforms ? Need to hear more opinions on this.

[reveman, 2014/05/19 14:09:37]

Yes, I'm hoping to enable it this week and remove all the old non-discardable
memory cache code.

+
+bool SkBlurMaskFilterImpl::getBlurMaskRecord(SkScalar sigma,
+    unsigned rectCount,
+    const SkRect rects[],
+    SkMask** mask) {
+    if (!fCachedBlurMaskRecordList.empty()) {
+        for (BlurMaskRecordList::reverse_iterator it = fCachedBlurMaskRecordList.rbegin();
+            it != fCachedBlurMaskRecordList.rend(); ++it) {
+            BlurMaskRecord* cachedBlurMaskRecord = *it;
+            if (cachedBlurMaskRecord->fSigma == sigma
+                && cachedBlurMaskRecord->fRectCount == rectCount) {
+                bool found = true;
+                SkRect* tempRects[2] = {NULL, NULL};
+                for (int i = 0; i < rectCount; i++) {
+                    tempRects[i] = *(cachedBlurMaskRecord->fRects + i);
+                    if (tempRects[i]->width() != rects[i].width() ||
+                        tempRects[i]->height() != rects[i].height()) {
+                        found = false;
+                        break;
+                    }
+                }
+                if (found && rectCount == 2) {
+                    if ((tempRects[0]->x() - rects[0].x()) != (tempRects[1]->x() - rects[1].x()) ||
+                        (tempRects[0]->y() - rects[0].y()) != (tempRects[1]->y() - rects[1].y()))
+                        found = false;
+                }
+                if (found) {
+                    *mask = cachedBlurMaskRecord->fMask;
+                     return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+bool SkBlurMaskFilterImpl::addBlurMaskRecord(BlurMaskRecord* blurMaskRecord) {
+    while (fCachedBlurMaskRecordList.size() >= fMaxBlurMaskListSize
+           || fCachedBlurMaskImageMemorySize >= fMaxImageMemorySize) {
+        BlurMaskRecord* cachedBlurMaskRecord = fCachedBlurMaskRecordList.front();
+        fCachedBlurMaskRecordList.pop_front();
+        if (cachedBlurMaskRecord) {
+            fCachedBlurMaskImageMemorySize -= cachedBlurMaskRecord->fMask->computeImageSize();
+            delete cachedBlurMaskRecord;
+            cachedBlurMaskRecord = NULL;
+        }
+    }
+    fCachedBlurMaskRecordList.push_back(blurMaskRecord);
+    fCachedBlurMaskImageMemorySize += blurMaskRecord->fMask->computeImageSize();
+    return true;
+}
+
+void SkBlurMaskFilterImpl::clearBlurMaskRecordList() {
+    while (!fCachedBlurMaskRecordList.empty()) {
+        BlurMaskRecord* cachedBlurMaskRecord = fCachedBlurMaskRecordList.front();
+        fCachedBlurMaskRecordList.pop_front();
+        if (cachedBlurMaskRecord) {
+            delete cachedBlurMaskRecord;
+            cachedBlurMaskRecord = NULL;
+        }
+    }
+    fCachedBlurMaskImageMemorySize = 0;
+}
+
+void SkBlurMaskFilterImpl::setBlurMaskRecordsLimit(unsigned listSize, unsigned memSize) {
+    fMaxBlurMaskListSize = listSize;
+    fMaxImageMemorySize = memSize;
+}
+
 SkMaskFilter* SkBlurMaskFilter::Create(SkBlurStyle style, SkScalar sigma, uint32_t flags) {
     if (!SkScalarIsFinite(sigma) || sigma <= 0) {
         return NULL;
     }
     if ((unsigned)style > (unsigned)kLastEnum_SkBlurStyle) {
         return NULL;
     }
     if (flags > SkBlurMaskFilter::kAll_BlurFlag) {
         return NULL;
     }
@@ skipping 248 matching lines @@
     SkRect smallR = SkRect::MakeWH(totalSmallWidth, totalSmallHeight);
 
     SkRRect smallRR;
     SkVector radii[4];
     radii[SkRRect::kUpperLeft_Corner] = UL;
     radii[SkRRect::kUpperRight_Corner] = UR;
     radii[SkRRect::kLowerRight_Corner] = LR;
     radii[SkRRect::kLowerLeft_Corner] = LL;
     smallRR.setRectRadii(smallR, radii);
 
+    SkScalar sigma = this->computeXformedSigma(matrix);
+    SkMask* cachedBlurMask = NULL;
+    SkRect rects[1];
+    rects[0] = rrect.rect();
+    if (getBlurMaskRecord(sigma, 1, rects, &cachedBlurMask)) {
+        patch->fMask = *cachedBlurMask;
+        patch->fOuterRect = dstM.fBounds;
+        patch->fCenter.fX = SkScalarCeilToInt(leftUnstretched) + 1;
+        patch->fCenter.fY = SkScalarCeilToInt(topUnstretched) + 1;
+        return kTrue_FilterReturn;
+    }
+
     bool analyticBlurWorked = false;
     if (c_analyticBlurRRect) {
         analyticBlurWorked =
             this->filterRRectMask(&patch->fMask, smallRR, matrix, &margin,
                                   SkMask::kComputeBoundsAndRenderImage_CreateMode);
     }
 
     if (!analyticBlurWorked) {
         if (!draw_rrect_into_mask(smallRR, &srcM)) {
             return kFalse_FilterReturn;
         }
 
         SkAutoMaskFreeImage amf(srcM.fImage);
 
         if (!this->filterMask(&patch->fMask, srcM, matrix, &margin)) {
             return kFalse_FilterReturn;
         }
     }
 
     patch->fMask.fBounds.offsetTo(0, 0);
     patch->fOuterRect = dstM.fBounds;
     patch->fCenter.fX = SkScalarCeilToInt(leftUnstretched) + 1;
     patch->fCenter.fY = SkScalarCeilToInt(topUnstretched) + 1;
+    if (!cachedBlurMask) {
+        SkMask* tempMask = new SkMask;
+        *tempMask = patch->fMask;
+        SkRect** tempRects = new SkRect* [1];
+        tempRects[0] = new SkRect;
+        *(tempRects[0]) = rrect.rect();
+        BlurMaskRecord * blurMaskRecord = new BlurMaskRecord(sigma, 1, tempRects, tempMask);
+        if (blurMaskRecord)
+            addBlurMaskRecord(blurMaskRecord);
+    }
+
     return kTrue_FilterReturn;
 }
 
 SK_CONF_DECLARE( bool, c_analyticBlurNinepatch, "mask.filter.analyticNinePatch", true, "Use the faster analytic blur approach for ninepatch rects" );
 
 SkMaskFilter::FilterReturn
 SkBlurMaskFilterImpl::filterRectsToNine(const SkRect rects[], int count,
                                         const SkMatrix& matrix,
                                         const SkIRect& clipBounds,
                                         NinePatch* patch) const {
@@ skipping 59 matching lines @@
     if (1 == count) {
         innerIR = srcM.fBounds;
         center.set(smallW, smallH);
     } else {
         SkASSERT(2 == count);
         rects[1].roundIn(&innerIR);
         center.set(smallW + (innerIR.left() - srcM.fBounds.left()),
                    smallH + (innerIR.top() - srcM.fBounds.top()));
     }
 
+    SkScalar sigma = this->computeXformedSigma(matrix);
+    SkMask* cachedBlurMask = NULL;
+    if (getBlurMaskRecord(sigma, count, rects, &cachedBlurMask)) {
+        patch->fMask = *cachedBlurMask;
+        patch->fOuterRect = dstM.fBounds;
+        patch->fCenter = center;
+        return kTrue_FilterReturn;
+    }
+
     // +1 so we get a clean, stretchable, center row/col
     smallW += 1;
     smallH += 1;
 
     // we want the inset amounts to be integral, so we don't change any
     // fractional phase on the fRight or fBottom of our smallR.
     const SkScalar dx = SkIntToScalar(innerIR.width() - smallW);
     const SkScalar dy = SkIntToScalar(innerIR.height() - smallH);
     if (dx < 0 || dy < 0) {
         // we're too small, relative to our blur, to break into nine-patch,
         // so we ask to have our normal filterMask() be called.
         return kUnimplemented_FilterReturn;
     }
 
     smallR[0].set(rects[0].left(), rects[0].top(), rects[0].right() - dx, rects[0].bottom() - dy);
     if (smallR[0].width() < 2 || smallR[0].height() < 2) {
         return kUnimplemented_FilterReturn;
     }
     if (2 == count) {
         smallR[1].set(rects[1].left(), rects[1].top(),
                       rects[1].right() - dx, rects[1].bottom() - dy);
         SkASSERT(!smallR[1].isEmpty());
     }
 
     if (count > 1 || !c_analyticBlurNinepatch) {
         if (!draw_rects_into_mask(smallR, count, &srcM)) {
             return kFalse_FilterReturn;
         }
-
         SkAutoMaskFreeImage amf(srcM.fImage);
 
         if (!this->filterMask(&patch->fMask, srcM, matrix, &margin)) {
             return kFalse_FilterReturn;
         }
     } else {
         if (!this->filterRectMask(&patch->fMask, smallR[0], matrix, &margin,
                                   SkMask::kComputeBoundsAndRenderImage_CreateMode)) {
             return kFalse_FilterReturn;
         }
     }
     patch->fMask.fBounds.offsetTo(0, 0);
     patch->fOuterRect = dstM.fBounds;
     patch->fCenter = center;
+
+    if (!cachedBlurMask) {
+        SkMask* tempMask = new SkMask;
+        *tempMask = patch->fMask;
+        SkRect** tempRects = new SkRect* [count];
+        for (int i = 0; i < count; i++) {
+            tempRects[i] = new SkRect;
+            *(tempRects[i]) = rects[i];
+        }
+        BlurMaskRecord * blurMaskRecord = new BlurMaskRecord(sigma, count, tempRects, tempMask);
+        if (blurMaskRecord)
+            addBlurMaskRecord(blurMaskRecord);
+    }
+
     return kTrue_FilterReturn;
 }
 
 void SkBlurMaskFilterImpl::computeFastBounds(const SkRect& src,
                                              SkRect* dst) const {
     SkScalar pad = 3.0f * fSigma;
 
     dst->set(src.fLeft  - pad, src.fTop    - pad,
              src.fRight + pad, src.fBottom + pad);
 }
@@ skipping 687 matching lines @@
     } else {
         str->append("None");
     }
     str->append("))");
 }
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkBlurMaskFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurMaskFilterImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END