Add CTM to the cached layers' key and reduce render target pingponging in layer pre-rendering

src/gpu/GrLayerCache.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrLayerCache_DEFINED
 #define GrLayerCache_DEFINED
 
@@ skipping 26 matching lines @@
 
     GrAtlas::ClientPlotUsage  fPlotUsage;
 };
 
 // GrCachedLayer encapsulates the caching information for a single saveLayer.
 //
 // Atlased layers get a ref to the backing GrTexture while non-atlased layers
 // get a ref to the GrTexture in which they reside. In both cases 'fRect' 
 // contains the layer's extent in its texture.
 // Atlased layers also get a pointer to the plot in which they reside.
-// For non-atlased layers the lock field just corresponds to locking in
-// the resource cache. For atlased layers it implements an additional level
+// For non-atlased layers, the lock field just corresponds to locking in
+// the resource cache. For atlased layers, it implements an additional level
 // of locking to allow atlased layers to be reused multiple times.
 struct GrCachedLayer {
 public:
     // For SkTDynamicHash
     struct Key {
-        Key(uint32_t pictureID, int layerID) : fPictureID(pictureID) , fLayerID(layerID) {}
+        Key(uint32_t pictureID, int start, int stop, const SkMatrix& ctm) 
+        : fPictureID(pictureID)
+        , fStart(start)
+        , fStop(stop)
+        , fCTM(ctm) {
+        }
 
         bool operator==(const Key& other) const {
-            return fPictureID == other.fPictureID && fLayerID == other.fLayerID;
+            return fPictureID == other.fPictureID &&
+                   fStart == other.fStart &&
+                   fStop == other.fStop &&
+                   fCTM.cheapEqualTo(other.fCTM);
         }
 
-        uint32_t getPictureID() const { return fPictureID; }
-        int      getLayerID() const { return fLayerID; }
+        uint32_t pictureID() const { return fPictureID; }
+        int start() const { return fStart; }
+        int stop() const { return fStop; }
+        const SkMatrix& ctm() const { return fCTM; }
 
     private:
         // ID of the picture of which this layer is a part
         const uint32_t fPictureID;
-        // fLayerID is the index of this layer in the picture (one of 0 .. #layers).
-        const int      fLayerID;
+        // The range of commands in the picture this layer represents
+        const int      fStart;
+        const int      fStop;
+        // The CTM applied to this layer in the picture
+        const SkMatrix fCTM;
     };
 
     static const Key& GetKey(const GrCachedLayer& layer) { return layer.fKey; }
     static uint32_t Hash(const Key& key) { 
-        return SkChecksum::Mix((key.getPictureID() << 16) | key.getLayerID());
+        return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(&key), sizeof(Key));

[bsalomon, 2014/07/30 21:23:09]

assert that key is tightly packed?

what if matrix::getType hasn't been called on one CTM but has on the other?

Stephen just encountered this. Maybe we should have an opaque struct that can be
copied out of an SkMatrix that just holds the matrix values (privately) and is
used for keys. Something like:

struct MatrixKey {
private:
  float m[9];
}

void SkMatrix::asKey(MatrixKey* key) const;

[robertphillips, 2014/07/31 13:23:36]

I have added the assert and forced the computation of the matrix type.

The MatrixKey proves problematic b.c. I want to use the ctm stored in the key as
a matrix. It would be possible to reinflate the matrix key but things stop being
simple.

     }
 
     // GrCachedLayer proper
-    GrCachedLayer(uint32_t pictureID, int layerID) 
-        : fKey(pictureID, layerID)
+    GrCachedLayer(uint32_t pictureID, int start, int stop, const SkMatrix& ctm) 
+        : fKey(pictureID, start, stop, ctm)
         , fTexture(NULL)
         , fRect(GrIRect16::MakeEmpty())
         , fPlot(NULL)
         , fLocked(false) {
         SkASSERT(SK_InvalidGenID != pictureID && layerID >= 0);
     }
 
     ~GrCachedLayer() {
         SkSafeUnref(fTexture);
     }
 
-    uint32_t pictureID() const { return fKey.getPictureID(); }
-    int layerID() const { return fKey.getLayerID(); }
+    uint32_t pictureID() const { return fKey.pictureID(); }
+    int start() const { return fKey.start(); }
+    int stop() const { return fKey.stop(); }
+    const SkMatrix& ctm() const { return fKey.ctm(); }
 
     void setTexture(GrTexture* texture, const GrIRect16& rect) {
         SkRefCnt_SafeAssign(fTexture, texture);
         fRect = rect;
     }
     GrTexture* texture() { return fTexture; }
     const GrIRect16& rect() const { return fRect; }
 
     void setPlot(GrPlot* plot) {
         SkASSERT(NULL == fPlot);
@@ skipping 43 matching lines @@
 // classes.
 class GrLayerCache {
 public:
     GrLayerCache(GrContext*);
     ~GrLayerCache();
 
     // As a cache, the GrLayerCache can be ordered to free up all its cached
     // elements by the GrContext
     void freeAll();
 
-    GrCachedLayer* findLayer(const SkPicture* picture, int layerID);
-    GrCachedLayer* findLayerOrCreate(const SkPicture* picture, int layerID);
+    GrCachedLayer* findLayer(const SkPicture* picture, int start, int stop, const SkMatrix& ctm);
+    GrCachedLayer* findLayerOrCreate(const SkPicture* picture, 
+                                     int start, int stop, 
+                                     const SkMatrix& ctm);
     
     // Inform the cache that layer's cached image is now required. Return true
     // if it was found in the ResourceCache and doesn't need to be regenerated.
     // If false is returned the caller should (re)render the layer into the
     // newly acquired texture.
     bool lock(GrCachedLayer* layer, const GrTextureDesc& desc);
 
     // Inform the cache that layer's cached image is not currently required
     void unlock(GrCachedLayer* layer);
 
@@ skipping 33 matching lines @@
 
     // This implements a plot-centric locking mechanism (since the atlas
     // backing texture is always locked). Each layer that is locked (i.e.,
     // needed for the current rendering) in a plot increments the plot lock
     // count for that plot. Similarly, once a rendering is complete all the
     // layers used in it decrement the lock count for the used plots.
     // Plots with a 0 lock count are open for recycling/purging.
     int fPlotLocks[kNumPlotsX * kNumPlotsY];
 
     void initAtlas();
-    GrCachedLayer* createLayer(const SkPicture* picture, int layerID);
+    GrCachedLayer* createLayer(const SkPicture* picture, int start, int stop, const SkMatrix& ctm);
 
     // Remove all the layers (and unlock any resources) associated with 'pictureID'
     void purge(uint32_t pictureID);
 
     static bool PlausiblyAtlasable(int width, int height) {
         return width <= kPlotWidth && height <= kPlotHeight;
     }
 
     // Try to find a purgeable plot and clear it out. Return true if a plot
     // was purged; false otherwise.
     bool purgePlot();
 
     // for testing
     friend class TestingAccess;
     int numLayers() const { return fLayerHash.count(); }
 };
 
 #endif